diff --git a/src/host/wasapi/stream.rs b/src/host/wasapi/stream.rs index 35c2b0f..20f6c2b 100644 --- a/src/host/wasapi/stream.rs +++ b/src/host/wasapi/stream.rs @@ -4,18 +4,23 @@ use crate::{ BackendSpecificError, Data, InputCallbackInfo, OutputCallbackInfo, PauseStreamError, PlayStreamError, SampleFormat, StreamError, }; -use std::mem; -use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}; -use std::ptr; -use std::sync::mpsc::{channel, Receiver, Sender}; -use std::sync::Arc; -use std::thread::{self, JoinHandle}; +use std::{ + mem, + os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}, + ptr, + sync::mpsc::{channel, Receiver, Sender}, + thread::{self, JoinHandle}, +}; use windows::Win32::Foundation; use windows::Win32::Foundation::WAIT_OBJECT_0; use windows::Win32::Media::Audio; use windows::Win32::System::SystemServices; use windows::Win32::System::Threading; +#[cfg(test)] +#[path = "stream_lifecycle_tests.rs"] +mod lifecycle_tests; + pub struct Stream { /// The high-priority audio processing thread calling callbacks. /// Option used for moving out in destructor. @@ -28,7 +33,7 @@ pub struct Stream { // This event is signalled after a new entry is added to `commands`, so that the `run()` // method can be notified. - pending_scheduled_event: Arc, + pending_scheduled_event: OwnedHandle, } struct RunContext { @@ -40,9 +45,6 @@ struct RunContext { handles: Vec, commands: Receiver, - - // Keep the event alive if Stream is dropped inside its own callback. - _pending_scheduled_event: Arc, } // Once we start running the eventloop, the RunContext will not be moved. @@ -95,15 +97,13 @@ impl Stream { Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) } .expect("cpal: could not create input stream event"); - let owned_event = - Arc::new(unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }); + let owned_event = unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }; let (tx, rx) = channel(); let run_context = RunContext { handles: vec![pending_scheduled_event, stream_inner.event], stream: stream_inner, commands: rx, - _pending_scheduled_event: Arc::clone(&owned_event), }; let thread = thread::Builder::new() @@ -131,15 +131,13 @@ impl Stream { Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) } .expect("cpal: could not create output stream event"); - let owned_event = - Arc::new(unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }); + let owned_event = unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }; let (tx, rx) = channel(); let run_context = RunContext { handles: vec![pending_scheduled_event, stream_inner.event], stream: stream_inner, commands: rx, - _pending_scheduled_event: Arc::clone(&owned_event), }; let thread = thread::Builder::new() @@ -171,13 +169,12 @@ impl Stream { impl Drop for Stream { #[inline] fn drop(&mut self) { - let _ = self.push_command(Command::Terminate); + if let Err(error) = self.push_command(Command::Terminate) { + eprintln!("cpal: WASAPI termination notification failed: {error}"); + } if let Some(thread) = self.thread.take() { - // Prevent self-join: Terminate was sent; the thread exits after the current callback - // returns. Shared event ownership keeps the handle alive until both Stream and - // RunContext release it. - if thread.thread().id() != thread::current().id() { - let _ = thread.join(); + if thread.join().is_err() { + eprintln!("cpal: WASAPI worker panicked during stream processing"); } } } diff --git a/src/host/wasapi/stream_lifecycle_tests.rs b/src/host/wasapi/stream_lifecycle_tests.rs new file mode 100644 index 0000000..50c488e --- /dev/null +++ b/src/host/wasapi/stream_lifecycle_tests.rs @@ -0,0 +1,163 @@ +use super::*; +use crate::traits::{DeviceTrait, HostTrait}; +use std::{ + ffi::CString, + time::{Duration, Instant}, +}; + +const WORKER_DEADLINE: Duration = Duration::from_secs(2); + +#[derive(Debug)] +enum WorkerExit { + Termination, + Finished, + Panicked, +} + +fn stream(exit: WorkerExit) -> (Stream, CString) { + let name = CString::new(format!( + "Local\\cpal-lifecycle-{}-{exit:?}", + std::process::id() + )) + .unwrap(); + let event = unsafe { + Threading::CreateEventA(None, false, false, windows::core::PCSTR(name.as_ptr() as _)) + } + .unwrap(); + let (tx, rx) = channel(); + let wait_for_exit = !matches!(exit, WorkerExit::Termination); + let worker = thread::spawn(move || match exit { + WorkerExit::Termination => assert!(matches!(rx.recv().unwrap(), Command::Terminate)), + WorkerExit::Finished => drop(rx), + WorkerExit::Panicked => { + drop(rx); + panic!("Injected worker failure"); + } + }); + if wait_for_exit { + let deadline = Instant::now() + WORKER_DEADLINE; + while !worker.is_finished() { + assert!(Instant::now() < deadline, "Worker failed to exit"); + thread::yield_now(); + } + } + let owned_event = unsafe { OwnedHandle::from_raw_handle(event.0 as _) }; + ( + Stream { + thread: Some(worker), + commands: tx, + pending_scheduled_event: owned_event, + }, + name, + ) +} + +fn assert_event_closed(exit: WorkerExit) { + let (stream, name) = stream(exit); + drop(stream); + // Another test can reuse a closed handle value; check the event's identity instead. + match unsafe { + Threading::OpenEventA( + Threading::EVENT_MODIFY_STATE, + false, + windows::core::PCSTR(name.as_ptr() as _), + ) + } { + Ok(event) => { + let _event = unsafe { OwnedHandle::from_raw_handle(event.0 as _) }; + panic!("Stream destruction leaked its command event"); + } + Err(error) => assert_eq!( + error.code(), + windows::core::HRESULT::from_win32(Foundation::ERROR_FILE_NOT_FOUND.0), + ), + } +} + +#[test] +fn normal_shutdown_closes_command_event() { + assert_event_closed(WorkerExit::Termination); +} + +#[test] +fn completed_worker_still_closes_command_event() { + assert_event_closed(WorkerExit::Finished); +} + +#[test] +fn panicked_worker_does_not_panic_in_drop_or_leak_event() { + assert_event_closed(WorkerExit::Panicked); +} + +const WARMUP_CYCLES: usize = 4; +const MEASURED_CYCLES: usize = 16; +const CALLBACK_TIMEOUT: Duration = Duration::from_secs(3); +const POLL_INTERVAL: Duration = Duration::from_millis(10); +const SETTLE_TIME: Duration = Duration::from_millis(100); + +fn handle_count() -> u32 { + let mut count = 0; + unsafe { Threading::GetProcessHandleCount(Threading::GetCurrentProcess(), &mut count) } + .unwrap(); + count +} + +fn native_cycle(worker_exits_first: bool) { + let host = crate::default_host(); + let device = host.default_output_device().unwrap(); + let supported = device.default_output_config().unwrap(); + assert_eq!(supported.sample_format(), SampleFormat::F32); + let (tx, rx) = channel(); + let output = device + .build_output_stream( + &supported.into(), + move |data: &mut [f32], _| { + data.fill(0.0); + tx.send(()).unwrap(); + // Test-only fault injection exits the real WASAPI worker before Drop. + assert!(!worker_exits_first, "Injected native worker exit"); + }, + |error| eprintln!("Native callback error: {error}"), + None, + ) + .unwrap(); + output.play().unwrap(); + rx.recv_timeout(CALLBACK_TIMEOUT).unwrap(); + if worker_exits_first { + let deadline = Instant::now() + CALLBACK_TIMEOUT; + while output.play().is_ok() { + assert!(Instant::now() < deadline, "Worker receiver did not close"); + thread::sleep(POLL_INTERVAL); + } + } + drop(output); + thread::sleep(SETTLE_TIME); +} + +fn measured_cycles(worker_exits_first: bool) -> Vec { + let mut counts = vec![handle_count()]; + for _ in 0..MEASURED_CYCLES { + native_cycle(worker_exits_first); + counts.push(handle_count()); + } + counts +} + +#[test] +#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"] +fn native_worker_exit_does_not_leak_process_handles() { + for _ in 0..WARMUP_CYCLES { + native_cycle(false); + } + let normal_before = measured_cycles(false); + let exited_first = measured_cycles(true); + let normal_after = measured_cycles(false); + eprintln!("normal_before={normal_before:?} worker_exits_first={exited_first:?} normal_after={normal_after:?}"); + assert_eq!(normal_before.first(), normal_before.last()); + assert_eq!(normal_after.first(), normal_after.last()); + assert_eq!( + exited_first.first(), + exited_first.last(), + "Worker-exit-before-drop leaked native process handles" + ); +}