Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

refactor(desktop-native): drop unused capture counters and tests

Hampus4e33a15de9c9
diff --git a/fluxer_desktop/native/mac-app-audio/src/coreaudio_tap.rs b/fluxer_desktop/native/mac-app-audio/src/coreaudio_tap.rs
index c89bcb7f5..6903941d0 100644
--- a/fluxer_desktop/native/mac-app-audio/src/coreaudio_tap.rs
+++ b/fluxer_desktop/native/mac-app-audio/src/coreaudio_tap.rs
@@ -65,7 +65,6 @@ pub enum CreateError {
Unsupported,
NoRelatedProcesses,
NoProcessObjects,
- FoundationObjectFailed,
CreateProcessTapFailed,
ReadTapUidFailed,
ReadTapFormatFailed,
@@ -77,12 +76,6 @@ pub enum CreateError {
pub type PcmCallback =
unsafe extern "C" fn(ctx: *mut c_void, slot: *mut Option<PooledPcmFrame>, frames: u32);
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub struct TapDiagnostics {
- pub convert_failures: u64,
- pub dropped_buffers: u64,
-}
-
pub struct Capture {
pub tap_id: AudioObjectID,
pub aggregate_device_id: AudioObjectID,
@@ -92,8 +85,6 @@ pub struct Capture {
pub pcm_callback: Option<PcmCallback>,
pub pcm_callback_ctx: *mut c_void,
pub pcm_pool: Option<PcmFramePool>,
- pub convert_failures: AtomicU64,
- pub dropped_buffers: AtomicU64,
refresher: Option<RefresherHandle>,
}
@@ -378,16 +369,12 @@ unsafe extern "C-unwind" fn io_proc(
let frames =
match unsafe { ac::input_frame_count_for_buffer_list(&capture.input_format, local_abl) } {
Ok(f) => f,
- Err(_) => {
- capture.convert_failures.fetch_add(1, Ordering::Relaxed);
- return NO_ERR;
- }
+ Err(_) => return NO_ERR,
};
if frames == 0 {
return NO_ERR;
}
if frames > MAX_CALLBACK_INPUT_FRAMES {
- capture.dropped_buffers.fetch_add(1, Ordering::Relaxed);
return NO_ERR;
}
unsafe {
@@ -412,11 +399,9 @@ unsafe fn convert_and_deliver(capture: &Capture, local_abl: *const AudioBufferLi
) as usize)
* (TARGET_CHANNELS as usize);
if needed > pool.samples_per_slot() as usize {
- capture.dropped_buffers.fetch_add(1, Ordering::Relaxed);
return;
}
let Some(mut slot) = pool.try_acquire() else {
- capture.dropped_buffers.fetch_add(1, Ordering::Relaxed);
return;
};
let out_frames = unsafe {
@@ -430,14 +415,7 @@ unsafe fn convert_and_deliver(capture: &Capture, local_abl: *const AudioBufferLi
)
};
let n = match out_frames {
- Ok(0) => {
- capture.dropped_buffers.fetch_add(1, Ordering::Relaxed);
- return;
- }
- Err(_) => {
- capture.convert_failures.fetch_add(1, Ordering::Relaxed);
- return;
- }
+ Ok(0) | Err(_) => return,
Ok(n) => n,
};
let filled = (n as usize) * (TARGET_CHANNELS as usize);
@@ -540,8 +518,6 @@ impl Capture {
pcm_callback: None,
pcm_callback_ctx: ptr::null_mut(),
pcm_pool: None,
- convert_failures: AtomicU64::new(0),
- dropped_buffers: AtomicU64::new(0),
refresher: None,
});
let mut io_proc_id: AudioDeviceIOProcID = None;
@@ -580,16 +556,6 @@ impl Capture {
self.pcm_pool = Some(pool);
}
- pub fn diagnostics(&self) -> TapDiagnostics {
- let diagnostics = TapDiagnostics {
- convert_failures: self.convert_failures.load(Ordering::Relaxed),
- dropped_buffers: self.dropped_buffers.load(Ordering::Relaxed),
- };
- assert!(diagnostics.convert_failures <= u64::MAX / 2);
- assert!(diagnostics.dropped_buffers <= u64::MAX / 2);
- diagnostics
- }
-
pub fn start(&mut self) -> Result<(), CreateError> {
if self.io_proc_id.is_none() || self.aggregate_device_id == kAudioObjectUnknown {
return Err(CreateError::StartDeviceFailed);
@@ -731,7 +697,6 @@ pub fn coreaudio_error_message(e: &CreateError) -> &'static str {
CreateError::Unsupported => "CoreAudio process taps unavailable",
CreateError::NoRelatedProcesses => "No related process for selected app",
CreateError::NoProcessObjects => "No CoreAudio process object for selected app",
- CreateError::FoundationObjectFailed => "CoreAudio tap configuration failed",
CreateError::CreateProcessTapFailed => "CoreAudio process tap creation failed",
CreateError::ReadTapUidFailed => "CoreAudio process tap UID lookup failed",
CreateError::ReadTapFormatFailed => "CoreAudio process tap format lookup failed",
@@ -742,212 +707,3 @@ pub fn coreaudio_error_message(e: &CreateError) -> &'static str {
CreateError::StartDeviceFailed => "CoreAudio process tap start failed",
}
}
-
-#[cfg(test)]
-mod io_proc_diagnostics_tests {
- use super::*;
- use crate::audio_converter::AudioBuffer;
- use core::mem::size_of;
- use core::ptr::NonNull;
- use core::sync::atomic::AtomicU32 as TestAtomicU32;
- use objc2_core_audio_types::AudioTimeStamp;
-
- fn make_idle_capture(input_format: AudioStreamBasicDescription) -> Box<Capture> {
- Box::new(Capture {
- tap_id: kAudioObjectUnknown,
- aggregate_device_id: kAudioObjectUnknown,
- io_proc_id: None,
- input_format,
- running: AtomicBool::new(true),
- pcm_callback: None,
- pcm_callback_ctx: ptr::null_mut(),
- pcm_pool: None,
- convert_failures: AtomicU64::new(0),
- dropped_buffers: AtomicU64::new(0),
- refresher: None,
- })
- }
-
- fn make_test_pool() -> PcmFramePool {
- PcmFramePool::new(2, 8_192).expect("test pool builds")
- }
-
- fn call_io_proc(capture: &Capture, abl: &mut AudioBufferList) -> OSStatus {
- let mut ts_now: AudioTimeStamp = unsafe { core::mem::zeroed() };
- let mut ts_input: AudioTimeStamp = unsafe { core::mem::zeroed() };
- let mut ts_output: AudioTimeStamp = unsafe { core::mem::zeroed() };
- let mut out_abl = AudioBufferList {
- m_number_buffers: 0,
- buffers: [AudioBuffer {
- m_number_channels: 0,
- m_data_byte_size: 0,
- m_data: ptr::null_mut(),
- }],
- };
- unsafe {
- io_proc(
- 0,
- NonNull::from(&mut ts_now),
- NonNull::new(
- abl as *mut AudioBufferList as *mut objc2_core_audio_types::AudioBufferList,
- )
- .expect("input abl non-null"),
- NonNull::from(&mut ts_input),
- NonNull::new(
- &mut out_abl as *mut AudioBufferList
- as *mut objc2_core_audio_types::AudioBufferList,
- )
- .expect("output abl non-null"),
- NonNull::from(&mut ts_output),
- capture as *const Capture as *mut c_void,
- )
- }
- }
-
- fn interleaved_abl(data: &mut [f32]) -> AudioBufferList {
- AudioBufferList {
- m_number_buffers: 1,
- buffers: [AudioBuffer {
- m_number_channels: TARGET_CHANNELS,
- m_data_byte_size: (data.len() * size_of::<f32>()) as u32,
- m_data: data.as_mut_ptr() as *mut c_void,
- }],
- }
- }
-
- #[test]
- fn convert_failures_counted_for_unsupported_format() {
- let capture = make_idle_capture(AudioStreamBasicDescription::default());
- let mut data = [0.0_f32; 8];
- let mut abl = interleaved_abl(&mut data);
- let status = call_io_proc(&capture, &mut abl);
- assert_eq!(status, NO_ERR);
- let diagnostics = capture.diagnostics();
- assert_eq!(diagnostics.convert_failures, 1);
- assert_eq!(diagnostics.dropped_buffers, 0);
- }
-
- unsafe extern "C" fn noop_pcm_cb(
- _ctx: *mut c_void,
- _slot: *mut Option<PooledPcmFrame>,
- _frames: u32,
- ) {
- }
-
- #[test]
- fn dropped_buffers_counted_when_pool_exhausted() {
- let mut capture = make_idle_capture(ac::build_input_asbd(48_000.0, TARGET_CHANNELS, false));
- let pool = make_test_pool();
- capture.set_pcm_callback(noop_pcm_cb, ptr::null_mut());
- capture.set_pcm_pool(pool.clone());
- let mut held = Vec::with_capacity(pool.capacity() as usize);
- for _ in 0..pool.capacity() {
- held.push(pool.try_acquire().expect("slot in capacity"));
- }
- let mut data = [0.25_f32; 96];
- let mut abl = interleaved_abl(&mut data);
- let status = call_io_proc(&capture, &mut abl);
- drop(held);
- assert_eq!(status, NO_ERR);
- let diagnostics = capture.diagnostics();
- assert_eq!(diagnostics.dropped_buffers, 1);
- assert_eq!(diagnostics.convert_failures, 0);
- }
-
- #[test]
- fn dropped_buffers_counted_when_slot_too_small_for_conversion() {
- let mut capture = make_idle_capture(ac::build_input_asbd(48_000.0, TARGET_CHANNELS, false));
- let pool = PcmFramePool::new(2, 16).expect("tiny pool builds");
- capture.set_pcm_callback(noop_pcm_cb, ptr::null_mut());
- capture.set_pcm_pool(pool);
- let mut data = [0.25_f32; 96];
- let mut abl = interleaved_abl(&mut data);
- let status = call_io_proc(&capture, &mut abl);
- assert_eq!(status, NO_ERR);
- let diagnostics = capture.diagnostics();
- assert_eq!(diagnostics.dropped_buffers, 1);
- assert_eq!(diagnostics.convert_failures, 0);
- }
-
- #[test]
- fn dropped_buffers_counted_for_oversize_input() {
- let capture = make_idle_capture(ac::build_input_asbd(48_000.0, TARGET_CHANNELS, false));
- let mut data = [0.0_f32; 8];
- let bytes_per_frame = (size_of::<f32>() as u32) * TARGET_CHANNELS;
- let mut abl = interleaved_abl(&mut data);
- abl.buffers[0].m_data_byte_size = (MAX_CALLBACK_INPUT_FRAMES + 1) * bytes_per_frame;
- let status = call_io_proc(&capture, &mut abl);
- assert_eq!(status, NO_ERR);
- let diagnostics = capture.diagnostics();
- assert_eq!(diagnostics.dropped_buffers, 1);
- assert_eq!(diagnostics.convert_failures, 0);
- }
-
- #[test]
- fn stopped_capture_counts_nothing() {
- let capture = make_idle_capture(AudioStreamBasicDescription::default());
- capture.running.store(false, Ordering::Release);
- let mut data = [0.0_f32; 8];
- let mut abl = interleaved_abl(&mut data);
- let status = call_io_proc(&capture, &mut abl);
- assert_eq!(status, NO_ERR);
- let diagnostics = capture.diagnostics();
- assert_eq!(diagnostics.convert_failures, 0);
- assert_eq!(diagnostics.dropped_buffers, 0);
- }
-
- static OBSERVED_FRAMES: TestAtomicU32 = TestAtomicU32::new(0);
- static OBSERVED_FILLED: TestAtomicU32 = TestAtomicU32::new(0);
-
- unsafe extern "C" fn observing_pcm_cb(
- _ctx: *mut c_void,
- slot: *mut Option<PooledPcmFrame>,
- frames: u32,
- ) {
- assert!(!slot.is_null());
- let frame = unsafe { (*slot).take() }.expect("slot delivered");
- assert_eq!(
- frame.filled_len(),
- (frames as usize) * (TARGET_CHANNELS as usize)
- );
- assert_eq!(frame.data_slice()[0], 0.25);
- OBSERVED_FILLED.store(frame.filled_len() as u32, Ordering::Release);
- OBSERVED_FRAMES.store(frames, Ordering::Release);
- }
-
- #[test]
- fn successful_conversion_counts_nothing_and_invokes_callback() {
- OBSERVED_FRAMES.store(0, Ordering::Release);
- OBSERVED_FILLED.store(0, Ordering::Release);
- let mut capture = make_idle_capture(ac::build_input_asbd(48_000.0, TARGET_CHANNELS, false));
- let pool = make_test_pool();
- capture.set_pcm_callback(observing_pcm_cb, ptr::null_mut());
- capture.set_pcm_pool(pool.clone());
- let mut data = [0.25_f32; 96];
- let mut abl = interleaved_abl(&mut data);
- let status = call_io_proc(&capture, &mut abl);
- assert_eq!(status, NO_ERR);
- let diagnostics = capture.diagnostics();
- assert_eq!(diagnostics.convert_failures, 0);
- assert_eq!(diagnostics.dropped_buffers, 0);
- assert_eq!(OBSERVED_FRAMES.load(Ordering::Acquire), 48);
- assert_eq!(OBSERVED_FILLED.load(Ordering::Acquire), 96);
- assert_eq!(pool.stats().in_flight, 0);
- assert_eq!(pool.stats().released, 1);
- }
-
- #[test]
- fn untaken_slot_returns_to_pool() {
- let mut capture = make_idle_capture(ac::build_input_asbd(48_000.0, TARGET_CHANNELS, false));
- let pool = make_test_pool();
- capture.set_pcm_callback(noop_pcm_cb, ptr::null_mut());
- capture.set_pcm_pool(pool.clone());
- let mut data = [0.25_f32; 96];
- let mut abl = interleaved_abl(&mut data);
- let status = call_io_proc(&capture, &mut abl);
- assert_eq!(status, NO_ERR);
- assert_eq!(pool.stats().in_flight, 0);
- assert_eq!(pool.stats().acquired, 1);
- assert_eq!(pool.stats().released, 1);
- }
-}
diff --git a/fluxer_desktop/native/windows-input-hook/index.d.ts b/fluxer_desktop/native/windows-input-hook/index.d.ts
index 37f95b4a4..dc86405b7 100644
--- a/fluxer_desktop/native/windows-input-hook/index.d.ts
+++ b/fluxer_desktop/native/windows-input-hook/index.d.ts
@@ -29,9 +29,6 @@ export declare class InputHook {
start(): void;
stop(): void;
-
- readonly droppedEvents: number;
- readonly reinstallCount: number;
}
export declare function isAvailable(): boolean;
diff --git a/fluxer_desktop/native/windows-input-hook/src/lib.rs b/fluxer_desktop/native/windows-input-hook/src/lib.rs
index d76f3585d..01bb47899 100644
--- a/fluxer_desktop/native/windows-input-hook/src/lib.rs
+++ b/fluxer_desktop/native/windows-input-hook/src/lib.rs
@@ -246,7 +246,6 @@ mod platform {
pub(crate) struct HookHandle {
pub(crate) tsfn: EventThreadsafeFunction,
- pub(crate) dropped_events: AtomicU64,
pub(crate) keyboard_hook: Mutex<Option<HHOOK>>,
pub(crate) mouse_hook: Mutex<Option<HHOOK>>,
pub(crate) thread_id: AtomicU64,
@@ -258,7 +257,6 @@ mod platform {
pub(crate) last_cursor_y: AtomicI32,
pub(crate) last_event_ms: AtomicU64,
pub(crate) last_cursor_change_ms: AtomicU64,
- pub(crate) reinstall_count: AtomicU64,
held: Mutex<HeldInputs>,
}
@@ -335,12 +333,9 @@ mod platform {
}
fn send(handle: &HookHandle, event: QueuedEvent) {
- let status = handle
+ let _ = handle
.tsfn
.call(event, ThreadsafeFunctionCallMode::NonBlocking);
- if !matches!(status, napi::Status::Ok) {
- handle.dropped_events.fetch_add(1, Ordering::Relaxed);
- }
}
unsafe extern "system" fn keyboard_proc(code: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
@@ -515,7 +510,6 @@ mod platform {
uninstall_hooks(&handle);
if install_hooks(&handle).is_ok() {
handle.last_event_ms.store(now_ms(), Ordering::Release);
- handle.reinstall_count.fetch_add(1, Ordering::Relaxed);
} else {
uninstall_hooks(&handle);
handle.last_event_ms.store(now_ms(), Ordering::Release);
@@ -661,7 +655,6 @@ mod platform {
pub(crate) fn new_handle(tsfn: EventThreadsafeFunction) -> Arc<HookHandle> {
Arc::new(HookHandle {
tsfn,
- dropped_events: AtomicU64::new(0),
keyboard_hook: Mutex::new(None),
mouse_hook: Mutex::new(None),
thread_id: AtomicU64::new(0),
@@ -673,7 +666,6 @@ mod platform {
last_cursor_y: AtomicI32::new(0),
last_event_ms: AtomicU64::new(0),
last_cursor_change_ms: AtomicU64::new(0),
- reinstall_count: AtomicU64::new(0),
held: Mutex::new(HeldInputs::default()),
})
}
@@ -683,20 +675,13 @@ mod platform {
mod platform {
use super::EventThreadsafeFunction;
use std::sync::Arc;
- use std::sync::atomic::AtomicU64;
pub(crate) struct HookHandle {
pub(crate) tsfn: EventThreadsafeFunction,
- pub(crate) dropped_events: AtomicU64,
- pub(crate) reinstall_count: AtomicU64,
}
pub(crate) fn new_handle(tsfn: EventThreadsafeFunction) -> Arc<HookHandle> {
- Arc::new(HookHandle {
- tsfn,
- dropped_events: AtomicU64::new(0),
- reinstall_count: AtomicU64::new(0),
- })
+ Arc::new(HookHandle { tsfn })
}
pub(crate) fn start(_handle: Arc<HookHandle>) -> Result<(), String> {
@@ -747,20 +732,6 @@ impl InputHook {
pub fn stop(&self) {
platform::stop(&self.inner);
}
-
- #[napi(getter, js_name = "droppedEvents")]
- pub fn dropped_events(&self) -> f64 {
- self.inner
- .dropped_events
- .load(std::sync::atomic::Ordering::Relaxed) as f64
- }
-
- #[napi(getter, js_name = "reinstallCount")]
- pub fn reinstall_count(&self) -> f64 {
- self.inner
- .reinstall_count
- .load(std::sync::atomic::Ordering::Relaxed) as f64
- }
}
impl Drop for InputHook {
@@ -773,99 +744,3 @@ impl Drop for InputHook {
pub fn is_available() -> bool {
cfg!(target_os = "windows")
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn write_key_name_from_hook_distinguishes_keypad_navigation() {
- let mut buf = [0u8; KEY_NAME_BUF];
- let mut len = 0u8;
-
- write_key_name_from_hook(&mut buf, &mut len, 0x2d, 0);
- assert_eq!(&buf[..len as usize], b"Numpad0");
-
- buf = [0u8; KEY_NAME_BUF];
- len = 0;
- write_key_name_from_hook(&mut buf, &mut len, 0x2d, LLKHF_EXTENDED_FLAG);
- assert_eq!(&buf[..len as usize], b"Insert");
-
- buf = [0u8; KEY_NAME_BUF];
- len = 0;
- write_key_name_from_hook(&mut buf, &mut len, 0x0d, LLKHF_EXTENDED_FLAG);
- assert_eq!(&buf[..len as usize], b"NumpadEnter");
- }
-
- #[test]
- fn write_packet_key_name_uses_the_injected_character() {
- let name = |unit: u32| {
- let mut buf = [0xffu8; KEY_NAME_BUF];
- let mut len = 7u8;
- write_packet_key_name(&mut buf, &mut len, unit);
- String::from_utf8(buf[..len as usize].to_vec()).unwrap()
- };
- assert_eq!(name(u32::from('g')), "G");
- assert_eq!(name(u32::from('G')), "G");
- assert_eq!(name(u32::from('7')), "7");
- assert_eq!(name(u32::from(' ')), "Space");
- assert_eq!(name(u32::from('.')), "");
- assert_eq!(name(0x00f6), "");
- assert_eq!(name(0xd83d), "");
- }
-
- #[test]
- fn event_kind_strings_match_contract() {
- assert_eq!(EventKind::KeyDown.as_str(), "keydown");
- assert_eq!(EventKind::KeyUp.as_str(), "keyup");
- assert_eq!(EventKind::MouseDown.as_str(), "mousedown");
- assert_eq!(EventKind::MouseUp.as_str(), "mouseup");
- }
-
- #[test]
- fn held_inputs_release_each_pressed_input_once_without_modifiers() {
- let key = |kind, keycode, scan_code, extended| QueuedEvent {
- kind,
- keycode,
- scan_code,
- extended,
- ctrl: true,
- ..QueuedEvent::default()
- };
- let mut held = HeldInputs::default();
- held.track(&key(EventKind::KeyDown, 0x41, 0x1e, false));
- held.track(&key(EventKind::KeyDown, 0x41, 0x1e, false));
- held.track(&key(EventKind::KeyDown, 0x0d, 0x1c, true));
- held.track(&key(EventKind::KeyDown, 0x0d, 0x1c, false));
- held.track(&key(EventKind::KeyUp, 0x0d, 0x1c, false));
- held.track(&QueuedEvent {
- kind: EventKind::MouseDown,
- button: 3,
- has_xy: true,
- ..QueuedEvent::default()
- });
- let releases = held.take_releases();
- let summary: Vec<(EventKind, u32, bool, u8, bool, bool)> = releases
- .iter()
- .map(|event| {
- (
- event.kind,
- event.keycode,
- event.extended,
- event.button,
- event.ctrl,
- event.has_xy,
- )
- })
- .collect();
- assert_eq!(
- summary,
- vec![
- (EventKind::KeyUp, 0x41, false, 0, false, false),
- (EventKind::KeyUp, 0x0d, true, 0, false, false),
- (EventKind::MouseUp, 0, false, 3, false, false),
- ]
- );
- assert!(held.take_releases().is_empty());
- }
-}