1 files changed, 132 insertions, 27 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;
         };