cpal 0.2.4

Cross-platform audio playing library in pure Rust.
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

use super::alsa;
use super::check_errors;
use super::Endpoint;

use std::ffi::CStr;
use std::ffi::CString;
use std::mem;

use libc;

/// ALSA implementation for `EndpointsIterator`.
pub struct EndpointsIterator {
    // we keep the original list so that we can pass it to the free function
    global_list: *const *const u8,

    // pointer to the next string ; contained within `global_list`
    next_str: *const *const u8,
}

unsafe impl Send for EndpointsIterator {}
unsafe impl Sync for EndpointsIterator {}

impl Drop for EndpointsIterator {
    #[inline]
    fn drop(&mut self) {
        unsafe {
            alsa::snd_device_name_free_hint(self.global_list as *mut _);
        }
    }
}

impl Default for EndpointsIterator {
    fn default() -> EndpointsIterator {
        unsafe {
            let mut hints = mem::uninitialized();
            // TODO: check in which situation this can fail
            check_errors(alsa::snd_device_name_hint(-1, b"pcm\0".as_ptr() as *const _,
                                                    &mut hints)).unwrap();

            let hints = hints as *const *const u8;

            EndpointsIterator {
                global_list: hints,
                next_str: hints,
            }
        }
    }
}

impl Iterator for EndpointsIterator {
    type Item = Endpoint;

    fn next(&mut self) -> Option<Endpoint> {
        loop {
            unsafe {
                if (*self.next_str).is_null() {
                    return None;
                }

                let name = {
                    let n_ptr = alsa::snd_device_name_get_hint(*self.next_str as *const _,
                                                               b"NAME\0".as_ptr() as *const _);
                    if !n_ptr.is_null() {
                        let n = CStr::from_ptr(n_ptr).to_bytes().to_vec();
                        let n = String::from_utf8(n).unwrap();
                        libc::free(n_ptr as *mut _);
                        Some(n)
                    } else {
                        None
                    }
                };

                let io = {
                    let n_ptr = alsa::snd_device_name_get_hint(*self.next_str as *const _,
                                                               b"IOID\0".as_ptr() as *const _);
                    if !n_ptr.is_null() {
                        let n = CStr::from_ptr(n_ptr).to_bytes().to_vec();
                        let n = String::from_utf8(n).unwrap();
                        libc::free(n_ptr as *mut _);
                        Some(n)
                    } else {
                        None
                    }
                };

                self.next_str = self.next_str.offset(1);

                if let Some(io) = io {
                    if io != "Output" {
                        continue;
                    }
                }

                if let Some(name) = name {
                    // trying to open the PCM device to see if it can be opened
                    let name_zeroed = CString::new(name.clone()).unwrap();
                    let mut playback_handle = mem::uninitialized();
                    if alsa::snd_pcm_open(&mut playback_handle, name_zeroed.as_ptr() as *const _,
                                          alsa::SND_PCM_STREAM_PLAYBACK, alsa::SND_PCM_NONBLOCK) == 0
                    {
                        alsa::snd_pcm_close(playback_handle);
                    } else {
                        continue;
                    }

                    // ignoring the `null` device
                    if name != "null" {
                        return Some(Endpoint(name));
                    }
                }
            }
        }
    }
}

#[inline]
pub fn get_default_endpoint() -> Option<Endpoint> {
    Some(Endpoint("default".to_owned()))
}