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

@@ -10,7 +10,7 @@ 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 MIN_BUFFER: Frames = (SAMPLE_RATE / 10) as Frames; // TODO: this is likely no longer valid with variable sampling rates
 const ZERO_FRAMES: Frames = 0;
 
 const MAX_PERIOD_DIVISOR: Frames = 4;
@@ -162,7 +162,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 +187,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,
             }
         })?;
@@ -416,18 +416,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 +437,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 +479,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!();
 }