feat: 初步增加 Windows 支持

src/audio/device_windows.rs

@@ -0,0 +1,232 @@
+use cpal::traits::{DeviceTrait, HostTrait};
+use cpal::DeviceId;
+use serde::Serialize;
+use std::str::FromStr;
+use tracing::{debug, info, warn};
+
+use crate::error::{AppError, Result};
+
+#[derive(Debug, Clone, Serialize)]
+pub struct AudioDeviceInfo {
+    pub name: String,
+    pub description: String,
+    pub card_index: i32,
+    pub device_index: i32,
+    pub sample_rates: Vec<u32>,
+    pub channels: Vec<u32>,
+    pub is_capture: bool,
+    pub is_hdmi: bool,
+    pub usb_bus: Option<String>,
+}
+
+pub fn enumerate_audio_devices() -> Result<Vec<AudioDeviceInfo>> {
+    enumerate_audio_devices_with_current(None)
+}
+
+pub fn enumerate_audio_devices_with_current(
+    current_device: Option<&str>,
+) -> Result<Vec<AudioDeviceInfo>> {
+    let host = cpal::default_host();
+    let devices = host
+        .input_devices()
+        .map_err(|e| AppError::AudioError(format!("Failed to enumerate WASAPI devices: {}", e)))?;
+
+    let mut result = Vec::new();
+
+    for (index, device) in devices.enumerate() {
+        let labels = device_labels(&device);
+        let id = device
+            .id()
+            .map(|id| id.to_string())
+            .unwrap_or_else(|_| format!("wasapi-index:{}", index));
+
+        let (sample_rates, channels) = query_device_caps(&device);
+        if sample_rates.is_empty() || channels.is_empty() {
+            debug!(
+                "Skipping WASAPI endpoint without usable input caps: {}",
+                labels.search_text
+            );
+            continue;
+        }
+
+        let is_current =
+            current_device == Some(id.as_str()) || current_device == Some(labels.display.as_str());
+        let description = if is_current {
+            format!("{} (in use)", labels.display)
+        } else {
+            labels.display.clone()
+        };
+
+        let lower = labels.search_text.to_lowercase();
+        let is_hdmi = lower.contains("hdmi")
+            || lower.contains("capture")
+            || lower.contains("usb")
+            || lower.contains("digital");
+
+        result.push(AudioDeviceInfo {
+            name: id,
+            description,
+            card_index: index as i32,
+            device_index: 0,
+            sample_rates,
+            channels,
+            is_capture: true,
+            is_hdmi,
+            usb_bus: None,
+        });
+    }
+
+    info!("Found {} WASAPI audio capture devices", result.len());
+    Ok(result)
+}
+
+fn query_device_caps(device: &cpal::Device) -> (Vec<u32>, Vec<u32>) {
+    let mut sample_rates = Vec::new();
+    let mut channels = Vec::new();
+
+    if let Ok(configs) = device.supported_input_configs() {
+        for cfg in configs {
+            for rate in [8000, 16000, 22050, 44100, 48000, 96000] {
+                if cfg.min_sample_rate() <= rate
+                    && rate <= cfg.max_sample_rate()
+                    && !sample_rates.contains(&rate)
+                {
+                    sample_rates.push(rate);
+                }
+            }
+
+            let ch = cfg.channels() as u32;
+            if !channels.contains(&ch) {
+                channels.push(ch);
+            }
+        }
+    }
+
+    if (sample_rates.is_empty() || channels.is_empty()) && device.default_input_config().is_ok() {
+        if let Ok(default_cfg) = device.default_input_config() {
+            if !sample_rates.contains(&default_cfg.sample_rate()) {
+                sample_rates.push(default_cfg.sample_rate());
+            }
+            let ch = default_cfg.channels() as u32;
+            if !channels.contains(&ch) {
+                channels.push(ch);
+            }
+        }
+    }
+
+    sample_rates.sort_unstable();
+    channels.sort_unstable();
+    (sample_rates, channels)
+}
+
+struct DeviceLabels {
+    display: String,
+    search_text: String,
+}
+
+fn device_labels(device: &cpal::Device) -> DeviceLabels {
+    match device.description() {
+        Ok(desc) => {
+            let formatted = desc.to_string();
+            let display = desc
+                .extended()
+                .first()
+                .cloned()
+                .unwrap_or_else(|| formatted.clone());
+            let mut parts = vec![formatted, desc.name().to_string(), display.clone()];
+            parts.extend(desc.extended().iter().cloned());
+
+            DeviceLabels {
+                display,
+                search_text: parts.join(" "),
+            }
+        }
+        Err(_) => {
+            #[allow(deprecated)]
+            let display = device
+                .name()
+                .unwrap_or_else(|_| "Unknown WASAPI capture device".to_string());
+            DeviceLabels {
+                display: display.clone(),
+                search_text: display,
+            }
+        }
+    }
+}
+
+pub(crate) fn find_wasapi_device(requested_device: &str) -> Result<cpal::Device> {
+    let host = cpal::default_host();
+    let trimmed = requested_device.trim();
+
+    if trimmed.is_empty()
+        || trimmed.eq_ignore_ascii_case("auto")
+        || trimmed.eq_ignore_ascii_case("default")
+    {
+        return host.default_input_device().ok_or_else(|| {
+            AppError::AudioError("No default WASAPI input device found".to_string())
+        });
+    }
+
+    if let Ok(id) = DeviceId::from_str(trimmed) {
+        if let Some(device) = host.device_by_id(&id) {
+            return Ok(device);
+        }
+    }
+
+    let needle = trimmed.to_lowercase();
+    let devices = host
+        .input_devices()
+        .map_err(|e| AppError::AudioError(format!("Failed to enumerate WASAPI devices: {}", e)))?;
+
+    for device in devices {
+        let id_match = device
+            .id()
+            .map(|id| id.to_string() == trimmed)
+            .unwrap_or(false);
+        let labels = device_labels(&device);
+        if id_match || labels.search_text.to_lowercase().contains(&needle) {
+            return Ok(device);
+        }
+    }
+
+    Err(AppError::AudioError(format!(
+        "WASAPI audio device not found: {}",
+        requested_device
+    )))
+}
+
+pub fn find_best_audio_device() -> Result<AudioDeviceInfo> {
+    let devices = enumerate_audio_devices()?;
+
+    if devices.is_empty() {
+        return Err(AppError::AudioError(
+            "No WASAPI audio capture devices found".to_string(),
+        ));
+    }
+
+    let mut first_48k_stereo: Option<&AudioDeviceInfo> = None;
+    for device in &devices {
+        if !device.sample_rates.contains(&48000) || !device.channels.contains(&2) {
+            continue;
+        }
+        if device.is_hdmi {
+            info!("Selected WASAPI capture device: {}", device.description);
+            return Ok(device.clone());
+        }
+        if first_48k_stereo.is_none() {
+            first_48k_stereo = Some(device);
+        }
+    }
+
+    if let Some(device) = first_48k_stereo {
+        info!("Selected WASAPI capture device: {}", device.description);
+        return Ok(device.clone());
+    }
+
+    let device = devices.into_iter().next().unwrap();
+    warn!(
+        "Using fallback WASAPI audio device: {} (will resample if needed)",
+        device.description
+    );
+    Ok(device)
+}