use std::collections::VecDeque;
use windows::{
Win32::{
Media::Audio::{
AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM, AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY,
IAudioClient, IAudioClock, IAudioRenderClient, IAudioStreamVolume, IMMDeviceEnumerator, MMDeviceEnumerator,
WAVE_FORMAT_PCM, WAVEFORMATEX, eMultimedia, eRender,
},
System::Com::{CLSCTX_ALL, CoCreateInstance},
},
core::Result,
};
pub(super) const CHANNELS: usize = 2;
const AHEAD: i64 = 2_000_000;
pub(super) struct Output {
client: IAudioClient,
render: IAudioRenderClient,
clock: IAudioClock,
level: Option<IAudioStreamVolume>,
frequency: u64,
room: u32,
speed: f64,
running: bool,
base: f64,
recent: VecDeque<f32>,
}
impl Output {
pub unsafe fn open(rate: u32, speed: f64, level: f32) -> Result<Self> {
unsafe {
let devices: IMMDeviceEnumerator = CoCreateInstance(&MMDeviceEnumerator, None, CLSCTX_ALL)?;
let device = devices.GetDefaultAudioEndpoint(eRender, eMultimedia)?;
let client: IAudioClient = device.Activate(CLSCTX_ALL, None)?;
let told = (f64::from(rate) * speed).round().clamp(1.0, f64::from(u32::MAX)) as u32;
let frame = (CHANNELS * 2) as u16;
let format = WAVEFORMATEX {
wFormatTag: WAVE_FORMAT_PCM as u16,
nChannels: CHANNELS as u16,
nSamplesPerSec: told,
nAvgBytesPerSec: told.saturating_mul(u32::from(frame)),
nBlockAlign: frame,
wBitsPerSample: 16,
cbSize: 0,
};
client.Initialize(
AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY,
AHEAD,
0,
&format,
None,
)?;
let room = client.GetBufferSize()?;
let render: IAudioRenderClient = client.GetService()?;
let clock: IAudioClock = client.GetService()?;
let frequency = clock.GetFrequency()?.max(1);
let output = Self {
level: client.GetService().ok(),
client,
render,
clock,
frequency,
room,
speed,
running: false,
base: 0.0,
recent: VecDeque::new(),
};
output.set_level(level);
Ok(output)
}
}
pub fn set_level(&self, level: f32) {
let Some(volume) = &self.level else {
return;
};
unsafe {
let channels = volume.GetChannelCount().unwrap_or(0) as usize;
let _ = volume.SetAllVolumes(&vec![level.clamp(0.0, 1.0); channels]);
}
}
pub fn running(&self) -> bool {
self.running
}
pub fn pending(&self) -> u32 {
unsafe { self.client.GetCurrentPadding().unwrap_or(0) }
}
pub unsafe fn feed(&mut self, queue: &mut VecDeque<f32>, at: f64) -> Result<usize> {
unsafe {
let free = self.room.saturating_sub(self.client.GetCurrentPadding()?) as usize;
let frames = free.min(queue.len() / CHANNELS);
if frames == 0 {
return Ok(0);
}
if self.recent.is_empty() {
self.base = at;
}
let data = self.render.GetBuffer(frames as u32)?;
let samples = std::slice::from_raw_parts_mut(data.cast::<i16>(), frames * CHANNELS);
for slot in samples.iter_mut() {
let sample = queue.pop_front().unwrap_or(0.0);
*slot = (sample.clamp(-1.0, 1.0) * f32::from(i16::MAX)) as i16;
self.recent.push_back(sample);
}
self.render.ReleaseBuffer(frames as u32, 0)?;
let kept = self.room as usize * CHANNELS;
while self.recent.len() > kept {
self.recent.pop_front();
}
Ok(frames)
}
}
pub unsafe fn start(&mut self) -> Result<()> {
if !self.running {
unsafe { self.client.Start()? };
self.running = true;
}
Ok(())
}
pub unsafe fn stop(&mut self) -> Result<()> {
if self.running {
unsafe { self.client.Stop()? };
self.running = false;
}
Ok(())
}
pub unsafe fn empty(&mut self) -> Result<()> {
unsafe {
self.stop()?;
self.client.Reset()?;
}
self.recent.clear();
Ok(())
}
pub fn heard(&self) -> Option<f64> {
if self.recent.is_empty() {
return None;
}
let mut position = 0_u64;
unsafe { self.clock.GetPosition(&mut position, None).ok()? };
Some(self.base + position as f64 / self.frequency as f64 * self.speed)
}
pub fn unheard(&self) -> Vec<f32> {
let samples = (self.pending() as usize * CHANNELS).min(self.recent.len());
self.recent.iter().skip(self.recent.len() - samples).copied().collect()
}
}