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

use std::{cell::Cell, marker::PhantomData};

use maudio_sys::ffi as sys;

use crate::{context::backend::Backend, device::device_builder::DeviceBuilder, Binding, MaResult};

pub mod device_builder;

pub struct Device {
    inner: *mut sys::ma_device,
    // user_data: *mut DeviceUserData,
    _not_sync: PhantomData<Cell<()>>,
}

impl Binding for Device {
    type Raw = *mut sys::ma_device;

    /// !!! unimplemented !!!
    fn from_ptr(_raw: Self::Raw) -> Self {
        unimplemented!()
    }

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

impl Device {
    fn init_default(_config: &DeviceBuilder) -> MaResult<Self> {
        // TODO: Used by DeviceBuilder
        todo!()
    }

    fn init_from_config_internal(_backends: &[Backend], _config: Option<&DeviceBuilder>) -> Self {
        todo!()
    }
}

pub(crate) mod device_ffi {
    use maudio_sys::ffi as sys;

    use crate::{
        context::{backend::Backend, Context},
        device::device_builder::DeviceBuilder,
        AsRawRef, Binding, MaResult, MaudioError,
    };

    pub fn ma_device_init(
        context: &mut Context,
        config: &DeviceBuilder,
        device: *mut sys::ma_device,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_device_init(context.to_raw(), config.as_raw_ptr(), device) };
        MaudioError::check(res)
    }

    pub fn ma_device_init_ex(
        backends: &[Backend],
        context_cfg: *const sys::ma_context_config,
        config: *const sys::ma_device_config,
        device: *mut sys::ma_device,
    ) -> MaResult<()> {
        let (backends_ptr, length): (*const sys::ma_backend, u32) = if !backends.is_empty() {
            (backends.as_ptr() as *const _, backends.len() as u32)
        } else {
            (core::ptr::null(), 0)
        };
        let res =
            unsafe { sys::ma_device_init_ex(backends_ptr, length, context_cfg, config, device) };
        MaudioError::check(res)
    }

    pub fn ma_device_uninit(device: *mut sys::ma_device) {
        // TODO
        unsafe { sys::ma_device_uninit(device) };
    }
}