🥮 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 modeled after Rust rodio. It provides stream/sink-based playback, source transforms, and built-in decoding for common audio formats.

#Target and scope

  • Preferred target: native
  • Output/input backend: Milky2018/moon_cpal
  • API alignment follows Rust rodio where it makes sense in MoonBit
  • Rust-specific lifetime/drop semantics are intentionally simplified

#Installation

Add the dependency to moon.mod.json:

{
  "deps": {
    "Milky2018/moon_rodio": "0.2.0"
  },
  "preferred-target": "native"
}

#What is included

#Milky2018/moon_rodio

The main package includes:

  • playback primitives such as OutputStreamBuilder, Mixer, Sink, and Player
  • Source helpers and effects such as speed, gain, delay, fades, filters, queueing, repetition, spatial helpers, and WAV output helpers
  • high-level decoding through Decoder and DecoderBuilder
  • convenience helpers such as play_file, play_bytes, and play_reader

#Milky2018/moon_rodio/decoder

The decoder subpackage exposes lower-level decoding helpers such as:

  • decode_wav_bytes
  • decode_mp3_bytes
  • decode_flac_bytes
  • decode_vorbis_bytes
  • decode_mp4a_bytes

Most users should start with Milky2018/moon_rodio and use Decoder.

#Supported formats

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

Backend notes:

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

#Platform notes for MP4A / AAC

On macOS, MP4A works through the system AudioToolbox framework.

On Linux and Windows, MP4A requires FFmpeg development libraries to be available to native builds. build.js tries to discover them automatically, and you can also provide them explicitly:

  • MOON_RODIO_FFMPEG_CFLAGS
  • MOON_RODIO_FFMPEG_LIBS
  • MOON_RODIO_ENABLE_FFMPEG=1

Example:

MOON_RODIO_FFMPEG_CFLAGS="-I/path/to/include" \
MOON_RODIO_FFMPEG_LIBS="-L/path/to/lib -lavformat -lavcodec -lavutil -lswresample" \
MOON_RODIO_ENABLE_FFMPEG=1 \
moon run cmd/main --target native

#Quick start

Play a file from disk:

import "Milky2018/moon_rodio"

fn play_file_example(path : String) -> Unit {
  let stream = try {
    OutputStreamBuilder::open_default_stream()
  } catch {
    _ => return
  } noraise {
    stream => stream
  }

  let player = try {
    play_file(stream.mixer(), path)
  } catch {
    _ => return
  } noraise {
    player => player
  }

  player.sleep_until_end()
}

Decode audio from bytes:

import "Milky2018/moon_rodio"

fn decode_bytes_example(bytes : Bytes) -> Unit {
  let decoder = try {
    Decoder::builder()
      .with_data(bytes)
      .with_hint("mp3")
      .with_seekable(true)
      .build()
  } catch {
    _ => return
  } noraise {
    decoder => decoder
  }

  println(decoder.channels().to_string())
  println(decoder.sample_rate().to_string())
}

Play generated samples:

import "Milky2018/moon_rodio"

fn play_sine_like_example() -> Unit {
  let stream = try {
    OutputStreamBuilder::open_default_stream()
  } catch {
    _ => return
  } noraise {
    stream => stream
  }

  let sink = Sink::connect_new(stream.mixer())
  let source = SamplesBuffer::new(1, 44_100, [0.0, 0.2, 0.0, -0.2])
  sink.append(source.repeat_infinite())
}

#
ChannelCount

source
type ChannelCount = Int

#
Sample

source
type Sample = Double

#
SampleRate

source
type SampleRate = Int

#
FixedSource

source
pub(open) trait FixedSource {
  next(Self) -> Double?
  channels(Self) -> Int
  sample_rate(Self) -> Int
  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 {
  next_u64(Self) -> UInt64
}

#
Source

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

#
WavWriter

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

impl WavWriter for Buffer

#
BitDepthError

source
pub suberror BitDepthError {
  OutOfRange(Int)
}

impl Eq for BitDepthError

#
DecoderError

source
pub suberror DecoderError {
  Backend(
DecoderError)
  UnrecognizedFormat
}

impl Eq for DecoderError

#
MicrophoneError

source
pub suberror MicrophoneError {
  NoDevice
  NoConfig
  DefaultInputConfigError(
DefaultStreamConfigError)
  SupportedInputConfigsError(
SupportedStreamConfigsError)
  UnsupportedByDevice
  BuildStreamError(
BuildStreamError)
  PlayStreamError(
PlayStreamError)
  UnsupportedSampleFormat
}

#
MicrophoneListError

source
pub suberror MicrophoneListError {
  DevicesError(
DevicesError)
}

#
PlayError

source
pub suberror PlayError {
  DecoderError(DecoderError)
}

impl Eq for PlayError
impl Show for PlayError

#
SeekError

source
pub suberror SeekError {
  NotSupported
}

impl Eq for SeekError
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)
}

impl Eq for SpeakersError

#
SpeakersListError

source
pub suberror SpeakersListError {
  DevicesError(
DevicesError)
}

#
SpeakersPlayError

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

#
StreamError

source

impl Eq for StreamError
impl Show for StreamError

#
ToWavError

source
pub suberror ToWavError {
  OpenFile
  Creating
  Writing
  Finishing
  Flushing
}

impl Eq for ToWavError
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
fn AutomaticGainControl::get_agc_control(self : AutomaticGainControl) -> Ref[Bool]

#
AutomaticGainControl::get_attack_coeff

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

#
AutomaticGainControl::get_release_coeff

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

#
AutomaticGainControl::get_target_level

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

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

impl Eq for BitDepth
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
pub struct BltFilter {
  input : DynSource
  mode : Ref[BltMode]
  freq : Ref[Int]
  q : Ref[Double]
  b0 : Ref[Double]
  b1 : Ref[Double]
  b2 : Ref[Double]
  a1 : Ref[Double]
  a2 : Ref[Double]
  x1 : Ref[Double]
  x2 : Ref[Double]
  y1 : Ref[Double]
  y2 : Ref[Double]
}

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
}

impl Eq for BltMode
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

impl Eq for DecoderKind
impl Show for DecoderKind

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

#
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
pub struct FromIter {
  sources : Ref[Array[DynSource]]
  current : Ref[DynSource]
  has_current : Ref[Bool]
}

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
}

impl Eq for Function
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
}

impl Eq for InputConfig
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
}

impl Eq for LimitSettings

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

impl Eq for OutputConfig

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

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

impl Eq for Settings
impl Show for Settings

#
Settings::default

source
fn Settings::default() -> Settings

#
SignalFunction

source
pub enum SignalFunction {
  Sine
  Square
  Sawtooth
  Triangle
}

#
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
pub struct SinkControls {
  pause : Ref[Bool]
  stopped : Ref[Bool]
  to_clear : Ref[Int]
  volume : Ref[Double]
  speed : Ref[Double]
  sound_count : Ref[Int]
  position : Ref[
Duration]
}

#
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