chore: Add ability to change player sample rate

Adds the ability for the player to change its sample rate, to be able to
accurately play back local files that aren't sampled at 44.1 kHz.

The functionality to change sample rate must be implemented individually
by each sink. In this commit, support for this has only been added to
the alsa sink.

Testing this by swapping between a 48.0 kHz local file and a 44.1 kHz
Spotify song appears to play back both without any distortion of sound.

Author: SapiensAnatis

playback/src/audio_backend/alsa.rs

@@ -9,8 +9,6 @@ use alsa::{Direction, ValueOr};
 use std::process::exit;
 use thiserror::Error;
 
-const MAX_BUFFER: Frames = (SAMPLE_RATE / 2) as Frames;
-const MIN_BUFFER: Frames = (SAMPLE_RATE / 10) as Frames;
 const ZERO_FRAMES: Frames = 0;
 
 const MAX_PERIOD_DIVISOR: Frames = 4;
@@ -162,7 +160,7 @@ fn list_compatible_devices() -> SinkResult<()> {
     Ok(())
 }
 
-fn open_device(dev_name: &str, format: AudioFormat) -> SinkResult<(PCM, usize)> {
+fn open_device(dev_name: &str, format: AudioFormat, sample_rate: u32) -> SinkResult<(PCM, usize)> {
     let pcm = PCM::new(dev_name, Direction::Playback, false).map_err(|e| AlsaError::PcmSetUp {
         device: dev_name.to_string(),
         e,
@@ -187,10 +185,10 @@ fn open_device(dev_name: &str, format: AudioFormat) -> SinkResult<(PCM, usize)>
                 e,
             })?;
 
-        hwp.set_rate(SAMPLE_RATE, ValueOr::Nearest).map_err(|e| {
+        hwp.set_rate(sample_rate, ValueOr::Nearest).map_err(|e| {
             AlsaError::UnsupportedSampleRate {
                 device: dev_name.to_string(),
-                samplerate: SAMPLE_RATE,
+                samplerate: sample_rate,
                 e,
             }
         })?;
@@ -240,8 +238,11 @@ fn open_device(dev_name: &str, format: AudioFormat) -> SinkResult<(PCM, usize)>
                 Ok(s) => s,
             };
 
+            let max_buffer: Frames = (sample_rate / 2) as Frames;
+            let min_buffer: Frames = (sample_rate / 10) as Frames;
+
             let buffer_size = if min < max {
-                match (MIN_BUFFER..=MAX_BUFFER)
+                match (min_buffer..=max_buffer)
                     .rev()
                     .find(|f| (min..=max).contains(f))
                 {
@@ -269,7 +270,7 @@ fn open_device(dev_name: &str, format: AudioFormat) -> SinkResult<(PCM, usize)>
             };
 
             if buffer_size == ZERO_FRAMES {
-                trace!("Desired Buffer Frame range: {MIN_BUFFER:?} - {MAX_BUFFER:?}",);
+                trace!("Desired Buffer Frame range: {min_buffer:?} - {max_buffer:?}",);
 
                 trace!("Actual Buffer Frame range as reported by the device: {min:?} - {max:?}",);
             }
@@ -416,18 +417,7 @@ impl Open for AlsaSink {
 impl Sink for AlsaSink {
     fn start(&mut self) -> SinkResult<()> {
         if self.pcm.is_none() {
-            let (pcm, bytes_per_period) = open_device(&self.device, self.format)?;
-            self.pcm = Some(pcm);
-
-            if self.period_buffer.capacity() != bytes_per_period {
-                self.period_buffer = Vec::with_capacity(bytes_per_period);
-            }
-
-            // Should always match the "Period Buffer size in bytes: " trace! message.
-            trace!(
-                "Period Buffer capacity: {:?}",
-                self.period_buffer.capacity()
-            );
+            self.start_internal(SAMPLE_RATE)?;
         }
 
         Ok(())
@@ -448,6 +438,13 @@ impl Sink for AlsaSink {
         Ok(())
     }
 
+    fn update_sample_rate(&mut self, new_sample_rate: u32) -> SinkResult<()> {
+        self.stop()?;
+        self.start_internal(new_sample_rate)?;
+
+        Ok(())
+    }
+
     sink_as_bytes!();
 }
 
@@ -483,6 +480,23 @@ impl SinkAsBytes for AlsaSink {
 impl AlsaSink {
     pub const NAME: &'static str = "alsa";
 
+    fn start_internal(&mut self, sample_rate: u32) -> SinkResult<()> {
+        let (pcm, bytes_per_period) = open_device(&self.device, self.format, sample_rate)?;
+        self.pcm = Some(pcm);
+
+        if self.period_buffer.capacity() != bytes_per_period {
+            self.period_buffer = Vec::with_capacity(bytes_per_period);
+        }
+
+        // Should always match the "Period Buffer size in bytes: " trace! message.
+        trace!(
+            "Period Buffer capacity: {:?}",
+            self.period_buffer.capacity()
+        );
+
+        Ok(())
+    }
+
     fn write_buf(&mut self) -> SinkResult<()> {
         if self.pcm.is_some() {
             let write_result = {

playback/src/audio_backend/gstreamer.rs

@@ -172,6 +172,10 @@ impl Sink for GstreamerSink {
         Ok(())
     }
 
+    fn update_sample_rate(&mut self, _new_sample_rate: u32) -> SinkResult<()> {
+        Err(SinkError::SampleRateChange("not implemented".into()))
+    }
+
     sink_as_bytes!();
 }
 

playback/src/audio_backend/jackaudio.rs

@@ -80,6 +80,10 @@ impl Sink for JackSink {
         }
         Ok(())
     }
+
+    fn update_sample_rate(&mut self, _new_sample_rate: u32) -> SinkResult<()> {
+        Err(SinkError::SampleRateChange("not implemented".into()))
+    }
 }
 
 impl JackSink {

playback/src/audio_backend/mod.rs

@@ -15,6 +15,8 @@ pub enum SinkError {
     InvalidParams(String),
     #[error("Audio Sink Error Changing State: {0}")]
     StateChange(String),
+    #[error("Audio Sink Error Updating Sample Rate: {0}")]
+    SampleRateChange(String),
 }
 
 pub type SinkResult<T> = Result<T, SinkError>;
@@ -30,6 +32,9 @@ pub trait Sink {
     fn stop(&mut self) -> SinkResult<()> {
         Ok(())
     }
+
+    fn update_sample_rate(&mut self, new_sample_rate: u32) -> SinkResult<()>;
+
     fn write(&mut self, packet: AudioPacket, converter: &mut Converter) -> SinkResult<()>;
 }
 

playback/src/audio_backend/pipe.rs

@@ -92,6 +92,10 @@ impl Sink for StdoutSink {
         Ok(())
     }
 
+    fn update_sample_rate(&mut self, _new_sample_rate: u32) -> SinkResult<()> {
+        Err(SinkError::SampleRateChange("not implemented".into()))
+    }
+
     sink_as_bytes!();
 }
 

playback/src/audio_backend/portaudio.rs

@@ -173,6 +173,10 @@ impl Sink for PortAudioSink<'_> {
 
         Ok(())
     }
+
+    fn update_sample_rate(&mut self, _new_sample_rate: u32) -> SinkResult<()> {
+        Err(SinkError::SampleRateChange("not implemented".into()))
+    }
 }
 
 impl Drop for PortAudioSink<'_> {

playback/src/audio_backend/pulseaudio.rs

@@ -133,6 +133,10 @@ impl Sink for PulseAudioSink {
         Ok(())
     }
 
+    fn update_sample_rate(&mut self, _new_sample_rate: u32) -> SinkResult<()> {
+        Err(SinkError::SampleRateChange("not implemented".into()))
+    }
+
     sink_as_bytes!();
 }
 

playback/src/audio_backend/rodio.rs

@@ -240,6 +240,10 @@ impl Sink for RodioSink {
         Ok(())
     }
 
+    fn update_sample_rate(&mut self, _new_sample_rate: u32) -> SinkResult<()> {
+        Err(SinkError::SampleRateChange("not implemented".into()))
+    }
+
     fn write(&mut self, packet: AudioPacket, converter: &mut Converter) -> SinkResult<()> {
         let samples = packet
             .samples()

playback/src/audio_backend/sdl.rs

@@ -114,6 +114,10 @@ impl Sink for SdlSink {
         };
         result.map_err(SinkError::OnWrite)
     }
+
+    fn update_sample_rate(&mut self, _new_sample_rate: u32) -> SinkResult<()> {
+        Err(SinkError::SampleRateChange("not implemented".into()))
+    }
 }
 
 impl SdlSink {

playback/src/audio_backend/subprocess.rs

@@ -135,6 +135,10 @@ impl Sink for SubprocessSink {
         }
     }
 
+    fn update_sample_rate(&mut self, _new_sample_rate: u32) -> SinkResult<()> {
+        Err(SinkError::SampleRateChange("not implemented".into()))
+    }
+
     sink_as_bytes!();
 }