maudio 0.1.3

Rust bindings to the miniaudio library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Stream format configuration for audio streams.
use maudio_sys::ffi as sys;

use crate::{ErrorKinds, MaudioError};

/// Audio stream sample format.
///
/// This enum specifies the fundamental representation of audio samples
/// in a stream.
///
/// At present, miniaudio only defines PCM streams.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(C)]
pub enum StreamFormat {
    /// Pulse-code modulation (PCM).
    ///
    /// Audio samples are provided directly as raw PCM data.
    /// This is the only stream format currently supported by miniaudio.
    Pcm,
}

impl From<StreamFormat> for sys::ma_stream_format {
    fn from(value: StreamFormat) -> Self {
        match value {
            StreamFormat::Pcm => sys::ma_stream_format_ma_stream_format_pcm,
        }
    }
}

impl TryFrom<sys::ma_stream_format> for StreamFormat {
    type Error = MaudioError;

    fn try_from(value: sys::ma_stream_format) -> Result<Self, Self::Error> {
        match value {
            sys::ma_stream_format_ma_stream_format_pcm => Ok(StreamFormat::Pcm),
            other => Err(MaudioError::new_ma_error(ErrorKinds::unknown_enum::<
                StreamFormat,
            >(other as i64))),
        }
    }
}

/// Channel data layout for audio streams.
///
/// This enum specifies how multi-channel audio samples are laid out in memory.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(C)]
pub enum StreamLayout {
    /// Interleaved channel layout.
    ///
    /// Samples for all channels are interleaved in a single buffer.
    /// For example, stereo audio is laid out as:
    /// `L, R, L, R, L, R, ...`
    ///
    /// This is the most common layout used by audio APIs and is the default
    /// layout in miniaudio.
    Interleaved,
    /// Deinterleaved channel layout.
    ///
    /// Each channel’s samples are stored in a separate buffer.
    /// For example, stereo audio is laid out as:
    /// `LLLL...`, `RRRR...`
    ///
    /// This layout can be useful for certain DSP algorithms but is less
    /// commonly used by audio backends.
    Deinterleaved,
}

impl From<StreamLayout> for sys::ma_stream_layout {
    fn from(value: StreamLayout) -> Self {
        match value {
            StreamLayout::Interleaved => sys::ma_stream_layout_ma_stream_layout_interleaved,
            StreamLayout::Deinterleaved => sys::ma_stream_layout_ma_stream_layout_deinterleaved,
        }
    }
}

impl TryFrom<sys::ma_stream_layout> for StreamLayout {
    type Error = MaudioError;

    fn try_from(value: sys::ma_stream_layout) -> Result<Self, Self::Error> {
        match value {
            sys::ma_stream_layout_ma_stream_layout_interleaved => Ok(StreamLayout::Interleaved),
            sys::ma_stream_layout_ma_stream_layout_deinterleaved => Ok(StreamLayout::Deinterleaved),
            other => Err(MaudioError::new_ma_error(ErrorKinds::unknown_enum::<
                StreamLayout,
            >(other as i64))),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::MaError;

    use super::*;
    use maudio_sys::ffi as sys;

    #[test]
    fn test_stream_format_from_rust_to_sys_pcm() {
        let sys_val: sys::ma_stream_format = StreamFormat::Pcm.into();
        assert_eq!(sys_val, sys::ma_stream_format_ma_stream_format_pcm);
    }

    #[test]
    fn test_stream_format_try_from_sys_to_rust_pcm() {
        let rust_val = StreamFormat::try_from(sys::ma_stream_format_ma_stream_format_pcm).unwrap();
        assert_eq!(rust_val, StreamFormat::Pcm);
    }

    #[test]
    fn test_stream_format_try_from_invalid_returns_error() {
        let invalid: sys::ma_stream_format = 0x7FFF as sys::ma_stream_format;
        let err = StreamFormat::try_from(invalid).unwrap_err();
        assert_eq!(err, MaError(sys::ma_result_MA_ERROR));
    }

    #[test]
    fn test_stream_layout_from_rust_to_sys_interleaved() {
        let sys_val: sys::ma_stream_layout = StreamLayout::Interleaved.into();
        assert_eq!(sys_val, sys::ma_stream_layout_ma_stream_layout_interleaved);
    }

    #[test]
    fn test_stream_layout_from_rust_to_sys_deinterleaved() {
        let sys_val: sys::ma_stream_layout = StreamLayout::Deinterleaved.into();
        assert_eq!(
            sys_val,
            sys::ma_stream_layout_ma_stream_layout_deinterleaved
        );
    }

    #[test]
    fn test_stream_layout_try_from_sys_to_rust_interleaved() {
        let rust_val =
            StreamLayout::try_from(sys::ma_stream_layout_ma_stream_layout_interleaved).unwrap();
        assert_eq!(rust_val, StreamLayout::Interleaved);
    }

    #[test]
    fn test_stream_layout_try_from_sys_to_rust_deinterleaved() {
        let rust_val =
            StreamLayout::try_from(sys::ma_stream_layout_ma_stream_layout_deinterleaved).unwrap();
        assert_eq!(rust_val, StreamLayout::Deinterleaved);
    }

    #[test]
    fn test_stream_layout_try_from_invalid_returns_error() {
        let invalid: sys::ma_stream_format = 0x7FFF as sys::ma_stream_format;
        let err = StreamLayout::try_from(invalid).unwrap_err();
        assert_eq!(err, MaError(sys::ma_result_MA_ERROR));
    }
}