1 files changed, 53 insertions, 44 deletions

diff --git a/src/audio.rs b/src/audio.rs
index 62afd93..62d13ff 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -101,7 +101,7 @@ impl AudioEngine {
 
 struct AudioData {
     format: Box<dyn symphonia::core::formats::FormatReader>,
-    decoder: Box<dyn symphonia::core::codecs::Decoder>,
+    decoder: Box<dyn symphonia::core::codecs::audio::AudioDecoder>,
     sample_rate: u32,
     channels: u16,
     sample_buffer: Vec<f32>,
@@ -165,10 +165,10 @@ fn audio_thread(
 
     let device_sample_rate = config.sample_rate();
     let channels = config.channels();
-    eprintln!(
+    crate::debug_eprintln(format_args!(
         "Default output: {} Hz, {} channels",
         device_sample_rate, channels
-    );
+    ));
 
     let mut current_stream: Option<cpal::Stream> = None;
     let audio_data: Arc<Mutex<Option<AudioData>>> = Arc::new(Mutex::new(None));
@@ -186,13 +186,16 @@ fn audio_thread(
 
                 match open_audio_file(&path) {
                     Ok(mut data) => {
-                        eprintln!("File: {} Hz, {} channels", data.sample_rate, data.channels);
+                        crate::debug_eprintln(format_args!(
+                            "File: {} Hz, {} channels",
+                            data.sample_rate, data.channels
+                        ));
 
                         if data.sample_rate != device_sample_rate {
-                            eprintln!(
+                            crate::debug_eprintln(format_args!(
                                 "Resampling from {} Hz to {} Hz",
                                 data.sample_rate, device_sample_rate
-                            );
+                            ));
                             data.resample_ratio =
                                 Some(device_sample_rate as f64 / data.sample_rate as f64);
                         }
@@ -201,28 +204,23 @@ fn audio_thread(
                         let channels = data.channels as usize;
                         for _ in 0..100 {
                             match data.format.next_packet() {
-                                Ok(packet) => match data.decoder.decode(&packet) {
+                                Ok(Some(packet)) => match data.decoder.decode(&packet) {
                                     Ok(decoded) => {
-                                        let spec = *decoded.spec();
-                                        let mut sample_buf = symphonia::core::audio::SampleBuffer::<
-                                            f32,
-                                        >::new(
-                                            decoded.capacity() as u64, spec
-                                        );
-                                        sample_buf.copy_interleaved_ref(decoded);
-                                        let samples = sample_buf.samples();
+                                        let num_samples = decoded.samples_interleaved();
+                                        let mut samples = vec![0.0f32; num_samples];
+                                        decoded.copy_to_slice_interleaved(&mut samples);
 
                                         let resampled = if let Some(ratio) = data.resample_ratio {
-                                            resample_linear(samples, ratio, channels)
+                                            resample_linear(&samples, ratio, channels)
                                         } else {
-                                            samples.to_vec()
+                                            samples
                                         };
 
                                         data.sample_buffer.extend(resampled);
                                     }
                                     Err(_) => break,
                                 },
-                                Err(_) => break,
+                                _ => break,
                             }
                         }
                         data.buffer_pos = 0;
@@ -274,29 +272,26 @@ fn audio_thread(
 
                                             // Decode more data
                                             match state.format.next_packet() {
-                                                Ok(packet) => {
+                                                Ok(Some(packet)) => {
                                                     match state.decoder.decode(&packet) {
                                                         Ok(decoded) => {
-                                                            let spec = *decoded.spec();
-                                                            let mut sample_buf =
-                                                        symphonia::core::audio::SampleBuffer::<
-                                                            f32,
-                                                        >::new(
-                                                            decoded.capacity() as u64, spec
-                                                        );
-                                                            sample_buf
-                                                                .copy_interleaved_ref(decoded);
-                                                            let samples = sample_buf.samples();
+                                                            let num_samples =
+                                                                decoded.samples_interleaved();
+                                                            let mut samples =
+                                                                vec![0.0f32; num_samples];
+                                                            decoded.copy_to_slice_interleaved(
+                                                                &mut samples,
+                                                            );
 
                                                             // Resample if needed
                                                             let resampled = if let Some(ratio) =
                                                                 state.resample_ratio
                                                             {
                                                                 resample_linear(
-                                                                    samples, ratio, channels,
+                                                                    &samples, ratio, channels,
                                                                 )
                                                             } else {
-                                                                samples.to_vec()
+                                                                samples
                                                             };
 
                                                             // Copy what we can to output
@@ -323,7 +318,7 @@ fn audio_thread(
                                                         Err(_) => break,
                                                     }
                                                 }
-                                                Err(_) => break,
+                                                _ => break,
                                             }
                                         }
 
@@ -419,36 +414,50 @@ fn audio_thread(
 }
 
 fn open_audio_file(path: &PathBuf) -> Result<AudioData, Box<dyn std::error::Error>> {
-    use symphonia::core::audio::Channels;
+    use symphonia::core::audio::layouts::CHANNEL_LAYOUT_STEREO;
+    use symphonia::core::codecs::audio::AudioDecoderOptions;
+    use symphonia::core::formats::probe::Hint;
     use symphonia::core::io::MediaSourceStream;
 
     let file = std::fs::File::open(path)?;
     let mss = MediaSourceStream::new(Box::new(file), Default::default());
 
-    let hint = symphonia::core::probe::Hint::new();
-    let probed = symphonia::default::get_probe().format(
+    let hint = Hint::new();
+    let format = symphonia::default::get_probe().probe(
         &hint,
         mss,
-        &Default::default(),
-        &Default::default(),
+        Default::default(),
+        Default::default(),
     )?;
 
-    let format = probed.format;
     let track = format
         .tracks()
         .iter()
-        .find(|t| t.codec_params.sample_rate.is_some())
+        .find(|t| {
+            t.codec_params
+                .as_ref()
+                .and_then(|p| p.audio())
+                .and_then(|a| a.sample_rate)
+                .is_some()
+        })
         .ok_or("No suitable track found")?;
 
-    let sample_rate = track.codec_params.sample_rate.unwrap_or(44100);
-    let channels = track
+    let codec_params = track
         .codec_params
+        .as_ref()
+        .ok_or("No codec parameters")?
+        .audio()
+        .ok_or("Not an audio track")?;
+
+    let sample_rate = codec_params.sample_rate.unwrap_or(44100);
+    let channels = codec_params
         .channels
-        .unwrap_or(Channels::FRONT_LEFT | Channels::FRONT_RIGHT)
+        .clone()
+        .unwrap_or(CHANNEL_LAYOUT_STEREO)
         .count() as u16;
 
-    let decoder =
-        symphonia::default::get_codecs().make(&track.codec_params, &Default::default())?;
+    let decoder = symphonia::default::get_codecs()
+        .make_audio_decoder(codec_params, &AudioDecoderOptions::default())?;
 
     Ok(AudioData {
         format,