🥮 mooncakes.io

moon_rodio

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

audio
moon add Milky2018/moon_rodio@0.3.4
Download zip
Author
Version
0.3.4
License
Apache-2.0
Repository
Last updated
12 days ago
Downloads
6K

Dependencies

README

#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)

#
DecoderError

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

#
MicrophoneError

source

#
MicrophoneListError

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

#
PlayError

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

impl Show for PlayError

#
SeekError

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

impl Show for SeekError

#
SeekError::source_intact

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

#
SpeakersError

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

#
SpeakersListError

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

#
SpeakersPlayError

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

#
StreamError

source

impl Show for StreamError

#
ToWavError

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

impl Show for ToWavError

#
Amplify

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

impl Source for Amplify

#
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::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

#
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::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

#
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::get

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

#
BitDepth::new

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

#
BltFilter

source

impl Source for BltFilter

#
BltFilter::channels

source
fn BltFilter::channels(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

#
BltMode

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

impl Show for BltMode

#
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::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

#
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::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

#
Buffered

source
pub struct Buffered {
  inner : SamplesBuffer
}

impl Source for Buffered

#
Buffered::channels

source
fn Buffered::channels(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

#
ChannelCountConverter

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

#
ChannelCountConverter::inner_mut

source

#
ChannelCountConverter::into_inner

source

#
ChannelCountConverter::new

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

#
ChannelVolume

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

#
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::set_volume

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

#
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::next

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

#
Chirp::sample_rate

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

#
ControlledQueueSource

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

#
ControlledQueueSource::channels

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

#
ControlledQueueSource::next

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

#
ControlledQueueSource::sample_rate

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

#
Crossfade

source
pub struct Crossfade {
  inner : DynSource
}

impl Source for Crossfade

#
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

#
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::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::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

#
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)

#
Delay

source
pub struct Delay {
  inner : DynSource
}

impl Source for Delay

#
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

#
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::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::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::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::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

#
DitherAlgorithm

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

#
DitherAlgorithm::gpdf

source

#
DitherAlgorithm::high_pass

source
fn DitherAlgorithm::high_pass() -> DitherAlgorithm

#
DitherAlgorithm::rpdf

source

#
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::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

#
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::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

#
EmptyCallback

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

#
EmptyCallback::channels

source
fn EmptyCallback::channels(_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

#
FadeIn

source
pub struct FadeIn {
  inner : DynSource
}

impl Source for FadeIn

#
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

#
FadeOut

source
pub struct FadeOut {
  inner : DynSource
}

impl Source for FadeOut

#
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

#
FixedSamplesBuffer

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

#
FixedSamplesBuffer::new

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

#
FixedSourceAdapter

source
pub struct FixedSourceAdapter {
  inner : DynSource
}

#
FixedSourceAdapter::channels

source
fn FixedSourceAdapter::channels(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

#
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::next

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

#
FromFactoryIter::sample_rate

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

#
FromIter

source

impl Source for FromIter

#
FromIter::channels

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

#
FromIter::next

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

#
FromIter::sample_rate

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

#
Function

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

impl Show for Function

#
Function::sawtooth

source
fn Function::sawtooth() -> Function

#
Function::sine

source
fn Function::sine() -> Function

#
Function::square

source
fn Function::square() -> Function

#
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::from_supported

source

#
InputConfig::new

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

#
InputConfig::stream_config

source

#
InputConfig::supported_given

source

#
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::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

#
LimitMono

source
pub struct LimitMono {
  inner : Limit
}

impl Source for LimitMono

#
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

#
LimitMulti

source
pub struct LimitMulti {
  inner : Limit
}

#
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

#
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::gaming

source

#
LimitSettings::live_performance

source
fn LimitSettings::live_performance() -> LimitSettings

#
LimitSettings::mastering

source
fn LimitSettings::mastering() -> LimitSettings

#
LimitSettings::new

source

#
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::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

#
LinearGainRamp

source
pub struct LinearGainRamp {
  inner : DynSource
}

#
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

#
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::next

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

#
LoopedDecoder::sample_rate

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

#
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::config

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

#
Microphone::next

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

#
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::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

#
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::next

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

#
MixerSource::sample_rate

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

#
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::from_supported

source

#
OutputConfig::new

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

#
OutputConfig::supported_given

source

#
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::sample_format

source

#
OutputStreamConfig::sample_rate

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

#
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::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

#
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::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

#
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::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

#
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::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

#
Repeat

source
pub struct Repeat {
  inner : DynSource
}

impl Source for Repeat

#
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

#
SampleRateConverter

source
pub struct SampleRateConverter {
  inner : DynSource
  to : Int
  channels : 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

#
SampleTypeConverter

source
pub struct SampleTypeConverter {
  inner : DynSource
}

#
SampleTypeConverter::inner_mut

source

#
SampleTypeConverter::into_inner

source

#
SampleTypeConverter::new

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::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

#
SawtoothWave

source
pub struct SawtoothWave {
  inner : SignalGenerator
}

#
SawtoothWave::channels

source
fn SawtoothWave::channels(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

#
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

#
SignalFunction

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

#
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::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::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::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

#
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::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

#
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::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

#
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::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

#
Spatial

source
pub struct Spatial {
  inner : SpatialSource
}

impl Source for Spatial

#
Spatial::channels

source
fn Spatial::channels(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

#
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::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

#
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::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::set_factor

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

#
SquareWave

source
pub struct SquareWave {
  inner : SignalGenerator
}

#
SquareWave::channels

source
fn SquareWave::channels(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

#
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::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

#
Stoppable

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

impl Source for Stoppable

#
Stoppable::channels

source
fn Stoppable::channels(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

#
TakeDuration

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

#
TakeDuration::clear_filter

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

#
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::set_filter_fadeout

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

#
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::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

#
TriangleWave

source
pub struct TriangleWave {
  inner : SignalGenerator
}

#
TriangleWave::channels

source
fn TriangleWave::channels(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

#
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::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

#
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::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

#
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::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

#
WhiteGaussian

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

#
WhiteGaussian::channels

source
fn WhiteGaussian::channels(_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

#
WhiteTriangular

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

#
WhiteTriangular::channels

source
fn WhiteTriangular::channels(_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

#
WhiteUniform

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

#
WhiteUniform::channels

source
fn WhiteUniform::channels(_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

#
Zero

source
pub struct Zero {
  inner : DynSource
}

impl Source for Zero

#
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

#
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