🥮 mooncakes.io
README

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

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

#
DeviceIdError

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

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

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

#
HostUnavailable

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

#
HostUnavailable::to_string

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

#
PauseStreamError

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

#
PauseStreamError::to_string

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

#
PlayStreamError

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

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

source

#
BackendSpecificError

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

#
BackendSpecificError::description

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

#
BackendSpecificError::new

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

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

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

#
Data

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

impl Show for 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::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::sample_format

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

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

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

#
DeviceDescription::supports_output

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

#
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)
fn DeviceDescriptionBuilder::DeviceDescriptionBuilder(name : String) -> DeviceDescriptionBuilder

Builder for constructing a DeviceDescription.

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

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

source

#
DeviceDescriptionBuilder::interface_type

source

#
DeviceDescriptionBuilder::manufacturer

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

#
DeviceDescriptionBuilder::new

source

#
DeviceDirection

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

#
DeviceDirection::duplex

source

#
DeviceDirection::input

source

#
DeviceDirection::output

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)
fn DeviceId::DeviceId(host_id : HostId, device_id : String) -> DeviceId

impl Show for DeviceId

#
DeviceId::device_id

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

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

source
fn DeviceType::speaker() -> DeviceType

#
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)
fn Duration::Duration(secs : UInt64, nanos : Int) -> Duration

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

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

#
Duration::new

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

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

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

#
HostId::to_string

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

#
I24

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

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

#
I24::new

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

#
I24::to_int

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

#
InputCallbackInfo

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

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

#
InputCallbackInfo::new

source

#
InputCallbackInfo::timestamp

source

#
InputStreamTimestamp

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

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

#
InputStreamTimestamp::callback

source

#
InputStreamTimestamp::capture

source

#
InputStreamTimestamp::new

source

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

source
fn InterfaceType::fire_wire() -> InterfaceType

#
InterfaceType::hdmi

source

#
InterfaceType::line

source

#
InterfaceType::network

source
fn InterfaceType::network() -> InterfaceType

#
InterfaceType::pci

source

#
InterfaceType::spdif

source

#
InterfaceType::thunderbolt

source
fn InterfaceType::thunderbolt() -> InterfaceType

#
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

#
OutputCallbackInfo

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

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

#
OutputCallbackInfo::new

source

#
OutputCallbackInfo::timestamp

source

#
OutputStreamTimestamp

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

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

#
OutputStreamTimestamp::callback

source

#
OutputStreamTimestamp::new

source

#
OutputStreamTimestamp::playback

source

#
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::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::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_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)
fn StreamConfig::StreamConfig(channels : Int, sample_rate : Int, buffer_size : BufferSize) -> StreamConfig

#
StreamConfig::new

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

#
StreamInstant

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

Monotonic timestamp associated with a stream.

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

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

#
StreamInstant::sub

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

Return the instant one duration ago.

#
SupportedBufferSize

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

#
SupportedBufferSize::contains

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

#
SupportedStreamConfig

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

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

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

#
SupportedStreamConfig::buffer_size

source

#
SupportedStreamConfig::channels

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

#
SupportedStreamConfig::config

source

#
SupportedStreamConfig::new

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

#
SupportedStreamConfig::sample_format

source

#
SupportedStreamConfig::sample_rate

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

#
SupportedStreamConfigRange

source
pub struct SupportedStreamConfigRange {
  buffer_size : SupportedBufferSize
  channels : Int
  min_sample_rate : Int
  max_sample_rate : Int
  sample_format : SampleFormat
} derive(Eq, 
Debug)
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::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::sample_format

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)
fn U24::U24(raw : Int) -> U24

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

#
U24::new

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

#
U24::to_int

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

#
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