3 files changed, 168 insertions, 28 deletions

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