AudioStream locking support with Callback API (#138)

Author: cynthia2006

examples/audio-capture-and-replay.rs

@@ -1,6 +1,6 @@
 extern crate sdl3;
 
-use sdl3::audio::{AudioCallback, AudioSpec};
+use sdl3::audio::{AudioCallback, AudioFormat, AudioRecordingCallback, AudioSpec, AudioStream};
 use sdl3::AudioSubsystem;
 use std::i16;
 use std::sync::mpsc;
@@ -17,22 +17,21 @@ struct Recording {
 
 // Append the input of the callback to the record_buffer.
 // When the record_buffer is full, send it to the main thread via done_sender.
-impl AudioCallback<i16> for Recording {
-    fn callback(&mut self, input: &mut [i16]) {
+impl AudioRecordingCallback<i16> for Recording {
+    fn callback(&mut self, stream: &mut AudioStream, _available: i32) {
         if self.done {
             return;
         }
 
-        for x in input {
-            self.record_buffer[self.pos] = *x;
-            self.pos += 1;
-            if self.pos >= self.record_buffer.len() {
-                self.done = true;
-                self.done_sender
-                    .send(self.record_buffer.clone())
-                    .expect("could not send record buffer");
-                break;
-            }
+        self.pos += stream
+            .read_i16_samples(&mut self.record_buffer[self.pos..])
+            .unwrap();
+
+        if self.pos >= self.record_buffer.len() {
+            self.done = true;
+            self.done_sender
+                .send(self.record_buffer.clone())
+                .expect("could not send record buffer");
         }
     }
 }
@@ -96,15 +95,11 @@ fn calculate_max_volume(recorded_vec: &[i16]) -> f32 {
 
 struct SoundPlayback {
     data: Vec<i16>,
-    pos: usize,
 }
 
 impl AudioCallback<i16> for SoundPlayback {
-    fn callback(&mut self, out: &mut [i16]) {
-        for dst in out.iter_mut() {
-            *dst = *self.data.get(self.pos).unwrap_or(&0);
-            self.pos += 1;
-        }
+    fn callback(&mut self, stream: &mut AudioStream, _requested: i32) {
+        stream.put_data_i16(&self.data).unwrap();
     }
 }
 
@@ -115,13 +110,8 @@ fn replay_recorded_vec(
 ) -> Result<(), Box<dyn std::error::Error>> {
     println!("Playing...");
 
-    let playback_device = audio_subsystem.open_playback_stream(
-        desired_spec,
-        SoundPlayback {
-            data: recorded_vec,
-            pos: 0,
-        },
-    )?;
+    let playback_device =
+        audio_subsystem.open_playback_stream(desired_spec, SoundPlayback { data: recorded_vec })?;
 
     // Start playback
     playback_device.resume()?;
@@ -137,9 +127,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let audio_subsystem = sdl_context.audio()?;
 
     let desired_spec = AudioSpec {
-        freq: None,
-        channels: None,
-        format: None,
+        freq: Some(48000),
+        channels: Some(2),
+        format: Some(AudioFormat::s16_sys()),
     };
 
     let recorded_vec = record(&audio_subsystem, &desired_spec)?;

examples/audio-squarewave.rs

@@ -1,25 +1,30 @@
 extern crate sdl3;
 
-use sdl3::audio::{AudioCallback, AudioSpec};
+use sdl3::audio::{AudioCallback, AudioFormat, AudioSpec, AudioStream};
 use std::time::Duration;
 
 struct SquareWave {
     phase_inc: f32,
     phase: f32,
     volume: f32,
+    buffer: Vec<f32>,
 }
 
 impl AudioCallback<f32> for SquareWave {
-    fn callback(&mut self, out: &mut [f32]) {
+    fn callback(&mut self, stream: &mut AudioStream, requested: i32) {
+        self.buffer.resize(requested as usize, 0.0);
+
         // Generate a square wave
-        for x in out.iter_mut() {
+        for x in self.buffer.iter_mut() {
             *x = if self.phase <= 0.5 {
                 self.volume
             } else {
                 -self.volume
             };
             self.phase = (self.phase + self.phase_inc) % 1.0;
         }
+
+        stream.put_data_f32(&self.buffer).unwrap();
     }
 }
 
@@ -28,9 +33,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let audio_subsystem = sdl_context.audio()?;
 
     let desired_spec = AudioSpec {
-        freq: Some(44_100),
+        freq: Some(48000),
         channels: Some(1), // mono
-        format: None,
+        format: Some(AudioFormat::f32_sys()),
     };
 
     let device = audio_subsystem.open_playback_stream(
@@ -39,6 +44,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             phase_inc: 440.0 / desired_spec.freq.unwrap() as f32,
             phase: 0.0,
             volume: 0.25,
+            buffer: Vec::new(),
         },
     )?;
 

examples/audio-wav.rs

@@ -1,6 +1,6 @@
 extern crate sdl3;
 
-use sdl3::audio::{AudioCallback, AudioSpec, AudioSpecWAV};
+use sdl3::audio::{AudioCallback, AudioSpec, AudioSpecWAV, AudioStream};
 use std::borrow::Cow;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
@@ -14,8 +14,10 @@ struct Sound {
     pos: usize,
 }
 
+// FIXME: Adapt to new playback api.
+#[cfg(feature = "")]
 impl AudioCallback<u8> for Sound {
-    fn callback(&mut self, out: &mut [u8]) {
+    fn callback(&mut self, out: &[u8]) {
         for dst in out.iter_mut() {
             // With channel type u8 the "silence" value is 128 (middle of the 0-2^8 range) so we need
             // to both fill in the silence and scale the wav data accordingly. Filling the silence

examples/audio-whitenoise.rs

@@ -1,27 +1,26 @@
 extern crate rand;
 extern crate sdl3;
 
-use sdl3::audio::{AudioCallback, AudioSpec};
-use std::{
-    sync::{Arc, Mutex},
-    time::Duration,
-};
+use sdl3::audio::{AudioCallback, AudioFormat, AudioSpec, AudioStream};
+use std::time::Duration;
 
 struct MyCallback {
-    volume: Arc<Mutex<f32>>, // it seems like AudioStreamWithCallback<> is supposed to have a lock() method which allows us to modify MyCallback, but that function no longer seems to exist
+    volume: f32,
+    buffer: Vec<f32>,
 }
 impl AudioCallback<f32> for MyCallback {
-    fn callback(&mut self, out: &mut [f32]) {
+    fn callback(&mut self, stream: &mut AudioStream, requested: i32) {
         use self::rand::{thread_rng, Rng};
         let mut rng = thread_rng();
 
-        let Ok(volume) = self.volume.lock() else {
-            return;
-        };
+        self.buffer.resize(requested as usize, 0.0);
+
         // Generate white noise
-        for x in out.iter_mut() {
-            *x = (rng.gen_range(0.0..=2.0) - 1.0) * *volume;
+        for x in self.buffer.iter_mut() {
+            *x = (rng.gen_range(0.0..=2.0) - 1.0) * self.volume;
         }
+
+        stream.put_data_f32(&self.buffer);
     }
 }
 
@@ -30,19 +29,19 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let audio_subsystem = sdl_context.audio()?;
 
     let desired_spec = AudioSpec {
-        freq: Some(44_100),
+        freq: Some(48000),
         channels: Some(1), // mono
-        format: None,
+        format: Some(AudioFormat::f32_sys()),
     };
     let device = audio_subsystem.open_playback_device(&desired_spec)?;
 
     // None: use default device
-    let volume = Arc::new(Mutex::new(0.5));
-    let device = audio_subsystem.open_playback_stream_with_callback(
+    let mut device = audio_subsystem.open_playback_stream_with_callback(
         &device,
         &desired_spec,
         MyCallback {
-            volume: volume.clone(),
+            volume: 0.0,
+            buffer: Vec::new(),
         },
     )?;
 
@@ -52,8 +51,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Play for 1 second
     std::thread::sleep(Duration::from_millis(1_000));
 
-    if let Ok(mut volume) = volume.lock() {
-        *volume = 0.25;
+    if let Some(mut context) = device.lock() {
+        context.volume = 0.25;
     }
 
     // Play for another second