Fix: Audio not playing on Windows

This may also fix issues on other devices, however this is not confirmed as I do not have alternative Operating Systems to check on

Author: RobinDadswell

src-tauri/src/sendspin/devices.rs

@@ -5,6 +5,15 @@
 
 use cpal::traits::{DeviceTrait, HostTrait};
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeSet;
+
+/// Sendspin PCM format candidate derived from device capabilities.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct SupportedPcmFormat {
+    pub channels: u16,
+    pub sample_rate: u32,
+    pub bit_depth: u16,
+}
 
 /// Information about an audio output device
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -125,6 +134,107 @@ pub fn get_default_device() -> Result<cpal::Device, String> {
         .ok_or_else(|| "No default output device available".to_string())
 }
 
+/// Resolve output device based on optional device ID.
+/// Falls back to default output device if the requested device is not available.
+pub fn resolve_output_device(device_id: Option<&str>) -> Option<cpal::Device> {
+    if let Some(id) = device_id {
+        match get_device_by_id(id) {
+            Ok(device) => {
+                let name = device
+                    .name()
+                    .unwrap_or_else(|_| "<unknown device>".to_string());
+                eprintln!("[Sendspin] Using configured output device: {}", name);
+                return Some(device);
+            }
+            Err(e) => {
+                eprintln!(
+                    "[Sendspin] Failed to get device {}: {}, falling back to default output",
+                    id, e
+                );
+            }
+        }
+    }
+
+    match get_default_device() {
+        Ok(device) => {
+            let name = device
+                .name()
+                .unwrap_or_else(|_| "<unknown device>".to_string());
+            eprintln!("[Sendspin] Using default output device: {}", name);
+            Some(device)
+        }
+        Err(e) => {
+            eprintln!("[Sendspin] Failed to get default output device: {}", e);
+            None
+        }
+    }
+}
+
+/// Build supported PCM stream formats for Sendspin negotiation.
+///
+/// Strategy:
+/// - Prefer stereo stream formats for compatibility with current playback path.
+/// - Use stable/common rates first.
+/// - Advertise 24-bit only if the output config clearly supports 24-bit integer samples.
+/// - Always include 16-bit for broad compatibility where possible.
+pub fn derive_supported_pcm_formats(device: Option<&cpal::Device>) -> Vec<SupportedPcmFormat> {
+    let Some(device) = device else {
+        return vec![];
+    };
+
+    let Ok(configs) = device.supported_output_configs() else {
+        return vec![];
+    };
+
+    let mut collected = BTreeSet::new();
+    let preferred_rates = [48_000u32, 44_100u32, 96_000u32];
+
+    for cfg in configs {
+        // Keep negotiation aligned with the stereo playback path.
+        if cfg.channels() < 2 {
+            continue;
+        }
+
+        let min_rate = cfg.min_sample_rate().0;
+        let max_rate = cfg.max_sample_rate().0;
+        let sample_format_label = format!("{:?}", cfg.sample_format());
+        let supports_24bit = sample_format_label.contains("I24");
+
+        for rate in preferred_rates {
+            if rate < min_rate || rate > max_rate {
+                continue;
+            }
+
+            collected.insert(SupportedPcmFormat {
+                channels: 2,
+                sample_rate: rate,
+                bit_depth: 16,
+            });
+
+            if supports_24bit {
+                collected.insert(SupportedPcmFormat {
+                    channels: 2,
+                    sample_rate: rate,
+                    bit_depth: 24,
+                });
+            }
+        }
+    }
+
+    let mut result: Vec<_> = collected.into_iter().collect();
+    result.sort_by_key(|f| {
+        let rate_rank = match f.sample_rate {
+            48_000 => 0,
+            44_100 => 1,
+            96_000 => 2,
+            _ => 3,
+        };
+        let depth_rank = i32::from(f.bit_depth != 16);
+        (rate_rank, depth_rank, f.sample_rate, f.bit_depth)
+    });
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src-tauri/src/sendspin/mod.rs

@@ -51,6 +51,31 @@ fn rand_jitter_ms(max_ms: u64) -> u64 {
     nanos % range
 }
 
+fn fallback_supported_formats() -> Vec<AudioFormatSpec> {
+    vec![
+        AudioFormatSpec {
+            codec: "pcm".to_string(),
+            channels: 2,
+            sample_rate: 48000,
+            bit_depth: 16,
+        },
+        AudioFormatSpec {
+            codec: "pcm".to_string(),
+            channels: 2,
+            sample_rate: 44100,
+            bit_depth: 16,
+        },
+    ]
+}
+
+fn format_specs_to_log_string(formats: &[AudioFormatSpec]) -> String {
+    formats
+        .iter()
+        .map(|f| format!("{}ch/{}Hz/{}bit", f.channels, f.sample_rate, f.bit_depth))
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
 /// Commands sent to the playback thread
 enum PlayerCommand {
     /// Create a new `SyncedPlayer` with the given format
@@ -386,6 +411,33 @@ async fn run_client(
         ResolvedVolumeMode::None => vec![],
     };
 
+    // Resolve output device once per connection and derive supported formats for this device.
+    // This avoids negotiating formats that the selected Windows output cannot open.
+    let output_device = devices::resolve_output_device(config.audio_device_id.as_deref());
+    let mut supported_formats: Vec<AudioFormatSpec> =
+        devices::derive_supported_pcm_formats(output_device.as_ref())
+            .into_iter()
+            .map(|f| AudioFormatSpec {
+                codec: "pcm".to_string(),
+                channels: f.channels as _,
+                sample_rate: f.sample_rate,
+                bit_depth: f.bit_depth as _,
+            })
+            .collect();
+
+    if supported_formats.is_empty() {
+        supported_formats = fallback_supported_formats();
+        eprintln!(
+            "[Sendspin] No reliable device format capabilities found; using conservative fallback formats: {}",
+            format_specs_to_log_string(&supported_formats)
+        );
+    } else {
+        eprintln!(
+            "[Sendspin] Advertising device-aware formats: {}",
+            format_specs_to_log_string(&supported_formats)
+        );
+    }
+
     // Build ClientHello message
     // Request player, controller, and metadata roles for full functionality
     let hello = ClientHello {
@@ -403,26 +455,7 @@ async fn run_client(
             software_version: Some(env!("CARGO_PKG_VERSION").to_string()),
         }),
         player_v1_support: Some(PlayerV1Support {
-            supported_formats: vec![
-                AudioFormatSpec {
-                    codec: "pcm".to_string(),
-                    channels: 2,
-                    sample_rate: 44100,
-                    bit_depth: 16,
-                },
-                AudioFormatSpec {
-                    codec: "pcm".to_string(),
-                    channels: 2,
-                    sample_rate: 48000,
-                    bit_depth: 24,
-                },
-                AudioFormatSpec {
-                    codec: "pcm".to_string(),
-                    channels: 2,
-                    sample_rate: 96000,
-                    bit_depth: 24,
-                },
-            ],
+            supported_formats,
             // Buffer capacity in samples - larger buffer reduces server-side scheduling pressure
             // 480000 = 10 seconds of buffer at 48kHz
             buffer_capacity: 480000,
@@ -513,6 +546,7 @@ async fn run_client(
         command_rx,
         volume_change_rx,
         resolved_mode,
+        output_device,
     )
     .await
 }
@@ -573,6 +607,7 @@ async fn run_authenticated_client(
     mut command_rx: mpsc::Receiver<String>,
     mut volume_change_rx: mpsc::Receiver<(u8, bool)>,
     resolved_mode: ResolvedVolumeMode,
+    output_device: Option<cpal::Device>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     // Read initial volume/mute state once and reuse for both the
     // ClientState message and the local tracking variables.
@@ -637,22 +672,6 @@ async fn run_authenticated_client(
     // Create shared clock sync with Kalman filter-based drift correction
     let clock_sync = Arc::new(Mutex::new(ClockSync::new(Arc::clone(&clock))));
 
-    // Get audio device
-    let device = if let Some(ref device_id) = config.audio_device_id {
-        match devices::get_device_by_id(device_id) {
-            Ok(d) => Some(d),
-            Err(e) => {
-                eprintln!(
-                    "[Sendspin] Failed to get device {}: {}, using default",
-                    device_id, e
-                );
-                None
-            }
-        }
-    } else {
-        None
-    };
-
     // Create channel for sending commands to the playback thread
     let (player_tx, player_rx) = std_mpsc::channel::<PlayerCommand>();
 
@@ -663,7 +682,7 @@ async fn run_authenticated_client(
         run_playback_thread(
             player_rx,
             clock_sync_for_thread,
-            device,
+            output_device,
             use_software_volume,
         );
     });
@@ -740,6 +759,14 @@ async fn run_authenticated_client(
                                         continue;
                                     };
 
+                                    eprintln!(
+                                        "[Sendspin] StreamStart format from server: codec={}, channels={}, sample_rate={}, bit_depth={}",
+                                        player_config.codec,
+                                        player_config.channels,
+                                        player_config.sample_rate,
+                                        player_config.bit_depth
+                                    );
+
                                     if player_config.codec != "pcm" {
                                         eprintln!("[Sendspin] Unsupported codec: {}", player_config.codec);
                                         continue;
@@ -1014,10 +1041,22 @@ fn run_playback_thread(
                     mute,
                 ) {
                     Ok(player) => {
+                        eprintln!(
+                            "[Sendspin] SyncedPlayer created: channels={}, sample_rate={}, bit_depth={}",
+                            format.channels,
+                            format.sample_rate,
+                            format.bit_depth
+                        );
                         synced_player = Some(player);
                     }
                     Err(e) => {
-                        eprintln!("[Sendspin] Failed to create SyncedPlayer: {}", e);
+                        eprintln!(
+                            "[Sendspin] Failed to create SyncedPlayer for channels={}, sample_rate={}, bit_depth={}: {}",
+                            format.channels,
+                            format.sample_rate,
+                            format.bit_depth,
+                            e
+                        );
                     }
                 }
             }
@@ -1117,7 +1156,16 @@ pub async fn stop() {
 pub async fn restart() {
     // Read lock is scoped to this block so it's released before start()
     // calls stop(), which takes a write lock on SENDSPIN_CLIENT.
-    let config = { SENDSPIN_CLIENT.read().as_ref().map(|c| c.config.clone()) };
+    let config = {
+        SENDSPIN_CLIENT.read().as_ref().map(|c| {
+            let mut config = c.config.clone();
+            let settings = crate::settings::get_settings();
+            config.audio_device_id = settings.audio_device_id;
+            config.sync_delay_ms = settings.sync_delay_ms;
+            config.player_name = settings.sendspin_player_name;
+            config
+        })
+    };
     if let Some(config) = config {
         log::info!("Restarting Sendspin client to apply new settings");
         let _ = start(config).await;

src-tauri/src/settings.rs

@@ -211,16 +211,21 @@ pub fn set_setting(app: tauri::AppHandle, key: &str, value: bool) -> Result<(),
 /// Set a string setting value
 pub fn set_string_setting(key: &str, value: Option<String>) -> Result<(), String> {
     let mut settings = get_settings();
+    let mut should_restart_sendspin = false;
 
     match key {
         "last_server_url" => settings.last_server_url = value,
         "last_server_name" => settings.last_server_name = value,
         "sendspin_player_id" => settings.sendspin_player_id = value,
         "sendspin_player_name" => {
             settings.sendspin_player_name = value.unwrap_or_else(default_player_name);
+            should_restart_sendspin = true;
         }
         "sendspin_server_url" => settings.sendspin_server_url = value,
-        "audio_device_id" => settings.audio_device_id = value,
+        "audio_device_id" => {
+            settings.audio_device_id = value;
+            should_restart_sendspin = true;
+        }
         "volume_control_mode" => {
             if let Some(mode_str) = value {
                 settings.volume_control_mode = match mode_str.as_str() {
@@ -230,24 +235,43 @@ pub fn set_string_setting(key: &str, value: Option<String>) -> Result<(), String
                     "disabled" => VolumeControlMode::Disabled,
                     _ => return Err(format!("Invalid volume control mode: {}", mode_str)),
                 };
+                should_restart_sendspin = true;
             }
         }
         _ => return Err(format!("Unknown string setting: {}", key)),
     }
 
-    save_settings(&settings)
+    save_settings(&settings)?;
+
+    if should_restart_sendspin && settings.sendspin_enabled {
+        tauri::async_runtime::spawn(async {
+            crate::sendspin::restart().await;
+        });
+    }
+
+    Ok(())
 }
 
 /// Set a numeric setting value
 pub fn set_int_setting(key: &str, value: i32) -> Result<(), String> {
     let mut settings = get_settings();
 
     match key {
-        "sync_delay_ms" => settings.sync_delay_ms = value,
+        "sync_delay_ms" => {
+            settings.sync_delay_ms = value;
+        }
         _ => return Err(format!("Unknown int setting: {}", key)),
     }
 
-    save_settings(&settings)
+    save_settings(&settings)?;
+
+    if settings.sendspin_enabled {
+        tauri::async_runtime::spawn(async {
+            crate::sendspin::restart().await;
+        });
+    }
+
+    Ok(())
 }
 
 #[cfg(desktop)]