audio-device 0.1.0-alpha.6

A library for interacting with audio devices
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
139
140
141
142

use crate::alsa::{CString, Result};
use crate::libc as c;
use alsa_sys as alsa;
use std::ffi::CStr;
use std::mem;

/// Construct an iterator over sounds cards.
///
/// # Examples
///
/// ```rust,no_run
/// use audio_device::alsa;
///
/// # fn main() -> anyhow::Result<()> {
/// for card in alsa::cards() {
///     let card = card?;
///     println!("{}", card.name()?.to_str()?);
/// }
/// # Ok(()) }
/// ```
pub fn cards() -> Cards {
    Cards { index: -1 }
}

/// An iterator over available cards.
///
/// See [cards].
pub struct Cards {
    index: c::c_int,
}

impl Iterator for Cards {
    type Item = Result<Card>;

    fn next(&mut self) -> Option<Self::Item> {
        Some(
            if let Err(e) = errno!(unsafe { alsa::snd_card_next(&mut self.index) }) {
                Err(e.into())
            } else {
                if self.index == -1 {
                    return None;
                }

                Ok(Card { index: self.index })
            },
        )
    }
}

/// A reference to a card.
pub struct Card {
    index: c::c_int,
}

impl Card {
    /// Open the given pcm device identified by name.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use audio_device::alsa;
    /// use std::ffi::CStr;
    ///
    /// # fn main() -> anyhow::Result<()> {
    /// let name = CStr::from_bytes_with_nul(b"hw:0\0")?;
    ///
    /// let pcm = alsa::Card::open(name)?;
    /// # Ok(()) }
    /// ```
    pub fn open(name: &CStr) -> Result<Self> {
        unsafe {
            let index = errno!(alsa::snd_card_get_index(
                name.to_bytes().as_ptr() as *const i8
            ))?;
            Ok(Self { index })
        }
    }

    /// Get the index of the card.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use audio_device::alsa;
    ///
    /// # fn main() -> anyhow::Result<()> {
    /// for card in alsa::cards() {
    ///     let card = card?;
    ///     println!("{}", card.index());
    /// }
    /// # Ok(()) }
    /// ```
    pub fn index(&self) -> c::c_int {
        self.index
    }

    /// Get the name of the card.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use audio_device::alsa;
    ///
    /// # fn main() -> anyhow::Result<()> {
    /// for card in alsa::cards() {
    ///     let card = card?;
    ///     println!("{}", card.name()?.to_str()?);
    /// }
    /// # Ok(()) }
    /// ```
    pub fn name(&self) -> Result<CString> {
        unsafe {
            let mut ptr = mem::MaybeUninit::uninit();
            errno!(alsa::snd_card_get_name(self.index, ptr.as_mut_ptr()))?;
            let ptr = ptr.assume_init();
            Ok(CString::from_raw(ptr))
        }
    }

    /// Get the long name of the card.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use audio_device::alsa;
    ///
    /// # fn main() -> anyhow::Result<()> {
    /// for card in alsa::cards() {
    ///     let card = card?;
    ///     println!("{}", card.long_name()?.to_str()?);
    /// }
    /// # Ok(()) }
    /// ```
    pub fn long_name(&self) -> Result<CString> {
        unsafe {
            let mut ptr = mem::MaybeUninit::uninit();
            errno!(alsa::snd_card_get_longname(self.index, ptr.as_mut_ptr()))?;
            let ptr = ptr.assume_init();
            Ok(CString::from_raw(ptr))
        }
    }
}