use crate::FrameCount; use crate::{ BackendSpecificError, BufferSize, Data, DefaultStreamConfigError, DeviceNameError, DevicesError, InputCallbackInfo, OutputCallbackInfo, SampleFormat, SampleRate, StreamConfig, SupportedBufferSize, SupportedStreamConfig, SupportedStreamConfigRange, SupportedStreamConfigsError, COMMON_SAMPLE_RATES, }; use once_cell::sync::Lazy; use std::ffi::OsString; use std::fmt; use std::mem; use std::ops::{Deref, DerefMut}; use std::os::windows::ffi::OsStringExt; use std::ptr; use std::slice; use std::sync::{Arc, Mutex, MutexGuard}; use std::time::Duration; use super::com; use super::{windows_err_to_cpal_err, windows_err_to_cpal_err_message}; use windows::core::ComInterface; use windows::core::GUID; use windows::Win32::Devices::Properties; use windows::Win32::Foundation; use windows::Win32::Media::Audio::IAudioRenderClient; use windows::Win32::Media::{Audio, KernelStreaming, Multimedia}; use windows::Win32::System::Com; use windows::Win32::System::Com::{StructuredStorage, STGM_READ, VT_LPWSTR}; use windows::Win32::System::Threading; use super::stream::{AudioClientFlow, Stream, StreamInner}; use crate::{traits::DeviceTrait, BuildStreamError, StreamError}; pub type SupportedInputConfigs = std::vec::IntoIter; pub type SupportedOutputConfigs = std::vec::IntoIter; /// Wrapper because of that stupid decision to remove `Send` and `Sync` from raw pointers. #[derive(Clone)] struct IAudioClientWrapper(Audio::IAudioClient); unsafe impl Send for IAudioClientWrapper {} unsafe impl Sync for IAudioClientWrapper {} /// An opaque type that identifies an end point. #[derive(Clone)] pub struct Device { device: Audio::IMMDevice, /// We cache an uninitialized `IAudioClient` so that we can call functions from it without /// having to create/destroy audio clients all the time. future_audio_client: Arc>>, // TODO: add NonZero around the ptr } impl DeviceTrait for Device { type SupportedInputConfigs = SupportedInputConfigs; type SupportedOutputConfigs = SupportedOutputConfigs; type Stream = Stream; fn name(&self) -> Result { Device::name(self) } fn supported_input_configs( &self, ) -> Result { Device::supported_input_configs(self) } fn supported_output_configs( &self, ) -> Result { Device::supported_output_configs(self) } fn default_input_config(&self) -> Result { Device::default_input_config(self) } fn default_output_config(&self) -> Result { Device::default_output_config(self) } fn build_input_stream_raw( &self, config: &StreamConfig, sample_format: SampleFormat, data_callback: D, error_callback: E, _timeout: Option, ) -> Result where D: FnMut(&Data, &InputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static, { let stream_inner = self.build_input_stream_raw_inner(config, sample_format)?; Ok(Stream::new_input( stream_inner, data_callback, error_callback, )) } fn build_output_stream_raw( &self, config: &StreamConfig, sample_format: SampleFormat, data_callback: D, error_callback: E, _timeout: Option, ) -> Result where D: FnMut(&mut Data, &OutputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static, { let stream_inner = self.build_output_stream_raw_inner(config, sample_format)?; Ok(Stream::new_output( stream_inner, data_callback, error_callback, )) } } struct Endpoint { endpoint: Audio::IMMEndpoint, } enum WaveFormat { Ex(Audio::WAVEFORMATEX), Extensible(Audio::WAVEFORMATEXTENSIBLE), } // Use RAII to make sure CoTaskMemFree is called when we are responsible for freeing. struct WaveFormatExPtr(*mut Audio::WAVEFORMATEX); impl Drop for WaveFormatExPtr { fn drop(&mut self) { unsafe { Com::CoTaskMemFree(Some(self.0 as *mut _)); } } } impl WaveFormat { // Given a pointer to some format, returns a valid copy of the format. pub fn copy_from_waveformatex_ptr(ptr: *const Audio::WAVEFORMATEX) -> Option { unsafe { match (*ptr).wFormatTag as u32 { Audio::WAVE_FORMAT_PCM | Multimedia::WAVE_FORMAT_IEEE_FLOAT => { Some(WaveFormat::Ex(*ptr)) } KernelStreaming::WAVE_FORMAT_EXTENSIBLE => { let extensible_ptr = ptr as *const Audio::WAVEFORMATEXTENSIBLE; Some(WaveFormat::Extensible(*extensible_ptr)) } _ => None, } } } // Get the pointer to the WAVEFORMATEX struct. pub fn as_ptr(&self) -> *const Audio::WAVEFORMATEX { self.deref() as *const _ } } impl Deref for WaveFormat { type Target = Audio::WAVEFORMATEX; fn deref(&self) -> &Self::Target { match *self { WaveFormat::Ex(ref f) => f, WaveFormat::Extensible(ref f) => &f.Format, } } } impl DerefMut for WaveFormat { fn deref_mut(&mut self) -> &mut Self::Target { match *self { WaveFormat::Ex(ref mut f) => f, WaveFormat::Extensible(ref mut f) => &mut f.Format, } } } unsafe fn immendpoint_from_immdevice(device: Audio::IMMDevice) -> Audio::IMMEndpoint { device .cast::() .expect("could not query IMMDevice interface for IMMEndpoint") } unsafe fn data_flow_from_immendpoint(endpoint: &Audio::IMMEndpoint) -> Audio::EDataFlow { endpoint .GetDataFlow() .expect("could not get endpoint data_flow") } // Given the audio client and format, returns whether or not the format is supported. pub unsafe fn is_format_supported( client: &Audio::IAudioClient, waveformatex_ptr: *const Audio::WAVEFORMATEX, ) -> Result { // Check if the given format is supported. let is_supported = |waveformatex_ptr, closest_waveformatex_ptr| { let result = client.IsFormatSupported( Audio::AUDCLNT_SHAREMODE_SHARED, waveformatex_ptr, Some(closest_waveformatex_ptr), ); // `IsFormatSupported` can return `S_FALSE` (which means that a compatible format // has been found, but not an exact match) so we also treat this as unsupported. match result { Audio::AUDCLNT_E_DEVICE_INVALIDATED => { Err(SupportedStreamConfigsError::DeviceNotAvailable) } r if r.is_err() => Ok(false), Foundation::S_FALSE => Ok(false), _ => Ok(true), } }; // First we want to retrieve a pointer to the `WAVEFORMATEX`. // Although `GetMixFormat` writes the format to a given `WAVEFORMATEX` pointer, // the pointer itself may actually point to a `WAVEFORMATEXTENSIBLE` structure. // We check the wFormatTag to determine this and get a pointer to the correct type. match (*waveformatex_ptr).wFormatTag as u32 { Audio::WAVE_FORMAT_PCM | Multimedia::WAVE_FORMAT_IEEE_FLOAT => { let mut closest_waveformatex = *waveformatex_ptr; let mut closest_waveformatex_ptr = &mut closest_waveformatex as *mut _; is_supported(waveformatex_ptr, &mut closest_waveformatex_ptr as *mut _) } KernelStreaming::WAVE_FORMAT_EXTENSIBLE => { let waveformatextensible_ptr = waveformatex_ptr as *const Audio::WAVEFORMATEXTENSIBLE; let mut closest_waveformatextensible = *waveformatextensible_ptr; let closest_waveformatextensible_ptr = &mut closest_waveformatextensible as *mut _; let mut closest_waveformatex_ptr = closest_waveformatextensible_ptr as *mut Audio::WAVEFORMATEX; is_supported(waveformatex_ptr, &mut closest_waveformatex_ptr as *mut _) } _ => Ok(false), } } // Get a cpal Format from a WAVEFORMATEX. unsafe fn format_from_waveformatex_ptr( waveformatex_ptr: *const Audio::WAVEFORMATEX, audio_client: &Audio::IAudioClient, ) -> Option { fn cmp_guid(a: &GUID, b: &GUID) -> bool { (a.data1, a.data2, a.data3, a.data4) == (b.data1, b.data2, b.data3, b.data4) } let sample_format = match ( (*waveformatex_ptr).wBitsPerSample, (*waveformatex_ptr).wFormatTag as u32, ) { (16, Audio::WAVE_FORMAT_PCM) => SampleFormat::I16, (32, Multimedia::WAVE_FORMAT_IEEE_FLOAT) => SampleFormat::F32, (n_bits, KernelStreaming::WAVE_FORMAT_EXTENSIBLE) => { let waveformatextensible_ptr = waveformatex_ptr as *const Audio::WAVEFORMATEXTENSIBLE; let sub = (*waveformatextensible_ptr).SubFormat; if n_bits == 16 && cmp_guid(&sub, &KernelStreaming::KSDATAFORMAT_SUBTYPE_PCM) { SampleFormat::I16 } else if n_bits == 32 && cmp_guid(&sub, &Multimedia::KSDATAFORMAT_SUBTYPE_IEEE_FLOAT) { SampleFormat::F32 } else { return None; } } // Unknown data format returned by GetMixFormat. _ => return None, }; let sample_rate = SampleRate((*waveformatex_ptr).nSamplesPerSec); // GetBufferSizeLimits is only used for Hardware-Offloaded Audio // Processing, which was added in Windows 8, which places hardware // limits on the size of the audio buffer. If the sound system // *isn't* using offloaded audio, we're using a software audio // processing stack and have pretty much free rein to set buffer // size. // // In software audio stacks GetBufferSizeLimits returns // AUDCLNT_E_OFFLOAD_MODE_ONLY. // // https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/hardware-offloaded-audio-processing let (mut min_buffer_duration, mut max_buffer_duration) = (0, 0); let buffer_size_is_limited = audio_client .cast::() .and_then(|audio_client| { audio_client.GetBufferSizeLimits( waveformatex_ptr, true, &mut min_buffer_duration, &mut max_buffer_duration, ) }) .is_ok(); let buffer_size = if buffer_size_is_limited { SupportedBufferSize::Range { min: buffer_duration_to_frames(min_buffer_duration, sample_rate.0), max: buffer_duration_to_frames(max_buffer_duration, sample_rate.0), } } else { SupportedBufferSize::Range { min: 0, max: u32::max_value(), } }; let format = SupportedStreamConfig { channels: (*waveformatex_ptr).nChannels as _, sample_rate, buffer_size, sample_format, }; Some(format) } unsafe impl Send for Device {} unsafe impl Sync for Device {} impl Device { pub fn name(&self) -> Result { unsafe { // Open the device's property store. let property_store = self .device .OpenPropertyStore(STGM_READ) .expect("could not open property store"); // Get the endpoint's friendly-name property. let mut property_value = property_store .GetValue(&Properties::DEVPKEY_Device_FriendlyName as *const _ as *const _) .map_err(|err| { let description = format!("failed to retrieve name from property store: {}", err); let err = BackendSpecificError { description }; DeviceNameError::from(err) })?; let prop_variant = &property_value.Anonymous.Anonymous; // Read the friendly-name from the union data field, expecting a *const u16. if prop_variant.vt != VT_LPWSTR { let description = format!( "property store produced invalid data: {:?}", prop_variant.vt ); let err = BackendSpecificError { description }; return Err(err.into()); } let ptr_utf16 = *(&prop_variant.Anonymous as *const _ as *const *const u16); // Find the length of the friendly name. let mut len = 0; while *ptr_utf16.offset(len) != 0 { len += 1; } // Create the utf16 slice and convert it into a string. let name_slice = slice::from_raw_parts(ptr_utf16, len as usize); let name_os_string: OsString = OsStringExt::from_wide(name_slice); let name_string = match name_os_string.into_string() { Ok(string) => string, Err(os_string) => os_string.to_string_lossy().into(), }; // Clean up the property. StructuredStorage::PropVariantClear(&mut property_value).ok(); Ok(name_string) } } #[inline] fn from_immdevice(device: Audio::IMMDevice) -> Self { Device { device, future_audio_client: Arc::new(Mutex::new(None)), } } /// Ensures that `future_audio_client` contains a `Some` and returns a locked mutex to it. fn ensure_future_audio_client( &self, ) -> Result>, windows::core::Error> { let mut lock = self.future_audio_client.lock().unwrap(); if lock.is_some() { return Ok(lock); } let audio_client: Audio::IAudioClient = unsafe { // can fail if the device has been disconnected since we enumerated it, or if // the device doesn't support playback for some reason self.device.Activate(Com::CLSCTX_ALL, None)? }; *lock = Some(IAudioClientWrapper(audio_client)); Ok(lock) } /// Returns an uninitialized `IAudioClient`. #[inline] pub(crate) fn build_audioclient(&self) -> Result { let mut lock = self.ensure_future_audio_client()?; Ok(lock.take().unwrap().0) } // There is no way to query the list of all formats that are supported by the // audio processor, so instead we just trial some commonly supported formats. // // Common formats are trialed by first getting the default format (returned via // `GetMixFormat`) and then mutating that format with common sample rates and // querying them via `IsFormatSupported`. // // When calling `IsFormatSupported` with the shared-mode audio engine, only the default // number of channels seems to be supported. Any, more or less returns an invalid // parameter error. Thus, we just assume that the default number of channels is the only // number supported. fn supported_formats(&self) -> Result { // initializing COM because we call `CoTaskMemFree` to release the format. com::com_initialized(); // Retrieve the `IAudioClient`. let lock = match self.ensure_future_audio_client() { Ok(lock) => lock, Err(ref e) if e.code() == Audio::AUDCLNT_E_DEVICE_INVALIDATED => { return Err(SupportedStreamConfigsError::DeviceNotAvailable) } Err(e) => { let description = format!("{}", e); let err = BackendSpecificError { description }; return Err(err.into()); } }; let client = &lock.as_ref().unwrap().0; unsafe { // Retrieve the pointer to the default WAVEFORMATEX. let default_waveformatex_ptr = client .GetMixFormat() .map(WaveFormatExPtr) .map_err(windows_err_to_cpal_err::)?; // If the default format can't succeed we have no hope of finding other formats. if !is_format_supported(client, default_waveformatex_ptr.0)? { let description = "Could not determine support for default `WAVEFORMATEX`".to_string(); let err = BackendSpecificError { description }; return Err(err.into()); } // Copy the format to use as a test format (as to avoid mutating the original format). let mut test_format = { match WaveFormat::copy_from_waveformatex_ptr(default_waveformatex_ptr.0) { Some(f) => f, // If the format is neither EX nor EXTENSIBLE we don't know how to work with it. None => return Ok(vec![].into_iter()), } }; // Begin testing common sample rates. // // NOTE: We should really be testing for whole ranges here, but it is infeasible to // test every sample rate up to the overflow limit as the `IsFormatSupported` method is // quite slow. let mut supported_sample_rates: Vec = Vec::new(); for &rate in COMMON_SAMPLE_RATES { let rate = rate.0; test_format.nSamplesPerSec = rate; test_format.nAvgBytesPerSec = rate * u32::from((*default_waveformatex_ptr.0).nBlockAlign); if is_format_supported(client, test_format.as_ptr())? { supported_sample_rates.push(rate); } } // If the common rates don't include the default one, add the default. let default_sr = (*default_waveformatex_ptr.0).nSamplesPerSec as _; if !supported_sample_rates.iter().any(|&r| r == default_sr) { supported_sample_rates.push(default_sr); } // Reset the sample rate on the test format now that we're done. test_format.nSamplesPerSec = (*default_waveformatex_ptr.0).nSamplesPerSec; test_format.nAvgBytesPerSec = (*default_waveformatex_ptr.0).nAvgBytesPerSec; // TODO: Test the different sample formats? // Create the supported formats. let format = match format_from_waveformatex_ptr(default_waveformatex_ptr.0, client) { Some(fmt) => fmt, None => { let description = "could not create a `cpal::SupportedStreamConfig` from a `WAVEFORMATEX`" .to_string(); let err = BackendSpecificError { description }; return Err(err.into()); } }; let mut supported_formats = Vec::with_capacity(supported_sample_rates.len()); for rate in supported_sample_rates { supported_formats.push(SupportedStreamConfigRange { channels: format.channels, min_sample_rate: SampleRate(rate as _), max_sample_rate: SampleRate(rate as _), buffer_size: format.buffer_size.clone(), sample_format: format.sample_format, }) } Ok(supported_formats.into_iter()) } } pub fn supported_input_configs( &self, ) -> Result { if self.data_flow() == Audio::eCapture { self.supported_formats() // If it's an output device, assume no input formats. } else { Ok(vec![].into_iter()) } } pub fn supported_output_configs( &self, ) -> Result { if self.data_flow() == Audio::eRender { self.supported_formats() // If it's an input device, assume no output formats. } else { Ok(vec![].into_iter()) } } // We always create voices in shared mode, therefore all samples go through an audio // processor to mix them together. // // One format is guaranteed to be supported, the one returned by `GetMixFormat`. fn default_format(&self) -> Result { // initializing COM because we call `CoTaskMemFree` com::com_initialized(); let lock = match self.ensure_future_audio_client() { Ok(lock) => lock, Err(ref e) if e.code() == Audio::AUDCLNT_E_DEVICE_INVALIDATED => { return Err(DefaultStreamConfigError::DeviceNotAvailable) } Err(e) => { let description = format!("{}", e); let err = BackendSpecificError { description }; return Err(err.into()); } }; let client = &lock.as_ref().unwrap().0; unsafe { let format_ptr = client .GetMixFormat() .map(WaveFormatExPtr) .map_err(windows_err_to_cpal_err::)?; format_from_waveformatex_ptr(format_ptr.0, client) .ok_or(DefaultStreamConfigError::StreamTypeNotSupported) } } pub(crate) fn data_flow(&self) -> Audio::EDataFlow { let endpoint = Endpoint::from(self.device.clone()); endpoint.data_flow() } pub fn default_input_config(&self) -> Result { if self.data_flow() == Audio::eCapture { self.default_format() } else { Err(DefaultStreamConfigError::StreamTypeNotSupported) } } pub fn default_output_config(&self) -> Result { let data_flow = self.data_flow(); if data_flow == Audio::eRender { self.default_format() } else { Err(DefaultStreamConfigError::StreamTypeNotSupported) } } pub(crate) fn build_input_stream_raw_inner( &self, config: &StreamConfig, sample_format: SampleFormat, ) -> Result { unsafe { // Making sure that COM is initialized. // It's not actually sure that this is required, but when in doubt do it. com::com_initialized(); // Obtaining a `IAudioClient`. let audio_client = match self.build_audioclient() { Ok(client) => client, Err(ref e) if e.code() == Audio::AUDCLNT_E_DEVICE_INVALIDATED => { return Err(BuildStreamError::DeviceNotAvailable) } Err(e) => { let description = format!("{}", e); let err = BackendSpecificError { description }; return Err(err.into()); } }; let buffer_duration = buffer_size_to_duration(&config.buffer_size, config.sample_rate.0); let mut stream_flags = Audio::AUDCLNT_STREAMFLAGS_EVENTCALLBACK; if self.data_flow() == Audio::eRender { stream_flags |= Audio::AUDCLNT_STREAMFLAGS_LOOPBACK; } // Computing the format and initializing the device. let waveformatex = { let format_attempt = config_to_waveformatextensible(config, sample_format) .ok_or(BuildStreamError::StreamConfigNotSupported)?; let share_mode = Audio::AUDCLNT_SHAREMODE_SHARED; // Ensure the format is supported. match super::device::is_format_supported(&audio_client, &format_attempt.Format) { Ok(false) => return Err(BuildStreamError::StreamConfigNotSupported), Err(_) => return Err(BuildStreamError::DeviceNotAvailable), _ => (), } // Finally, initializing the audio client let hresult = audio_client.Initialize( share_mode, stream_flags, buffer_duration, 0, &format_attempt.Format, None, ); match hresult { Err(ref e) if e.code() == Audio::AUDCLNT_E_DEVICE_INVALIDATED => { return Err(BuildStreamError::DeviceNotAvailable); } Err(e) => { let description = format!("{}", e); let err = BackendSpecificError { description }; return Err(err.into()); } Ok(()) => (), }; format_attempt.Format }; // obtaining the size of the samples buffer in number of frames let max_frames_in_buffer = audio_client .GetBufferSize() .map_err(windows_err_to_cpal_err::)?; // Creating the event that will be signalled whenever we need to submit some samples. let event = { let event = Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) .map_err(|e| { let description = format!("failed to create event: {}", e); let err = BackendSpecificError { description }; BuildStreamError::from(err) })?; if let Err(e) = audio_client.SetEventHandle(event) { let description = format!("failed to call SetEventHandle: {}", e); let err = BackendSpecificError { description }; return Err(err.into()); } event }; // Building a `IAudioCaptureClient` that will be used to read captured samples. let capture_client = audio_client .GetService::() .map_err(|e| { windows_err_to_cpal_err_message::( e, "failed to build capture client: ", ) })?; // Once we built the `StreamInner`, we add a command that will be picked up by the // `run()` method and added to the `RunContext`. let client_flow = AudioClientFlow::Capture { capture_client }; let audio_clock = get_audio_clock(&audio_client)?; Ok(StreamInner { audio_client, audio_clock, client_flow, event, playing: false, max_frames_in_buffer, bytes_per_frame: waveformatex.nBlockAlign, config: config.clone(), sample_format, }) } } pub(crate) fn build_output_stream_raw_inner( &self, config: &StreamConfig, sample_format: SampleFormat, ) -> Result { unsafe { // Making sure that COM is initialized. // It's not actually sure that this is required, but when in doubt do it. com::com_initialized(); // Obtaining a `IAudioClient`. let audio_client = self .build_audioclient() .map_err(windows_err_to_cpal_err::)?; let buffer_duration = buffer_size_to_duration(&config.buffer_size, config.sample_rate.0); // Computing the format and initializing the device. let waveformatex = { let format_attempt = config_to_waveformatextensible(config, sample_format) .ok_or(BuildStreamError::StreamConfigNotSupported)?; let share_mode = Audio::AUDCLNT_SHAREMODE_SHARED; // Ensure the format is supported. match super::device::is_format_supported(&audio_client, &format_attempt.Format) { Ok(false) => return Err(BuildStreamError::StreamConfigNotSupported), Err(_) => return Err(BuildStreamError::DeviceNotAvailable), _ => (), } // Finally, initializing the audio client audio_client .Initialize( share_mode, Audio::AUDCLNT_STREAMFLAGS_EVENTCALLBACK, buffer_duration, 0, &format_attempt.Format, None, ) .map_err(windows_err_to_cpal_err::)?; format_attempt.Format }; // Creating the event that will be signalled whenever we need to submit some samples. let event = { let event = Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) .map_err(|e| { let description = format!("failed to create event: {}", e); let err = BackendSpecificError { description }; BuildStreamError::from(err) })?; if let Err(e) = audio_client.SetEventHandle(event) { let description = format!("failed to call SetEventHandle: {}", e); let err = BackendSpecificError { description }; return Err(err.into()); } event }; // obtaining the size of the samples buffer in number of frames let max_frames_in_buffer = audio_client.GetBufferSize().map_err(|e| { windows_err_to_cpal_err_message::( e, "failed to obtain buffer size: ", ) })?; // Building a `IAudioRenderClient` that will be used to fill the samples buffer. let render_client = audio_client .GetService::() .map_err(|e| { windows_err_to_cpal_err_message::( e, "failed to build render client: ", ) })?; // Once we built the `StreamInner`, we add a command that will be picked up by the // `run()` method and added to the `RunContext`. let client_flow = AudioClientFlow::Render { render_client }; let audio_clock = get_audio_clock(&audio_client)?; Ok(StreamInner { audio_client, audio_clock, client_flow, event, playing: false, max_frames_in_buffer, bytes_per_frame: waveformatex.nBlockAlign, config: config.clone(), sample_format, }) } } } impl PartialEq for Device { #[inline] fn eq(&self, other: &Device) -> bool { // Use case: In order to check whether the default device has changed // the client code might need to compare the previous default device with the current one. // The pointer comparison (`self.device == other.device`) don't work there, // because the pointers are different even when the default device stays the same. // // In this code section we're trying to use the GetId method for the device comparison, cf. // https://docs.microsoft.com/en-us/windows/desktop/api/mmdeviceapi/nf-mmdeviceapi-immdevice-getid unsafe { struct IdRAII(windows::core::PWSTR); /// RAII for device IDs. impl Drop for IdRAII { fn drop(&mut self) { unsafe { Com::CoTaskMemFree(Some(self.0 .0 as *mut _)) } } } // GetId only fails with E_OUTOFMEMORY and if it does, we're probably dead already. // Plus it won't do to change the device comparison logic unexpectedly. let id1 = self.device.GetId().expect("cpal: GetId failure"); let id1 = IdRAII(id1); let id2 = other.device.GetId().expect("cpal: GetId failure"); let id2 = IdRAII(id2); // 16-bit null-terminated comparison. let mut offset = 0; loop { let w1: u16 = *(id1.0).0.offset(offset); let w2: u16 = *(id2.0).0.offset(offset); if w1 == 0 && w2 == 0 { return true; } if w1 != w2 { return false; } offset += 1; } } } } impl Eq for Device {} impl fmt::Debug for Device { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_struct("Device") .field("device", &self.device) .field("name", &self.name()) .finish() } } impl From for Endpoint { fn from(device: Audio::IMMDevice) -> Self { unsafe { let endpoint = immendpoint_from_immdevice(device); Endpoint { endpoint } } } } impl Endpoint { fn data_flow(&self) -> Audio::EDataFlow { unsafe { data_flow_from_immendpoint(&self.endpoint) } } } static ENUMERATOR: Lazy = Lazy::new(|| { // COM initialization is thread local, but we only need to have COM initialized in the // thread we create the objects in com::com_initialized(); // building the devices enumerator object unsafe { let enumerator = Com::CoCreateInstance::<_, Audio::IMMDeviceEnumerator>( &Audio::MMDeviceEnumerator, None, Com::CLSCTX_ALL, ) .unwrap(); Enumerator(enumerator) } }); /// Send/Sync wrapper around `IMMDeviceEnumerator`. struct Enumerator(Audio::IMMDeviceEnumerator); unsafe impl Send for Enumerator {} unsafe impl Sync for Enumerator {} /// WASAPI implementation for `Devices`. pub struct Devices { collection: Audio::IMMDeviceCollection, total_count: u32, next_item: u32, } impl Devices { pub fn new() -> Result { unsafe { // can fail because of wrong parameters (should never happen) or out of memory let collection = ENUMERATOR .0 .EnumAudioEndpoints(Audio::eAll, Audio::DEVICE_STATE_ACTIVE) .map_err(BackendSpecificError::from)?; let count = collection.GetCount().map_err(BackendSpecificError::from)?; Ok(Devices { collection, total_count: count, next_item: 0, }) } } } unsafe impl Send for Devices {} unsafe impl Sync for Devices {} impl Iterator for Devices { type Item = Device; fn next(&mut self) -> Option { if self.next_item >= self.total_count { return None; } unsafe { let device = self.collection.Item(self.next_item).unwrap(); self.next_item += 1; Some(Device::from_immdevice(device)) } } #[inline] fn size_hint(&self) -> (usize, Option) { let num = self.total_count - self.next_item; let num = num as usize; (num, Some(num)) } } fn default_device(data_flow: Audio::EDataFlow) -> Option { unsafe { let device = ENUMERATOR .0 .GetDefaultAudioEndpoint(data_flow, Audio::eConsole) .ok()?; // TODO: check specifically for `E_NOTFOUND`, and panic otherwise Some(Device::from_immdevice(device)) } } pub fn default_input_device() -> Option { default_device(Audio::eCapture) } pub fn default_output_device() -> Option { default_device(Audio::eRender) } /// Get the audio clock used to produce `StreamInstant`s. unsafe fn get_audio_clock( audio_client: &Audio::IAudioClient, ) -> Result { audio_client .GetService::() .map_err(|e| { windows_err_to_cpal_err_message::(e, "failed to build audio clock: ") }) } // Turns a `Format` into a `WAVEFORMATEXTENSIBLE`. // // Returns `None` if the WAVEFORMATEXTENSIBLE does not support the given format. fn config_to_waveformatextensible( config: &StreamConfig, sample_format: SampleFormat, ) -> Option { let format_tag = match sample_format { SampleFormat::I16 => Audio::WAVE_FORMAT_PCM, SampleFormat::F32 => KernelStreaming::WAVE_FORMAT_EXTENSIBLE, _ => return None, } as u16; let channels = config.channels; let sample_rate = config.sample_rate.0; let sample_bytes = sample_format.sample_size() as u16; let avg_bytes_per_sec = u32::from(channels) * sample_rate * u32::from(sample_bytes); let block_align = channels * sample_bytes; let bits_per_sample = 8 * sample_bytes; let cb_size = match sample_format { SampleFormat::I16 => 0, SampleFormat::F32 => { let extensible_size = mem::size_of::(); let ex_size = mem::size_of::(); (extensible_size - ex_size) as u16 } _ => return None, }; let waveformatex = Audio::WAVEFORMATEX { wFormatTag: format_tag, nChannels: channels, nSamplesPerSec: sample_rate, nAvgBytesPerSec: avg_bytes_per_sec, nBlockAlign: block_align, wBitsPerSample: bits_per_sample, cbSize: cb_size, }; // CPAL does not care about speaker positions, so pass audio ight through. let channel_mask = KernelStreaming::KSAUDIO_SPEAKER_DIRECTOUT; let sub_format = match sample_format { SampleFormat::I16 => KernelStreaming::KSDATAFORMAT_SUBTYPE_PCM, SampleFormat::F32 => Multimedia::KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, _ => return None, }; let waveformatextensible = Audio::WAVEFORMATEXTENSIBLE { Format: waveformatex, Samples: Audio::WAVEFORMATEXTENSIBLE_0 { wSamplesPerBlock: bits_per_sample, }, dwChannelMask: channel_mask, SubFormat: sub_format, }; Some(waveformatextensible) } fn buffer_size_to_duration(buffer_size: &BufferSize, sample_rate: u32) -> i64 { match buffer_size { BufferSize::Fixed(frames) => *frames as i64 * (1_000_000_000 / 100) / sample_rate as i64, BufferSize::Default => 0, } } fn buffer_duration_to_frames(buffer_duration: i64, sample_rate: u32) -> FrameCount { (buffer_duration * sample_rate as i64 * 100 / 1_000_000_000) as FrameCount }