🥮 mooncakes.io

    moonbit-community/moon_cpal/core does not have a README file

    ChannelCount

    source
    type ChannelCount = Int

    FrameCount

    source
    type FrameCount = Int

    SampleRate

    source
    type SampleRate = Int

    FromSample

    source
    pub trait FromSample : Sample {
      fn from_sample(Float) -> Self
    }

    impl FromSample for Byte
    impl FromSample for Int16
    impl FromSample for Float

    Sample

    source
    pub trait Sample {
      fn equilibrium() -> Self
      fn to_f32(Self) -> Float
      fn from_f32(Float) -> Self
    }

    impl Sample for Byte
    impl Sample for Int16
    impl Sample for UInt16
    impl Sample for Float
    impl Sample for Double

    SizedSample

    source
    pub trait SizedSample : Sample {
      fn format(Self) -> SampleFormat
    }

    impl SizedSample for Byte

    BuildStreamError

    source
    pub suberror BuildStreamError {
      DeviceNotAvailable
      DeviceBusy
      StreamConfigNotSupported
      InvalidArgument
      StreamIdOverflow
      BackendSpecific(BackendSpecificError)
    } derive(Eq, 
    Debug    )

    Error that can happen when creating a stream.

    BuildStreamError::equal

    source

    BuildStreamError::not_equal

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

    BuildStreamError::output

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

    BuildStreamError::to_repr

    source

    BuildStreamError::to_string

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

    DefaultStreamConfigError

    source
    pub suberror DefaultStreamConfigError {
      DeviceNotAvailable
      DeviceBusy
      StreamTypeNotSupported
      BackendSpecific(BackendSpecificError)
    } derive(Eq, 
    Debug    )

    May occur when attempting to request the default input or output stream config from a device.

    DefaultStreamConfigError::equal

    source

    DefaultStreamConfigError::not_equal

    source

    DefaultStreamConfigError::output

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

    DefaultStreamConfigError::to_repr

    source

    DefaultStreamConfigError::to_string

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

    DeviceIdError

    source
    pub suberror DeviceIdError {
      UnsupportedPlatform
      BackendSpecific(BackendSpecificError)
    } derive(Eq, 
    Debug    )

    DeviceIdError::equal

    source

    DeviceIdError::not_equal

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

    DeviceIdError::output

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

    DeviceIdError::to_repr

    source

    DeviceIdError::to_string

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

    DeviceNameError

    source
    pub suberror DeviceNameError {
      BackendSpecific(BackendSpecificError)
    } derive(Eq, 
    Debug    )

    An error that may occur while attempting to retrieve a device name.

    DeviceNameError::equal

    source

    DeviceNameError::not_equal

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

    DeviceNameError::output

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

    DeviceNameError::to_repr

    source

    DeviceNameError::to_string

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

    DevicesError

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

    An error that might occur while attempting to enumerate devices.

    DevicesError::equal

    source

    DevicesError::not_equal

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

    DevicesError::output

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

    DevicesError::to_repr

    source

    DevicesError::to_string

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

    HostUnavailable

    source
    pub suberror HostUnavailable {
      HostUnavailable
    } derive(Eq, 
    Debug    )

    HostUnavailable::equal

    source

    HostUnavailable::not_equal

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

    HostUnavailable::output

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

    HostUnavailable::to_repr

    source

    HostUnavailable::to_string

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

    PauseStreamError

    source
    pub suberror PauseStreamError {
      DeviceNotAvailable
      BackendSpecific(BackendSpecificError)
    } derive(Eq, 
    Debug    )

    PauseStreamError::equal

    source

    PauseStreamError::not_equal

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

    PauseStreamError::output

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

    PauseStreamError::to_repr

    source

    PauseStreamError::to_string

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

    PlayStreamError

    source
    pub suberror PlayStreamError {
      DeviceNotAvailable
      BackendSpecific(BackendSpecificError)
    } derive(Eq, 
    Debug    )

    PlayStreamError::equal

    source

    PlayStreamError::not_equal

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

    PlayStreamError::output

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

    PlayStreamError::to_repr

    source

    PlayStreamError::to_string

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

    StreamError

    source
    pub suberror StreamError {
      DeviceNotAvailable
      StreamInvalidated
      BufferUnderrun
      BackendSpecific(BackendSpecificError)
    } derive(Eq, 
    Debug    )

    impl Show for StreamError

    StreamError::equal

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

    StreamError::not_equal

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

    StreamError::output

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

    StreamError::to_repr

    source

    StreamError::to_string

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

    SupportedStreamConfigsError

    source
    pub suberror SupportedStreamConfigsError {
      DeviceNotAvailable
      DeviceBusy
      InvalidArgument
      BackendSpecific(BackendSpecificError)
    } derive(Eq, 
    Debug    )

    Error that can happen when enumerating the list of supported configs.

    SupportedStreamConfigsError::equal

    source

    SupportedStreamConfigsError::not_equal

    source

    SupportedStreamConfigsError::output

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

    SupportedStreamConfigsError::to_repr

    source

    SupportedStreamConfigsError::to_string

    source

    BackendSpecificError

    source
    pub struct BackendSpecificError {
      description : String
    } derive(Eq, 
    Debug    )

    BackendSpecificError::BackendSpecificError

    source
    fn BackendSpecificError::BackendSpecificError(description : String) -> BackendSpecificError

    BackendSpecificError::description

    source
    fn BackendSpecificError::description(self : BackendSpecificError) -> String

    BackendSpecificError::equal

    source

    BackendSpecificError::new

    source
    fn BackendSpecificError::new(description : String) -> BackendSpecificError

    BackendSpecificError::not_equal

    source

    BackendSpecificError::output

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

    BackendSpecificError::to_repr

    source

    BackendSpecificError::to_string

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

    BufferSize

    source
    pub enum BufferSize {
      Default
      Fixed(Int)
    } derive(Eq, 
    Debug    )

    The buffer size requests the callback size for audio streams.

    Mirrors upstream cpal::BufferSize:
    • Default uses the host's default callback size.
    • Fixed(n) requests approximately n frames per callback.

    The actual callback size depends on the backend/host implementation and may differ from or vary around the requested size.
    impl Show for BufferSize

    BufferSize::default

    source
    fn BufferSize::default() -> BufferSize

    BufferSize::equal

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

    BufferSize::fixed

    source
    fn BufferSize::fixed(n : Int) -> BufferSize

    BufferSize::not_equal

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

    BufferSize::output

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

    BufferSize::to_repr

    source

    BufferSize::to_string

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

    Data

    source
    pub struct Data {
      sample_format : SampleFormat
      bytes : FixedArray[Byte]
    } derive(Eq, 
    Debug    )

    impl Show for Data

    Data::Data

    source
    fn Data::Data(sample_format : SampleFormat, bytes : FixedArray[Byte]) -> Data

    Data::bytes

    source
    fn Data::bytes(self : Data) -> FixedArray[Byte]

    Data::clear

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

    Fill the underlying buffer with the sample-format equilibrium value (silence).

    Data::equal

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

    Data::len

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

    Number of samples in the buffer (floor if the byte length is not aligned to the sample size).

    Data::new

    source
    fn Data::new(sample_format : SampleFormat, bytes : FixedArray[Byte]) -> Data

    Data::not_equal

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

    Data::output

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

    Data::sample_format

    source
    fn Data::sample_format(self : Data) -> SampleFormat

    Data::to_repr

    source

    Data::to_string

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

    Data::try_as_f32

    source
    fn Data::try_as_f32(self : Data) -> Array[Float]?

    Data::try_as_f64

    source
    fn Data::try_as_f64(self : Data) -> Array[Double]?

    Data::try_as_i16

    source
    fn Data::try_as_i16(self : Data) -> Array[Int16]?

    Data::try_as_i24

    source
    fn Data::try_as_i24(self : Data) -> Array[I24]?

    Data::try_as_i32

    source
    fn Data::try_as_i32(self : Data) -> Array[Int]?

    Data::try_as_i64

    source
    fn Data::try_as_i64(self : Data) -> Array[Int64]?

    Data::try_as_i8

    source
    fn Data::try_as_i8(self : Data) -> Array[Int]?

    Data::try_as_u16

    source
    fn Data::try_as_u16(self : Data) -> Array[UInt16]?

    Data::try_as_u24

    source
    fn Data::try_as_u24(self : Data) -> Array[U24]?

    Data::try_as_u32

    source
    fn Data::try_as_u32(self : Data) -> Array[UInt]?

    Data::try_as_u64

    source
    fn Data::try_as_u64(self : Data) -> Array[UInt64]?

    Data::try_as_u8

    source
    fn Data::try_as_u8(self : Data) -> Array[Byte]?

    Data::write_f32

    source
    fn Data::write_f32(self : Data, samples : Array[Float]) -> Bool

    Best-effort encoder for F32 (IEEE-754, little-endian) output buffers.

    Data::write_f64

    source
    fn Data::write_f64(self : Data, samples : Array[Double]) -> Bool

    Best-effort encoder for F64 (IEEE-754, little-endian).

    Data::write_i16

    source
    fn Data::write_i16(self : Data, samples : Array[Int16]) -> Bool

    Best-effort encoder for I16 (little-endian) output buffers.

    Data::write_i24

    source
    fn Data::write_i24(self : Data, samples : Array[I24]) -> Bool

    Best-effort encoder for I24 (little-endian, stored in the low 24 bits of a 32-bit word).

    Data::write_i32

    source
    fn Data::write_i32(self : Data, samples : Array[Int]) -> Bool

    Best-effort encoder for I32 (little-endian).

    Data::write_i64

    source
    fn Data::write_i64(self : Data, samples : Array[Int64]) -> Bool

    Best-effort encoder for I64 (little-endian).

    Data::write_i8

    source
    fn Data::write_i8(self : Data, samples : Array[Int]) -> Bool

    Best-effort encoder for I8 output buffers.

    Data::write_u16

    source
    fn Data::write_u16(self : Data, samples : Array[UInt16]) -> Bool

    Best-effort encoder for U16 (little-endian) output buffers.

    Data::write_u24

    source
    fn Data::write_u24(self : Data, samples : Array[U24]) -> Bool

    Best-effort encoder for U24 (little-endian, stored in the low 24 bits of a 32-bit word).

    Data::write_u32

    source
    fn Data::write_u32(self : Data, samples : Array[UInt]) -> Bool

    Best-effort encoder for U32 (little-endian).

    Data::write_u64

    source
    fn Data::write_u64(self : Data, samples : Array[UInt64]) -> Bool

    Best-effort encoder for U64 (little-endian).

    Data::write_u8

    source
    fn Data::write_u8(self : Data, samples : Array[Byte]) -> Bool

    Best-effort encoder for U8 output buffers.

    DeviceDescription

    source
    pub struct DeviceDescription {
      name : String
      manufacturer : String?
      driver : String?
      device_type : DeviceType
      interface_type : InterfaceType
      direction : DeviceDirection
      address : String?
      extended : Array[String]
    } derive(Eq, 
    Debug    )

    DeviceDescription::DeviceDescription

    source
    fn DeviceDescription::DeviceDescription(name : String, manufacturer? : String?, driver? : String?, device_type? : DeviceType, interface_type? : InterfaceType, direction? : DeviceDirection, address? : String?, extended? : Array[String]) -> DeviceDescription

    DeviceDescription::address

    source
    fn DeviceDescription::address(self : DeviceDescription) -> String?

    DeviceDescription::device_type

    source

    DeviceDescription::direction

    source

    DeviceDescription::driver

    source
    fn DeviceDescription::driver(self : DeviceDescription) -> String?

    DeviceDescription::equal

    source

    DeviceDescription::extended

    source
    fn DeviceDescription::extended(self : DeviceDescription) -> Array[String]

    DeviceDescription::interface_type

    source
    fn DeviceDescription::interface_type(self : DeviceDescription) -> InterfaceType

    DeviceDescription::manufacturer

    source
    fn DeviceDescription::manufacturer(self : DeviceDescription) -> String?

    DeviceDescription::name

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

    DeviceDescription::new

    source
    fn DeviceDescription::new(name : String, manufacturer? : String?, driver? : String?, device_type? : DeviceType, interface_type? : InterfaceType, direction? : DeviceDirection, address? : String?, extended? : Array[String]) -> DeviceDescription

    DeviceDescription::not_equal

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

    DeviceDescription::output

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

    DeviceDescription::supports_input

    source
    fn DeviceDescription::supports_input(self : DeviceDescription) -> Bool

    DeviceDescription::supports_output

    source
    fn DeviceDescription::supports_output(self : DeviceDescription) -> Bool

    DeviceDescription::to_repr

    source

    DeviceDescription::to_string

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

    DeviceDescriptionBuilder

    source
    pub struct DeviceDescriptionBuilder {
      name : String
      manufacturer : String?
      driver : String?
      device_type : DeviceType
      interface_type : InterfaceType
      direction : DeviceDirection
      address : String?
      extended : Array[String]
    } derive(Eq, 
    Debug    )

    Builder for constructing a DeviceDescription.

    This is primarily intended for backend implementations to gradually build up descriptions with whatever metadata is available.

    DeviceDescriptionBuilder::DeviceDescriptionBuilder

    source
    fn DeviceDescriptionBuilder::DeviceDescriptionBuilder(name : String) -> DeviceDescriptionBuilder

    DeviceDescriptionBuilder::add_extended_line

    source
    fn DeviceDescriptionBuilder::add_extended_line(self : DeviceDescriptionBuilder, line : String) -> DeviceDescriptionBuilder

    DeviceDescriptionBuilder::address

    source

    DeviceDescriptionBuilder::build

    source

    DeviceDescriptionBuilder::device_type

    source

    DeviceDescriptionBuilder::direction

    source

    DeviceDescriptionBuilder::driver

    source

    DeviceDescriptionBuilder::equal

    source

    DeviceDescriptionBuilder::extended

    source

    DeviceDescriptionBuilder::interface_type

    source

    DeviceDescriptionBuilder::manufacturer

    source
    fn DeviceDescriptionBuilder::manufacturer(self : DeviceDescriptionBuilder, manufacturer : String) -> DeviceDescriptionBuilder

    DeviceDescriptionBuilder::new

    source

    DeviceDescriptionBuilder::not_equal

    source

    DeviceDescriptionBuilder::output

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

    DeviceDescriptionBuilder::to_repr

    source

    DeviceDescriptionBuilder::to_string

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

    DeviceDirection

    source
    pub enum DeviceDirection {
      Input
      Output
      Duplex
      Unknown
    } derive(Eq, 
    Debug    )

    DeviceDirection::duplex

    source

    DeviceDirection::equal

    source

    DeviceDirection::input

    source

    DeviceDirection::not_equal

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

    DeviceDirection::output

    source

    DeviceDirection::to_repr

    source

    DeviceDirection::to_string

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

    DeviceDirection::unknown

    source

    DeviceId

    source
    pub struct DeviceId {
      host_id : HostId
      device_id : String
    } derive(Eq, 
    Debug    )

    impl Show for DeviceId

    DeviceId::DeviceId

    source
    fn DeviceId::DeviceId(host_id : HostId, device_id : String) -> DeviceId

    DeviceId::device_id

    source
    fn DeviceId::device_id(self : DeviceId) -> String

    DeviceId::equal

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

    DeviceId::from_string

    source
    fn DeviceId::from_string(s : String) -> DeviceId raise DeviceIdError

    DeviceId::host_id

    source
    fn DeviceId::host_id(self : DeviceId) -> HostId

    DeviceId::new

    source
    fn DeviceId::new(host_id : HostId, device_id : String) -> DeviceId

    DeviceId::not_equal

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

    DeviceId::output

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

    DeviceId::to_repr

    source

    DeviceId::to_string

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

    DeviceType

    source
    pub enum DeviceType {
      Speaker
      Microphone
      Headphones
      Headset
      Earpiece
      Handset
      HearingAid
      Dock
      Tuner
      Virtual
      Unknown
    } derive(Eq, 
    Debug    )

    impl Show for DeviceType

    DeviceType::dock

    source
    fn DeviceType::dock() -> DeviceType

    DeviceType::earpiece

    source
    fn DeviceType::earpiece() -> DeviceType

    DeviceType::equal

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

    DeviceType::handset

    source
    fn DeviceType::handset() -> DeviceType

    DeviceType::headphones

    source
    fn DeviceType::headphones() -> DeviceType

    DeviceType::headset

    source
    fn DeviceType::headset() -> DeviceType

    DeviceType::hearing_aid

    source
    fn DeviceType::hearing_aid() -> DeviceType

    DeviceType::microphone

    source
    fn DeviceType::microphone() -> DeviceType

    DeviceType::not_equal

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

    DeviceType::output

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

    DeviceType::speaker

    source
    fn DeviceType::speaker() -> DeviceType

    DeviceType::to_repr

    source

    DeviceType::to_string

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

    DeviceType::tuner

    source
    fn DeviceType::tuner() -> DeviceType

    DeviceType::unknown

    source
    fn DeviceType::unknown() -> DeviceType

    DeviceType::virtual_

    source
    fn DeviceType::virtual_() -> DeviceType

    Duration

    source
    pub struct Duration {
      secs : UInt64
      nanos : Int
    } derive(Eq, 
    Debug    )

    A minimal duration type used by the ported StreamInstant arithmetic.

    Upstream uses std::time::Duration (non-negative). Here we keep the same invariant.
    impl Show for Duration

    Duration::Duration

    source
    fn Duration::Duration(secs : UInt64, nanos : Int) -> Duration

    Duration::equal

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

    Duration::from_secs

    source
    fn Duration::from_secs(secs : UInt64) -> Duration

    Duration::new

    source
    fn Duration::new(secs : UInt64, nanos : Int) -> Duration

    Duration::not_equal

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

    Duration::output

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

    Duration::to_repr

    source

    Duration::to_string

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

    HostId

    source
    pub(all) enum HostId {
      AAudio
      Alsa
      Asio
      CoreAudio
      Custom
      Emscripten
      Jack
      Null
      Wasapi
      WebAudio
      AudioWorklet
    } derive(Eq, 
    Debug    )

    impl Show for HostId

    HostId::equal

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

    HostId::from_string

    source
    fn HostId::from_string(s : String) -> HostId?

    HostId::from_view

    source
    fn HostId::from_view(v : StringView) -> HostId?

    HostId::name

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

    Upstream HostId::name() returns the variant name (before lowercase display).

    HostId::not_equal

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

    HostId::output

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

    HostId::parse

    source
    fn HostId::parse(s : String) -> HostId raise HostUnavailable

    HostId::to_repr

    source

    HostId::to_string

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

    I24

    source
    pub struct I24 {
      raw : Int
    } derive(Eq, 
    Debug    )

    impl FromSample for I24
    impl Sample for I24
    impl SizedSample for I24
    impl Show for I24

    I24::I24

    source
    fn I24::I24(raw : Int) -> I24

    I24::equal

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

    I24::equilibrium

    source
    fn I24::equilibrium() -> I24

    I24::format

    source
    fn I24::format(_self : I24) -> SampleFormat

    I24::from_f32

    source
    fn I24::from_f32(x : Float) -> I24

    I24::from_sample

    source
    fn I24::from_sample(x : Float) -> I24

    I24::new

    source
    fn I24::new(raw : Int) -> I24

    I24::not_equal

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

    I24::output

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

    I24::to_f32

    source
    fn I24::to_f32(self : I24) -> Float

    I24::to_int

    source
    fn I24::to_int(self : I24) -> Int

    I24::to_repr

    source

    I24::to_string

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

    InputCallbackInfo

    source
    pub struct InputCallbackInfo {
      timestamp : InputStreamTimestamp
    } derive(Eq, 
    Debug    )

    Information relevant to a single call to the user's input stream data callback.

    InputCallbackInfo::InputCallbackInfo

    source
    fn InputCallbackInfo::InputCallbackInfo(timestamp : InputStreamTimestamp) -> InputCallbackInfo

    InputCallbackInfo::equal

    source

    InputCallbackInfo::new

    source

    InputCallbackInfo::not_equal

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

    InputCallbackInfo::output

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

    InputCallbackInfo::timestamp

    source

    InputCallbackInfo::to_repr

    source

    InputCallbackInfo::to_string

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

    InputStreamTimestamp

    source
    pub struct InputStreamTimestamp {
      callback : StreamInstant
      capture : StreamInstant
    } derive(Eq, 
    Debug    )

    A timestamp associated with a call to an input stream's data callback.

    InputStreamTimestamp::InputStreamTimestamp

    source
    fn InputStreamTimestamp::InputStreamTimestamp(callback : StreamInstant, capture : StreamInstant) -> InputStreamTimestamp

    InputStreamTimestamp::callback

    source

    InputStreamTimestamp::capture

    source

    InputStreamTimestamp::equal

    source

    InputStreamTimestamp::new

    source

    InputStreamTimestamp::not_equal

    source

    InputStreamTimestamp::output

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

    InputStreamTimestamp::to_repr

    source

    InputStreamTimestamp::to_string

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

    InterfaceType

    source
    pub enum InterfaceType {
      BuiltIn
      Usb
      Bluetooth
      Pci
      FireWire
      Thunderbolt
      Hdmi
      Line
      Spdif
      Network
      Virtual
      DisplayPort
      Aggregate
      Unknown
    } derive(Eq, 
    Debug    )

    InterfaceType::aggregate

    source
    fn InterfaceType::aggregate() -> InterfaceType

    InterfaceType::bluetooth

    source
    fn InterfaceType::bluetooth() -> InterfaceType

    InterfaceType::built_in

    source
    fn InterfaceType::built_in() -> InterfaceType

    InterfaceType::display_port

    source
    fn InterfaceType::display_port() -> InterfaceType

    InterfaceType::equal

    source

    InterfaceType::fire_wire

    source
    fn InterfaceType::fire_wire() -> InterfaceType

    InterfaceType::hdmi

    source

    InterfaceType::line

    source

    InterfaceType::network

    source
    fn InterfaceType::network() -> InterfaceType

    InterfaceType::not_equal

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

    InterfaceType::output

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

    InterfaceType::pci

    source

    InterfaceType::spdif

    source

    InterfaceType::thunderbolt

    source
    fn InterfaceType::thunderbolt() -> InterfaceType

    InterfaceType::to_repr

    source

    InterfaceType::to_string

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

    InterfaceType::unknown

    source
    fn InterfaceType::unknown() -> InterfaceType

    InterfaceType::usb

    source

    InterfaceType::virtual_

    source
    fn InterfaceType::virtual_() -> InterfaceType

    NativeOs

    source
    pub(all) enum NativeOs {
      Unknown
      Macos
      Windows
      Linux
    } derive(Eq, 
    Debug    )

    impl Show for NativeOs

    NativeOs::equal

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

    NativeOs::not_equal

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

    NativeOs::output

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

    NativeOs::to_repr

    source

    NativeOs::to_string

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

    OutputCallbackInfo

    source
    pub struct OutputCallbackInfo {
      timestamp : OutputStreamTimestamp
    } derive(Eq, 
    Debug    )

    Information relevant to a single call to the user's output stream data callback.

    OutputCallbackInfo::OutputCallbackInfo

    source
    fn OutputCallbackInfo::OutputCallbackInfo(timestamp : OutputStreamTimestamp) -> OutputCallbackInfo

    OutputCallbackInfo::equal

    source

    OutputCallbackInfo::new

    source

    OutputCallbackInfo::not_equal

    source

    OutputCallbackInfo::output

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

    OutputCallbackInfo::timestamp

    source

    OutputCallbackInfo::to_repr

    source

    OutputCallbackInfo::to_string

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

    OutputStreamTimestamp

    source
    pub struct OutputStreamTimestamp {
      callback : StreamInstant
      playback : StreamInstant
    } derive(Eq, 
    Debug    )

    A timestamp associated with a call to an output stream's data callback.

    OutputStreamTimestamp::OutputStreamTimestamp

    source
    fn OutputStreamTimestamp::OutputStreamTimestamp(callback : StreamInstant, playback : StreamInstant) -> OutputStreamTimestamp

    OutputStreamTimestamp::callback

    source

    OutputStreamTimestamp::equal

    source

    OutputStreamTimestamp::new

    source

    OutputStreamTimestamp::not_equal

    source

    OutputStreamTimestamp::output

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

    OutputStreamTimestamp::playback

    source

    OutputStreamTimestamp::to_repr

    source

    OutputStreamTimestamp::to_string

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

    SampleFormat

    source
    pub(all) enum SampleFormat {
      I8
      I16
      I24
      I32
      I64
      U8
      U16
      U24
      U32
      U64
      F32
      F64
      DsdU8
      DsdU16
      DsdU32
    } derive(Eq, 
    Debug    )

    SampleFormat::bits_per_sample

    source
    fn SampleFormat::bits_per_sample(self : SampleFormat) -> Int

    SampleFormat::equal

    source

    SampleFormat::is_dsd

    source
    fn SampleFormat::is_dsd(self : SampleFormat) -> Bool

    SampleFormat::is_float

    source
    fn SampleFormat::is_float(self : SampleFormat) -> Bool

    SampleFormat::is_int

    source
    fn SampleFormat::is_int(self : SampleFormat) -> Bool

    SampleFormat::is_uint

    source
    fn SampleFormat::is_uint(self : SampleFormat) -> Bool

    SampleFormat::not_equal

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

    SampleFormat::output

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

    SampleFormat::sample_size

    source
    fn SampleFormat::sample_size(self : SampleFormat) -> Int

    SampleFormat::to_debug_string

    source
    fn SampleFormat::to_debug_string(self : SampleFormat) -> String

    SampleFormat::to_repr

    source

    SampleFormat::to_string

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

    StreamConfig

    source
    pub struct StreamConfig {
      channels : Int
      sample_rate : Int
      buffer_size : BufferSize
    } derive(Eq, 
    Debug    )

    StreamConfig::StreamConfig

    source
    fn StreamConfig::StreamConfig(channels : Int, sample_rate : Int, buffer_size : BufferSize) -> StreamConfig

    StreamConfig::equal

    source

    StreamConfig::new

    source
    fn StreamConfig::new(channels : Int, sample_rate : Int, buffer_size : BufferSize) -> StreamConfig

    StreamConfig::not_equal

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

    StreamConfig::output

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

    StreamConfig::to_repr

    source

    StreamConfig::to_string

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

    StreamInstant

    source
    pub struct StreamInstant {
      secs : Int64
      nanos : Int
    } derive(Eq, 
    Debug    )

    Monotonic timestamp associated with a stream.

    StreamInstant::StreamInstant

    source
    fn StreamInstant::StreamInstant(secs : Int64, nanos : Int) -> StreamInstant

    StreamInstant::add

    source
    fn StreamInstant::add(self : StreamInstant, duration : Duration) -> StreamInstant?

    Return the instant after the given duration has passed.

    StreamInstant::duration_since

    source
    fn StreamInstant::duration_since(self : StreamInstant, earlier : StreamInstant) -> Duration?

    The amount of time elapsed from another instant to this one.

    Returns None if earlier is later than self.

    StreamInstant::equal

    source

    StreamInstant::new

    source
    fn StreamInstant::new(secs : Int64, nanos : Int) -> StreamInstant

    StreamInstant::not_equal

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

    StreamInstant::output

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

    StreamInstant::sub

    source
    fn StreamInstant::sub(self : StreamInstant, duration : Duration) -> StreamInstant?

    Return the instant one duration ago.

    StreamInstant::to_repr

    source

    StreamInstant::to_string

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

    SupportedBufferSize

    source
    pub(all) enum SupportedBufferSize {
      Range(min~ : Int, max~ : Int)
      Unknown
    } derive(Eq, 
    Debug    )

    SupportedBufferSize::contains

    source
    fn SupportedBufferSize::contains(self : SupportedBufferSize, frames : Int) -> Bool

    SupportedBufferSize::equal

    source

    SupportedBufferSize::not_equal

    source

    SupportedBufferSize::output

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

    SupportedBufferSize::to_repr

    source

    SupportedBufferSize::to_string

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

    SupportedStreamConfig

    source
    pub struct SupportedStreamConfig {
      buffer_size : SupportedBufferSize
      channels : Int
      sample_rate : Int
      sample_format : SampleFormat
    } derive(Eq, 
    Debug    )

    A single supported stream configuration (as opposed to a range).

    Mirrors cpal's SupportedStreamConfig shape used by default_*_config.

    SupportedStreamConfig::SupportedStreamConfig

    source
    fn SupportedStreamConfig::SupportedStreamConfig(channels : Int, sample_rate : Int, buffer_size : SupportedBufferSize, sample_format : SampleFormat) -> SupportedStreamConfig

    SupportedStreamConfig::buffer_size

    source

    SupportedStreamConfig::channels

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

    SupportedStreamConfig::config

    source

    SupportedStreamConfig::equal

    source

    SupportedStreamConfig::new

    source
    fn SupportedStreamConfig::new(channels : Int, sample_rate : Int, buffer_size : SupportedBufferSize, sample_format : SampleFormat) -> SupportedStreamConfig

    SupportedStreamConfig::not_equal

    source

    SupportedStreamConfig::output

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

    SupportedStreamConfig::sample_format

    source

    SupportedStreamConfig::sample_rate

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

    SupportedStreamConfig::to_repr

    source

    SupportedStreamConfig::to_string

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

    SupportedStreamConfigRange

    source
    pub struct SupportedStreamConfigRange {
      buffer_size : SupportedBufferSize
      channels : Int
      min_sample_rate : Int
      max_sample_rate : Int
      sample_format : SampleFormat
    } derive(Eq, 
    Debug    )

    SupportedStreamConfigRange::SupportedStreamConfigRange

    source
    fn SupportedStreamConfigRange::SupportedStreamConfigRange(channels : Int, min_sample_rate : Int, max_sample_rate : Int, buffer_size : SupportedBufferSize, sample_format : SampleFormat) -> SupportedStreamConfigRange

    SupportedStreamConfigRange::buffer_size

    source

    SupportedStreamConfigRange::channels

    source

    SupportedStreamConfigRange::cmp_default_heuristics

    source
    fn SupportedStreamConfigRange::cmp_default_heuristics(self : SupportedStreamConfigRange, other : SupportedStreamConfigRange) -> Int

    Compare two supported config ranges using the same "default config" heuristics as upstream.

    Returns:
    • negative if self has lower priority
    • 0 if equal priority
    • positive if self has higher priority

    SupportedStreamConfigRange::equal

    source

    SupportedStreamConfigRange::max_sample_rate

    source
    fn SupportedStreamConfigRange::max_sample_rate(self : SupportedStreamConfigRange) -> Int

    SupportedStreamConfigRange::min_sample_rate

    source
    fn SupportedStreamConfigRange::min_sample_rate(self : SupportedStreamConfigRange) -> Int

    SupportedStreamConfigRange::new

    source
    fn SupportedStreamConfigRange::new(channels : Int, min_sample_rate : Int, max_sample_rate : Int, buffer_size : SupportedBufferSize, sample_format : SampleFormat) -> SupportedStreamConfigRange

    Public constructor for black-box tests and downstream users.

    SupportedStreamConfigRange::not_equal

    source

    SupportedStreamConfigRange::output

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

    SupportedStreamConfigRange::sample_format

    source

    SupportedStreamConfigRange::to_repr

    source

    SupportedStreamConfigRange::to_string

    source

    SupportedStreamConfigRange::try_with_sample_rate

    source
    fn SupportedStreamConfigRange::try_with_sample_rate(self : SupportedStreamConfigRange, sample_rate : Int) -> SupportedStreamConfig?

    Retrieve a SupportedStreamConfig with the given sample rate.

    Returns None if sample_rate is outside [min_sample_rate, max_sample_rate].

    SupportedStreamConfigRange::with_max_sample_rate

    source

    Turns this range into a SupportedStreamConfig corresponding to the maximum sample rate.

    SupportedStreamConfigRange::with_sample_rate

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

    Retrieve a SupportedStreamConfig with the given sample rate.

    Panics

    Panics if sample_rate is outside [min_sample_rate, max_sample_rate].

    U24

    source
    pub struct U24 {
      raw : Int
    } derive(Eq, 
    Debug    )

    impl FromSample for U24
    impl Sample for U24
    impl SizedSample for U24
    impl Show for U24

    U24::U24

    source
    fn U24::U24(raw : Int) -> U24

    U24::equal

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

    U24::equilibrium

    source
    fn U24::equilibrium() -> U24

    U24::format

    source
    fn U24::format(_self : U24) -> SampleFormat

    U24::from_f32

    source
    fn U24::from_f32(x : Float) -> U24

    U24::from_sample

    source
    fn U24::from_sample(x : Float) -> U24

    U24::new

    source
    fn U24::new(raw : Int) -> U24

    U24::not_equal

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

    U24::output

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

    U24::to_f32

    source
    fn U24::to_f32(self : U24) -> Float

    U24::to_int

    source
    fn U24::to_int(self : U24) -> Int

    U24::to_repr

    source

    U24::to_string

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

    build_stream_error_backend_specific

    source
    fn build_stream_error_backend_specific(description : String) -> BuildStreamError

    build_stream_error_device_busy

    source
    fn build_stream_error_device_busy() -> BuildStreamError

    build_stream_error_device_not_available

    source
    fn build_stream_error_device_not_available() -> BuildStreamError

    build_stream_error_invalid_argument

    source
    fn build_stream_error_invalid_argument() -> BuildStreamError

    build_stream_error_stream_config_not_supported

    source
    fn build_stream_error_stream_config_not_supported() -> BuildStreamError

    build_stream_error_stream_id_overflow

    source
    fn build_stream_error_stream_id_overflow() -> BuildStreamError

    common_sample_rates

    source
    fn common_sample_rates() -> Array[Int]

    default_stream_config_error_backend_specific

    source
    fn default_stream_config_error_backend_specific(description : String) -> DefaultStreamConfigError

    default_stream_config_error_device_busy

    source
    fn default_stream_config_error_device_busy() -> DefaultStreamConfigError

    default_stream_config_error_device_not_available

    source
    fn default_stream_config_error_device_not_available() -> DefaultStreamConfigError

    default_stream_config_error_stream_type_not_supported

    source
    fn default_stream_config_error_stream_type_not_supported() -> DefaultStreamConfigError

    device_id_error_backend_specific

    source
    fn device_id_error_backend_specific(description : String) -> DeviceIdError

    device_id_error_unsupported_platform

    source
    fn device_id_error_unsupported_platform() -> DeviceIdError

    device_name_error_backend_specific

    source
    fn device_name_error_backend_specific(description : String) -> DeviceNameError

    devices_error_backend_specific

    source
    fn devices_error_backend_specific(description : String) -> DevicesError

    direction_from_caps

    source
    fn direction_from_caps(has_input : Bool, has_output : Bool) -> DeviceDirection

    direction_from_counts

    source
    fn direction_from_counts(input_channels : Int?, output_channels : Int?) -> DeviceDirection

    host_unavailable

    source
    fn host_unavailable() -> HostUnavailable

    native_os

    source
    fn native_os() -> NativeOs

    pause_stream_error_backend_specific

    source
    fn pause_stream_error_backend_specific(description : String) -> PauseStreamError

    pause_stream_error_device_not_available

    source
    fn pause_stream_error_device_not_available() -> PauseStreamError

    play_stream_error_backend_specific

    source
    fn play_stream_error_backend_specific(description : String) -> PlayStreamError

    play_stream_error_device_not_available

    source
    fn play_stream_error_device_not_available() -> PlayStreamError

    sample_cast

    source
    fn[A : Sample, B : Sample] sample_cast(x : A) -> B

    sleep_millis

    source
    fn sleep_millis(ms : Int) -> Unit

    stream_error_backend_specific

    source
    fn stream_error_backend_specific(description : String) -> StreamError

    stream_error_buffer_underrun

    source
    fn stream_error_buffer_underrun() -> StreamError

    stream_error_device_not_available

    source
    fn stream_error_device_not_available() -> StreamError

    stream_error_stream_invalidated

    source
    fn stream_error_stream_invalidated() -> StreamError

    string_to_ascii_bytes

    source
    fn string_to_ascii_bytes(s : String) -> Bytes

    Encode a string into ASCII bytes (best-effort).

    This is intended for native backend identifiers like default or hw:0,0. Any non-ASCII chars are replaced with ?.

    string_to_utf8_bytes

    source
    fn string_to_utf8_bytes(s : String) -> Bytes

    Encode a string into UTF-8 bytes.

    This is needed for native backends that require UTF-8 identifiers (e.g. WASAPI endpoint IDs).

    supported_stream_configs_error_backend_specific

    source
    fn supported_stream_configs_error_backend_specific(description : String) -> SupportedStreamConfigsError

    supported_stream_configs_error_device_busy

    source
    fn supported_stream_configs_error_device_busy() -> SupportedStreamConfigsError

    supported_stream_configs_error_device_not_available

    source
    fn supported_stream_configs_error_device_not_available() -> SupportedStreamConfigsError

    supported_stream_configs_error_invalid_argument

    source
    fn supported_stream_configs_error_invalid_argument() -> SupportedStreamConfigsError

    utf8_bytes_to_string

    source
    fn utf8_bytes_to_string(bytes : Bytes, length : Int) -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io