Skip to content

Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.

25.7 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
//! Phone as Speaker / Headphones for PC Audio (§3.8 P2): captures Windows
//! system audio via WASAPI loopback (`AUDCLNT_STREAMFLAGS_LOOPBACK`), converts
//! 32-bit float stereo samples to 16-bit signed little-endian PCM, and streams
//! them to connected phones over NectarLink's low-latency audio stream.

/// Where the PC's sound goes: only to the phone that asked for it, waiting
/// while it's away (never to another phone, which may be someone else's), or
/// to the first online phone when the PC itself turned the speaker on.
#[cfg_attr(not(any(windows, target_os = "linux")), allow(dead_code))]
fn pick_target(
    wanted: Option<nectarlink_core::DeviceId>,
    online: &[nectarlink_core::DeviceId],
) -> Option<nectarlink_core::DeviceId> {
    match wanted {
        Some(phone) => online.contains(&phone).then_some(phone),
        None => online.first().copied(),
    }
}

#[cfg(test)]
mod tests {
    use super::pick_target;
    use nectarlink_core::DeviceId;

    #[test]
    fn sound_never_moves_to_a_phone_that_did_not_ask() {
        let (a, b) = (DeviceId([1; 32]), DeviceId([2; 32]));
        assert_eq!(pick_target(Some(a), &[b, a]), Some(a));
        assert_eq!(pick_target(Some(a), &[b]), None);
        assert_eq!(pick_target(None, &[b, a]), Some(b));
        assert_eq!(pick_target(None, &[]), None);
    }
}

#[cfg(any(windows, target_os = "linux"))]
mod imp {

    #![allow(unsafe_code)]

    use std::{
        sync::atomic::{AtomicBool, Ordering},
        time::Duration,
    };

    #[cfg(windows)]
    use windows::Win32::{
        Media::Audio::{
            AUDCLNT_BUFFERFLAGS_SILENT, AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_LOOPBACK,
            IAudioCaptureClient, IAudioClient, IMMDeviceEnumerator, MMDeviceEnumerator, WAVEFORMATEX,
            eConsole, eRender,
        },
        System::{
            Com::{CLSCTX_ALL, COINIT_MULTITHREADED, CoCreateInstance, CoInitializeEx, CoTaskMemFree},
            Threading::{GetCurrentThread, SetThreadPriority, THREAD_PRIORITY_TIME_CRITICAL},
        },
    };

    use crate::core_host;

    static ENABLED: AtomicBool = AtomicBool::new(false);
    static WORKER_RUNNING: AtomicBool = AtomicBool::new(false);
    /// The phone that last turned "Phone speaker" on. Audio goes only there; when
    /// the PC turned it on, to the first phone that is online.
    static TARGET: std::sync::Mutex<Option<nectarlink_core::DeviceId>> = std::sync::Mutex::new(None);

    /// The phone the sound goes to first, if one asked.
    pub fn target() -> Option<nectarlink_core::DeviceId> {
        *TARGET.lock().unwrap_or_else(|e| e.into_inner())
    }

    /// Records which phone asked to be the speaker.
    pub fn set_target(phone: Option<nectarlink_core::DeviceId>) {
        *TARGET.lock().unwrap_or_else(|e| e.into_inner()) = phone;
    }

    /// Returns whether PC-to-phone audio streaming is currently enabled.
    pub fn is_enabled() -> bool {
        ENABLED.load(Ordering::SeqCst)
    }

    /// Enables or disables PC-to-phone audio loopback streaming.
    pub fn set_enabled(enabled: bool) {
        let prev = ENABLED.swap(enabled, Ordering::SeqCst);
        if enabled && !prev && core_host::node().is_some() {
            ensure_worker();
        }
    }

    /// Converts interleaved stereo `f32` samples (`[-1.0, 1.0]`) into 16-bit
    /// signed little-endian PCM bytes (`pcm_s16le`).
    #[cfg(test)]
    pub fn f32_stereo_to_i16le(samples: &[f32]) -> Vec<u8> {
        let mut out = Vec::with_capacity(samples.len() * 2);
        for &sample in samples {
            let clean = if sample.is_finite() { sample.clamp(-1.0, 1.0) } else { 0.0 };
            let scaled = (clean * 32767.0).round() as i16;
            out.extend_from_slice(&scaled.to_le_bytes());
        }
        out
    }

    #[derive(Clone, Copy)]
    struct Biquad {
        b0: f32,
        b1: f32,
        b2: f32,
        a1: f32,
        a2: f32,
        z1_l: f32,
        z2_l: f32,
        z1_r: f32,
        z2_r: f32,
    }

    impl Biquad {
        fn low_shelf(sample_rate: f32, freq: f32, gain_db: f32) -> Self {
            let a = 10.0_f32.powf(gain_db / 40.0);
            let w0 = 2.0 * std::f32::consts::PI * (freq / sample_rate.max(8_000.0)).clamp(0.001, 0.45);
            let cos_w0 = w0.cos();
            let sin_w0 = w0.sin();
            let alpha = sin_w0 / 2.0 * std::f32::consts::SQRT_2;
            let two_sqrt_a_alpha = 2.0 * a.sqrt() * alpha;

            let b0 = a * ((a + 1.0) - (a - 1.0) * cos_w0 + two_sqrt_a_alpha);
            let b1 = 2.0 * a * ((a - 1.0) - (a + 1.0) * cos_w0);
            let b2 = a * ((a + 1.0) - (a - 1.0) * cos_w0 - two_sqrt_a_alpha);
            let a0 = (a + 1.0) + (a - 1.0) * cos_w0 + two_sqrt_a_alpha;
            let a1 = -2.0 * ((a - 1.0) + (a + 1.0) * cos_w0);
            let a2 = (a + 1.0) + (a - 1.0) * cos_w0 - two_sqrt_a_alpha;

            Self {
                b0: b0 / a0,
                b1: b1 / a0,
                b2: b2 / a0,
                a1: a1 / a0,
                a2: a2 / a0,
                z1_l: 0.0,
                z2_l: 0.0,
                z1_r: 0.0,
                z2_r: 0.0,
            }
        }

        fn high_shelf(sample_rate: f32, freq: f32, gain_db: f32) -> Self {
            let a = 10.0_f32.powf(gain_db / 40.0);
            let w0 = 2.0 * std::f32::consts::PI * (freq / sample_rate.max(8_000.0)).clamp(0.001, 0.45);
            let cos_w0 = w0.cos();
            let sin_w0 = w0.sin();
            let alpha = sin_w0 / 2.0 * std::f32::consts::SQRT_2;
            let two_sqrt_a_alpha = 2.0 * a.sqrt() * alpha;

            let b0 = a * ((a + 1.0) + (a - 1.0) * cos_w0 + two_sqrt_a_alpha);
            let b1 = -2.0 * a * ((a - 1.0) + (a + 1.0) * cos_w0);
            let b2 = a * ((a + 1.0) + (a - 1.0) * cos_w0 - two_sqrt_a_alpha);
            let a0 = (a + 1.0) - (a - 1.0) * cos_w0 + two_sqrt_a_alpha;
            let a1 = 2.0 * ((a - 1.0) - (a + 1.0) * cos_w0);
            let a2 = (a + 1.0) - (a - 1.0) * cos_w0 - two_sqrt_a_alpha;

            Self {
                b0: b0 / a0,
                b1: b1 / a0,
                b2: b2 / a0,
                a1: a1 / a0,
                a2: a2 / a0,
                z1_l: 0.0,
                z2_l: 0.0,
                z1_r: 0.0,
                z2_r: 0.0,
            }
        }

        #[inline]
        fn process_stereo(&mut self, l: f32, r: f32) -> (f32, f32) {
            let out_l = self.b0 * l + self.z1_l;
            self.z1_l = self.b1 * l - self.a1 * out_l + self.z2_l;
            self.z2_l = self.b2 * l - self.a2 * out_l;

            let out_r = self.b0 * r + self.z1_r;
            self.z1_r = self.b1 * r - self.a1 * out_r + self.z2_r;
            self.z2_r = self.b2 * r - self.a2 * out_r;
            (out_l, out_r)
        }
    }

    struct SpeakerEnhancer {
        low_shelf: Biquad,
        high_shelf: Biquad,
    }

    impl SpeakerEnhancer {
        fn new(sample_rate: u32) -> Self {
            let sr = sample_rate as f32;
            Self {
                low_shelf: Biquad::low_shelf(sr, 155.0, 3.5),
                high_shelf: Biquad::high_shelf(sr, 3800.0, 1.5),
            }
        }

        #[inline]
        fn soft_limit(x: f32) -> f32 {
            if !x.is_finite() {
                return 0.0;
            }
            let boosted = x * 1.12;
            (boosted / (1.0 + 0.18 * boosted.abs())).clamp(-1.0, 1.0)
        }

        fn encode_stereo_f32(&mut self, floats: &[f32], channels: usize) -> Vec<u8> {
            let frames = floats.len() / channels.max(1);
            let mut out = Vec::with_capacity(frames * 4);
            for frame in floats.chunks_exact(channels.max(1)) {
                let l_in = if frame[0].is_finite() { frame[0] } else { 0.0 };
                let r_in = if channels > 1 && frame[1].is_finite() { frame[1] } else { l_in };
                let (l1, r1) = self.low_shelf.process_stereo(l_in, r_in);
                let (l2, r2) = self.high_shelf.process_stereo(l1, r1);
                let l_i16 = (Self::soft_limit(l2) * 32767.0).round() as i16;
                let r_i16 = (Self::soft_limit(r2) * 32767.0).round() as i16;
                out.extend_from_slice(&l_i16.to_le_bytes());
                out.extend_from_slice(&r_i16.to_le_bytes());
            }
            out
        }

        #[cfg_attr(target_os = "linux", allow(dead_code))]
        fn encode_stereo_i16(&mut self, samples: &[i16], channels: usize) -> Vec<u8> {
            let frames = samples.len() / channels.max(1);
            let mut out = Vec::with_capacity(frames * 4);
            for frame in samples.chunks_exact(channels.max(1)) {
                let l_in = (frame[0] as f32) / 32768.0;
                let r_in = if channels > 1 { (frame[1] as f32) / 32768.0 } else { l_in };
                let (l1, r1) = self.low_shelf.process_stereo(l_in, r_in);
                let (l2, r2) = self.high_shelf.process_stereo(l1, r1);
                let l_i16 = (Self::soft_limit(l2) * 32767.0).round() as i16;
                let r_i16 = (Self::soft_limit(r2) * 32767.0).round() as i16;
                out.extend_from_slice(&l_i16.to_le_bytes());
                out.extend_from_slice(&r_i16.to_le_bytes());
            }
            out
        }
    }

    fn ensure_worker() {
        if WORKER_RUNNING.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst).is_err() {
            return;
        }
        std::thread::Builder::new()
            .name("nectarlink-pc-audio-loopback".into())
            .spawn(|| {
                run_loopback_worker();
                WORKER_RUNNING.store(false, Ordering::SeqCst);
            })
            .ok();
    }

    /// Formats a PulseAudio/PipeWire sink name into its monitor source name.
    #[cfg_attr(windows, allow(dead_code))]
    pub(crate) fn format_monitor_source_name(default_sink: Option<&str>) -> String {
        let Some(trimmed) = default_sink.map(str::trim).filter(|s| !s.is_empty()) else {
            return "@DEFAULT_MONITOR@".to_owned();
        };
        if trimmed.ends_with(".monitor") { trimmed.to_owned() } else { format!("{trimmed}.monitor") }
    }

    /// Builds `pw-record` CLI arguments that capture desktop sink monitor loopback
    /// (`-P stream.capture.sink=true`) rather than the default microphone input.
    #[cfg_attr(windows, allow(dead_code))]
    pub(crate) fn pw_record_loopback_args(monitor: &str) -> Vec<String> {
        let mut args = vec![
            "--raw".to_owned(),
            "--format=f32".to_owned(),
            "--rate=48000".to_owned(),
            "--channels=2".to_owned(),
            "-P".to_owned(),
            "stream.capture.sink=true".to_owned(),
        ];
        let trimmed = monitor.trim();
        if !trimmed.is_empty() && trimmed != "@DEFAULT_MONITOR@" {
            let sink_name = trimmed.strip_suffix(".monitor").unwrap_or(trimmed).trim();
            if !sink_name.is_empty() && !sink_name.starts_with('-') {
                args.push("--target".to_owned());
                args.push(sink_name.to_owned());
            }
        }
        args.push("-".to_owned());
        args
    }

    #[cfg(target_os = "linux")]
    fn resolve_default_monitor_source() -> String {
        let default_sink = std::process::Command::new("pactl")
            .arg("get-default-sink")
            .output()
            .ok()
            .filter(|o| o.status.success())
            .map(|o| String::from_utf8_lossy(&o.stdout).into_owned());
        format_monitor_source_name(default_sink.as_deref())
    }

    #[cfg(target_os = "linux")]
    fn run_loopback_worker() {
        while is_enabled() {
            if let Err(e) = capture_and_stream_once() {
                tracing::debug!(error = %e, "PC audio loopback stream cycle ended");
                for _ in 0..30 {
                    if !is_enabled() {
                        break;
                    }
                    std::thread::sleep(Duration::from_millis(100));
                }
            }
        }
    }

    #[cfg(target_os = "linux")]
    fn capture_and_stream_once() -> Result<(), String> {
        use std::io::Read;
        use std::process::{Command, Stdio};

        let node = core_host::node().ok_or_else(|| "core node not running".to_owned())?;
        let peers: Vec<_> = node
            .paired_devices()
            .unwrap_or_default()
            .into_iter()
            .filter(|d| matches!(d.link, nectarlink_core::LinkState::Online { .. }))
            .map(|d| d.id)
            .collect();
        let wanted = *TARGET.lock().unwrap_or_else(|e| e.into_inner());
        let Some(peer) = super::pick_target(wanted, &peers) else {
            std::thread::sleep(Duration::from_millis(500));
            return Ok(());
        };

        let monitor = resolve_default_monitor_source();
        let rate: u32 = 48_000;
        let channels: usize = 2;

        let mut child = Command::new("parec")
            .args([
                "--raw",
                "--format=float32le",
                "--rate=48000",
                "--channels=2",
                "--latency-msec=10",
                &format!("--device={monitor}"),
            ])
            .stdout(Stdio::piped())
            .stderr(Stdio::null())
            .spawn()
            .or_else(|_| {
                let pw_args = pw_record_loopback_args(&monitor);
                Command::new("pw-record").args(&pw_args).stdout(Stdio::piped()).stderr(Stdio::null()).spawn()
            })
            .map_err(|e| format!("failed to spawn parec/pw-record: {e}"))?;

        let Some(mut stdout) = child.stdout.take() else {
            let _ = child.kill();
            let _ = child.wait();
            return Err("loopback recorder stdout unavailable".into());
        };

        let mut enhancer = SpeakerEnhancer::new(rate);
        let (tx, mut rx) = tokio::sync::mpsc::channel::<(u32, u8, Vec<u8>)>(64);
        let send_node = node.clone();
        core_host::spawn(async move {
            while let Some((r, ch, pcm)) = rx.recv().await {
                for chunk in pcm.chunks(960) {
                    if send_node.send_pc_audio_pcm(&peer, r, ch, chunk.to_vec()).await.is_err() {
                        return;
                    }
                }
            }
        });

        // 480 stereo f32 frames = 10 ms = 3840 bytes.
        let frames_per_read = 480usize;
        let mut raw_buf = vec![0u8; frames_per_read * channels * 4];
        let mut floats = vec![0.0_f32; frames_per_read * channels];
        let mut silence_tail_packets: u32 = 0;

        while is_enabled() {
            if target() != wanted && target().is_some_and(|t| peers.contains(&t)) {
                break;
            }
            if stdout.read_exact(&mut raw_buf).is_err() {
                break;
            }
            for (dst, &chunk) in floats.iter_mut().zip(raw_buf.as_chunks::<4>().0) {
                *dst = f32::from_le_bytes(chunk);
            }
            let has_signal = floats.iter().any(|&s| s.is_finite() && s.abs() > 1e-5);
            let pcm_bytes = if has_signal {
                silence_tail_packets = 50;
                enhancer.encode_stereo_f32(&floats, channels)
            } else if silence_tail_packets > 0 {
                silence_tail_packets -= 1;
                vec![0u8; frames_per_read * 4]
            } else {
                Vec::new()
            };

            if !pcm_bytes.is_empty()
                && matches!(
                    tx.try_send((rate, 2, pcm_bytes)),
                    Err(tokio::sync::mpsc::error::TrySendError::Closed(_))
                )
            {
                break;
            }
        }

        let _ = child.kill();
        let _ = child.wait();
        Ok(())
    }

    #[cfg(windows)]
    fn run_loopback_worker() {
        // SAFETY: Initialize COM and elevate thread priority for low-latency audio capture.
        unsafe {
            let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
            let _ = SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
        }

        while is_enabled() {
            if let Err(e) = capture_and_stream_once() {
                tracing::debug!(error = %e, "PC audio loopback stream cycle ended");
                std::thread::sleep(Duration::from_millis(500));
            }
        }
    }

    #[cfg(windows)]
    fn capture_and_stream_once() -> Result<(), String> {
        let node = core_host::node().ok_or_else(|| "core node not running".to_owned())?;
        let peers: Vec<_> = node
            .paired_devices()
            .unwrap_or_default()
            .into_iter()
            .filter(|d| matches!(d.link, nectarlink_core::LinkState::Online { .. }))
            .map(|d| d.id)
            .collect();
        let wanted = *TARGET.lock().unwrap_or_else(|e| e.into_inner());
        let Some(peer) = super::pick_target(wanted, &peers) else {
            std::thread::sleep(Duration::from_millis(500));
            return Ok(());
        };

        // SAFETY: WASAPI loopback initialization on the default render endpoint.
        let (client, capture, rate, channels, bits_per_sample) = unsafe {
            let enumerator: IMMDeviceEnumerator =
                CoCreateInstance(&MMDeviceEnumerator, None, CLSCTX_ALL).map_err(|e| e.to_string())?;
            let device = enumerator.GetDefaultAudioEndpoint(eRender, eConsole).map_err(|e| e.to_string())?;
            let client: IAudioClient = device.Activate(CLSCTX_ALL, None).map_err(|e| e.to_string())?;
            let mix_ptr: *mut WAVEFORMATEX = client.GetMixFormat().map_err(|e| e.to_string())?;
            if mix_ptr.is_null() {
                return Err("GetMixFormat returned null".into());
            }
            let mix = *mix_ptr;
            let rate = mix.nSamplesPerSec.clamp(8_000, 96_000);
            let channels = mix.nChannels.max(1) as usize;
            let bits = mix.wBitsPerSample;
            // 10 ms shared loopback buffer in 100-ns units = 100_000.
            let init_res = client.Initialize(
                AUDCLNT_SHAREMODE_SHARED,
                AUDCLNT_STREAMFLAGS_LOOPBACK,
                100_000,
                0,
                mix_ptr,
                None,
            );
            CoTaskMemFree(Some(mix_ptr.cast()));
            init_res.map_err(|e| e.to_string())?;
            let capture: IAudioCaptureClient = client.GetService().map_err(|e| e.to_string())?;
            client.Start().map_err(|e| e.to_string())?;
            (client, capture, rate, channels, bits)
        };

        let mut enhancer = SpeakerEnhancer::new(rate);
        let (tx, mut rx) = tokio::sync::mpsc::channel::<(u32, u8, Vec<u8>)>(64);
        let send_node = node.clone();
        core_host::spawn(async move {
            while let Some((r, ch, pcm)) = rx.recv().await {
                // Slice into 960-byte (5 ms at 48 kHz stereo) sub-MTU chunks so each
                // chunk travels in a single QUIC datagram without HOL blocking.
                for chunk in pcm.chunks(960) {
                    if send_node.send_pc_audio_pcm(&peer, r, ch, chunk.to_vec()).await.is_err() {
                        return;
                    }
                }
            }
        });

        // Keep sending zero-filled PCM for ~500 ms after audible audio stops so brief
        // pauses between words or beats never starve the phone's AudioTrack ringbuffer.
        let mut silence_tail_packets: u32 = 0;

        'capture: while is_enabled() {
            std::thread::sleep(Duration::from_millis(2));
            // Another phone asked for the sound (it watches the PC's playback):
            // start over for that one.
            if target() != wanted && target().is_some_and(|t| peers.contains(&t)) {
                break 'capture;
            }
            // SAFETY: Drain available capture packets from `IAudioCaptureClient`.
            unsafe {
                loop {
                    let Ok(packet_frames) = capture.GetNextPacketSize() else { break };
                    if packet_frames == 0 {
                        break;
                    }
                    let mut data_ptr: *mut u8 = std::ptr::null_mut();
                    let mut frames_to_read: u32 = 0;
                    let mut flags: u32 = 0;
                    if capture.GetBuffer(&mut data_ptr, &mut frames_to_read, &mut flags, None, None).is_err()
                    {
                        break;
                    }
                    let silent = (flags & (AUDCLNT_BUFFERFLAGS_SILENT.0 as u32)) != 0 || data_ptr.is_null();
                    let frames = frames_to_read as usize;
                    let pcm_bytes = if silent {
                        if silence_tail_packets > 0 {
                            silence_tail_packets -= 1;
                            vec![0u8; frames * 4]
                        } else {
                            Vec::new()
                        }
                    } else if bits_per_sample == 32 {
                        let floats = std::slice::from_raw_parts(data_ptr.cast::<f32>(), frames * channels);
                        let has_signal = floats.iter().any(|&s| s.is_finite() && s.abs() > 1e-5);
                        if has_signal {
                            silence_tail_packets = 50;
                            enhancer.encode_stereo_f32(floats, channels)
                        } else if silence_tail_packets > 0 {
                            silence_tail_packets -= 1;
                            vec![0u8; frames * 4]
                        } else {
                            Vec::new()
                        }
                    } else if bits_per_sample == 16 {
                        let i16s = std::slice::from_raw_parts(data_ptr.cast::<i16>(), frames * channels);
                        let has_signal = i16s.iter().any(|&s| s.unsigned_abs() > 2);
                        if has_signal {
                            silence_tail_packets = 50;
                            enhancer.encode_stereo_i16(i16s, channels)
                        } else if silence_tail_packets > 0 {
                            silence_tail_packets -= 1;
                            vec![0u8; frames * 4]
                        } else {
                            Vec::new()
                        }
                    } else {
                        Vec::new()
                    };
                    let _ = capture.ReleaseBuffer(frames_to_read);

                    if !pcm_bytes.is_empty()
                        && matches!(
                            tx.try_send((rate, 2, pcm_bytes)),
                            Err(tokio::sync::mpsc::error::TrySendError::Closed(_))
                        )
                    {
                        break 'capture;
                    }
                }
            }
        }

        // SAFETY: Stop the WASAPI client before dropping.
        unsafe {
            let _ = client.Stop();
        }
        Ok(())
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn f32_stereo_to_i16le_clamps_and_encodes_little_endian() {
            let samples = [0.0_f32, 1.0, -1.0, 2.5, -3.0, f32::NAN];
            let bytes = f32_stereo_to_i16le(&samples);
            assert_eq!(bytes.len(), samples.len() * 2);
            let decoded: Vec<i16> = bytes.as_chunks::<2>().0.iter().map(|&c| i16::from_le_bytes(c)).collect();
            assert_eq!(decoded, vec![0, 32767, -32767, 32767, -32767, 0]);
        }

        #[test]
        fn set_enabled_toggles_atomic_state_cleanly() {
            set_enabled(false);
            assert!(!is_enabled());
            set_enabled(true);
            assert!(is_enabled());
            set_enabled(false);
            assert!(!is_enabled());
        }

        #[test]
        fn format_monitor_source_name_appends_monitor_suffix_or_uses_default() {
            assert_eq!(
                format_monitor_source_name(Some("alsa_output.pci-0000_00_1f.3.analog-stereo\n")),
                "alsa_output.pci-0000_00_1f.3.analog-stereo.monitor"
            );
            assert_eq!(
                format_monitor_source_name(Some("alsa_output.pci.monitor")),
                "alsa_output.pci.monitor"
            );
            assert_eq!(format_monitor_source_name(Some("  ")), "@DEFAULT_MONITOR@");
            assert_eq!(format_monitor_source_name(None), "@DEFAULT_MONITOR@");

            let default_pw = pw_record_loopback_args("@DEFAULT_MONITOR@");
            assert!(default_pw.windows(2).any(|w| w == ["-P", "stream.capture.sink=true"]));
            assert!(!default_pw.iter().any(|a| a == "--target"));
            assert_eq!(default_pw.last().map(String::as_str), Some("-"));

            let targeted_pw = pw_record_loopback_args("alsa_output.pci-0000_00_1f.3.analog-stereo.monitor");
            assert!(targeted_pw.windows(2).any(|w| w == ["-P", "stream.capture.sink=true"]));
            assert!(
                targeted_pw
                    .windows(2)
                    .any(|w| w == ["--target", "alsa_output.pci-0000_00_1f.3.analog-stereo"])
            );
            assert_eq!(targeted_pw.last().map(String::as_str), Some("-"));
        }

        #[test]
        fn speaker_enhancer_encodes_stereo_f32_and_i16_without_clipping() {
            let mut enhancer = SpeakerEnhancer::new(48_000);
            let floats = [0.25_f32, -0.25, 0.95, -0.95, f32::NAN, 0.5];
            let encoded = enhancer.encode_stereo_f32(&floats, 2);
            assert_eq!(encoded.len(), 3 * 4);
            assert!(encoded.iter().any(|&b| b != 0));

            let i16s = [8000i16, -8000, 16000, -16000];
            let encoded_i16 = enhancer.encode_stereo_i16(&i16s, 2);
            assert_eq!(encoded_i16.len(), 2 * 4);
            assert!(encoded_i16.iter().any(|&b| b != 0));
        }
    }
}

#[cfg(not(any(windows, target_os = "linux")))]
mod imp {
    #![allow(dead_code)]

    pub fn target() -> Option<nectarlink_core::DeviceId> {
        None
    }

    pub fn set_target(_phone: Option<nectarlink_core::DeviceId>) {}

    pub fn is_enabled() -> bool {
        false
    }

    pub fn set_enabled(_enabled: bool) {}

    pub fn f32_stereo_to_i16le(_samples: &[f32]) -> Vec<u8> {
        Vec::new()
    }
}

pub use imp::*;