teamtalk 6.0.0

TeamTalk SDK for Rust
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

//! Windows mixer control APIs.
#[cfg(windows)]
use super::Client;
#[cfg(windows)]
use crate::types::TT_STRLEN;
#[cfg(windows)]
use crate::utils::strings::tt_buf;
#[cfg(windows)]
use teamtalk_sys as ffi;

#[cfg(windows)]
impl Client {
    /// Returns the number of mixer devices.
    pub fn get_mixer_count(&self) -> i32 {
        unsafe { ffi::api().TT_Mixer_GetMixerCount() }
    }

    /// Returns the mixer name by index.
    pub fn get_mixer_name(&self, index: i32) -> String {
        let mut buf = tt_buf::<TT_STRLEN>();
        unsafe {
            if ffi::api().TT_Mixer_GetMixerName(index, buf.as_mut_ptr()) == 1 {
                crate::utils::strings::to_string(&buf)
            } else {
                String::new()
            }
        }
    }

    /// Mutes or unmutes mixer output.
    pub fn set_mixer_output_mute(&self, wave_id: i32, control: ffi::MixerControl, mute: bool) -> bool {
        unsafe { ffi::api().TT_Mixer_SetWaveOutMute(wave_id, control, mute as i32) == 1 }
    }

    /// Returns mixer output mute state.
    pub fn get_mixer_output_mute(&self, wave_id: i32, control: ffi::MixerControl) -> i32 {
        unsafe { ffi::api().TT_Mixer_GetWaveOutMute(wave_id, control) }
    }

    /// Sets mixer output volume.
    pub fn set_mixer_output_volume(&self, wave_id: i32, control: ffi::MixerControl, vol: i32) -> bool {
        unsafe { ffi::api().TT_Mixer_SetWaveOutVolume(wave_id, control, vol) == 1 }
    }

    /// Returns mixer output volume.
    pub fn get_mixer_output_volume(&self, wave_id: i32, control: ffi::MixerControl) -> i32 {
        unsafe { ffi::api().TT_Mixer_GetWaveOutVolume(wave_id, control) }
    }

    /// Mutes or unmutes mixer input.
    pub fn set_mixer_input_mute(&self, wave_id: i32, mute: bool) -> bool {
        unsafe { ffi::api().TT_Mixer_SetWaveInMute(wave_id, mute as i32) == 1 }
    }

    /// Returns mixer input mute state.
    pub fn get_mixer_input_mute(&self, wave_id: i32) -> i32 {
        unsafe { ffi::api().TT_Mixer_GetWaveInMute(wave_id) }
    }

    /// Returns mixer input device name.
    pub fn get_mixer_wave_in_name(&self, wave_id: i32) -> String {
        let mut buf = tt_buf::<TT_STRLEN>();
        unsafe {
            if ffi::api().TT_Mixer_GetWaveInName(wave_id, buf.as_mut_ptr()) == 1 {
                crate::utils::strings::to_string(&buf)
            } else {
                String::new()
            }
        }
    }

    /// Returns mixer output device name.
    pub fn get_mixer_wave_out_name(&self, wave_id: i32) -> String {
        let mut buf = tt_buf::<TT_STRLEN>();
        unsafe {
            if ffi::api().TT_Mixer_GetWaveOutName(wave_id, buf.as_mut_ptr()) == 1 {
                crate::utils::strings::to_string(&buf)
            } else {
                String::new()
            }
        }
    }

    /// Enables or disables mixer input boost.
    pub fn set_mixer_input_boost(&self, wave_id: i32, enable: bool) -> bool {
        unsafe { ffi::api().TT_Mixer_SetWaveInBoost(wave_id, enable as i32) == 1 }
    }

    /// Returns mixer input boost state.
    pub fn get_mixer_input_boost(&self, wave_id: i32) -> i32 {
        unsafe { ffi::api().TT_Mixer_GetWaveInBoost(wave_id) }
    }

    /// Returns the number of mixer input controls.
    pub fn get_mixer_input_control_count(&self, wave_id: i32) -> i32 {
        unsafe { ffi::api().TT_Mixer_GetWaveInControlCount(wave_id) }
    }

    /// Returns a mixer input control name.
    pub fn get_mixer_input_control_name(&self, wave_id: i32, index: i32) -> String {
        let mut buf = tt_buf::<TT_STRLEN>();
        unsafe {
            if ffi::api().TT_Mixer_GetWaveInControlName(wave_id, index, buf.as_mut_ptr()) == 1 {
                crate::utils::strings::to_string(&buf)
            } else {
                String::new()
            }
        }
    }

    /// Selects a mixer input control.
    pub fn set_mixer_input_control_selected(&self, wave_id: i32, index: i32) -> bool {
        unsafe { ffi::api().TT_Mixer_SetWaveInControlSelected(wave_id, index) == 1 }
    }

    /// Returns whether a mixer input control is selected.
    pub fn get_mixer_input_control_selected(&self, wave_id: i32, index: i32) -> bool {
        unsafe { ffi::api().TT_Mixer_GetWaveInControlSelected(wave_id, index) == 1 }
    }

    /// Selects a mixer input enum control.
    pub fn set_mixer_input_selected(&self, wave_id: i32, control: ffi::MixerControl) -> bool {
        unsafe { ffi::api().TT_Mixer_SetWaveInSelected(wave_id, control) == 1 }
    }

    /// Returns the state of a mixer input enum control.
    pub fn get_mixer_input_selected(&self, wave_id: i32, control: ffi::MixerControl) -> i32 {
        unsafe { ffi::api().TT_Mixer_GetWaveInSelected(wave_id, control) }
    }

    /// Sets the volume of a mixer input enum control.
    pub fn set_mixer_input_volume(&self, wave_id: i32, control: ffi::MixerControl, vol: i32) -> bool {
        unsafe { ffi::api().TT_Mixer_SetWaveInVolume(wave_id, control, vol) == 1 }
    }

    /// Returns the volume of a mixer input enum control.
    pub fn get_mixer_input_volume(&self, wave_id: i32, control: ffi::MixerControl) -> i32 {
        unsafe { ffi::api().TT_Mixer_GetWaveInVolume(wave_id, control) }
    }
}