maudio 0.1.5

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

//! Builder for creating a [`ResourceManager`]
use maudio_sys::ffi as sys;

use crate::{
    audio::{formats::Format, sample_rate::SampleRate},
    engine::resource::{rm_flags::RmFlags, ResourceManager},
    pcm_frames::{S24Packed, S24},
    AsRawRef, MaResult,
};

/// At the end, you will set the sample format that audio decoded by
/// this `ResourceManager` will be converted to.
/// The audio will decoded from its native sample format.
pub struct ResourceManagerBuilder {
    inner: sys::ma_resource_manager_config,
    format: Option<Format>,
    channels: Option<u32>,
    sample_rate: Option<SampleRate>,
    flags: RmFlags,
}

impl AsRawRef for ResourceManagerBuilder {
    type Raw = sys::ma_resource_manager_config;

    fn as_raw(&self) -> &Self::Raw {
        &self.inner
    }
}

impl ResourceManagerBuilder {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
        let inner = unsafe { sys::ma_resource_manager_config_init() };
        Self {
            inner,
            format: None,
            channels: None,
            sample_rate: None,
            flags: RmFlags::NONE,
        }
    }

    /// Sets the number of channels that all audio decoded by this ResourceManager
    /// will be converted to.
    ///
    /// By default, audio keeps its original channel count. If set, all resources
    /// loaded through this ResourceManager will be decoded to this channel count
    /// at load time.
    pub fn channels(&mut self, channels: u32) -> &mut Self {
        self.inner.decodedChannels = channels;
        self.channels = Some(channels);
        self
    }

    fn set_format(&mut self, format: Format) -> &mut Self {
        self.inner.decodedFormat = format.into();
        self.format = Some(format);
        self
    }

    /// Sets the [`SampleRate`] that audio decoded by this `ResourceManager`
    /// will be converted to.
    ///
    /// By default, audio is decoded at its original sample rate. If set,
    /// all resources loaded through this `ResourceManager` will be resampled
    /// to this rate during decoding.
    pub fn sample_rate(&mut self, sample_rate: SampleRate) -> &mut Self {
        self.inner.decodedSampleRate = sample_rate.into();
        self.sample_rate = Some(sample_rate);
        self
    }

    /// Sets the [`RmFlags`]. Removes any existing ones.
    pub fn flags(&mut self, flags: RmFlags) -> &mut Self {
        self.inner.flags = flags.bits();
        self
    }

    pub fn non_blocking(&mut self, yes: bool) -> &mut Self {
        let mut flags = RmFlags::from_bits(self.inner.flags);
        if yes {
            flags.insert(RmFlags::NON_BLOCKING);
        } else {
            flags.remove(RmFlags::NON_BLOCKING);
        }
        self.inner.flags = flags.bits();
        self.flags = flags;
        self
    }

    /// Also sets the job_thread_count to 0
    pub fn no_threading(&mut self, yes: bool) -> &mut Self {
        let mut flags = RmFlags::from_bits(self.inner.flags);
        if yes {
            flags.insert(RmFlags::NO_THREADING);
        } else {
            flags.remove(RmFlags::NO_THREADING);
        }
        self.inner.flags = flags.bits();
        self.flags = flags;
        self
    }

    pub fn job_thread_count(&mut self, count: u32) -> &mut Self {
        self.inner.jobThreadCount = count;
        self
    }

    pub fn build_u8(&mut self) -> MaResult<ResourceManager<u8>> {
        self.set_format(Format::U8);
        ResourceManager::<u8>::new_with_config(self)
    }

    pub fn build_i16(&mut self) -> MaResult<ResourceManager<i16>> {
        self.set_format(Format::S16);
        ResourceManager::new_with_config(self)
    }

    pub fn build_i32(&mut self) -> MaResult<ResourceManager<i32>> {
        self.set_format(Format::S32);
        ResourceManager::new_with_config(self)
    }

    pub fn build_s24_packed(&mut self) -> MaResult<ResourceManager<S24Packed>> {
        self.set_format(Format::S24Packed);
        ResourceManager::new_with_config(self)
    }

    pub fn build_s24(&mut self) -> MaResult<ResourceManager<S24>> {
        self.set_format(Format::S24Packed);
        ResourceManager::new_with_config(self)
    }

    pub fn build_f32(&mut self) -> MaResult<ResourceManager<f32>> {
        self.set_format(Format::F32);
        ResourceManager::<f32>::new_with_config(self)
    }
}