use core::ffi::c_void;
use std::collections::HashMap;
use std::num::{NonZeroU32, NonZeroUsize};
use std::ops::Range;
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use firewheel::{
collector::ArcGc,
diff::{Diff, PathBuilder},
event::NodeEventType,
node::NodeID,
nodes::{
sampler::{PlayFrom, RepeatMode, SamplerConfig, SamplerNode},
svf::{SvfNode, SvfType},
volume::VolumeNode,
volume_pan::VolumePanNode,
},
sample_resource::{SampleResource, SampleResourceInfo},
Volume,
};
use firewheel::nodes::stream::{
writer::{StreamWriterConfig, StreamWriterNode, StreamWriterState},
ResamplingChannelConfig,
};
use super::hrtf::{HrtfDatabase, PannerRoute, WebPannerConfig, WebPannerNode};
use super::mediadevices;
use super::osc::{OscNode, OscShared, Wave};
use super::pcm::{self, PcmStreamConfig};
use super::util::*;
use crate::glue;
use super::audio_worklet::{NativeKind, NativeMessage, NativeNode, NativeShared};
#[cfg(test)]
mod channel_tests;
mod graph;
mod mixing;
mod native_worklet;
pub mod output;
use mixing::{CountMode, Interp};
pub use mixing::speaker;
pub use output::{
object_model, set_output_backend, ObjectBlock, ObjectPlacement, OutputBackend, OutputOpen, OutputRequest,
OutputStream, Renderer,
};
use output::{RedBackend, RedConfig};
type FirewheelContext = firewheel::FirewheelCtx<RedBackend>;
const P_GAIN: u8 = 0; const P_PAN: u8 = 1; const P_RATE: u8 = 2; const P_FREQ: u8 = 3; const P_Q: u8 = 4; const P_POS_X: u8 = 6; const P_POS_Y: u8 = 7;
const P_POS_Z: u8 = 8;
const P_INERT: u8 = 9; const P_ORIENT_X: u8 = 10; const P_ORIENT_Y: u8 = 11;
const P_ORIENT_Z: u8 = 12;
const P_DETUNE: u8 = 13; const P_NATIVE_ENABLED: u8 = 20;
const P_NATIVE_THRESHOLD: u8 = 21;
const P_L_POS_X: u8 = 100; const P_L_POS_Y: u8 = 101;
const P_L_POS_Z: u8 = 102;
const P_L_FWD_X: u8 = 103; const P_L_FWD_Y: u8 = 104;
const P_L_FWD_Z: u8 = 105;
const P_L_UP_X: u8 = 106;
const P_L_UP_Y: u8 = 107;
const P_L_UP_Z: u8 = 108;
pub struct PlanarBuffer {
pub data: Vec<Vec<f32>>,
pub sample_rate: u32,
}
impl PlanarBuffer {
fn len_frames(&self) -> u64 {
self.data.first().map(|c| c.len() as u64).unwrap_or(0)
}
}
fn secs_to_frames(s: f64, rate: f64) -> u64 {
if s.is_finite() && s > 0.0 {
(s * rate).round() as u64
} else {
0
}
}
#[derive(Default)]
struct SourceCtl {
looping: AtomicBool,
loop_start: AtomicU64,
loop_end: AtomicU64,
done: AtomicBool,
}
impl SourceCtl {
fn loop_start(&self) -> f64 {
f64::from_bits(self.loop_start.load(Ordering::Relaxed))
}
fn loop_end(&self) -> f64 {
f64::from_bits(self.loop_end.load(Ordering::Relaxed))
}
fn region(&self, len: u64, rate: f64) -> Option<(u64, u64)> {
if !self.looping.load(Ordering::Relaxed) || len == 0 {
return None;
}
let (ls, le) = (self.loop_start(), self.loop_end());
if ls >= 0.0 && le > 0.0 && ls < le {
let (a, b) = (secs_to_frames(ls, rate).min(len), secs_to_frames(le, rate).min(len));
if a < b {
return Some((a, b));
}
}
Some((0, len))
}
}
struct SourceSample {
buf: Arc<PlanarBuffer>,
ctl: Arc<SourceCtl>,
start: u64,
len: u64,
next_v: AtomicU64,
pos: AtomicU64,
}
impl SourceSample {
const UNBOUNDED: u64 = u64::MAX / 4;
fn new(buf: Arc<PlanarBuffer>, ctl: Arc<SourceCtl>, start: u64, len: u64) -> Self {
Self { buf, ctl, start, len, next_v: AtomicU64::new(0), pos: AtomicU64::new(start) }
}
fn rate(&self) -> f64 {
self.buf.sample_rate.max(1) as f64
}
fn walk(&self, v: u64) -> u64 {
let blen = self.buf.len_frames();
match self.ctl.region(blen, self.rate()) {
None => self.start.saturating_add(v).min(blen),
Some((a, b)) => {
let p = if self.start >= b { a } else { self.start }.saturating_add(v);
if p < b { p } else { a + (p - b) % (b - a) }
}
}
}
}
impl SampleResourceInfo for SourceSample {
fn num_channels(&self) -> NonZeroUsize {
NonZeroUsize::new(self.buf.data.len().max(1)).unwrap()
}
fn len_frames(&self) -> u64 {
self.len
}
fn sample_rate(&self) -> Option<NonZeroU32> {
NonZeroU32::new(self.buf.sample_rate)
}
}
impl SampleResource for SourceSample {
fn fill_buffers(&self, buffers: &mut [&mut [f32]], buffer_range: Range<usize>, start_frame: u64) {
let frames = buffer_range.len();
let blen = self.buf.len_frames();
let rate = self.rate();
let mut pos = if start_frame == self.next_v.load(Ordering::Relaxed) {
self.pos.load(Ordering::Relaxed)
} else {
self.walk(start_frame)
};
let mut filled = 0usize;
while filled < frames {
let region = self.ctl.region(blen, rate);
let end = match region {
Some((a, b)) => {
if pos >= b {
pos = a;
}
b
}
None => blen,
};
let at = buffer_range.start + filled;
if pos >= end {
for out in buffers.iter_mut() {
out[at..buffer_range.end].fill(0.0);
}
self.ctl.done.store(true, Ordering::Relaxed);
break;
}
let n = ((end - pos) as usize).min(frames - filled);
let p = pos as usize;
for (ch, out) in self.buf.data.iter().zip(buffers.iter_mut()) {
out[at..at + n].copy_from_slice(&ch[p..p + n]);
}
pos += n as u64;
filled += n;
}
let next = start_frame + frames as u64;
if next >= self.len || (pos >= blen && self.ctl.region(blen, rate).is_none()) {
self.ctl.done.store(true, Ordering::Relaxed);
}
self.next_v.store(next, Ordering::Relaxed);
self.pos.store(pos, Ordering::Relaxed);
}
}
#[derive(Clone, Copy)]
enum Tl {
Set { t: f64, v: f64 },
Lin { t: f64, v: f64 },
Exp { t: f64, v: f64 },
Target { t: f64, v: f64, tau: f64 },
}
impl Tl {
fn time(&self) -> f64 {
match *self {
Tl::Set { t, .. } | Tl::Lin { t, .. } | Tl::Exp { t, .. } | Tl::Target { t, .. } => t,
}
}
}
struct Timeline {
evs: Vec<Tl>,
start_v: f64,
start_t: f64,
}
impl Timeline {
fn eval(&self, now: f64) -> (f64, bool) {
let mut cur = self.start_v;
let mut cur_t = self.start_t;
for (i, ev) in self.evs.iter().enumerate() {
match *ev {
Tl::Set { t, v } => {
if t <= now {
cur = v;
cur_t = t;
} else {
return (cur, false);
}
}
Tl::Lin { t, v } => {
if t <= now {
cur = v;
cur_t = t;
} else {
let t0 = cur_t.max(0.0);
let k = if t > t0 { ((now - t0) / (t - t0)).clamp(0.0, 1.0) } else { 1.0 };
return (cur + (v - cur) * k, false);
}
}
Tl::Exp { t, v } => {
if t <= now {
cur = v;
cur_t = t;
} else {
let t0 = cur_t.max(0.0);
let k = if t > t0 { ((now - t0) / (t - t0)).clamp(0.0, 1.0) } else { 1.0 };
let ok = (cur > 0.0 && v > 0.0) || (cur < 0.0 && v < 0.0);
let val = if ok { cur * (v / cur).powf(k) } else { cur + (v - cur) * k };
return (val, false);
}
}
Tl::Target { t, v, tau } => {
if t > now {
return (cur, false);
}
if i + 1 < self.evs.len() && self.evs[i + 1].time() <= now {
cur = v; cur_t = t;
continue;
}
let val = v + (cur - v) * (-(now - t) / tau.max(1e-4)).exp();
return (val, (val - v).abs() < 1e-4);
}
}
}
(cur, true)
}
}
const MONITOR_WINDOW: usize = 4096;
struct MonitorRing {
samples: Box<[AtomicU32]>,
cursor: AtomicUsize,
mix: Box<[AtomicU32]>,
}
impl MonitorRing {
fn new() -> Self {
let ring = Self {
samples: (0..MONITOR_WINDOW).map(|_| AtomicU32::new(0)).collect(),
cursor: AtomicUsize::new(0),
mix: (0..mixing::MAX_CHANNELS).map(|_| AtomicU32::new(0)).collect(),
};
ring.set_mix(&mixing::web_mix(2, 1, Interp::Speakers));
ring
}
fn set_mix(&self, m: &mixing::Matrix) {
for (port, g) in self.mix.iter().enumerate() {
let gain = m.iter().find(|e| e.0 as usize == port).map(|e| e.2).unwrap_or(0.0);
g.store(gain.to_bits(), Ordering::Relaxed);
}
}
fn read_latest(&self, out: &mut [f32]) {
let cur = self.cursor.load(Ordering::Acquire);
let n = out.len().min(MONITOR_WINDOW);
let start = cur.wrapping_sub(n);
for (i, slot) in out.iter_mut().take(n).enumerate() {
let bits = self.samples[start.wrapping_add(i) & (MONITOR_WINDOW - 1)].load(Ordering::Relaxed);
*slot = f32::from_bits(bits);
}
}
}
#[derive(Clone)]
struct MonitorNode {
ring: ArcGc<MonitorRing>,
channels: u32,
}
impl firewheel::node::AudioNode for MonitorNode {
type Configuration = firewheel::node::EmptyConfig;
fn info(&self, _config: &Self::Configuration) -> firewheel::node::AudioNodeInfo {
let n = firewheel::channel_config::ChannelCount::new(self.channels).unwrap();
firewheel::node::AudioNodeInfo::new()
.debug_name("webaudio_analyser")
.channel_config(firewheel::channel_config::ChannelConfig { num_inputs: n, num_outputs: n })
}
fn construct_processor(
&self,
_config: &Self::Configuration,
_cx: firewheel::node::ConstructProcessorContext,
) -> impl firewheel::node::AudioNodeProcessor {
MonitorProcessor { ring: ArcGc::clone(&self.ring) }
}
}
struct MonitorProcessor {
ring: ArcGc<MonitorRing>,
}
impl firewheel::node::AudioNodeProcessor for MonitorProcessor {
fn process(
&mut self,
info: &firewheel::node::ProcInfo,
buffers: firewheel::node::ProcBuffers,
_events: &mut firewheel::event::ProcEvents,
_extra: &mut firewheel::node::ProcExtra,
) -> firewheel::node::ProcessStatus {
let mut gains = [0.0f32; mixing::MAX_CHANNELS as usize];
for (ch, g) in gains.iter_mut().enumerate().take(buffers.inputs.len()) {
if !info.in_silence_mask.is_channel_silent(ch) {
*g = f32::from_bits(self.ring.mix[ch].load(Ordering::Relaxed));
}
}
let mut cur = self.ring.cursor.load(Ordering::Relaxed);
for i in 0..info.frames {
let mut s = 0.0f32;
for (buf, &g) in buffers.inputs.iter().zip(&gains) {
if g != 0.0 {
s += g * buf[i];
}
}
self.ring.samples[cur & (MONITOR_WINDOW - 1)].store(s.to_bits(), Ordering::Relaxed);
cur = cur.wrapping_add(1);
}
self.ring.cursor.store(cur, Ordering::Release);
firewheel::node::ProcessStatus::Bypass
}
}
pub type RenderReference = fn(u64, &[f32], usize, u32);
static RENDER_REFERENCE: OnceLock<RenderReference> = OnceLock::new();
static NEXT_REFERENCE_KEY: AtomicU64 = AtomicU64::new(1);
pub fn set_render_reference(f: RenderReference) {
let _ = RENDER_REFERENCE.set(f);
}
#[derive(Clone)]
struct RefTapNode {
key: u64,
sink: RenderReference,
}
impl firewheel::node::AudioNode for RefTapNode {
type Configuration = firewheel::node::EmptyConfig;
fn info(&self, _config: &Self::Configuration) -> firewheel::node::AudioNodeInfo {
firewheel::node::AudioNodeInfo::new().debug_name("render_reference").channel_config(
firewheel::channel_config::ChannelConfig {
num_inputs: firewheel::channel_config::ChannelCount::STEREO,
num_outputs: firewheel::channel_config::ChannelCount::ZERO,
},
)
}
fn construct_processor(
&self,
_config: &Self::Configuration,
cx: firewheel::node::ConstructProcessorContext,
) -> impl firewheel::node::AudioNodeProcessor {
RefTapProcessor {
key: self.key,
sink: self.sink,
scratch: vec![0.0; cx.stream_info.max_block_frames.get() as usize * 2],
rate: cx.stream_info.sample_rate.get(),
}
}
}
struct RefTapProcessor {
key: u64,
sink: RenderReference,
scratch: Vec<f32>,
rate: u32,
}
impl firewheel::node::AudioNodeProcessor for RefTapProcessor {
fn process(
&mut self,
info: &firewheel::node::ProcInfo,
buffers: firewheel::node::ProcBuffers,
_events: &mut firewheel::event::ProcEvents,
_extra: &mut firewheel::node::ProcExtra,
) -> firewheel::node::ProcessStatus {
let frames = info.frames.min(self.scratch.len() / 2);
for ch in 0..2 {
let silent = info.in_silence_mask.is_channel_silent(ch);
let input = buffers.inputs.get(ch);
for i in 0..frames {
self.scratch[2 * i + ch] = match input {
Some(buf) if !silent => buf[i],
_ => 0.0,
};
}
}
(self.sink)(self.key, &self.scratch[..frames * 2], 2, self.rate);
firewheel::node::ProcessStatus::ClearAllOutputs
}
fn new_stream(&mut self, stream_info: &firewheel::StreamInfo, _context: &mut firewheel::node::ProcStreamCtx) {
self.rate = stream_info.sample_rate.get();
self.scratch.resize(stream_info.max_block_frames.get() as usize * 2, 0.0);
}
}
#[derive(Clone)]
struct TapNode {
source: Arc<super::mediastream::Source>,
}
impl firewheel::node::AudioNode for TapNode {
type Configuration = firewheel::node::EmptyConfig;
fn info(&self, _config: &Self::Configuration) -> firewheel::node::AudioNodeInfo {
firewheel::node::AudioNodeInfo::new()
.debug_name("webaudio_media_stream_destination")
.channel_config(firewheel::channel_config::ChannelConfig {
num_inputs: firewheel::channel_config::ChannelCount::STEREO,
num_outputs: firewheel::channel_config::ChannelCount::ZERO,
})
}
fn construct_processor(
&self,
_config: &Self::Configuration,
cx: firewheel::node::ConstructProcessorContext,
) -> impl firewheel::node::AudioNodeProcessor {
let rate = cx.stream_info.sample_rate.get();
self.source.set_format(2, rate);
TapProcessor {
source: Arc::clone(&self.source),
scratch: vec![0.0; cx.stream_info.max_block_frames.get() as usize * 2],
rate,
}
}
}
struct TapProcessor {
source: Arc<super::mediastream::Source>,
scratch: Vec<f32>,
rate: u32,
}
impl firewheel::node::AudioNodeProcessor for TapProcessor {
fn process(
&mut self,
info: &firewheel::node::ProcInfo,
buffers: firewheel::node::ProcBuffers,
_events: &mut firewheel::event::ProcEvents,
_extra: &mut firewheel::node::ProcExtra,
) -> firewheel::node::ProcessStatus {
let frames = info.frames.min(self.scratch.len() / 2);
for ch in 0..2 {
let silent = info.in_silence_mask.is_channel_silent(ch);
let input = buffers.inputs.get(ch);
for i in 0..frames {
self.scratch[2 * i + ch] = match input {
Some(buf) if !silent => buf[i],
_ => 0.0,
};
}
}
self.source.deliver(&self.scratch[..frames * 2], 2, self.rate);
firewheel::node::ProcessStatus::ClearAllOutputs
}
fn new_stream(&mut self, stream_info: &firewheel::StreamInfo, _context: &mut firewheel::node::ProcStreamCtx) {
self.rate = stream_info.sample_rate.get();
self.scratch.resize(stream_info.max_block_frames.get() as usize * 2, 0.0);
self.source.set_format(2, self.rate);
}
}
const MAX_SPLIT_CHANNELS: u32 = 32;
#[derive(Clone)]
struct SplitterNode {
n: u32,
}
impl firewheel::node::AudioNode for SplitterNode {
type Configuration = firewheel::node::EmptyConfig;
fn info(&self, _config: &Self::Configuration) -> firewheel::node::AudioNodeInfo {
let n = firewheel::channel_config::ChannelCount::new(self.n).unwrap();
firewheel::node::AudioNodeInfo::new()
.debug_name("webaudio_channel_splitter")
.channel_config(firewheel::channel_config::ChannelConfig { num_inputs: n, num_outputs: n })
}
fn construct_processor(
&self,
_config: &Self::Configuration,
_cx: firewheel::node::ConstructProcessorContext,
) -> impl firewheel::node::AudioNodeProcessor {
SplitterProcessor
}
}
struct SplitterProcessor;
impl firewheel::node::AudioNodeProcessor for SplitterProcessor {
fn process(
&mut self,
_info: &firewheel::node::ProcInfo,
_buffers: firewheel::node::ProcBuffers,
_events: &mut firewheel::event::ProcEvents,
_extra: &mut firewheel::node::ProcExtra,
) -> firewheel::node::ProcessStatus {
firewheel::node::ProcessStatus::Bypass
}
}
#[derive(Clone)]
struct MergerNode {
n: u32,
discrete: ArcGc<AtomicBool>,
}
impl firewheel::node::AudioNode for MergerNode {
type Configuration = firewheel::node::EmptyConfig;
fn info(&self, _config: &Self::Configuration) -> firewheel::node::AudioNodeInfo {
firewheel::node::AudioNodeInfo::new()
.debug_name("webaudio_channel_merger")
.channel_config(firewheel::channel_config::ChannelConfig {
num_inputs: firewheel::channel_config::ChannelCount::new(2 * self.n).unwrap(),
num_outputs: firewheel::channel_config::ChannelCount::new(self.n).unwrap(),
})
}
fn construct_processor(
&self,
_config: &Self::Configuration,
_cx: firewheel::node::ConstructProcessorContext,
) -> impl firewheel::node::AudioNodeProcessor {
MergerProcessor { discrete: ArcGc::clone(&self.discrete) }
}
}
struct MergerProcessor {
discrete: ArcGc<AtomicBool>,
}
impl firewheel::node::AudioNodeProcessor for MergerProcessor {
fn process(
&mut self,
info: &firewheel::node::ProcInfo,
buffers: firewheel::node::ProcBuffers,
_events: &mut firewheel::event::ProcEvents,
_extra: &mut firewheel::node::ProcExtra,
) -> firewheel::node::ProcessStatus {
let discrete = self.discrete.load(Ordering::Relaxed);
let mask = merge_block(
buffers.inputs,
buffers.outputs,
info.frames,
|port| info.in_silence_mask.is_channel_silent(port),
discrete,
);
firewheel::node::ProcessStatus::outputs_modified_with_silence_mask(mask)
}
}
fn merge_block(
inputs: &[&[f32]],
outputs: &mut [&mut [f32]],
frames: usize,
silent: impl Fn(usize) -> bool,
discrete: bool,
) -> firewheel::mask::SilenceMask {
let mut mask = firewheel::mask::SilenceMask::NONE_SILENT;
for (j, out) in outputs.iter_mut().enumerate() {
let out = &mut out[..frames];
let (l, r) = (2 * j, 2 * j + 1);
let l_silent = silent(l);
let r_silent = discrete || silent(r);
match (l_silent, r_silent) {
(true, true) => {
out.fill(0.0);
mask.set_channel(j, true);
}
(false, true) if discrete => out.copy_from_slice(&inputs[l][..frames]),
(false, true) => {
for (o, &a) in out.iter_mut().zip(&inputs[l][..frames]) {
*o = 0.5 * a;
}
}
(true, false) => {
for (o, &b) in out.iter_mut().zip(&inputs[r][..frames]) {
*o = 0.5 * b;
}
}
(false, false) => {
for ((o, &a), &b) in out.iter_mut().zip(&inputs[l][..frames]).zip(&inputs[r][..frames]) {
*o = 0.5 * (a + b);
}
}
}
}
mask
}
fn blackman(n: usize, len: usize) -> f32 {
const A0: f32 = 0.42;
const A1: f32 = 0.5;
const A2: f32 = 0.08;
let x = core::f32::consts::TAU * n as f32 / len as f32;
A0 - A1 * x.cos() + A2 * (2.0 * x).cos()
}
fn fft_in_place(re: &mut [f32], im: &mut [f32]) {
let n = re.len();
debug_assert!(n.is_power_of_two() && im.len() == n);
let mut j = 0usize;
for i in 1..n {
let mut bit = n >> 1;
while j & bit != 0 {
j ^= bit;
bit >>= 1;
}
j |= bit;
if i < j {
re.swap(i, j);
im.swap(i, j);
}
}
let mut len = 2;
while len <= n {
let ang = -core::f32::consts::TAU / len as f32;
let (wr, wi) = (ang.cos(), ang.sin());
let half = len / 2;
let mut i = 0;
while i < n {
let (mut cr, mut ci) = (1.0f32, 0.0f32);
for k in 0..half {
let (ur, ui) = (re[i + k], im[i + k]);
let (br, bi) = (re[i + k + half], im[i + k + half]);
let (vr, vi) = (br * cr - bi * ci, br * ci + bi * cr);
re[i + k] = ur + vr;
im[i + k] = ui + vi;
re[i + k + half] = ur - vr;
im[i + k + half] = ui - vi;
let ncr = cr * wr - ci * wi;
ci = cr * wi + ci * wr;
cr = ncr;
}
i += len;
}
len <<= 1;
}
}
enum Params {
Dest,
Gain(VolumeNode),
Pan(VolumePanNode),
Svf(Box<SvfNode<2>>),
Spatial(WebPannerNode),
Sampler(Box<SamplerNode>),
Analyser {
ring: ArcGc<MonitorRing>,
smooth: Vec<f32>,
},
Osc(ArcGc<OscShared>),
Native { kind: NativeKind, shared: ArcGc<NativeShared>, discrete: bool },
PcmStream(PcmStreamConfig),
Splitter(u32),
Merger { n: u32, discrete: ArcGc<AtomicBool> },
Passthrough,
MediaDest(Arc<super::mediastream::Source>),
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
struct Conn {
dst: u64,
output: u32,
input: u32,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum DistModel {
Inverse,
Linear,
Exponential,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Panning {
EqualPower,
Hrtf,
Objects,
}
struct NodeRec {
engine: u64,
id: NodeID,
params: Params,
out_ch: u32,
in_ch: u32,
outs: Vec<Conn>,
wires: HashMap<Conn, graph::Wire>,
ch_count: u32,
ch_mode: CountMode,
ch_interp: Interp,
lin: u32,
lout: u32,
panning: Panning,
object: u32,
send: f32,
pos: [f32; 3],
orient: [f32; 3],
cone: [f32; 3],
dist_model: DistModel,
dist: [f32; 3],
gain: f32,
buffer: Option<Arc<PlanarBuffer>>,
src: Arc<SourceCtl>,
started: bool,
saw_playing: bool,
ended: bool,
js_obj: u64,
worklet_obj: u64,
pending_start: Option<(f64, f64, Option<f64>)>, pending_stop: Option<f64>,
}
impl NodeRec {
fn new(engine: u64, id: NodeID, params: Params) -> Self {
let (in_ch, out_ch) = match ¶ms {
Params::PcmStream(cfg) => (0, cfg.channels),
Params::Osc(_) => (0, 2),
Params::Splitter(n) => (*n, *n),
Params::Merger { n, .. } => (2 * n, *n),
Params::MediaDest(_) => (2, 0),
_ => (2, 2),
};
let (ch_count, ch_mode, ch_interp) = match ¶ms {
Params::Dest | Params::MediaDest(_) => (2, CountMode::Explicit, Interp::Speakers),
Params::Pan(_) | Params::Spatial(_) => (2, CountMode::ClampedMax, Interp::Speakers),
Params::Native { discrete, .. } => {
(2, CountMode::Explicit, if *discrete { Interp::Discrete } else { Interp::Speakers })
}
Params::Splitter(n) => (*n, CountMode::Explicit, Interp::Discrete),
Params::Merger { discrete, .. } => (
1,
CountMode::Explicit,
if discrete.load(Ordering::Relaxed) { Interp::Discrete } else { Interp::Speakers },
),
_ => (2, CountMode::Max, Interp::Speakers),
};
Self {
engine,
id,
params,
out_ch,
in_ch,
outs: Vec::new(),
wires: HashMap::new(),
ch_count,
ch_mode,
ch_interp,
lin: 1,
lout: 2,
panning: Panning::EqualPower,
object: 0,
send: 1.0,
pos: [0.0; 3],
orient: [1.0, 0.0, 0.0],
cone: [360.0, 360.0, 0.0],
dist_model: DistModel::Inverse,
dist: [1.0, 10_000.0, 1.0], gain: 1.0,
buffer: None,
src: Arc::new(SourceCtl::default()),
started: false,
saw_playing: false,
ended: false,
js_obj: 0,
worklet_obj: 0,
pending_start: None,
pending_stop: None,
}
}
fn web_inputs(&self) -> u32 {
match &self.params {
Params::Merger { n, .. } => *n,
Params::Osc(_) | Params::Sampler(_) | Params::PcmStream(_) | Params::Passthrough => 0,
_ => 1,
}
}
fn web_outputs(&self) -> u32 {
match &self.params {
Params::Splitter(n) => *n,
Params::MediaDest(_) => 0,
_ => 1,
}
}
}
const ST_RUNNING: u8 = 0;
const ST_SUSPENDED: u8 = 1;
const ST_CLOSED: u8 = 2;
struct Engine {
g: usize,
fw: FirewheelContext,
running: bool,
state: u8,
master: NodeID,
master_params: VolumeNode,
listener: [f32; 3],
listener_fwd: [f32; 3],
listener_up: [f32; 3],
sample_rate: u32,
sink_id: String,
default_seen: u64,
device_channels: u32,
device_mask: u32,
out_wire: Option<graph::Wire>,
ref_tap: Option<NodeID>,
tap_wire: Option<graph::Wire>,
wants_objects: bool,
objects: Option<graph::Objects>,
refused: Option<String>,
retry_at: Option<std::time::Instant>,
}
impl Engine {
fn now(&self) -> f64 {
self.fw.audio_clock().seconds.0
}
fn running_rate(&self) -> Option<u32> {
(self.sample_rate != 0).then_some(self.sample_rate)
}
}
const SINK_SWITCH_TIMEOUT: std::time::Duration = std::time::Duration::from_millis(1000);
fn restart_stream(eng: &mut Engine, device: Option<firewheel::cpal::cpal::DeviceId>) -> Result<(), String> {
open_output(eng, device, false)
}
fn open_output(eng: &mut Engine, device: Option<firewheel::cpal::cpal::DeviceId>, fallback: bool) -> Result<(), String> {
if eng.fw.is_audio_stream_running() {
eng.fw.stop_stream();
}
let deadline = std::time::Instant::now() + SINK_SWITCH_TIMEOUT;
while !eng.fw.can_start_stream() {
if std::time::Instant::now() >= deadline {
eng.running = false;
return Err("the previous output stream did not finish stopping".into());
}
std::thread::sleep(std::time::Duration::from_millis(1));
}
graph::drop_objects(eng);
if let Some(w) = eng.out_wire.take() {
w.tear(&mut eng.fw);
}
let cfg = RedConfig {
device,
sample_rate: eng.running_rate(),
fallback,
objects: eng.wants_objects,
};
match eng.fw.start_stream(cfg) {
Ok(()) => {
eng.running = true;
eng.retry_at = None;
if let Some(rate) = eng.fw.stream_info().map(|i| i.sample_rate.get()) {
eng.sample_rate = rate;
}
graph::adopt_output(eng);
Ok(())
}
Err(e) => {
eng.running = false;
eng.refused = output::take_start_refusal();
Err(match e {
firewheel::error::StartStreamError::BackendError(e) => e.0,
e => format!("{e:?}"),
})
}
}
}
fn follow_default_output(eng: &mut Engine, generation: u64) -> bool {
if eng.default_seen == generation {
return false;
}
eng.default_seen = generation;
if eng.state == ST_CLOSED || !(eng.sink_id.is_empty() || eng.sink_id == mediadevices::DEFAULT_SINK) {
return false;
}
match restart_stream(eng, None) {
Ok(()) => {
eprintln!("[audio] the system default output moved: the context follows it ({} Hz)", eng.sample_rate);
true
}
Err(e) => {
eprintln!("[audio] the system default output moved, and it could not be opened: {e}");
false
}
}
}
fn retry_output(eng: &mut Engine) -> bool {
let Some(at) = eng.retry_at else { return false };
if eng.state == ST_CLOSED || std::time::Instant::now() < at {
return false;
}
let device = mediadevices::resolve_output(&eng.sink_id).ok().flatten();
match open_output(eng, device, true) {
Ok(()) => true,
Err(e) => {
if audio_log() {
eprintln!("[audio] reopening the output failed: {e}");
}
eng.retry_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(1));
false
}
}
}
fn reopened(gl: &mut Glob, eh: u64) {
if let Some(eng) = gl.engines.get_mut(&eh) {
graph::assign_objects(eng, &mut gl.nodes, eh);
}
graph::resync(&mut gl.engines, &mut gl.nodes, eh);
}
#[derive(Default)]
struct Glob {
engines: HashMap<u64, Engine>,
nodes: HashMap<u64, NodeRec>,
timelines: HashMap<(u64, u8), Timeline>,
next: u64,
}
unsafe impl Send for Glob {}
fn glob() -> &'static Mutex<Glob> {
static G: OnceLock<Mutex<Glob>> = OnceLock::new();
G.get_or_init(|| Mutex::new(Glob::default()))
}
fn audio_log() -> bool {
static ON: OnceLock<bool> = OnceLock::new();
*ON.get_or_init(|| std::env::var("REDJS_AUDIO_LOG").is_ok_and(|v| v == "1"))
}
macro_rules! alog {
($($arg:tt)*) => {
if audio_log() {
eprintln!("[audio] {}", format_args!($($arg)*));
}
};
}
fn dead() -> &'static Mutex<Vec<u64>> {
static D: OnceLock<Mutex<Vec<u64>>> = OnceLock::new();
D.get_or_init(|| Mutex::new(Vec::new()))
}
struct NodeHandle(u64);
impl Drop for NodeHandle {
fn drop(&mut self) {
dead().lock().unwrap().push(self.0);
}
}
struct CtxHandle(u64);
impl Drop for CtxHandle {
fn drop(&mut self) {
dead().lock().unwrap().push(self.0);
}
}
struct ListenerHandle(#[allow(dead_code)] u64);
struct ParamRef {
node: u64,
kind: u8,
last: f64,
}
struct BufData {
buf: Arc<PlanarBuffer>,
}
pub struct AudioClasses {
node_cls: crate::capi::JSClassRef,
ctx_cls: crate::capi::JSClassRef,
param_cls: crate::capi::JSClassRef,
buffer_cls: crate::capi::JSClassRef,
listener_cls: crate::capi::JSClassRef,
s_audio: *mut c_void,
node_base: Class,
ctx: Class,
gain: Class,
stereo: Class,
panner: Class,
biquad: Class,
analyser: Class,
source: Class,
osc: Class,
stream_src: Class,
worklet: Class,
worklet_port: Class,
worklet_port_cls: crate::capi::JSClassRef,
splitter: Class,
merger: Class,
dest: Class,
listener: Class,
param: Class,
buffer: Class,
}
unsafe impl Send for AudioClasses {}
unsafe impl Sync for AudioClasses {}
fn class_registry() -> &'static Mutex<HashMap<usize, &'static AudioClasses>> {
static R: OnceLock<Mutex<HashMap<usize, &'static AudioClasses>>> = OnceLock::new();
R.get_or_init(|| Mutex::new(HashMap::new()))
}
fn classes(g: *mut c_void) -> &'static AudioClasses {
class_registry().lock().unwrap().get(&(g as usize)).copied().expect("webapi::audio not installed")
}
pub(crate) fn forget(gone: crate::context::Gone) {
class_registry().lock().unwrap().remove(&gone.key);
let mut gl = glob().lock().unwrap();
for eng in gl.engines.values_mut().filter(|e| e.g == gone.key) {
if eng.fw.is_audio_stream_running() {
eng.fw.stop_stream();
}
eng.running = false;
eng.state = ST_CLOSED;
eng.g = 0;
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct OutputStatus {
pub channels: u32,
pub objects_requested: bool,
pub objects: Option<ObjectOutput>,
pub refused: Option<String>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct ObjectOutput {
pub label: String,
pub max_objects: u32,
pub in_use: u32,
}
pub unsafe fn output_status(g: *mut c_void, context: u64) -> Option<OutputStatus> {
let h = host_data::<CtxHandle>(g, classes(g).ctx_cls, context)?.0;
let gl = glob().lock().unwrap();
let eng = gl.engines.get(&h)?;
Some(OutputStatus {
channels: eng.device_channels,
objects_requested: eng.wants_objects,
objects: eng.objects.as_ref().map(|o| ObjectOutput {
label: o.label.clone(),
max_objects: o.owners.len() as u32,
in_use: o.owners.iter().filter(|&&x| x != 0).count() as u32,
}),
refused: eng.refused.clone(),
})
}
pub fn busy(g: *mut c_void) -> bool {
let gl = glob().lock().unwrap();
let running: Vec<u64> = gl
.engines
.iter()
.filter(|(_, e)| e.g == g as usize && e.state != ST_CLOSED && e.running)
.map(|(&h, _)| h)
.collect();
if running.is_empty() {
return false;
}
let owned = |node: u64, kind: u8| {
if kind >= P_L_POS_X {
running.contains(&node)
} else {
gl.nodes.get(&node).is_some_and(|r| running.contains(&r.engine))
}
};
gl.timelines.keys().any(|&(node, kind)| owned(node, kind))
|| gl.nodes.values().any(|r| {
running.contains(&r.engine)
&& (r.pending_start.is_some() || r.pending_stop.is_some() || (r.started && !r.ended))
})
}
pub fn close_all(g: *mut c_void) -> usize {
let mut gl = glob().lock().unwrap();
let mut n = 0;
for eng in gl.engines.values_mut().filter(|e| e.g == g as usize && e.state != ST_CLOSED) {
if eng.fw.is_audio_stream_running() {
eng.fw.stop_stream();
}
eng.running = false;
eng.state = ST_CLOSED;
n += 1;
}
n
}
unsafe fn queue_diff<T: Diff>(fw: &mut FirewheelContext, id: NodeID, old: &T, new: &T) {
let mut evs: Vec<NodeEventType> = Vec::new();
new.diff(old, PathBuilder::default(), &mut evs);
for e in evs {
fw.queue_event_for(id, e);
}
}
fn v_dot(a: [f32; 3], b: [f32; 3]) -> f32 {
a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
}
fn v_cross(a: [f32; 3], b: [f32; 3]) -> [f32; 3] {
[
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
]
}
fn v_norm(v: [f32; 3], fallback: [f32; 3]) -> [f32; 3] {
let len = v_dot(v, v).sqrt();
if len < 1e-6 {
fallback
} else {
[v[0] / len, v[1] / len, v[2] / len]
}
}
fn cone_gain(src_to_listener: [f32; 3], orient: [f32; 3], cone: [f32; 3]) -> f32 {
let (inner, outer, outer_gain) = (cone[0], cone[1], cone[2].clamp(0.0, 1.0));
if inner >= 360.0 && outer >= 360.0 {
return 1.0;
}
let dist = v_dot(src_to_listener, src_to_listener).sqrt();
let olen = v_dot(orient, orient).sqrt();
if dist < 1e-6 || olen < 1e-6 {
return 1.0; }
let cos = (v_dot(src_to_listener, orient) / (dist * olen)).clamp(-1.0, 1.0);
let angle = cos.acos().to_degrees();
let half_inner = inner.min(360.0) / 2.0;
let half_outer = outer.min(360.0) / 2.0;
if angle <= half_inner {
1.0
} else if angle >= half_outer {
outer_gain
} else {
let t = (angle - half_inner) / (half_outer - half_inner).max(1e-6);
1.0 + (outer_gain - 1.0) * t
}
}
fn distance_gain(model: DistModel, dist: f32, ref_d: f32, max_d: f32, rolloff: f32) -> f32 {
let ref_d = ref_d.max(1e-4);
match model {
DistModel::Inverse => {
let d = dist.max(ref_d);
ref_d / (ref_d + rolloff.max(0.0) * (d - ref_d))
}
DistModel::Linear => {
if max_d <= ref_d {
1.0
} else {
let d = dist.clamp(ref_d, max_d);
(1.0 - rolloff.clamp(0.0, 1.0) * (d - ref_d) / (max_d - ref_d)).clamp(0.0, 1.0)
}
}
DistModel::Exponential => {
let d = dist.max(ref_d);
(d / ref_d).powf(-rolloff.max(0.0))
}
}
}
fn update_spatial_with(eng: &mut Engine, rec: &mut NodeRec, mutate: impl FnOnce(&mut WebPannerNode)) {
let (pos, orient, cone) = (rec.pos, rec.orient, rec.cone);
let (dist_model, dist_params) = (rec.dist_model, rec.dist);
if let Params::Spatial(p) = &mut rec.params {
let old = *p;
mutate(p);
let d = [
pos[0] - eng.listener[0],
pos[1] - eng.listener[1],
pos[2] - eng.listener[2],
];
let fwd = v_norm(eng.listener_fwd, [0.0, 0.0, -1.0]);
let up = v_norm(eng.listener_up, [0.0, 1.0, 0.0]);
let right = v_norm(v_cross(fwd, up), [1.0, 0.0, 0.0]);
let (lx, ly, lz) = (v_dot(d, right), v_dot(d, up), v_dot(d, fwd));
let dist = v_dot(d, d).sqrt();
p.azimuth = lx.atan2(lz).to_degrees();
p.elevation = if dist > 1e-6 {
(ly / dist).clamp(-1.0, 1.0).asin().to_degrees()
} else {
0.0
};
let to_listener = [-d[0], -d[1], -d[2]];
p.gain = distance_gain(dist_model, dist, dist_params[0], dist_params[1], dist_params[2])
* cone_gain(to_listener, orient, cone);
p.hrtf = rec.panning == Panning::Hrtf || (rec.panning == Panning::Objects && rec.object == 0);
unsafe { queue_diff(&mut eng.fw, rec.id, &old, p) };
if rec.object != 0 {
let bus = eng.objects.as_ref().and_then(|o| o.bus.as_ref()).and_then(|b| b.get());
if let Some(bus) = bus {
bus.place(
rec.object as usize - 1,
output::ObjectPlacement {
position: pos,
orientation: orient,
listener_position: eng.listener,
listener_forward: eng.listener_fwd,
listener_up: eng.listener_up,
gain: p.gain * rec.send,
},
);
}
}
}
}
fn update_spatial(eng: &mut Engine, rec: &mut NodeRec) {
update_spatial_with(eng, rec, |_| {});
}
fn gain_volume(v: f32) -> Volume {
if v < 0.0 {
static ONCE: OnceLock<()> = OnceLock::new();
ONCE.get_or_init(|| {
eprintln!(
"[audio] advisory: a GainNode was given a negative gain. It plays at the gain's \
magnitude here, without the phase inversion a browser applies."
);
});
}
Volume::Linear(v.abs().sqrt())
}
fn set_param(engines: &mut HashMap<u64, Engine>, nodes: &mut HashMap<u64, NodeRec>, handle: u64, kind: u8, v: f64) {
if kind >= P_L_POS_X {
let Some(eng) = engines.get_mut(&handle) else { return };
let i = (kind - P_L_POS_X) as usize;
match i {
0..=2 => eng.listener[i] = v as f32,
3..=5 => eng.listener_fwd[i - 3] = v as f32,
6..=8 => eng.listener_up[i - 6] = v as f32,
_ => return,
}
for rec in nodes.values_mut().filter(|r| r.engine == handle) {
update_spatial(eng, rec);
}
return;
}
let Some(rec) = nodes.get_mut(&handle) else { return };
let eh = rec.engine;
let Some(eng) = engines.get_mut(&eh) else { return };
let mut resend = false;
unsafe {
match (&mut rec.params, kind) {
(Params::Gain(p), P_GAIN) => {
let old = *p;
rec.gain = v as f32;
p.volume = gain_volume(rec.gain);
queue_diff(&mut eng.fw, rec.id, &old, p);
resend = eng.objects.is_some();
}
(Params::Pan(p), P_PAN) => {
let old = *p;
p.pan = (v as f32).clamp(-1.0, 1.0);
queue_diff(&mut eng.fw, rec.id, &old, p);
}
(Params::Svf(p), P_FREQ) => {
let old = (**p).clone();
p.cutoff_hz = (v as f32).clamp(20.0, 20_480.0);
queue_diff(&mut eng.fw, rec.id, &old, &**p);
}
(Params::Svf(p), P_Q) => {
let old = (**p).clone();
p.q_factor = (v as f32).max(1e-3);
queue_diff(&mut eng.fw, rec.id, &old, &**p);
}
(Params::Svf(p), P_GAIN) => {
let old = (**p).clone();
p.gain = Volume::Decibels(v as f32);
queue_diff(&mut eng.fw, rec.id, &old, &**p);
}
(Params::Sampler(s), P_RATE) => {
let baseline = (**s).clone();
s.speed = v.max(0.0);
queue_diff(&mut eng.fw, rec.id, &baseline, &**s);
}
(Params::Native { shared, .. }, P_NATIVE_ENABLED) => shared.set_enabled(v.clamp(0.0, 1.0) as f32),
(Params::Native { shared, .. }, P_NATIVE_THRESHOLD) => shared.set_threshold(v.clamp(-100.0, 0.0) as f32),
(Params::Osc(sh), P_FREQ) => sh.set_frequency(v as f32),
(Params::Osc(sh), P_DETUNE) => sh.set_detune(v as f32),
(Params::Spatial(_), P_POS_X..=P_POS_Z) => {
rec.pos[(kind - P_POS_X) as usize] = v as f32;
update_spatial(eng, rec);
}
(Params::Spatial(_), P_ORIENT_X..=P_ORIENT_Z) => {
rec.orient[(kind - P_ORIENT_X) as usize] = v as f32;
update_spatial(eng, rec);
}
_ => {}
}
}
if resend {
graph::object_sends(eng, nodes, eh);
}
}
fn do_start(eng: &mut Engine, rec: &mut NodeRec, offset: f64, duration: Option<f64>) {
if let Params::Osc(sh) = &rec.params {
alog!("osc start node={:?} freq={}", rec.id, sh.frequency());
sh.start();
return;
}
let Params::Sampler(s) = &mut rec.params else { return };
alog!(
"do_start node={:?} buffer_frames={:?} loop={} speed={} offset={offset} duration={duration:?}",
rec.id,
rec.buffer.as_ref().map(|b| b.len_frames()),
rec.src.looping.load(Ordering::Relaxed),
s.speed
);
let baseline = (**s).clone();
arm_source(s, rec.buffer.as_ref(), &rec.src, offset, duration);
unsafe { queue_diff(&mut eng.fw, rec.id, &baseline, &**s) };
}
fn arm_source(
s: &mut SamplerNode,
buffer: Option<&Arc<PlanarBuffer>>,
ctl: &Arc<SourceCtl>,
offset: f64,
duration: Option<f64>,
) {
if let Some(buf) = buffer {
let rate = buf.sample_rate.max(1) as f64;
let start = secs_to_frames(offset, rate).min(buf.len_frames());
let len = duration.map(|d| secs_to_frames(d, rate)).unwrap_or(SourceSample::UNBOUNDED);
let looping = ctl.region(buf.len_frames(), rate).is_some();
if len == 0 || (!looping && start >= buf.len_frames()) {
ctl.done.store(true, Ordering::Relaxed);
}
let view = SourceSample::new(buf.clone(), ctl.clone(), start, len);
s.set_sample(ArcGc::new_unsized(|| Arc::new(view) as Arc<dyn SampleResource>));
}
s.repeat_mode = RepeatMode::PlayOnce;
s.start_from(PlayFrom::BEGINNING);
}
fn do_stop(eng: &mut Engine, rec: &mut NodeRec) {
if let Params::Osc(sh) = &rec.params {
sh.stop();
return;
}
let Params::Sampler(s) = &mut rec.params else { return };
let baseline = (**s).clone();
s.stop();
unsafe { queue_diff(&mut eng.fw, rec.id, &baseline, &**s) };
}
unsafe fn this_node_handle(g: *mut c_void, cf: *mut c_void) -> Option<u64> {
host_data::<NodeHandle>(g, classes(g).node_cls, cf_this(cf)).map(|h| h.0)
}
unsafe fn this_engine_handle(g: *mut c_void, cf: *mut c_void) -> Option<u64> {
host_data::<CtxHandle>(g, classes(g).ctx_cls, cf_this(cf)).map(|h| h.0)
}
unsafe fn node_class_for(g: *mut c_void, proto: u64) -> crate::capi::JSClassRef {
let base = classes(g).node_cls;
if !is_cell(proto) {
return base;
}
let a = glue::rjs_atom_wellknown(g, 1); if a.is_null() {
return base;
}
let tag = read_string(g, get_a(g, proto, a));
glue::rjs_atom_free(g, a);
let Some(name) = tag.filter(|t| !t.is_empty() && t != "AudioNode") else {
return base;
};
static SUBCLASSES: OnceLock<Mutex<HashMap<(usize, String), usize>>> = OnceLock::new();
let mut map = SUBCLASSES.get_or_init(|| Mutex::new(HashMap::new())).lock().unwrap();
let key = (base as usize, name);
if let Some(&cls) = map.get(&key) {
return cls as crate::capi::JSClassRef;
}
let Ok(cname) = std::ffi::CString::new(key.1.as_str()) else {
return base;
};
let mut def = crate::capi::JSClassDefinition::empty();
def.class_name = cname.as_ptr();
def.parent_class = base;
let cls = crate::capi::JSClassCreate(&def);
map.insert(key, cls as usize);
cls
}
unsafe fn wrap_node(g: *mut c_void, proto: u64, handle: u64, params: &[(&str, u8, f64)]) -> u64 {
let c = classes(g);
let obj = host_create(g, node_class_for(g, proto), proto, NodeHandle(handle));
let slots = new_object(g, UNDEF);
glue::rjs_define(g, obj, c.s_audio, slots, 0);
for &(name, kind, initial) in params {
let p = host_create(g, c.param_cls, c.param.proto, ParamRef { node: handle, kind, last: initial });
define(g, slots, name, p, 0);
}
obj
}
unsafe fn slots_of(g: *mut c_void, obj: u64) -> u64 {
get_a(g, obj, classes(g).s_audio)
}
const OUTS_SLOT: &str = "~outs";
unsafe fn hold_downstream(g: *mut c_void, src_obj: u64, dst_obj: u64) {
let slots = slots_of(g, src_obj);
if !is_cell(slots) {
return;
}
let mut held = get(g, slots, OUTS_SLOT);
if !is_cell(held) {
held = new_array(g);
define(g, slots, OUTS_SLOT, held, 0);
}
let n = array_len(g, held);
let mut free = None;
for i in 0..n {
let v = get_i(g, held, i);
if v == dst_obj {
return;
}
if free.is_none() && v == UNDEF {
free = Some(i);
}
}
set_i(g, held, free.unwrap_or(n), dst_obj);
}
unsafe fn release_downstream(g: *mut c_void, src_obj: u64, src: u64) {
let slots = slots_of(g, src_obj);
if !is_cell(slots) {
return;
}
let held = get(g, slots, OUTS_SLOT);
if !is_cell(held) {
return;
}
let still: Vec<u64> = {
let gl = glob().lock().unwrap();
gl.nodes.get(&src).map(|r| r.outs.iter().map(|k| k.dst).collect()).unwrap_or_default()
};
let cls = classes(g).node_cls;
for i in 0..array_len(g, held) {
let v = get_i(g, held, i);
if v == UNDEF {
continue;
}
let kept = host_data::<NodeHandle>(g, cls, v).is_some_and(|h| still.contains(&h.0));
if !kept {
set_i(g, held, i, UNDEF);
}
}
}
fn open_pcm_channel(eng: &mut Engine, id: NodeID, handle: u64, cfg: PcmStreamConfig) -> bool {
let (Some(in_rate), Some(out_rate)) =
(NonZeroU32::new(cfg.sample_rate), NonZeroU32::new(eng.sample_rate))
else {
return false;
};
let chan = ResamplingChannelConfig {
latency_seconds: cfg.latency_seconds,
capacity_seconds: cfg.capacity_seconds,
..Default::default()
};
let (ev, producer) = {
let Some(st) = eng.fw.node_state_mut::<StreamWriterState>(id) else { return false };
let Ok(ev) = st.start_stream(in_rate, out_rate, chan) else { return false };
(ev, st.clone())
};
eng.fw.queue_event_for(id, NodeEventType::custom(ev));
pcm::register(handle, producer, cfg);
true
}
fn alloc_node(gl: &mut Glob, engine: u64, params: Params) -> Option<u64> {
let eng = gl.engines.get_mut(&engine)?;
if eng.state == ST_CLOSED {
return None;
}
let handle = gl.next;
gl.next += 1;
let id = match ¶ms {
Params::Gain(p) => eng.fw.add_node(*p, None),
Params::Pan(p) => eng.fw.add_node(*p, None),
Params::Spatial(p) => eng.fw.add_node(
*p,
Some(WebPannerConfig { db: HrtfDatabase::for_rate(eng.sample_rate) }),
),
Params::Svf(p) => eng.fw.add_node((**p).clone(), None),
Params::Sampler(s) => eng.fw.add_node((**s).clone(), Some(SamplerConfig::default())),
Params::Analyser { ring, .. } => eng.fw.add_node(MonitorNode { ring: ArcGc::clone(ring), channels: 2 }, None),
Params::Osc(sh) => eng.fw.add_node(OscNode { shared: ArcGc::clone(sh) }, None),
Params::Native { kind, shared, .. } => eng.fw.add_node(NativeNode { kind: *kind, shared: ArcGc::clone(shared) }, None),
Params::PcmStream(cfg) => {
let ch = firewheel::channel_config::NonZeroChannelCount::new(cfg.channels as u32)
.unwrap_or(firewheel::channel_config::NonZeroChannelCount::STEREO);
eng.fw.add_node(
StreamWriterNode,
Some(StreamWriterConfig { channels: ch, check_for_silence: true }),
)
}
Params::Splitter(n) => eng.fw.add_node(SplitterNode { n: *n }, None),
Params::Merger { n, discrete } => {
eng.fw.add_node(MergerNode { n: *n, discrete: ArcGc::clone(discrete) }, None)
}
Params::Passthrough => eng.fw.add_node(VolumeNode::default(), None),
Params::MediaDest(source) => eng.fw.add_node(TapNode { source: Arc::clone(source) }, None),
Params::Dest => eng.master,
};
if let Params::PcmStream(cfg) = ¶ms {
if !open_pcm_channel(eng, id, handle, *cfg) {
alog!("RedStreamSourceNode {handle}: no producer channel (running={})", eng.running);
}
}
gl.nodes.insert(handle, NodeRec::new(engine, id, params));
Some(handle)
}
unsafe fn idl_u32(g: *mut c_void, v: u64, default: u32) -> Result<u32, ()> {
if v == UNDEF {
return Ok(default);
}
let d = to_number(g, v)?;
if !d.is_finite() {
return Ok(0);
}
Ok(d.trunc().rem_euclid(4_294_967_296.0) as u32)
}
enum Refusal {
Type(String),
Dom(&'static str, String),
}
unsafe fn throw_refusal(g: *mut c_void, r: Refusal) -> u64 {
match r {
Refusal::Type(m) => throw_type_error(g, &m),
Refusal::Dom(name, m) => super::domexception::throw(g, name, &m),
}
}
#[crate::host_fn]
unsafe fn node_connect(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let Some(src) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioNode.connect called on wrong this");
};
let dst_v = cf_arg(cf, 0);
let Some(dst) = host_data::<NodeHandle>(g, c.node_cls, dst_v).map(|h| h.0) else {
return throw_type_error(g, "AudioNode.connect: destination is not an AudioNode");
};
let Ok(output) = idl_u32(g, cf_arg(cf, 1), 0) else { return UNDEF };
let Ok(input) = idl_u32(g, cf_arg(cf, 2), 0) else { return UNDEF };
let step: Result<(), Refusal> = 'step: {
let mut guard = glob().lock().unwrap();
let gl = &mut *guard;
let (Some(sr), Some(dr)) = (gl.nodes.get(&src), gl.nodes.get(&dst)) else {
break 'step Err(Refusal::Type("AudioNode.connect: node is gone".into()));
};
let refusal = if sr.engine != dr.engine {
Some(Refusal::Dom(
"InvalidAccessError",
"Failed to execute 'connect' on 'AudioNode': cannot connect to an AudioNode belonging \
to a different audio context."
.into(),
))
} else if output >= sr.web_outputs() {
Some(Refusal::Dom(
"IndexSizeError",
format!(
"Failed to execute 'connect' on 'AudioNode': output index ({output}) exceeds \
number of outputs ({}).",
sr.web_outputs()
),
))
} else if input >= dr.web_inputs() {
Some(Refusal::Dom(
"IndexSizeError",
format!(
"Failed to execute 'connect' on 'AudioNode': input index ({input}) exceeds \
number of inputs ({}).",
dr.web_inputs()
),
))
} else {
None
};
if let Some(r) = refusal {
break 'step Err(r);
}
let conn = Conn { dst, output, input };
if sr.outs.contains(&conn) {
break 'step Ok(());
}
let engine = sr.engine;
gl.nodes.get_mut(&src).unwrap().outs.push(conn);
graph::resync(&mut gl.engines, &mut gl.nodes, engine);
Ok(())
};
match step {
Err(r) => throw_refusal(g, r),
Ok(()) => {
hold_downstream(g, cf_this(cf), dst_v);
dst_v
}
}
}
#[crate::host_fn]
unsafe fn node_disconnect(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let Some(src) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioNode.disconnect called on wrong this");
};
let argc = cf_argc(cf);
let a0 = cf_arg(cf, 0);
let dest = host_data::<NodeHandle>(g, c.node_cls, a0).map(|h| h.0);
let is_param = dest.is_none() && host_data::<ParamRef>(g, c.param_cls, a0).is_some();
enum Sel {
All,
Output(u32),
To { dst: u64, output: Option<u32>, input: Option<u32> },
Param,
}
let sel = if argc == 0 {
Sel::All
} else if let Some(dst) = dest {
let output = if argc >= 2 {
let Ok(o) = idl_u32(g, cf_arg(cf, 1), 0) else { return UNDEF };
Some(o)
} else {
None
};
let input = if argc >= 3 {
let Ok(i) = idl_u32(g, cf_arg(cf, 2), 0) else { return UNDEF };
Some(i)
} else {
None
};
Sel::To { dst, output, input }
} else if is_param {
Sel::Param
} else if argc >= 2 {
return throw_type_error(
g,
"Failed to execute 'disconnect' on 'AudioNode': parameter 1 is not of type 'AudioNode'.",
);
} else {
let Ok(o) = idl_u32(g, a0, 0) else { return UNDEF };
Sel::Output(o)
};
let refusal = {
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let Some(sr) = gl.nodes.get(&src) else { return UNDEF };
let outputs = sr.web_outputs();
let past_outputs = |o: u32| {
Refusal::Dom(
"IndexSizeError",
format!(
"Failed to execute 'disconnect' on 'AudioNode': output index ({o}) exceeds \
number of outputs ({outputs})."
),
)
};
let picked: Result<Vec<Conn>, Refusal> = match sel {
Sel::All => Ok(sr.outs.clone()),
Sel::Output(o) if o >= outputs => Err(past_outputs(o)),
Sel::Output(o) => Ok(sr.outs.iter().copied().filter(|k| k.output == o).collect()),
Sel::To { output: Some(o), .. } if o >= outputs => Err(past_outputs(o)),
Sel::To { dst, output, input } => {
let inputs = gl.nodes.get(&dst).map(|d| d.web_inputs()).unwrap_or(0);
match input {
Some(i) if i >= inputs => Err(Refusal::Dom(
"IndexSizeError",
format!(
"Failed to execute 'disconnect' on 'AudioNode': input index ({i}) \
exceeds number of inputs ({inputs})."
),
)),
_ => {
let hit: Vec<Conn> = sr
.outs
.iter()
.copied()
.filter(|k| {
k.dst == dst
&& output.is_none_or(|o| k.output == o)
&& input.is_none_or(|i| k.input == i)
})
.collect();
if hit.is_empty() {
let what = match (output, input) {
(None, _) => "the given destination is not connected.".to_string(),
(Some(o), None) => format!("output ({o}) is not connected to the given destination."),
(Some(o), Some(i)) => {
format!("output ({o}) is not connected to input ({i}) of the destination.")
}
};
Err(Refusal::Dom(
"InvalidAccessError",
format!("Failed to execute 'disconnect' on 'AudioNode': {what}"),
))
} else {
Ok(hit)
}
}
}
}
Sel::Param => Err(Refusal::Dom(
"InvalidAccessError",
"Failed to execute 'disconnect' on 'AudioNode': the given AudioParam is not connected."
.into(),
)),
};
match picked {
Err(r) => Some(r),
Ok(gone) => {
let engine = sr.engine;
if let (Some(sr), Some(eng)) = (gl.nodes.get_mut(&src), gl.engines.get_mut(&engine)) {
sr.outs.retain(|k| !gone.contains(k));
for k in &gone {
if let Some(w) = sr.wires.remove(k) {
w.tear(&mut eng.fw);
}
}
}
graph::resync(&mut gl.engines, &mut gl.nodes, engine);
None
}
}
};
match refusal {
Some(r) => throw_refusal(g, r),
None => {
release_downstream(g, cf_this(cf), src);
UNDEF
}
}
}
#[crate::host_fn]
unsafe fn node_get_number_of_inputs(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioNode.numberOfInputs on wrong this");
};
let gl = glob().lock().unwrap();
enc_i32(gl.nodes.get(&h).map(|r| r.web_inputs()).unwrap_or(0) as i32)
}
#[crate::host_fn]
unsafe fn node_get_number_of_outputs(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioNode.numberOfOutputs on wrong this");
};
let gl = glob().lock().unwrap();
enc_i32(gl.nodes.get(&h).map(|r| r.web_outputs()).unwrap_or(0) as i32)
}
unsafe fn this_param<'a>(g: *mut c_void, cf: *mut c_void) -> Option<&'a mut ParamRef> {
host_data::<ParamRef>(g, classes(g).param_cls, cf_this(cf))
}
fn param_current(gl: &Glob, node: u64, kind: u8, fallback: f64) -> f64 {
if kind >= P_L_POS_X {
if let Some(eng) = gl.engines.get(&node) {
let i = (kind - P_L_POS_X) as usize;
match i {
0..=2 => return eng.listener[i] as f64,
3..=5 => return eng.listener_fwd[i - 3] as f64,
6..=8 => return eng.listener_up[i - 6] as f64,
_ => {}
}
}
return fallback;
}
let Some(rec) = gl.nodes.get(&node) else { return fallback };
match (&rec.params, kind) {
(Params::Gain(_), P_GAIN) => rec.gain as f64,
(Params::Pan(p), P_PAN) => p.pan as f64,
(Params::Svf(p), P_FREQ) => p.cutoff_hz as f64,
(Params::Svf(p), P_Q) => p.q_factor as f64,
(Params::Sampler(s), P_RATE) => s.speed,
(Params::Native { shared, .. }, P_NATIVE_ENABLED) => shared.enabled() as f64,
(Params::Native { shared, .. }, P_NATIVE_THRESHOLD) => shared.threshold() as f64,
(Params::Osc(sh), P_FREQ) => sh.frequency() as f64,
(Params::Osc(sh), P_DETUNE) => sh.detune() as f64,
(Params::Spatial(_), P_POS_X..=P_POS_Z) => rec.pos[(kind - P_POS_X) as usize] as f64,
(Params::Spatial(_), P_ORIENT_X..=P_ORIENT_Z) => rec.orient[(kind - P_ORIENT_X) as usize] as f64,
_ => fallback,
}
}
#[crate::host_fn]
unsafe fn param_get_value(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_param(g, cf) {
Some(p) => {
let gl = glob().lock().unwrap();
enc_f64(param_current(&gl, p.node, p.kind, p.last))
}
None => throw_type_error(g, "AudioParam.value on wrong this"),
}
}
#[crate::host_fn]
unsafe fn param_set_value(g: *mut c_void, cf: *mut c_void) -> u64 {
let native = this_param(g, cf).is_some_and(|p| matches!(p.kind, P_NATIVE_ENABLED | P_NATIVE_THRESHOLD));
let v = if native {
let Ok(v) = to_number(g, cf_arg(cf, 0)) else { return UNDEF; };
if !v.is_finite() { return throw_type_error(g, "Native audio parameters must be finite"); }
v
} else { dec_f64(cf_arg(cf, 0)).unwrap_or(0.0) };
let Some(p) = this_param(g, cf) else {
return throw_type_error(g, "AudioParam.value on wrong this");
};
p.last = v;
let (node, kind) = (p.node, p.kind);
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
gl.timelines.remove(&(node, kind));
set_param(&mut gl.engines, &mut gl.nodes, node, kind, v);
UNDEF
}
unsafe fn param_schedule(g: *mut c_void, cf: *mut c_void, mk: impl FnOnce(f64, f64) -> Tl) -> u64 {
let native = this_param(g, cf).is_some_and(|p| matches!(p.kind, P_NATIVE_ENABLED | P_NATIVE_THRESHOLD));
let (v, t) = if native {
let Ok(v) = to_number(g, cf_arg(cf, 0)) else { return UNDEF; };
let Ok(t) = to_number(g, cf_arg(cf, 1)) else { return UNDEF; };
if !v.is_finite() || !t.is_finite() { return throw_type_error(g, "Native audio automation values/times must be finite"); }
(v, t)
} else { (dec_f64(cf_arg(cf, 0)).unwrap_or(0.0), dec_f64(cf_arg(cf, 1)).unwrap_or(0.0)) };
let this = cf_this(cf);
let Some(p) = this_param(g, cf) else {
return throw_type_error(g, "AudioParam method on wrong this");
};
p.last = v;
let (node, kind) = (p.node, p.kind);
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let engine = if kind >= P_L_POS_X { Some(node) } else { gl.nodes.get(&node).map(|r| r.engine) };
let now = engine.and_then(|e| gl.engines.get(&e)).map(|e| e.now()).unwrap_or(0.0);
let cur = param_current(gl, node, kind, v);
let tl = gl.timelines.entry((node, kind)).or_insert_with(|| Timeline { evs: Vec::new(), start_v: cur, start_t: now });
let ev = mk(v, t);
let at = tl.evs.partition_point(|e| e.time() <= ev.time());
tl.evs.insert(at, ev);
let (value, _) = tl.eval(now);
set_param(&mut gl.engines, &mut gl.nodes, node, kind, value);
this
}
#[crate::host_fn]
unsafe fn param_set_value_at(g: *mut c_void, cf: *mut c_void) -> u64 {
param_schedule(g, cf, |v, t| Tl::Set { t, v })
}
#[crate::host_fn]
unsafe fn param_linear_ramp(g: *mut c_void, cf: *mut c_void) -> u64 {
param_schedule(g, cf, |v, t| Tl::Lin { t, v })
}
#[crate::host_fn]
unsafe fn param_exp_ramp(g: *mut c_void, cf: *mut c_void) -> u64 {
param_schedule(g, cf, |v, t| Tl::Exp { t, v })
}
#[crate::host_fn]
unsafe fn param_set_target(g: *mut c_void, cf: *mut c_void) -> u64 {
let tau = dec_f64(cf_arg(cf, 2)).unwrap_or(0.01);
param_schedule(g, cf, move |v, t| Tl::Target { t, v, tau })
}
#[crate::host_fn]
unsafe fn param_cancel(g: *mut c_void, cf: *mut c_void) -> u64 {
let t = dec_f64(cf_arg(cf, 0)).unwrap_or(0.0);
let this = cf_this(cf);
let Some(p) = this_param(g, cf) else {
return throw_type_error(g, "AudioParam.cancelScheduledValues on wrong this");
};
let key = (p.node, p.kind);
let mut gl = glob().lock().unwrap();
if let Some(tl) = gl.timelines.get_mut(&key) {
tl.evs.retain(|e| e.time() < t);
if tl.evs.is_empty() {
gl.timelines.remove(&key);
}
}
this
}
unsafe fn this_buf<'a>(g: *mut c_void, cf: *mut c_void) -> Option<&'a mut BufData> {
host_data::<BufData>(g, classes(g).buffer_cls, cf_this(cf))
}
unsafe fn wrap_buffer(g: *mut c_void, buf: Arc<PlanarBuffer>) -> u64 {
let c = classes(g);
host_create(g, c.buffer_cls, c.buffer.proto, BufData { buf })
}
#[crate::host_fn]
unsafe fn buf_get_sample_rate(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_buf(g, cf) {
Some(b) => enc_f64(b.buf.sample_rate as f64),
None => throw_type_error(g, "AudioBuffer.sampleRate on wrong this"),
}
}
#[crate::host_fn]
unsafe fn buf_get_length(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_buf(g, cf) {
Some(b) => enc_f64(b.buf.data.first().map(|c| c.len()).unwrap_or(0) as f64),
None => throw_type_error(g, "AudioBuffer.length on wrong this"),
}
}
#[crate::host_fn]
unsafe fn buf_get_duration(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_buf(g, cf) {
Some(b) => {
let frames = b.buf.data.first().map(|c| c.len()).unwrap_or(0) as f64;
enc_f64(frames / (b.buf.sample_rate.max(1) as f64))
}
None => throw_type_error(g, "AudioBuffer.duration on wrong this"),
}
}
#[crate::host_fn]
unsafe fn buf_get_channels(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_buf(g, cf) {
Some(b) => enc_i32(b.buf.data.len() as i32),
None => throw_type_error(g, "AudioBuffer.numberOfChannels on wrong this"),
}
}
#[crate::host_fn]
unsafe fn buf_get_channel_data(g: *mut c_void, cf: *mut c_void) -> u64 {
let i = dec_f64(cf_arg(cf, 0)).unwrap_or(0.0) as usize;
let Some(b) = this_buf(g, cf) else {
return throw_type_error(g, "AudioBuffer.getChannelData on wrong this");
};
let Some(ch) = b.buf.data.get(i) else {
return throw_error(g, 2, "AudioBuffer.getChannelData: channel index out of range");
};
let mut out = UNDEF;
if crate::ffi::redjs_typedarray_create(g, 8 , ch.len(), &mut out) != 0 {
return UNDEF;
}
let mut ta = crate::ffi::RjsTaInfo::default();
if glue::rjs_typedarray_info(g, out, &mut ta) == 0 && !ta.data.is_null() {
core::ptr::copy_nonoverlapping(ch.as_ptr(), ta.data as *mut f32, ch.len());
}
out
}
#[crate::host_fn]
unsafe fn buf_copy_to_channel(g: *mut c_void, cf: *mut c_void) -> u64 {
let src = cf_arg(cf, 0);
let ch = dec_f64(cf_arg(cf, 1)).unwrap_or(0.0) as usize;
let start = dec_f64(cf_arg(cf, 2)).unwrap_or(0.0) as usize;
let Some(b) = this_buf(g, cf) else {
return throw_type_error(g, "AudioBuffer.copyToChannel on wrong this");
};
let mut ta = crate::ffi::RjsTaInfo::default();
if glue::rjs_typedarray_info(g, src, &mut ta) != 0 || ta.data.is_null() || ta.kind != 8 {
return throw_type_error(g, "AudioBuffer.copyToChannel: source must be a Float32Array");
}
let src_slice = core::slice::from_raw_parts(ta.data as *const f32, ta.length as usize);
let data = Arc::make_mut(&mut b.buf);
if let Some(chan) = data.data.get_mut(ch) {
let start = start.min(chan.len());
let n = src_slice.len().min(chan.len() - start);
chan[start..start + n].copy_from_slice(&src_slice[..n]);
}
UNDEF
}
impl Clone for PlanarBuffer {
fn clone(&self) -> Self {
Self { data: self.data.clone(), sample_rate: self.sample_rate }
}
}
#[crate::host_fn]
unsafe fn src_get_buffer(g: *mut c_void, cf: *mut c_void) -> u64 {
let slots = slots_of(g, cf_this(cf));
get(g, slots, "buffer")
}
#[crate::host_fn]
unsafe fn src_set_buffer(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let v = cf_arg(cf, 0);
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioBufferSourceNode.buffer on wrong this");
};
let arc = host_data::<BufData>(g, c.buffer_cls, v).map(|b| b.buf.clone());
{
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
if let Some(rec) = gl.nodes.get_mut(&handle) {
rec.buffer = arc;
let eh = rec.engine;
graph::resync(&mut gl.engines, &mut gl.nodes, eh);
}
}
let slots = slots_of(g, cf_this(cf));
define(g, slots, "buffer", if is_cell(v) { v } else { NULL }, 0);
UNDEF
}
#[crate::host_fn]
unsafe fn src_get_loop(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioBufferSourceNode.loop on wrong this");
};
let gl = glob().lock().unwrap();
enc_bool(gl.nodes.get(&handle).map(|r| r.src.looping.load(Ordering::Relaxed)).unwrap_or(false))
}
#[crate::host_fn]
unsafe fn src_set_loop(g: *mut c_void, cf: *mut c_void) -> u64 {
let v = cf_arg(cf, 0) == 0x7; let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioBufferSourceNode.loop on wrong this");
};
let gl = glob().lock().unwrap();
if let Some(rec) = gl.nodes.get(&handle) {
rec.src.looping.store(v, Ordering::Relaxed);
}
UNDEF
}
unsafe fn src_loop_point(g: *mut c_void, cf: *mut c_void, end: bool) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioBufferSourceNode.loopStart/loopEnd on wrong this");
};
let gl = glob().lock().unwrap();
let ctl = gl.nodes.get(&handle).map(|r| r.src.clone());
drop(gl);
let v = ctl.map(|c| if end { c.loop_end() } else { c.loop_start() }).unwrap_or(0.0);
enc_f64(v)
}
unsafe fn src_set_loop_point(g: *mut c_void, cf: *mut c_void, end: bool) -> u64 {
let name = if end { "loopEnd" } else { "loopStart" };
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, &format!("AudioBufferSourceNode.{name} on wrong this"));
};
let Ok(v) = to_number(g, cf_arg(cf, 0)) else { return UNDEF };
if !v.is_finite() {
return throw_type_error(
g,
&format!("Failed to set the '{name}' property on 'AudioBufferSourceNode': The provided double value is non-finite."),
);
}
let gl = glob().lock().unwrap();
if let Some(rec) = gl.nodes.get(&handle) {
let slot = if end { &rec.src.loop_end } else { &rec.src.loop_start };
slot.store(v.to_bits(), Ordering::Relaxed);
}
UNDEF
}
#[crate::host_fn]
unsafe fn src_get_loop_start(g: *mut c_void, cf: *mut c_void) -> u64 {
src_loop_point(g, cf, false)
}
#[crate::host_fn]
unsafe fn src_set_loop_start(g: *mut c_void, cf: *mut c_void) -> u64 {
src_set_loop_point(g, cf, false)
}
#[crate::host_fn]
unsafe fn src_get_loop_end(g: *mut c_void, cf: *mut c_void) -> u64 {
src_loop_point(g, cf, true)
}
#[crate::host_fn]
unsafe fn src_set_loop_end(g: *mut c_void, cf: *mut c_void) -> u64 {
src_set_loop_point(g, cf, true)
}
#[crate::host_fn]
unsafe fn src_get_onended(g: *mut c_void, cf: *mut c_void) -> u64 {
let slots = slots_of(g, cf_this(cf));
get(g, slots, "onended")
}
#[crate::host_fn]
unsafe fn src_set_onended(g: *mut c_void, cf: *mut c_void) -> u64 {
let slots = slots_of(g, cf_this(cf));
define(g, slots, "onended", cf_arg(cf, 0), 0);
UNDEF
}
#[crate::host_fn]
unsafe fn src_start(g: *mut c_void, cf: *mut c_void) -> u64 {
let when = dec_f64(cf_arg(cf, 0)).unwrap_or(0.0);
let offset = dec_f64(cf_arg(cf, 1)).unwrap_or(0.0);
let duration = dec_f64(cf_arg(cf, 2));
let this = cf_this(cf);
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioScheduledSourceNode.start on wrong this");
};
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let Some(rec) = gl.nodes.get_mut(&handle) else { return UNDEF };
let (iface, checks) = match rec.params {
Params::Sampler(_) => ("AudioBufferSourceNode", [("when", when), ("offset", offset), ("duration", duration.unwrap_or(0.0))]),
_ => ("OscillatorNode", [("when", when), ("offset", 0.0), ("duration", 0.0)]),
};
if let Some((name, v)) = checks.into_iter().find(|&(_, v)| v < 0.0) {
return throw_error(
g,
2,
&format!("Failed to execute 'start' on '{iface}': The {name} provided ({v}) is less than the minimum bound (0)."),
);
}
if rec.started {
return super::domexception::throw(g, "InvalidStateError", "start() has already been called on this source");
}
rec.started = true;
rec.js_obj = this;
crate::ffi::redjs_protect(g, this);
let Some(eng) = gl.engines.get_mut(&rec.engine) else { return UNDEF };
if when <= eng.now() || !eng.running {
do_start(eng, rec, offset, duration);
} else {
rec.pending_start = Some((when, offset, duration));
}
UNDEF
}
#[crate::host_fn]
unsafe fn src_stop(g: *mut c_void, cf: *mut c_void) -> u64 {
let when = dec_f64(cf_arg(cf, 0)).unwrap_or(0.0);
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioScheduledSourceNode.stop on wrong this");
};
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let Some(rec) = gl.nodes.get_mut(&handle) else { return UNDEF };
let Some(eng) = gl.engines.get_mut(&rec.engine) else { return UNDEF };
if when <= eng.now() || !eng.running {
rec.pending_start = None;
do_stop(eng, rec);
} else {
rec.pending_stop = Some(when);
}
UNDEF
}
#[crate::host_fn]
unsafe fn osc_get_type(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "OscillatorNode.type on wrong this");
};
let gl = glob().lock().unwrap();
let name = match gl.nodes.get(&handle).map(|r| &r.params) {
Some(Params::Osc(sh)) => sh.wave().name(),
_ => return throw_type_error(g, "OscillatorNode.type on a node that is not an oscillator"),
};
drop(gl);
js_string(g, name)
}
#[crate::host_fn]
unsafe fn osc_set_type(g: *mut c_void, cf: *mut c_void) -> u64 {
let raw = read_string(g, cf_arg(cf, 0)).unwrap_or_default();
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "OscillatorNode.type on wrong this");
};
let Some(w) = Wave::from_name(&raw) else {
return throw_type_error(
g,
&format!(
"OscillatorNode.type: '{raw}' is not one of 'sine' | 'square' | 'sawtooth' | \
'triangle'. 'custom' needs createPeriodicWave(), which this runtime does not \
implement — synthesize the waveform into an AudioBuffer instead."
),
);
};
let mut gl = glob().lock().unwrap();
match gl.nodes.get_mut(&handle).map(|r| &r.params) {
Some(Params::Osc(sh)) => sh.set_wave(w),
_ => return throw_type_error(g, "OscillatorNode.type on a node that is not an oscillator"),
}
UNDEF
}
unsafe fn this_sink(g: *mut c_void, cf: *mut c_void) -> Option<pcm::PcmSink> {
pcm::sink(this_node_handle(g, cf)?)
}
#[crate::host_fn]
unsafe fn stream_push(g: *mut c_void, cf: *mut c_void) -> u64 {
let src = cf_arg(cf, 0);
let Some(sink) = this_sink(g, cf) else {
return throw_error(g, 0, "RedStreamSourceNode.push: the stream is closed");
};
let mut ta = crate::ffi::RjsTaInfo::default();
if glue::rjs_typedarray_info(g, src, &mut ta) != 0 || ta.data.is_null() || ta.kind != 8 {
return throw_type_error(g, "RedStreamSourceNode.push: expected an interleaved Float32Array");
}
let data = core::slice::from_raw_parts(ta.data as *const f32, ta.length as usize);
let frames = data.len() / sink.channels().max(1) as usize;
let accepted = match sink.push_interleaved(data) {
pcm::PushOutcome::Ok | pcm::PushOutcome::UnderflowCorrected { .. } => frames,
pcm::PushOutcome::Overflow { frames_pushed } => frames_pushed,
pcm::PushOutcome::NotReady => 0,
};
enc_f64(accepted as f64)
}
#[crate::host_fn]
unsafe fn stream_close(g: *mut c_void, cf: *mut c_void) -> u64 {
if let Some(h) = this_node_handle(g, cf) {
pcm::unregister(h);
}
UNDEF
}
#[crate::host_fn]
unsafe fn stream_get_queued(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_sink(g, cf).and_then(|s| s.occupied_seconds()) {
Some(v) => enc_f64(v),
None => NULL,
}
}
#[crate::host_fn]
unsafe fn stream_get_available(g: *mut c_void, cf: *mut c_void) -> u64 {
enc_f64(this_sink(g, cf).map(|s| s.available_frames()).unwrap_or(0) as f64)
}
#[crate::host_fn]
unsafe fn stream_get_underflowed(g: *mut c_void, cf: *mut c_void) -> u64 {
enc_bool(this_sink(g, cf).map(|s| s.underflowed()).unwrap_or(false))
}
#[crate::host_fn]
unsafe fn stream_get_overflowed(g: *mut c_void, cf: *mut c_void) -> u64 {
enc_bool(this_sink(g, cf).map(|s| s.overflowed()).unwrap_or(false))
}
#[crate::host_fn]
unsafe fn stream_get_ready(g: *mut c_void, cf: *mut c_void) -> u64 {
enc_bool(this_sink(g, cf).map(|s| s.is_ready()).unwrap_or(false))
}
#[crate::host_fn]
unsafe fn biquad_get_type(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "BiquadFilterNode.type on wrong this");
};
let gl = glob().lock().unwrap();
let s = match gl.nodes.get(&handle).map(|r| &r.params) {
Some(Params::Svf(p)) => match p.filter_type {
SvfType::Lowpass | SvfType::LowpassX2 => "lowpass",
SvfType::Highpass | SvfType::HighpassX2 => "highpass",
SvfType::Bandpass => "bandpass",
SvfType::LowShelf => "lowshelf",
SvfType::HighShelf => "highshelf",
_ => "peaking",
},
_ => "lowpass",
};
js_string(g, s)
}
#[crate::host_fn]
unsafe fn biquad_set_type(g: *mut c_void, cf: *mut c_void) -> u64 {
let ty = read_string(g, cf_arg(cf, 0)).unwrap_or_default();
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "BiquadFilterNode.type on wrong this");
};
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let Some(rec) = gl.nodes.get_mut(&handle) else { return UNDEF };
let Some(eng) = gl.engines.get_mut(&rec.engine) else { return UNDEF };
if let Params::Svf(p) = &mut rec.params {
let old = (**p).clone();
p.filter_type = match ty.as_str() {
"highpass" => SvfType::Highpass,
"bandpass" => SvfType::Bandpass,
"lowshelf" => SvfType::LowShelf,
"highshelf" => SvfType::HighShelf,
"peaking" => SvfType::Bell,
_ => SvfType::Lowpass,
};
queue_diff(&mut eng.fw, rec.id, &old, &**p);
}
UNDEF
}
unsafe fn panner_read(g: *mut c_void, cf: *mut c_void, read: impl FnOnce(&NodeRec) -> f64) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "PannerNode attribute on wrong this");
};
let gl = glob().lock().unwrap();
match gl.nodes.get(&handle) {
Some(rec) if matches!(rec.params, Params::Spatial(_)) => enc_f64(read(rec)),
_ => enc_f64(0.0),
}
}
unsafe fn panner_write(g: *mut c_void, cf: *mut c_void, apply: impl FnOnce(&mut NodeRec)) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "PannerNode attribute on wrong this");
};
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let Some(rec) = gl.nodes.get_mut(&handle) else { return UNDEF };
let Some(eng) = gl.engines.get_mut(&rec.engine) else { return UNDEF };
apply(rec);
update_spatial(eng, rec);
UNDEF
}
macro_rules! panner_f32_accessor {
($get:ident, $set:ident, $field:ident, $idx:expr, $clamp:expr) => {
#[crate::host_fn]
unsafe fn $get(g: *mut c_void, cf: *mut c_void) -> u64 {
panner_read(g, cf, |rec| rec.$field[$idx] as f64)
}
#[crate::host_fn]
unsafe fn $set(g: *mut c_void, cf: *mut c_void) -> u64 {
let v = dec_f64(cf_arg(cf, 0)).unwrap_or(0.0) as f32;
panner_write(g, cf, |rec| rec.$field[$idx] = ($clamp)(v))
}
};
}
panner_f32_accessor!(panner_get_ref, panner_set_ref, dist, 0, |v: f32| v.max(1e-4));
panner_f32_accessor!(panner_get_max, panner_set_max, dist, 1, |v: f32| v.max(0.0));
panner_f32_accessor!(panner_get_rolloff, panner_set_rolloff, dist, 2, |v: f32| v.max(0.0));
panner_f32_accessor!(panner_get_cone_inner, panner_set_cone_inner, cone, 0, |v: f32| v);
panner_f32_accessor!(panner_get_cone_outer, panner_set_cone_outer, cone, 1, |v: f32| v);
panner_f32_accessor!(panner_get_cone_gain, panner_set_cone_gain, cone, 2, |v: f32| v);
#[crate::host_fn]
unsafe fn panner_get_distance_model(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "PannerNode.distanceModel on wrong this");
};
let gl = glob().lock().unwrap();
let s = match gl.nodes.get(&handle).map(|r| r.dist_model) {
Some(DistModel::Linear) => "linear",
Some(DistModel::Exponential) => "exponential",
_ => "inverse",
};
js_string(g, s)
}
#[crate::host_fn]
unsafe fn panner_set_distance_model(g: *mut c_void, cf: *mut c_void) -> u64 {
let ty = read_string(g, cf_arg(cf, 0)).unwrap_or_default();
let model = match ty.as_str() {
"linear" => DistModel::Linear,
"exponential" => DistModel::Exponential,
_ => DistModel::Inverse,
};
panner_write(g, cf, |rec| rec.dist_model = model)
}
#[crate::host_fn]
unsafe fn panner_get_panning_model(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "PannerNode.panningModel on wrong this");
};
let gl = glob().lock().unwrap();
let panning = gl.nodes.get(&handle).map(|r| r.panning);
drop(gl);
let name = match panning {
Some(Panning::Hrtf) => "HRTF",
Some(Panning::Objects) => output::object_model().unwrap_or("HRTF"),
_ => "equalpower",
};
js_string(g, name)
}
#[crate::host_fn]
unsafe fn panner_set_panning_model(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(handle) = this_node_handle(g, cf) else {
return throw_type_error(g, "PannerNode.panningModel on wrong this");
};
let Ok(v) = to_js_string(g, cf_arg(cf, 0)) else { return UNDEF };
let ty = read_string(g, v).unwrap_or_default();
let panning = match ty.as_str() {
"equalpower" => Panning::EqualPower,
"HRTF" => Panning::Hrtf,
t if output::object_model() == Some(t) => Panning::Objects,
_ => return UNDEF,
};
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let Some(rec) = gl.nodes.get_mut(&handle) else { return UNDEF };
if !matches!(rec.params, Params::Spatial(_)) || rec.panning == panning {
return UNDEF;
}
rec.panning = panning;
let eh = rec.engine;
let Some(eng) = gl.engines.get_mut(&eh) else { return UNDEF };
update_spatial(eng, rec);
if panning == Panning::Objects && !eng.wants_objects && eng.state != ST_CLOSED {
eng.wants_objects = true;
let device = mediadevices::resolve_output(&eng.sink_id).ok().flatten();
if let Err(e) = open_output(eng, device, true) {
eprintln!("[audio] the output could not be reopened for '{ty}' ({e})");
eng.retry_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(1));
}
reopened(gl, eh);
return UNDEF;
}
graph::assign_objects(eng, &mut gl.nodes, eh);
UNDEF
}
unsafe fn analyser_out<'a, T>(g: *mut c_void, cf: *mut c_void, kind: u32) -> Option<&'a mut [T]> {
let arr = cf_arg(cf, 0);
let mut ta = crate::ffi::RjsTaInfo::default();
if glue::rjs_typedarray_info(g, arr, &mut ta) == 0 && !ta.data.is_null() && ta.kind == kind {
Some(core::slice::from_raw_parts_mut(ta.data as *mut T, ta.length as usize))
} else {
None
}
}
fn valid_fft_size(v: f64) -> Option<usize> {
let n = v as usize;
(v.fract() == 0.0 && (32..=MONITOR_WINDOW).contains(&n) && n.is_power_of_two()).then_some(n)
}
unsafe fn analyser_slot_f64(g: *mut c_void, cf: *mut c_void, name: &str, default: f64) -> f64 {
let slots = slots_of(g, cf_this(cf));
dec_f64(get(g, slots, name)).unwrap_or(default)
}
unsafe fn analyser_fft_size(g: *mut c_void, cf: *mut c_void) -> usize {
valid_fft_size(analyser_slot_f64(g, cf, "fftSize", 2048.0)).unwrap_or(2048)
}
unsafe fn analyser_time_domain(g: *mut c_void, cf: *mut c_void) -> Option<Vec<f32>> {
let handle = this_node_handle(g, cf)?;
let n = analyser_fft_size(g, cf);
let gl = glob().lock().unwrap();
match gl.nodes.get(&handle).map(|r| &r.params) {
Some(Params::Analyser { ring, .. }) => {
let mut buf = vec![0.0f32; n];
ring.read_latest(&mut buf);
Some(buf)
}
_ => None,
}
}
unsafe fn analyser_spectrum(g: *mut c_void, cf: *mut c_void) -> Option<Vec<f32>> {
let handle = this_node_handle(g, cf)?;
let n = analyser_fft_size(g, cf);
let tau = analyser_slot_f64(g, cf, "smoothingTimeConstant", 0.8).clamp(0.0, 1.0) as f32;
let mut gl = glob().lock().unwrap();
let Some(rec) = gl.nodes.get_mut(&handle) else { return None };
let Params::Analyser { ring, smooth } = &mut rec.params else { return None };
let mut re = vec![0.0f32; n];
ring.read_latest(&mut re);
for (i, v) in re.iter_mut().enumerate() {
*v *= blackman(i, n);
}
let mut im = vec![0.0f32; n];
fft_in_place(&mut re, &mut im);
if smooth.len() != n / 2 {
smooth.clear();
smooth.resize(n / 2, 0.0);
}
for k in 0..n / 2 {
let mag = (re[k] * re[k] + im[k] * im[k]).sqrt() / n as f32;
smooth[k] = tau * smooth[k] + (1.0 - tau) * mag;
}
Some(smooth.clone())
}
#[crate::host_fn]
unsafe fn analyser_float_time(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(out) = analyser_out::<f32>(g, cf, 8) else { return UNDEF };
match analyser_time_domain(g, cf) {
Some(data) => {
let n = out.len().min(data.len());
out[..n].copy_from_slice(&data[..n]);
}
None => out.fill(0.0),
}
UNDEF
}
#[crate::host_fn]
unsafe fn analyser_byte_time(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(out) = analyser_out::<u8>(g, cf, 2) else { return UNDEF };
match analyser_time_domain(g, cf) {
Some(data) => {
for (o, &v) in out.iter_mut().zip(data.iter()) {
*o = ((128.0 * (1.0 + v)).round()).clamp(0.0, 255.0) as u8;
}
}
None => out.fill(128),
}
UNDEF
}
#[crate::host_fn]
unsafe fn analyser_float_freq(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(out) = analyser_out::<f32>(g, cf, 8) else { return UNDEF };
match analyser_spectrum(g, cf) {
Some(mags) => {
for (o, &m) in out.iter_mut().zip(mags.iter()) {
*o = 20.0 * m.log10(); }
}
None => out.fill(f32::NEG_INFINITY),
}
UNDEF
}
#[crate::host_fn]
unsafe fn analyser_byte_freq(g: *mut c_void, cf: *mut c_void) -> u64 {
let min_db = analyser_slot_f64(g, cf, "minDecibels", -100.0) as f32;
let max_db = analyser_slot_f64(g, cf, "maxDecibels", -30.0) as f32;
let range = (max_db - min_db).max(1e-6);
let Some(out) = analyser_out::<u8>(g, cf, 2) else { return UNDEF };
match analyser_spectrum(g, cf) {
Some(mags) => {
for (o, &m) in out.iter_mut().zip(mags.iter()) {
let db = 20.0 * m.log10();
*o = (255.0 * (db - min_db) / range).clamp(0.0, 255.0) as u8;
}
}
None => out.fill(0),
}
UNDEF
}
#[crate::host_fn]
unsafe fn analyser_get_fft(g: *mut c_void, cf: *mut c_void) -> u64 {
enc_i32(analyser_fft_size(g, cf) as i32)
}
#[crate::host_fn]
unsafe fn analyser_set_fft(g: *mut c_void, cf: *mut c_void) -> u64 {
let v = dec_f64(cf_arg(cf, 0)).unwrap_or(f64::NAN);
if valid_fft_size(v).is_none() {
return throw_type_error(g, "AnalyserNode.fftSize must be a power of two in [32, 4096]");
}
let slots = slots_of(g, cf_this(cf));
define(g, slots, "fftSize", cf_arg(cf, 0), 0);
UNDEF
}
#[crate::host_fn]
unsafe fn analyser_bin_count(g: *mut c_void, cf: *mut c_void) -> u64 {
enc_i32((analyser_fft_size(g, cf) / 2) as i32)
}
macro_rules! analyser_slot_accessor {
($get:ident, $set:ident, $name:literal, $default:expr) => {
#[crate::host_fn]
unsafe fn $get(g: *mut c_void, cf: *mut c_void) -> u64 {
enc_f64(analyser_slot_f64(g, cf, $name, $default))
}
#[crate::host_fn]
unsafe fn $set(g: *mut c_void, cf: *mut c_void) -> u64 {
let slots = slots_of(g, cf_this(cf));
define(g, slots, $name, cf_arg(cf, 0), 0);
UNDEF
}
};
}
analyser_slot_accessor!(analyser_get_smoothing, analyser_set_smoothing, "smoothingTimeConstant", 0.8);
analyser_slot_accessor!(analyser_get_min_db, analyser_set_min_db, "minDecibels", -100.0);
analyser_slot_accessor!(analyser_get_max_db, analyser_set_max_db, "maxDecibels", -30.0);
macro_rules! slot_getter {
($fn_name:ident, $slot:literal) => {
#[crate::host_fn]
unsafe fn $fn_name(g: *mut c_void, cf: *mut c_void) -> u64 {
let slots = slots_of(g, cf_this(cf));
get(g, slots, $slot)
}
};
}
slot_getter!(get_slot_gain, "gain");
slot_getter!(get_slot_pan, "pan");
slot_getter!(get_slot_playback_rate, "playbackRate");
slot_getter!(get_slot_detune, "detune");
slot_getter!(get_slot_frequency, "frequency");
slot_getter!(get_slot_q, "Q");
slot_getter!(get_slot_pos_x, "positionX");
slot_getter!(get_slot_pos_y, "positionY");
slot_getter!(get_slot_pos_z, "positionZ");
slot_getter!(get_slot_orient_x, "orientationX");
slot_getter!(get_slot_orient_y, "orientationY");
slot_getter!(get_slot_orient_z, "orientationZ");
slot_getter!(get_slot_forward_x, "forwardX");
slot_getter!(get_slot_forward_y, "forwardY");
slot_getter!(get_slot_forward_z, "forwardZ");
slot_getter!(get_slot_up_x, "upX");
slot_getter!(get_slot_up_y, "upY");
slot_getter!(get_slot_up_z, "upZ");
slot_getter!(get_slot_destination, "destination");
slot_getter!(get_slot_listener, "listener");
slot_getter!(get_slot_stream_id, "streamId");
slot_getter!(get_slot_stream_rate, "sampleRate");
slot_getter!(get_slot_stream_channels, "channelCount");
#[crate::host_fn]
unsafe fn ctx_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let mut fw = FirewheelContext::new(firewheel::FirewheelConfig {
num_graph_outputs: firewheel::channel_config::ChannelCount::new(mixing::MAX_CHANNELS).unwrap(),
..Default::default()
});
let master = fw.add_node(VolumeNode::default(), None);
let ref_tap = RENDER_REFERENCE.get().map(|&sink| {
let key = NEXT_REFERENCE_KEY.fetch_add(1, Ordering::Relaxed);
fw.add_node(RefTapNode { key, sink }, None)
});
let mut eng = Engine {
g: g as usize,
fw,
running: false,
state: ST_RUNNING,
master,
master_params: VolumeNode::default(),
listener: [0.0; 3],
listener_fwd: [0.0, 0.0, -1.0],
listener_up: [0.0, 1.0, 0.0],
sample_rate: 0,
sink_id: String::new(),
default_seen: mediadevices::default_generation(mediadevices::Flow::Output),
device_channels: 2,
device_mask: 0,
out_wire: None,
ref_tap,
tap_wire: None,
wants_objects: false,
objects: None,
refused: None,
retry_at: None,
};
if let Err(e) = open_output(&mut eng, None, true) {
eprintln!("[audio] AudioContext: output stream failed ({e}) — graph runs silent");
}
if eng.sample_rate == 0 {
eng.sample_rate = 48_000;
}
alog!("AudioContext created: running={} rate={} channels={}", eng.running, eng.sample_rate, eng.device_channels);
let (engine_handle, dest_handle) = {
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let engine_handle = gl.next;
gl.next += 1;
gl.engines.insert(engine_handle, eng);
let dest_handle = alloc_node(gl, engine_handle, Params::Dest).unwrap();
graph::resync(&mut gl.engines, &mut gl.nodes, engine_handle);
(engine_handle, dest_handle)
};
let nt = cf_new_target(cf);
let mut proto = if is_cell(nt) { get(g, nt, "prototype") } else { UNDEF };
if !is_cell(proto) {
proto = c.ctx.proto;
}
let obj = host_create(g, c.ctx_cls, proto, CtxHandle(engine_handle));
let slots = new_object(g, UNDEF);
glue::rjs_define(g, obj, c.s_audio, slots, 0);
let dest = wrap_node(g, c.dest.proto, dest_handle, &[]);
define(g, slots, "destination", dest, 0);
let listener = host_create(g, c.listener_cls, c.listener.proto, ListenerHandle(engine_handle));
let lslots = new_object(g, UNDEF);
glue::rjs_define(g, listener, c.s_audio, lslots, 0);
let lparams: &[(&str, u8, f64)] = &[
("positionX", P_L_POS_X, 0.0),
("positionY", P_L_POS_Y, 0.0),
("positionZ", P_L_POS_Z, 0.0),
("forwardX", P_L_FWD_X, 0.0),
("forwardY", P_L_FWD_Y, 0.0),
("forwardZ", P_L_FWD_Z, -1.0),
("upX", P_L_UP_X, 0.0),
("upY", P_L_UP_Y, 1.0),
("upZ", P_L_UP_Z, 0.0),
];
for &(name, kind, initial) in lparams {
let p = host_create(g, c.param_cls, c.param.proto, ParamRef { node: engine_handle, kind, last: initial });
define(g, lslots, name, p, 0);
}
define(g, slots, "listener", listener, 0);
obj
}
#[crate::host_fn]
unsafe fn ctx_get_current_time(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return throw_type_error(g, "AudioContext.currentTime on wrong this");
};
let gl = glob().lock().unwrap();
enc_f64(gl.engines.get(&h).map(|e| e.now()).unwrap_or(0.0))
}
#[crate::host_fn]
unsafe fn ctx_get_sample_rate(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return throw_type_error(g, "AudioContext.sampleRate on wrong this");
};
let gl = glob().lock().unwrap();
enc_f64(gl.engines.get(&h).map(|e| e.sample_rate).unwrap_or(48_000) as f64)
}
#[crate::host_fn]
unsafe fn ctx_get_state(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return throw_type_error(g, "AudioContext.state on wrong this");
};
let gl = glob().lock().unwrap();
let s = match gl.engines.get(&h).map(|e| e.state) {
Some(ST_SUSPENDED) => "suspended",
Some(ST_CLOSED) | None => "closed",
_ => "running",
};
js_string(g, s)
}
#[crate::host_fn]
unsafe fn ctx_get_sink_id(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return throw_type_error(g, "AudioContext.sinkId on wrong this");
};
let gl = glob().lock().unwrap();
let id = gl.engines.get(&h).map(|e| e.sink_id.clone()).unwrap_or_default();
drop(gl);
js_string(g, &id)
}
#[crate::host_fn]
unsafe fn ctx_set_sink_id(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return rejected_promise(g, 1, "AudioContext.setSinkId on wrong this");
};
let arg = cf_arg(cf, 0);
if glue::rjs_kind(g, arg) != 5 {
return rejected_promise(
g,
1,
"AudioContext.setSinkId: sinkId must be a device id string (AudioSinkOptions — the \
{type:'none'} silent sink — is not implemented)",
);
}
let requested = read_string(g, arg).unwrap_or_default();
let device = match mediadevices::resolve_output(&requested) {
Ok(d) => d,
Err(()) => {
return super::domexception::rejected(
g,
"NotFoundError",
&format!("AudioContext.setSinkId: no audio output device with id '{requested}'"),
)
}
};
enum Outcome {
Ok,
Closed,
Failed(String),
}
let outcome = {
let mut gl = glob().lock().unwrap();
let outcome = match gl.engines.get_mut(&h) {
None => Outcome::Closed,
Some(eng) if eng.state == ST_CLOSED => Outcome::Closed,
Some(eng) => {
let previous = mediadevices::resolve_output(&eng.sink_id).ok().flatten();
if previous == device {
eng.sink_id = requested.clone();
Outcome::Ok
} else {
match restart_stream(eng, device) {
Ok(()) => {
eng.sink_id = requested.clone();
alog!("setSinkId -> '{}' (rate={})", eng.sink_id, eng.sample_rate);
Outcome::Ok
}
Err(e) => {
let restored = restart_stream(eng, previous);
if restored.is_err() {
eprintln!(
"[audio] setSinkId: '{requested}' failed ({e}) and the previous \
device could not be reopened either — output is stopped"
);
}
Outcome::Failed(e)
}
}
}
}
};
reopened(&mut gl, h);
outcome
};
match outcome {
Outcome::Ok => resolved_promise(g, UNDEF),
Outcome::Closed => {
super::domexception::rejected(g, "InvalidStateError", "AudioContext.setSinkId: the context is closed")
}
Outcome::Failed(e) => rejected_promise(
g,
0,
&format!("AudioContext.setSinkId: could not open output device '{requested}': {e}"),
),
}
}
unsafe fn ctx_set_suspended(g: *mut c_void, cf: *mut c_void, suspended: bool) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return rejected_promise(g, 1, "AudioContext method on wrong this");
};
let mut guard = glob().lock().unwrap();
let gl = &mut *guard;
if let Some(eng) = gl.engines.get_mut(&h) {
if eng.state == ST_CLOSED {
return super::domexception::rejected(g, "InvalidStateError", "AudioContext is closed");
}
eng.state = if suspended { ST_SUSPENDED } else { ST_RUNNING };
let old = eng.master_params;
eng.master_params.volume = Volume::Linear(if suspended { 0.0 } else { 1.0 });
let (id, new_params) = (eng.master, eng.master_params);
queue_diff(&mut eng.fw, id, &old, &new_params);
graph::object_sends(eng, &mut gl.nodes, h);
}
drop(guard);
resolved_promise(g, UNDEF)
}
#[crate::host_fn]
unsafe fn ctx_resume(g: *mut c_void, cf: *mut c_void) -> u64 {
ctx_set_suspended(g, cf, false)
}
#[crate::host_fn]
unsafe fn ctx_suspend(g: *mut c_void, cf: *mut c_void) -> u64 {
ctx_set_suspended(g, cf, true)
}
#[crate::host_fn]
unsafe fn ctx_close(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return rejected_promise(g, 1, "AudioContext.close on wrong this");
};
let mut gl = glob().lock().unwrap();
if let Some(eng) = gl.engines.get_mut(&h) {
eng.state = ST_CLOSED;
eng.fw.stop_stream();
eng.running = false;
}
drop(gl);
resolved_promise(g, UNDEF)
}
unsafe fn ctx_create_node(g: *mut c_void, cf: *mut c_void, params: Params, proto: u64, jsparams: &[(&str, u8, f64)]) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return throw_type_error(g, "AudioContext factory called on wrong this");
};
create_node_on(g, h, params, proto, jsparams)
}
unsafe fn create_node_on(g: *mut c_void, engine: u64, params: Params, proto: u64, jsparams: &[(&str, u8, f64)]) -> u64 {
let handle = {
let mut gl = glob().lock().unwrap();
match alloc_node(&mut gl, engine, params) {
Some(x) => x,
None => return throw_error(g, 0, "AudioContext is closed"),
}
};
wrap_node(g, proto, handle, jsparams)
}
#[crate::host_fn]
unsafe fn ctx_create_gain(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
ctx_create_node(g, cf, Params::Gain(VolumeNode::default()), c.gain.proto, &[("gain", P_GAIN, 1.0)])
}
#[crate::host_fn]
unsafe fn ctx_create_stereo_panner(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
ctx_create_node(g, cf, Params::Pan(VolumePanNode::default()), c.stereo.proto, &[("pan", P_PAN, 0.0)])
}
#[crate::host_fn]
unsafe fn ctx_create_panner(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
ctx_create_node(
g,
cf,
Params::Spatial(WebPannerNode::default()),
c.panner.proto,
&[
("positionX", P_POS_X, 0.0),
("positionY", P_POS_Y, 0.0),
("positionZ", P_POS_Z, 0.0),
("orientationX", P_ORIENT_X, 1.0),
("orientationY", P_ORIENT_Y, 0.0),
("orientationZ", P_ORIENT_Z, 0.0),
],
)
}
#[crate::host_fn]
unsafe fn ctx_create_biquad(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let svf = SvfNode::<2> { cutoff_hz: 350.0, ..Default::default() };
ctx_create_node(
g,
cf,
Params::Svf(Box::new(svf)),
c.biquad.proto,
&[
("frequency", P_FREQ, 350.0),
("Q", P_Q, 1.0),
("gain", P_GAIN, 0.0),
("detune", P_INERT, 0.0),
],
)
}
#[crate::host_fn]
unsafe fn ctx_create_analyser(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let params = Params::Analyser { ring: ArcGc::new(MonitorRing::new()), smooth: Vec::new() };
ctx_create_node(g, cf, params, c.analyser.proto, &[])
}
#[crate::host_fn]
unsafe fn ctx_create_media_element_source(g: *mut c_void, cf: *mut c_void) -> u64 {
static WARNED: OnceLock<()> = OnceLock::new();
WARNED.get_or_init(|| {
eprintln!(
"[audio] advisory: createMediaElementSource() returns a SILENT pass-through on this \
runtime. A <video>/<audio> element decodes and plays out through the platform media \
engine, not through the Web Audio graph, so its samples never reach this node — \
anything connected downstream (analyser, gain, panner) will see nothing but zeros. \
For audio you want in the graph, fetch the bytes and use decodeAudioData() + \
AudioBufferSourceNode, or push PCM through createRedStreamSource()."
);
});
let c = classes(g);
ctx_create_node(g, cf, Params::Passthrough, c.node_base.proto, &[])
}
#[crate::host_fn]
unsafe fn ctx_create_oscillator(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let shared = ArcGc::new(OscShared::default());
let obj = ctx_create_node(
g,
cf,
Params::Osc(shared),
c.osc.proto,
&[("frequency", P_FREQ, 440.0), ("detune", P_DETUNE, 0.0)],
);
if is_cell(obj) {
define(g, slots_of(g, obj), "onended", NULL, 0);
}
obj
}
#[crate::host_fn]
unsafe fn ctx_create_red_stream_source(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let opts = cf_arg(cf, 0);
let num = |name: &str, dflt: f64| -> f64 {
if is_cell(opts) {
dec_f64(get(g, opts, name)).filter(|v| v.is_finite()).unwrap_or(dflt)
} else {
dflt
}
};
let d = PcmStreamConfig::default();
let cfg = PcmStreamConfig {
sample_rate: num("sampleRate", d.sample_rate as f64) as u32,
channels: num("channelCount", d.channels as f64) as u32,
latency_seconds: num("latencySeconds", d.latency_seconds),
capacity_seconds: num("capacitySeconds", d.capacity_seconds),
}
.sanitized();
let obj = ctx_create_node(g, cf, Params::PcmStream(cfg), c.stream_src.proto, &[]);
if is_cell(obj) {
if let Some(h) = host_data::<NodeHandle>(g, c.node_cls, obj).map(|x| x.0) {
let slots = slots_of(g, obj);
define(g, slots, "streamId", enc_f64(h as f64), 0);
define(g, slots, "sampleRate", enc_f64(cfg.sample_rate as f64), 0);
define(g, slots, "channelCount", enc_f64(cfg.channels as f64), 0);
}
}
obj
}
unsafe fn engine_of(g: *mut c_void, v: u64) -> Option<u64> {
host_data::<CtxHandle>(g, classes(g).ctx_cls, v).map(|h| h.0)
}
#[crate::host_fn]
pub(crate) unsafe fn ms_source_node(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(engine) = engine_of(g, cf_arg(cf, 0)) else {
return throw_type_error(g, "MediaStreamAudioSourceNode: parameter 1 is not of type 'AudioContext'.");
};
let Some(track) = super::mediastream::handle_id(g, cf_arg(cf, 1)) else {
return throw_type_error(g, "MediaStreamAudioSourceNode: the track is not a MediaStreamTrack.");
};
let Some(info) = super::mediastream::info(track) else {
return super::domexception::throw(g, "InvalidStateError", "MediaStreamAudioSourceNode: the track is gone.");
};
let remote = info.kind == super::mediastream::SourceKind::Remote;
let cfg = PcmStreamConfig {
sample_rate: info.sample_rate,
channels: info.channels.min(2),
latency_seconds: if remote { 0.08 } else { 0.03 },
capacity_seconds: if remote { 0.4 } else { 0.2 },
}
.sanitized();
let proto = cf_arg(cf, 2);
let obj = create_node_on(g, engine, Params::PcmStream(cfg), proto, &[]);
if is_cell(obj) {
if let Some(h) = host_data::<NodeHandle>(g, classes(g).node_cls, obj).map(|x| x.0) {
if !super::mediastream::pipe(h, track) {
alog!("MediaStreamAudioSourceNode {h}: track {track} is not live");
}
}
}
obj
}
pub(crate) fn reaches_destination(start: u64) -> bool {
let gl = glob().lock().unwrap();
let mut seen = std::collections::HashSet::new();
let mut todo = vec![start];
while let Some(n) = todo.pop() {
if !seen.insert(n) {
continue;
}
let Some(rec) = gl.nodes.get(&n) else { continue };
if matches!(rec.params, Params::Dest) {
return true;
}
todo.extend(rec.outs.iter().map(|c| c.dst));
}
false
}
#[crate::host_fn]
pub(crate) unsafe fn ms_dest_node(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(engine) = engine_of(g, cf_arg(cf, 0)) else {
return throw_type_error(g, "MediaStreamAudioDestinationNode: parameter 1 is not of type 'AudioContext'.");
};
let rate = glob().lock().unwrap().engines.get(&engine).map(|e| e.sample_rate).unwrap_or(48_000);
let source = super::mediastream::Source::new(
super::mediastream::SourceKind::Graph,
"MediaStreamAudioDestinationNode".into(),
2,
rate,
super::mediastream::Settings::default(),
);
let obj = create_node_on(g, engine, Params::MediaDest(Arc::clone(&source)), cf_arg(cf, 1), &[]);
if !is_cell(obj) {
return obj; }
let track = super::mediastream::new_track(&source, super::mediastream::owner_of(g));
let handle = super::mediastream::new_handle(g, track);
let out = new_array(g);
set_i(g, out, 0, obj);
set_i(g, out, 1, handle);
out
}
#[crate::host_fn]
unsafe fn ctx_create_buffer_source(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let obj = ctx_create_node(
g,
cf,
Params::Sampler(Box::new(SamplerNode::default())),
c.source.proto,
&[("playbackRate", P_RATE, 1.0), ("detune", P_INERT, 0.0)],
);
if is_cell(obj) {
let slots = slots_of(g, obj);
define(g, slots, "buffer", NULL, 0);
define(g, slots, "onended", NULL, 0);
}
obj
}
#[crate::host_fn]
unsafe fn ctx_create_buffer(g: *mut c_void, cf: *mut c_void) -> u64 {
let channels = (dec_f64(cf_arg(cf, 0)).unwrap_or(1.0) as usize).clamp(1, 32);
let length = dec_f64(cf_arg(cf, 1)).unwrap_or(0.0).max(0.0) as usize;
let rate = dec_f64(cf_arg(cf, 2)).unwrap_or(48_000.0).max(1.0) as u32;
if this_engine_handle(g, cf).is_none() {
return throw_type_error(g, "AudioContext.createBuffer on wrong this");
}
wrap_buffer(g, Arc::new(PlanarBuffer { data: vec![vec![0.0; length]; channels], sample_rate: rate }))
}
const COUNT_MODES: &[&str] = &["max", "clamped-max", "explicit"];
const INTERPRETATIONS: &[&str] = &["speakers", "discrete"];
fn count_out_of_range(n: u32, what: &str) -> Option<String> {
(!(1..=MAX_SPLIT_CHANNELS).contains(&n))
.then(|| format!("The number of {what} provided ({n}) is outside the range [1, {MAX_SPLIT_CHANNELS}]."))
}
#[derive(Clone, Copy)]
enum Pinned {
Splitter(u32),
Merger { discrete: bool },
}
impl Pinned {
fn who(self) -> &'static str {
match self {
Pinned::Splitter(_) => "ChannelSplitter",
Pinned::Merger { .. } => "ChannelMerger",
}
}
fn count(self) -> u32 {
match self {
Pinned::Splitter(n) => n,
Pinned::Merger { .. } => 1,
}
}
fn check_count(self, v: u32) -> Result<(), String> {
if v == self.count() {
Ok(())
} else {
Err(format!("{}: channelCount cannot be changed from {}", self.who(), self.count()))
}
}
fn check_mode(self, mode: &str) -> Result<(), String> {
if mode == "explicit" {
Ok(())
} else {
Err(format!("{}: channelCountMode cannot be changed from 'explicit'", self.who()))
}
}
fn check_interpretation(self, interp: &str) -> Result<(), String> {
match self {
Pinned::Splitter(_) if interp != "discrete" => {
Err("ChannelSplitter: channelInterpretation cannot be changed from 'discrete'".into())
}
_ => Ok(()),
}
}
}
unsafe fn pinned_of(g: *mut c_void, cf: *mut c_void) -> Option<(u64, Pinned)> {
let h = this_node_handle(g, cf)?;
let gl = glob().lock().unwrap();
match gl.nodes.get(&h).map(|r| &r.params) {
Some(Params::Splitter(n)) => Some((h, Pinned::Splitter(*n))),
Some(Params::Merger { discrete, .. }) => Some((h, Pinned::Merger { discrete: discrete.load(Ordering::Relaxed) })),
_ => None,
}
}
unsafe fn set_refused(g: *mut c_void, attr: &str, msg: &str) -> u64 {
super::domexception::throw(
g,
"InvalidStateError",
&format!("Failed to set the '{attr}' property on 'AudioNode': {msg}"),
)
}
unsafe fn enum_value(g: *mut c_void, v: u64, allowed: &[&str]) -> Result<Option<String>, ()> {
let s = to_js_string(g, v)?;
let s = read_string(g, s).unwrap_or_default();
Ok(allowed.contains(&s.as_str()).then_some(s))
}
#[crate::host_fn]
unsafe fn pinned_get_count(g: *mut c_void, cf: *mut c_void) -> u64 {
match pinned_of(g, cf) {
Some((_, p)) => enc_i32(p.count() as i32),
None => throw_type_error(g, "AudioNode.channelCount on wrong this"),
}
}
#[crate::host_fn]
unsafe fn pinned_set_count(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some((_, p)) = pinned_of(g, cf) else {
return throw_type_error(g, "AudioNode.channelCount on wrong this");
};
let Ok(v) = idl_u32(g, cf_arg(cf, 0), 0) else { return UNDEF };
match p.check_count(v) {
Ok(()) => UNDEF,
Err(m) => set_refused(g, "channelCount", &m),
}
}
#[crate::host_fn]
unsafe fn pinned_get_mode(g: *mut c_void, cf: *mut c_void) -> u64 {
match pinned_of(g, cf) {
Some(_) => js_string(g, "explicit"),
None => throw_type_error(g, "AudioNode.channelCountMode on wrong this"),
}
}
#[crate::host_fn]
unsafe fn pinned_set_mode(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some((_, p)) = pinned_of(g, cf) else {
return throw_type_error(g, "AudioNode.channelCountMode on wrong this");
};
match enum_value(g, cf_arg(cf, 0), COUNT_MODES) {
Err(()) | Ok(None) => UNDEF,
Ok(Some(mode)) => match p.check_mode(&mode) {
Ok(()) => UNDEF,
Err(m) => set_refused(g, "channelCountMode", &m),
},
}
}
#[crate::host_fn]
unsafe fn pinned_get_interpretation(g: *mut c_void, cf: *mut c_void) -> u64 {
match pinned_of(g, cf) {
Some((_, Pinned::Merger { discrete: false })) => js_string(g, "speakers"),
Some(_) => js_string(g, "discrete"),
None => throw_type_error(g, "AudioNode.channelInterpretation on wrong this"),
}
}
#[crate::host_fn]
unsafe fn pinned_set_interpretation(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some((h, p)) = pinned_of(g, cf) else {
return throw_type_error(g, "AudioNode.channelInterpretation on wrong this");
};
let interp = match enum_value(g, cf_arg(cf, 0), INTERPRETATIONS) {
Err(()) | Ok(None) => return UNDEF,
Ok(Some(s)) => s,
};
if let Err(m) = p.check_interpretation(&interp) {
return set_refused(g, "channelInterpretation", &m);
}
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
if let Some(rec) = gl.nodes.get_mut(&h) {
if let Params::Merger { discrete, .. } = &rec.params {
discrete.store(interp == "discrete", Ordering::Relaxed);
rec.ch_interp = Interp::parse(&interp).unwrap_or(Interp::Speakers);
let eh = rec.engine;
graph::resync(&mut gl.engines, &mut gl.nodes, eh);
}
}
UNDEF
}
unsafe fn channel_attr<T>(g: *mut c_void, cf: *mut c_void, read: impl FnOnce(&NodeRec) -> T) -> Option<T> {
let h = this_node_handle(g, cf)?;
let gl = glob().lock().unwrap();
gl.nodes.get(&h).map(read)
}
unsafe fn channel_write(
g: *mut c_void,
cf: *mut c_void,
attr: &str,
check: impl FnOnce(&NodeRec, &Engine) -> Result<(), (&'static str, String)>,
apply: impl FnOnce(&mut NodeRec),
) -> u64 {
let Some(h) = this_node_handle(g, cf) else {
return throw_type_error(g, &format!("AudioNode.{attr} on wrong this"));
};
let refusal = {
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let Some(rec) = gl.nodes.get_mut(&h) else { return UNDEF };
let eh = rec.engine;
let Some(eng) = gl.engines.get(&eh) else { return UNDEF };
match check(rec, eng) {
Err(r) => Some(r),
Ok(()) => {
apply(rec);
graph::resync(&mut gl.engines, &mut gl.nodes, eh);
None
}
}
};
match refusal {
Some((name, msg)) => {
super::domexception::throw(g, name, &format!("Failed to set the '{attr}' property on 'AudioNode': {msg}"))
}
None => UNDEF,
}
}
fn host_channel_limit(rec: &NodeRec) -> u32 {
match rec.params {
Params::Pan(_) | Params::Spatial(_) | Params::MediaDest(_) | Params::Native { .. } => 2,
_ => mixing::MAX_CHANNELS,
}
}
#[crate::host_fn]
unsafe fn node_get_channel_count(g: *mut c_void, cf: *mut c_void) -> u64 {
match channel_attr(g, cf, |r| r.ch_count) {
Some(n) => enc_i32(n as i32),
None => throw_type_error(g, "AudioNode.channelCount on wrong this"),
}
}
#[crate::host_fn]
unsafe fn node_set_channel_count(g: *mut c_void, cf: *mut c_void) -> u64 {
let Ok(v) = idl_u32(g, cf_arg(cf, 0), 0) else { return UNDEF };
channel_write(
g,
cf,
"channelCount",
|rec, eng| {
if matches!(rec.params, Params::Dest) && (v == 0 || v > eng.device_channels) {
return Err((
"IndexSizeError",
format!("The provided value ({v}) is outside the range [1, {}].", eng.device_channels),
));
}
let limit = host_channel_limit(rec);
if v == 0 || v > limit {
return Err(("NotSupportedError", format!("The channel count provided ({v}) is outside the range [1, {limit}].")));
}
Ok(())
},
|rec| rec.ch_count = v,
)
}
#[crate::host_fn]
unsafe fn node_get_channel_count_mode(g: *mut c_void, cf: *mut c_void) -> u64 {
match channel_attr(g, cf, |r| r.ch_mode) {
Some(m) => js_string(g, m.name()),
None => throw_type_error(g, "AudioNode.channelCountMode on wrong this"),
}
}
#[crate::host_fn]
unsafe fn node_set_channel_count_mode(g: *mut c_void, cf: *mut c_void) -> u64 {
let mode = match enum_value(g, cf_arg(cf, 0), COUNT_MODES) {
Err(()) | Ok(None) => return UNDEF,
Ok(Some(m)) => CountMode::parse(&m).unwrap(),
};
channel_write(
g,
cf,
"channelCountMode",
|rec, _| match rec.params {
Params::Pan(_) | Params::Spatial(_) if mode == CountMode::Max => {
Err(("NotSupportedError", "a panner's channelCountMode cannot be 'max'.".into()))
}
_ => Ok(()),
},
|rec| rec.ch_mode = mode,
)
}
#[crate::host_fn]
unsafe fn node_get_channel_interpretation(g: *mut c_void, cf: *mut c_void) -> u64 {
match channel_attr(g, cf, |r| r.ch_interp) {
Some(i) => js_string(g, i.name()),
None => throw_type_error(g, "AudioNode.channelInterpretation on wrong this"),
}
}
#[crate::host_fn]
unsafe fn node_set_channel_interpretation(g: *mut c_void, cf: *mut c_void) -> u64 {
let interp = match enum_value(g, cf_arg(cf, 0), INTERPRETATIONS) {
Err(()) | Ok(None) => return UNDEF,
Ok(Some(i)) => Interp::parse(&i).unwrap(),
};
channel_write(g, cf, "channelInterpretation", |_, _| Ok(()), |rec| rec.ch_interp = interp)
}
#[crate::host_fn]
unsafe fn dest_get_max_channel_count(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_node_handle(g, cf) else {
return throw_type_error(g, "AudioDestinationNode.maxChannelCount on wrong this");
};
let gl = glob().lock().unwrap();
let n = gl.nodes.get(&h).and_then(|r| gl.engines.get(&r.engine)).map_or(2, |e| e.device_channels);
enc_i32(n as i32)
}
#[crate::host_fn]
unsafe fn ctx_create_channel_splitter(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
if this_engine_handle(g, cf).is_none() {
return throw_type_error(g, "AudioContext.createChannelSplitter on wrong this");
}
let Ok(n) = idl_u32(g, cf_arg(cf, 0), 6) else { return UNDEF };
if let Some(m) = count_out_of_range(n, "outputs") {
return super::domexception::throw(
g,
"IndexSizeError",
&format!("Failed to execute 'createChannelSplitter' on 'BaseAudioContext': {m}"),
);
}
ctx_create_node(g, cf, Params::Splitter(n), c.splitter.proto, &[])
}
#[crate::host_fn]
unsafe fn ctx_create_channel_merger(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
if this_engine_handle(g, cf).is_none() {
return throw_type_error(g, "AudioContext.createChannelMerger on wrong this");
}
let Ok(n) = idl_u32(g, cf_arg(cf, 0), 6) else { return UNDEF };
if let Some(m) = count_out_of_range(n, "inputs") {
return super::domexception::throw(
g,
"IndexSizeError",
&format!("Failed to execute 'createChannelMerger' on 'BaseAudioContext': {m}"),
);
}
let params = Params::Merger { n, discrete: ArcGc::new(AtomicBool::new(false)) };
ctx_create_node(g, cf, params, c.merger.proto, &[])
}
struct PinnedOptions {
count: Option<u32>,
mode: Option<String>,
interpretation: Option<String>,
n: u32,
}
unsafe fn enum_member(g: *mut c_void, dict: u64, member: &str, allowed: &[&str], ty: &str, iface: &str) -> Result<Option<String>, ()> {
let v = try_get(g, dict, member)?;
if v == UNDEF {
return Ok(None);
}
let s = to_js_string(g, v)?;
let s = read_string(g, s).unwrap_or_default();
if !allowed.contains(&s.as_str()) {
throw_type_error(
g,
&format!(
"Failed to construct '{iface}': Failed to read the '{member}' property from \
'AudioNodeOptions': The provided value '{s}' is not a valid enum value of type {ty}."
),
);
return Err(());
}
Ok(Some(s))
}
unsafe fn pinned_options(g: *mut c_void, v: u64, n_member: &str, iface: &str, dict: &str) -> Result<PinnedOptions, ()> {
let mut o = PinnedOptions { count: None, mode: None, interpretation: None, n: 6 };
if v == UNDEF || v == NULL {
return Ok(o);
}
if !super::blob::is_object(g, v) {
throw_type_error(g, &format!("Failed to construct '{iface}': The provided value is not of type '{dict}'."));
return Err(());
}
let count = try_get(g, v, "channelCount")?;
if count != UNDEF {
o.count = Some(idl_u32(g, count, 0)?);
}
o.mode = enum_member(g, v, "channelCountMode", COUNT_MODES, "ChannelCountMode", iface)?;
o.interpretation = enum_member(g, v, "channelInterpretation", INTERPRETATIONS, "ChannelInterpretation", iface)?;
o.n = idl_u32(g, try_get(g, v, n_member)?, 6)?;
Ok(o)
}
unsafe fn construct_pinned(g: *mut c_void, cf: *mut c_void, splitter: bool) -> u64 {
let c = classes(g);
let (iface, dict, n_member, what) = if splitter {
("ChannelSplitterNode", "ChannelSplitterOptions", "numberOfOutputs", "outputs")
} else {
("ChannelMergerNode", "ChannelMergerOptions", "numberOfInputs", "inputs")
};
let Some(engine) = host_data::<CtxHandle>(g, c.ctx_cls, cf_arg(cf, 0)).map(|h| h.0) else {
return throw_type_error(g, &format!("Failed to construct '{iface}': parameter 1 is not of type 'BaseAudioContext'."));
};
let Ok(o) = pinned_options(g, cf_arg(cf, 1), n_member, iface, dict) else { return UNDEF };
if let Some(m) = count_out_of_range(o.n, what) {
return super::domexception::throw(g, "IndexSizeError", &format!("Failed to construct '{iface}': {m}"));
}
let p = if splitter { Pinned::Splitter(o.n) } else { Pinned::Merger { discrete: false } };
let checks = [
o.count.map(|v| p.check_count(v)),
o.mode.as_deref().map(|m| p.check_mode(m)),
o.interpretation.as_deref().map(|i| p.check_interpretation(i)),
];
if let Some(refused) = checks.into_iter().flatten().find_map(Result::err) {
return super::domexception::throw(g, "InvalidStateError", &format!("Failed to construct '{iface}': {refused}"));
}
let nt = cf_new_target(cf);
let mut proto = if is_cell(nt) { get(g, nt, "prototype") } else { UNDEF };
if !is_cell(proto) {
proto = if splitter { c.splitter.proto } else { c.merger.proto };
}
let params = if splitter {
Params::Splitter(o.n)
} else {
let discrete = o.interpretation.as_deref() == Some("discrete");
Params::Merger { n: o.n, discrete: ArcGc::new(AtomicBool::new(discrete)) }
};
create_node_on(g, engine, params, proto, &[])
}
#[crate::host_fn]
unsafe fn splitter_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
construct_pinned(g, cf, true)
}
#[crate::host_fn]
unsafe fn merger_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
construct_pinned(g, cf, false)
}
pub fn supported_decode_formats() -> &'static [&'static str] {
#[cfg(feature = "audio-codecs-extra")]
{
&[
"WAV/RIFF (PCM, IEEE float)", "AIFF", "CAF", "FLAC", "MP3", "OGG/Vorbis", "MP4/M4A (AAC-LC)",
"MKV", "ALAC", "ADPCM",
]
}
#[cfg(not(feature = "audio-codecs-extra"))]
{
&["WAV/RIFF (PCM, IEEE float)", "FLAC", "MP3", "OGG/Vorbis"]
}
}
pub(crate) fn decode_bytes(bytes: Vec<u8>, target_rate: Option<u32>) -> Result<PlanarBuffer, String> {
static LOADER: OnceLock<Mutex<symphonium::SymphoniumLoader>> = OnceLock::new();
let loader = LOADER.get_or_init(|| Mutex::new(symphonium::SymphoniumLoader::new()));
let mut loader = loader.lock().unwrap();
let decoded = loader
.load_from_source(
Box::new(std::io::Cursor::new(bytes)),
None,
target_rate.and_then(NonZeroU32::new),
symphonium::ResampleQuality::default(),
None,
)
.map_err(|e| {
format!(
"decodeAudioData could not decode this data ({e}). \
Decodable here: {}. Not decodable in any build: Opus, HE-AAC/AAC+ (the AAC-LC \
core decodes, SBR/PS do not), and anything DRM-protected.",
supported_decode_formats().join(", ")
)
})?;
let frames = decoded.frames();
let mut data = Vec::with_capacity(decoded.channels());
for ch in 0..decoded.channels() {
let mut v = vec![0.0f32; frames];
let _ = decoded.fill_channel(ch, 0, &mut v);
data.push(v);
}
Ok(PlanarBuffer { data, sample_rate: decoded.sample_rate().get() })
}
#[crate::host_fn]
unsafe fn ctx_decode_audio_data(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(h) = this_engine_handle(g, cf) else {
return rejected_promise(g, 1, "AudioContext.decodeAudioData on wrong this");
};
let Some(bytes) = bufferish(g, cf_arg(cf, 0)).map(|b| b.to_vec()) else {
return rejected_promise(g, 1, "decodeAudioData: expected an ArrayBuffer");
};
if bytes.is_empty() {
return super::domexception::rejected(g, "EncodingError", "decodeAudioData: empty buffer");
}
let target_rate = {
let gl = glob().lock().unwrap();
gl.engines.get(&h).filter(|e| e.running).map(|e| e.sample_rate)
};
let (mut res, mut rej, mut p) = (0u64, 0u64, 0u64);
if crate::ffi::redjs_promise_create(g, &mut res, &mut rej, &mut p) != 0 {
return UNDEF;
}
let success_cb = cf_arg(cf, 1);
let error_cb = cf_arg(cf, 2);
for v in [res, rej, success_cb, error_cb] {
if is_cell(v) {
crate::ffi::redjs_protect(g, v);
}
}
crate::web::schedule_native(g, 0.0, Box::new(move |g| {
match decode_bytes(bytes, target_rate) {
Ok(buf) => {
let js_buf = wrap_buffer(g, Arc::new(buf));
if is_cell(success_cb) {
let _ = call(g, success_cb, UNDEF, &[js_buf]);
}
let _ = call(g, res, UNDEF, &[js_buf]);
}
Err(msg) => {
let err = super::domexception::create(g, "EncodingError", &msg);
if is_cell(error_cb) {
let _ = call(g, error_cb, UNDEF, &[err]);
}
let _ = call(g, rej, UNDEF, &[err]);
}
}
for v in [res, rej, success_cb, error_cb] {
if is_cell(v) {
crate::ffi::redjs_unprotect(g, v);
}
}
}));
p
}
pub unsafe fn pump(g: *mut c_void) {
let c_s_audio;
{
let reg = class_registry().lock().unwrap();
match reg.get(&(g as usize)) {
Some(c) => c_s_audio = c.s_audio,
None => return, }
}
let mut ended: Vec<u64> = Vec::new();
let mut worklet_messages: Vec<(u64, NativeMessage)> = Vec::new();
{
let mut gl = glob().lock().unwrap();
let gl = &mut *gl;
let dead_list: Vec<u64> = core::mem::take(&mut *dead().lock().unwrap());
for h in dead_list {
if let Some(mut eng) = gl.engines.remove(&h) {
eng.fw.stop_stream();
for (nh, r) in gl.nodes.iter() {
if r.engine == h && matches!(r.params, Params::PcmStream(_)) {
super::mediastream::unpipe(*nh);
pcm::unregister(*nh);
}
}
gl.nodes.retain(|_, r| r.engine != h);
gl.timelines.retain(|(n, _), _| *n != h);
continue;
}
if let Some(mut rec) = gl.nodes.remove(&h) {
if matches!(rec.params, Params::PcmStream(_)) {
super::mediastream::unpipe(h);
pcm::unregister(h);
}
if let Some(eng) = gl.engines.get_mut(&rec.engine) {
graph::unwire(eng, &mut rec);
if !matches!(rec.params, Params::Dest) {
let _ = eng.fw.remove_node(rec.id);
}
}
for other in gl.nodes.values_mut().filter(|r| r.engine == rec.engine) {
other.outs.retain(|k| k.dst != h);
other.wires.retain(|k, _| k.dst != h);
}
gl.timelines.retain(|(n, _), _| *n != h);
if rec.object != 0 || !rec.outs.is_empty() {
if let Some(eng) = gl.engines.get_mut(&rec.engine) {
graph::assign_objects(eng, &mut gl.nodes, rec.engine);
}
graph::resync(&mut gl.engines, &mut gl.nodes, rec.engine);
}
}
}
let Glob { engines, nodes, timelines, .. } = gl;
let handles: Vec<u64> = engines
.iter()
.filter(|(_, e)| e.g == g as usize && e.state != ST_CLOSED)
.map(|(&h, _)| h)
.collect();
let default_output = mediadevices::default_generation(mediadevices::Flow::Output);
for eh in handles {
let (now, moved) = {
let eng = engines.get_mut(&eh).unwrap();
let moved = follow_default_output(eng, default_output) || retry_output(eng);
(eng.now(), moved)
};
if moved {
graph::assign_objects(engines.get_mut(&eh).unwrap(), nodes, eh);
graph::resync(engines, nodes, eh);
} else if engines[&eh].objects.as_ref().is_some_and(|o| o.lost_changed()) {
graph::assign_objects(engines.get_mut(&eh).unwrap(), nodes, eh);
}
let due: Vec<((u64, u8), f64, bool)> = timelines
.iter()
.filter_map(|(&(node, kind), tl)| {
let belongs = if kind >= P_L_POS_X {
node == eh
} else {
nodes.get(&node).map(|r| r.engine == eh).unwrap_or(false)
};
if !belongs {
return None;
}
let (v, done) = tl.eval(now);
Some(((node, kind), v, done))
})
.collect();
for (key, v, done) in due {
set_param(engines, nodes, key.0, key.1, v);
if done {
timelines.remove(&key);
}
}
let eng = engines.get_mut(&eh).unwrap();
for rec in nodes.values_mut().filter(|r| r.engine == eh) {
if let Params::Native { shared, .. } = &rec.params {
if rec.worklet_obj != 0 {
if let Some(message) = shared.take_message() {
crate::ffi::redjs_protect(g, rec.worklet_obj);
worklet_messages.push((rec.worklet_obj, message));
}
}
}
if let Some((when, offset, duration)) = rec.pending_start {
if when <= now {
rec.pending_start = None;
do_start(eng, rec, offset, duration);
}
}
if let Some(when) = rec.pending_stop {
if when <= now {
rec.pending_stop = None;
do_stop(eng, rec);
}
}
if rec.started && !rec.ended && rec.src.done.load(Ordering::Relaxed) {
do_stop(eng, rec);
rec.ended = true;
alog!("source walk done node={:?}", rec.id);
if rec.js_obj != 0 {
ended.push(rec.js_obj);
rec.js_obj = 0;
}
}
if rec.started && !rec.ended && matches!(rec.params, Params::Sampler(_)) {
if let Some(st) = eng.fw.node_state::<firewheel::nodes::sampler::SamplerState>(rec.id) {
if st.playing() {
rec.saw_playing = true;
}
if rec.saw_playing && st.stopped() {
rec.ended = true;
alog!("source ended node={:?}", rec.id);
if rec.js_obj != 0 {
ended.push(rec.js_obj);
rec.js_obj = 0;
}
}
}
}
if rec.started && !rec.ended {
if let Params::Osc(sh) = &rec.params {
if sh.is_playing() {
rec.saw_playing = true;
}
let done = if eng.running {
sh.is_finished()
} else {
rec.saw_playing && !sh.is_playing()
};
if done {
rec.ended = true;
alog!("oscillator ended node={:?}", rec.id);
if rec.js_obj != 0 {
ended.push(rec.js_obj);
rec.js_obj = 0;
}
}
}
}
}
match eng.fw.update() {
Ok(()) => {}
Err(firewheel::error::UpdateError::StreamStoppedUnexpectedly(e)) => {
eprintln!(
"[audio] the output stopped ({}); reopening it",
e.map(|e| e.0).unwrap_or_else(|| "the audio thread ended".into())
);
eng.running = false;
eng.retry_at = Some(std::time::Instant::now());
}
Err(e) => eprintln!("[audio] firewheel update error (engine {eh}): {e:?}"),
}
}
}
for (obj, message) in worklet_messages {
native_worklet::dispatch_message(g, obj, message);
crate::ffi::redjs_unprotect(g, obj);
}
for obj in ended {
let slots = get_a(g, obj, c_s_audio);
let cb = get(g, slots, "onended");
if is_cell(cb) {
let ev = new_object(g, UNDEF);
define(g, ev, "type", js_string(g, "ended"), 0);
define(g, ev, "target", obj, 0);
let _ = call(g, cb, obj, &[ev]);
}
crate::ffi::redjs_unprotect(g, obj);
}
}
pub unsafe fn install(g: *mut c_void) {
let s_audio = atom_priv(g, "redjs#audio");
let node_cls = make_host_class::<NodeHandle>("AudioNode");
let ctx_cls = make_host_class::<CtxHandle>("AudioContext");
let param_cls = make_host_class::<ParamRef>("AudioParam");
let buffer_cls = make_host_class::<BufData>("AudioBuffer");
let listener_cls = make_host_class::<ListenerHandle>("AudioListener");
let node_base = define_class(g, &ClassSpec {
name: "AudioNode",
arity: 0,
construct: None,
parent_proto: 0,
methods: &[("connect", 1, node_connect), ("disconnect", 0, node_disconnect)],
getters: &[("numberOfInputs", node_get_number_of_inputs), ("numberOfOutputs", node_get_number_of_outputs)],
accessors: &[
("channelCount", node_get_channel_count, node_set_channel_count),
("channelCountMode", node_get_channel_count_mode, node_set_channel_count_mode),
("channelInterpretation", node_get_channel_interpretation, node_set_channel_interpretation),
],
});
let param = define_class(g, &ClassSpec {
name: "AudioParam",
arity: 0,
construct: None,
parent_proto: 0,
methods: &[
("setValueAtTime", 2, param_set_value_at),
("linearRampToValueAtTime", 2, param_linear_ramp),
("exponentialRampToValueAtTime", 2, param_exp_ramp),
("setTargetAtTime", 3, param_set_target),
("cancelScheduledValues", 1, param_cancel),
],
getters: &[],
accessors: &[("value", param_get_value, param_set_value)],
});
let buffer = define_class(g, &ClassSpec {
name: "AudioBuffer",
arity: 0,
construct: None,
parent_proto: 0,
methods: &[("getChannelData", 1, buf_get_channel_data), ("copyToChannel", 2, buf_copy_to_channel)],
getters: &[
("sampleRate", buf_get_sample_rate),
("length", buf_get_length),
("duration", buf_get_duration),
("numberOfChannels", buf_get_channels),
],
accessors: &[],
});
let dest = define_class(g, &ClassSpec {
name: "AudioDestinationNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[],
getters: &[("maxChannelCount", dest_get_max_channel_count)],
accessors: &[],
});
let listener = define_class(g, &ClassSpec {
name: "AudioListener",
arity: 0,
construct: None,
parent_proto: 0,
methods: &[],
getters: &[
("positionX", get_slot_pos_x),
("positionY", get_slot_pos_y),
("positionZ", get_slot_pos_z),
("forwardX", get_slot_forward_x),
("forwardY", get_slot_forward_y),
("forwardZ", get_slot_forward_z),
("upX", get_slot_up_x),
("upY", get_slot_up_y),
("upZ", get_slot_up_z),
],
accessors: &[],
});
let gain = define_class(g, &ClassSpec {
name: "GainNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[],
getters: &[("gain", get_slot_gain)],
accessors: &[],
});
let stereo = define_class(g, &ClassSpec {
name: "StereoPannerNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[],
getters: &[("pan", get_slot_pan)],
accessors: &[],
});
let panner = define_class(g, &ClassSpec {
name: "PannerNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[],
getters: &[
("positionX", get_slot_pos_x),
("positionY", get_slot_pos_y),
("positionZ", get_slot_pos_z),
("orientationX", get_slot_orient_x),
("orientationY", get_slot_orient_y),
("orientationZ", get_slot_orient_z),
],
accessors: &[
("distanceModel", panner_get_distance_model, panner_set_distance_model),
("panningModel", panner_get_panning_model, panner_set_panning_model),
("refDistance", panner_get_ref, panner_set_ref),
("maxDistance", panner_get_max, panner_set_max),
("rolloffFactor", panner_get_rolloff, panner_set_rolloff),
("coneInnerAngle", panner_get_cone_inner, panner_set_cone_inner),
("coneOuterAngle", panner_get_cone_outer, panner_set_cone_outer),
("coneOuterGain", panner_get_cone_gain, panner_set_cone_gain),
],
});
let biquad = define_class(g, &ClassSpec {
name: "BiquadFilterNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[],
getters: &[
("frequency", get_slot_frequency),
("Q", get_slot_q),
("gain", get_slot_gain),
("detune", get_slot_detune),
],
accessors: &[("type", biquad_get_type, biquad_set_type)],
});
let analyser = define_class(g, &ClassSpec {
name: "AnalyserNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[
("getByteFrequencyData", 1, analyser_byte_freq),
("getFloatFrequencyData", 1, analyser_float_freq),
("getByteTimeDomainData", 1, analyser_byte_time),
("getFloatTimeDomainData", 1, analyser_float_time),
],
getters: &[("frequencyBinCount", analyser_bin_count)],
accessors: &[
("fftSize", analyser_get_fft, analyser_set_fft),
("smoothingTimeConstant", analyser_get_smoothing, analyser_set_smoothing),
("minDecibels", analyser_get_min_db, analyser_set_min_db),
("maxDecibels", analyser_get_max_db, analyser_set_max_db),
],
});
let source = define_class(g, &ClassSpec {
name: "AudioBufferSourceNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[("start", 0, src_start), ("stop", 0, src_stop)],
getters: &[("playbackRate", get_slot_playback_rate), ("detune", get_slot_detune)],
accessors: &[
("buffer", src_get_buffer, src_set_buffer),
("loop", src_get_loop, src_set_loop),
("loopStart", src_get_loop_start, src_set_loop_start),
("loopEnd", src_get_loop_end, src_set_loop_end),
("onended", src_get_onended, src_set_onended),
],
});
let osc = define_class(g, &ClassSpec {
name: "OscillatorNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[("start", 1, src_start), ("stop", 1, src_stop)],
getters: &[("frequency", get_slot_frequency), ("detune", get_slot_detune)],
accessors: &[("type", osc_get_type, osc_set_type), ("onended", src_get_onended, src_set_onended)],
});
let stream_src = define_class(g, &ClassSpec {
name: "RedStreamSourceNode",
arity: 0,
construct: None,
parent_proto: node_base.proto,
methods: &[("push", 1, stream_push), ("close", 0, stream_close)],
getters: &[
("streamId", get_slot_stream_id),
("sampleRate", get_slot_stream_rate),
("channelCount", get_slot_stream_channels),
("queuedSeconds", stream_get_queued),
("availableFrames", stream_get_available),
("underflowed", stream_get_underflowed),
("overflowed", stream_get_overflowed),
("ready", stream_get_ready),
],
accessors: &[],
});
let pinned: &[(&str, HostFn, HostFn)] = &[
("channelCount", pinned_get_count, pinned_set_count),
("channelCountMode", pinned_get_mode, pinned_set_mode),
("channelInterpretation", pinned_get_interpretation, pinned_set_interpretation),
];
let splitter = define_class(g, &ClassSpec {
name: "ChannelSplitterNode",
arity: 1,
construct: Some(splitter_construct),
parent_proto: node_base.proto,
methods: &[],
getters: &[],
accessors: pinned,
});
let merger = define_class(g, &ClassSpec {
name: "ChannelMergerNode",
arity: 1,
construct: Some(merger_construct),
parent_proto: node_base.proto,
methods: &[],
getters: &[],
accessors: pinned,
});
let (worklet, worklet_port, worklet_port_cls) = native_worklet::install(g, node_base.proto);
let ctx = define_class(g, &ClassSpec {
name: "AudioContext",
arity: 0,
construct: Some(ctx_construct),
parent_proto: 0,
methods: &[
("loadNativeAudioWorklet", 1, native_worklet::load),
("createGain", 0, ctx_create_gain),
("createStereoPanner", 0, ctx_create_stereo_panner),
("createPanner", 0, ctx_create_panner),
("createBiquadFilter", 0, ctx_create_biquad),
("createAnalyser", 0, ctx_create_analyser),
("createBufferSource", 0, ctx_create_buffer_source),
("createOscillator", 0, ctx_create_oscillator),
("createChannelSplitter", 0, ctx_create_channel_splitter),
("createChannelMerger", 0, ctx_create_channel_merger),
("createBuffer", 3, ctx_create_buffer),
("createMediaElementSource", 1, ctx_create_media_element_source),
("createRedStreamSource", 1, ctx_create_red_stream_source),
("decodeAudioData", 1, ctx_decode_audio_data),
("setSinkId", 1, ctx_set_sink_id),
("resume", 0, ctx_resume),
("suspend", 0, ctx_suspend),
("close", 0, ctx_close),
],
getters: &[
("currentTime", ctx_get_current_time),
("sampleRate", ctx_get_sample_rate),
("state", ctx_get_state),
("sinkId", ctx_get_sink_id),
("destination", get_slot_destination),
("listener", get_slot_listener),
],
accessors: &[],
});
let ctor = ctx.ctor;
define(g, glue::rjs_global(g), "webkitAudioContext", ctor, 2);
let boxed: &'static AudioClasses = Box::leak(Box::new(AudioClasses {
node_cls,
ctx_cls,
param_cls,
buffer_cls,
listener_cls,
s_audio,
node_base,
ctx,
gain,
stereo,
panner,
biquad,
analyser,
source,
osc,
stream_src,
worklet,
worklet_port,
worklet_port_cls,
splitter,
merger,
dest,
listener,
param,
buffer,
}));
class_registry().lock().unwrap().insert(g as usize, boxed);
}
#[cfg(test)]
mod jsc_tests {
use crate::api::Context;
use crate::webapi::testing::*;
fn run(c: &Context, body: &str) -> String {
s(
c,
&format!(
"globalThis.__out = '<pending>'; (async () => {{ {body} }})().then(\
v => {{ globalThis.__out = String(v); }}, \
e => {{ globalThis.__out = 'ERROR: ' + \
(e instanceof DOMException ? 'DOMException ' + e.name + ': ' : '') + \
((e && e.message) || e); }}); 'started'"
),
);
for _ in 0..64 {
unsafe {
crate::web::pump(
c.raw(),
crate::web::PUMP_TIMERS | crate::web::PUMP_MICROTASKS,
core::ptr::null_mut(),
)
};
if s(c, "globalThis.__out") != "<pending>" {
break;
}
}
s(c, "globalThis.__out")
}
#[test]
fn the_harness_can_report_a_stall() {
let c = ctx();
assert_eq!(run(&c, "await new Promise(() => {}); return 1;"), "<pending>");
}
#[test]
fn a_context_exposes_the_element_free_output_selection_surface() {
let c = ctx();
ok(&c, "const a = new AudioContext(); const r = ('setSinkId' in a) && ('sinkId' in a); a.close(); r");
ok(&c, "typeof AudioContext.prototype.setSinkId === 'function'");
ok(&c, "AudioContext.prototype.setSinkId.length === 1");
}
#[test]
fn sink_id_starts_empty_and_records_what_was_set() {
let c = ctx();
assert_eq!(
run(
&c,
"const a = new AudioContext();
const before = a.sinkId;
await a.setSinkId('default');
const mid = a.sinkId;
await a.setSinkId('');
const after = a.sinkId;
a.close();
return JSON.stringify([before, mid, after]);"
),
r#"["","default",""]"#
);
}
#[test]
fn an_unknown_sink_is_refused_by_name() {
let c = ctx();
let got = run(
&c,
"const a = new AudioContext();
try { await a.setSinkId('no-such-endpoint'); return 'resolved'; }
finally { a.close(); }",
);
assert!(got.contains("DOMException NotFoundError"), "{got}");
assert!(got.contains("no-such-endpoint"), "{got}");
}
#[test]
fn a_non_string_sink_is_a_type_error() {
let c = ctx();
for arg in ["42", "null", "undefined", "{ type: 'none' }"] {
let got = run(
&c,
&format!(
"const a = new AudioContext();
try {{ await a.setSinkId({arg}); return 'resolved'; }}
finally {{ a.close(); }}"
),
);
assert!(got.starts_with("ERROR:"), "setSinkId({arg}) did not reject: {got}");
assert!(got.contains("must be a device id string"), "setSinkId({arg}): {got}");
}
}
#[test]
fn a_closed_context_refuses_to_switch() {
let c = ctx();
let got = run(
&c,
"const a = new AudioContext();
await a.close();
await a.setSinkId('');
return 'resolved';",
);
assert!(got.contains("DOMException InvalidStateError"), "{got}");
}
#[test]
fn switching_to_a_real_device_keeps_the_graph_and_the_clock() {
let c = ctx();
let got = run(
&c,
"const a = new AudioContext();
const dest = a.destination;
const g = a.createGain();
g.connect(dest);
const t0 = a.currentTime;
const ids = (await navigator.mediaDevices.enumerateDevices())
.filter(d => d.kind === 'audiooutput')
.map(d => d.deviceId).filter(id => id !== '' && id !== 'default');
for (const id of ids) {
await a.setSinkId(id);
if (a.sinkId !== id) return 'sinkId did not take: ' + a.sinkId;
if (a.destination !== dest) return 'destination identity lost';
if (!(a.sampleRate > 0)) return 'sampleRate: ' + a.sampleRate;
if (a.currentTime < t0) return 'clock went backwards';
if (a.state !== 'running') return 'state: ' + a.state;
g.gain.value = 0.5;
g.disconnect();
g.connect(dest);
}
a.close();
return 'ok:' + ids.length;",
);
assert!(got.starts_with("ok:"), "{got}");
eprintln!("[setSinkId] round-tripped {} real output device(s)", &got[3..]);
}
#[test]
fn an_envelope_scheduled_with_its_node_ships_with_it() {
let c = ctx();
s(
&c,
"globalThis.__d = new AudioContext(); const g = __d.createGain(); globalThis.__g = g; \
const now = __d.currentTime; g.gain.setValueAtTime(0, now); \
g.gain.linearRampToValueAtTime(0.075, now + 0.008); 'ok'",
);
let gains = || -> Vec<f32> {
let gl = super::glob().lock().unwrap();
gl.nodes
.values()
.filter(|r| gl.engines.get(&r.engine).is_some_and(|e| e.g == c.raw() as usize))
.filter_map(|r| match &r.params {
super::Params::Gain(p) => Some(p.volume.amp()),
_ => None,
})
.collect()
};
let now = gains();
assert_eq!(now.len(), 1);
assert!(now[0] <= 0.075 + 1e-6, "the gain ships at {}, not the envelope's value", now[0]);
s(&c, "__g.gain.setValueAtTime(0.5, __d.currentTime + 60); 'ok'");
assert!(gains()[0] <= 0.075 + 1e-6);
s(&c, "__d.close(); 'ok'");
}
#[test]
fn a_gain_is_an_amplitude() {
let c = ctx();
let got = s(
&c,
"globalThis.__d = new AudioContext(); \
[0.075, 0.5, 1, 2, -0.5].map(v => { const g = __d.createGain(); g.gain.value = v; \
return g.gain.value === Math.fround(v); }).join()",
);
assert_eq!(got, "true,true,true,true,true");
let mut amps: Vec<(f32, f32)> = {
let gl = super::glob().lock().unwrap();
gl.nodes
.values()
.filter(|r| gl.engines.get(&r.engine).is_some_and(|e| e.g == c.raw() as usize))
.filter_map(|r| match &r.params {
super::Params::Gain(p) => Some((r.gain, p.volume.amp())),
_ => None,
})
.collect()
};
amps.sort_by(|a, b| a.0.total_cmp(&b.0));
assert_eq!(amps.len(), 5);
for (set, amp) in amps {
assert!((amp - set.abs()).abs() <= 1e-6 * set.abs().max(1.0), "gain {set} plays at {amp}");
}
s(&c, "__d.close(); 'ok'");
}
#[test]
fn a_playing_source_keeps_the_nodes_after_it() {
let c = ctx();
s(
&c,
"globalThis.__d = new AudioContext(); (() => { \
const o = __d.createOscillator(), p = __d.createStereoPanner(), \
g = __d.createGain(), f = __d.createBiquadFilter(), gone = __d.createGain(); \
g.gain.value = 0; \
o.connect(p).connect(g).connect(f).connect(__d.destination); \
o.connect(gone); o.disconnect(gone); \
o.start(); \
for (let i = 0; i < 64; i++) __d.createGain(); \
})(); 'ok'",
);
let census = || -> (usize, usize, usize) {
let gl = super::glob().lock().unwrap();
let mine = gl.nodes.values().filter(|r| gl.engines.get(&r.engine).is_some_and(|e| e.g == c.raw() as usize));
let (mut p, mut g, mut f) = (0, 0, 0);
for r in mine {
match &r.params {
super::Params::Pan(_) => p += 1,
super::Params::Gain(_) => g += 1,
super::Params::Svf(_) => f += 1,
_ => {}
}
}
(p, g, f)
};
assert_eq!(census(), (1, 66, 1));
for _ in 0..4 {
c.gc();
unsafe { super::pump(c.raw()) };
}
let (p, g, f) = census();
assert!(g < 33, "the unreferenced gains were not collected ({g} left), so this proves nothing");
assert_eq!((p, f), (1, 1), "the panner or the filter after a playing oscillator was collected");
assert!(g >= 1, "the gain after a playing oscillator was collected");
let chain_gain = {
let gl = super::glob().lock().unwrap();
gl.nodes
.values()
.filter(|r| gl.engines.get(&r.engine).is_some_and(|e| e.g == c.raw() as usize))
.any(|r| matches!(&r.params, super::Params::Gain(_)) && r.gain == 0.0)
};
assert!(chain_gain, "the chain's own gain (set to 0) was collected");
s(&c, "__d.close(); 'ok'");
}
#[test]
fn a_context_on_the_default_sink_follows_the_default_and_a_chosen_sink_stays() {
let c = ctx();
s(&c, "globalThis.__a = new AudioContext(); globalThis.__b = new AudioContext(); 'ok'");
let mut gl = super::glob().lock().unwrap();
let mut mine: Vec<u64> = gl.engines.iter().filter(|(_, e)| e.g == c.raw() as usize).map(|(&h, _)| h).collect();
mine.sort_unstable();
assert_eq!(mine.len(), 2);
let (a, b) = (mine[0], mine[1]);
gl.engines.get_mut(&b).unwrap().sink_id = "chosen-endpoint".into();
let next = gl.engines[&a].default_seen + 1;
let ea = gl.engines.get_mut(&a).unwrap();
let had_device = ea.running;
let reopened = super::follow_default_output(ea, next);
assert_eq!(reopened, had_device, "a default-sink context reopens on the new default");
assert_eq!(ea.default_seen, next);
assert!(!super::follow_default_output(ea, next), "the same move is followed once");
let eb = gl.engines.get_mut(&b).unwrap();
let next_b = eb.default_seen + 1;
assert!(!super::follow_default_output(eb, next_b), "a chosen sink stays where it is");
assert_eq!(eb.default_seen, next_b);
eb.sink_id = super::mediadevices::DEFAULT_SINK.into();
eb.state = super::ST_CLOSED;
assert!(!super::follow_default_output(eb, next_b + 1), "a closed context is not reopened");
drop(gl);
s(&c, "__a.close(); __b.close(); 'ok'");
}
pub(super) fn pump_for(c: &Context, ms: u64) -> bool {
let before = s(c, "globalThis.__ctx.currentTime");
for _ in 0..(ms / 10).max(1) {
unsafe { super::pump(c.raw()) };
c.drain_microtasks();
std::thread::sleep(std::time::Duration::from_millis(10));
}
unsafe { super::pump(c.raw()) };
c.drain_microtasks();
let after = s(c, "globalThis.__ctx.currentTime");
before != after && after != "0"
}
pub(super) fn pump_until_rendered(c: &Context, t: f64, cap_ms: u64) -> bool {
let now = || s(c, "globalThis.__ctx.currentTime").parse::<f64>().unwrap_or(0.0);
let deadline = std::time::Instant::now() + std::time::Duration::from_millis(cap_ms);
let mut reached = None;
loop {
unsafe { super::pump(c.raw()) };
c.drain_microtasks();
let clock = now();
match reached {
None if clock >= t => reached = Some(clock),
Some(r) if clock > r => {
unsafe { super::pump(c.raw()) };
c.drain_microtasks();
return true;
}
_ => {}
}
if std::time::Instant::now() >= deadline {
return false;
}
std::thread::sleep(std::time::Duration::from_millis(10));
}
}
pub(super) fn analyser_rms(c: &Context, which: &str) -> f64 {
s(
c,
&format!(
"(() => {{ const b = new Float32Array(1024); {which}.getFloatTimeDomainData(b);
let acc = 0; for (const v of b) acc += v * v; return Math.sqrt(acc / b.length); }})()"
),
)
.parse()
.unwrap_or(f64::NAN)
}
#[test]
fn an_oscillator_exists_and_has_the_spec_shape() {
let c = ctx();
ok(&c, "typeof AudioContext.prototype.createOscillator === 'function'");
ok(
&c,
"{ const a = new AudioContext(); const o = a.createOscillator();
const r = o instanceof OscillatorNode
&& o instanceof AudioNode
&& o.type === 'sine'
&& o.frequency instanceof AudioParam
&& o.detune instanceof AudioParam
&& o.frequency.value === 440
&& o.detune.value === 0
&& typeof o.start === 'function'
&& typeof o.stop === 'function'
&& typeof o.connect === 'function';
a.close(); r }",
);
}
#[test]
fn the_four_waveforms_round_trip_and_custom_is_refused_by_name() {
let c = ctx();
ok(
&c,
"{ const a = new AudioContext(); const o = a.createOscillator();
let r = true;
for (const t of ['square','sawtooth','triangle','sine']) { o.type = t; r = r && o.type === t; }
a.close(); r }",
);
let msg = throws(
&c,
"{ const a = new AudioContext(); const o = a.createOscillator();
try { o.type = 'custom'; } finally { a.close(); } }",
);
assert!(msg.contains("custom"), "{msg}");
assert!(msg.contains("createPeriodicWave"), "the refusal must name what is missing: {msg}");
let msg = throws(
&c,
"{ const a = new AudioContext(); const o = a.createOscillator();
try { o.type = 'Sine'; } finally { a.close(); } }",
);
assert!(msg.contains("'Sine'"), "{msg}");
}
#[test]
fn an_oscillator_starts_once() {
let c = ctx();
ok(
&c,
"(() => { const a = new AudioContext(); const o = a.createOscillator(); o.start();
try { o.start(); return false; }
catch (e) { return e instanceof DOMException && e.name === 'InvalidStateError' && e.code === 11; }
finally { a.close(); } })()",
);
}
#[test]
fn a_muted_gain_silences_the_output_but_not_the_pre_gain_tap() {
let c = ctx();
s(
&c,
"globalThis.__ctx = new AudioContext();
const a = globalThis.__ctx;
globalThis.__pre = a.createAnalyser();
globalThis.__post = a.createAnalyser();
const g = a.createGain(); g.gain.value = 0;
const o = a.createOscillator(); o.type = 'square'; o.frequency.value = 330;
o.connect(__pre); __pre.connect(g); g.connect(__post); __post.connect(a.destination);
o.start(); globalThis.__osc = o; 'wired'",
);
let live = pump_for(&c, 300);
let (pre, post) = (analyser_rms(&c, "__pre"), analyser_rms(&c, "__post"));
assert!(pre.is_finite() && post.is_finite(), "analyser returned {pre} / {post}");
if !live {
eprintln!("[oscillator] no output stream on this machine — signal assertions skipped");
s(&c, "__ctx.close(); 'closed'");
return;
}
assert!(pre > 0.1, "the oscillator produced no signal at the pre-gain tap (RMS {pre})");
assert!(post < 1e-3, "gain 0 did not silence the signal: post-gain RMS {post}");
s(&c, "__osc.stop(); 'stopped'");
pump_for(&c, 100);
assert!(analyser_rms(&c, "__pre") < 1e-3, "stop() left the oscillator running");
s(&c, "__ctx.close(); 'closed'");
}
#[test]
fn a_stream_source_is_a_connectable_node_with_an_id() {
let c = ctx();
ok(&c, "typeof AudioContext.prototype.createRedStreamSource === 'function'");
ok(
&c,
"{ const a = new AudioContext();
const n = a.createRedStreamSource({ sampleRate: 24000, channelCount: 1 });
const r = n instanceof RedStreamSourceNode
&& n instanceof AudioNode
&& typeof n.streamId === 'number' && n.streamId >= 0
&& n.sampleRate === 24000
&& n.channelCount === 1
&& typeof n.push === 'function'
&& typeof n.close === 'function'
&& n.connect(a.destination) === a.destination;
a.close(); r }",
);
}
#[test]
fn stream_options_are_clamped_rather_than_trusted() {
let c = ctx();
ok(
&c,
"{ const a = new AudioContext();
const n = a.createRedStreamSource({ sampleRate: 1, channelCount: 999, latencySeconds: 0 });
const r = n.sampleRate >= 4000 && n.channelCount <= 16;
a.close(); r }",
);
ok(
&c,
"{ const a = new AudioContext(); const n = a.createRedStreamSource();
const r = n.channelCount === 2 && n.sampleRate === 48000; a.close(); r }",
);
}
#[test]
fn pushing_the_wrong_thing_is_refused_by_name() {
let c = ctx();
for arg in ["", "42", "'frames'", "new Uint8Array(8)", "[0.1, 0.2]"] {
let msg = throws(
&c,
&format!(
"{{ const a = new AudioContext(); const n = a.createRedStreamSource();
try {{ n.push({arg}); }} finally {{ a.close(); }} }}"
),
);
assert!(msg.contains("Float32Array"), "push({arg}): {msg}");
}
}
#[test]
fn a_closed_stream_refuses_pushes_instead_of_swallowing_them() {
let c = ctx();
ok(
&c,
"{ const a = new AudioContext();
const n = a.createRedStreamSource({ channelCount: 1 });
const ok1 = typeof n.push(new Float32Array(128)) === 'number';
n.close();
let refused = false;
try { n.push(new Float32Array(128)); } catch (e) { refused = /closed/.test(e.message); }
a.close(); ok1 && refused }",
);
}
#[test]
fn a_stream_source_carries_pushed_pcm_into_the_graph() {
let c = ctx();
s(
&c,
"globalThis.__ctx = new AudioContext();
const a = globalThis.__ctx;
globalThis.__an = a.createAnalyser(); __an.fftSize = 2048;
const mute = a.createGain(); mute.gain.value = 0;
globalThis.__n = a.createRedStreamSource({ sampleRate: 48000, channelCount: 1, latencySeconds: 0.05 });
__n.connect(__an); __an.connect(mute); mute.connect(a.destination);
globalThis.__blk = new Float32Array(960); // 20 ms
globalThis.__ph = 0;
globalThis.__fill = () => {
for (let i = 0; i < __blk.length; i++) { __blk[i] = Math.sin(__ph); __ph += 2 * Math.PI * 440 / 48000; }
return __n.push(__blk);
};
'wired'",
);
let mut accepted_total = 0f64;
let mut rms = 0.0;
for tick in 0..300 {
accepted_total += s(&c, "__fill()").parse::<f64>().unwrap_or(0.0);
unsafe { super::pump(c.raw()) };
c.drain_microtasks();
std::thread::sleep(std::time::Duration::from_millis(10));
if tick >= 40 {
rms = analyser_rms(&c, "__an");
if rms > 0.1 || s(&c, "__ctx.currentTime") == "0" {
break;
}
}
}
let live = s(&c, "__ctx.currentTime") != "0";
if !live {
eprintln!("[stream] no output stream — pushed {accepted_total} frames, playout not asserted");
s(&c, "__ctx.close(); 'closed'");
return;
}
assert!(accepted_total > 0.0, "the stream accepted no frames at all");
assert!(rms > 0.1, "pushed PCM never reached the analyser (RMS {rms})");
s(&c, "__ctx.close(); 'closed'");
}
#[test]
fn create_media_element_source_still_returns_a_connectable_node() {
let c = ctx();
ok(
&c,
"{ const a = new AudioContext();
const n = a.createMediaElementSource({});
const r = n instanceof AudioNode && n.connect(a.destination) === a.destination;
a.close(); r }",
);
}
fn wav_fixture(rate: u32, frames: u32) -> Vec<u8> {
let data_len = frames * 2;
let mut v = Vec::with_capacity(44 + data_len as usize);
v.extend_from_slice(b"RIFF");
v.extend_from_slice(&(36 + data_len).to_le_bytes());
v.extend_from_slice(b"WAVEfmt ");
v.extend_from_slice(&16u32.to_le_bytes()); v.extend_from_slice(&1u16.to_le_bytes()); v.extend_from_slice(&1u16.to_le_bytes()); v.extend_from_slice(&rate.to_le_bytes());
v.extend_from_slice(&(rate * 2).to_le_bytes()); v.extend_from_slice(&2u16.to_le_bytes()); v.extend_from_slice(&16u16.to_le_bytes()); v.extend_from_slice(b"data");
v.extend_from_slice(&data_len.to_le_bytes());
for i in 0..frames {
let smp: i16 = if (i / 50) % 2 == 0 { 24_000 } else { -24_000 };
v.extend_from_slice(&smp.to_le_bytes());
}
v
}
fn as_js_bytes(v: &[u8]) -> String {
v.iter().map(|b| b.to_string()).collect::<Vec<_>>().join(",")
}
#[test]
fn decode_audio_data_decodes_a_wav_and_the_samples_are_real() {
let c = ctx();
let wav = wav_fixture(48_000, 4_800);
s(&c, &format!("globalThis.__wav = new Uint8Array([{}]).buffer; 'ok'", as_js_bytes(&wav)));
let got = run(
&c,
"const a = new AudioContext();
const buf = await a.decodeAudioData(__wav);
const ch = buf.getChannelData(0);
let peak = 0, energy = 0;
for (const v of ch) { peak = Math.max(peak, Math.abs(v)); energy += v * v; }
const rms = Math.sqrt(energy / ch.length);
a.close();
return JSON.stringify({
ch: buf.numberOfChannels, rate: buf.sampleRate,
peak: Math.round(peak * 1000) / 1000, rms: Math.round(rms * 1000) / 1000,
});",
);
assert!(!got.starts_with("ERROR"), "{got}");
assert!(got.contains(r#""ch":1"#), "{got}");
if got.contains(r#""rate":48000"#) {
assert!(got.contains(r#""peak":0.732"#), "decoded amplitude is wrong: {got}");
assert!(got.contains(r#""rms":0.732"#), "a decoded square must have RMS == peak: {got}");
} else {
let field = |k: &str| -> f64 {
let at = got.find(&format!("\"{k}\":")).unwrap() + k.len() + 3;
got[at..].split([',', '}']).next().unwrap().parse().unwrap()
};
assert!((field("rms") - 0.732).abs() < 0.01, "decoded energy is wrong: {got}");
assert!(field("peak") >= 0.72, "decoded amplitude is wrong: {got}");
}
}
#[test]
fn an_undecodable_blob_rejects_by_naming_what_would_work() {
let c = ctx();
let got = run(
&c,
"const a = new AudioContext();
try { await a.decodeAudioData(new Uint8Array([1,2,3,4,5,6,7,8,9,10]).buffer); return 'resolved'; }
finally { a.close(); }",
);
assert!(got.starts_with("ERROR"), "garbage decoded?! {got}");
assert!(got.contains("DOMException EncodingError"), "{got}");
assert!(got.contains("WAV"), "the rejection must list what IS decodable: {got}");
assert!(got.contains("Opus"), "the rejection must name the notable absences: {got}");
}
#[test]
fn a_decoded_buffer_plays_through_a_buffer_source() {
let c = ctx();
let wav = wav_fixture(48_000, 48_000);
s(&c, &format!("globalThis.__wav = new Uint8Array([{}]).buffer; 'ok'", as_js_bytes(&wav)));
let started = run(
&c,
"globalThis.__ctx = new AudioContext();
const a = globalThis.__ctx;
globalThis.__an = a.createAnalyser(); __an.fftSize = 2048;
const mute = a.createGain(); mute.gain.value = 0;
const buf = await a.decodeAudioData(__wav);
const src = a.createBufferSource();
src.buffer = buf; src.loop = true;
src.connect(__an); __an.connect(mute); mute.connect(a.destination);
src.start();
return 'started';",
);
assert_eq!(started, "started", "{started}");
let live = pump_for(&c, 300);
let rms = analyser_rms(&c, "__an");
if !live {
eprintln!("[buffer source] no output stream — playout not asserted");
s(&c, "__ctx.close(); 'closed'");
return;
}
assert!(rms > 0.1, "the decoded buffer never reached the analyser (RMS {rms})");
s(&c, "__ctx.close(); 'closed'");
}
#[test]
fn a_buffer_source_has_loop_points_and_start_checks_its_range() {
let c = ctx();
ok(
&c,
"{ const a = new AudioContext(); const s = a.createBufferSource();
const fresh = s.loopStart === 0 && s.loopEnd === 0;
s.loopStart = 1.5; s.loopEnd = '2.25';
const r = fresh && s.loopStart === 1.5 && s.loopEnd === 2.25
&& 'loopStart' in AudioBufferSourceNode.prototype
&& 'loopEnd' in AudioBufferSourceNode.prototype
&& AudioBufferSourceNode.prototype.start.length === 0;
a.close(); r }",
);
let msg =
throws(&c, "{ const a = new AudioContext(); try { a.createBufferSource().loopEnd = NaN; } finally { a.close(); } }");
assert!(msg.contains("non-finite"), "{msg}");
for call in ["s.start(-1)", "s.start(0, -0.5)", "s.start(0, 0, -1)"] {
ok(
&c,
&format!(
"(() => {{ const a = new AudioContext(); const s = a.createBufferSource();
try {{ {call}; return false; }} catch (e) {{ return e instanceof RangeError; }}
finally {{ a.close(); }} }})()"
),
);
}
ok(
&c,
"{ const a = new AudioContext(); const o = a.createOscillator();
o.start(0, -1); o.stop(); a.close(); true }",
);
}
#[test]
fn unloading_the_page_closes_its_contexts() {
let c = ctx();
s(&c, "globalThis.__a = new AudioContext(); globalThis.__b = new AudioContext();
globalThis.__z = new AudioContext(); __z.close(); 0");
assert_eq!(super::close_all(c.raw()), 2);
ok(&c, "__a.state === 'closed' && __b.state === 'closed'");
assert_eq!(super::close_all(c.raw()), 0);
ok(&c, "{ const n = new AudioContext(); const r = n.state !== 'closed'; n.close(); r }");
}
#[test]
fn a_sprite_ends_after_its_duration() {
let c = ctx();
let wav = wav_fixture(48_000, 48_000);
s(&c, &format!("globalThis.__wav = new Uint8Array([{}]).buffer; 'ok'", as_js_bytes(&wav)));
let started = run(
&c,
"globalThis.__ctx = new AudioContext();
const a = globalThis.__ctx;
const mute = a.createGain(); mute.gain.value = 0; mute.connect(a.destination);
const buf = await a.decodeAudioData(__wav);
globalThis.__ended = 0;
const src = a.createBufferSource();
src.buffer = buf; src.connect(mute);
src.onended = () => { globalThis.__ended = a.currentTime; };
globalThis.__t0 = a.currentTime;
src.start(0, 0.5, 0.02);
return 'started';",
);
assert_eq!(started, "started", "{started}");
let live = pump_for(&c, 300);
if !live {
eprintln!("[sprite] no output stream — the end is not asserted");
s(&c, "__ctx.close(); 'closed'");
return;
}
ok(&c, "__ended > 0 && __ended - __t0 < 0.25");
s(&c, "__ctx.close(); 'closed'");
}
#[test]
fn suspend_and_resume_round_trip_the_state() {
let c = ctx();
assert_eq!(
run(
&c,
"const a = new AudioContext();
const s0 = a.state;
await a.suspend(); const s1 = a.state;
await a.resume(); const s2 = a.state;
await a.close(); const s3 = a.state;
return JSON.stringify([s0, s1, s2, s3]);"
),
r#"["running","suspended","running","closed"]"#
);
}
fn dom_throw(c: &Context, stmt: &str, name: &str) {
ok(
c,
&format!(
"(() => {{ try {{ {stmt}; return false; }} \
catch (e) {{ return e instanceof DOMException && e.name === '{name}'; }} }})()"
),
);
}
#[test]
fn splitter_and_merger_have_the_spec_shape() {
let c = ctx();
ok(&c, "AudioContext.prototype.createChannelSplitter.length === 0 && AudioContext.prototype.createChannelMerger.length === 0");
assert_eq!(
s(
&c,
"{ const a = new AudioContext();
const d = a.createChannelSplitter(), m = a.createChannelMerger(), d2 = a.createChannelSplitter(2);
const r = JSON.stringify([
d instanceof ChannelSplitterNode && d instanceof AudioNode,
d.numberOfInputs, d.numberOfOutputs, d.channelCount, d.channelCountMode, d.channelInterpretation,
m instanceof ChannelMergerNode && m instanceof AudioNode,
m.numberOfInputs, m.numberOfOutputs, m.channelCount, m.channelCountMode, m.channelInterpretation,
d2.numberOfOutputs, d2.channelCount]);
a.close(); r }"
),
r#"[true,1,6,6,"explicit","discrete",true,6,1,1,"explicit","speakers",2,2]"#
);
ok(
&c,
"{ const a = new AudioContext();
const g = a.createGain(), o = a.createOscillator(), an = a.createAnalyser(), b = a.createBufferSource();
const r = g.numberOfInputs === 1 && g.numberOfOutputs === 1
&& o.numberOfInputs === 0 && o.numberOfOutputs === 1
&& b.numberOfInputs === 0 && an.numberOfInputs === 1
&& a.destination.numberOfInputs === 1
&& AudioNode.prototype.connect.length === 1 && AudioNode.prototype.disconnect.length === 0;
a.close(); r }",
);
}
#[test]
fn the_constructors_take_a_context_and_options() {
let c = ctx();
ok(
&c,
"{ const a = new AudioContext();
const d = new ChannelSplitterNode(a, { numberOfOutputs: 2 });
const m = new ChannelMergerNode(a, { numberOfInputs: 3, channelInterpretation: 'discrete' });
const e = new ChannelSplitterNode(a);
const r = d instanceof ChannelSplitterNode && d.numberOfOutputs === 2
&& m.numberOfInputs === 3 && m.channelInterpretation === 'discrete'
&& e.numberOfOutputs === 6
&& ChannelSplitterNode.length === 1 && ChannelMergerNode.length === 1;
a.close(); r }",
);
ok(
&c,
"{ const a = new AudioContext(); class Mine extends ChannelMergerNode {}
const m = new Mine(a, { numberOfInputs: 2 });
const r = m instanceof Mine && m instanceof ChannelMergerNode && m.numberOfInputs === 2; a.close(); r }",
);
assert!(throws(&c, "new ChannelSplitterNode()").contains("BaseAudioContext"));
assert!(throws(&c, "new ChannelMergerNode({})").contains("BaseAudioContext"));
assert!(throws(&c, "ChannelSplitterNode({})").contains("new"));
ok(
&c,
"(() => { const a = new AudioContext();
try { new ChannelSplitterNode(a, 2); return false; } catch (e) { return e instanceof TypeError; }
finally { a.close(); } })()",
);
ok(
&c,
"(() => { const a = new AudioContext();
try { new ChannelMergerNode(a, { channelCountMode: 'bogus' }); return false; }
catch (e) { return e instanceof TypeError && /ChannelCountMode/.test(e.message); }
finally { a.close(); } })()",
);
}
#[test]
fn a_count_outside_1_to_32_is_an_index_size_error() {
let c = ctx();
s(&c, "globalThis.__a = new AudioContext(); 0");
for call in [
"__a.createChannelSplitter(0)",
"__a.createChannelSplitter(33)",
"__a.createChannelMerger(0)",
"__a.createChannelMerger(33)",
"__a.createChannelSplitter(-1)",
"__a.createChannelMerger(NaN)",
"new ChannelSplitterNode(__a, { numberOfOutputs: 0 })",
"new ChannelMergerNode(__a, { numberOfInputs: 40 })",
] {
dom_throw(&c, call, "IndexSizeError");
}
let msg = throws(&c, "__a.createChannelSplitter(33)");
assert!(msg.contains("outside the range [1, 32]"), "{msg}");
ok(
&c,
"__a.createChannelSplitter(32).numberOfOutputs === 32 && __a.createChannelMerger(32).numberOfInputs === 32
&& __a.createChannelSplitter(1).numberOfOutputs === 1",
);
ok(&c, "__a.createChannelSplitter(2.9).numberOfOutputs === 2 && __a.createChannelMerger('3').numberOfInputs === 3");
s(&c, "__a.close(); 0");
}
#[test]
fn the_pinned_attributes_refuse_a_change_and_accept_their_own_value() {
let c = ctx();
s(&c, "globalThis.__a = new AudioContext(); globalThis.__d = __a.createChannelSplitter(4); globalThis.__m = __a.createChannelMerger(2); 0");
for stmt in [
"__d.channelCount = 2",
"__d.channelCountMode = 'max'",
"__d.channelInterpretation = 'speakers'",
"__m.channelCount = 2",
"__m.channelCountMode = 'clamped-max'",
"new ChannelSplitterNode(__a, { numberOfOutputs: 2, channelCount: 3 })",
"new ChannelSplitterNode(__a, { channelCountMode: 'max' })",
"new ChannelSplitterNode(__a, { channelInterpretation: 'speakers' })",
"new ChannelMergerNode(__a, { channelCount: 2 })",
"new ChannelMergerNode(__a, { channelCountMode: 'max' })",
] {
dom_throw(&c, stmt, "InvalidStateError");
}
let msg = throws(&c, "__d.channelCount = 6");
assert!(msg.contains("cannot be changed from 4"), "{msg}");
ok(
&c,
"{ __d.channelCount = 4; __d.channelCountMode = 'explicit'; __d.channelInterpretation = 'discrete';
__m.channelCount = 1; __m.channelCountMode = 'explicit';
new ChannelSplitterNode(__a, { numberOfOutputs: 3, channelCount: 3, channelCountMode: 'explicit',
channelInterpretation: 'discrete' }).channelCount === 3 }",
);
ok(
&c,
"{ __d.channelCountMode = 'bogus'; __d.channelInterpretation = 'nope';
__d.channelCountMode === 'explicit' && __d.channelInterpretation === 'discrete' }",
);
ok(
&c,
"{ __m.channelInterpretation = 'discrete'; const was = __m.channelInterpretation;
__m.channelInterpretation = 'speakers'; was === 'discrete' && __m.channelInterpretation === 'speakers' }",
);
assert!(throws(&c, "Object.getOwnPropertyDescriptor(ChannelSplitterNode.prototype, 'channelCount').get.call(__a.createGain())")
.contains("wrong this"));
s(&c, "__a.close(); 0");
}
#[test]
fn connect_and_disconnect_use_the_output_and_input_indices() {
let c = ctx();
s(&c, "globalThis.__a = new AudioContext(); 0");
ok(
&c,
"{ const ctx = __a;
const outputAnalyserNode = ctx.createAnalyser();
outputAnalyserNode.fftSize = 256; outputAnalyserNode.smoothingTimeConstant = 0.3;
outputAnalyserNode.connect(ctx.destination);
const outputSplitter = ctx.createChannelSplitter(2);
const left = ctx.createAnalyser(); left.fftSize = 256; left.smoothingTimeConstant = 0.3;
const right = ctx.createAnalyser(); right.fftSize = 256; right.smoothingTimeConstant = 0.3;
const l = outputSplitter.connect(left, 0);
const r = outputSplitter.connect(right, 1);
const masterGainNode = ctx.createGain();
masterGainNode.connect(outputAnalyserNode);
masterGainNode.connect(outputSplitter);
const voiceBusNode = ctx.createGain();
voiceBusNode.connect(masterGainNode);
l === left && r === right }",
);
s(
&c,
"globalThis.__d = __a.createChannelSplitter(2); globalThis.__m = __a.createChannelMerger(2);
globalThis.__g = __a.createGain(); globalThis.__o = __a.createOscillator(); 0",
);
for stmt in [
"__d.connect(__g, 2)",
"__g.connect(__a.destination, 1)",
"__g.connect(__m, 0, 2)",
"__g.connect(__o)",
"__d.disconnect(2)",
"__g.disconnect(__m, 1)",
"__d.disconnect(__m, 0, 2)",
] {
dom_throw(&c, stmt, "IndexSizeError");
}
ok(&c, "__d.connect(__m, 0, 1) === __m && __d.connect(__m, 1, 0) === __m && __m.connect(__g) === __g");
s(&c, "__d.connect(__m, 0, 1); __d.disconnect(__m, 0, 1); 0");
dom_throw(&c, "__d.disconnect(__m, 0, 1)", "InvalidAccessError");
s(&c, "__d.connect(__g, 0); __d.connect(__g, 1); __d.disconnect(1); 0");
dom_throw(&c, "__d.disconnect(__g, 1)", "InvalidAccessError");
s(&c, "__d.disconnect(__g, 0); 0");
dom_throw(&c, "__g.disconnect(__o)", "InvalidAccessError");
dom_throw(&c, "__g.disconnect(__g.gain)", "InvalidAccessError");
dom_throw(&c, "{ const b = new AudioContext(); try { __g.connect(b.destination); } finally { b.close(); } }", "InvalidAccessError");
ok(&c, "{ __m.disconnect(); __m.disconnect(); __d.disconnect(); true }");
s(&c, "__a.close(); 0");
}
#[test]
fn a_split_stereo_signal_reaches_each_channel_s_analyser_and_merges_back() {
let c = ctx();
s(
&c,
"globalThis.__ctx = new AudioContext();
const a = __ctx, rate = a.sampleRate, n = rate;
const buf = a.createBuffer(2, n, rate);
const L = new Float32Array(n), R = new Float32Array(n);
for (let i = 0; i < n; i++) { L[i] = (i % 100) < 50 ? 0.5 : -0.5; R[i] = (i % 60) < 30 ? 0.25 : -0.25; }
buf.copyToChannel(L, 0); buf.copyToChannel(R, 1);
const src = a.createBufferSource(); src.buffer = buf; src.loop = true;
const sp = a.createChannelSplitter(2);
globalThis.__l = a.createAnalyser(); globalThis.__r = a.createAnalyser();
src.connect(sp); sp.connect(__l, 0); sp.connect(__r, 1);
const m = a.createChannelMerger(2); sp.connect(m, 0, 1); sp.connect(m, 1, 0);
const sp2 = a.createChannelSplitter(2); m.connect(sp2);
globalThis.__l2 = a.createAnalyser(); globalThis.__r2 = a.createAnalyser();
sp2.connect(__l2, 0); sp2.connect(__r2, 1);
const mute = a.createGain(); mute.gain.value = 0; m.connect(mute); mute.connect(a.destination);
src.start(); 'wired'",
);
let live = pump_for(&c, 400);
let (l, r) = (analyser_rms(&c, "__l"), analyser_rms(&c, "__r"));
let (l2, r2) = (analyser_rms(&c, "__l2"), analyser_rms(&c, "__r2"));
if !live {
eprintln!("[splitter] no output stream on this machine — signal assertions skipped");
s(&c, "__ctx.close(); 'closed'");
return;
}
assert!((l - 0.5).abs() < 0.02, "left channel's analyser: RMS {l}, want 0.5");
assert!((r - 0.25).abs() < 0.02, "right channel's analyser: RMS {r}, want 0.25");
assert!((l2 - 0.25).abs() < 0.02, "merged-swapped left: RMS {l2}, want 0.25");
assert!((r2 - 0.5).abs() < 0.02, "merged-swapped right: RMS {r2}, want 0.5");
s(&c, "__ctx.close(); 'closed'");
}
}
#[cfg(test)]
mod split_merge_graph_tests {
use super::*;
use core::time::Duration;
use firewheel::backend::{AudioBackend, BackendProcessInfo};
use firewheel::node::StreamStatus;
use firewheel::processor::FirewheelProcessor;
use firewheel::{FirewheelConfig, FirewheelCtx, StreamInfo};
const RATE: u32 = 48_000;
const BLOCK: usize = 128;
#[derive(Debug)]
struct Never;
impl core::fmt::Display for Never {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("never")
}
}
impl std::error::Error for Never {}
struct Offline {
processor: Option<FirewheelProcessor<Offline>>,
}
impl AudioBackend for Offline {
type Enumerator = ();
type Config = ();
type StartStreamError = Never;
type StreamError = Never;
type Instant = ();
fn enumerator() -> Self::Enumerator {}
fn start_stream(_config: ()) -> Result<(Self, StreamInfo), Never> {
let info = StreamInfo {
sample_rate: NonZeroU32::new(RATE).unwrap(),
prev_sample_rate: NonZeroU32::new(RATE).unwrap(),
max_block_frames: NonZeroU32::new(BLOCK as u32).unwrap(),
num_stream_out_channels: 2,
..Default::default()
};
Ok((Offline { processor: None }, info))
}
fn set_processor(&mut self, processor: FirewheelProcessor<Self>) {
self.processor = Some(processor);
}
fn poll_status(&mut self) -> Result<(), Never> {
Ok(())
}
fn delay_from_last_process(&self, _process_timestamp: ()) -> Option<Duration> {
None
}
}
fn left(t: u64) -> f32 {
if (t / 32) % 2 == 0 { 0.5 } else { -0.5 }
}
fn right(t: u64) -> f32 {
(t % 50) as f32 / 100.0 - 0.25
}
#[derive(Clone)]
struct Known;
impl firewheel::node::AudioNode for Known {
type Configuration = firewheel::node::EmptyConfig;
fn info(&self, _config: &Self::Configuration) -> firewheel::node::AudioNodeInfo {
firewheel::node::AudioNodeInfo::new().debug_name("test_known_stereo").channel_config(
firewheel::channel_config::ChannelConfig {
num_inputs: firewheel::channel_config::ChannelCount::ZERO,
num_outputs: firewheel::channel_config::ChannelCount::STEREO,
},
)
}
fn construct_processor(
&self,
_config: &Self::Configuration,
_cx: firewheel::node::ConstructProcessorContext,
) -> impl firewheel::node::AudioNodeProcessor {
KnownProcessor { t: 0 }
}
}
struct KnownProcessor {
t: u64,
}
impl firewheel::node::AudioNodeProcessor for KnownProcessor {
fn process(
&mut self,
info: &firewheel::node::ProcInfo,
buffers: firewheel::node::ProcBuffers,
_events: &mut firewheel::event::ProcEvents,
_extra: &mut firewheel::node::ProcExtra,
) -> firewheel::node::ProcessStatus {
for i in 0..info.frames {
let t = self.t + i as u64;
buffers.outputs[0][i] = left(t);
buffers.outputs[1][i] = right(t);
}
self.t += info.frames as u64;
firewheel::node::ProcessStatus::OutputsModified
}
}
type Fw = FirewheelCtx<Offline>;
fn rec(id: NodeID, params: Params) -> NodeRec {
NodeRec::new(0, id, params)
}
fn splitter(fw: &mut Fw, n: u32) -> NodeRec {
let mut r = rec(fw.add_node(SplitterNode { n }, None), Params::Splitter(n));
r.lin = n;
r.lout = 1;
r
}
fn merger(fw: &mut Fw, n: u32, discrete: bool) -> NodeRec {
let d = ArcGc::new(AtomicBool::new(discrete));
let mut r = rec(fw.add_node(MergerNode { n, discrete: ArcGc::clone(&d) }, None), Params::Merger { n, discrete: d });
r.lout = n;
r
}
fn monitor(fw: &mut Fw, channels: u32) -> (NodeRec, ArcGc<MonitorRing>) {
let ring = ArcGc::new(MonitorRing::new());
ring.set_mix(&mixing::web_mix(channels, 1, Interp::Speakers));
let id = fw.add_node(MonitorNode { ring: ArcGc::clone(&ring), channels: 2 }, None);
let mut r = rec(id, Params::Analyser { ring: ArcGc::clone(&ring), smooth: Vec::new() });
r.lin = channels;
(r, ring)
}
fn wire(fw: &mut Fw, src: &NodeRec, output: u32, dst: &NodeRec, input: u32) {
match graph::plan(src, output, dst, input) {
mixing::Route::Ports(ports) => {
fw.connect(src.id, dst.id, &ports, true).unwrap_or_else(|e| panic!("connect {ports:?}: {e:?}"));
}
r => panic!("a stereo graph took a mixer: {r:?}"),
}
}
fn tap(fw: &mut Fw, src: &NodeRec, output: u32) -> ArcGc<MonitorRing> {
let channels = if matches!(src.params, Params::Splitter(_)) { 1 } else { src.lout };
let (m, ring) = monitor(fw, channels);
wire(fw, src, output, &m, 0);
ring
}
fn render(fw: &mut Fw, blocks: usize) {
let mut out = vec![0.0f32; BLOCK * 2];
for b in 0..blocks {
fw.update().expect("firewheel update");
let p = fw.active_backend_mut().unwrap().processor.as_mut().expect("the processor was handed over");
p.process_interleaved(
&[],
&mut out,
BackendProcessInfo {
num_in_channels: 0,
num_out_channels: 2,
frames: BLOCK,
process_timestamp: (),
duration_since_stream_start: Duration::from_secs_f64((b * BLOCK) as f64 / RATE as f64),
input_stream_status: StreamStatus::empty(),
output_stream_status: StreamStatus::empty(),
dropped_frames: 0,
},
);
}
}
fn assert_signal(ring: &MonitorRing, total: u64, what: &str, want: impl Fn(u64) -> f32) {
assert_eq!(ring.cursor.load(Ordering::Acquire) as u64, total, "{what}: the monitor missed frames");
let n = 1024usize;
let mut got = vec![0.0f32; n];
ring.read_latest(&mut got);
for (i, v) in got.iter().enumerate() {
let t = total - n as u64 + i as u64;
let w = want(t);
assert!((v - w).abs() < 1e-6, "{what}: sample {t} is {v}, want {w}");
}
}
#[test]
fn a_known_stereo_signal_splits_into_its_channels_and_merges_back() {
let mut fw = Fw::new(FirewheelConfig::default());
let src = rec(fw.add_node(Known, None), Params::Passthrough);
let split = splitter(&mut fw, 2);
wire(&mut fw, &src, 0, &split, 0);
let split_l = tap(&mut fw, &split, 0);
let split_r = tap(&mut fw, &split, 1);
let swap = merger(&mut fw, 2, false);
wire(&mut fw, &split, 0, &swap, 1);
wire(&mut fw, &split, 1, &swap, 0);
let split2 = splitter(&mut fw, 2);
wire(&mut fw, &swap, 0, &split2, 0);
let swapped_l = tap(&mut fw, &split2, 0);
let swapped_r = tap(&mut fw, &split2, 1);
let speakers = merger(&mut fw, 1, false);
wire(&mut fw, &src, 0, &speakers, 0);
let speakers_mix = tap(&mut fw, &speakers, 0);
let discrete = merger(&mut fw, 1, true);
wire(&mut fw, &src, 0, &discrete, 0);
let discrete_mix = tap(&mut fw, &discrete, 0);
let summed = merger(&mut fw, 1, false);
wire(&mut fw, &split, 0, &summed, 0);
wire(&mut fw, &split, 1, &summed, 0);
let sum = tap(&mut fw, &summed, 0);
let narrow = splitter(&mut fw, 1);
wire(&mut fw, &src, 0, &narrow, 0);
let narrow_0 = tap(&mut fw, &narrow, 0);
let half = merger(&mut fw, 2, false);
wire(&mut fw, &split, 1, &half, 1);
let split3 = splitter(&mut fw, 2);
wire(&mut fw, &half, 0, &split3, 0);
let half_0 = tap(&mut fw, &split3, 0);
let half_1 = tap(&mut fw, &split3, 1);
fw.start_stream(()).expect("the offline stream starts");
let blocks = 40;
render(&mut fw, blocks);
let total = (blocks * BLOCK) as u64;
assert_signal(&split_l, total, "splitter output 0", left);
assert_signal(&split_r, total, "splitter output 1", right);
assert_signal(&swapped_l, total, "merged back swapped, channel 0", right);
assert_signal(&swapped_r, total, "merged back swapped, channel 1", left);
assert_signal(&speakers_mix, total, "speakers down-mix", |t| 0.5 * (left(t) + right(t)));
assert_signal(&discrete_mix, total, "discrete down-mix", left);
assert_signal(&sum, total, "two connections into one input", |t| left(t) + right(t));
assert_signal(&narrow_0, total, "one-output splitter", left);
assert_signal(&half_0, total, "unconnected merger input", |_| 0.0);
assert_signal(&half_1, total, "connected merger input", right);
}
#[test]
fn merge_block_mixes_each_pair_and_reports_silence() {
let (a, b) = ([0.5f32, -0.5, 0.25], [0.25f32, 0.25, -0.75]);
let z = [0.0f32; 3];
let inputs: [&[f32]; 4] = [&a, &b, &z, &z];
let (mut o0, mut o1) = ([9.0f32; 3], [9.0f32; 3]);
let mut outputs: [&mut [f32]; 2] = [&mut o0, &mut o1];
let mask = merge_block(&inputs, &mut outputs, 3, |p| p >= 2, false);
assert_eq!(o0, [0.375, -0.125, -0.25]);
assert_eq!(o1, [0.0; 3]);
assert!(!mask.is_channel_silent(0) && mask.is_channel_silent(1));
let (mut d0, mut d1) = ([9.0f32; 3], [9.0f32; 3]);
let mut outputs: [&mut [f32]; 2] = [&mut d0, &mut d1];
merge_block(&inputs, &mut outputs, 3, |p| p >= 2, true);
assert_eq!(d0, a, "discrete keeps the left port");
}
fn ramp(frames: u64) -> Arc<PlanarBuffer> {
Arc::new(PlanarBuffer { data: vec![(0..frames).map(ramp_at).collect()], sample_rate: RATE })
}
fn ramp_at(frame: u64) -> f32 {
(frame + 1) as f32 / 8192.0
}
fn secs(frames: u64) -> f64 {
frames as f64 / RATE as f64
}
fn source(
fw: &mut Fw,
buffer: &Arc<PlanarBuffer>,
ctl: &Arc<SourceCtl>,
offset: f64,
duration: Option<f64>,
speed: f64,
) -> ArcGc<MonitorRing> {
let mut s = SamplerNode { speed, ..SamplerNode::default() };
let id = fw.add_node(s.clone(), Some(SamplerConfig::default()));
let baseline = s.clone();
arm_source(&mut s, Some(buffer), ctl, offset, duration);
let mut evs: Vec<NodeEventType> = Vec::new();
s.diff(&baseline, PathBuilder::default(), &mut evs);
for e in evs {
fw.queue_event_for(id, e);
}
let mut r = rec(id, Params::Sampler(Box::new(s)));
r.lout = 1;
tap(fw, &r, 0)
}
fn recorded(ring: &MonitorRing, total: usize) -> Vec<f32> {
assert!(total <= MONITOR_WINDOW);
assert_eq!(ring.cursor.load(Ordering::Acquire), total, "the monitor missed frames");
let mut got = vec![0.0f32; total];
ring.read_latest(&mut got);
got
}
#[test]
fn a_sprite_renders_only_its_slice_of_the_buffer() {
let mut fw = Fw::new(FirewheelConfig::default());
let atlas = ramp(4_000);
let ctl = Arc::new(SourceCtl::default());
let ring = source(&mut fw, &atlas, &ctl, secs(1_000), Some(secs(500)), 1.0);
fw.start_stream(()).expect("the offline stream starts");
let blocks = 16;
render(&mut fw, blocks);
let got = recorded(&ring, blocks * BLOCK);
for (t, &v) in got.iter().enumerate() {
let want = if t < 500 { ramp_at(1_000 + t as u64) } else { 0.0 };
assert!((v - want).abs() < 1e-6, "frame {t}: {v}, want {want} (buffer frame {})", v * 8192.0 - 1.0);
}
assert!(ctl.done.load(Ordering::Relaxed), "the walk did not report its end");
}
#[test]
fn a_sprite_at_another_playback_rate_still_stays_inside_its_slice() {
let mut fw = Fw::new(FirewheelConfig::default());
let atlas = ramp(4_000);
let ctl = Arc::new(SourceCtl::default());
let ring = source(&mut fw, &atlas, &ctl, secs(1_000), Some(secs(500)), 2.0);
fw.start_stream(()).expect("the offline stream starts");
let blocks = 16;
render(&mut fw, blocks);
let got = recorded(&ring, blocks * BLOCK);
let (lo, hi) = (ramp_at(1_000), ramp_at(1_499));
let mut last = 0;
for (t, &v) in got.iter().enumerate() {
if v != 0.0 {
assert!(v <= hi + 1e-6 && (v >= lo - 1e-6 || t >= 248), "frame {t}: {v} is outside the slice");
last = t;
}
}
assert!((245..=252).contains(&last), "the slice should last ~250 output frames, last sound at {last}");
}
#[test]
fn a_loop_region_loops_only_itself_after_the_lead_in() {
let mut fw = Fw::new(FirewheelConfig::default());
let atlas = ramp(4_000);
let ctl = Arc::new(SourceCtl::default());
ctl.looping.store(true, Ordering::Relaxed);
ctl.loop_start.store(secs(1_000).to_bits(), Ordering::Relaxed);
ctl.loop_end.store(secs(1_200).to_bits(), Ordering::Relaxed);
let ring = source(&mut fw, &atlas, &ctl, secs(900), None, 1.0);
fw.start_stream(()).expect("the offline stream starts");
let blocks = 24;
render(&mut fw, blocks);
let got = recorded(&ring, blocks * BLOCK);
for (t, &v) in got.iter().enumerate() {
let t = t as u64;
let frame = if t < 300 { 900 + t } else { 1_000 + (t - 300) % 200 };
let want = ramp_at(frame);
assert!((v - want).abs() < 1e-6, "frame {t}: {v}, want buffer frame {frame}");
}
assert!(!ctl.done.load(Ordering::Relaxed), "a loop without a duration never ends by itself");
}
}
#[cfg(test)]
mod source_walk_tests {
use super::*;
const RATE: u32 = 48_000;
fn ramp(frames: usize) -> Arc<PlanarBuffer> {
Arc::new(PlanarBuffer { data: vec![(0..frames).map(|i| (i + 1) as f32).collect()], sample_rate: RATE })
}
fn secs(frames: u64) -> f64 {
frames as f64 / RATE as f64
}
fn read(view: &SourceSample, v: u64, frames: usize) -> Vec<i64> {
let mut out = vec![f32::NAN; frames];
{
let mut bufs: [&mut [f32]; 1] = [&mut out];
view.fill_buffers(&mut bufs, 0..frames, v);
}
assert!(out.iter().all(|x| !x.is_nan()), "frames left unwritten: {out:?}");
out.iter().map(|&x| x as i64 - 1).collect()
}
fn looping(ctl: &SourceCtl, start: u64, end: u64) {
ctl.loop_start.store(secs(start).to_bits(), Ordering::Relaxed);
ctl.loop_end.store(secs(end).to_bits(), Ordering::Relaxed);
ctl.looping.store(true, Ordering::Relaxed);
}
#[test]
fn a_duration_counts_loop_iterations() {
let ctl = Arc::new(SourceCtl::default());
looping(&ctl, 10, 14);
let view = SourceSample::new(ramp(100), ctl.clone(), 8, 10);
assert_eq!(read(&view, 0, 10), [8, 9, 10, 11, 12, 13, 10, 11, 12, 13]);
assert!(ctl.done.load(Ordering::Relaxed));
}
#[test]
fn turning_loop_off_mid_play_runs_on_to_the_end_of_the_buffer() {
let ctl = Arc::new(SourceCtl::default());
looping(&ctl, 2, 4);
let view = SourceSample::new(ramp(8), ctl.clone(), 0, SourceSample::UNBOUNDED);
assert_eq!(read(&view, 0, 6), [0, 1, 2, 3, 2, 3]);
ctl.looping.store(false, Ordering::Relaxed);
assert_eq!(read(&view, 6, 8), [4, 5, 6, 7, -1, -1, -1, -1]);
assert!(ctl.done.load(Ordering::Relaxed));
}
#[test]
fn turning_loop_on_mid_play_loops_the_region_from_the_playhead() {
let ctl = Arc::new(SourceCtl::default());
let view = SourceSample::new(ramp(8), ctl.clone(), 0, SourceSample::UNBOUNDED);
assert_eq!(read(&view, 0, 3), [0, 1, 2]);
looping(&ctl, 2, 5);
assert_eq!(read(&view, 3, 6), [3, 4, 2, 3, 4, 2]);
assert!(!ctl.done.load(Ordering::Relaxed));
}
#[test]
fn an_offset_past_loop_end_begins_at_loop_start() {
let ctl = Arc::new(SourceCtl::default());
looping(&ctl, 2, 4);
let view = SourceSample::new(ramp(8), ctl.clone(), 6, SourceSample::UNBOUNDED);
assert_eq!(read(&view, 0, 5), [2, 3, 2, 3, 2]);
}
#[test]
fn a_region_that_is_not_a_forward_range_loops_the_whole_buffer() {
for (a, b) in [(0, 0), (5, 3)] {
let ctl = Arc::new(SourceCtl::default());
looping(&ctl, a, b);
let view = SourceSample::new(ramp(4), ctl.clone(), 1, SourceSample::UNBOUNDED);
assert_eq!(read(&view, 0, 7), [1, 2, 3, 0, 1, 2, 3], "loopStart {a}, loopEnd {b}");
}
}
#[test]
fn a_non_sequential_read_rederives_the_position() {
let ctl = Arc::new(SourceCtl::default());
let view = SourceSample::new(ramp(10), ctl, 3, SourceSample::UNBOUNDED);
assert_eq!(read(&view, 0, 4), [3, 4, 5, 6]);
assert_eq!(read(&view, 0, 2), [3, 4]);
assert_eq!(read(&view, 5, 2), [8, 9]);
}
#[test]
fn a_slice_ending_inside_a_block_is_silence_after_it() {
let ctl = Arc::new(SourceCtl::default());
let view = SourceSample::new(ramp(6), ctl.clone(), 3, SourceSample::UNBOUNDED);
assert_eq!(read(&view, 0, 5), [3, 4, 5, -1, -1]);
assert!(ctl.done.load(Ordering::Relaxed), "past the end without loop is the end");
}
}
#[cfg(test)]
mod timeline_tests {
use super::{Timeline, Tl};
fn tl(start: f64, evs: Vec<Tl>) -> Timeline {
Timeline { evs, start_v: start, start_t: 0.0 }
}
#[test]
fn a_ramp_with_nothing_before_it_starts_when_it_was_scheduled() {
let t = Timeline { evs: vec![Tl::Lin { t: 101.0, v: 0.0 }], start_v: 1.0, start_t: 100.0 };
assert_eq!(t.eval(100.0), (1.0, false));
assert!((t.eval(100.5).0 - 0.5).abs() < 1e-9);
assert_eq!(t.eval(101.0), (0.0, true));
}
#[test]
fn a_linear_ramp_is_linear() {
let t = tl(0.0, vec![Tl::Set { t: 0.0, v: 0.0 }, Tl::Lin { t: 1.0, v: 1.0 }]);
for (now, want) in [(0.0, 0.0), (0.25, 0.25), (0.5, 0.5), (0.75, 0.75)] {
let (v, done) = t.eval(now);
assert!((v - want).abs() < 1e-6, "at {now}: {v}, want {want}");
assert!(!done);
}
assert_eq!(t.eval(1.0), (1.0, true));
}
#[test]
fn an_exponential_ramp_is_exponential_and_not_a_line() {
let t = tl(0.001, vec![Tl::Set { t: 0.0, v: 0.001 }, Tl::Exp { t: 1.0, v: 1.0 }]);
let (v, _) = t.eval(0.5);
let want = 0.001f64 * (1.0f64 / 0.001).powf(0.5);
assert!((v - want).abs() < 1e-6, "midpoint {v}, want {want}");
assert!(v < 0.05, "an exponential ramp must not be halfway up at halfway: {v}");
assert!((t.eval(0.0).0 - 0.001).abs() < 1e-9);
assert_eq!(t.eval(1.0), (1.0, true));
}
#[test]
fn an_exponential_ramp_through_zero_degrades_to_linear_instead_of_nan() {
for (from, to) in [(0.0, 1.0), (1.0, 0.0), (-1.0, 1.0)] {
let t = tl(from, vec![Tl::Set { t: 0.0, v: from }, Tl::Exp { t: 1.0, v: to }]);
let (v, _) = t.eval(0.5);
assert!(v.is_finite(), "{from} → {to} produced {v}");
assert!((v - (from + (to - from) * 0.5)).abs() < 1e-6, "{from} → {to}: {v}");
}
}
#[test]
fn set_target_decays_toward_its_target_and_reports_done() {
let t = tl(1.0, vec![Tl::Target { t: 0.0, v: 0.0, tau: 0.1 }]);
let (early, done_early) = t.eval(0.05);
assert!(early > 0.5 && early < 1.0, "{early}");
assert!(!done_early);
let (late, done_late) = t.eval(2.0);
assert!(late.abs() < 1e-3, "{late}");
assert!(done_late, "a settled setTargetAtTime must retire its timeline");
}
#[test]
fn a_future_event_holds_the_current_value() {
let t = tl(0.25, vec![Tl::Set { t: 10.0, v: 1.0 }]);
assert_eq!(t.eval(0.0), (0.25, false));
}
}