Capture and playback failures were only written to the log on detached threads, so a microphone or output that could not be opened still showed a connected voice room with no sound. Threads now report into a shared diagnostics sink that the UI polls: errors appear in the status bar, a room with neither working half is marked failed, and signal counters (captured, sent, received, decoded, input peak) are logged every ten seconds. A microphone that delivers only digital silence is reported, and rejected voice datagrams are logged instead of dropped silently. Voice activation now tracks the background noise floor and opens just above it, capped by a much lower default ceiling; the old fixed threshold (about -26 dBFS) rarely opened for normal speech. Stream configuration only accepts f32 formats and says so when a device offers nothing else. Playback gains a mixing queue for short notification effects.
233 lines
7.6 KiB
Rust
233 lines
7.6 KiB
Rust
mod capture;
|
|
mod effects;
|
|
mod media;
|
|
pub use media::MediaMixer;
|
|
mod playback;
|
|
|
|
use std::sync::{
|
|
Arc, Mutex,
|
|
atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering},
|
|
mpsc::{self, Receiver, Sender},
|
|
};
|
|
use tracing::info;
|
|
|
|
use crate::audio::{
|
|
AudioSync, EncodedFrame, IncomingVoice, PipelineConfig, config, devices,
|
|
diagnostics::{AudioIssue, AudioStage, AudioStats, Diagnostics},
|
|
processing::TransmitGate,
|
|
};
|
|
|
|
pub use playback::JitterConfig;
|
|
|
|
pub struct AudioPipeline {
|
|
stopped: Arc<AtomicBool>,
|
|
encoded_rx: Receiver<EncodedFrame>,
|
|
microphone_tap: media::MicrophoneTap,
|
|
media_mixer: MediaMixer,
|
|
effects: effects::EffectQueue,
|
|
diagnostics: Arc<Diagnostics>,
|
|
voice_tx: Sender<IncomingVoice>,
|
|
_encoded_tx: Sender<EncodedFrame>,
|
|
gate: Arc<Mutex<TransmitGate>>,
|
|
output_volume: Arc<Mutex<f32>>,
|
|
jitter_cfg: Arc<Mutex<JitterConfig>>,
|
|
bitrate_bps: Arc<AtomicU32>,
|
|
/// Local user is currently transmitting (PTT held or VAD above threshold and mic enabled).
|
|
local_speaking: Arc<AtomicBool>,
|
|
/// UNIX millisecond timestamp of the last voice packet received from a remote peer.
|
|
last_remote_voice_ms: Arc<AtomicU64>,
|
|
}
|
|
|
|
impl Drop for AudioPipeline {
|
|
fn drop(&mut self) {
|
|
// Releasing a voice session must release its microphone even while muted.
|
|
self.stopped.store(true, Ordering::Release);
|
|
self.microphone_tap.enable(false);
|
|
self.media_mixer.clear();
|
|
self.effects.clear();
|
|
}
|
|
}
|
|
|
|
impl AudioPipeline {
|
|
pub fn enable_media_microphone(&self, enabled: bool) {
|
|
self.microphone_tap.enable(enabled);
|
|
}
|
|
pub fn poll_media_microphone(&self) -> Option<crate::media::AudioFrame> {
|
|
self.microphone_tap.pop()
|
|
}
|
|
pub fn media_mixer(&self) -> MediaMixer {
|
|
self.media_mixer.clone()
|
|
}
|
|
|
|
/// Plays a short notification (mono, 48 kHz, volume already applied) through the open
|
|
/// playback stream without touching the voice path.
|
|
pub fn play_effect(&self, mono_48k: &[f32]) {
|
|
self.effects.push(mono_48k);
|
|
}
|
|
|
|
/// Problems raised by the capture and playback threads since the last call.
|
|
pub fn take_issues(&self) -> Vec<AudioIssue> {
|
|
self.diagnostics.take_issues()
|
|
}
|
|
|
|
/// True when neither the microphone nor the output could be used.
|
|
pub fn is_dead(&self) -> bool {
|
|
self.diagnostics.all_failed()
|
|
}
|
|
|
|
/// Signal counters for support logs.
|
|
pub fn stats(&self) -> AudioStats {
|
|
self.diagnostics.snapshot()
|
|
}
|
|
|
|
pub fn poll_encoded(&self) -> Option<EncodedFrame> {
|
|
self.encoded_rx.try_recv().ok()
|
|
}
|
|
|
|
pub fn push_voice(&self, packet: IncomingVoice) {
|
|
let _ = self.voice_tx.send(packet);
|
|
self.last_remote_voice_ms.store(
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map(|d| d.as_millis() as u64)
|
|
.unwrap_or(0),
|
|
Ordering::Relaxed,
|
|
);
|
|
}
|
|
|
|
/// Returns true if the local user is currently speaking / transmitting.
|
|
pub fn local_speaking(&self) -> bool {
|
|
self.local_speaking.load(Ordering::Relaxed)
|
|
}
|
|
|
|
/// Returns true if we received a voice packet from a remote peer within the
|
|
/// last `within_ms` milliseconds.
|
|
pub fn remote_speaking(&self, within_ms: u64) -> bool {
|
|
let last = self.last_remote_voice_ms.load(Ordering::Relaxed);
|
|
if last == 0 {
|
|
return false;
|
|
}
|
|
let now = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map(|d| d.as_millis() as u64)
|
|
.unwrap_or(0);
|
|
now.saturating_sub(last) <= within_ms
|
|
}
|
|
|
|
pub fn sync_controls(&self, sync: AudioSync) {
|
|
let mut g = self.gate.lock().unwrap();
|
|
g.mic_enabled = sync.mic_enabled;
|
|
g.vad_mode = sync.vad_mode.min(2) as u8;
|
|
g.vad_threshold = sync.vad_threshold;
|
|
g.input_volume = sync.input_volume;
|
|
g.ptt_held = sync.ptt_held;
|
|
g.noise_suppress = sync.noise_suppress;
|
|
*self.output_volume.lock().unwrap() = sync.output_volume;
|
|
*self.jitter_cfg.lock().unwrap() = JitterConfig {
|
|
target_ms: config::jitter_ms_from_setting(sync.jitter_size),
|
|
adaptive: sync.adaptive_buffer,
|
|
};
|
|
self.bitrate_bps.store(
|
|
config::bitrate_bps_from_kbps(sync.voice_bitrate_kbps),
|
|
Ordering::Relaxed,
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn start(cfg: PipelineConfig) -> anyhow::Result<AudioPipeline> {
|
|
let input = devices::open_input(&cfg.mic_device_id)?;
|
|
let output = devices::open_output(&cfg.output_device_id)?;
|
|
info!(
|
|
"audio in: {} out: {}",
|
|
devices::device_name(&input),
|
|
devices::device_name(&output)
|
|
);
|
|
|
|
let in_cfg = config::AudioConfig::find(&input, true)?;
|
|
let out_cfg = config::AudioConfig::find(&output, false)?;
|
|
let frame_ms = config::frame_ms_from_interval(cfg.packet_interval);
|
|
let microphone_tap = media::MicrophoneTap::default();
|
|
let tap_capture = microphone_tap.clone();
|
|
let media_mixer = MediaMixer::new(out_cfg.sample_rate);
|
|
let mixer_playback = media_mixer.clone();
|
|
let effects = effects::EffectQueue::new(out_cfg.sample_rate);
|
|
let effects_playback = effects.clone();
|
|
let diagnostics = Arc::new(Diagnostics::default());
|
|
let diagnostics_capture = diagnostics.clone();
|
|
let diagnostics_playback = diagnostics.clone();
|
|
|
|
let (encoded_tx, encoded_rx) = mpsc::channel::<EncodedFrame>();
|
|
let (voice_tx, voice_rx) = mpsc::channel::<IncomingVoice>();
|
|
let gate = Arc::new(Mutex::new(TransmitGate::default()));
|
|
let gate_cap = gate.clone();
|
|
let output_volume = Arc::new(Mutex::new(90.0f32));
|
|
let vol_play = output_volume.clone();
|
|
let jitter_cfg = Arc::new(Mutex::new(JitterConfig {
|
|
target_ms: 40,
|
|
adaptive: true,
|
|
}));
|
|
let jitter_play = jitter_cfg.clone();
|
|
let bitrate_bps = Arc::new(AtomicU32::new(config::bitrate_bps_from_kbps(
|
|
cfg.voice_bitrate_kbps,
|
|
)));
|
|
let bitrate_cap = bitrate_bps.clone();
|
|
|
|
let local_speaking = Arc::new(AtomicBool::new(false));
|
|
let local_speaking_cap = local_speaking.clone();
|
|
let last_remote_voice_ms = Arc::new(AtomicU64::new(0));
|
|
let last_remote_voice_play = last_remote_voice_ms.clone();
|
|
|
|
let stopped = Arc::new(AtomicBool::new(false));
|
|
let capture_stopped = stopped.clone();
|
|
let channel_id = cfg.channel_key;
|
|
let enc_tx = encoded_tx.clone();
|
|
std::thread::spawn(move || {
|
|
if let Err(e) = capture::run(
|
|
input,
|
|
in_cfg,
|
|
channel_id,
|
|
enc_tx,
|
|
gate_cap,
|
|
frame_ms,
|
|
bitrate_cap,
|
|
local_speaking_cap,
|
|
capture_stopped,
|
|
tap_capture,
|
|
diagnostics_capture.clone(),
|
|
) {
|
|
diagnostics_capture.report(AudioStage::Capture, true, format!("{e:#}"));
|
|
}
|
|
});
|
|
std::thread::spawn(move || {
|
|
if let Err(e) = playback::run(
|
|
output,
|
|
out_cfg,
|
|
voice_rx,
|
|
vol_play,
|
|
jitter_play,
|
|
last_remote_voice_play,
|
|
mixer_playback,
|
|
effects_playback,
|
|
diagnostics_playback.clone(),
|
|
) {
|
|
diagnostics_playback.report(AudioStage::Playback, true, format!("{e:#}"));
|
|
}
|
|
});
|
|
|
|
Ok(AudioPipeline {
|
|
stopped,
|
|
encoded_rx,
|
|
microphone_tap,
|
|
media_mixer,
|
|
effects,
|
|
diagnostics,
|
|
voice_tx,
|
|
_encoded_tx: encoded_tx,
|
|
gate,
|
|
output_volume,
|
|
jitter_cfg,
|
|
bitrate_bps,
|
|
local_speaking,
|
|
last_remote_voice_ms,
|
|
})
|
|
}
|