🥮 mooncakes.io

    moon_rodio

    Native-only MoonBit port of Rust rodio with playback pipeline, source effects, and WAV/MP3/FLAC/Vorbis/MP4A decoding.

    audio
    Download zip
    Author
    Version
    0.3.5
    License
    Apache-2.0
    Repository
    Last updated
    14 days ago
    Downloads
    6K

    Dependencies

    #Milky2018/moon_rodio

    Native CI

    moon_rodio is a native-only MoonBit audio playback library. It provides in-memory playback composition through Mixer, Sink, Player, and Source, plus built-in decoders for common audio formats.

    #Scope

    • Preferred target: native
    • Output and input are built on Milky2018/moon_cpal
    • The main package is Milky2018/moon_rodio
    • The lower-level decoder package is Milky2018/moon_rodio/decoder

    #Installation

    • Add "Milky2018/moon_rodio": "0.3.0" to deps in moon.mod.json
    • Set "preferred-target": "native" in moon.mod.json

    #Packages

    #Milky2018/moon_rodio

    Use this package for the normal playback API:

    • OutputStreamBuilder
    • Mixer
    • Sink
    • Player
    • Decoder and Decoder::builder()
    • source helpers such as gain, speed, delay, fades, filters, spatial helpers, and WAV output helpers

    #Milky2018/moon_rodio/decoder

    Use this package when you want lower-level byte-to-sample decoding helpers directly:

    • decode_wav_bytes
    • decode_mp3_bytes
    • decode_flac_bytes
    • decode_vorbis_bytes
    • decode_mp4a_bytes

    #Supported formats

    • WAV
    • MP3
    • FLAC
    • Ogg Vorbis
    • MP4A / AAC

    Backend notes:

    • WAV: native parser
    • MP3: vendored minimp3
    • FLAC: vendored dr_flac
    • Vorbis: vendored stb_vorbis
    • MP4A / AAC:
      • macOS: AudioToolbox
      • Linux / Windows: FFmpeg

    #MP4A / AAC on Linux and Windows

    MP4A on Linux and Windows depends on FFmpeg development libraries being available to native builds.

    build.js will try to discover them automatically. If auto-detection does not fit your environment, set these variables explicitly before building or testing:

    • MOON_RODIO_FFMPEG_CFLAGS
    • MOON_RODIO_FFMPEG_LIBS
    • MOON_RODIO_ENABLE_FFMPEG=1

    #Quick start

    Create an in-memory playback chain:

    ///|
    test "readme: in-memory playback chain" {
      let (tx, rx) = mixer(1, 44_100)
      let sink = Sink::connect_new(tx)
      let source = SamplesBuffer::new(1, 44_100, [0.0, 0.25, 0.0, -0.25])

      sink.append(source)
      @debug.assert_eq(rx.next(), Some(0.0))
    }

    Decode audio bytes with the high-level decoder API:

    ///|
    test "readme: decoder builder" {
      let decoder = Decoder::builder()
        .with_data(@decoder.mp3_ill2_mono_bytes())
        .with_hint("mp3")
        .with_seekable(true)
        .build()

      @debug.assert_eq(decoder.channels(), 1)
      @debug.assert_eq(decoder.sample_rate(), 48_000)
    }

    Play embedded bytes through a mixer:

    ///|
    test "readme: play bytes through mixer" {
      let (tx, _rx) = mixer(1, 44_100)
      let player = play_bytes(tx, @decoder.flac_pop_bytes())

      player.pause()
      player.play()
    }

    For files on disk, use play_file(...), Reader::from_file(...), or Decoder::try_from_file(...).

    ChannelCount

    source
    type ChannelCount = Int

    Sample

    source
    type Sample = Double

    SampleRate

    source
    type SampleRate = Int

    FixedSource

    source
    pub(open) trait FixedSource {
      fn next(Self) -> Double?
      fn channels(Self) -> Int
      fn sample_rate(Self) -> Int
      fn total_duration(Self) -> 
    Duration    ?
    }

    Compatibility trait mirroring rodio::fixed_source::FixedSource.

    Unlike Source, a FixedSource never changes channel count and sample rate.

    NoiseRng

    source
    pub(open) trait NoiseRng {
      fn next_u64(Self) -> UInt64
    }

    Source

    source
    pub(open) trait Source {
      fn next(Self) -> Double?
      fn channels(Self) -> Int
      fn sample_rate(Self) -> Int
      fn current_span_len(Self) -> Int?
      fn total_duration(Self) -> 
    Duration    ?
      fn try_seek(Self, pos : 
    Duration    ) -> Unit raise SeekError
    }

    WavWriter

    source
    pub(open) trait WavWriter {
      fn write_all(Self, bytes : Bytes) -> Unit raise ToWavError
    }

    impl WavWriter for Buffer

    BitDepthError

    source
    pub suberror BitDepthError {
      OutOfRange(Int)
    } derive(Eq, 
    Debug    )

    BitDepthError::equal

    source

    BitDepthError::not_equal

    source
    fn BitDepthError::not_equal(x : BitDepthError, y : BitDepthError) -> Bool

    BitDepthError::output

    source
    fn BitDepthError::output(self : BitDepthError, logger : &Logger) -> Unit

    BitDepthError::to_repr

    source

    BitDepthError::to_string

    source
    fn BitDepthError::to_string(self : BitDepthError) -> String

    DecoderError

    source
    pub suberror DecoderError {
      Backend(
    DecoderError    )
      UnrecognizedFormat
    } derive(Eq, 
    Debug    )

    DecoderError::equal

    source

    DecoderError::not_equal

    source
    fn DecoderError::not_equal(x : DecoderError, y : DecoderError) -> Bool

    DecoderError::output

    source
    fn DecoderError::output(self : DecoderError, logger : &Logger) -> Unit

    DecoderError::to_repr

    source

    DecoderError::to_string

    source
    fn DecoderError::to_string(self : DecoderError) -> String

    MicrophoneError

    source

    MicrophoneError::equal

    source

    MicrophoneError::not_equal

    source
    fn MicrophoneError::not_equal(x : MicrophoneError, y : MicrophoneError) -> Bool

    MicrophoneError::output

    source
    fn MicrophoneError::output(self : MicrophoneError, logger : &Logger) -> Unit

    MicrophoneError::to_repr

    source

    MicrophoneError::to_string

    source
    fn MicrophoneError::to_string(self : MicrophoneError) -> String

    MicrophoneListError

    source
    pub suberror MicrophoneListError {
      DevicesError(
    DevicesError    )
    } derive(Eq, 
    Debug    )

    MicrophoneListError::equal

    source

    MicrophoneListError::not_equal

    source

    MicrophoneListError::output

    source
    fn MicrophoneListError::output(self : MicrophoneListError, logger : &Logger) -> Unit

    MicrophoneListError::to_repr

    source

    MicrophoneListError::to_string

    source
    fn MicrophoneListError::to_string(self : MicrophoneListError) -> String

    PlayError

    source
    pub suberror PlayError {
      DecoderError(DecoderError)
    } derive(Eq, 
    Debug    )

    impl Show for PlayError

    PlayError::equal

    source
    fn PlayError::equal(PlayError, PlayError) -> Bool

    PlayError::not_equal

    source
    fn PlayError::not_equal(x : PlayError, y : PlayError) -> Bool

    PlayError::output

    source
    fn PlayError::output(self : PlayError, logger : &Logger) -> Unit

    PlayError::to_repr

    source

    PlayError::to_string

    source
    fn PlayError::to_string(self : PlayError) -> String

    SeekError

    source
    pub suberror SeekError {
      NotSupported
    } derive(Eq, 
    Debug    )

    impl Show for SeekError

    SeekError::equal

    source
    fn SeekError::equal(SeekError, SeekError) -> Bool

    SeekError::not_equal

    source
    fn SeekError::not_equal(x : SeekError, y : SeekError) -> Bool

    SeekError::output

    source
    fn SeekError::output(self : SeekError, logger : &Logger) -> Unit

    SeekError::source_intact

    source
    fn SeekError::source_intact(self : SeekError) -> Bool

    SeekError::to_repr

    source

    SeekError::to_string

    source
    fn SeekError::to_string(self : SeekError) -> String

    SpeakersError

    source
    pub suberror SpeakersError {
      NoDevice
      NoConfig
      DefaultOutputConfigError(
    DefaultStreamConfigError    )
      SupportedOutputConfigsError(
    SupportedStreamConfigsError    )
      UnsupportedByDevice
      DeviceSinkError(StreamError)
    } derive(Eq, 
    Debug    )

    SpeakersError::equal

    source

    SpeakersError::not_equal

    source
    fn SpeakersError::not_equal(x : SpeakersError, y : SpeakersError) -> Bool

    SpeakersError::output

    source
    fn SpeakersError::output(self : SpeakersError, logger : &Logger) -> Unit

    SpeakersError::to_repr

    source

    SpeakersError::to_string

    source
    fn SpeakersError::to_string(self : SpeakersError) -> String

    SpeakersListError

    source
    pub suberror SpeakersListError {
      DevicesError(
    DevicesError    )
    } derive(Eq, 
    Debug    )

    SpeakersListError::equal

    source

    SpeakersListError::not_equal

    source
    fn SpeakersListError::not_equal(x : SpeakersListError, y : SpeakersListError) -> Bool

    SpeakersListError::output

    source
    fn SpeakersListError::output(self : SpeakersListError, logger : &Logger) -> Unit

    SpeakersListError::to_repr

    source

    SpeakersListError::to_string

    source
    fn SpeakersListError::to_string(self : SpeakersListError) -> String

    SpeakersPlayError

    source
    pub suberror SpeakersPlayError {
      WrongChannelCount(Int, Int)
      WrongSampleRate(Int, Int)
      BuilderError(SpeakersError)
    } derive(Eq, 
    Debug    )

    SpeakersPlayError::equal

    source

    SpeakersPlayError::not_equal

    source
    fn SpeakersPlayError::not_equal(x : SpeakersPlayError, y : SpeakersPlayError) -> Bool

    SpeakersPlayError::output

    source
    fn SpeakersPlayError::output(self : SpeakersPlayError, logger : &Logger) -> Unit

    SpeakersPlayError::to_repr

    source

    SpeakersPlayError::to_string

    source
    fn SpeakersPlayError::to_string(self : SpeakersPlayError) -> String

    StreamError

    source

    impl Show for StreamError

    StreamError::equal

    source
    fn StreamError::equal(StreamError, StreamError) -> Bool

    StreamError::not_equal

    source
    fn StreamError::not_equal(x : StreamError, y : StreamError) -> Bool

    StreamError::output

    source
    fn StreamError::output(self : StreamError, logger : &Logger) -> Unit

    StreamError::to_repr

    source

    StreamError::to_string

    source
    fn StreamError::to_string(self : StreamError) -> String

    ToWavError

    source
    pub suberror ToWavError {
      OpenFile
      Creating
      Writing
      Finishing
      Flushing
    } derive(Eq, 
    Debug    )

    impl Show for ToWavError

    ToWavError::equal

    source
    fn ToWavError::equal(ToWavError, ToWavError) -> Bool

    ToWavError::not_equal

    source
    fn ToWavError::not_equal(x : ToWavError, y : ToWavError) -> Bool

    ToWavError::output

    source
    fn ToWavError::output(self : ToWavError, logger : &Logger) -> Unit

    ToWavError::to_repr

    source

    ToWavError::to_string

    source
    fn ToWavError::to_string(self : ToWavError) -> String

    Amplify

    source
    pub struct Amplify {
      input : DynSource
      factor : 
    Ref    [Double]
    }

    impl Source for Amplify

    Amplify::channels

    source
    fn Amplify::channels(self : Amplify) -> Int

    Amplify::current_span_len

    source
    fn Amplify::current_span_len(_self : Amplify) -> Int?

    Amplify::inner

    source
    fn Amplify::inner(self : Amplify) -> DynSource

    Amplify::inner_mut

    source
    fn Amplify::inner_mut(self : Amplify) -> DynSource

    Amplify::into_inner

    source
    fn Amplify::into_inner(self : Amplify) -> DynSource

    Amplify::new

    source
    fn[S : Source] Amplify::new(source : S, factor : Double) -> Amplify

    Amplify::next

    source
    fn Amplify::next(self : Amplify) -> Double?

    Amplify::sample_rate

    source
    fn Amplify::sample_rate(self : Amplify) -> Int

    Amplify::set_factor

    source
    fn Amplify::set_factor(self : Amplify, factor : Double) -> Unit

    Amplify::set_log_factor

    source
    fn Amplify::set_log_factor(self : Amplify, factor : Double) -> Unit

    Amplify::total_duration

    source

    Amplify::try_seek

    source
    fn Amplify::try_seek(_self : Amplify, pos : 
    Duration    ) -> Unit raise SeekError

    AutomaticGainControl

    source
    pub struct AutomaticGainControl {
      input : DynSource
      target_level : 
    Ref    [Double]
      absolute_max_gain : 
    Ref    [Double]
      current_gain : 
    Ref    [Double]
      floor : 
    Ref    [Double]
      attack_coeff : 
    Ref    [Double]
      release_coeff : 
    Ref    [Double]
      agc_control : 
    Ref    [Bool]
    }

    AutomaticGainControl::channels

    source
    fn AutomaticGainControl::channels(self : AutomaticGainControl) -> Int

    AutomaticGainControl::current_span_len

    source
    fn AutomaticGainControl::current_span_len(_self : AutomaticGainControl) -> Int?

    AutomaticGainControl::get_absolute_max_gain

    source
    fn AutomaticGainControl::get_absolute_max_gain(self : AutomaticGainControl) -> 
    Ref    [Double]

    AutomaticGainControl::get_agc_control

    source

    AutomaticGainControl::get_attack_coeff

    source

    AutomaticGainControl::get_release_coeff

    source

    AutomaticGainControl::get_target_level

    source

    AutomaticGainControl::inner

    source

    AutomaticGainControl::inner_mut

    source

    AutomaticGainControl::new

    source

    AutomaticGainControl::new_with_params

    source
    fn[S : Source] AutomaticGainControl::new_with_params(source : S, target_level : Double, attack_time : 
    Duration    , release_time : 
    Duration    , absolute_max_gain : Double) -> AutomaticGainControl

    AutomaticGainControl::next

    source
    fn AutomaticGainControl::next(self : AutomaticGainControl) -> Double?

    AutomaticGainControl::sample_rate

    source
    fn AutomaticGainControl::sample_rate(self : AutomaticGainControl) -> Int

    AutomaticGainControl::set_enabled

    source
    fn AutomaticGainControl::set_enabled(self : AutomaticGainControl, enabled : Bool) -> Unit

    AutomaticGainControl::set_floor

    source
    fn AutomaticGainControl::set_floor(self : AutomaticGainControl, floor : Double?) -> Unit

    AutomaticGainControl::total_duration

    source

    AutomaticGainControl::try_seek

    source

    AutomaticGainControlSettings

    source
    pub struct AutomaticGainControlSettings {
      target_level : Double
      attack_time : 
    Duration
      release_time : 
    Duration
      absolute_max_gain : Double
    }

    AutomaticGainControlSettings::default

    source

    AutomaticGainControlSettings::new

    source

    AutomaticGainControlSettings::with_absolute_max_gain

    source
    fn AutomaticGainControlSettings::with_absolute_max_gain(self : AutomaticGainControlSettings, absolute_max_gain : Double) -> AutomaticGainControlSettings

    AutomaticGainControlSettings::with_attack

    source

    AutomaticGainControlSettings::with_release

    source

    AutomaticGainControlSettings::with_target_level

    source
    fn AutomaticGainControlSettings::with_target_level(self : AutomaticGainControlSettings, target_level : Double) -> AutomaticGainControlSettings

    BitDepth

    source
    pub struct BitDepth {
      bits : Int
    } derive(Eq, 
    Debug    )

    impl Show for BitDepth

    BitDepth::equal

    source
    fn BitDepth::equal(BitDepth, BitDepth) -> Bool

    BitDepth::get

    source
    fn BitDepth::get(self : BitDepth) -> Int

    BitDepth::new

    source
    fn BitDepth::new(bits : Int) -> BitDepth raise BitDepthError

    BitDepth::not_equal

    source
    fn BitDepth::not_equal(x : BitDepth, y : BitDepth) -> Bool

    BitDepth::output

    source
    fn BitDepth::output(self : BitDepth, logger : &Logger) -> Unit

    BitDepth::to_repr

    source

    BitDepth::to_string

    source
    fn BitDepth::to_string(self : BitDepth) -> String

    BltFilter

    source

    impl Source for BltFilter

    BltFilter::channels

    source
    fn BltFilter::channels(self : BltFilter) -> Int

    BltFilter::current_span_len

    source
    fn BltFilter::current_span_len(_self : BltFilter) -> Int?

    BltFilter::inner

    source
    fn BltFilter::inner(self : BltFilter) -> DynSource

    BltFilter::inner_mut

    source
    fn BltFilter::inner_mut(self : BltFilter) -> DynSource

    BltFilter::into_inner

    source
    fn BltFilter::into_inner(self : BltFilter) -> DynSource

    BltFilter::next

    source
    fn BltFilter::next(self : BltFilter) -> Double?

    BltFilter::sample_rate

    source
    fn BltFilter::sample_rate(self : BltFilter) -> Int

    BltFilter::to_high_pass

    source
    fn BltFilter::to_high_pass(self : BltFilter, freq : Int) -> Unit

    BltFilter::to_high_pass_with_q

    source
    fn BltFilter::to_high_pass_with_q(self : BltFilter, freq : Int, q : Double) -> Unit

    BltFilter::to_low_pass

    source
    fn BltFilter::to_low_pass(self : BltFilter, freq : Int) -> Unit

    BltFilter::to_low_pass_with_q

    source
    fn BltFilter::to_low_pass_with_q(self : BltFilter, freq : Int, q : Double) -> Unit

    BltFilter::total_duration

    source

    BltFilter::try_seek

    source
    fn BltFilter::try_seek(_self : BltFilter, pos : 
    Duration    ) -> Unit raise SeekError

    BltMode

    source
    pub enum BltMode {
      LowPass
      HighPass
    } derive(Eq, 
    Debug    )

    impl Show for BltMode

    BltMode::equal

    source
    fn BltMode::equal(BltMode, BltMode) -> Bool

    BltMode::not_equal

    source
    fn BltMode::not_equal(x : BltMode, y : BltMode) -> Bool

    BltMode::output

    source
    fn BltMode::output(self : BltMode, logger : &Logger) -> Unit

    BltMode::to_repr

    source

    BltMode::to_string

    source
    fn BltMode::to_string(self : BltMode) -> String

    Blue

    source
    pub struct Blue {
      sample_rate : Int
      white_noise : WhiteUniform
      prev_white : 
    Ref    [Double]
    }

    impl Source for Blue

    Blue::channels

    source
    fn Blue::channels(_self : Blue) -> Int

    Blue::current_span_len

    source
    fn Blue::current_span_len(_self : Blue) -> Int?

    Blue::new

    source
    fn Blue::new(sample_rate : Int) -> Blue

    Blue::new_with_rng

    source
    fn[R : NoiseRng] Blue::new_with_rng(sample_rate : Int, rng : R) -> Blue

    Blue::new_with_seed

    source
    fn Blue::new_with_seed(sample_rate : Int, seed : UInt64) -> Blue

    Blue::next

    source
    fn Blue::next(self : Blue) -> Double?

    Blue::sample_rate

    source
    fn Blue::sample_rate(self : Blue) -> Int

    Blue::total_duration

    source
    fn Blue::total_duration(_self : Blue) -> 
    Duration    ?

    Blue::try_seek

    source
    fn Blue::try_seek(_self : Blue, pos : 
    Duration    ) -> Unit raise SeekError

    Brownian

    source
    pub struct Brownian {
      sample_rate : Int
      white_noise : WhiteGaussian
      accumulator : 
    Ref    [Double]
      leak_factor : 
    Ref    [Double]
      scale : 
    Ref    [Double]
    }

    impl Source for Brownian

    Brownian::channels

    source
    fn Brownian::channels(_self : Brownian) -> Int

    Brownian::current_span_len

    source
    fn Brownian::current_span_len(_self : Brownian) -> Int?

    Brownian::new

    source
    fn Brownian::new(sample_rate : Int) -> Brownian

    Brownian::new_with_rng

    source
    fn[R : NoiseRng] Brownian::new_with_rng(sample_rate : Int, rng : R) -> Brownian

    Brownian::new_with_seed

    source
    fn Brownian::new_with_seed(sample_rate : Int, seed : UInt64) -> Brownian

    Brownian::next

    source
    fn Brownian::next(self : Brownian) -> Double?

    Brownian::sample_rate

    source
    fn Brownian::sample_rate(self : Brownian) -> Int

    Brownian::total_duration

    source

    Brownian::try_seek

    source
    fn Brownian::try_seek(_self : Brownian, _pos : 
    Duration    ) -> Unit raise SeekError

    Buffered

    source
    pub struct Buffered {
      inner : SamplesBuffer
    }

    impl Source for Buffered

    Buffered::channels

    source
    fn Buffered::channels(self : Buffered) -> Int

    Buffered::current_span_len

    source
    fn Buffered::current_span_len(_self : Buffered) -> Int?

    Buffered::inner

    source
    fn Buffered::inner(self : Buffered) -> SamplesBuffer

    Buffered::inner_mut

    source
    fn Buffered::inner_mut(self : Buffered) -> SamplesBuffer

    Buffered::into_inner

    source
    fn Buffered::into_inner(self : Buffered) -> SamplesBuffer

    Buffered::new

    source
    fn[S : Source] Buffered::new(source : S) -> Buffered

    Buffered::next

    source
    fn Buffered::next(self : Buffered) -> Double?

    Buffered::sample_rate

    source
    fn Buffered::sample_rate(self : Buffered) -> Int

    Buffered::total_duration

    source

    Buffered::try_seek

    source
    fn Buffered::try_seek(_self : Buffered, pos : 
    Duration    ) -> Unit raise SeekError

    ChannelCountConverter

    source
    pub struct ChannelCountConverter {
      inner : DynSource
      to : Int
    }

    ChannelCountConverter::channels

    source
    fn ChannelCountConverter::channels(self : ChannelCountConverter) -> Int

    ChannelCountConverter::current_span_len

    source
    fn ChannelCountConverter::current_span_len(_self : ChannelCountConverter) -> Int?

    ChannelCountConverter::inner_mut

    source

    ChannelCountConverter::into_inner

    source

    ChannelCountConverter::new

    source
    fn[S : Source] ChannelCountConverter::new(input : S, from : Int, to : Int) -> ChannelCountConverter

    ChannelCountConverter::next

    source
    fn ChannelCountConverter::next(self : ChannelCountConverter) -> Double?

    ChannelCountConverter::sample_rate

    source
    fn ChannelCountConverter::sample_rate(self : ChannelCountConverter) -> Int

    ChannelCountConverter::total_duration

    source

    ChannelCountConverter::try_seek

    source

    ChannelVolume

    source
    pub struct ChannelVolume {
      input : DynSource
      channel_factors : 
    Ref    [Array[Double]]
      current_channel : 
    Ref    [Int]
      current_sample : 
    Ref    [Double?]
    }

    ChannelVolume::channels

    source
    fn ChannelVolume::channels(self : ChannelVolume) -> Int

    ChannelVolume::current_span_len

    source
    fn ChannelVolume::current_span_len(_self : ChannelVolume) -> Int?

    ChannelVolume::inner

    source

    ChannelVolume::inner_mut

    source
    fn ChannelVolume::inner_mut(self : ChannelVolume) -> DynSource

    ChannelVolume::into_inner

    source
    fn ChannelVolume::into_inner(self : ChannelVolume) -> DynSource

    ChannelVolume::new

    source
    fn[S : Source] ChannelVolume::new(source : S, channel_factors : Array[Double]) -> ChannelVolume

    ChannelVolume::next

    source
    fn ChannelVolume::next(self : ChannelVolume) -> Double?

    ChannelVolume::sample_rate

    source
    fn ChannelVolume::sample_rate(self : ChannelVolume) -> Int

    ChannelVolume::set_volume

    source
    fn ChannelVolume::set_volume(self : ChannelVolume, channel : Int, volume : Double) -> Unit

    ChannelVolume::total_duration

    source

    ChannelVolume::try_seek

    source

    Chirp

    source
    pub struct Chirp {
      sample_rate : Int
      start_frequency : Double
      end_frequency : Double
      total_samples : Int
      elapsed_samples : 
    Ref    [Int]
      phase : 
    Ref    [Double]
    }

    impl Source for Chirp

    Chirp::channels

    source
    fn Chirp::channels(_self : Chirp) -> Int

    Chirp::current_span_len

    source
    fn Chirp::current_span_len(self : Chirp) -> Int?

    Chirp::next

    source
    fn Chirp::next(self : Chirp) -> Double?

    Chirp::sample_rate

    source
    fn Chirp::sample_rate(self : Chirp) -> Int

    Chirp::total_duration

    source

    Chirp::try_seek

    source
    fn Chirp::try_seek(self : Chirp, pos : 
    Duration    ) -> Unit raise SeekError

    ControlledQueueSource

    source
    pub struct ControlledQueueSource {
      inner : SourcesQueueOutput
      controls : SinkControls
    }

    ControlledQueueSource::channels

    source
    fn ControlledQueueSource::channels(self : ControlledQueueSource) -> Int

    ControlledQueueSource::current_span_len

    source
    fn ControlledQueueSource::current_span_len(self : ControlledQueueSource) -> Int?

    ControlledQueueSource::next

    source
    fn ControlledQueueSource::next(self : ControlledQueueSource) -> Double?

    ControlledQueueSource::sample_rate

    source
    fn ControlledQueueSource::sample_rate(self : ControlledQueueSource) -> Int

    ControlledQueueSource::total_duration

    source

    ControlledQueueSource::try_seek

    source

    Crossfade

    source
    pub struct Crossfade {
      inner : DynSource
    }

    impl Source for Crossfade

    Crossfade::channels

    source
    fn Crossfade::channels(self : Crossfade) -> Int

    Crossfade::current_span_len

    source
    fn Crossfade::current_span_len(_self : Crossfade) -> Int?

    Crossfade::inner

    source
    fn Crossfade::inner(self : Crossfade) -> DynSource

    Crossfade::inner_mut

    source
    fn Crossfade::inner_mut(self : Crossfade) -> DynSource

    Crossfade::into_inner

    source
    fn Crossfade::into_inner(self : Crossfade) -> DynSource

    Crossfade::new

    source
    fn[A : Source, B : Source] Crossfade::new(left : A, right : B, duration : 
    Duration    ) -> Crossfade

    Crossfade::next

    source
    fn Crossfade::next(self : Crossfade) -> Double?

    Crossfade::sample_rate

    source
    fn Crossfade::sample_rate(self : Crossfade) -> Int

    Crossfade::total_duration

    source

    Crossfade::try_seek

    source
    fn Crossfade::try_seek(_self : Crossfade, pos : 
    Duration    ) -> Unit raise SeekError

    Decoder

    source
    pub struct Decoder {
      inner : 
    DecodedSamples
      seekable : Bool
      allow_backward_seek : Bool
      kind : DecoderKind
    }

    impl Source for Decoder

    Decoder::builder

    source
    fn Decoder::builder() -> DecoderBuilder

    Decoder::channels

    source
    fn Decoder::channels(self : Decoder) -> Int

    Decoder::current_span_len

    source
    fn Decoder::current_span_len(self : Decoder) -> Int?

    Decoder::new

    source
    fn Decoder::new(bytes : Bytes) -> Decoder raise DecoderError

    Decoder::new_aac

    source
    fn Decoder::new_aac(bytes : Bytes) -> Decoder raise DecoderError

    Decoder::new_flac

    source
    fn Decoder::new_flac(bytes : Bytes) -> Decoder raise DecoderError

    Decoder::new_looped

    source
    fn Decoder::new_looped(bytes : Bytes) -> LoopedDecoder raise DecoderError

    Decoder::new_mp3

    source
    fn Decoder::new_mp3(bytes : Bytes) -> Decoder raise DecoderError

    Decoder::new_mp4

    source
    fn Decoder::new_mp4(bytes : Bytes) -> Decoder raise DecoderError

    Decoder::new_mp4a

    source
    fn Decoder::new_mp4a(bytes : Bytes) -> Decoder raise DecoderError

    Decoder::new_vorbis

    source
    fn Decoder::new_vorbis(bytes : Bytes) -> Decoder raise DecoderError

    Decoder::new_wav

    source
    fn Decoder::new_wav(bytes : Bytes) -> Decoder raise DecoderError

    Decoder::next

    source
    fn Decoder::next(self : Decoder) -> Double?

    Decoder::sample_rate

    source
    fn Decoder::sample_rate(self : Decoder) -> Int

    Decoder::total_duration

    source

    Decoder::try_from_file

    source
    fn Decoder::try_from_file(path : StringView) -> Decoder raise DecoderError

    Decoder::try_from_file_looped

    source
    fn Decoder::try_from_file_looped(path : StringView) -> LoopedDecoder raise DecoderError

    Decoder::try_seek

    source
    fn Decoder::try_seek(self : Decoder, pos : 
    Duration    ) -> Unit raise SeekError

    DecoderBuilder

    source
    pub struct DecoderBuilder {
      data : Bytes?
      settings : Settings
    }

    DecoderBuilder::build

    source

    DecoderBuilder::build_looped

    source
    fn DecoderBuilder::build_looped(self : DecoderBuilder) -> LoopedDecoder raise DecoderError

    DecoderBuilder::new

    source

    DecoderBuilder::with_byte_len

    source
    fn DecoderBuilder::with_byte_len(self : DecoderBuilder, byte_len : Int) -> DecoderBuilder

    DecoderBuilder::with_coarse_seek

    source
    fn DecoderBuilder::with_coarse_seek(self : DecoderBuilder, coarse_seek : Bool) -> DecoderBuilder

    DecoderBuilder::with_data

    source
    fn DecoderBuilder::with_data(self : DecoderBuilder, data : Bytes) -> DecoderBuilder

    DecoderBuilder::with_gapless

    source
    fn DecoderBuilder::with_gapless(self : DecoderBuilder, gapless : Bool) -> DecoderBuilder

    DecoderBuilder::with_hint

    source
    fn DecoderBuilder::with_hint(self : DecoderBuilder, hint : StringView) -> DecoderBuilder

    DecoderBuilder::with_mime_type

    source
    fn DecoderBuilder::with_mime_type(self : DecoderBuilder, mime_type : StringView) -> DecoderBuilder

    DecoderBuilder::with_seekable

    source
    fn DecoderBuilder::with_seekable(self : DecoderBuilder, is_seekable : Bool) -> DecoderBuilder

    DecoderKind

    source
    type DecoderKind derive(Eq, 
    Debug    )

    DecoderKind::equal

    source
    fn DecoderKind::equal(DecoderKind, DecoderKind) -> Bool

    DecoderKind::not_equal

    source
    fn DecoderKind::not_equal(x : DecoderKind, y : DecoderKind) -> Bool

    DecoderKind::to_repr

    source

    Delay

    source
    pub struct Delay {
      inner : DynSource
    }

    impl Source for Delay

    Delay::channels

    source
    fn Delay::channels(self : Delay) -> Int

    Delay::current_span_len

    source
    fn Delay::current_span_len(_self : Delay) -> Int?

    Delay::inner

    source
    fn Delay::inner(self : Delay) -> DynSource

    Delay::inner_mut

    source
    fn Delay::inner_mut(self : Delay) -> DynSource

    Delay::into_inner

    source
    fn Delay::into_inner(self : Delay) -> DynSource

    Delay::new

    source
    fn[S : Source] Delay::new(source : S, duration : 
    Duration    ) -> Delay

    Delay::next

    source
    fn Delay::next(self : Delay) -> Double?

    Delay::sample_rate

    source
    fn Delay::sample_rate(self : Delay) -> Int

    Delay::total_duration

    source

    Delay::try_seek

    source
    fn Delay::try_seek(_self : Delay, pos : 
    Duration    ) -> Unit raise SeekError

    DeviceSinkBuilder

    source
    pub struct DeviceSinkBuilder {
      inner : OutputStreamBuilder
    }

    DeviceSinkBuilder::config

    source

    DeviceSinkBuilder::default

    source

    DeviceSinkBuilder::from_default_device

    source
    fn DeviceSinkBuilder::from_default_device() -> DeviceSinkBuilder raise StreamError

    DeviceSinkBuilder::from_device

    source

    DeviceSinkBuilder::open_default_sink

    source
    fn DeviceSinkBuilder::open_default_sink() -> MixerDeviceSink raise StreamError

    DeviceSinkBuilder::open_sink_or_fallback

    source
    fn DeviceSinkBuilder::open_sink_or_fallback(self : DeviceSinkBuilder) -> MixerDeviceSink raise StreamError

    DeviceSinkBuilder::open_stream

    source

    DeviceSinkBuilder::with_buffer_size

    source

    DeviceSinkBuilder::with_channels

    source
    fn DeviceSinkBuilder::with_channels(self : DeviceSinkBuilder, channel_count : Int) -> DeviceSinkBuilder

    DeviceSinkBuilder::with_config

    source

    DeviceSinkBuilder::with_device

    source

    DeviceSinkBuilder::with_error_callback

    source

    DeviceSinkBuilder::with_sample_format

    source

    DeviceSinkBuilder::with_sample_rate

    source
    fn DeviceSinkBuilder::with_sample_rate(self : DeviceSinkBuilder, sample_rate : Int) -> DeviceSinkBuilder

    DeviceSinkBuilder::with_supported_config

    source

    Distortion

    source
    pub struct Distortion {
      input : DynSource
      gain : 
    Ref    [Double]
      threshold : 
    Ref    [Double]
    }

    Distortion::channels

    source
    fn Distortion::channels(self : Distortion) -> Int

    Distortion::current_span_len

    source
    fn Distortion::current_span_len(_self : Distortion) -> Int?

    Distortion::inner

    source
    fn Distortion::inner(self : Distortion) -> DynSource

    Distortion::inner_mut

    source
    fn Distortion::inner_mut(self : Distortion) -> DynSource

    Distortion::into_inner

    source
    fn Distortion::into_inner(self : Distortion) -> DynSource

    Distortion::new

    source
    fn[S : Source] Distortion::new(source : S, gain : Double, threshold : Double) -> Distortion

    Distortion::new_with_threshold

    source
    fn[S : Source] Distortion::new_with_threshold(source : S, threshold : Double) -> Distortion

    Distortion::next

    source
    fn Distortion::next(self : Distortion) -> Double?

    Distortion::sample_rate

    source
    fn Distortion::sample_rate(self : Distortion) -> Int

    Distortion::set_gain

    source
    fn Distortion::set_gain(self : Distortion, gain : Double) -> Unit

    Distortion::set_threshold

    source
    fn Distortion::set_threshold(self : Distortion, threshold : Double) -> Unit

    Distortion::total_duration

    source

    Distortion::try_seek

    source

    Distortion::with_gain

    source
    fn[S : Source] Distortion::with_gain(source : S, gain : Double, threshold : Double) -> Distortion

    Dither

    source
    pub struct Dither {
      input : DynSource
      noise : 
    Ref    [DitherAlgorithm]
      current_channel : 
    Ref    [Int]
      lsb_amplitude : 
    Ref    [Double]
      rng_state : 
    Ref    [UInt64]
      highpass_prev : 
    Ref    [Array[Double]]
    }

    impl Source for Dither

    Dither::algorithm

    source
    fn Dither::algorithm(self : Dither) -> DitherAlgorithm

    Dither::channels

    source
    fn Dither::channels(self : Dither) -> Int

    Dither::current_span_len

    source
    fn Dither::current_span_len(self : Dither) -> Int?

    Dither::next

    source
    fn Dither::next(self : Dither) -> Double?

    Dither::sample_rate

    source
    fn Dither::sample_rate(self : Dither) -> Int

    Dither::set_algorithm

    source
    fn Dither::set_algorithm(self : Dither, algorithm : DitherAlgorithm) -> Unit

    Dither::total_duration

    source

    Dither::try_seek

    source
    fn Dither::try_seek(self : Dither, pos : 
    Duration    ) -> Unit raise SeekError

    DitherAlgorithm

    source
    pub enum DitherAlgorithm {
      GPDF
      HighPass
      RPDF
      TPDF
    } derive(Eq, 
    Debug    )

    DitherAlgorithm::equal

    source

    DitherAlgorithm::gpdf

    source

    DitherAlgorithm::high_pass

    source
    fn DitherAlgorithm::high_pass() -> DitherAlgorithm

    DitherAlgorithm::not_equal

    source
    fn DitherAlgorithm::not_equal(x : DitherAlgorithm, y : DitherAlgorithm) -> Bool

    DitherAlgorithm::output

    source
    fn DitherAlgorithm::output(self : DitherAlgorithm, logger : &Logger) -> Unit

    DitherAlgorithm::rpdf

    source

    DitherAlgorithm::to_repr

    source

    DitherAlgorithm::to_string

    source
    fn DitherAlgorithm::to_string(self : DitherAlgorithm) -> String

    DitherAlgorithm::tpdf

    source

    Done

    source
    pub struct Done {
      input : DynSource
      signal : 
    Ref    [Int]
      signal_sent : 
    Ref    [Bool]
    }

    impl Source for Done

    Done::channels

    source
    fn Done::channels(self : Done) -> Int

    Done::current_span_len

    source
    fn Done::current_span_len(_self : Done) -> Int?

    Done::inner

    source
    fn Done::inner(self : Done) -> DynSource

    Done::inner_mut

    source
    fn Done::inner_mut(self : Done) -> DynSource

    Done::into_inner

    source
    fn Done::into_inner(self : Done) -> DynSource

    Done::new

    source
    fn[S : Source] Done::new(source : S, signal : 
    Ref    [Int]) -> Done

    Done::next

    source
    fn Done::next(self : Done) -> Double?

    Done::sample_rate

    source
    fn Done::sample_rate(self : Done) -> Int

    Done::total_duration

    source
    fn Done::total_duration(_self : Done) -> 
    Duration    ?

    Done::try_seek

    source
    fn Done::try_seek(_self : Done, pos : 
    Duration    ) -> Unit raise SeekError

    DynSource

    source
    pub struct DynSource {
      next_sample : () -> Double?
      channels_fn : () -> Int
      sample_rate_fn : () -> Int
      current_span_len_fn : () -> Int?
      total_duration_fn : () -> 
    Duration    ?
      try_seek_fn : (
    Duration    ) -> Result[Unit, SeekError]
    }

    impl Source for DynSource

    DynSource::channels

    source
    fn DynSource::channels(self : DynSource) -> Int

    DynSource::current_span_len

    source
    fn DynSource::current_span_len(self : DynSource) -> Int?

    DynSource::new

    source
    fn DynSource::new(next_sample : () -> Double?, channels : Int, sample_rate : Int, current_span_len? : () -> Int?, total_duration? : () -> 
    Duration    ?, try_seek? : (
    Duration    ) -> Result[Unit, SeekError]) -> DynSource

    DynSource::new_dynamic

    source
    fn DynSource::new_dynamic(next_sample : () -> Double?, channels : () -> Int, sample_rate : () -> Int, current_span_len? : () -> Int?, total_duration? : () -> 
    Duration    ?, try_seek? : (
    Duration    ) -> Result[Unit, SeekError]) -> DynSource

    DynSource::next

    source
    fn DynSource::next(self : DynSource) -> Double?

    DynSource::sample_rate

    source
    fn DynSource::sample_rate(self : DynSource) -> Int

    DynSource::total_duration

    source

    DynSource::try_seek

    source

    Empty

    source
    pub struct Empty {
      inner : DynSource
    }

    impl Source for Empty

    Empty::channels

    source
    fn Empty::channels(self : Empty) -> Int

    Empty::current_span_len

    source
    fn Empty::current_span_len(_self : Empty) -> Int?

    Empty::inner

    source
    fn Empty::inner(self : Empty) -> DynSource

    Empty::inner_mut

    source
    fn Empty::inner_mut(self : Empty) -> DynSource

    Empty::into_inner

    source
    fn Empty::into_inner(self : Empty) -> DynSource

    Empty::new

    source
    fn Empty::new(channels : Int, sample_rate : Int) -> Empty

    Empty::next

    source
    fn Empty::next(self : Empty) -> Double?

    Empty::sample_rate

    source
    fn Empty::sample_rate(self : Empty) -> Int

    Empty::total_duration

    source

    Empty::try_seek

    source
    fn Empty::try_seek(_self : Empty, pos : 
    Duration    ) -> Unit raise SeekError

    EmptyCallback

    source
    pub struct EmptyCallback {
      callback : () -> Unit
    }

    EmptyCallback::channels

    source
    fn EmptyCallback::channels(_self : EmptyCallback) -> Int

    EmptyCallback::current_span_len

    source
    fn EmptyCallback::current_span_len(_self : EmptyCallback) -> Int?

    EmptyCallback::new

    source
    fn EmptyCallback::new(callback : () -> Unit) -> EmptyCallback

    EmptyCallback::next

    source
    fn EmptyCallback::next(self : EmptyCallback) -> Double?

    EmptyCallback::sample_rate

    source
    fn EmptyCallback::sample_rate(_self : EmptyCallback) -> Int

    EmptyCallback::total_duration

    source

    EmptyCallback::try_seek

    source

    FadeIn

    source
    pub struct FadeIn {
      inner : DynSource
    }

    impl Source for FadeIn

    FadeIn::channels

    source
    fn FadeIn::channels(self : FadeIn) -> Int

    FadeIn::current_span_len

    source
    fn FadeIn::current_span_len(_self : FadeIn) -> Int?

    FadeIn::inner

    source
    fn FadeIn::inner(self : FadeIn) -> DynSource

    FadeIn::inner_mut

    source
    fn FadeIn::inner_mut(self : FadeIn) -> DynSource

    FadeIn::into_inner

    source
    fn FadeIn::into_inner(self : FadeIn) -> DynSource

    FadeIn::new

    source
    fn[S : Source] FadeIn::new(source : S, duration : 
    Duration    ) -> FadeIn

    FadeIn::next

    source
    fn FadeIn::next(self : FadeIn) -> Double?

    FadeIn::sample_rate

    source
    fn FadeIn::sample_rate(self : FadeIn) -> Int

    FadeIn::total_duration

    source

    FadeIn::try_seek

    source
    fn FadeIn::try_seek(_self : FadeIn, pos : 
    Duration    ) -> Unit raise SeekError

    FadeOut

    source
    pub struct FadeOut {
      inner : DynSource
    }

    impl Source for FadeOut

    FadeOut::channels

    source
    fn FadeOut::channels(self : FadeOut) -> Int

    FadeOut::current_span_len

    source
    fn FadeOut::current_span_len(_self : FadeOut) -> Int?

    FadeOut::inner

    source
    fn FadeOut::inner(self : FadeOut) -> DynSource

    FadeOut::inner_mut

    source
    fn FadeOut::inner_mut(self : FadeOut) -> DynSource

    FadeOut::into_inner

    source
    fn FadeOut::into_inner(self : FadeOut) -> DynSource

    FadeOut::new

    source
    fn[S : Source] FadeOut::new(source : S, duration : 
    Duration    ) -> FadeOut

    FadeOut::next

    source
    fn FadeOut::next(self : FadeOut) -> Double?

    FadeOut::sample_rate

    source
    fn FadeOut::sample_rate(self : FadeOut) -> Int

    FadeOut::total_duration

    source

    FadeOut::try_seek

    source
    fn FadeOut::try_seek(_self : FadeOut, pos : 
    Duration    ) -> Unit raise SeekError

    FixedSamplesBuffer

    source
    pub struct FixedSamplesBuffer {
      channels : Int
      sample_rate : Int
      samples : Array[Double]
      cursor : 
    Ref    [Int]
      duration : 
    Duration    ?
    }

    FixedSamplesBuffer::channels

    source
    fn FixedSamplesBuffer::channels(self : FixedSamplesBuffer) -> Int

    FixedSamplesBuffer::new

    source
    fn FixedSamplesBuffer::new(channels : Int, sample_rate : Int, samples : Array[Double]) -> FixedSamplesBuffer

    FixedSamplesBuffer::next

    source
    fn FixedSamplesBuffer::next(self : FixedSamplesBuffer) -> Double?

    FixedSamplesBuffer::sample_rate

    source
    fn FixedSamplesBuffer::sample_rate(self : FixedSamplesBuffer) -> Int

    FixedSamplesBuffer::total_duration

    source

    FixedSourceAdapter

    source
    pub struct FixedSourceAdapter {
      inner : DynSource
    }

    FixedSourceAdapter::channels

    source
    fn FixedSourceAdapter::channels(self : FixedSourceAdapter) -> Int

    FixedSourceAdapter::current_span_len

    source
    fn FixedSourceAdapter::current_span_len(_self : FixedSourceAdapter) -> Int?

    FixedSourceAdapter::inner

    source

    FixedSourceAdapter::new

    source

    FixedSourceAdapter::next

    source
    fn FixedSourceAdapter::next(self : FixedSourceAdapter) -> Double?

    FixedSourceAdapter::sample_rate

    source
    fn FixedSourceAdapter::sample_rate(self : FixedSourceAdapter) -> Int

    FixedSourceAdapter::total_duration

    source

    FixedSourceAdapter::try_seek

    source

    FromFactoryIter

    source
    pub struct FromFactoryIter[S] {
      factory : () -> S?
      current : 
    Ref    [DynSource?]
      channels : 
    Ref    [Int]
      sample_rate : 
    Ref    [Int]
    }

    FromFactoryIter::channels

    source
    fn[S] FromFactoryIter::channels(self : FromFactoryIter[S]) -> Int

    FromFactoryIter::current_span_len

    source
    fn[S : Source] FromFactoryIter::current_span_len(self : FromFactoryIter[S]) -> Int?

    FromFactoryIter::next

    source
    fn[S : Source] FromFactoryIter::next(self : FromFactoryIter[S]) -> Double?

    FromFactoryIter::sample_rate

    source
    fn[S] FromFactoryIter::sample_rate(self : FromFactoryIter[S]) -> Int

    FromFactoryIter::total_duration

    source

    FromFactoryIter::try_seek

    source

    FromIter

    source

    impl Source for FromIter

    FromIter::channels

    source
    fn FromIter::channels(self : FromIter) -> Int

    FromIter::current_span_len

    source
    fn FromIter::current_span_len(_self : FromIter) -> Int?

    FromIter::next

    source
    fn FromIter::next(self : FromIter) -> Double?

    FromIter::sample_rate

    source
    fn FromIter::sample_rate(self : FromIter) -> Int

    FromIter::total_duration

    source

    FromIter::try_seek

    source
    fn FromIter::try_seek(self : FromIter, pos : 
    Duration    ) -> Unit raise SeekError

    Function

    source
    pub enum Function {
      Sine
      Triangle
      Square
      Sawtooth
    } derive(Eq, 
    Debug    )

    impl Show for Function

    Function::equal

    source
    fn Function::equal(Function, Function) -> Bool

    Function::not_equal

    source
    fn Function::not_equal(x : Function, y : Function) -> Bool

    Function::output

    source
    fn Function::output(self : Function, logger : &Logger) -> Unit

    Function::sawtooth

    source
    fn Function::sawtooth() -> Function

    Function::sine

    source
    fn Function::sine() -> Function

    Function::square

    source
    fn Function::square() -> Function

    Function::to_repr

    source

    Function::to_string

    source
    fn Function::to_string(self : Function) -> String

    Function::triangle

    source
    fn Function::triangle() -> Function

    GeneratorFunction

    source
    pub struct GeneratorFunction {
      generator : (Double) -> Double
    }

    GeneratorFunction::new

    source
    fn GeneratorFunction::new(generator : (Double) -> Double) -> GeneratorFunction

    Input

    source
    pub struct Input {
      inner : 
    Device
    }

    Input::into_inner

    source

    Input::name

    source
    fn Input::name(self : Input) -> String

    InputConfig

    source
    pub struct InputConfig {
      channel_count : Int
      sample_rate : Int
      buffer_size : 
    BufferSize
      sample_format : 
    SampleFormat
    } derive(Eq, 
    Debug    )

    impl Show for InputConfig

    InputConfig::default

    source
    fn InputConfig::default() -> InputConfig

    InputConfig::equal

    source
    fn InputConfig::equal(InputConfig, InputConfig) -> Bool

    InputConfig::from_supported

    source

    InputConfig::new

    source
    fn InputConfig::new(channel_count : Int, sample_rate : Int, buffer_size : 
    BufferSize    , sample_format : 
    SampleFormat    ) -> InputConfig

    InputConfig::not_equal

    source
    fn InputConfig::not_equal(x : InputConfig, y : InputConfig) -> Bool

    InputConfig::output

    source
    fn InputConfig::output(self : InputConfig, logger : &Logger) -> Unit

    InputConfig::stream_config

    source

    InputConfig::supported_given

    source

    InputConfig::to_repr

    source

    InputConfig::to_string

    source
    fn InputConfig::to_string(self : InputConfig) -> String

    InputConfig::with_buffer_size

    source

    InputConfig::with_channel_count

    source
    fn InputConfig::with_channel_count(self : InputConfig, channel_count : Int) -> InputConfig

    InputConfig::with_sample_format

    source

    InputConfig::with_sample_rate

    source
    fn InputConfig::with_sample_rate(self : InputConfig, sample_rate : Int) -> InputConfig

    LcgNoiseRng

    source
    pub struct LcgNoiseRng {
      state : 
    Ref    [UInt64]
    }

    LcgNoiseRng::new

    source
    fn LcgNoiseRng::new(seed : UInt64) -> LcgNoiseRng

    LcgNoiseRng::next_u64

    source
    fn LcgNoiseRng::next_u64(self : LcgNoiseRng) -> UInt64

    Limit

    source
    pub struct Limit {
      input : DynSource
      settings : LimitSettings
      attack_coeff : Double
      release_coeff : Double
      integrators : 
    Ref    [Array[Double]]
      peaks : 
    Ref    [Array[Double]]
      position : 
    Ref    [Int]
    }

    impl Source for Limit

    Limit::channels

    source
    fn Limit::channels(self : Limit) -> Int

    Limit::current_span_len

    source
    fn Limit::current_span_len(_self : Limit) -> Int?

    Limit::inner

    source
    fn Limit::inner(self : Limit) -> DynSource

    Limit::inner_mut

    source
    fn Limit::inner_mut(self : Limit) -> DynSource

    Limit::into_inner

    source
    fn Limit::into_inner(self : Limit) -> DynSource

    Limit::new

    source
    fn[S : Source] Limit::new(source : S, settings : LimitSettings) -> Limit

    Limit::next

    source
    fn Limit::next(self : Limit) -> Double?

    Limit::sample_rate

    source
    fn Limit::sample_rate(self : Limit) -> Int

    Limit::total_duration

    source

    Limit::try_seek

    source
    fn Limit::try_seek(_self : Limit, pos : 
    Duration    ) -> Unit raise SeekError

    LimitMono

    source
    pub struct LimitMono {
      inner : Limit
    }

    impl Source for LimitMono

    LimitMono::channels

    source
    fn LimitMono::channels(self : LimitMono) -> Int

    LimitMono::current_span_len

    source
    fn LimitMono::current_span_len(_self : LimitMono) -> Int?

    LimitMono::inner

    source
    fn LimitMono::inner(self : LimitMono) -> Limit

    LimitMono::inner_mut

    source
    fn LimitMono::inner_mut(self : LimitMono) -> Limit

    LimitMono::into_inner

    source
    fn LimitMono::into_inner(self : LimitMono) -> Limit

    LimitMono::new

    source
    fn[S : Source] LimitMono::new(source : S, settings : LimitSettings) -> LimitMono

    LimitMono::next

    source
    fn LimitMono::next(self : LimitMono) -> Double?

    LimitMono::sample_rate

    source
    fn LimitMono::sample_rate(self : LimitMono) -> Int

    LimitMono::total_duration

    source

    LimitMono::try_seek

    source
    fn LimitMono::try_seek(_self : LimitMono, pos : 
    Duration    ) -> Unit raise SeekError

    LimitMulti

    source
    pub struct LimitMulti {
      inner : Limit
    }

    LimitMulti::channels

    source
    fn LimitMulti::channels(self : LimitMulti) -> Int

    LimitMulti::current_span_len

    source
    fn LimitMulti::current_span_len(_self : LimitMulti) -> Int?

    LimitMulti::inner

    source
    fn LimitMulti::inner(self : LimitMulti) -> Limit

    LimitMulti::inner_mut

    source
    fn LimitMulti::inner_mut(self : LimitMulti) -> Limit

    LimitMulti::into_inner

    source
    fn LimitMulti::into_inner(self : LimitMulti) -> Limit

    LimitMulti::new

    source
    fn[S : Source] LimitMulti::new(source : S, settings : LimitSettings) -> LimitMulti

    LimitMulti::next

    source
    fn LimitMulti::next(self : LimitMulti) -> Double?

    LimitMulti::sample_rate

    source
    fn LimitMulti::sample_rate(self : LimitMulti) -> Int

    LimitMulti::total_duration

    source

    LimitMulti::try_seek

    source

    LimitSettings

    source
    pub struct LimitSettings {
      min_value : Double
      max_value : Double
      threshold : Double
      knee_width : Double
      attack : 
    Duration
      release : 
    Duration
    } derive(Eq, 
    Debug    )

    LimitSettings::broadcast

    source
    fn LimitSettings::broadcast() -> LimitSettings

    LimitSettings::default

    source
    fn LimitSettings::default() -> LimitSettings

    LimitSettings::dynamic_content

    source
    fn LimitSettings::dynamic_content() -> LimitSettings

    LimitSettings::equal

    source

    LimitSettings::gaming

    source

    LimitSettings::live_performance

    source
    fn LimitSettings::live_performance() -> LimitSettings

    LimitSettings::mastering

    source
    fn LimitSettings::mastering() -> LimitSettings

    LimitSettings::new

    source

    LimitSettings::not_equal

    source
    fn LimitSettings::not_equal(x : LimitSettings, y : LimitSettings) -> Bool

    LimitSettings::output

    source
    fn LimitSettings::output(self : LimitSettings, logger : &Logger) -> Unit

    LimitSettings::to_repr

    source

    LimitSettings::to_string

    source
    fn LimitSettings::to_string(self : LimitSettings) -> String

    LimitSettings::with_attack

    source

    LimitSettings::with_knee_width

    source
    fn LimitSettings::with_knee_width(self : LimitSettings, knee_width : Double) -> LimitSettings

    LimitSettings::with_max

    source
    fn LimitSettings::with_max(self : LimitSettings, max_value : Double) -> LimitSettings

    LimitSettings::with_min

    source
    fn LimitSettings::with_min(self : LimitSettings, min_value : Double) -> LimitSettings

    LimitSettings::with_release

    source

    LimitSettings::with_threshold

    source
    fn LimitSettings::with_threshold(self : LimitSettings, threshold : Double) -> LimitSettings

    LimitStereo

    source
    pub struct LimitStereo {
      inner : Limit
    }

    LimitStereo::channels

    source
    fn LimitStereo::channels(self : LimitStereo) -> Int

    LimitStereo::current_span_len

    source
    fn LimitStereo::current_span_len(_self : LimitStereo) -> Int?

    LimitStereo::inner

    source
    fn LimitStereo::inner(self : LimitStereo) -> Limit

    LimitStereo::inner_mut

    source
    fn LimitStereo::inner_mut(self : LimitStereo) -> Limit

    LimitStereo::into_inner

    source
    fn LimitStereo::into_inner(self : LimitStereo) -> Limit

    LimitStereo::new

    source
    fn[S : Source] LimitStereo::new(source : S, settings : LimitSettings) -> LimitStereo

    LimitStereo::next

    source
    fn LimitStereo::next(self : LimitStereo) -> Double?

    LimitStereo::sample_rate

    source
    fn LimitStereo::sample_rate(self : LimitStereo) -> Int

    LimitStereo::total_duration

    source

    LimitStereo::try_seek

    source

    LinearGainRamp

    source
    pub struct LinearGainRamp {
      inner : DynSource
    }

    LinearGainRamp::channels

    source
    fn LinearGainRamp::channels(self : LinearGainRamp) -> Int

    LinearGainRamp::current_span_len

    source
    fn LinearGainRamp::current_span_len(_self : LinearGainRamp) -> Int?

    LinearGainRamp::inner

    source

    LinearGainRamp::inner_mut

    source
    fn LinearGainRamp::inner_mut(self : LinearGainRamp) -> DynSource

    LinearGainRamp::into_inner

    source
    fn LinearGainRamp::into_inner(self : LinearGainRamp) -> DynSource

    LinearGainRamp::new

    source
    fn[S : Source] LinearGainRamp::new(source : S, start_gain : Double, end_gain : Double, duration : 
    Duration    ) -> LinearGainRamp

    LinearGainRamp::new_with_clamp

    source
    fn[S : Source] LinearGainRamp::new_with_clamp(source : S, start_gain : Double, end_gain : Double, duration : 
    Duration    , clamp_end : Bool) -> LinearGainRamp

    LinearGainRamp::next

    source
    fn LinearGainRamp::next(self : LinearGainRamp) -> Double?

    LinearGainRamp::sample_rate

    source
    fn LinearGainRamp::sample_rate(self : LinearGainRamp) -> Int

    LinearGainRamp::total_duration

    source

    LinearGainRamp::try_seek

    source

    LoopedDecoder

    source
    pub struct LoopedDecoder {
      channels : Int
      sample_rate : Int
      samples : Array[Double]
      cursor : 
    Ref    [Int]
      seekable : Bool
    }

    LoopedDecoder::channels

    source
    fn LoopedDecoder::channels(self : LoopedDecoder) -> Int

    LoopedDecoder::current_span_len

    source
    fn LoopedDecoder::current_span_len(self : LoopedDecoder) -> Int?

    LoopedDecoder::next

    source
    fn LoopedDecoder::next(self : LoopedDecoder) -> Double?

    LoopedDecoder::sample_rate

    source
    fn LoopedDecoder::sample_rate(self : LoopedDecoder) -> Int

    LoopedDecoder::total_duration

    source

    LoopedDecoder::try_seek

    source

    Microphone

    source
    pub struct Microphone {
      _stream_handle : 
    Stream
      queued_samples : 
    Ref    [Array[Double]]
      read_pos : 
    Ref    [Int]
      max_buffered_samples : Int
      config : InputConfig
      error_occurred : 
    Ref    [Bool]
    }

    Microphone::channels

    source
    fn Microphone::channels(self : Microphone) -> Int

    Microphone::config

    source
    fn Microphone::config(self : Microphone) -> InputConfig

    Microphone::current_span_len

    source
    fn Microphone::current_span_len(_self : Microphone) -> Int?

    Microphone::next

    source
    fn Microphone::next(self : Microphone) -> Double?

    Microphone::sample_rate

    source
    fn Microphone::sample_rate(self : Microphone) -> Int

    Microphone::total_duration

    source

    Microphone::try_seek

    source

    MicrophoneBuilder

    source

    MicrophoneBuilder::config

    source

    MicrophoneBuilder::default_config

    source

    MicrophoneBuilder::default_device

    source

    MicrophoneBuilder::device

    source

    MicrophoneBuilder::get_config

    source

    MicrophoneBuilder::new

    source

    MicrophoneBuilder::open_stream

    source

    MicrophoneBuilder::prefer_buffer_sizes

    source
    fn MicrophoneBuilder::prefer_buffer_sizes(self : MicrophoneBuilder, buffer_sizes : Array[Int]) -> MicrophoneBuilder

    MicrophoneBuilder::prefer_channel_counts

    source
    fn MicrophoneBuilder::prefer_channel_counts(self : MicrophoneBuilder, channel_counts : Array[Int]) -> MicrophoneBuilder

    MicrophoneBuilder::prefer_sample_rates

    source
    fn MicrophoneBuilder::prefer_sample_rates(self : MicrophoneBuilder, sample_rates : Array[Int]) -> MicrophoneBuilder

    MicrophoneBuilder::try_buffer_size

    source
    fn MicrophoneBuilder::try_buffer_size(self : MicrophoneBuilder, buffer_size : Int) -> MicrophoneBuilder raise MicrophoneError

    MicrophoneBuilder::try_channels

    source
    fn MicrophoneBuilder::try_channels(self : MicrophoneBuilder, channel_count : Int) -> MicrophoneBuilder raise MicrophoneError

    MicrophoneBuilder::try_sample_rate

    source
    fn MicrophoneBuilder::try_sample_rate(self : MicrophoneBuilder, sample_rate : Int) -> MicrophoneBuilder raise MicrophoneError

    MicrophoneBuilder::with_error_callback

    source

    Mix

    source
    pub struct Mix {
      inner : DynSource
    }

    impl Source for Mix

    Mix::channels

    source
    fn Mix::channels(self : Mix) -> Int

    Mix::current_span_len

    source
    fn Mix::current_span_len(_self : Mix) -> Int?

    Mix::inner

    source
    fn Mix::inner(self : Mix) -> DynSource

    Mix::inner_mut

    source
    fn Mix::inner_mut(self : Mix) -> DynSource

    Mix::into_inner

    source
    fn Mix::into_inner(self : Mix) -> DynSource

    Mix::new

    source
    fn[A : Source, B : Source] Mix::new(left : A, right : B) -> Mix

    Mix::next

    source
    fn Mix::next(self : Mix) -> Double?

    Mix::sample_rate

    source
    fn Mix::sample_rate(self : Mix) -> Int

    Mix::total_duration

    source
    fn Mix::total_duration(_self : Mix) -> 
    Duration    ?

    Mix::try_seek

    source
    fn Mix::try_seek(_self : Mix, pos : 
    Duration    ) -> Unit raise SeekError

    Mixer

    source
    pub struct Mixer {
      has_pending : 
    Ref    [Bool]
      pending_sources : 
    Ref    [Array[DynSource]]
      channels : Int
      sample_rate : Int
    }

    Mixer::add

    source
    fn[S : Source] Mixer::add(self : Mixer, source : S) -> Unit

    MixerDeviceSink

    source
    pub struct MixerDeviceSink {
      inner : OutputStream
    }

    MixerDeviceSink::config

    source

    MixerDeviceSink::log_on_drop

    source
    fn MixerDeviceSink::log_on_drop(self : MixerDeviceSink, enabled : Bool) -> Unit

    MixerDeviceSink::mixer

    source

    MixerSource

    source
    pub struct MixerSource {
      current_sources : 
    Ref    [Array[DynSource]]
      input : Mixer
      sample_count : 
    Ref    [Int]
    }

    MixerSource::channels

    source
    fn MixerSource::channels(self : MixerSource) -> Int

    MixerSource::current_span_len

    source
    fn MixerSource::current_span_len(_self : MixerSource) -> Int?

    MixerSource::next

    source
    fn MixerSource::next(self : MixerSource) -> Double?

    MixerSource::sample_rate

    source
    fn MixerSource::sample_rate(self : MixerSource) -> Int

    MixerSource::total_duration

    source

    MixerSource::try_seek

    source

    NoiseRngState

    source
    pub struct NoiseRngState {
      next_fn : () -> UInt64
    }

    Output

    source
    pub struct Output {
      inner : 
    Device
      default : Bool
    }

    Output::into_inner

    source

    Output::is_default

    source
    fn Output::is_default(self : Output) -> Bool

    Output::name

    source
    fn Output::name(self : Output) -> String

    OutputConfig

    source
    pub struct OutputConfig {
      channel_count : Int
      sample_rate : Int
      buffer_size : 
    BufferSize
      sample_format : 
    SampleFormat
    } derive(Eq, 
    Debug    )

    OutputConfig::default

    source
    fn OutputConfig::default() -> OutputConfig

    OutputConfig::equal

    source

    OutputConfig::from_supported

    source

    OutputConfig::new

    source
    fn OutputConfig::new(channel_count : Int, sample_rate : Int, buffer_size : 
    BufferSize    , sample_format : 
    SampleFormat    ) -> OutputConfig

    OutputConfig::not_equal

    source
    fn OutputConfig::not_equal(x : OutputConfig, y : OutputConfig) -> Bool

    OutputConfig::output

    source
    fn OutputConfig::output(self : OutputConfig, logger : &Logger) -> Unit

    OutputConfig::supported_given

    source

    OutputConfig::to_repr

    source

    OutputConfig::to_string

    source
    fn OutputConfig::to_string(self : OutputConfig) -> String

    OutputConfig::with_buffer_size

    source

    OutputConfig::with_channel_count

    source
    fn OutputConfig::with_channel_count(self : OutputConfig, channel_count : Int) -> OutputConfig

    OutputConfig::with_sample_format

    source

    OutputConfig::with_sample_rate

    source
    fn OutputConfig::with_sample_rate(self : OutputConfig, sample_rate : Int) -> OutputConfig

    OutputStream

    source
    pub struct OutputStream {
      config : OutputStreamConfig
      mixer : Mixer
      _stream : 
    Stream
      log_on_drop : 
    Ref    [Bool]
    }

    OutputStream::config

    source

    OutputStream::log_on_drop

    source
    fn OutputStream::log_on_drop(self : OutputStream, enabled : Bool) -> Unit

    OutputStream::mixer

    source
    fn OutputStream::mixer(self : OutputStream) -> Mixer

    OutputStream::open

    source

    OutputStreamBuilder

    source
    pub struct OutputStreamBuilder {
      device : 
    Device    ?
      config : OutputStreamConfig
      error_callback : (
    StreamError    ) -> Unit
    }

    OutputStreamBuilder::default

    source

    OutputStreamBuilder::from_default_device

    source
    fn OutputStreamBuilder::from_default_device() -> OutputStreamBuilder raise StreamError

    OutputStreamBuilder::from_device

    source

    OutputStreamBuilder::open_default_stream

    source
    fn OutputStreamBuilder::open_default_stream() -> OutputStream raise StreamError

    OutputStreamBuilder::open_stream

    source

    OutputStreamBuilder::open_stream_or_fallback

    source
    fn OutputStreamBuilder::open_stream_or_fallback(self : OutputStreamBuilder) -> OutputStream raise StreamError

    OutputStreamBuilder::with_buffer_size

    source

    OutputStreamBuilder::with_channels

    source
    fn OutputStreamBuilder::with_channels(self : OutputStreamBuilder, channel_count : Int) -> OutputStreamBuilder

    OutputStreamBuilder::with_config

    source

    OutputStreamBuilder::with_device

    source

    OutputStreamBuilder::with_error_callback

    source

    OutputStreamBuilder::with_sample_format

    source

    OutputStreamBuilder::with_sample_rate

    source
    fn OutputStreamBuilder::with_sample_rate(self : OutputStreamBuilder, sample_rate : Int) -> OutputStreamBuilder

    OutputStreamBuilder::with_supported_config

    source

    OutputStreamConfig

    source
    #alias(DeviceSinkConfig)
    pub struct OutputStreamConfig {
      channel_count : Int
      sample_rate : Int
      buffer_size : 
    BufferSize
      sample_format : 
    SampleFormat
    } derive(Eq, 
    Debug    )

    OutputStreamConfig::buffer_size

    source

    OutputStreamConfig::channel_count

    source
    fn OutputStreamConfig::channel_count(self : OutputStreamConfig) -> Int

    OutputStreamConfig::default

    source

    OutputStreamConfig::equal

    source

    OutputStreamConfig::not_equal

    source

    OutputStreamConfig::output

    source
    fn OutputStreamConfig::output(self : OutputStreamConfig, logger : &Logger) -> Unit

    OutputStreamConfig::sample_format

    source

    OutputStreamConfig::sample_rate

    source
    fn OutputStreamConfig::sample_rate(self : OutputStreamConfig) -> Int

    OutputStreamConfig::to_repr

    source

    OutputStreamConfig::to_string

    source
    fn OutputStreamConfig::to_string(self : OutputStreamConfig) -> String

    Pausable

    source
    pub struct Pausable {
      input : DynSource
      paused_channels : 
    Ref    [Int?]
      remaining_paused_samples : 
    Ref    [Int]
    }

    impl Source for Pausable

    Pausable::channels

    source
    fn Pausable::channels(self : Pausable) -> Int

    Pausable::current_span_len

    source
    fn Pausable::current_span_len(_self : Pausable) -> Int?

    Pausable::inner

    source
    fn Pausable::inner(self : Pausable) -> DynSource

    Pausable::inner_mut

    source
    fn Pausable::inner_mut(self : Pausable) -> DynSource

    Pausable::into_inner

    source
    fn Pausable::into_inner(self : Pausable) -> DynSource

    Pausable::is_paused

    source
    fn Pausable::is_paused(self : Pausable) -> Bool

    Pausable::next

    source
    fn Pausable::next(self : Pausable) -> Double?

    Pausable::sample_rate

    source
    fn Pausable::sample_rate(self : Pausable) -> Int

    Pausable::set_paused

    source
    fn Pausable::set_paused(self : Pausable, paused : Bool) -> Unit

    Pausable::total_duration

    source

    Pausable::try_seek

    source
    fn Pausable::try_seek(_self : Pausable, pos : 
    Duration    ) -> Unit raise SeekError

    PeriodicAccess

    source
    pub struct PeriodicAccess {
      input : DynSource
      every_samples : Int
      remaining : 
    Ref    [Int]
      callback : (DynSource) -> Unit
    }

    PeriodicAccess::channels

    source
    fn PeriodicAccess::channels(self : PeriodicAccess) -> Int

    PeriodicAccess::current_span_len

    source
    fn PeriodicAccess::current_span_len(_self : PeriodicAccess) -> Int?

    PeriodicAccess::inner

    source

    PeriodicAccess::inner_mut

    source
    fn PeriodicAccess::inner_mut(self : PeriodicAccess) -> DynSource

    PeriodicAccess::into_inner

    source
    fn PeriodicAccess::into_inner(self : PeriodicAccess) -> DynSource

    PeriodicAccess::next

    source
    fn PeriodicAccess::next(self : PeriodicAccess) -> Double?

    PeriodicAccess::sample_rate

    source
    fn PeriodicAccess::sample_rate(self : PeriodicAccess) -> Int

    PeriodicAccess::total_duration

    source

    PeriodicAccess::try_seek

    source

    Pink

    source
    pub struct Pink {
      sample_rate : Int
      rng : NoiseRngState
      prev : 
    Ref    [Double]
    }

    impl Source for Pink

    Pink::channels

    source
    fn Pink::channels(_self : Pink) -> Int

    Pink::current_span_len

    source
    fn Pink::current_span_len(_self : Pink) -> Int?

    Pink::new

    source
    fn Pink::new(sample_rate : Int) -> Pink

    Pink::new_with_rng

    source
    fn[R : NoiseRng] Pink::new_with_rng(sample_rate : Int, rng : R) -> Pink

    Pink::new_with_seed

    source
    fn Pink::new_with_seed(sample_rate : Int, seed : UInt64) -> Pink

    Pink::next

    source
    fn Pink::next(self : Pink) -> Double?

    Pink::sample_rate

    source
    fn Pink::sample_rate(self : Pink) -> Int

    Pink::total_duration

    source
    fn Pink::total_duration(_self : Pink) -> 
    Duration    ?

    Pink::try_seek

    source
    fn Pink::try_seek(_self : Pink, pos : 
    Duration    ) -> Unit raise SeekError

    Player

    source
    pub struct Player {
      inner : Sink
    }

    Player::append

    source
    fn[S : Source] Player::append(self : Player, source : S) -> Unit

    Player::clear

    source
    fn Player::clear(self : Player) -> Unit

    Player::connect_new

    source
    fn Player::connect_new(mixer : Mixer) -> Player

    Player::detach

    source
    fn Player::detach(self : Player) -> Unit

    Player::empty

    source
    fn Player::empty(self : Player) -> Bool

    Player::get_pos

    source

    Player::is_paused

    source
    fn Player::is_paused(self : Player) -> Bool

    Player::len

    source
    fn Player::len(self : Player) -> Int

    Player::new

    source

    Player::pause

    source
    fn Player::pause(self : Player) -> Unit

    Player::play

    source
    fn Player::play(self : Player) -> Unit

    Player::set_speed

    source
    fn Player::set_speed(self : Player, value : Double) -> Unit

    Player::set_volume

    source
    fn Player::set_volume(self : Player, value : Double) -> Unit

    Player::skip_one

    source
    fn Player::skip_one(self : Player) -> Unit

    Player::sleep_until_end

    source
    fn Player::sleep_until_end(self : Player) -> Unit

    Player::speed

    source
    fn Player::speed(self : Player) -> Double

    Player::stop

    source
    fn Player::stop(self : Player) -> Unit

    Player::try_seek

    source
    fn Player::try_seek(self : Player, pos : 
    Duration    ) -> Unit raise SeekError

    Player::volume

    source
    fn Player::volume(self : Player) -> Double

    QueueSignal

    source
    pub struct QueueSignal {
      done : 
    Ref    [Bool]
    }

    QueueSignal::is_done

    source
    fn QueueSignal::is_done(self : QueueSignal) -> Bool

    QueueSignal::mark_done

    source
    fn QueueSignal::mark_done(self : QueueSignal) -> Unit

    QueuedSource

    source
    type QueuedSource

    Reader

    source
    pub struct Reader {
      bytes : Bytes
    }

    Reader::from_bytes

    source
    fn Reader::from_bytes(bytes : Bytes) -> Reader

    Reader::from_file

    source
    fn Reader::from_file(path : StringView) -> Reader raise PlayError

    Reader::into_bytes

    source
    fn Reader::into_bytes(self : Reader) -> Bytes

    Red

    source
    pub struct Red {
      sample_rate : Int
      white_noise : WhiteUniform
      accumulator : 
    Ref    [Double]
      leak_factor : 
    Ref    [Double]
      scale : 
    Ref    [Double]
    }

    impl Source for Red

    Red::channels

    source
    fn Red::channels(_self : Red) -> Int

    Red::current_span_len

    source
    fn Red::current_span_len(_self : Red) -> Int?

    Red::new

    source
    fn Red::new(sample_rate : Int) -> Red

    Red::new_with_rng

    source
    fn[R : NoiseRng] Red::new_with_rng(sample_rate : Int, rng : R) -> Red

    Red::new_with_seed

    source
    fn Red::new_with_seed(sample_rate : Int, seed : UInt64) -> Red

    Red::next

    source
    fn Red::next(self : Red) -> Double?

    Red::sample_rate

    source
    fn Red::sample_rate(self : Red) -> Int

    Red::total_duration

    source
    fn Red::total_duration(_self : Red) -> 
    Duration    ?

    Red::try_seek

    source
    fn Red::try_seek(_self : Red, _pos : 
    Duration    ) -> Unit raise SeekError

    Repeat

    source
    pub struct Repeat {
      inner : DynSource
    }

    impl Source for Repeat

    Repeat::channels

    source
    fn Repeat::channels(self : Repeat) -> Int

    Repeat::current_span_len

    source
    fn Repeat::current_span_len(_self : Repeat) -> Int?

    Repeat::inner

    source
    fn Repeat::inner(self : Repeat) -> DynSource

    Repeat::inner_mut

    source
    fn Repeat::inner_mut(self : Repeat) -> DynSource

    Repeat::into_inner

    source
    fn Repeat::into_inner(self : Repeat) -> DynSource

    Repeat::new

    source
    fn[S : Source] Repeat::new(source : S) -> Repeat

    Repeat::next

    source
    fn Repeat::next(self : Repeat) -> Double?

    Repeat::sample_rate

    source
    fn Repeat::sample_rate(self : Repeat) -> Int

    Repeat::total_duration

    source

    Repeat::try_seek

    source
    fn Repeat::try_seek(_self : Repeat, pos : 
    Duration    ) -> Unit raise SeekError

    SampleRateConverter

    source
    pub struct SampleRateConverter {
      inner : DynSource
      to : Int
      channels : Int
    }

    SampleRateConverter::channels

    source
    fn SampleRateConverter::channels(self : SampleRateConverter) -> Int

    SampleRateConverter::current_span_len

    source
    fn SampleRateConverter::current_span_len(_self : SampleRateConverter) -> Int?

    SampleRateConverter::inner_mut

    source

    SampleRateConverter::into_inner

    source

    SampleRateConverter::new

    source
    fn[S : Source] SampleRateConverter::new(input : S, from : Int, to : Int, num_channels : Int) -> SampleRateConverter

    SampleRateConverter::next

    source
    fn SampleRateConverter::next(self : SampleRateConverter) -> Double?

    SampleRateConverter::sample_rate

    source
    fn SampleRateConverter::sample_rate(self : SampleRateConverter) -> Int

    SampleRateConverter::total_duration

    source

    SampleRateConverter::try_seek

    source

    SampleTypeConverter

    source
    pub struct SampleTypeConverter {
      inner : DynSource
    }

    SampleTypeConverter::channels

    source
    fn SampleTypeConverter::channels(self : SampleTypeConverter) -> Int

    SampleTypeConverter::current_span_len

    source
    fn SampleTypeConverter::current_span_len(_self : SampleTypeConverter) -> Int?

    SampleTypeConverter::inner_mut

    source

    SampleTypeConverter::into_inner

    source

    SampleTypeConverter::new

    source

    SampleTypeConverter::next

    source
    fn SampleTypeConverter::next(self : SampleTypeConverter) -> Double?

    SampleTypeConverter::sample_rate

    source
    fn SampleTypeConverter::sample_rate(self : SampleTypeConverter) -> Int

    SampleTypeConverter::total_duration

    source

    SampleTypeConverter::try_seek

    source

    SamplesBuffer

    source
    pub struct SamplesBuffer {
      channels : Int
      sample_rate : Int
      samples : Array[Double]
      cursor : 
    Ref    [Int]
    }

    SamplesBuffer::amplify

    source
    fn SamplesBuffer::amplify(self : SamplesBuffer, factor : Double) -> DynSource

    SamplesBuffer::channels

    source
    fn SamplesBuffer::channels(self : SamplesBuffer) -> Int

    SamplesBuffer::current_span_len

    source
    fn SamplesBuffer::current_span_len(self : SamplesBuffer) -> Int?

    SamplesBuffer::new

    source
    fn SamplesBuffer::new(channels : Int, sample_rate : Int, samples : Array[Double]) -> SamplesBuffer

    SamplesBuffer::next

    source
    fn SamplesBuffer::next(self : SamplesBuffer) -> Double?

    SamplesBuffer::record_source

    source
    fn[S : Source] SamplesBuffer::record_source(source : S) -> SamplesBuffer

    SamplesBuffer::repeat_infinite

    source
    fn SamplesBuffer::repeat_infinite(self : SamplesBuffer) -> DynSource

    SamplesBuffer::sample_rate

    source
    fn SamplesBuffer::sample_rate(self : SamplesBuffer) -> Int

    SamplesBuffer::total_duration

    source

    SamplesBuffer::try_seek

    source

    SawtoothWave

    source
    pub struct SawtoothWave {
      inner : SignalGenerator
    }

    SawtoothWave::channels

    source
    fn SawtoothWave::channels(self : SawtoothWave) -> Int

    SawtoothWave::current_span_len

    source
    fn SawtoothWave::current_span_len(_self : SawtoothWave) -> Int?

    SawtoothWave::new

    source
    fn SawtoothWave::new(freq : Double) -> SawtoothWave

    SawtoothWave::next

    source
    fn SawtoothWave::next(self : SawtoothWave) -> Double?

    SawtoothWave::sample_rate

    source
    fn SawtoothWave::sample_rate(self : SawtoothWave) -> Int

    SawtoothWave::total_duration

    source

    SawtoothWave::try_seek

    source

    Settings

    source
    pub struct Settings {
      byte_len : Int?
      coarse_seek : Bool
      gapless : Bool
      hint : String?
      mime_type : String?
      is_seekable : Bool
    } derive(Eq, 
    Debug    )

    impl Show for Settings

    Settings::default

    source
    fn Settings::default() -> Settings

    Settings::equal

    source
    fn Settings::equal(Settings, Settings) -> Bool

    Settings::not_equal

    source
    fn Settings::not_equal(x : Settings, y : Settings) -> Bool

    Settings::output

    source
    fn Settings::output(self : Settings, logger : &Logger) -> Unit

    Settings::to_repr

    source

    Settings::to_string

    source
    fn Settings::to_string(self : Settings) -> String

    SignalFunction

    source
    pub enum SignalFunction {
      Sine
      Square
      Sawtooth
      Triangle
    } derive(Eq, 
    Debug    )

    SignalFunction::equal

    source

    SignalFunction::not_equal

    source
    fn SignalFunction::not_equal(x : SignalFunction, y : SignalFunction) -> Bool

    SignalFunction::output

    source
    fn SignalFunction::output(self : SignalFunction, logger : &Logger) -> Unit

    SignalFunction::to_repr

    source

    SignalFunction::to_string

    source
    fn SignalFunction::to_string(self : SignalFunction) -> String

    SignalGenerator

    source
    pub struct SignalGenerator {
      channels : Int
      sample_rate : Int
      frequency : Double
      function : SignalFunction
      phase : 
    Ref    [Double]
    }

    SignalGenerator::channels

    source
    fn SignalGenerator::channels(self : SignalGenerator) -> Int

    SignalGenerator::current_span_len

    source
    fn SignalGenerator::current_span_len(_self : SignalGenerator) -> Int?

    SignalGenerator::from_function

    source
    fn SignalGenerator::from_function(sample_rate : Int, frequency : Double, function : Function) -> SignalGenerator

    SignalGenerator::new

    source
    fn SignalGenerator::new(sample_rate : Int, frequency : Double, function : SignalFunction) -> SignalGenerator

    SignalGenerator::next

    source
    fn SignalGenerator::next(self : SignalGenerator) -> Double?

    SignalGenerator::sample_rate

    source
    fn SignalGenerator::sample_rate(self : SignalGenerator) -> Int

    SignalGenerator::total_duration

    source

    SignalGenerator::try_seek

    source

    SignalGenerator::with_function

    source
    fn SignalGenerator::with_function(sample_rate : Int, frequency : Double, function : Function) -> SignalGenerator

    SignalGenerator::with_generator

    source
    fn SignalGenerator::with_generator(sample_rate : Int, frequency : Double, function : GeneratorFunction) -> DynSource

    SineWave

    source
    pub struct SineWave {
      inner : SignalGenerator
    }

    impl Source for SineWave

    SineWave::channels

    source
    fn SineWave::channels(self : SineWave) -> Int

    SineWave::current_span_len

    source
    fn SineWave::current_span_len(_self : SineWave) -> Int?

    SineWave::new

    source
    fn SineWave::new(freq : Double) -> SineWave

    SineWave::next

    source
    fn SineWave::next(self : SineWave) -> Double?

    SineWave::sample_rate

    source
    fn SineWave::sample_rate(self : SineWave) -> Int

    SineWave::total_duration

    source

    SineWave::try_seek

    source
    fn SineWave::try_seek(self : SineWave, pos : 
    Duration    ) -> Unit raise SeekError

    Sink

    source
    pub struct Sink {
      queue_tx : SourcesQueueInput
      queue_rx : SourcesQueueOutput
      controls : SinkControls
      detached : 
    Ref    [Bool]
      last_signal : 
    Ref    [QueueSignal?]
    }

    Sink::append

    source
    fn[S : Source] Sink::append(self : Sink, source : S) -> Unit

    Sink::clear

    source
    fn Sink::clear(self : Sink) -> Unit

    Sink::connect_new

    source
    fn Sink::connect_new(mixer : Mixer) -> Sink

    Sink::detach

    source
    fn Sink::detach(self : Sink) -> Unit

    Sink::empty

    source
    fn Sink::empty(self : Sink) -> Bool

    Sink::get_pos

    source

    Sink::is_paused

    source
    fn Sink::is_paused(self : Sink) -> Bool

    Sink::len

    source
    fn Sink::len(self : Sink) -> Int

    Sink::new

    source

    Sink::pause

    source
    fn Sink::pause(self : Sink) -> Unit

    Sink::play

    source
    fn Sink::play(self : Sink) -> Unit

    Sink::set_speed

    source
    fn Sink::set_speed(self : Sink, value : Double) -> Unit

    Sink::set_volume

    source
    fn Sink::set_volume(self : Sink, value : Double) -> Unit

    Sink::skip_one

    source
    fn Sink::skip_one(self : Sink) -> Unit

    Sink::sleep_until_end

    source
    fn Sink::sleep_until_end(self : Sink) -> Unit

    Sink::speed

    source
    fn Sink::speed(self : Sink) -> Double

    Sink::stop

    source
    fn Sink::stop(self : Sink) -> Unit

    Sink::try_seek

    source
    fn Sink::try_seek(self : Sink, pos : 
    Duration    ) -> Unit raise SeekError

    Sink::volume

    source
    fn Sink::volume(self : Sink) -> Double

    SinkControls

    source

    SinkHandle

    source
    pub struct SinkHandle {
      _sink : MixerDeviceSink
    }

    SkipDuration

    source
    pub struct SkipDuration {
      inner : DynSource
    }

    SkipDuration::channels

    source
    fn SkipDuration::channels(self : SkipDuration) -> Int

    SkipDuration::current_span_len

    source
    fn SkipDuration::current_span_len(_self : SkipDuration) -> Int?

    SkipDuration::inner

    source
    fn SkipDuration::inner(self : SkipDuration) -> DynSource

    SkipDuration::inner_mut

    source
    fn SkipDuration::inner_mut(self : SkipDuration) -> DynSource

    SkipDuration::into_inner

    source
    fn SkipDuration::into_inner(self : SkipDuration) -> DynSource

    SkipDuration::new

    source

    SkipDuration::next

    source
    fn SkipDuration::next(self : SkipDuration) -> Double?

    SkipDuration::sample_rate

    source
    fn SkipDuration::sample_rate(self : SkipDuration) -> Int

    SkipDuration::total_duration

    source

    SkipDuration::try_seek

    source

    Skippable

    source
    pub struct Skippable {
      input : DynSource
      do_skip : 
    Ref    [Bool]
    }

    impl Source for Skippable

    Skippable::channels

    source
    fn Skippable::channels(self : Skippable) -> Int

    Skippable::current_span_len

    source
    fn Skippable::current_span_len(_self : Skippable) -> Int?

    Skippable::inner

    source
    fn Skippable::inner(self : Skippable) -> DynSource

    Skippable::inner_mut

    source
    fn Skippable::inner_mut(self : Skippable) -> DynSource

    Skippable::into_inner

    source
    fn Skippable::into_inner(self : Skippable) -> DynSource

    Skippable::next

    source
    fn Skippable::next(self : Skippable) -> Double?

    Skippable::sample_rate

    source
    fn Skippable::sample_rate(self : Skippable) -> Int

    Skippable::skip

    source
    fn Skippable::skip(self : Skippable) -> Unit

    Skippable::total_duration

    source

    Skippable::try_seek

    source
    fn Skippable::try_seek(_self : Skippable, pos : 
    Duration    ) -> Unit raise SeekError

    SourcesQueueInput

    source
    pub struct SourcesQueueInput {
      next_sounds : 
    Ref    [Array[QueuedSource]]
      keep_alive_if_empty : 
    Ref    [Bool]
    }

    SourcesQueueInput::append

    source
    fn[S : Source] SourcesQueueInput::append(self : SourcesQueueInput, source : S) -> Unit

    SourcesQueueInput::append_with_signal

    source
    fn[S : Source] SourcesQueueInput::append_with_signal(self : SourcesQueueInput, source : S) -> QueueSignal

    SourcesQueueInput::clear

    source
    fn SourcesQueueInput::clear(self : SourcesQueueInput) -> Int

    SourcesQueueInput::set_keep_alive_if_empty

    source
    fn SourcesQueueInput::set_keep_alive_if_empty(self : SourcesQueueInput, keep_alive_if_empty : Bool) -> Unit

    SourcesQueueOutput

    source
    pub struct SourcesQueueOutput {
      current : 
    Ref    [DynSource]
      current_is_fallback : 
    Ref    [Bool]
      prefetched : 
    Ref    [Double?]
      has_prefetched : 
    Ref    [Bool]
      signal_after_end : 
    Ref    [QueueSignal?]
      samples_consumed_in_span : 
    Ref    [Int]
      padding_samples_remaining : 
    Ref    [Int]
      input : SourcesQueueInput
    }

    SourcesQueueOutput::channels

    source
    fn SourcesQueueOutput::channels(self : SourcesQueueOutput) -> Int

    SourcesQueueOutput::current_span_len

    source
    fn SourcesQueueOutput::current_span_len(self : SourcesQueueOutput) -> Int?

    SourcesQueueOutput::next

    source
    fn SourcesQueueOutput::next(self : SourcesQueueOutput) -> Double?

    SourcesQueueOutput::sample_rate

    source
    fn SourcesQueueOutput::sample_rate(self : SourcesQueueOutput) -> Int

    SourcesQueueOutput::skip_one

    source
    fn SourcesQueueOutput::skip_one(self : SourcesQueueOutput) -> Unit

    SourcesQueueOutput::total_duration

    source

    SourcesQueueOutput::try_seek

    source

    Spatial

    source
    pub struct Spatial {
      inner : SpatialSource
    }

    impl Source for Spatial

    Spatial::channels

    source
    fn Spatial::channels(self : Spatial) -> Int

    Spatial::current_span_len

    source
    fn Spatial::current_span_len(_self : Spatial) -> Int?

    Spatial::inner

    source
    fn Spatial::inner(self : Spatial) -> SpatialSource

    Spatial::inner_mut

    source
    fn Spatial::inner_mut(self : Spatial) -> SpatialSource

    Spatial::into_inner

    source
    fn Spatial::into_inner(self : Spatial) -> SpatialSource

    Spatial::new

    source
    fn[S : Source] Spatial::new(input : S, emitter_position : Array[Double], left_ear : Array[Double], right_ear : Array[Double]) -> Spatial

    Spatial::next

    source
    fn Spatial::next(self : Spatial) -> Double?

    Spatial::sample_rate

    source
    fn Spatial::sample_rate(self : Spatial) -> Int

    Spatial::set_positions

    source
    fn Spatial::set_positions(self : Spatial, emitter_position : Array[Double], left_ear : Array[Double], right_ear : Array[Double]) -> Unit

    Spatial::total_duration

    source

    Spatial::try_seek

    source
    fn Spatial::try_seek(_self : Spatial, pos : 
    Duration    ) -> Unit raise SeekError

    SpatialPlayer

    source
    pub struct SpatialPlayer {
      inner : SpatialSink
    }

    Naming-compatible wrapper around SpatialSink.

    SpatialPlayer::append

    source
    fn[S : Source] SpatialPlayer::append(self : SpatialPlayer, source : S) -> Unit

    SpatialPlayer::clear

    source
    fn SpatialPlayer::clear(self : SpatialPlayer) -> Unit

    SpatialPlayer::connect_new

    source
    fn SpatialPlayer::connect_new(mixer : Mixer, emitter_position : Array[Double], left_ear : Array[Double], right_ear : Array[Double]) -> SpatialPlayer

    SpatialPlayer::detach

    source
    fn SpatialPlayer::detach(self : SpatialPlayer) -> Unit

    SpatialPlayer::empty

    source
    fn SpatialPlayer::empty(self : SpatialPlayer) -> Bool

    SpatialPlayer::get_pos

    source

    SpatialPlayer::is_paused

    source
    fn SpatialPlayer::is_paused(self : SpatialPlayer) -> Bool

    SpatialPlayer::len

    source
    fn SpatialPlayer::len(self : SpatialPlayer) -> Int

    SpatialPlayer::pause

    source
    fn SpatialPlayer::pause(self : SpatialPlayer) -> Unit

    SpatialPlayer::play

    source
    fn SpatialPlayer::play(self : SpatialPlayer) -> Unit

    SpatialPlayer::set_emitter_position

    source
    fn SpatialPlayer::set_emitter_position(self : SpatialPlayer, pos : Array[Double]) -> Unit

    SpatialPlayer::set_left_ear_position

    source
    fn SpatialPlayer::set_left_ear_position(self : SpatialPlayer, pos : Array[Double]) -> Unit

    SpatialPlayer::set_right_ear_position

    source
    fn SpatialPlayer::set_right_ear_position(self : SpatialPlayer, pos : Array[Double]) -> Unit

    SpatialPlayer::set_speed

    source
    fn SpatialPlayer::set_speed(self : SpatialPlayer, value : Double) -> Unit

    SpatialPlayer::set_volume

    source
    fn SpatialPlayer::set_volume(self : SpatialPlayer, value : Double) -> Unit

    SpatialPlayer::sleep_until_end

    source
    fn SpatialPlayer::sleep_until_end(self : SpatialPlayer) -> Unit

    SpatialPlayer::speed

    source
    fn SpatialPlayer::speed(self : SpatialPlayer) -> Double

    SpatialPlayer::stop

    source
    fn SpatialPlayer::stop(self : SpatialPlayer) -> Unit

    SpatialPlayer::try_seek

    source

    SpatialPlayer::volume

    source
    fn SpatialPlayer::volume(self : SpatialPlayer) -> Double

    SpatialSink

    source
    pub struct SpatialSink {
      sink : Sink
      emitter_position : 
    Ref    [Array[Double]]
      left_ear : 
    Ref    [Array[Double]]
      right_ear : 
    Ref    [Array[Double]]
    }

    SpatialSink::append

    source
    fn[S : Source] SpatialSink::append(self : SpatialSink, source : S) -> Unit

    SpatialSink::clear

    source
    fn SpatialSink::clear(self : SpatialSink) -> Unit

    SpatialSink::connect_new

    source
    fn SpatialSink::connect_new(mixer : Mixer, emitter_position : Array[Double], left_ear : Array[Double], right_ear : Array[Double]) -> SpatialSink

    SpatialSink::detach

    source
    fn SpatialSink::detach(self : SpatialSink) -> Unit

    SpatialSink::empty

    source
    fn SpatialSink::empty(self : SpatialSink) -> Bool

    SpatialSink::get_pos

    source

    SpatialSink::is_paused

    source
    fn SpatialSink::is_paused(self : SpatialSink) -> Bool

    SpatialSink::len

    source
    fn SpatialSink::len(self : SpatialSink) -> Int

    SpatialSink::pause

    source
    fn SpatialSink::pause(self : SpatialSink) -> Unit

    SpatialSink::play

    source
    fn SpatialSink::play(self : SpatialSink) -> Unit

    SpatialSink::set_emitter_position

    source
    fn SpatialSink::set_emitter_position(self : SpatialSink, pos : Array[Double]) -> Unit

    SpatialSink::set_left_ear_position

    source
    fn SpatialSink::set_left_ear_position(self : SpatialSink, pos : Array[Double]) -> Unit

    SpatialSink::set_right_ear_position

    source
    fn SpatialSink::set_right_ear_position(self : SpatialSink, pos : Array[Double]) -> Unit

    SpatialSink::set_speed

    source
    fn SpatialSink::set_speed(self : SpatialSink, value : Double) -> Unit

    SpatialSink::set_volume

    source
    fn SpatialSink::set_volume(self : SpatialSink, value : Double) -> Unit

    SpatialSink::skip_one

    source
    fn SpatialSink::skip_one(self : SpatialSink) -> Unit

    SpatialSink::sleep_until_end

    source
    fn SpatialSink::sleep_until_end(self : SpatialSink) -> Unit

    SpatialSink::speed

    source
    fn SpatialSink::speed(self : SpatialSink) -> Double

    SpatialSink::stop

    source
    fn SpatialSink::stop(self : SpatialSink) -> Unit

    SpatialSink::try_seek

    source

    SpatialSink::volume

    source
    fn SpatialSink::volume(self : SpatialSink) -> Double

    SpatialSource

    source
    pub struct SpatialSource {
      input : DynSource
      emitter_position : 
    Ref    [Array[Double]]
      left_ear : 
    Ref    [Array[Double]]
      right_ear : 
    Ref    [Array[Double]]
      left_gain : 
    Ref    [Double]
      right_gain : 
    Ref    [Double]
      pending_mono : 
    Ref    [Double]
      has_pending : 
    Ref    [Bool]
      pending_channel : 
    Ref    [Int]
    }

    SpatialSource::channels

    source
    fn SpatialSource::channels(_self : SpatialSource) -> Int

    SpatialSource::current_span_len

    source
    fn SpatialSource::current_span_len(self : SpatialSource) -> Int?

    SpatialSource::new

    source
    fn[S : Source] SpatialSource::new(input : S, emitter_position : Array[Double], left_ear : Array[Double], right_ear : Array[Double]) -> SpatialSource

    SpatialSource::next

    source
    fn SpatialSource::next(self : SpatialSource) -> Double?

    SpatialSource::sample_rate

    source
    fn SpatialSource::sample_rate(self : SpatialSource) -> Int

    SpatialSource::set_positions

    source
    fn SpatialSource::set_positions(self : SpatialSource, emitter_position : Array[Double], left_ear : Array[Double], right_ear : Array[Double]) -> Unit

    SpatialSource::total_duration

    source

    SpatialSource::try_seek

    source

    SpeakersBuilder

    source

    SpeakersBuilder::config

    source

    SpeakersBuilder::default_config

    source
    fn SpeakersBuilder::default_config(self : SpeakersBuilder) -> SpeakersBuilder raise SpeakersError

    SpeakersBuilder::default_device

    source
    fn SpeakersBuilder::default_device(self : SpeakersBuilder) -> SpeakersBuilder raise SpeakersError

    SpeakersBuilder::device

    source

    SpeakersBuilder::get_config

    source

    SpeakersBuilder::new

    source

    SpeakersBuilder::open_mixer

    source

    SpeakersBuilder::play

    source
    fn[S : FixedSource] SpeakersBuilder::play(self : SpeakersBuilder, source : S) -> SinkHandle raise SpeakersPlayError

    SpeakersBuilder::prefer_buffer_sizes

    source
    fn SpeakersBuilder::prefer_buffer_sizes(self : SpeakersBuilder, buffer_sizes : Array[Int]) -> SpeakersBuilder

    SpeakersBuilder::prefer_channel_counts

    source
    fn SpeakersBuilder::prefer_channel_counts(self : SpeakersBuilder, channel_counts : Array[Int]) -> SpeakersBuilder

    SpeakersBuilder::prefer_sample_rates

    source
    fn SpeakersBuilder::prefer_sample_rates(self : SpeakersBuilder, sample_rates : Array[Int]) -> SpeakersBuilder

    SpeakersBuilder::try_buffer_size

    source
    fn SpeakersBuilder::try_buffer_size(self : SpeakersBuilder, buffer_size : Int) -> SpeakersBuilder raise SpeakersError

    SpeakersBuilder::try_channels

    source
    fn SpeakersBuilder::try_channels(self : SpeakersBuilder, channel_count : Int) -> SpeakersBuilder raise SpeakersError

    SpeakersBuilder::try_sample_rate

    source
    fn SpeakersBuilder::try_sample_rate(self : SpeakersBuilder, sample_rate : Int) -> SpeakersBuilder raise SpeakersError

    SpeakersBuilder::with_error_callback

    source

    Speed

    source
    pub struct Speed {
      input : DynSource
      factor : 
    Ref    [Double]
    }

    impl Source for Speed

    Speed::channels

    source
    fn Speed::channels(self : Speed) -> Int

    Speed::current_span_len

    source
    fn Speed::current_span_len(_self : Speed) -> Int?

    Speed::inner

    source
    fn Speed::inner(self : Speed) -> DynSource

    Speed::inner_mut

    source
    fn Speed::inner_mut(self : Speed) -> DynSource

    Speed::into_inner

    source
    fn Speed::into_inner(self : Speed) -> DynSource

    Speed::new

    source
    fn[S : Source] Speed::new(source : S, ratio : Double) -> Speed

    Speed::next

    source
    fn Speed::next(self : Speed) -> Double?

    Speed::sample_rate

    source
    fn Speed::sample_rate(self : Speed) -> Int

    Speed::set_factor

    source
    fn Speed::set_factor(self : Speed, factor : Double) -> Unit

    Speed::total_duration

    source

    Speed::try_seek

    source
    fn Speed::try_seek(_self : Speed, pos : 
    Duration    ) -> Unit raise SeekError

    SquareWave

    source
    pub struct SquareWave {
      inner : SignalGenerator
    }

    SquareWave::channels

    source
    fn SquareWave::channels(self : SquareWave) -> Int

    SquareWave::current_span_len

    source
    fn SquareWave::current_span_len(_self : SquareWave) -> Int?

    SquareWave::new

    source
    fn SquareWave::new(freq : Double) -> SquareWave

    SquareWave::next

    source
    fn SquareWave::next(self : SquareWave) -> Double?

    SquareWave::sample_rate

    source
    fn SquareWave::sample_rate(self : SquareWave) -> Int

    SquareWave::total_duration

    source

    SquareWave::try_seek

    source

    StaticSamplesBuffer

    source
    pub struct StaticSamplesBuffer {
      channels : Int
      sample_rate : Int
      samples : Array[Double]
      cursor : 
    Ref    [Int]
    }

    StaticSamplesBuffer::channels

    source
    fn StaticSamplesBuffer::channels(self : StaticSamplesBuffer) -> Int

    StaticSamplesBuffer::current_span_len

    source
    fn StaticSamplesBuffer::current_span_len(_self : StaticSamplesBuffer) -> Int?

    StaticSamplesBuffer::new

    source
    fn StaticSamplesBuffer::new(channels : Int, sample_rate : Int, samples : Array[Double]) -> StaticSamplesBuffer

    StaticSamplesBuffer::next

    source
    fn StaticSamplesBuffer::next(self : StaticSamplesBuffer) -> Double?

    StaticSamplesBuffer::sample_rate

    source
    fn StaticSamplesBuffer::sample_rate(self : StaticSamplesBuffer) -> Int

    StaticSamplesBuffer::total_duration

    source

    StaticSamplesBuffer::try_seek

    source

    Stoppable

    source
    pub struct Stoppable {
      input : DynSource
      stopped : 
    Ref    [Bool]
    }

    impl Source for Stoppable

    Stoppable::channels

    source
    fn Stoppable::channels(self : Stoppable) -> Int

    Stoppable::current_span_len

    source
    fn Stoppable::current_span_len(_self : Stoppable) -> Int?

    Stoppable::inner

    source
    fn Stoppable::inner(self : Stoppable) -> DynSource

    Stoppable::inner_mut

    source
    fn Stoppable::inner_mut(self : Stoppable) -> DynSource

    Stoppable::into_inner

    source
    fn Stoppable::into_inner(self : Stoppable) -> DynSource

    Stoppable::next

    source
    fn Stoppable::next(self : Stoppable) -> Double?

    Stoppable::sample_rate

    source
    fn Stoppable::sample_rate(self : Stoppable) -> Int

    Stoppable::stop

    source
    fn Stoppable::stop(self : Stoppable) -> Unit

    Stoppable::total_duration

    source

    Stoppable::try_seek

    source
    fn Stoppable::try_seek(_self : Stoppable, pos : 
    Duration    ) -> Unit raise SeekError

    TakeDuration

    source
    pub struct TakeDuration {
      inner : DynSource
      requested_duration : 
    Duration
      requested_samples : Int
      remaining_samples : 
    Ref    [Int]
      filter_fadeout : 
    Ref    [Bool]
    }

    TakeDuration::channels

    source
    fn TakeDuration::channels(self : TakeDuration) -> Int

    TakeDuration::clear_filter

    source
    fn TakeDuration::clear_filter(self : TakeDuration) -> Unit

    TakeDuration::current_span_len

    source
    fn TakeDuration::current_span_len(_self : TakeDuration) -> Int?

    TakeDuration::inner

    source
    fn TakeDuration::inner(self : TakeDuration) -> DynSource

    TakeDuration::inner_mut

    source
    fn TakeDuration::inner_mut(self : TakeDuration) -> DynSource

    TakeDuration::into_inner

    source
    fn TakeDuration::into_inner(self : TakeDuration) -> DynSource

    TakeDuration::new

    source

    TakeDuration::next

    source
    fn TakeDuration::next(self : TakeDuration) -> Double?

    TakeDuration::sample_rate

    source
    fn TakeDuration::sample_rate(self : TakeDuration) -> Int

    TakeDuration::set_filter_fadeout

    source
    fn TakeDuration::set_filter_fadeout(self : TakeDuration) -> Unit

    TakeDuration::total_duration

    source

    TakeDuration::try_seek

    source

    TrackPosition

    source
    pub struct TrackPosition {
      input : DynSource
      samples_counted : 
    Ref    [Int]
      offset_duration : 
    Ref    [
    Duration    ]
      current_span_sample_rate : 
    Ref    [Int]
      current_span_channels : 
    Ref    [Int]
      current_span_len : 
    Ref    [Int?]
    }

    TrackPosition::channels

    source
    fn TrackPosition::channels(self : TrackPosition) -> Int

    TrackPosition::current_span_len

    source
    fn TrackPosition::current_span_len(_self : TrackPosition) -> Int?

    TrackPosition::get_pos

    source

    TrackPosition::inner

    source

    TrackPosition::inner_mut

    source
    fn TrackPosition::inner_mut(self : TrackPosition) -> DynSource

    TrackPosition::into_inner

    source
    fn TrackPosition::into_inner(self : TrackPosition) -> DynSource

    TrackPosition::next

    source
    fn TrackPosition::next(self : TrackPosition) -> Double?

    TrackPosition::sample_rate

    source
    fn TrackPosition::sample_rate(self : TrackPosition) -> Int

    TrackPosition::total_duration

    source

    TrackPosition::try_seek

    source

    TriangleWave

    source
    pub struct TriangleWave {
      inner : SignalGenerator
    }

    TriangleWave::channels

    source
    fn TriangleWave::channels(self : TriangleWave) -> Int

    TriangleWave::current_span_len

    source
    fn TriangleWave::current_span_len(_self : TriangleWave) -> Int?

    TriangleWave::new

    source
    fn TriangleWave::new(freq : Double) -> TriangleWave

    TriangleWave::next

    source
    fn TriangleWave::next(self : TriangleWave) -> Double?

    TriangleWave::sample_rate

    source
    fn TriangleWave::sample_rate(self : TriangleWave) -> Int

    TriangleWave::total_duration

    source

    TriangleWave::try_seek

    source

    UniformSourceIterator

    source
    pub struct UniformSourceIterator {
      input : DynSource
      target_channels : Int
      target_sample_rate : Int
      total_duration : 
    Duration    ?
    }

    UniformSourceIterator::channels

    source
    fn UniformSourceIterator::channels(self : UniformSourceIterator) -> Int

    UniformSourceIterator::current_span_len

    source
    fn UniformSourceIterator::current_span_len(_self : UniformSourceIterator) -> Int?

    UniformSourceIterator::inner_mut

    source

    UniformSourceIterator::new

    source
    fn[S : Source] UniformSourceIterator::new(source : S, target_channels : Int, target_sample_rate : Int) -> UniformSourceIterator

    UniformSourceIterator::next

    source
    fn UniformSourceIterator::next(self : UniformSourceIterator) -> Double?

    UniformSourceIterator::sample_rate

    source
    fn UniformSourceIterator::sample_rate(self : UniformSourceIterator) -> Int

    UniformSourceIterator::total_duration

    source

    UniformSourceIterator::try_seek

    source

    Velvet

    source
    pub struct Velvet {
      sample_rate : Int
      rng : NoiseRngState
      grid_size : 
    Ref    [Double]
      grid_pos : 
    Ref    [Double]
      impulse_pos : 
    Ref    [Double]
    }

    impl Source for Velvet

    Velvet::channels

    source
    fn Velvet::channels(_self : Velvet) -> Int

    Velvet::current_span_len

    source
    fn Velvet::current_span_len(_self : Velvet) -> Int?

    Velvet::new

    source
    fn Velvet::new(sample_rate : Int) -> Velvet

    Velvet::new_with_density

    source
    fn Velvet::new_with_density(sample_rate : Int, density : Double) -> Velvet

    Velvet::new_with_density_and_rng

    source
    fn[R : NoiseRng] Velvet::new_with_density_and_rng(sample_rate : Int, density : Double, rng : R) -> Velvet

    Velvet::new_with_density_and_seed

    source
    fn Velvet::new_with_density_and_seed(sample_rate : Int, density : Double, seed : UInt64) -> Velvet

    Velvet::new_with_rng

    source
    fn[R : NoiseRng] Velvet::new_with_rng(sample_rate : Int, rng : R) -> Velvet

    Velvet::new_with_seed

    source
    fn Velvet::new_with_seed(sample_rate : Int, seed : UInt64) -> Velvet

    Velvet::next

    source
    fn Velvet::next(self : Velvet) -> Double?

    Velvet::sample_rate

    source
    fn Velvet::sample_rate(self : Velvet) -> Int

    Velvet::total_duration

    source

    Velvet::try_seek

    source
    fn Velvet::try_seek(_self : Velvet, _pos : 
    Duration    ) -> Unit raise SeekError

    Violet

    source
    pub struct Violet {
      sample_rate : Int
      blue_noise : Blue
      prev : 
    Ref    [Double]
    }

    impl Source for Violet

    Violet::channels

    source
    fn Violet::channels(_self : Violet) -> Int

    Violet::current_span_len

    source
    fn Violet::current_span_len(_self : Violet) -> Int?

    Violet::new

    source
    fn Violet::new(sample_rate : Int) -> Violet

    Violet::new_with_rng

    source
    fn[R : NoiseRng] Violet::new_with_rng(sample_rate : Int, rng : R) -> Violet

    Violet::new_with_seed

    source
    fn Violet::new_with_seed(sample_rate : Int, seed : UInt64) -> Violet

    Violet::next

    source
    fn Violet::next(self : Violet) -> Double?

    Violet::sample_rate

    source
    fn Violet::sample_rate(self : Violet) -> Int

    Violet::total_duration

    source

    Violet::try_seek

    source
    fn Violet::try_seek(_self : Violet, _pos : 
    Duration    ) -> Unit raise SeekError

    WhiteGaussian

    source
    pub struct WhiteGaussian {
      sample_rate : Int
      rng : NoiseRngState
    }

    WhiteGaussian::channels

    source
    fn WhiteGaussian::channels(_self : WhiteGaussian) -> Int

    WhiteGaussian::current_span_len

    source
    fn WhiteGaussian::current_span_len(_self : WhiteGaussian) -> Int?

    WhiteGaussian::mean

    source
    fn WhiteGaussian::mean(_self : WhiteGaussian) -> Double

    WhiteGaussian::new

    source
    fn WhiteGaussian::new(sample_rate : Int) -> WhiteGaussian

    WhiteGaussian::new_with_rng

    source
    fn[R : NoiseRng] WhiteGaussian::new_with_rng(sample_rate : Int, rng : R) -> WhiteGaussian

    WhiteGaussian::new_with_seed

    source
    fn WhiteGaussian::new_with_seed(sample_rate : Int, seed : UInt64) -> WhiteGaussian

    WhiteGaussian::next

    source
    fn WhiteGaussian::next(self : WhiteGaussian) -> Double?

    WhiteGaussian::sample_rate

    source
    fn WhiteGaussian::sample_rate(self : WhiteGaussian) -> Int

    WhiteGaussian::std_dev

    source
    fn WhiteGaussian::std_dev(_self : WhiteGaussian) -> Double

    WhiteGaussian::total_duration

    source

    WhiteGaussian::try_seek

    source

    WhiteTriangular

    source
    pub struct WhiteTriangular {
      sample_rate : Int
      rng : NoiseRngState
    }

    WhiteTriangular::channels

    source
    fn WhiteTriangular::channels(_self : WhiteTriangular) -> Int

    WhiteTriangular::current_span_len

    source
    fn WhiteTriangular::current_span_len(_self : WhiteTriangular) -> Int?

    WhiteTriangular::new

    source
    fn WhiteTriangular::new(sample_rate : Int) -> WhiteTriangular

    WhiteTriangular::new_with_rng

    source
    fn[R : NoiseRng] WhiteTriangular::new_with_rng(sample_rate : Int, rng : R) -> WhiteTriangular

    WhiteTriangular::new_with_seed

    source
    fn WhiteTriangular::new_with_seed(sample_rate : Int, seed : UInt64) -> WhiteTriangular

    WhiteTriangular::next

    source
    fn WhiteTriangular::next(self : WhiteTriangular) -> Double?

    WhiteTriangular::sample_rate

    source
    fn WhiteTriangular::sample_rate(self : WhiteTriangular) -> Int

    WhiteTriangular::std_dev

    source
    fn WhiteTriangular::std_dev(_self : WhiteTriangular) -> Double

    WhiteTriangular::total_duration

    source

    WhiteTriangular::try_seek

    source

    WhiteUniform

    source
    pub struct WhiteUniform {
      sample_rate : Int
      rng : NoiseRngState
    }

    WhiteUniform::channels

    source
    fn WhiteUniform::channels(_self : WhiteUniform) -> Int

    WhiteUniform::current_span_len

    source
    fn WhiteUniform::current_span_len(_self : WhiteUniform) -> Int?

    WhiteUniform::new

    source
    fn WhiteUniform::new(sample_rate : Int) -> WhiteUniform

    WhiteUniform::new_with_rng

    source
    fn[R : NoiseRng] WhiteUniform::new_with_rng(sample_rate : Int, rng : R) -> WhiteUniform

    WhiteUniform::new_with_seed

    source
    fn WhiteUniform::new_with_seed(sample_rate : Int, seed : UInt64) -> WhiteUniform

    WhiteUniform::next

    source
    fn WhiteUniform::next(self : WhiteUniform) -> Double?

    WhiteUniform::sample_rate

    source
    fn WhiteUniform::sample_rate(self : WhiteUniform) -> Int

    WhiteUniform::std_dev

    source
    fn WhiteUniform::std_dev(_self : WhiteUniform) -> Double

    WhiteUniform::total_duration

    source

    WhiteUniform::try_seek

    source

    Zero

    source
    pub struct Zero {
      inner : DynSource
    }

    impl Source for Zero

    Zero::channels

    source
    fn Zero::channels(self : Zero) -> Int

    Zero::current_span_len

    source
    fn Zero::current_span_len(_self : Zero) -> Int?

    Zero::inner

    source
    fn Zero::inner(self : Zero) -> DynSource

    Zero::inner_mut

    source
    fn Zero::inner_mut(self : Zero) -> DynSource

    Zero::into_inner

    source
    fn Zero::into_inner(self : Zero) -> DynSource

    Zero::new

    source
    fn Zero::new(channels : Int, sample_rate : Int) -> Zero

    Zero::new_samples

    source
    fn Zero::new_samples(channels : Int, sample_rate : Int, num_samples : Int) -> Zero

    Zero::next

    source
    fn Zero::next(self : Zero) -> Double?

    Zero::sample_rate

    source
    fn Zero::sample_rate(self : Zero) -> Int

    Zero::total_duration

    source
    fn Zero::total_duration(_self : Zero) -> 
    Duration    ?

    Zero::try_seek

    source
    fn Zero::try_seek(_self : Zero, pos : 
    Duration    ) -> Unit raise SeekError

    amplify

    source
    fn[S : Source] amplify(source : S, factor : Double) -> DynSource

    amplify_decibel

    source
    fn[S : Source] amplify_decibel(source : S, value : Double) -> DynSource

    amplify_normalized

    source
    fn[S : Source] amplify_normalized(source : S, value : Double) -> DynSource

    automatic_gain_control

    source
    fn[S : Source] automatic_gain_control(source : S, settings : AutomaticGainControlSettings) -> AutomaticGainControl

    automatic_gain_control_with_params

    source
    fn[S : Source] automatic_gain_control_with_params(source : S, target_level : Double, attack_time : 
    Duration    , release_time : 
    Duration    , absolute_max_gain : Double) -> AutomaticGainControl

    available_inputs

    source
    fn available_inputs() -> Array[Input] raise MicrophoneListError

    available_outputs

    source
    fn available_outputs() -> Array[Output] raise SpeakersListError

    buffer_from_iter

    source
    fn buffer_from_iter(channels : Int, sample_rate : Int, samples : Array[Double]) -> SamplesBuffer

    buffered

    source
    fn[S : Source] buffered(source : S) -> SamplesBuffer

    channel_volume

    source
    fn[S : Source] channel_volume(source : S, channel_factors : Array[Double]) -> DynSource

    chirp

    source
    fn chirp(sample_rate : Int, start_frequency : Double, end_frequency : Double, duration : 
    Duration    ) -> Chirp

    convert_channels

    source
    fn[S : Source] convert_channels(source : S, target_channels : Int) -> DynSource

    convert_sample_rate

    source
    fn[S : Source] convert_sample_rate(source : S, target_sample_rate : Int) -> DynSource

    crossfade

    source
    fn[A : Source, B : Source] crossfade(left : A, right : B, duration : 
    Duration    ) -> DynSource

    db_to_linear

    source
    fn db_to_linear(decibels : Double) -> Double

    delay

    source
    fn[S : Source] delay(source : S, duration : 
    Duration    ) -> DynSource

    distortion

    source
    fn[S : Source] distortion(source : S, gain : Double, threshold : Double) -> DynSource

    distortion_threshold

    source
    fn[S : Source] distortion_threshold(source : S, threshold : Double) -> DynSource

    distortion_with_gain

    source
    fn[S : Source] distortion_with_gain(source : S, gain : Double, threshold : Double) -> DynSource

    dither

    source
    fn[S : Source] dither(source : S, target_bits : BitDepth, algorithm : DitherAlgorithm) -> Dither

    empty

    source
    fn empty(channels : Int, sample_rate : Int) -> DynSource

    fade_in

    source
    fn[S : Source] fade_in(source : S, duration : 
    Duration    ) -> DynSource

    fade_out

    source
    fn[S : Source] fade_out(source : S, duration : 
    Duration    ) -> DynSource

    fadein

    source
    fn[S : Source] fadein(source : S, duration : 
    Duration    ) -> DynSource

    fadeout

    source
    fn[S : Source] fadeout(source : S, duration : 
    Duration    ) -> DynSource

    from_factory

    source
    fn[S : Source] from_factory(factory : () -> S?) -> FromFactoryIter[S]

    from_iter

    source
    fn[S : Source] from_iter(sources : Array[S]) -> FromIter

    high_pass

    source
    fn[S : Source] high_pass(source : S, freq : Int) -> BltFilter

    high_pass_with_q

    source
    fn[S : Source] high_pass_with_q(source : S, freq : Int, q : Double) -> BltFilter

    is_exhausted

    source
    fn[S : Source] is_exhausted(source : S) -> Bool

    lerp

    source
    fn lerp(first : Double, second : Double, numerator : Int, denominator : Int) -> Double

    limit

    source
    fn[S : Source] limit(source : S, settings : LimitSettings) -> DynSource

    limit_range

    source
    fn[S : Source] limit_range(source : S, min_value : Double, max_value : Double) -> DynSource

    linear_gain_ramp

    source
    fn[S : Source] linear_gain_ramp(source : S, start_gain : Double, end_gain : Double, duration : 
    Duration    ) -> DynSource

    linear_gain_ramp_with_clamp

    source
    fn[S : Source] linear_gain_ramp_with_clamp(source : S, start_gain : Double, end_gain : Double, duration : 
    Duration    , clamp_end : Bool) -> DynSource

    linear_to_db

    source
    fn linear_to_db(linear : Double) -> Double

    low_pass

    source
    fn[S : Source] low_pass(source : S, freq : Int) -> BltFilter

    low_pass_with_q

    source
    fn[S : Source] low_pass_with_q(source : S, freq : Int, q : Double) -> BltFilter

    mix

    source
    fn[A : Source, B : Source] mix(left : A, right : B) -> DynSource

    mixer

    source
    fn mixer(channels : Int, sample_rate : Int) -> (Mixer, MixerSource)

    output_to_wav

    source
    fn[S : Source] output_to_wav(source : S, wav_file : StringView) -> Unit raise ToWavError

    pausable

    source
    fn[S : Source] pausable(source : S, paused : Bool) -> Pausable

    periodic

    source
    fn[S : Source] periodic(source : S, period : 
    Duration    , callback : () -> Unit) -> PeriodicAccess

    periodic_access

    source
    fn[S : Source] periodic_access(source : S, every_samples : Int, callback : () -> Unit) -> PeriodicAccess

    periodic_access_with_source

    source
    fn[S : Source] periodic_access_with_source(source : S, every_samples : Int, callback : (DynSource) -> Unit) -> PeriodicAccess

    periodic_with_source

    source
    fn[S : Source] periodic_with_source(source : S, period : 
    Duration    , callback : (DynSource) -> Unit) -> PeriodicAccess

    pink

    source
    fn pink(sample_rate : Int) -> Pink

    play

    source
    fn play(mixer : Mixer, reader : Reader) -> Player raise PlayError

    play_bytes

    source
    fn play_bytes(mixer : Mixer, bytes : Bytes) -> Player raise PlayError

    play_file

    source
    fn play_file(mixer : Mixer, path : StringView) -> Player raise PlayError

    play_reader

    source
    fn play_reader(mixer : Mixer, reader : Reader) -> Player raise PlayError

    queue

    source
    fn queue(keep_alive_if_empty : Bool) -> (SourcesQueueInput, SourcesQueueOutput)

    record

    source
    fn[S : Source] record(source : S) -> SamplesBuffer

    repeat

    source
    fn[S : Source] repeat(source : S) -> DynSource

    repeat_infinite

    source
    fn[S : Source] repeat_infinite(source : S) -> DynSource

    reverb

    source
    fn[S : Source] reverb(source : S, duration : 
    Duration    , amplitude : Double) -> DynSource

    skip_duration

    source
    fn[S : Source] skip_duration(source : S, duration : 
    Duration    ) -> DynSource

    skippable

    source
    fn[S : Source] skippable(source : S) -> Skippable

    speed

    source
    fn[S : Source] speed(source : S, ratio : Double) -> DynSource

    stoppable

    source
    fn[S : Source] stoppable(source : S) -> Stoppable

    supported_output_configs

    source

    take

    source
    fn[S : Source] take(source : S, sample_count : Int) -> DynSource

    take_crossfade_with

    source
    fn[A : Source, B : Source] take_crossfade_with(left : A, right : B, duration : 
    Duration    ) -> DynSource

    take_duration

    source
    fn[S : Source] take_duration(source : S, duration : 
    Duration    ) -> DynSource

    to_dyn

    source
    fn[S : Source] to_dyn(source : S) -> DynSource

    track_position

    source
    fn[S : Source] track_position(source : S) -> TrackPosition

    uniform

    source
    fn[S : Source] uniform(source : S, target_channels : Int, target_sample_rate : Int) -> DynSource

    wav_to_file

    source
    fn[S : Source] wav_to_file(source : S, wav_file : StringView) -> Unit raise ToWavError

    wav_to_writer

    source
    fn[S : Source, W : WavWriter] wav_to_writer(source : S, writer : W) -> Unit raise ToWavError

    white

    source
    fn white(sample_rate : Int) -> WhiteUniform

    zero

    source
    fn zero(channels : Int, sample_rate : Int) -> DynSource

    zero_samples

    source
    fn zero_samples(channels : Int, sample_rate : Int, sample_count : Int) -> DynSource

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io