1
1
use sdl2:: audio:: { AudioCallback , AudioDevice , AudioSpecDesired } ;
2
2
3
- pub struct Audio {
3
+ type AudioDeviceIndex = u32 ;
4
+
5
+ pub struct AudioCaptureDevice {
6
+ name : String ,
7
+ index : AudioDeviceIndex ,
8
+ }
9
+
10
+ pub struct Audio < ' a > {
4
11
audio_subsystem : sdl2:: AudioSubsystem ,
5
- audio_device_index : u8 ,
6
- // device_list: Vec<sdl2::audio::AudioDevice>,
12
+ audio_device_index : AudioDeviceIndex , // device_list: Option<Vec<sdl2::audio::AudioDevice>>,
13
+ frame_rate : Option < u32 > ,
14
+ capturing_device : Option < AudioDevice < AudioCaptureCallback > > ,
7
15
}
8
16
9
- impl Audio {
17
+ impl Audio < ' _ > {
10
18
pub fn new ( sdl_context : & sdl2:: Sdl ) -> Self {
11
19
let audio_subsystem = sdl_context. audio ( ) . unwrap ( ) ;
12
20
13
21
Self {
14
22
audio_subsystem,
15
23
audio_device_index : 0 ,
24
+ frame_rate : None ,
25
+ capturing_device : None ,
16
26
}
17
27
}
18
28
19
- // pub fn get_device_list(mut self) -> Vec<sdl2::audio::AudioDevice> {
20
- // let audio_subsystem = sdl_context.audio().unwrap();
21
- // let device_list = audio_subsystem
22
- // .capture_devices()
23
- // .expect("could not get audio device list");
24
- // for (i, device) in device_list.enumerate() {
25
- // println!("{}: {}", i, device.name());
26
- // }
27
- // }
29
+ pub fn init ( & mut self , frame_rate : u32 ) {
30
+ self . frame_rate = frame_rate. into ( ) ;
31
+ self . begin_audio_capture ( ) ;
32
+ }
33
+
34
+ pub fn list_devices ( & self ) {
35
+ self . get_device_list ( ) ;
36
+ }
37
+
38
+ pub fn set_device ( & mut self , device_index : AudioDeviceIndex ) {
39
+ self . stop_audio_capture ( ) ;
40
+ self . audio_device_index = device_index;
41
+ self . begin_audio_capture ( ) ;
42
+ }
43
+
44
+ pub fn get_current_device_name ( & self ) -> String {
45
+ let device_name = self
46
+ . audio_subsystem
47
+ . audio_capture_device_name ( self . audio_device_index )
48
+ . expect ( "could not get audio device" ) ;
49
+ device_name
50
+ }
51
+
52
+ pub fn open_next_device ( & mut self ) {
53
+ let device_list = self . get_device_list ( ) ;
54
+ let current_device_index = self . audio_device_index ;
55
+
56
+ let next_device_index = current_device_index + 1 % device_list. len ( ) as AudioDeviceIndex ;
57
+ self . set_device ( next_device_index) ;
58
+ }
59
+
60
+ fn get_device_list ( & self ) -> Vec < AudioCaptureDevice > {
61
+ let audio_subsystem = & self . audio_subsystem ;
62
+
63
+ let num_devices = audio_subsystem
64
+ . num_audio_capture_devices ( )
65
+ . expect ( "could not get number of audio devices" ) ;
66
+
67
+ let mut device_list: Vec < AudioCaptureDevice > = vec ! [ ] ;
28
68
29
- pub fn begin_audio_capture ( self , frame_rate : u32 ) {
69
+ for i in 0 ..num_devices {
70
+ let device_name = audio_subsystem
71
+ . audio_capture_device_name ( i)
72
+ . expect ( "could not get audio device" ) ;
73
+ println ! ( "{}: {}" , i, device_name) ;
74
+
75
+ device_list. push ( AudioCaptureDevice {
76
+ name : device_name,
77
+ index : i,
78
+ } ) ;
79
+ }
80
+
81
+ device_list
82
+ }
83
+
84
+ pub fn begin_audio_capture < ' a > ( & ' a mut self ) {
30
85
let sample_rate: u32 = 44100 ;
86
+ let frame_rate: u32 = self
87
+ . frame_rate
88
+ . expect ( "frame rate not set, call init() pls" ) ;
31
89
32
90
// should be enough for 1 frame
33
91
let buffer_size = ( sample_rate / frame_rate) as u16 ;
@@ -38,17 +96,59 @@ impl Audio {
38
96
samples : Some ( buffer_size) ,
39
97
} ;
40
98
41
- // let audio_device = self
42
- // .audio_subsystem
43
- // .open_capture(None, &desired_spec, |spec| {
44
- // // initialize the audio callback
45
- // AudioCallback {
46
- // spec,
47
- // buffer_size,
48
- // buffer: vec![0; buffer_size as usize],
49
- // position: 0,
50
- // }
51
- // })
52
- // .unwrap();
99
+ // let mut audio_device: &'a AudioDevice<AudioCaptureCallback> = &self
100
+ let mut audio_device = self
101
+ . audio_subsystem // sdl
102
+ . open_capture ( None , & desired_spec, |spec| {
103
+ println ! (
104
+ "Beginning audio capture for device {}" ,
105
+ self . get_current_device_name( )
106
+ ) ;
107
+ // return callback fn
108
+ AudioCaptureCallback {
109
+ spec,
110
+ buffer_size,
111
+ buffer : vec ! [ 0 ; buffer_size as usize ] ,
112
+ position : 0 ,
113
+ }
114
+ } )
115
+ . unwrap ( ) ;
116
+
117
+ self . capturing_device = Some ( audio_device) ;
118
+ }
119
+
120
+ pub fn stop_audio_capture ( & self ) {
121
+ let current_device_name = self . get_current_device_name ( ) ;
122
+ println ! ( "Stopping audio capture for device {}" , current_device_name) ;
123
+
124
+ let current_device = self . audio_device_index ;
125
+ drop ( self . capturing_device ) ;
126
+ }
127
+ }
128
+
129
+ struct AudioCaptureCallback {
130
+ spec : sdl2:: audio:: AudioSpec ,
131
+ buffer_size : u16 ,
132
+ buffer : Vec < u8 > ,
133
+ position : usize ,
134
+ }
135
+
136
+ impl AudioCallback for AudioCaptureCallback {
137
+ type Channel = i16 ;
138
+
139
+ fn callback ( & mut self , out : & mut [ i16 ] ) {
140
+ // let buffer = &mut self.buffer;
141
+ // let position = &mut self.position;
142
+ // let buffer_size = self.buffer_size;
143
+
144
+ // let mut i = 0;
145
+ // while i < out.len() {
146
+ // out[i] = buffer[*position];
147
+ // *position += 1;
148
+ // if *position >= buffer_size as usize {
149
+ // *position = 0;
150
+ // }
151
+ // i += 1;
152
+ // }
53
153
}
54
154
}
0 commit comments