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
use {DeviceCollection, DeviceId, DeviceType, Result, Stream, StreamParamsRef};
use ffi;
use std::{ptr, str};
use std::ffi::CStr;
use std::os::raw::c_void;
use util::opt_bytes;
macro_rules! as_ptr {
($e:expr) => { $e.map(|s| s.as_ptr()).unwrap_or(ptr::null_mut()) }
}
ffi_type_heap! {
type CType = ffi::cubeb;
fn drop = ffi::cubeb_destroy;
pub struct Context;
pub struct ContextRef;
}
impl Context {
pub fn init(context_name: Option<&CStr>, backend_name: Option<&CStr>) -> Result<Context> {
let mut context: *mut ffi::cubeb = ptr::null_mut();
let context_name = as_ptr!(context_name);
let backend_name = as_ptr!(backend_name);
unsafe {
try_call!(ffi::cubeb_init(&mut context, context_name, backend_name));
Ok(Context::from_ptr(context))
}
}
}
impl ContextRef {
pub fn backend_id(&self) -> &str {
str::from_utf8(self.backend_id_bytes()).unwrap()
}
pub fn backend_id_bytes(&self) -> &[u8] {
unsafe { opt_bytes(ffi::cubeb_get_backend_id(self.as_ptr())).unwrap() }
}
pub fn max_channel_count(&self) -> Result<u32> {
let mut channel_count = 0u32;
unsafe {
let _ = try_call!(ffi::cubeb_get_max_channel_count(
self.as_ptr(),
&mut channel_count
));
}
Ok(channel_count)
}
pub fn min_latency(&self, params: &StreamParamsRef) -> Result<u32> {
let mut latency = 0u32;
unsafe {
let _ = try_call!(ffi::cubeb_get_min_latency(
self.as_ptr(),
params.as_ptr(),
&mut latency
));
}
Ok(latency)
}
pub fn preferred_sample_rate(&self) -> Result<u32> {
let mut rate = 0u32;
unsafe {
let _ = try_call!(ffi::cubeb_get_preferred_sample_rate(
self.as_ptr(),
&mut rate
));
}
Ok(rate)
}
#[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
pub unsafe fn stream_init(
&self,
stream_name: Option<&CStr>,
input_device: DeviceId,
input_stream_params: Option<&StreamParamsRef>,
output_device: DeviceId,
output_stream_params: Option<&StreamParamsRef>,
latency_frames: u32,
data_callback: ffi::cubeb_data_callback,
state_callback: ffi::cubeb_state_callback,
user_ptr: *mut c_void,
) -> Result<Stream> {
let mut stm: *mut ffi::cubeb_stream = ptr::null_mut();
let stream_name = as_ptr!(stream_name);
let input_stream_params = as_ptr!(input_stream_params);
let output_stream_params = as_ptr!(output_stream_params);
let _ = try_call!(ffi::cubeb_stream_init(
self.as_ptr(),
&mut stm,
stream_name,
input_device,
input_stream_params,
output_device,
output_stream_params,
latency_frames,
data_callback,
state_callback,
user_ptr
));
Ok(Stream::from_ptr(stm))
}
pub fn enumerate_devices(&self, devtype: DeviceType) -> Result<DeviceCollection> {
let mut coll = ffi::cubeb_device_collection::default();
unsafe {
let _ = try_call!(ffi::cubeb_enumerate_devices(
self.as_ptr(),
devtype.bits(),
&mut coll
));
}
Ok(DeviceCollection::init_with_ctx(self, coll))
}
pub unsafe fn register_device_collection_changed(
&self,
devtype: DeviceType,
callback: ffi::cubeb_device_collection_changed_callback,
user_ptr: *mut c_void,
) -> Result<()> {
let _ = try_call!(ffi::cubeb_register_device_collection_changed(
self.as_ptr(),
devtype.bits(),
callback,
user_ptr
));
Ok(())
}
}