soloud 1.1.1

Rust bindings for the soloud audio engine
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

use crate::prelude::*;
use soloud_sys::soloud as ffi;
use std::path::Path;

/// Wav audio type
#[derive(Debug)]
pub struct Wav {
    inner: *mut ffi::Wav,
}

crate::macros::load::impl_load_ext!(Wav);
crate::macros::audio::impl_audio_ext!(Wav);

impl Wav {
    /// Load raw wav data of precise bits
    /// # Safety
    /// The data must be valid
    pub unsafe fn load_raw_wav_8(&mut self, data: &[u8]) -> Result<(), SoloudError> {
        ffi_call!(ffi::Wav_loadRawWave8(
            self.inner,
            data.as_ptr() as *mut _,
            data.len() as u32
        ))
    }

    /// Load raw wav data of precise bits
    /// # Safety
    /// The data must be valid
    pub unsafe fn load_raw_wav_8_ex(
        &mut self,
        data: &[u8],
        samplerate: f32,
        channels: u32,
    ) -> Result<(), SoloudError> {
        ffi_call!(ffi::Wav_loadRawWave8Ex(
            self.inner,
            data.as_ptr() as *mut _,
            data.len() as u32,
            samplerate,
            channels,
        ))
    }

    /// Load raw wav data of precise bits
    /// # Safety
    /// The data must be valid
    pub unsafe fn load_raw_wav_16(&mut self, data: &[i16]) -> Result<(), SoloudError> {
        ffi_call!(ffi::Wav_loadRawWave16(
            self.inner,
            data.as_ptr() as *mut _,
            data.len() as u32
        ))
    }

    /// Load raw wav data of precise bits
    /// # Safety
    /// The data must be valid
    pub unsafe fn load_raw_wav_16_ex(
        &mut self,
        data: &[i16],
        samplerate: f32,
        channels: u32,
    ) -> Result<(), SoloudError> {
        ffi_call!(ffi::Wav_loadRawWave16Ex(
            self.inner,
            data.as_ptr() as *mut _,
            data.len() as u32,
            samplerate,
            channels,
        ))
    }

    /// Load raw wav data of precise bits
    /// # Safety
    /// The data must be valid
    pub unsafe fn load_raw_wav(&mut self, data: &[f32]) -> Result<(), SoloudError> {
        ffi_call!(ffi::Wav_loadRawWave(
            self.inner,
            data.as_ptr() as *mut _,
            data.len() as u32
        ))
    }

    /// Load raw wav data of precise bits
    /// # Safety
    /// The data must be valid
    pub unsafe fn load_raw_wav_ex(
        &mut self,
        data: &[f32],
        samplerate: f32,
        channels: u32,
        copy: bool,
        take_ownership: bool,
    ) -> Result<(), SoloudError> {
        ffi_call!(ffi::Wav_loadRawWaveEx(
            self.inner,
            data.as_ptr() as *mut _,
            data.len() as u32,
            samplerate,
            channels,
            copy as i32,
            take_ownership as i32,
        ))
    }

    /// Get the length of the Wav object
    pub fn length(&self) -> f64 {
        unsafe { ffi::Wav_getLength(self.inner) }
    }
}