From 484dad10725fd390fc34c67ff2c8a4978661ed0a Mon Sep 17 00:00:00 2001 From: Edison Jwa Date: Thu, 4 Jun 2026 00:51:25 +0900 Subject: [PATCH] fix(audio): eliminate Android output stutter via Oboe config + lock-free callback MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 1 — Oboe configuration: - Change output stream from Usage::VoiceCommunication to Usage::Game with ContentType::Sonification to avoid forcing the Legacy (OpenSL ES) data path on most devices (Oboe issue #2075) - Switch output format from i16 Mono to f32 Stereo, matching Qint's proven configuration and eliminating per-callback downmix conversion - Set buffer size to 2x burst after stream open, reducing default buffer from 8-20x burst to 2x burst for lower latency - Remove scratch Mutex>; callback writes directly to Oboe buffer Phase 2 — Lock-free output callback: - Add audio_event_queue.rs: lock-free SPSC bridge using crossbeam ArrayQueue with separate packet (lossy) and control (reliable) channels - OutputCallback now owns AudioHandler directly (no Arc> on Android) - Inbound forwarder pushes packets via AudioEventProducer (no mutex) - set_client_volume pushes control commands via event queue on Android - iOS/desktop Arc> path unchanged --- Cargo.lock | 22 +++ crates/chanora_audio/Cargo.toml | 2 + .../chanora_audio/src/android_voice_unit.rs | 137 +++++++++++------- crates/chanora_audio/src/audio_event_queue.rs | 118 +++++++++++++++ crates/chanora_audio/src/engine.rs | 85 ++++++----- crates/chanora_audio/src/lib.rs | 2 + .../chanora_audio/src/mobile_voice_backend.rs | 12 +- 7 files changed, 291 insertions(+), 87 deletions(-) create mode 100644 crates/chanora_audio/src/audio_event_queue.rs diff --git a/Cargo.lock b/Cargo.lock index 939cdfd..170a3f9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -423,6 +423,8 @@ dependencies = [ "coreaudio-rs", "cpal", "criterion", + "crossbeam", + "crossbeam-utils", "dhat", "dispatch2", "futures-util", @@ -803,6 +805,17 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" +[[package]] +name = "crossbeam" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8" +dependencies = [ + "crossbeam-epoch", + "crossbeam-queue", + "crossbeam-utils", +] + [[package]] name = "crossbeam-channel" version = "0.5.15" @@ -831,6 +844,15 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "crossbeam-queue" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-utils" version = "0.8.21" diff --git a/crates/chanora_audio/Cargo.toml b/crates/chanora_audio/Cargo.toml index d94642a..1425165 100644 --- a/crates/chanora_audio/Cargo.toml +++ b/crates/chanora_audio/Cargo.toml @@ -29,6 +29,8 @@ audiopus = "0.3.0-rc.0" tsclientlib = { git = "https://github.com/ReSpeak/tsclientlib.git", rev = "04aa2491", default-features = false, features = ["audio"] } tokio = { version = "1", features = ["sync", "rt", "macros", "time"] } rustfft = "6.2.0" +crossbeam = { version = "0.8", default-features = false, features = ["alloc", "crossbeam-queue"] } +crossbeam-utils = { version = "0.8", default-features = false } [target.'cfg(all(not(target_os = "android"), not(target_os = "ios"), not(target_os = "macos")))'.dependencies] # Desktop audio I/O for Windows capture/playback and Linux capture. diff --git a/crates/chanora_audio/src/android_voice_unit.rs b/crates/chanora_audio/src/android_voice_unit.rs index 8eb5f35..c3c7c16 100644 --- a/crates/chanora_audio/src/android_voice_unit.rs +++ b/crates/chanora_audio/src/android_voice_unit.rs @@ -44,6 +44,7 @@ use std::sync::{Arc, Mutex}; use audiopus::coder::Encoder as OpusEncoder; use tracing::{debug, info, warn}; +use crate::audio_event_queue::{AudioCommand, AudioEventQueue}; use crate::mobile_voice_backend::{ clear_android_audio_diagnostics, latency_tier_for, next_input_preset_after, next_sharing_mode_after, publish_android_audio_diagnostics, AchievedInputPreset, @@ -63,7 +64,7 @@ use oboe::{ AudioInputCallback, AudioInputStreamSafe, AudioOutputCallback, AudioOutputStreamSafe, AudioStream, AudioStreamAsync, AudioStreamBase, AudioStreamBuilder, AudioStreamSafe, DataCallbackResult, Input as OboeInput, InputPreset, Mono, Output as OboeOutput, - PerformanceMode, SessionId, SharingMode, Usage, + PerformanceMode, SessionId, SharingMode, Stereo, Usage, }; use crate::processor::AudioProcessor; @@ -518,14 +519,14 @@ impl AudioInputCallback for InputCallback { // // Mirrors the iOS VPIO render callback. Pulls mixed 48 kHz stereo f32 // from `AudioHandler::fill_buffer`, applies output gain + mute, and -// writes mono i16 to the Oboe output buffer. +// writes stereo f32 directly to the Oboe output buffer. struct OutputCallback { - handler: Arc>>, + handler: AudioHandler, + event_queue: Arc, output_gain: Arc, output_muted: Arc, event_tx: BackendEventTx, - scratch: Arc>>, render_reference: Arc, audio_processing_stats: Arc, pending_render_ref: [f32; crate::frame::FRAME_10MS_SAMPLES], @@ -533,51 +534,56 @@ struct OutputCallback { } impl AudioOutputCallback for OutputCallback { - type FrameType = (i16, Mono); + type FrameType = (f32, Stereo); fn on_audio_ready( &mut self, _stream: &mut dyn AudioOutputStreamSafe, - frames: &mut [i16], + frames: &mut [(f32, f32)], ) -> DataCallbackResult { let _ = catch_unwind(AssertUnwindSafe(|| { - let needed = frames.len() * 2; // stereo - let scratch = &mut self.scratch.lock().unwrap(); - if scratch.len() < needed { - scratch.resize(needed, 0.0); - } else { - for s in &mut scratch[..needed] { - *s = 0.0; + let buf: &mut [f32] = unsafe { + std::slice::from_raw_parts_mut(frames.as_mut_ptr() as *mut f32, frames.len() * 2) + }; + for s in buf.iter_mut() { + *s = 0.0; + } + let consumer = AudioEventQueue::consumer(&self.event_queue); + for cmd in consumer.drain_controls() { + match cmd { + AudioCommand::SetVolume(id, vol) => { + if let Some(q) = self.handler.get_mut_queues().get_mut(&id) { + q.volume = vol; + } + } + AudioCommand::RemoveClient(id) => { + self.handler.get_mut_queues().remove(&id); + } } } - match self.handler.try_lock() { - Ok(mut h) => { - let _ = h.fill_buffer(&mut scratch[..needed]); - } - Err(std::sync::TryLockError::WouldBlock) => {} - Err(std::sync::TryLockError::Poisoned(e)) => { - warn!( - target: "chanora_audio", - "AudioHandler mutex poisoned: {}", - e - ); + + for pkt in consumer.drain_packets(50) { + if let Err(e) = self.handler.handle_packet(pkt.client_id, pkt.data) { + debug!(target: "chanora_audio", error = %e, "decode failed"); } } + + let _ = self.handler.fill_buffer(buf); let gain = f32::from_bits(self.output_gain.load(Ordering::Relaxed)); let muted = self.output_muted.load(Ordering::Relaxed); - let _ = crate::voice_render::downmix_stereo_f32_to_mono_i16( - &scratch[..needed], - frames, - gain, - muted, - ); + if muted { + for s in buf.iter_mut() { + *s = 0.0; + } + } else if gain != 1.0 { + for s in buf.iter_mut() { + *s *= gain; + } + } self.audio_processing_stats - .update_render(crate::frame::dbfs(&scratch[..needed]), frames.len() as u32); + .update_render(crate::frame::dbfs(buf), frames.len() as u32); - // Accumulate the full render callback into 10 ms mono chunks so - // AEC sees consistent reference timing even when output callbacks - // are shorter or longer than 10 ms. - for chunk in scratch[..needed].chunks_exact(2) { + for chunk in buf.chunks_exact(2) { self.pending_render_ref[self.pending_render_ref_len] = (chunk[0] + chunk[1]) * 0.5; self.pending_render_ref_len += 1; if self.pending_render_ref_len == crate::frame::FRAME_10MS_SAMPLES { @@ -677,8 +683,6 @@ impl AndroidVoiceUnit { .map_err(|e| BackendError::OpenFailed(format!("capture state init: {e}")))?, )); - let scratch = Arc::new(Mutex::new(Vec::with_capacity(8192))); - // --- Open input stream (SDD-112) --------------------------- let input_builder = AudioStreamBuilder::default() .set_direction::() @@ -766,8 +770,8 @@ impl AndroidVoiceUnit { let output_builder = AudioStreamBuilder::default() .set_direction::() .set_sample_rate(cfg.sample_rate as i32) - .set_channel_count::() - .set_format::() + .set_channel_count::() + .set_format::() .set_performance_mode(if cfg.request_low_latency { PerformanceMode::LowLatency } else { @@ -778,16 +782,21 @@ impl AndroidVoiceUnit { } else { SharingMode::Shared }) - .set_usage(Usage::VoiceCommunication) - .set_content_type(oboe::ContentType::Speech); + // Usage::Game avoids forcing the Legacy (OpenSL ES) data path + // that Usage::VoiceCommunication triggers on most devices. + // Android audio routing is already handled by + // AudioManager.MODE_IN_COMMUNICATION on the Flutter side. + .set_usage(Usage::Game) + .set_content_type(oboe::ContentType::Sonification); let render_ref_for_output = render_ref_buf.clone(); + let event_queue = params.event_producer.queue(); let output_cb = OutputCallback { - handler: params.handler.clone(), + handler: params.handler, + event_queue: event_queue.clone(), output_gain: params.output_gain.clone(), output_muted: params.output_muted.clone(), event_tx: event_tx.clone(), - scratch: scratch.clone(), render_reference: render_ref_for_output, audio_processing_stats: audio_processing_stats.clone(), pending_render_ref: [0.0_f32; crate::frame::FRAME_10MS_SAMPLES], @@ -806,20 +815,41 @@ impl AndroidVoiceUnit { Self::open_output_fallback( cfg, &event_tx, - params.handler.clone(), + AudioHandler::new(), + event_queue.clone(), params.output_gain.clone(), params.output_muted.clone(), audio_processing_stats.clone(), - scratch.clone(), render_ref_buf, )? } }; + let output_frames_per_burst = output_stream.get_frames_per_burst(); + if output_frames_per_burst > 0 { + let desired = output_frames_per_burst * 2; + match output_stream.set_buffer_size_in_frames(desired) { + Ok(actual) => { + debug!( + target: "chanora_audio", + desired, + actual, + "android: output buffer size tuned" + ); + } + Err(e) => { + warn!( + target: "chanora_audio", + error = ?e, + "android: output buffer size tuning failed; using device default" + ); + } + } + } + let output_perf = perf_from_oboe(output_stream.get_performance_mode()); let output_share = share_from_oboe(output_stream.get_sharing_mode()); let output_sample_rate = output_stream.get_sample_rate(); - let output_frames_per_burst = output_stream.get_frames_per_burst(); // SDD-112 / SRS-210: structured "stream opened" event with // achieved values. No PII; only platform-reported scalars. @@ -1038,19 +1068,19 @@ impl AndroidVoiceUnit { fn open_output_fallback( cfg: &AndroidVoiceStreamConfig, event_tx: &BackendEventTx, - handler: Arc>>, + handler: AudioHandler, + event_queue: Arc, output_gain: Arc, output_muted: Arc, audio_processing_stats: Arc, - scratch: Arc>>, render_reference: Arc, ) -> Result, BackendError> { let cb = OutputCallback { handler, + event_queue, output_gain, output_muted, event_tx: event_tx.clone(), - scratch, render_reference, audio_processing_stats, pending_render_ref: [0.0_f32; crate::frame::FRAME_10MS_SAMPLES], @@ -1059,12 +1089,13 @@ impl AndroidVoiceUnit { let builder = AudioStreamBuilder::default() .set_direction::() .set_sample_rate(cfg.sample_rate as i32) - .set_channel_count::() - .set_format::() + .set_channel_count::() + .set_format::() .set_performance_mode(PerformanceMode::LowLatency) .set_sharing_mode(SharingMode::Shared) - .set_usage(Usage::VoiceCommunication) - .set_content_type(oboe::ContentType::Speech) + // Same Usage::Game rationale as primary output builder above. + .set_usage(Usage::Game) + .set_content_type(oboe::ContentType::Sonification) .set_callback(cb); builder .open_stream() diff --git a/crates/chanora_audio/src/audio_event_queue.rs b/crates/chanora_audio/src/audio_event_queue.rs new file mode 100644 index 0000000..40a1e82 --- /dev/null +++ b/crates/chanora_audio/src/audio_event_queue.rs @@ -0,0 +1,118 @@ +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::Arc; + +use chanora_protocol::InAudioBuf; +use crossbeam::queue::ArrayQueue; + +use crate::engine::SessionAudioId; + +const PACKET_QUEUE_CAPACITY: usize = 100; +const CONTROL_QUEUE_CAPACITY: usize = 32; + +/// A raw inbound voice packet waiting to be inserted into AudioHandler. +pub struct AudioPacket { + /// Client whose TeamSpeak audio packet this belongs to. + pub client_id: SessionAudioId, + /// Raw inbound TeamSpeak audio payload accepted by AudioHandler::handle_packet. + pub data: InAudioBuf, +} + +/// Control commands from the main thread to the audio callback. +pub enum AudioCommand { + /// Set a client's output volume. + SetVolume(SessionAudioId, f32), + /// Remove a client's decode queue. + RemoveClient(SessionAudioId), +} + +/// Lock-free bridge between the inbound forwarder / main thread and the +/// audio callback. The callback owns the consumer halves. +pub struct AudioEventQueue { + /// Bounded lossy queue for raw voice packets. On overflow, the push + /// fails and the packet is dropped (counted via `packets_dropped`). + /// Capacity: 100 packets (~2 seconds at 50pps, far more than needed). + pub packet_queue: ArrayQueue, + /// Bounded reliable queue for control commands (volume, client removal). + /// On overflow, the caller retries. Capacity: 32 commands. + pub control_queue: ArrayQueue, + /// Atomic counter for dropped packets (for diagnostics). + pub packets_dropped: AtomicU64, +} + +impl AudioEventQueue { + /// Create the Android audio event bridge with fixed queue capacities. + pub fn new() -> Arc { + Arc::new(Self { + packet_queue: ArrayQueue::new(PACKET_QUEUE_CAPACITY), + control_queue: ArrayQueue::new(CONTROL_QUEUE_CAPACITY), + packets_dropped: AtomicU64::new(0), + }) + } + + /// Create a producer handle sharing this queue. + pub fn producer(queue: &Arc) -> AudioEventProducer { + AudioEventProducer { + queue: Arc::clone(queue), + } + } + + /// Create a consumer handle sharing this queue. + pub fn consumer(queue: &Arc) -> AudioEventConsumer { + AudioEventConsumer { + queue: Arc::clone(queue), + } + } +} + +/// Producer side used by the inbound forwarder and engine control methods. +#[derive(Clone)] +pub struct AudioEventProducer { + queue: Arc, +} + +impl AudioEventProducer { + /// Push a raw voice packet, incrementing the drop counter if full. + pub fn push_packet(&self, packet: AudioPacket) -> Result<(), AudioPacket> { + self.queue.packet_queue.push(packet).map_err(|packet| { + self.queue.packets_dropped.fetch_add(1, Ordering::Relaxed); + packet + }) + } + + /// Push a control command, returning it unchanged if the queue is full. + pub fn push_control(&self, cmd: AudioCommand) -> Result<(), AudioCommand> { + self.queue.control_queue.push(cmd) + } + + /// Shared queue backing this producer. + pub fn queue(&self) -> Arc { + Arc::clone(&self.queue) + } +} + +/// Consumer side used by the Android output callback. +pub struct AudioEventConsumer { + queue: Arc, +} + +impl AudioEventConsumer { + /// Pop up to `cap` queued packets. + pub fn drain_packets(&self, cap: usize) -> impl Iterator + '_ { + let mut drained = 0; + std::iter::from_fn(move || { + if drained >= cap { + return None; + } + let packet = self.queue.packet_queue.pop(); + if packet.is_some() { + drained += 1; + } + packet + }) + } + + /// Pop all currently queued controls. + pub fn drain_controls(&self) -> impl Iterator + '_ { + std::iter::from_fn(move || self.queue.control_queue.pop()) + } +} diff --git a/crates/chanora_audio/src/engine.rs b/crates/chanora_audio/src/engine.rs index ce32975..8e6b065 100644 --- a/crates/chanora_audio/src/engine.rs +++ b/crates/chanora_audio/src/engine.rs @@ -52,6 +52,8 @@ use tsclientlib::audio::AudioHandler; use chanora_protocol::{InboundVoice, OutPacket}; +#[cfg(target_os = "android")] +use crate::audio_event_queue::{AudioCommand, AudioEventQueue, AudioPacket}; use crate::AudioError; #[cfg(all( @@ -305,12 +307,15 @@ pub struct AudioEngine { output_muted: Arc, audio_processing_config: Arc>, audio_processing_stats: Arc, + #[cfg(not(target_os = "android"))] audio_handler: Arc>>, - #[cfg(any(target_os = "ios", target_os = "macos", target_os = "android"))] + #[cfg(target_os = "android")] + audio_event_producer: crate::audio_event_queue::AudioEventProducer, + #[cfg(target_os = "android")] voice_out_tx: mpsc::Sender, - #[cfg(any(target_os = "ios", target_os = "macos", target_os = "android"))] + #[cfg(target_os = "android")] voice_activity_selector: Option>, - #[cfg(any(target_os = "ios", target_os = "macos", target_os = "android"))] + #[cfg(target_os = "android")] mic_gain: f32, // Streams must be dropped to stop audio. Both are `!Send` because // cpal's Stream isn't Send on some backends; we keep them in an @@ -482,7 +487,7 @@ impl AudioEngine { voice_out_tx: mpsc::Sender, transmit_gate: crate::ptt::AudioTransmitGate, frames_sent: Arc, - audio_handler: Arc>>, + event_producer: crate::audio_event_queue::AudioEventProducer, output_gain: Arc, output_muted: Arc, voice_activity_selector: Option>, @@ -552,7 +557,8 @@ impl AudioEngine { transmit_active: transmit_gate.flag_arc(), frames_sent: frames_sent.clone(), mic_gain, - handler: audio_handler.clone(), + handler: AudioHandler::new(), + event_producer: event_producer.clone(), output_gain: output_gain.clone(), output_muted: output_muted.clone(), voice_activity_selector: voice_activity_selector.clone(), @@ -572,7 +578,7 @@ impl AudioEngine { voice_out_tx.clone(), transmit_gate.clone(), frames_sent.clone(), - audio_handler.clone(), + event_producer.clone(), output_gain.clone(), output_muted.clone(), voice_activity_selector.clone(), @@ -1007,8 +1013,8 @@ impl AudioEngine { let audio_processing_config = Arc::new(Mutex::new(crate::AudioProcessingConfig::default())); let audio_processing_stats = Arc::new(crate::SharedAudioProcessingStats::default()); - let audio_handler: Arc>> = - Arc::new(Mutex::new(AudioHandler::new())); + let event_queue = AudioEventQueue::new(); + let event_producer = AudioEventQueue::producer(&event_queue); if !cfg.mobile_voice_preset { return Err(AudioError::Backend( @@ -1069,7 +1075,8 @@ impl AudioEngine { transmit_active: transmit_flag_for_capture, frames_sent: frames_sent.clone(), mic_gain: cfg.mic_gain, - handler: audio_handler.clone(), + handler: AudioHandler::new(), + event_producer: event_producer.clone(), output_gain: output_gain.clone(), output_muted: output_muted.clone(), voice_activity_selector: cfg.voice_activity_selector.clone(), @@ -1103,7 +1110,7 @@ impl AudioEngine { voice_out_tx.clone(), transmit_gate.clone(), frames_sent.clone(), - audio_handler.clone(), + event_producer.clone(), output_gain.clone(), output_muted.clone(), cfg.voice_activity_selector.clone(), @@ -1151,7 +1158,7 @@ impl AudioEngine { let capture_active = true; let (shutdown_tx, mut shutdown_rx) = tokio::sync::oneshot::channel(); - let handler_for_task = audio_handler.clone(); + let event_producer_for_task = event_producer.clone(); let frames_received_for_task = frames_received.clone(); tokio::spawn(async move { loop { @@ -1164,10 +1171,8 @@ impl AudioEngine { match item { Some(v) => { let id = SessionAudioId(v.from_client); - let mut h = handler_for_task.lock().unwrap(); - if let Err(e) = h.handle_packet(id, v.packet) { - debug!(target: "chanora_audio", error = %e, "decode failed"); - } else { + let packet = AudioPacket { client_id: id, data: v.packet }; + if event_producer_for_task.push_packet(packet).is_ok() { frames_received_for_task.fetch_add(1, Ordering::Relaxed); } } @@ -1186,7 +1191,7 @@ impl AudioEngine { output_muted, audio_processing_config, audio_processing_stats, - audio_handler, + audio_event_producer: event_producer, voice_out_tx, voice_activity_selector: cfg.voice_activity_selector.clone(), mic_gain: cfg.mic_gain, @@ -1308,9 +1313,6 @@ impl AudioEngine { audio_processing_config, audio_processing_stats, audio_handler, - voice_out_tx, - voice_activity_selector: cfg.voice_activity_selector.clone(), - mic_gain: cfg.mic_gain, _ios_voice_backend: Mutex::new(Some(ios_voice_backend)), shutdown_tx: Some(shutdown_tx), capture_active, @@ -1470,7 +1472,8 @@ impl AudioEngine { transmit_active: self.transmit_gate.flag_arc(), frames_sent: self.frames_sent.clone(), mic_gain: self.mic_gain, - handler: self.audio_handler.clone(), + handler: AudioHandler::new(), + event_producer: self.audio_event_producer.clone(), output_gain: self.output_gain.clone(), output_muted: self.output_muted.clone(), voice_activity_selector: self.voice_activity_selector.clone(), @@ -1491,7 +1494,7 @@ impl AudioEngine { self.voice_out_tx.clone(), self.transmit_gate.clone(), self.frames_sent.clone(), - self.audio_handler.clone(), + self.audio_event_producer.clone(), self.output_gain.clone(), self.output_muted.clone(), self.voice_activity_selector.clone(), @@ -1658,20 +1661,36 @@ impl AudioEngine { /// `0.0..4.0`. pub fn set_client_volume(&self, client_id: u64, volume: f32) { let clamped = volume.clamp(0.0, 4.0); - match self.audio_handler.lock() { - Ok(mut h) => { - if let Some(q) = h.get_mut_queues().get_mut(&SessionAudioId(client_id)) { - q.volume = clamped; + #[cfg(target_os = "android")] + { + let mut cmd = AudioCommand::SetVolume(SessionAudioId(client_id), clamped); + loop { + match self.audio_event_producer.push_control(cmd) { + Ok(()) => break, + Err(returned) => { + cmd = returned; + std::thread::yield_now(); + } } } - Err(e) => { - tracing::warn!( - target: "chanora_audio", - client_id, - volume = clamped, - error = %e, - "set_client_volume: audio_handler lock poisoned — volume not applied" - ); + } + #[cfg(not(target_os = "android"))] + { + match self.audio_handler.lock() { + Ok(mut h) => { + if let Some(q) = h.get_mut_queues().get_mut(&SessionAudioId(client_id)) { + q.volume = clamped; + } + } + Err(e) => { + tracing::warn!( + target: "chanora_audio", + client_id, + volume = clamped, + error = %e, + "set_client_volume: audio_handler lock poisoned — volume not applied" + ); + } } } } diff --git a/crates/chanora_audio/src/lib.rs b/crates/chanora_audio/src/lib.rs index f49c4e4..cf58813 100644 --- a/crates/chanora_audio/src/lib.rs +++ b/crates/chanora_audio/src/lib.rs @@ -28,6 +28,8 @@ #![warn(missing_docs)] +#[cfg(target_os = "android")] +mod audio_event_queue; pub mod audio_processing; pub mod debug_wav; mod engine; diff --git a/crates/chanora_audio/src/mobile_voice_backend.rs b/crates/chanora_audio/src/mobile_voice_backend.rs index 8a352cd..9bbad8b 100644 --- a/crates/chanora_audio/src/mobile_voice_backend.rs +++ b/crates/chanora_audio/src/mobile_voice_backend.rs @@ -22,6 +22,9 @@ use std::sync::atomic::{AtomicBool, AtomicU32}; use std::sync::{Arc, Mutex}; use tokio::sync::mpsc; +#[cfg(not(target_os = "android"))] +use tsclientlib::audio::AudioHandler; +#[cfg(target_os = "android")] use tsclientlib::audio::AudioHandler; use crate::engine::SessionAudioId; @@ -67,7 +70,7 @@ pub type BackendEventTx = mpsc::UnboundedSender; pub type AudioSessionId = i32; /// Engine-owned state shared with mobile voice audio callbacks. -#[derive(Clone)] +#[cfg_attr(not(target_os = "android"), derive(Clone))] pub(crate) struct VoiceAudioParams { /// Opus-encoded voice packets sent on this channel toward the /// protocol layer. @@ -78,8 +81,15 @@ pub(crate) struct VoiceAudioParams { pub frames_sent: Arc, /// Pre-encode amplitude scale (1.0 = unity). pub mic_gain: f32, + /// AudioHandler owned by the Android output callback. + #[cfg(target_os = "android")] + pub handler: AudioHandler, + /// Producer used by Android engine tasks to feed the output callback. + #[cfg(target_os = "android")] + pub event_producer: crate::audio_event_queue::AudioEventProducer, /// AudioHandler that inbound decode+mix feeds into; the output /// callback pulls mixed stereo f32 from it. + #[cfg(not(target_os = "android"))] pub handler: Arc>>, /// Master output gain (f32 bits stored in AtomicU32 for lock-free /// cross-thread read from the realtime audio callback).