use std::collections::HashMap;
use std::sync::{Arc, Mutex, OnceLock};
pub use firewheel::nodes::stream::writer::StreamWriterState;
use firewheel::nodes::stream::writer::PushStatus;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PushOutcome {
Ok,
NotReady,
Overflow { frames_pushed: usize },
UnderflowCorrected { zero_frames: usize },
}
#[derive(Debug, Clone, Copy)]
pub struct PcmStreamConfig {
pub sample_rate: u32,
pub channels: u32,
pub latency_seconds: f64,
pub capacity_seconds: f64,
}
impl Default for PcmStreamConfig {
fn default() -> Self {
Self { sample_rate: 48_000, channels: 2, latency_seconds: 0.15, capacity_seconds: 0.4 }
}
}
impl PcmStreamConfig {
pub fn sanitized(mut self) -> Self {
self.sample_rate = self.sample_rate.clamp(4_000, 384_000);
self.channels = self.channels.clamp(1, 16);
self.latency_seconds = self.latency_seconds.clamp(0.005, 30.0);
self.capacity_seconds = self.capacity_seconds.clamp(self.latency_seconds * 2.0, 60.0);
self
}
}
struct Entry {
state: Arc<Mutex<StreamWriterState>>,
cfg: PcmStreamConfig,
}
fn sinks() -> &'static Mutex<HashMap<u64, Entry>> {
static S: OnceLock<Mutex<HashMap<u64, Entry>>> = OnceLock::new();
S.get_or_init(|| Mutex::new(HashMap::new()))
}
pub(crate) fn register(id: u64, state: StreamWriterState, cfg: PcmStreamConfig) {
sinks().lock().unwrap().insert(id, Entry { state: Arc::new(Mutex::new(state)), cfg });
}
pub(crate) fn unregister(id: u64) {
sinks().lock().unwrap().remove(&id);
}
#[derive(Clone)]
pub struct PcmSink {
id: u64,
state: Arc<Mutex<StreamWriterState>>,
cfg: PcmStreamConfig,
}
pub fn sink(stream_id: u64) -> Option<PcmSink> {
let map = sinks().lock().unwrap();
let e = map.get(&stream_id)?;
Some(PcmSink { id: stream_id, state: Arc::clone(&e.state), cfg: e.cfg })
}
pub fn live_streams() -> Vec<u64> {
let mut v: Vec<u64> = sinks().lock().unwrap().keys().copied().collect();
v.sort_unstable();
v
}
impl PcmSink {
pub fn id(&self) -> u64 {
self.id
}
pub fn sample_rate(&self) -> u32 {
self.cfg.sample_rate
}
pub fn channels(&self) -> u32 {
self.cfg.channels
}
pub fn push_interleaved(&self, data: &[f32]) -> PushOutcome {
let ch = self.cfg.channels as usize;
if ch == 0 || data.len() < ch {
return PushOutcome::Ok; }
let usable = data.len() - (data.len() % ch);
let mut st = self.state.lock().unwrap();
match st.push_interleaved(&data[..usable]) {
PushStatus::Ok => PushOutcome::Ok,
PushStatus::OutputNotReady => PushOutcome::NotReady,
PushStatus::OverflowOccurred { num_frames_pushed } => {
PushOutcome::Overflow { frames_pushed: num_frames_pushed }
}
PushStatus::UnderflowCorrected { num_zero_frames_pushed } => {
PushOutcome::UnderflowCorrected { zero_frames: num_zero_frames_pushed }
}
}
}
pub fn available_frames(&self) -> usize {
self.state.lock().unwrap().available_frames()
}
pub fn occupied_seconds(&self) -> Option<f64> {
self.state.lock().unwrap().occupied_seconds()
}
pub fn underflowed(&self) -> bool {
self.state.lock().unwrap().underflow_occurred()
}
pub fn overflowed(&self) -> bool {
self.state.lock().unwrap().overflow_occurred()
}
pub fn is_ready(&self) -> bool {
self.state.lock().unwrap().is_ready()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_config_is_clamped_into_something_buildable() {
let c = PcmStreamConfig {
sample_rate: 0,
channels: 0,
latency_seconds: 0.0,
capacity_seconds: 0.0,
}
.sanitized();
assert!(c.sample_rate >= 4_000);
assert!(c.channels >= 1);
assert!(c.latency_seconds > 0.0);
assert!(c.capacity_seconds >= c.latency_seconds * 2.0);
let c = PcmStreamConfig {
sample_rate: 10_000_000,
channels: 999,
latency_seconds: 1e9,
capacity_seconds: 1.0,
}
.sanitized();
assert!(c.sample_rate <= 384_000);
assert!(c.channels <= 16);
assert!(c.capacity_seconds >= c.latency_seconds * 2.0);
}
#[test]
fn an_unknown_stream_id_has_no_sink() {
assert!(sink(u64::MAX).is_none());
}
}