byte-engine-ahi 0.1.0

Audio hardware interface layer used by Byte-Engine.
Documentation
use windows::Win32::{
	Foundation::S_OK,
	Media::{
		Audio::{
			eConsole, eRender, IAudioClient, IAudioRenderClient, IMMDevice, IMMDeviceEnumerator, MMDeviceEnumerator,
			AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM, AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY,
			WAVEFORMATEX, WAVEFORMATEXTENSIBLE as WAVEFORMATEXTENSIBLE_t,
		},
		KernelStreaming::{
			KSDATAFORMAT_SUBTYPE_PCM, SPEAKER_ALL, SPEAKER_FRONT_LEFT, SPEAKER_FRONT_RIGHT, WAVE_FORMAT_EXTENSIBLE,
		},
		Multimedia::KSDATAFORMAT_SUBTYPE_IEEE_FLOAT,
	},
	System::Com::{CoCreateInstance, CoInitializeEx, CoTaskMemFree, CLSCTX_ALL, COINIT_MULTITHREADED},
};

use crate::audio_hardware_interface::{AudioPlayError, HardwareParameters, Streams, WritePlayFunction};

pub struct Device {
	device: IMMDevice,
	client: IAudioClient,
	render_client: IAudioRenderClient,
	parameters: HardwareParameters,
}

impl crate::audio_hardware_interface::AudioHardwareInterface for Device {
	fn new(params: HardwareParameters) -> Result<Self, String> {
		if unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) } != S_OK {
			return Err("Failed to initialize COM".to_string());
		}

		let enumerator: IMMDeviceEnumerator = unsafe {
			CoCreateInstance(&MMDeviceEnumerator, None, CLSCTX_ALL).map_err(|_| {
				"Failed to create device enumerator. The COM class for MMDeviceEnumerator could not be instantiated."
					.to_string()
			})?
		};

		let device: IMMDevice = unsafe {
			enumerator.GetDefaultAudioEndpoint(eRender, eConsole).map_err(|_| {
				"Failed to get default audio endpoint. The system has no default render device or it is unavailable."
					.to_string()
			})?
		};

		let (client, params) = unsafe {
			let client: IAudioClient = device.Activate(CLSCTX_ALL, None).map_err(|_| {
				"Failed to activate audio client. The audio endpoint could not provide an IAudioClient interface.".to_string()
			})?;

			let bits_per_sample = params.bit_depth;
			let samples_per_second = params.sample_rate;
			let channels = params.channels;

			let dw_channel_mask = match channels {
				1 => SPEAKER_FRONT_LEFT,
				2 => SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
				_ => SPEAKER_ALL,
			};

			let m_format = WAVEFORMATEXTENSIBLE_t {
				Format: WAVEFORMATEX {
					nChannels: channels as _,
					nSamplesPerSec: samples_per_second,
					nBlockAlign: (channels * bits_per_sample / 8) as _,
					nAvgBytesPerSec: samples_per_second * (channels * bits_per_sample / 8),
					wBitsPerSample: bits_per_sample.next_multiple_of(8) as _,
					wFormatTag: WAVE_FORMAT_EXTENSIBLE as _,
					cbSize: 22,
				},
				Samples: windows::Win32::Media::Audio::WAVEFORMATEXTENSIBLE_0 {
					wValidBitsPerSample: bits_per_sample as _,
				},
				dwChannelMask: dw_channel_mask,
				SubFormat: KSDATAFORMAT_SUBTYPE_PCM,
			};

			let mut m_closest_format: *const WAVEFORMATEXTENSIBLE_t = std::ptr::null();

			if client
				.IsFormatSupported(
					AUDCLNT_SHAREMODE_SHARED,
					std::mem::transmute(&m_format),
					Some(std::mem::transmute(&mut m_closest_format)),
				)
				.is_err()
			{
				if !m_closest_format.is_null() {
					let m_closest_format: &WAVEFORMATEXTENSIBLE_t = std::mem::transmute(m_closest_format);
					let closest_channels = m_closest_format.Format.nChannels;
					let closest_samples_per_second = m_closest_format.Format.nSamplesPerSec;
					let closest_bits_per_sample = m_closest_format.Format.wBitsPerSample;
					let closest_sub_format = m_closest_format.SubFormat;
					panic!(
						"Demanded audio format and/or parameters are not supported by the target audio device. Closest match available is :\n\t- Channels: {}\n\t- Samples per second: {}\n\t- Bits per Sample: {}\n\t- SubFormat: {:#?}",
						closest_channels, closest_samples_per_second, closest_bits_per_sample, closest_sub_format
					);
				}

				panic!("Demanded audio format and/or parameters are not supported by the target audio device.");
			}

			let m_format = if !m_closest_format.is_null() {
				let m_closest_format: &WAVEFORMATEXTENSIBLE_t = std::mem::transmute(m_closest_format);
				let closest_channels = m_closest_format.Format.nChannels;
				let closest_samples_per_second = m_closest_format.Format.nSamplesPerSec;
				let closest_bits_per_sample = m_closest_format.Format.wBitsPerSample;
				let closest_sub_format = m_closest_format.SubFormat;
				println!(
					"Closest match available is :\n\t- Channels: {}\n\t- Samples per second: {}\n\t- Bits per Sample: {}\n\t- SubFormat: {:#?}",
					closest_channels, closest_samples_per_second, closest_bits_per_sample, closest_sub_format
				);

				m_closest_format
			} else {
				&m_format
			};

			client
				.Initialize(AUDCLNT_SHAREMODE_SHARED, 0, 0, 0, std::mem::transmute(m_format), None)
				.map_err(|_| {
					"Failed to initialize audio client. The device rejected the requested stream format or parameters."
						.to_string()
				})?;

			let bit_depth = m_format.Format.wBitsPerSample as u32;
			let sample_rate = m_format.Format.nSamplesPerSec as u32;
			let channels = m_format.Format.nChannels as u32;

			let params = HardwareParameters {
				sample_rate,
				channels,
				bit_depth,
			};

			if !m_closest_format.is_null() {
				CoTaskMemFree(Some(m_closest_format as _));
			}

			(client, params)
		};

		let render_client: IAudioRenderClient = unsafe {
			client.GetService().map_err(|_| {
				"Failed to get render client service. The audio client did not expose IAudioRenderClient.".to_string()
			})?
		};

		unsafe {
			client.Start().map_err(|_| {
				"Failed to start audio stream. The audio client could not transition to the running state.".to_string()
			})?;
		}

		Ok(Device {
			device,
			client,
			render_client,
			parameters: params,
		})
	}

	fn get_period_size(&self) -> usize {
		let period_size = unsafe { self.client.GetBufferSize().unwrap() };

		period_size as usize
	}

	fn play(&self, wpf: impl WritePlayFunction) -> Result<usize, AudioPlayError> {
		let buffer_size = unsafe { self.client.GetBufferSize().unwrap() };
		let padding = unsafe { self.client.GetCurrentPadding().unwrap() };

		let available_space = buffer_size - padding;

		if available_space == 0 {
			return Ok(0);
		}

		match self.parameters.bit_depth {
			16 => match self.parameters.channels {
				1 => {
					let buffer = unsafe {
						std::slice::from_raw_parts_mut(
							self.render_client.GetBuffer(available_space).unwrap() as *mut i16,
							available_space as usize,
						)
					};

					wpf(Streams::Mono16Bit(buffer))
				}
				2 => {
					let buffer = unsafe {
						std::slice::from_raw_parts_mut(
							self.render_client.GetBuffer(available_space).unwrap() as *mut (i16, i16),
							available_space as usize,
						)
					};

					wpf(Streams::Stereo16Bit(buffer))
				}
				_ => panic!(),
			},
			32 => match self.parameters.channels {
				1 => {
					let buffer = unsafe {
						std::slice::from_raw_parts_mut(
							self.render_client.GetBuffer(available_space).unwrap() as *mut f32,
							available_space as usize,
						)
					};

					wpf(Streams::MonoFloat32(buffer))
				}
				2 => {
					let buffer = unsafe {
						std::slice::from_raw_parts_mut(
							self.render_client.GetBuffer(available_space).unwrap() as *mut (f32, f32),
							available_space as usize,
						)
					};

					wpf(Streams::StereoFloat32(buffer))
				}
				_ => panic!(),
			},
			_ => panic!(),
		}

		unsafe {
			self.render_client.ReleaseBuffer(available_space as _, 0).unwrap();
		}

		Ok(available_space as usize)
	}

	fn pause(&self) {}
}

impl Drop for Device {
	fn drop(&mut self) {
		unsafe {
			self.client.Stop().unwrap();
		}
	}
}