//! Audio bit-depth diagnostic //! //! Lock-free capture that accumulates an OR-mask of all sample values //! converted to i32. The trailing zeros in the mask reveal the effective //! bit depth of the source data — no sample storage needed. //! //! Works for both rodio (PipeWire/ALSA via CPAL) and ALSA Direct paths //! via a transparent Source wrapper. use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering}; use std::sync::Arc; use std::time::Duration; use rodio::Source; use serde::Serialize; // --------------------------------------------------------------------------- // Shared diagnostic state (atomics — safe to clone across threads) // --------------------------------------------------------------------------- #[derive(Clone)] pub struct AudioDiagnostic { capturing: Arc, or_mask: Arc, sample_count: Arc, sample_rate: Arc, channels: Arc, } impl AudioDiagnostic { pub fn new() -> Self { Self { capturing: Arc::new(AtomicBool::new(false)), or_mask: Arc::new(AtomicU32::new(0)), sample_count: Arc::new(AtomicU64::new(0)), sample_rate: Arc::new(AtomicU32::new(0)), channels: Arc::new(AtomicU32::new(0)), } } /// Begin capturing. Resets previous state. pub fn start_capture(&self, sample_rate: u32, channels: u32) { self.or_mask.store(0, Ordering::SeqCst); self.sample_count.store(0, Ordering::SeqCst); self.sample_rate.store(sample_rate, Ordering::SeqCst); self.channels.store(channels, Ordering::SeqCst); self.capturing.store(true, Ordering::SeqCst); log::info!( "[Diagnostic] Bit-depth capture started ({}Hz, {}ch)", sample_rate, channels ); } #[inline] pub fn is_capturing(&self) -> bool { self.capturing.load(Ordering::Relaxed) } /// Push a single sample (called per-sample in the Source wrapper). #[inline] pub fn push_sample(&self, sample: f32) { if !self.is_capturing() { return; } let clamped = sample.clamp(-1.0, 1.0); let s32 = (clamped * 2_147_483_647.0) as i32; self.or_mask.fetch_or(s32.unsigned_abs(), Ordering::Relaxed); self.sample_count.fetch_add(1, Ordering::Relaxed); } /// Stop capturing and return the analysis. pub fn stop_and_analyze(&self) -> BitDepthResult { self.capturing.store(false, Ordering::SeqCst); let or_mask = self.or_mask.load(Ordering::SeqCst); let sample_count = self.sample_count.load(Ordering::SeqCst); let sample_rate = self.sample_rate.load(Ordering::SeqCst); let channels = self.channels.load(Ordering::SeqCst); let trailing_zeros = if or_mask == 0 { 32 } else { or_mask.trailing_zeros() }; let effective_bits = 32 - trailing_zeros; let frames = if channels > 0 { sample_count / channels as u64 } else { sample_count }; let duration_secs = if sample_rate > 0 { frames as f64 / sample_rate as f64 } else { 0.0 }; log::info!( "[Diagnostic] Capture stopped: {} samples, {:.1}s, or_mask=0x{:08X}, trailing_zeros={}, effective_bits={}", sample_count, duration_secs, or_mask, trailing_zeros, effective_bits ); BitDepthResult { sample_count, sample_rate, channels, duration_secs, or_mask: format!("0x{:08X}", or_mask), trailing_zeros, effective_bits, } } } impl Default for AudioDiagnostic { fn default() -> Self { Self::new() } } // --------------------------------------------------------------------------- // Result returned to the frontend // --------------------------------------------------------------------------- #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] pub struct BitDepthResult { pub sample_count: u64, pub sample_rate: u32, pub channels: u32, pub duration_secs: f64, pub or_mask: String, pub trailing_zeros: u32, pub effective_bits: u32, } // --------------------------------------------------------------------------- // Source wrapper — transparent tap for bit-depth capture // --------------------------------------------------------------------------- pub struct DiagnosticSource where S: Source, { inner: S, diagnostic: AudioDiagnostic, } impl DiagnosticSource where S: Source, { pub fn new(source: S, diagnostic: AudioDiagnostic) -> Self { Self { inner: source, diagnostic, } } } impl Iterator for DiagnosticSource where S: Source, { type Item = f32; #[inline] fn next(&mut self) -> Option { let sample = self.inner.next()?; self.diagnostic.push_sample(sample); Some(sample) } #[inline] fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } } impl Source for DiagnosticSource where S: Source, { #[inline] fn current_span_len(&self) -> Option { self.inner.current_span_len() } #[inline] fn channels(&self) -> std::num::NonZero { self.inner.channels() } #[inline] fn sample_rate(&self) -> std::num::NonZero { self.inner.sample_rate() } #[inline] fn total_duration(&self) -> Option { self.inner.total_duration() } }