audio: open the output at the track's rate instead of pw-alsa's 44100

cpal asks the ALSA "default" PCM for its default config and pipewire-alsa
answers 44.1 kHz no matter what the graph runs at, so 48 kHz material was
resampled down to 44.1 in our linear resampler and then back up to 48 by
PipeWire. The stream now opens at the track's own rate (when the device
supports it), which keeps our resampler out of the path and leaves the
conversion to PipeWire's polyphase one.

The new `sample_rate` setting forces a fixed rate instead ("auto" by
default), for anyone who would rather match the graph exactly.

5 files changed, 211 insertions, 28 deletions

diff --git a/README.md b/README.md
index c2cf39a..678d085 100644
--- a/README.md
+++ b/README.md
@@ -42,6 +42,7 @@ configuration is generated at startup in $XDG_CONFIG_HOME/rsplayer/config.toml
 - display_format (supports $ARTIST $ALBUM and $TRACK)
 - music_paths (for DB usage)
 - scan_interval (same as above)  
+- sample_rate ("auto" follows each track's own rate, or e.g. 48000 to force one)
 
 all other values can be changed in runtime using commands
 
diff --git a/src/audio.rs b/src/audio.rs
index 5ce00ae..dc7bc56 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -138,7 +138,8 @@ pub struct AudioEngine {
 
 #[allow(clippy::new_without_default)]
 impl AudioEngine {
-    pub fn new() -> Self {
+    /// `sample_rate` forces the output rate; `None` follows each track.
+    pub fn new(sample_rate: Option<u32>) -> Self {
         let (tx, rx) = mpsc::channel();
         let is_playing = Arc::new(AtomicBool::new(false));
         let is_playing_clone = Arc::clone(&is_playing);
@@ -161,6 +162,7 @@ impl AudioEngine {
                 volume_clone,
                 track_ended_clone,
                 position_clone,
+                sample_rate,
             );
         });
 
@@ -575,6 +577,63 @@ impl RecoveryState {
     }
 }
 
+/// Picks the output config for a requested sample rate.
+///
+/// `requested` is the rate the audio is already in — the track's own, or the
+/// value forced by the `sample_rate` setting — and `None` keeps whatever the
+/// device reports as its default.
+///
+/// cpal asks the ALSA "default" PCM for its default config, and pipewire-alsa
+/// answers 44.1 kHz regardless of what the graph runs at. Opening the stream
+/// at the track's rate instead means our (linear, cheap) resampler stays out of
+/// the path and PipeWire's polyphase one converts to the graph rate only when
+/// the track does not already match it.
+fn choose_output_config(
+    device: &cpal::Device,
+    requested: Option<u32>,
+) -> Result<cpal::SupportedStreamConfig, String> {
+    use cpal::traits::DeviceTrait;
+
+    let default = device
+        .default_output_config()
+        .map_err(|e| format!("Failed to get output config: {}", e))?;
+    let Some(target) = requested else {
+        return Ok(default);
+    };
+    if default.sample_rate() == target {
+        return Ok(default);
+    }
+
+    let ranges = device
+        .supported_output_configs()
+        .map_err(|e| format!("Failed to query output configs: {}", e))?;
+    let mut fallback = None;
+    for range in ranges {
+        if range.min_sample_rate() > target || range.max_sample_rate() < target {
+            continue;
+        }
+        // Prefer a range that keeps the default's channel count and format.
+        if range.channels() == default.channels()
+            && range.sample_format() == default.sample_format()
+        {
+            return Ok(range.with_sample_rate(target));
+        }
+        fallback.get_or_insert(range);
+    }
+
+    match fallback {
+        Some(range) => Ok(range.with_sample_rate(target)),
+        None => {
+            crate::debug_eprintln(format_args!(
+                "Output does not support {} Hz, using {} Hz",
+                target,
+                default.sample_rate()
+            ));
+            Ok(default)
+        }
+    }
+}
+
 /// Rebuilds the output stream after the backend broke it.
 ///
 /// The default output can change while the daemon runs (a re-plugged DAC, a
@@ -584,16 +643,21 @@ fn rebuild_stream(
     host: &cpal::Host,
     device: &mut cpal::Device,
     ctx: &StreamContext,
+    sample_rate: Option<u32>,
 ) -> Result<cpal::Stream, String> {
-    use cpal::traits::{DeviceTrait, HostTrait};
+    use cpal::traits::HostTrait;
 
     if let Some(fresh) = host.default_output_device() {
         *device = fresh;
     }
 
-    let config = device
-        .default_output_config()
-        .map_err(|e| format!("Failed to get output config while rebuilding: {}", e))?;
+    // Keep the rate the track was opened at, so the resampler ratio stays valid.
+    let track_rate = ctx
+        .audio_data
+        .lock()
+        .ok()
+        .and_then(|data| data.as_ref().map(|state| state.sample_rate));
+    let config = choose_output_config(device, sample_rate.or(track_rate))?;
     let device_sample_rate = config.sample_rate();
 
     // The device may report a different rate now than when the track was
@@ -619,8 +683,9 @@ fn audio_thread(
     volume: Arc<Mutex<f32>>,
     track_ended: Arc<AtomicBool>,
     position: Arc<Mutex<f64>>,
+    sample_rate: Option<u32>,
 ) {
-    use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
+    use cpal::traits::{HostTrait, StreamTrait};
 
     let host = cpal::default_host();
     let mut device = match host.default_output_device() {
@@ -682,25 +747,6 @@ fn audio_thread(
                     recovery.clear();
                     ctx.failed.store(false, Ordering::SeqCst);
 
-                    // Query the config every time instead of caching it at
-                    // startup: the default device or its rate can change while
-                    // the daemon runs.
-                    let config = match device.default_output_config() {
-                        Ok(c) => c,
-                        Err(e) => {
-                            eprintln!("Failed to get output config: {}", e);
-                            notification::notify_error("Failed to query audio output");
-                            is_playing.store(false, Ordering::SeqCst);
-                            continue;
-                        }
-                    };
-                    let device_sample_rate = config.sample_rate();
-                    crate::debug_eprintln(format_args!(
-                        "Default output: {} Hz, {} channels",
-                        device_sample_rate,
-                        config.channels()
-                    ));
-
                     match open_audio_file(&path) {
                         Ok(mut data) => {
                             crate::debug_eprintln(format_args!(
@@ -708,6 +754,29 @@ fn audio_thread(
                                 data.sample_rate, data.channels
                             ));
 
+                            // Ask for the track's own rate unless one is forced:
+                            // the output then runs at the rate the samples are
+                            // already in, and PipeWire converts to the graph rate
+                            // with its polyphase resampler.
+                            let config = match choose_output_config(
+                                &device,
+                                sample_rate.or(Some(data.sample_rate)),
+                            ) {
+                                Ok(c) => c,
+                                Err(e) => {
+                                    eprintln!("Failed to get output config: {}", e);
+                                    notification::notify_error("Failed to query audio output");
+                                    is_playing.store(false, Ordering::SeqCst);
+                                    continue;
+                                }
+                            };
+                            let device_sample_rate = config.sample_rate();
+                            crate::debug_eprintln(format_args!(
+                                "Output: {} Hz, {} channels",
+                                device_sample_rate,
+                                config.channels()
+                            ));
+
                             if data.sample_rate != device_sample_rate {
                                 crate::debug_eprintln(format_args!(
                                     "Resampling from {} Hz to {} Hz",
@@ -870,7 +939,7 @@ fn audio_thread(
             && recovery.retry_at.is_some_and(|at| at <= Instant::now());
         if retry_due {
             recovery.retry_at = None;
-            match rebuild_stream(&host, &mut device, &ctx) {
+            match rebuild_stream(&host, &mut device, &ctx, sample_rate) {
                 Ok(stream) => {
                     current_stream = Some(stream);
                     recovery.stream_built(Instant::now());
@@ -1117,6 +1186,42 @@ mod tests {
     }
 
     #[test]
+    fn keeps_the_device_rate_when_nothing_is_requested() {
+        use cpal::traits::{DeviceTrait, HostTrait};
+
+        let host = cpal::default_host();
+        let Some(device) = host.default_output_device() else {
+            eprintln!("skipped: no output device available");
+            return;
+        };
+        let Ok(default) = device.default_output_config() else {
+            eprintln!("skipped: no default output config available");
+            return;
+        };
+
+        let config = choose_output_config(&device, None).expect("config");
+
+        assert_eq!(config.sample_rate(), default.sample_rate());
+        assert_eq!(config.channels(), default.channels());
+    }
+
+    #[test]
+    fn opens_at_the_requested_rate() {
+        use cpal::traits::{DeviceTrait, HostTrait};
+
+        let host = cpal::default_host();
+        let Some(device) = host.default_output_device() else {
+            eprintln!("skipped: no output device available");
+            return;
+        };
+
+        // 48 kHz is supported by any output that pipes through a graph.
+        let config = choose_output_config(&device, Some(48_000)).expect("config");
+
+        assert_eq!(config.sample_rate(), 48_000);
+    }
+
+    #[test]
     fn rebuilds_stream_after_error() {
         use cpal::traits::{HostTrait, StreamTrait};
 
@@ -1127,7 +1232,7 @@ mod tests {
         };
 
         let ctx = test_context();
-        let Ok(stream) = rebuild_stream(&host, &mut device, &ctx) else {
+        let Ok(stream) = rebuild_stream(&host, &mut device, &ctx, None) else {
             eprintln!("skipped: cannot build output stream");
             return;
         };
diff --git a/src/config.rs b/src/config.rs
index a08f01f..52afd92 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -25,6 +25,8 @@ pub struct Config {
     pub volume: Option<u8>,
     pub shuffle: Option<String>,
     pub display_format: Option<String>,
+    /// Output sample rate: `None` follows the track, `Some` forces a rate.
+    pub sample_rate: Option<String>,
 }
 
 /// Identity of the config file on disk, used to tell whether a cached copy is
@@ -64,6 +66,7 @@ impl Config {
                 volume: Some(50),
                 shuffle: None,
                 display_format: Some(String::from("$ARTIST - $TRACK")),
+                sample_rate: None,
             };
             default.save()?;
             return Ok(default);
@@ -192,6 +195,8 @@ impl Config {
         output.push_str(&format!("shuffle = \"{}\"\n", shuffle));
         let fmt = self.display_format.clone().unwrap_or_default();
         output.push_str(&format!("display_format = \"{}\"\n", fmt));
+        let sample_rate = self.sample_rate.as_deref().unwrap_or("auto");
+        output.push_str(&format!("sample_rate = \"{}\"\n", sample_rate));
         if let Some(parent) = self.config_path.parent() {
             fs::create_dir_all(parent)?;
         }
@@ -207,6 +212,11 @@ impl Config {
         Ok(())
     }
 
+    /// Forced output rate, or `None` to follow each track.
+    pub fn sample_rate_hz(&self) -> Option<u32> {
+        self.sample_rate.as_deref().and_then(|s| s.parse().ok())
+    }
+
     pub fn get(&self, key: &str) -> Result<String, Box<dyn std::error::Error>> {
         match key {
             "music_paths" => Ok(self
@@ -252,6 +262,10 @@ impl Config {
                 .display_format
                 .clone()
                 .unwrap_or_else(|| "not set".to_string())),
+            "sample_rate" => Ok(self
+                .sample_rate
+                .clone()
+                .unwrap_or_else(|| "auto".to_string())),
             _ => Err(format!("Unknown setting: {}", key).into()),
         }
     }
@@ -291,6 +305,20 @@ impl Config {
             "display_format" => {
                 self.display_format = Some(value.to_string());
             }
+            "sample_rate" => {
+                let value = value.trim();
+                if value.eq_ignore_ascii_case("auto") || value == "off" {
+                    self.sample_rate = None;
+                } else {
+                    let rate: u32 = value
+                        .parse()
+                        .map_err(|_| format!("Invalid sample rate: {}", value))?;
+                    if !(8_000..=384_000).contains(&rate) {
+                        return Err(format!("Sample rate must be 8000-384000 Hz: {}", value).into());
+                    }
+                    self.sample_rate = Some(rate.to_string());
+                }
+            }
             _ => return Err(format!("Unknown setting: {}", key).into()),
         }
         Ok(())
@@ -357,6 +385,12 @@ impl Config {
                 .clone()
                 .unwrap_or_else(|| "not set".to_string())
         );
+        println!(
+            "sample_rate = {}",
+            self.sample_rate
+                .clone()
+                .unwrap_or_else(|| "auto".to_string())
+        );
     }
 
     pub fn unset(&mut self, key: &str) -> Result<(), Box<dyn std::error::Error>> {
@@ -370,6 +404,7 @@ impl Config {
             "volume" => self.volume = None,
             "shuffle" => self.shuffle = None,
             "display_format" => self.display_format = None,
+            "sample_rate" => self.sample_rate = None,
             _ => return Err(format!("Unknown setting: {}", key).into()),
         }
         Ok(())
diff --git a/src/daemon.rs b/src/daemon.rs
index eaae64f..3dcb802 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -225,7 +225,7 @@ pub fn start_daemon() -> Result<(), Box<dyn std::error::Error>> {
     let listener = UnixListener::bind(&socket_path)?;
     println!("Listening on {:?}", socket_path);
 
-    let audio_engine = Arc::new(AudioEngine::new());
+    let audio_engine = Arc::new(AudioEngine::new(config.sample_rate_hz()));
     let queue = Arc::new(Mutex::new(Queue::new()));
 
     // Load and apply saved settings
diff --git a/tests/config.rs b/tests/config.rs
index 7b9d179..6a44a17 100644
--- a/tests/config.rs
+++ b/tests/config.rs
@@ -21,6 +21,7 @@ fn test_config_get_scan_interval() {
         volume: None,
         shuffle: None,
         display_format: Some(String::from("$ARTIST - $TRACK")),
+        sample_rate: None,
     };
     assert_eq!(config.get("scan_interval").unwrap(), "3600");
 }
@@ -38,6 +39,7 @@ fn test_config_get_not_set() {
         volume: None,
         shuffle: None,
         display_format: None,
+        sample_rate: None,
     };
     assert_eq!(config.get("scan_interval").unwrap(), "not set");
 }
@@ -55,6 +57,7 @@ fn test_config_get_volume() {
         volume: Some(75),
         shuffle: None,
         display_format: None,
+        sample_rate: None,
     };
     assert_eq!(config.get("volume").unwrap(), "75");
 }
@@ -135,6 +138,7 @@ fn test_config_unset_volume() {
         volume: Some(50),
         shuffle: None,
         display_format: None,
+        sample_rate: None,
     };
     config.unset("volume").unwrap();
     assert_eq!(config.volume, None);
@@ -146,3 +150,41 @@ fn test_config_unset_unknown_key() {
     let result = config.unset("unknown_key");
     assert!(result.is_err());
 }
+
+#[test]
+fn test_config_sample_rate_defaults_to_auto() {
+    let config = Config {
+        config_path: PathBuf::from("/test/config.toml"),
+        music_paths: vec![],
+        scan_interval: None,
+        lastfm_api_key: None,
+        lastfm_api_secret: None,
+        lastfm_session_key: None,
+        listenbrainz_token: None,
+        volume: None,
+        shuffle: None,
+        display_format: None,
+        sample_rate: None,
+    };
+    assert_eq!(config.get("sample_rate").unwrap(), "auto");
+    assert_eq!(config.sample_rate_hz(), None);
+}
+
+#[test]
+fn test_config_set_sample_rate() {
+    let mut config = Config::default();
+    config.set("sample_rate", "48000").unwrap();
+    assert_eq!(config.get("sample_rate").unwrap(), "48000");
+    assert_eq!(config.sample_rate_hz(), Some(48_000));
+
+    config.set("sample_rate", "auto").unwrap();
+    assert_eq!(config.sample_rate_hz(), None);
+}
+
+#[test]
+fn test_config_rejects_bad_sample_rate() {
+    let mut config = Config::default();
+    assert!(config.set("sample_rate", "fast").is_err());
+    assert!(config.set("sample_rate", "100").is_err());
+    assert!(config.set("sample_rate", "999999").is_err());
+}