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.

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;
         };