diff --git a/src/distortion.rs b/src/distortion.rs index d292678..3b90335 100644 --- a/src/distortion.rs +++ b/src/distortion.rs @@ -26,13 +26,15 @@ pub struct DistortionParameters { /// ADAA2の群遅延。Dryとホストへの申告を同じ1サンプルに揃える。 pub const LATENCY: usize = 1; +#[cfg_attr(test, derive(Clone))] struct DistortionState { /// 過去2点のGain適用済み入力。Gain変更時も当時の値を維持する。 input: [[f64; 2]; 2], - /// 過去2点の原始関数。F2を保持する。 + /// Soft用の過去2点の原始関数。Clipper切替時にresetする。 integral: [[f64; 2]; 2], } +#[cfg_attr(test, derive(Clone))] pub struct Distortion { state: DistortionState, } @@ -66,7 +68,21 @@ impl Distortion { // ADAAの大きな計算経路を分離し、Noneの経路にレジスター退避を持ち込まない。 #[inline(never)] fn process_adaa_sample(&mut self, input: [f64; 2], gain: f64) -> [f64; 2] { + // 入力3点が左右で一致すれば、原始関数とADAA出力も同値になる。 + let mono = input[0] == input[1] + && self.state.input[0][0] == self.state.input[0][1] + && self.state.input[1][0] == self.state.input[1][1]; + let mut left = 0.0; std::array::from_fn(|ch| { + if ch == 1 && mono { + self.state.input[0][1] = self.state.input[0][0]; + self.state.input[1][1] = self.state.input[1][0]; + if SOFT { + self.state.integral[0][1] = self.state.integral[0][0]; + self.state.integral[1][1] = self.state.integral[1][0]; + } + return left; + } let x = input[ch] * gain; let previous = self.state.input[0][ch]; let values = if SOFT { soft::eval(x) } else { [0.0; 4] }; @@ -96,14 +112,18 @@ impl Distortion { }; self.state.input[1][ch] = previous; self.state.input[0][ch] = x; - self.state.integral[1][ch] = self.state.integral[0][ch]; - self.state.integral[0][ch] = integral; + if SOFT { + self.state.integral[1][ch] = self.state.integral[0][ch]; + self.state.integral[0][ch] = integral; + } + left = out; out }) } } -// 区分的な一次クリップ関数を三角形重みで厳密積分する。 +// 三角形分布の生存関数を[-1,1]で積分する。 +// 区間内の位置を正規化し、大きい入力同士の差引きと二乗のオーバーフローを避ける。 fn hard_second(a: f64, b: f64, c: f64) -> f64 { if a >= 1. { return 1.; @@ -112,39 +132,91 @@ fn hard_second(a: f64, b: f64, c: f64) -> f64 { return -1.; } if a >= -1. && c <= 1. { - return (a + b + c) / 3.; + return (a + b + c) * (1. / 3.); } - let span = c - a; - let integrate = |lo: f64, hi: f64, rising: bool| { - if hi == lo { - return 0.; - } - let mut sum = 0.; - let mut l = lo; - for r in [(-1.0_f64).clamp(lo, hi), 1.0_f64.clamp(lo, hi), hi] { - let d = r - l; - if d > 0. { - let mid = l + d * 0.5; - let val = mid.clamp(-1., 1.); - let slope = if l >= -1. && r <= 1. { 1. } else { 0. }; - let (weight, ws) = if rising { - (((l - lo) + d * 0.5) / (hi - lo), 1. / (hi - lo)) - } else { - (((hi - r) + d * 0.5) / (hi - lo), -1. / (hi - lo)) - }; - sum += d * (val * weight + slope * ws * d * d / 12.); - } - l = r; - } - sum - }; - 2. * (integrate(a, b, true) + integrate(b, c, false)) / span + let lo = a.max(-1.); + let hi = c.min(1.); + let mid = b.max(lo).min(hi); + let inverse_span = 1.0 / (c - a); + let mut out = lo; + // 区間端が異なっても、差分はFTZで0になり得る。 + let left_width = mid - lo; + if left_width > 0. { + let span = b - a; + let inverse_width = 1.0 / span; + let x = (lo - a) * inverse_width; + let y = (mid - a) * inverse_width; + out += left_width * (1.0 - (x * x + x * y + y * y) * (span * inverse_span) * (1.0 / 3.0)); + } + let right_width = hi - mid; + if right_width > 0. { + let span = c - b; + let inverse_width = 1.0 / span; + let x = (c - mid) * inverse_width; + let y = (c - hi) * inverse_width; + out += right_width * (x * x + x * y + y * y) * (span * inverse_span) * (1.0 / 3.0); + } + out } #[cfg(test)] mod tests { use super::*; #[test] + #[cfg(not(miri))] + fn subnormal_interval_with_normal_endpoints_remains_finite() { + let _mode = crate::float_mode::FloatMode::flush_subnormals(); + // 端点はnormalだが、差は3.12e-309でFTZによって0になる。 + // 定数畳み込みはFTZを考慮しないため、入力を実行時に読み出す。 + let (a, b, c) = std::hint::black_box(( + 5.655013176369847e-306, + 5.658134873944616e-306, + 1.2268606283216226, + )); + let expected = 0.40636791694234973; + assert!((hard_second(a, b, c) - expected).abs() < 1e-14); + assert!((hard_second(-c, -b, -a) + expected).abs() < 1e-14); + for (points, expected) in [ + ([-1e154, 0.0, 1e154], 0.0), + ([-1e154, -1e154, 1e154], -0.5), + ([-1e154, 1e154, 1e154], 0.5), + ] { + let [a, b, c] = std::hint::black_box(points); + assert!((hard_second(a, b, c) - expected).abs() < 1e-14); + } + } + #[test] + fn matching_channels_preserve_history_when_stereo_returns() { + let mut stereo = Distortion::new(); + let mut channels = [Distortion::new(), Distortion::new()]; + for n in 0..2000 { + let clipper = [ClipperType::Soft, ClipperType::Hard, ClipperType::None][n / 97 % 3]; + if n % 97 == 0 { + stereo.reset(); + for channel in &mut channels { + channel.reset(); + } + } + let left = (n as f64 * 0.37).sin(); + let right = if n % 29 < 15 { + (n as f64 * 0.51).cos() + } else { + left + }; + let input = [left, right]; + let parameters = DistortionParameters { + clipper, + gain: [1.0, 3.0, 251.188643150958][n / 11 % 3], + mix: 1.0, + }; + let actual = stereo.process_sample(input, ¶meters); + for ch in 0..2 { + let expected = channels[ch].process_sample([input[ch]; 2], ¶meters)[0]; + assert_eq!(actual[ch], expected, "sample={n}, ch={ch}, {clipper:?}"); + } + } + } + #[test] fn linear_response_gain_history_and_reset() { let mut d = Distortion::new(); let mut history = [0.0; 2]; diff --git a/src/envelope.rs b/src/envelope.rs index 9b48e6a..4758cdf 100644 --- a/src/envelope.rs +++ b/src/envelope.rs @@ -3,6 +3,11 @@ //! 単位に依存せず、0〜1の正規化値を操作する線形AHDSR。 +const RESET: u8 = 1; +const TRIGGER: u8 = 2; +const RELEASE: u8 = 4; +const GATE: u8 = 8; + /// エンベロープの時間と正規化値をまとめたパラメーター。 #[derive(Clone, Copy, Debug, PartialEq)] pub struct EnvelopeParameters { @@ -93,11 +98,28 @@ fn ramp(time: f64, duration: f64) -> f64 { (time / duration.abs()).min(1.0).max(0.0) } +/// 次の段境界まで適用する線形区間。HoldとSustainはConstantにまとめる。 +#[derive(Clone, Copy, PartialEq)] +enum Segment { + Constant, + Attack, + Decay, + Release, +} + /// エンベロープの独立した時間・再トリガー履歴。データだけを保持する。 #[derive(Clone, Copy)] struct EnvelopeState { /// 次サンプル時点の正規化値。再ノートオンの開始値に使う。 current_value: f64, + /// 現在の区間。線形区間の値は前回値へ加算せず、絶対時刻から求める。 + segment: Segment, + /// Decayのピーク、またはRelease開始時の値。元式と同じ演算順で保持する。 + segment_value: f64, + /// ノートオフ位置を現在のレートで換算したms。設定変更時に再計算する。 + release_start_ms: f64, + /// 次の段境界までのサンプル数。設定変更時の0は次回生成での再計算を表す。 + remaining: u64, /// 検証・値計算に使用した設定、レート、ピーク。変更時だけ再検証する。 input: Option<(EnvelopeParameters, f64, f64)>, /// 直近のノートオン時の値。attack中は固定する。 @@ -108,10 +130,8 @@ struct EnvelopeState { note_off_sample: Option, /// releaseが完了するまでtrue。値0のattack中も進行する。 active: bool, - /// 処理済みのノートオン世代。 - note_generation: u64, - /// 処理済みの即時停止世代。 - reset_generation: u64, + /// 次の生成時へ遅延するノート変更。Reset/Trigger/Release/Gateをビットで保持する。 + pending: u8, } /// 音量・カットオフで共用するAHDSR。時間管理も各インスタンスで独立する。 @@ -126,86 +146,157 @@ impl Envelope { Self { state: EnvelopeState { current_value: 0.0, + segment: Segment::Constant, + segment_value: 0.0, + release_start_ms: 0.0, + remaining: 0, input: None, start_value: 0.0, elapsed_samples: 0, note_off_sample: None, active: false, - note_generation: 0, - reset_generation: 0, + pending: 0, }, } } - /// ノート境界を反映し、現在サンプルの正規化値を生成する。 - /// peakは0〜1。生成後は同じ設定でupdate_sampleを呼ぶ。 - #[inline(always)] // 音量・Cutoffの毎サンプル呼び出しと周辺のレジスタ退避を省く。 - pub fn generate_sample( + /// 設定・レート・ピークを変更時に反映する。不正値では生成を止め、時間履歴を保つ。 + /// 値の再計算は次回生成へ遅らせ、同位置のNote Onは直前の音量から開始する。 + pub fn set_input( &mut self, parameters: &EnvelopeParameters, sample_rate: f64, - gate: bool, - note_generation: u64, - reset_generation: u64, peak: f64, - ) -> f64 { + ) -> bool { let input = (*parameters, sample_rate, peak); - let changed = self.state.input != Some(input); - if changed { - if !(parameters.is_valid() - & (0.0..=1.0).contains(&peak) - & sample_rate.is_finite() - & (sample_rate > 0.0)) - { - return 0.0; - } - self.state.input = Some(input); + if self.state.input == Some(input) { + return true; + } + self.state.remaining = 0; + if !(parameters.is_valid() + & (0.0..=1.0).contains(&peak) + & sample_rate.is_finite() + & (sample_rate > 0.0)) + { + self.state.input = None; + return false; } - let reset = reset_generation != self.state.reset_generation; + self.state.input = Some(input); + true + } + + /// 次サンプルで現在値からattackを開始する。同位置の複数通知は1回へまとめる。 + pub fn note_on(&mut self) { + self.state.pending |= TRIGGER | GATE; + } + + /// 次サンプルでreleaseを開始する。 + pub fn note_off(&mut self) { + self.state.pending = (self.state.pending | RELEASE) & !GATE; + } + + /// 次サンプルで即時消音する。同位置で後続するNote Onは0から開始する。 + pub fn stop(&mut self) { + self.state.pending = (self.state.pending | RESET) & !GATE; + } + + /// 設定済み入力から現在サンプルの正規化値を生成する。 + #[inline(always)] + pub fn generate_sample(&mut self) -> f64 { + if self.state.input.is_none() { + return 0.0; + } + if self.state.pending != 0 { + self.apply_note_change(); + } else if self.state.remaining == 0 { + self.refresh_value(); + } + self.state.current_value + } + + #[cold] + fn apply_note_change(&mut self) { + let pending = std::mem::take(&mut self.state.pending); + let reset = pending & RESET != 0; + let gate = pending & GATE != 0; if reset { self.state.active = false; self.state.current_value = 0.0; } - let triggered = note_generation != self.state.note_generation && (gate || !reset); + let triggered = pending & TRIGGER != 0 && (gate || !reset); if triggered { self.state.start_value = self.state.current_value; self.state.elapsed_samples = 0; self.state.note_off_sample = None; self.state.active = true; } - self.state.note_generation = note_generation; - self.state.reset_generation = reset_generation; let released = !gate && self.state.active && self.state.note_off_sample.is_none(); if released { self.state.note_off_sample = Some(self.state.elapsed_samples); } - // 同じ入力ならupdate_sampleが用意した現在値をそのまま使う。 - if changed || reset || triggered || released { - self.refresh_value(parameters, sample_rate, peak); + if reset || triggered || released || self.state.remaining == 0 { + self.refresh_value(); } - self.state.current_value } - /// 次サンプルへ進める。生成時と同じ有効な設定・サンプルレートを渡す。 - pub fn update_sample(&mut self, parameters: &EnvelopeParameters, sample_rate: f64, peak: f64) { - if self.state.active { + /// 設定済み入力を使って次サンプルへ進める。 + pub fn update_sample(&mut self) { + if self.state.active && self.state.input.is_some() { self.state.elapsed_samples = self.state.elapsed_samples.saturating_add(1); - self.refresh_value(parameters, sample_rate, peak); + if self.state.remaining > 1 { + self.state.remaining -= 1; + self.update_segment_sample(); + } else { + self.refresh_value(); + } } } + /// 元のvalue_validatedと同じ演算順で、現在段の1つのランプだけを求める。 + #[inline] + fn update_segment_sample(&mut self) { + if self.state.segment == Segment::Constant { + return; + } + let Some((parameters, sample_rate, peak)) = self.state.input else { + return; + }; + let time = self.state.elapsed_samples as f64 / sample_rate * 1000.0; + self.state.current_value = match self.state.segment { + Segment::Attack => { + let attack = ramp(time, parameters.attack_ms); + self.state.start_value * (1.0 - attack) + peak * attack + } + Segment::Decay => { + let decay = ramp( + time - parameters.attack_ms - parameters.hold_ms, + parameters.decay_ms, + ); + self.state.segment_value * ((1.0 - decay) + parameters.sustain * decay) + } + Segment::Release => { + self.state.segment_value + * (1.0 - ramp(time - self.state.release_start_ms, parameters.release_ms)) + } + Segment::Constant => self.state.current_value, + }; + } + pub fn is_active(&self) -> bool { self.state.active } - fn refresh_value(&mut self, parameters: &EnvelopeParameters, sample_rate: f64, peak: f64) { + fn refresh_value(&mut self) { + let Some((parameters, sample_rate, peak)) = self.state.input else { + return; + }; self.state.active &= !self.state.note_off_sample.is_some_and(|off| { (self.state.elapsed_samples - off) as f64 >= (parameters.release_ms * sample_rate / 1000.0).ceil() }); self.state.current_value = if self.state.active { value_validated( - parameters, + ¶meters, self.state.elapsed_samples as f64 / sample_rate * 1000.0, self.state .note_off_sample @@ -216,6 +307,49 @@ impl Envelope { } else { 0.0 }; + if !self.state.active { + self.state.remaining = u64::MAX; + return; + } + let time = self.state.elapsed_samples as f64 / sample_rate * 1000.0; + let decay_start = parameters.attack_ms + parameters.hold_ms; + let decay_end = decay_start + parameters.decay_ms; + let sample_at = |ms: f64| (ms * sample_rate / 1000.0).ceil() as u64; + let (segment, value, boundary) = if let Some(off) = self.state.note_off_sample { + let off_ms = off as f64 / sample_rate * 1000.0; + let start = value_validated(¶meters, off_ms, None, self.state.start_value, peak); + self.state.release_start_ms = off_ms; + ( + Segment::Release, + start, + off.saturating_add(sample_at(parameters.release_ms)), + ) + } else if time < parameters.attack_ms { + (Segment::Attack, 0.0, sample_at(parameters.attack_ms)) + } else if time < decay_start { + (Segment::Constant, 0.0, sample_at(decay_start)) + } else if time < decay_end { + ( + Segment::Decay, + self.state.start_value * 0.0 + peak, + sample_at(decay_end), + ) + } else { + // 正の極小Decayが終了時刻の加算で消えても、境界サンプルのピークを保持し続けない。 + let boundary = if self.state.current_value == peak * parameters.sustain { + u64::MAX + } else { + self.state.elapsed_samples.saturating_add(1) + }; + (Segment::Constant, 0.0, boundary) + }; + self.state.segment = segment; + self.state.segment_value = value; + // ms→sampleとsample→msの丸めが境界の両側へ分かれる場合も、 + // 境界直前から元式で判定し、0ms段階の切替を遅らせない。 + self.state.remaining = boundary + .saturating_sub(1) + .saturating_sub(self.state.elapsed_samples); } } @@ -239,6 +373,36 @@ mod tests { ); } + #[test] + fn fractional_sample_rate_preserves_zero_decay_boundary() { + let rate = 44100.5; + let parameters = EnvelopeParameters { + attack_ms: 100.0 * 1000.0 / rate, + hold_ms: 0.0, + decay_ms: 0.0, + sustain: 0.31, + release_ms: 0.0, + }; + let mut envelope = Envelope::new(); + envelope.set_input(¶meters, rate, 0.7); + envelope.note_on(); + for sample in 0..104 { + let actual = envelope.generate_sample(); + let expected = value( + ¶meters, + f64::from(sample) / rate * 1000.0, + None, + 0.0, + 0.7, + ); + assert!( + (actual - expected).abs() < 1e-12, + "sample={sample}: {actual} != {expected}" + ); + envelope.update_sample(); + } + } + #[test] fn linear_stages_and_boundaries() { for (time, expected) in [ @@ -404,6 +568,92 @@ mod tests { assert_eq!(value(&p, p.attack_ms, None, 0.25, 1.0), 1.0); } + #[test] + fn tiny_positive_decay_does_not_hold_the_peak_past_the_boundary() { + for rate in [1000.0, 44_100.0, 48_000.0, 96_000.0] { + for decay_ms in [f64::from_bits(1), 1e-14] { + let p = EnvelopeParameters { + decay_ms, + ..PARAMETERS + }; + let mut envelope = Envelope::new(); + envelope.set_input(&p, rate, 1.0); + envelope.note_on(); + for sample in 0..(rate as u32 / 5) { + let time = f64::from(sample) / rate * 1000.0; + let actual = envelope.generate_sample(); + assert!((actual - value(&p, time, None, 0.0, 1.0)).abs() < 1e-11); + envelope.update_sample(); + } + } + } + } + + #[test] + fn linear_updates_follow_exact_formula_across_fractional_boundaries() { + for rate in [44_100.0, 96_000.0] { + for off in [0, 81, 6789] { + let p = EnvelopeParameters { + attack_ms: 10.125, + hold_ms: 2.0625, + decay_ms: 19.125, + sustain: 0.3, + release_ms: 43.333, + }; + let mut envelope = Envelope::new(); + envelope.set_input(&p, rate, 0.8); + envelope.note_on(); + for sample in 0..12_000 { + let time = f64::from(sample) / rate * 1000.0; + let off_ms = (sample >= off).then_some(f64::from(off) / rate * 1000.0); + let expected = value(&p, time, off_ms, 0.0, 0.8); + if sample == off { + envelope.note_off(); + } + let actual = envelope.generate_sample(); + assert!((actual - expected).abs() < 1e-11); + envelope.update_sample(); + } + } + } + } + + #[test] + fn simultaneous_stop_and_note_order_preserves_attack_and_release() { + for reset_first in [false, true] { + let mut envelope = Envelope::new(); + envelope.set_input(&PARAMETERS, 1000.0, 1.0); + if reset_first { + envelope.stop(); + envelope.note_on(); + } else { + envelope.note_on(); + envelope.stop(); + } + assert_eq!(envelope.generate_sample(), 0.0); + assert_eq!(envelope.is_active(), reset_first); + envelope.update_sample(); + assert_eq!( + envelope.generate_sample(), + if reset_first { 0.01 } else { 0.0 } + ); + } + let mut envelope = Envelope::new(); + let parameters = EnvelopeParameters { + attack_ms: 0.0, + ..PARAMETERS + }; + envelope.set_input(¶meters, 1000.0, 1.0); + envelope.note_on(); + envelope.note_off(); + assert_eq!(envelope.generate_sample(), 1.0); + envelope.update_sample(); + assert_eq!(envelope.generate_sample(), 0.99); + let mut unchanged = envelope; + envelope.note_off(); + assert_eq!(envelope.generate_sample(), unchanged.generate_sample()); + } + #[test] fn cached_value_tracks_parameters_rate_peak_and_note_boundaries() { let mut envelope = Envelope::new(); @@ -414,37 +664,39 @@ mod tests { sustain: 0.5, release_ms: 10.0, }; - assert_eq!(envelope.generate_sample(&p, 1000.0, true, 1, 0, 1.0), 0.0); - envelope.update_sample(&p, 1000.0, 1.0); - assert_eq!(envelope.generate_sample(&p, 1000.0, true, 1, 0, 1.0), 0.1); + assert!(envelope.set_input(&p, 1000.0, 1.0)); + envelope.note_on(); + assert_eq!(envelope.generate_sample(), 0.0); + envelope.update_sample(); + assert_eq!(envelope.generate_sample(), 0.1); p.attack_ms = 20.0; - assert_eq!(envelope.generate_sample(&p, 1000.0, true, 1, 0, 1.0), 0.05); - envelope.update_sample(&p, 1000.0, 1.0); - assert_eq!(envelope.generate_sample(&p, 1000.0, true, 1, 0, 0.5), 0.05); - assert_eq!(envelope.generate_sample(&p, 2000.0, true, 1, 0, 0.5), 0.025); + envelope.set_input(&p, 1000.0, 1.0); + assert_eq!(envelope.generate_sample(), 0.05); + envelope.update_sample(); + envelope.set_input(&p, 1000.0, 0.5); + assert_eq!(envelope.generate_sample(), 0.05); + envelope.set_input(&p, 2000.0, 0.5); + assert_eq!(envelope.generate_sample(), 0.025); let invalid = EnvelopeParameters { attack_ms: f64::NAN, ..p }; - assert_eq!( - envelope.generate_sample(&invalid, 2000.0, false, 2, 1, 0.5), - 0.0 - ); - assert_eq!( - envelope.generate_sample(&p, 2000.0, false, 1, 0, 0.5), - 0.025 - ); - envelope.update_sample(&p, 2000.0, 0.5); - let released = envelope.generate_sample(&p, 2000.0, false, 1, 0, 0.5); + assert!(!envelope.set_input(&invalid, 2000.0, 0.5)); + assert_eq!(envelope.generate_sample(), 0.0); + envelope.note_off(); + envelope.set_input(&p, 2000.0, 0.5); + assert_eq!(envelope.generate_sample(), 0.025); + envelope.update_sample(); + let released = envelope.generate_sample(); assert!((released - 0.02375).abs() < 1e-15); - assert_eq!( - envelope.generate_sample(&p, 2000.0, true, 2, 0, 0.75), - released - ); - envelope.update_sample(&p, 2000.0, 0.75); + envelope.set_input(&p, 2000.0, 0.75); + envelope.note_on(); + assert_eq!(envelope.generate_sample(), released); + envelope.update_sample(); let expected = released * 0.975 + 0.75 * 0.025; - assert!((envelope.generate_sample(&p, 2000.0, true, 2, 0, 0.75) - expected).abs() < 1e-15); - assert_eq!(envelope.generate_sample(&p, 2000.0, false, 2, 1, 0.75), 0.0); + assert!((envelope.generate_sample() - expected).abs() < 1e-15); + envelope.stop(); + assert_eq!(envelope.generate_sample(), 0.0); assert!(!envelope.is_active()); } } diff --git a/src/filter.rs b/src/filter.rs index bf411ea..5a5052c 100644 --- a/src/filter.rs +++ b/src/filter.rs @@ -43,6 +43,7 @@ impl FilterParameters { } /// 同一サンプル・同一の積分器状態から得た3種類の出力。 +#[allow(dead_code)] // 単体SVFの入口で使用する。音源のFilterはステレオ出力を使う。 #[derive(Default)] pub struct SvfOutput { /// 低域通過出力。 @@ -53,6 +54,16 @@ pub struct SvfOutput { pub high: f64, } +/// 左右の独立した積分器から同時に得た3種類の出力。 +struct StereoSvfOutput { + /// 左右の低域通過出力。 + low: [f64; 2], + /// 左右の帯域通過出力。 + band: [f64; 2], + /// 左右の高域通過出力。 + high: [f64; 2], +} + /// 同じHz・Q・レートで共用できる係数。積分器の状態は含まない。 #[derive(Clone, Copy)] struct SvfCoefficients { @@ -66,6 +77,7 @@ struct SvfCoefficients { /// 1段のTPT SVF。フィルタタイプ・多段化・ノートを扱わない。 #[derive(Default)] +#[cfg_attr(test, derive(Clone))] pub struct SvfState { /// 台形積分器の履歴。[帯域通過側, 低域通過側]。設定変更時も保持する。 integrators: [f64; 2], @@ -75,6 +87,7 @@ pub struct SvfState { /// TPT SVFの処理。Stateは積分器の履歴と計算済み係数を保持する。 #[derive(Default)] +#[cfg_attr(test, derive(Clone))] pub struct Svf { /// この段の積分器の状態。 state: SvfState, @@ -161,6 +174,59 @@ impl Svf { self.state.integrators = next; SvfOutput { low, band, high } } + /// 左右独立の履歴へ同じ係数を適用し、3種類のステレオ出力を返す。 + #[inline(always)] + fn process_stereo_prepared_sample( + &mut self, + right: &mut Self, + samples: [f64; 2], + coefficients: SvfCoefficients, + ) -> StereoSvfOutput { + // SAFETY: 対応先x86_64はSSE2を備える。読み書きは各2要素配列の範囲内。 + unsafe { + use std::arch::x86_64::*; + let left = self.state.integrators; + let right_values = right.state.integrators; + let s1 = _mm_set_pd(right_values[0], left[0]); + let s2 = _mm_set_pd(right_values[1], left[1]); + let sample = _mm_loadu_pd(samples.as_ptr()); + let g = _mm_set1_pd(coefficients.g); + let high = _mm_mul_pd( + _mm_sub_pd( + _mm_sub_pd( + sample, + _mm_mul_pd(_mm_set1_pd(coefficients.damping_plus_g), s1), + ), + s2, + ), + _mm_set1_pd(coefficients.inverse_denominator), + ); + let band = _mm_add_pd(s1, _mm_mul_pd(g, high)); + let low = _mm_add_pd(s2, _mm_mul_pd(g, band)); + let two = _mm_set1_pd(2.0); + let a = _mm_sub_pd(_mm_mul_pd(two, band), s1); + let b = _mm_sub_pd(_mm_mul_pd(two, low), s2); + let sign = _mm_set1_pd(-0.0); + let max = _mm_set1_pd(f64::MAX); + let finite = _mm_and_pd( + _mm_cmple_pd(_mm_andnot_pd(sign, a), max), + _mm_cmple_pd(_mm_andnot_pd(sign, b), max), + ); + let a = _mm_and_pd(a, finite); + let b = _mm_and_pd(b, finite); + _mm_storeu_pd(self.state.integrators.as_mut_ptr(), _mm_unpacklo_pd(a, b)); + _mm_storeu_pd(right.state.integrators.as_mut_ptr(), _mm_unpackhi_pd(a, b)); + let mut output = StereoSvfOutput { + low: [0.0; 2], + band: [0.0; 2], + high: [0.0; 2], + }; + _mm_storeu_pd(output.low.as_mut_ptr(), _mm_and_pd(low, finite)); + _mm_storeu_pd(output.band.as_mut_ptr(), _mm_and_pd(band, finite)); + _mm_storeu_pd(output.high.as_mut_ptr(), _mm_and_pd(high, finite)); + output + } + } } fn valid_input(sample: f64, parameters: &FilterParameters, sample_rate: f64) -> bool { @@ -171,12 +237,14 @@ fn valid_input(sample: f64, parameters: &FilterParameters, sample_rate: f64) -> } /// SVFの外側で出力を選択し、必要な段数だけ直列接続するコンポーネント。 +#[cfg_attr(test, derive(Clone))] pub struct FilterState { /// [左右][段]のSVF。左右の履歴を独立させ、未使用の段は消去する。 stages: [[Svf; 2]; 2], } /// Filterの処理を担当し、専用のStateを所有するコンポーネント。 +#[cfg_attr(test, derive(Clone))] pub struct Filter { /// このコンポーネントの内部状態。 state: FilterState, @@ -198,7 +266,7 @@ impl Filter { } } - #[inline] + #[inline(always)] pub fn process_sample( &mut self, samples: [f64; 2], @@ -207,7 +275,12 @@ impl Filter { sample_rate: f64, ) -> [f64; 2] { if matches!(filter_type, FilterType::None) { - self.reset(); + // 履歴を進める前には必ず先頭SVFで係数を準備する。 + // 初回バイパスで両方を消去すれば、以降のゼロ書込みは不要。 + if self.state.stages[0][0].state.coefficients.is_some() { + self.reset(); + self.state.stages[0][0].state.coefficients = None; + } return samples; } if !(valid_input(samples[0], parameters, sample_rate) & samples[1].is_finite()) { @@ -233,12 +306,29 @@ impl Filter { } // 左右・両段で係数を共用し、積分器の履歴だけ独立させる。 let coefficients = self.state.stages[0][0].prepare_coefficients(parameters, sample_rate); + match output_index { + 0 => self.process_selected_sample::<0>(samples, coefficients, count), + 1 => self.process_selected_sample::<1>(samples, coefficients, count), + _ => self.process_selected_sample::<2>(samples, coefficients, count), + } + } + + #[inline(always)] + fn process_selected_sample( + &mut self, + samples: [f64; 2], + coefficients: SvfCoefficients, + count: usize, + ) -> [f64; 2] { let mut output = samples; - for (sample, channel) in output.iter_mut().zip(&mut self.state.stages) { - for stage in &mut channel[..count] { - let result = stage.process_prepared_sample(*sample, coefficients); - *sample = [result.low, result.high, result.band][output_index]; - } + let (left, right) = self.state.stages.split_at_mut(1); + for stage in 0..count { + let result = left[0][stage].process_stereo_prepared_sample( + &mut right[0][stage], + output, + coefficients, + ); + output = [result.low, result.high, result.band][OUTPUT]; } output } diff --git a/src/oscillator/adaa.rs b/src/oscillator/adaa.rs index aa85a91..7da3ec1 100644 --- a/src/oscillator/adaa.rs +++ b/src/oscillator/adaa.rs @@ -21,9 +21,9 @@ static SECOND: &[u8] = include_bytes!("f2.bin"); #[derive(Clone, Copy)] pub(super) struct Bank { /// Richer band selected from the unmodulated frequency. - hi: Table, + hi: &'static Table, /// Adjacent band used while removing the highest harmonics. - lo: Table, + lo: &'static Table, /// Crossfade toward the adjacent band. mix: f64, /// Fundamental fade immediately below Nyquist. @@ -31,7 +31,7 @@ pub(super) struct Bank { } impl Bank { pub fn new(w: super::Waveform, inc: f64) -> Self { - let ts: &[Table] = match w { + let ts: &'static [Table] = match w { super::Waveform::Sine => &tables::SINE, super::Waveform::Triangle => &tables::TRIANGLE, super::Waveform::Square => &tables::SQUARE, @@ -48,8 +48,8 @@ impl Bank { ((inc * ts[idx].h * 2. - 0.9) * 10.).clamp(0., 1.) }; Self { - hi: ts[idx], - lo: ts[idx.saturating_sub(1)], + hi: &ts[idx], + lo: &ts[idx.saturating_sub(1)], mix: if idx == 0 { 0. } else { mix }, gain: if idx == 0 && w != super::Waveform::Sine { 1. - mix @@ -68,7 +68,7 @@ impl Bank { } }) } - fn blend(self, f: impl Fn(Table) -> f64) -> f64 { + fn blend(self, f: impl Fn(&Table) -> f64) -> f64 { let v = f(self.hi); self.gain * if self.mix == 0. { diff --git a/src/oscillator/wavetable.rs b/src/oscillator/wavetable.rs index 5c3590d..4afa136 100644 --- a/src/oscillator/wavetable.rs +++ b/src/oscillator/wavetable.rs @@ -46,8 +46,9 @@ fn tables(wave: Waveform) -> &'static [Table] { /// 周波数・波形変更時に選ぶ読出し設定。OscillatorStateがユニゾンごとに保持する。 #[derive(Clone, Copy)] pub(super) struct Selection { - /// 高域側の倍音を多く含むテーブルの番号。 - index: usize, + /// 周波数変更時に選ぶ倍音の多い帯域と、その隣の帯域。 + hi: &'static Table, + lo: &'static Table, /// 直前の帯域(倍音の少ないテーブル)への混合率。 mix: f64, /// Nyquist直前で基音を0へ下げる倍率。他の帯域は1。 @@ -56,7 +57,8 @@ pub(super) struct Selection { impl Selection { pub const EMPTY: Self = Self { - index: 0, + hi: &data::SAW[0], + lo: &data::SAW[0], mix: 0.0, gain: 0.0, }; @@ -78,7 +80,12 @@ impl Selection { let mix = ((increment * rich.harmonic * 2.0 - 0.9) * 10.0).clamp(0.0, 1.0); let gain = if index == 0 { 1.0 - mix } else { 1.0 }; let mix = if index == 0 { 0.0 } else { mix }; - Self { index, mix, gain } + Self { + hi: rich, + lo: &tables[index.saturating_sub(1)], + mix, + gain, + } } /// phaseは発振器の保持位相または変調後の、有限の[0,1]。 @@ -90,10 +97,9 @@ impl Selection { } else { 0.25 - (half - 0.25).abs() }; - let tables = tables(wave); - let mut value = tables[self.index].read_sample(folded); + let mut value = self.hi.read_sample(folded); if self.mix != 0.0 { - value += (tables[self.index - 1].read_sample(folded) - value) * self.mix; + value += (self.lo.read_sample(folded) - value) * self.mix; } value * (self.gain.copysign(0.5 - phase)) } @@ -111,9 +117,8 @@ mod tests { let reference = tables(wave) .partition_point(|t| t.harmonic * increment < 0.5) .saturating_sub(1); - assert_eq!( - Selection::new(wave, increment).index, - reference, + assert!( + std::ptr::eq(Selection::new(wave, increment).hi, &tables(wave)[reference]), "increment={increment:?}" ); }; diff --git a/src/oscillator.rs b/src/oscillator.rs index 17ae160..fe0e098 100644 --- a/src/oscillator.rs +++ b/src/oscillator.rs @@ -168,18 +168,18 @@ pub struct OscillatorState { bank: [adaa::Bank; 7], /// 履歴を連続使用できるか。ノート・波形・発音数変更時に破棄する。 valid: bool, - /// 履歴に有効なユニゾン数。未使用スロットの再利用を検出する。 - history_count: usize, + /// 定常入力から求めた実ユニゾン数。未使用スロットの再利用も検出する。 + rendered_count: usize, /// Note On時だけ進める位相用乱数。ノイズ用とは独立した状態を持つ。 random: Random, /// ノイズ専用xoshiro256+の状態。各ユニゾンに連続する別の値を割り当てる。 noise: Random, /// サンプル処理へ反映済みのNote On世代番号。 note_generation: u64, - /// 周波数倍率の計算に使った(ユニゾン数, Detune)。Noneは未計算。 - unison_input: Option<(u32, f64)>, - /// 位相増分・帯域選択の計算に使った(基音Hz, サンプルレート, 波形)。 - frequency_input: Option<(f64, f64, Waveform)>, + /// 周波数倍率の計算に使った(ユニゾン数, Detune)。初期値の0音は未計算を表す。 + unison_input: (u32, f64), + /// 位相増分・帯域選択の計算に使った(基音Hz, サンプルレート, 波形)。初期レート0は未計算。 + frequency_input: (f64, f64, Waveform), /// 各ユニゾンの帯域とクロスフェード係数。 bands: [wavetable::Selection; 7], /// 各ユニゾンの基音に対する周波数倍率。入力の音程幅が変わったときだけ更新する。 @@ -197,6 +197,7 @@ pub struct OscillatorSample { } /// Oscillatorの処理を担当し、専用のStateを所有するコンポーネント。 +#[cfg_attr(test, derive(Clone))] pub struct Oscillator { /// このコンポーネントの内部状態。 state: OscillatorState, @@ -210,12 +211,12 @@ impl Oscillator { history: [[0.; 2]; 7], bank: [adaa::Bank::new(Waveform::Sine, 0.); 7], valid: false, - history_count: 0, + rendered_count: 0, random: Random::new(), noise: Random::new(), note_generation: 0, - unison_input: None, - frequency_input: None, + unison_input: (0, 0.0), + frequency_input: (0.0, 0.0, Waveform::Sine), bands: [wavetable::Selection::EMPTY; 7], frequency_ratios: [1.0; 7], phase_increments: [0.0; 7], @@ -225,11 +226,28 @@ impl Oscillator { /// 現在の入力・状態でサンプルを生成し、その後で次のサンプルに向けて状態を更新する。 /// sample_rateは処理環境のサンプルレート(Hz)。不正な入力・レートでは無音を返し、状態を保持する。 + #[allow(dead_code)] // 単体ベンチマークが使う、入力検証付きの入口。 #[inline] pub fn generate_sample( &mut self, input: &OscillatorInput, sample_rate: f64, + ) -> OscillatorSample { + self.generate_optional_sample::(input, sample_rate) + } + + /// 音声・変調のどちらにも使わないサンプルの状態だけを更新する。 + #[cfg(test)] + #[inline] + pub fn advance_sample(&mut self, input: &OscillatorInput, sample_rate: f64) { + self.generate_optional_sample::(input, sample_rate); + } + + #[inline] + fn generate_optional_sample( + &mut self, + input: &OscillatorInput, + sample_rate: f64, ) -> OscillatorSample { if !(input.is_valid() & (sample_rate <= f64::MAX) & (sample_rate > 0.0)) { return OscillatorSample { @@ -237,6 +255,23 @@ impl Oscillator { count: 0, }; } + // SAFETY: 上の検証で入力とレートの全条件を満たすことを確認した。 + unsafe { self.generate_validated_sample::(input, sample_rate) } + } + + /// Voice内で検証済みの定常入力とレートから、生成と状態更新を行う。 + /// OUTPUT=falseは状態だけを更新する。 + /// + /// # Safety + /// input.is_valid()がtrue、sample_rateが有限の正数であること。 + /// 後段の高速整数変換と固定長配列の処理はこの範囲を前提とする。 + #[inline] + pub(super) unsafe fn generate_validated_sample( + &mut self, + input: &OscillatorInput, + sample_rate: f64, + ) -> OscillatorSample { + debug_assert!(input.is_valid() && sample_rate.is_finite() && sample_rate > 0.0); // ノート境界と位相モードを反映して生成した後、次サンプルへ進める。 // キャッシュを含むState全体のサンプルごとのコピーは行わない。 if input.note_generation != self.state.note_generation && input.active { @@ -252,56 +287,83 @@ impl Oscillator { } } self.state.note_generation = input.note_generation; - // activeはVoiceの共通AHDSRから渡す。無音のattack中も位相を進める。 + if input.active { + self.refresh_frequency(input, sample_rate); + } + // SAFETY: 上で同じ定常入力のノート境界と周波数を反映した。 + unsafe { self.generate_prepared_sample::(input) } + } + + /// 区間の先頭で反映した定常入力から1サンプルを生成する。 + /// + /// # Safety + /// 直前のgenerate_validated_sampleとwaveform・frequency_hz・unison_voices・ + /// detune_cents・note_generation・phase_mode・phase_modulatedが同じこと。 + /// activeがfalseからtrueへ変わる場合は、改めてvalidated入口で準備すること。 + /// phase_modulationは変化してよいが、有限のi32範囲内であること。 + #[inline] + pub(super) unsafe fn generate_prepared_sample( + &mut self, + input: &OscillatorInput, + ) -> OscillatorSample { + debug_assert!(input.is_valid()); if !input.active { self.state.valid = false; return OscillatorSample { - values: [0.0; 7], + values: [0.; 7], count: 0, }; } - self.refresh_frequency(input, sample_rate); - let sample = self.generate_waveform_sample(input); - self.update_sample(input); + let sample = self.generate_waveform_sample::(input); + self.update_sample(); sample } /// 位相変調は読出し位置だけへ適用する。Noiseはユニゾンごとに乱数を一つ進める。 - #[inline] - fn generate_waveform_sample(&mut self, input: &OscillatorInput) -> OscillatorSample { + #[inline(always)] + fn generate_waveform_sample( + &mut self, + input: &OscillatorInput, + ) -> OscillatorSample { match input.waveform { Waveform::Noise => { self.state.valid = false; - let count = input.rendered_voices(); + let count = self.state.rendered_count; let mut values = [0.0; 7]; for value in &mut values[..count] { *value = 2.0 * self.state.noise.next_f64() - 1.0; } OscillatorSample { values, count } } - Waveform::Sine => self.generate_periodic_sample::(input), - _ => self.generate_bandlimited_sample(input), + Waveform::Sine => self.generate_periodic_sample::(input), + _ => self.generate_bandlimited_sample::(input), } } // 帯域別のループを分離してSine/Noiseを小さく保ち、ユニゾンごとの関数呼出しを省く。 #[inline(never)] - fn generate_bandlimited_sample(&mut self, input: &OscillatorInput) -> OscillatorSample { - self.generate_periodic_sample::(input) + fn generate_bandlimited_sample( + &mut self, + input: &OscillatorInput, + ) -> OscillatorSample { + self.generate_periodic_sample::(input) } /// 波形別に展開する周期波の読出し。位相変調の処理は両経路で共通にする。 #[inline(always)] - fn generate_periodic_sample( + fn generate_periodic_sample( &mut self, input: &OscillatorInput, ) -> OscillatorSample { - let count = input.rendered_voices(); + let count = self.state.rendered_count; let mut values = [0.0; 7]; if input.phase_modulated { - return self.generate_antialiased_sample(input); + return self.generate_antialiased_sample::(input); } self.state.valid = false; + if !OUTPUT { + return OscillatorSample { values, count }; + } // 整数周期を先に除き、±1/±2回転では元の位相を厳密に保持する。 // SAFETY: generate_sampleで位相変調が有限のi32範囲であることを検証済み。 let cycles = unsafe { input.phase_modulation.to_int_unchecked::() }; @@ -338,13 +400,12 @@ impl Oscillator { } #[inline(never)] - fn generate_antialiased_sample(&mut self, input: &OscillatorInput) -> OscillatorSample { - let count = input.rendered_voices(); + fn generate_antialiased_sample( + &mut self, + input: &OscillatorInput, + ) -> OscillatorSample { + let count = self.state.rendered_count; let mut values = [0.; 7]; - if self.state.history_count != count { - self.state.valid = false; - self.state.history_count = count; - } for (k, value) in values[..count].iter_mut().enumerate() { let phase = self.state.phases[k]; let q = phase + input.phase_modulation; @@ -354,7 +415,9 @@ impl Oscillator { } else { [q - inc, q - 2. * inc] }; - *value = self.state.bank[k].generate_sample(q, b, c); + if OUTPUT { + *value = self.state.bank[k].generate_sample(q, b, c); + } // 次サンプルで保持位相が巻き戻る量を履歴にも適用する。 // 変調量は折り返さず、周期を跨ぐ差商の距離を保持する。 let wrap = f64::from((phase + inc >= 1.) as u8); @@ -377,21 +440,22 @@ impl Oscillator { #[inline] fn refresh_frequency(&mut self, input: &OscillatorInput, sample_rate: f64) { let unison = (input.unison_voices, input.detune_cents); - let changed = self.state.unison_input != Some(unison); - let count = input.rendered_voices(); + let changed = self.state.unison_input != unison; if changed { + let count = input.rendered_voices(); + if self.state.rendered_count != count { + self.state.valid = false; + self.state.rendered_count = count; + } for (k, ratio) in self.state.frequency_ratios[..count].iter_mut().enumerate() { *ratio = input.frequency_ratio(k); } - self.state.unison_input = Some(unison); + self.state.unison_input = unison; } + let count = self.state.rendered_count; let frequency = (input.frequency_hz, sample_rate, input.waveform); - if changed || self.state.frequency_input != Some(frequency) { - if self - .state - .frequency_input - .is_some_and(|old| old.2 != input.waveform) - { + if changed || self.state.frequency_input != frequency { + if self.state.frequency_input.2 != input.waveform { self.state.valid = false; } for (k, (increment, ratio)) in self.state.phase_increments[..count] @@ -418,14 +482,14 @@ impl Oscillator { hz % sample_rate } / sample_rate; } - self.state.frequency_input = Some(frequency); + self.state.frequency_input = frequency; } } /// 発音中のサンプル生成後に、定常入力を用いて内部状態を1サンプル分進める。 - fn update_sample(&mut self, input: &OscillatorInput) { + fn update_sample(&mut self) { // generate_sampleが発音中であることを確認してから呼ぶ。 - for (phase, increment) in self.state.phases[..input.rendered_voices()] + for (phase, increment) in self.state.phases[..self.state.rendered_count] .iter_mut() .zip(&self.state.phase_increments) { @@ -1086,6 +1150,44 @@ mod tests { oscillator } + #[test] + fn advancing_without_output_preserves_phase_noise_and_adaa_history() { + let mut full = Oscillator::new(); + let mut skipped = Oscillator { state: full.state }; + let waves = [ + Waveform::Sine, + Waveform::Triangle, + Waveform::Square, + Waveform::Sawtooth, + Waveform::Noise, + ]; + for n in 0..5000 { + let mut input = test_input(); + input.waveform = waves[n / 61 % waves.len()]; + input.unison_voices = (n / 79 % 7 + 1) as u32; + input.detune_cents = if n % 11 == 0 { 0.0 } else { 25.0 }; + input.phase_mode = [PhaseMode::Keep, PhaseMode::Zero, PhaseMode::Random][n / 127 % 3]; + input.note_generation = (n / 127) as u64; + input.active = n % 43 != 0; + input.phase_modulation = (n as f64 * 0.17).sin() * 2.0; + input.phase_modulated = n % 17 != 0; + input.frequency_hz = 40.0 + (n % 300) as f64 * 17.0; + let expected = full.generate_sample(&input, 48000.0); + if n % 19 == 0 { + let actual = skipped.generate_sample(&input, 48000.0); + assert_eq!(actual.count, expected.count); + assert_eq!(actual.values, expected.values); + } else { + skipped.advance_sample(&input, 48000.0); + } + assert_eq!(skipped.state.phases, full.state.phases); + assert_eq!(skipped.state.history, full.state.history); + assert_eq!(skipped.state.valid, full.state.valid); + assert_eq!(skipped.state.random, full.state.random); + assert_eq!(skipped.state.noise, full.state.noise); + } + } + #[test] fn inactive_samples_preserve_phase_and_silent_active_samples_advance() { let mut oscillator = Oscillator::new(); diff --git a/src/parameters.rs b/src/parameters.rs index f5ee72d..73fe02b 100644 --- a/src/parameters.rs +++ b/src/parameters.rs @@ -490,50 +490,61 @@ pub struct ParameterPoints<'a> { } impl<'a> ParameterPoints<'a> { - /// parameterは音色設定の番号またはPROGRAM_INDEX。 + /// ホストのキューを1回列挙し、ParamIDごとのカーソルを構成する。 /// SAFETY: dataの入れ子のインターフェースはホスト所有で、dataの借用期間中有効。 - pub unsafe fn new(data: &'a ProcessData, parameter: usize, previous_value: f64) -> Self { - let id = if parameter == PROGRAM_INDEX { - PROGRAM_ID - } else { - IDS[parameter] - }; - let mut result = Self { - queue: ptr::null_mut(), - table: None, - count: 0, - index: 0, - previous_offset: 0, - samples: data.num_samples, - next: None, - previous: (-1, previous_value), - parameter, - interpolates: !holds_between_points(parameter), - automated: false, - }; + pub unsafe fn all(data: &'a ProcessData, values: &[f64; COUNT]) -> [Self; COUNT + 1] { + let mut points = std::array::from_fn(|i| { + Self::empty(data.num_samples, i, values.get(i).copied().unwrap_or(0.0)) + }); if !data.input_parameter_changes.is_null() { - // SAFETY: ホストのIParameterChangesと借用キューを読み、保持期間をprocess内に限定する。 + // SAFETY: ホストのIParameterChangesと借用キューを読み、process中だけ保持する。 unsafe { let changes = data.input_parameter_changes; let table = &**changes.cast::<*const ParameterChangesVTable>(); - for index in 0..(table.get_parameter_count)(changes) { - let queue = (table.get_parameter_data)(changes, index); + for at in 0..(table.get_parameter_count)(changes) { + let queue = (table.get_parameter_data)(changes, at); if queue.is_null() { continue; } let queue_table = &**queue.cast::<*const ParamValueQueueVTable>(); - if (queue_table.get_parameter_id)(queue) == id { - result.queue = queue; - result.table = Some(queue_table); - result.count = (queue_table.get_point_count)(queue); - break; // 仕様ではParamIDごとに1キュー。重複時は最初のキューを採用する。 + let id = (queue_table.get_parameter_id)(queue); + let parameter = if id == PROGRAM_ID { + Some(PROGRAM_INDEX) + } else { + index(id) + }; + let Some(parameter) = parameter else { + continue; + }; + let point = &mut points[parameter]; + if point.table.is_some() { + continue; // ParamID重複時は最初のキューを採用する。 } + point.queue = queue; + point.table = Some(queue_table); + point.count = (queue_table.get_point_count)(queue); + point.advance(); + point.automated = point.next.is_some(); } } } - result.advance(); - result.automated = result.next.is_some(); - result + points + } + + fn empty(samples: i32, parameter: usize, previous_value: f64) -> Self { + Self { + queue: ptr::null_mut(), + table: None, + count: 0, + index: 0, + previous_offset: 0, + samples, + next: None, + previous: (-1, previous_value), + parameter, + interpolates: !holds_between_points(parameter), + automated: false, + } } /// Programは同じ番号の再選択もロード要求として扱う。 @@ -573,7 +584,7 @@ impl<'a> ParameterPoints<'a> { while self.index < self.count { let mut offset = -1; let mut value = f64::NAN; - // SAFETY: newの契約によりキューは生存中。出力先は型の一致したローカル変数。 + // SAFETY: allの契約によりキューは生存中。出力先は型の一致したローカル変数。 let status = unsafe { (table.get_point)(self.queue, self.index, &mut offset, &mut value) }; self.index += 1; @@ -682,11 +693,7 @@ mod tests { #[test] fn sample_positions_interpolate_only_known_continuous_intervals() { - // SAFETY: ProcessDataは整数とnull許容の生ポインターだけを持つ。 - let mut data: ProcessData = unsafe { std::mem::zeroed() }; - data.num_samples = 8; - // SAFETY: dataにはホストポインターがなく、このスコープ中有効。 - let mut points = unsafe { ParameterPoints::new(&data, 32, 0.2) }; + let mut points = ParameterPoints::empty(8, 32, 0.2); points.previous = (0, 0.2); points.next = Some((4, 1.0)); for (at, expected) in [(0, 0.2), (1, 0.4), (2, 0.6), (3, 0.8)] { diff --git a/src/plugin.rs b/src/plugin.rs index a6bda3f..c92f2f6 100644 --- a/src/plugin.rs +++ b/src/plugin.rs @@ -814,19 +814,19 @@ unsafe extern "system" fn process(this: This, data: *mut ProcessData) -> TResult if data.num_samples != 0 { return NOT_INITIALIZED; } - // SAFETY: 変更キューは呼び出し中有効。停止中のDSP状態には触れない。 - let mut program = unsafe { ParameterPoints::new(data, parameters::PROGRAM_INDEX, 0.0) }; - let loaded = program.take_program_at(0); - let mut values = if loaded { - parameters::sine_preset() - } else { - plugin.processor_parameters.snapshot() - }; + let mut values = plugin.processor_parameters.snapshot(); + // SAFETY: 変更キューはこの呼び出し中有効。停止中のDSP状態には触れない。 + let mut changes = unsafe { ParameterPoints::all(data, &values) }; + let loaded = changes[parameters::PROGRAM_INDEX].take_program_at(0); + if loaded { + values = parameters::sine_preset(); + for (point, &value) in changes.iter_mut().zip(&values) { + point.reset_value(0, value); + } + } for (i, value) in values.iter_mut().enumerate() { - // SAFETY: キューの借用期間はこのprocess内だけ。 - let mut changes = unsafe { ParameterPoints::new(data, i, *value) }; - *value = changes.value_at(0); - if loaded || changes.automated { + *value = changes[i].value_at(0); + if loaded || changes[i].automated { plugin.processor_parameters.set(i, *value); } } @@ -869,10 +869,7 @@ unsafe extern "system" fn process(this: This, data: *mut ProcessData) -> TResult let values = plugin.processor_parameters.snapshot(); synth.set_parameters(values); // SAFETY: 音色設定とProgramのカーソルはこのprocess中だけホストのキューを借用する。 - let mut changes: [ParameterPoints<'_>; parameters::COUNT + 1] = - std::array::from_fn(|i| unsafe { - ParameterPoints::new(data, i, values.get(i).copied().unwrap_or(0.0)) - }); + let mut changes = unsafe { ParameterPoints::all(data, &values) }; let event_active = plugin.event_active.load(Ordering::Relaxed); if !event_active { synth.stop(); @@ -973,34 +970,51 @@ unsafe fn generate_samples( changes: &mut [ParameterPoints<'_>; parameters::COUNT + 1], peak: &mut f32, ) -> u64 { + let automated = changes.iter().enumerate().fold(0_u64, |mask, (i, point)| { + mask | (u64::from(point.automated) << i) + }); // バッファの有無と精度は区間ごとに選び、サンプルループ内では分岐しない。 let nonzero = match channels { Some(channels) if data.symbolic_sample_size == SAMPLE32 => { - generate_output_samples(plugin, synth, changes, range.clone(), |offset, sample| { - let sample = sample.map(|value| value as f32); - *peak = (*peak).max(sample[0].abs()).max(sample[1].abs()); - for (channel, sample) in channels.into_iter().zip(sample) { - // SAFETY: 呼び出し元で検証済み。左右が同じ領域でも順に書き込む。 - unsafe { channel.cast::().add(offset).write(sample) }; - } - u64::from(sample[0] != 0.0) | (u64::from(sample[1] != 0.0) << 1) - }) + generate_output_samples( + plugin, + synth, + changes, + automated, + range.clone(), + |offset, sample| { + let sample = sample.map(|value| value as f32); + *peak = (*peak).max(sample[0].abs()).max(sample[1].abs()); + for (channel, sample) in channels.into_iter().zip(sample) { + // SAFETY: 呼び出し元で検証済み。左右が同じ領域でも順に書き込む。 + unsafe { channel.cast::().add(offset).write(sample) }; + } + u64::from(sample[0] != 0.0) | (u64::from(sample[1] != 0.0) << 1) + }, + ) } Some(channels) => { - generate_output_samples(plugin, synth, changes, range.clone(), |offset, sample| { - *peak = (*peak).max(sample[0].abs().max(sample[1].abs()) as f32); - for (channel, sample) in channels.into_iter().zip(sample) { - // SAFETY: 呼び出し元で検証済み。排他的sliceは作らない。 - unsafe { channel.cast::().add(offset).write(sample) }; - } - u64::from(sample[0] != 0.0) | (u64::from(sample[1] != 0.0) << 1) - }) + generate_output_samples( + plugin, + synth, + changes, + automated, + range.clone(), + |offset, sample| { + *peak = (*peak).max(sample[0].abs().max(sample[1].abs()) as f32); + for (channel, sample) in channels.into_iter().zip(sample) { + // SAFETY: 呼び出し元で検証済み。排他的sliceは作らない。 + unsafe { channel.cast::().add(offset).write(sample) }; + } + u64::from(sample[0] != 0.0) | (u64::from(sample[1] != 0.0) << 1) + }, + ) } - None => generate_output_samples(plugin, synth, changes, range.clone(), |_, _| 0), + None => generate_output_samples(plugin, synth, changes, automated, range.clone(), |_, _| 0), }; // ノートと同位置のパラメーターを先に適用。0サンプルフラッシュもここを通る。 if range.end < data.num_samples || data.num_samples == 0 { - apply_parameters(plugin, synth, changes, range.end); + apply_parameters(plugin, synth, changes, automated, range.end); } nonzero } @@ -1010,18 +1024,24 @@ fn generate_output_samples( plugin: &Plugin, synth: &mut Synthesizer, changes: &mut [ParameterPoints<'_>; parameters::COUNT + 1], + automated: u64, range: std::ops::Range, mut write: impl FnMut(usize, [f64; 2]) -> u64, ) -> u64 { let mut nonzero = 0; - if changes.iter().any(|change| change.automated) { + if automated != 0 { for offset in range { - apply_parameters(plugin, synth, changes, offset); + apply_parameters(plugin, synth, changes, automated, offset); nonzero |= write(offset as usize, synth.generate_sample()); } } else { - for offset in range { - nonzero |= write(offset as usize, synth.generate_sample()); + let mut samples = [[0.0; 2]; 32]; + for start in (range.start..range.end).step_by(samples.len()) { + let count = (range.end - start).min(samples.len() as i32) as usize; + synth.generate_samples(&mut samples[..count]); + for (offset, &sample) in samples[..count].iter().enumerate() { + nonzero |= write(start as usize + offset, sample); + } } } nonzero @@ -1031,24 +1051,34 @@ fn apply_parameters( plugin: &Plugin, synth: &mut Synthesizer, changes: &mut [ParameterPoints<'_>; parameters::COUNT + 1], + automated: u64, offset: i32, ) { - let loaded = changes[parameters::PROGRAM_INDEX].take_program_at(offset); + let loaded = automated & (1 << parameters::PROGRAM_INDEX) != 0 + && changes[parameters::PROGRAM_INDEX].take_program_at(offset); + let mut values = synth.parameters(); if loaded { - let values = parameters::sine_preset(); + values = parameters::sine_preset(); for (change, value) in changes.iter_mut().zip(values) { change.reset_value(offset, value); } } - let values = std::array::from_fn(|i| changes[i].value_at(offset)); + let controls = automated & ((1_u64 << parameters::COUNT) - 1); + let mut pending = controls; + while pending != 0 { + let i = pending.trailing_zeros() as usize; + pending &= pending - 1; + values[i] = changes[i].value_at(offset); + } let changed = synth.set_parameters(values); if loaded { plugin.processor_parameters.store(values); } else if changed { - for (i, change) in changes[..parameters::COUNT].iter().enumerate() { - if change.automated { - plugin.processor_parameters.set(i, values[i]); - } + let mut pending = controls; + while pending != 0 { + let i = pending.trailing_zeros() as usize; + pending &= pending - 1; + plugin.processor_parameters.set(i, values[i]); } } } diff --git a/src/synth.rs b/src/synth.rs index dac189e..3d9f4e1 100644 --- a/src/synth.rs +++ b/src/synth.rs @@ -8,6 +8,7 @@ use crate::oscillator::{PanningGains, panning_gains}; use crate::parameters; use crate::voice::{Note, Voice}; +#[cfg_attr(test, derive(Clone))] pub struct SynthesizerState { /// 最大32枠を初期化時に確保し、音声処理中は確保・解放しない。 voices: [Voice; 32], @@ -15,6 +16,8 @@ pub struct SynthesizerState { next_oscillator_id: usize, /// 現在使用する枠数(1..=32)。範囲外の枠は停止し、位相だけ保持する。 polyphony: usize, + /// 停止後に一度でもNote Onを割り当てた枠の上端。未使用枠のサンプル処理を省く。 + used_voices: usize, /// 全オシレータに共通のサンプルレート(Hz)。 sample_rate: f64, /// 適用済みの正規化値。変更時だけ実単位へ換算する。 @@ -39,6 +42,7 @@ pub struct SynthesizerState { } /// Synthesizerの処理を担当し、専用のStateを所有するコンポーネント。 +#[cfg_attr(test, derive(Clone))] pub struct Synthesizer { /// このコンポーネントの内部状態。 state: Box, @@ -51,6 +55,7 @@ impl Synthesizer { voices: std::array::from_fn(|_| Voice::new()), next_oscillator_id: 0, polyphony: 1, + used_voices: 0, sample_rate: 44100.0, parameters: parameters::defaults(), master_gain: 1.0, @@ -70,7 +75,11 @@ impl Synthesizer { self.state.sample_rate = sample_rate; } - /// 設定は全枠の入力に反映し、発振器の内部状態はイベント処理から変更しない。 + pub fn parameters(&self) -> [f64; parameters::COUNT] { + self.state.parameters + } + + /// 設定は有効な枠の入力へ反映し、Polyphony増加時は追加した枠も同期する。 pub fn set_parameters(&mut self, values: [f64; parameters::COUNT]) -> bool { if values == self.state.parameters { return false; @@ -87,16 +96,18 @@ impl Synthesizer { } let previous = self.state.parameters; self.state.parameters = values; - // 変更した設定グループだけ配送する。未発音の枠も次のNote Onに備えて更新する。 - let oscillator_changed = values[..8] != previous[..8] || values[12] != previous[12]; - let envelope_changed = values[14..20] != previous[14..20]; - let filter_changed = values[9..12] != previous[9..12]; + // 有効範囲が広がるときは、休止していた枠へ現在の全設定を配送する。 + let expanded = values[8] > previous[8]; + let oscillator_changed = + expanded || values[..8] != previous[..8] || values[12] != previous[12]; + let envelope_changed = expanded || values[14..20] != previous[14..20]; if values[8] != previous[8] { let count = parameters::to_plain(8, values[8]) as usize; for voice in &mut self.state.voices[count..self.state.polyphony.max(count)] { voice.stop(); } self.state.polyphony = count; + self.state.used_voices = self.state.used_voices.min(count); self.state.next_oscillator_id %= count; } // 変更のないグループの時間換算(pow)なども省く。 @@ -106,14 +117,14 @@ impl Synthesizer { let unison_voices = parameters::to_plain(6, values[6]) as u32; let detune_cents = parameters::to_plain(7, values[7]); let phase_mode = parameters::PHASE_MODES[parameters::to_plain(12, values[12]) as usize]; - for voice in &mut self.state.voices { + for voice in &mut self.state.voices[..self.state.polyphony] { voice.set_parameters(waveform, envelope, unison_voices, detune_cents, phase_mode); } } if envelope_changed { let cutoff_envelope = parameters::envelope(&values, 14); let cutoff_amount = parameters::to_plain(19, values[19]); - for voice in &mut self.state.voices { + for voice in &mut self.state.voices[..self.state.polyphony] { voice.set_cutoff_envelope(cutoff_envelope, cutoff_amount); } } @@ -124,7 +135,8 @@ impl Synthesizer { for (osc, volume) in parameters::OSCILLATOR_VOLUMES.into_iter().enumerate() { let wave = [0, 23, 26][osc]; let tune = [None, Some(24), Some(27)][osc]; - if values[volume] != previous[volume] + if expanded + || values[volume] != previous[volume] || values[wave] != previous[wave] || tune.is_some_and(|i| values[i] != previous[i]) { @@ -134,13 +146,13 @@ impl Synthesizer { 2.0_f64.powf(parameters::to_plain(i, values[i]) / 1200.0) }); let gain = 10.0_f64.powf(parameters::to_plain(volume, values[volume]) / 20.0); - for voice in &mut self.state.voices { + for voice in &mut self.state.voices[..self.state.polyphony] { voice.set_oscillator(osc, waveform, ratio, gain); } } } - if values[29..31] != previous[29..31] { - for voice in &mut self.state.voices { + if expanded || values[29..31] != previous[29..31] { + for voice in &mut self.state.voices[..self.state.polyphony] { voice.set_phase_modulation([values[29] * 2.0, values[30] * 2.0]); } } @@ -180,13 +192,18 @@ impl Synthesizer { self.reset_distortion(); } } - if filter_changed { + if expanded || values[9..11] != previous[9..11] { let filter_type = parameters::FILTER_TYPES[parameters::to_plain(9, values[9]) as usize]; let cutoff_cents = parameters::to_plain(10, values[10]); let resonance_q = parameters::to_plain(11, values[11]); - for voice in &mut self.state.voices { + for voice in &mut self.state.voices[..self.state.polyphony] { voice.set_filter(filter_type, cutoff_cents, resonance_q); } + } else if values[11] != previous[11] { + let resonance_q = parameters::to_plain(11, values[11]); + for voice in &mut self.state.voices[..self.state.polyphony] { + voice.set_resonance(resonance_q); + } } true } @@ -196,13 +213,17 @@ impl Synthesizer { if !self.state.voices[self.state.next_oscillator_id].note_on(note, tuning, velocity) { return false; } + self.state.used_voices = self + .state + .used_voices + .max(self.state.next_oscillator_id + 1); self.state.next_oscillator_id = (self.state.next_oscillator_id + 1) % self.state.polyphony; true } pub fn note_off(&mut self, note: Note) { // 同じID、またはID未提供の同チャンネル・同音高が複数あれば全一致をreleaseする。 - for voice in &mut self.state.voices[..self.state.polyphony] { + for voice in &mut self.state.voices[..self.state.used_voices] { voice.note_off(note); } } @@ -216,6 +237,7 @@ impl Synthesizer { pub fn stop(&mut self) { self.state.previous_dry = [0.0; 2]; self.state.started = false; + self.state.used_voices = 0; self.state.transition = 0; self.state.processing = self.state.requested_processing; for voice in &mut self.state.voices { @@ -225,12 +247,82 @@ impl Synthesizer { /// 表示用の同時発音数。ブロック末尾で読み、ユニゾンや発振器数は加算しない。 pub fn active_voice_count(&self) -> u32 { - self.state.voices[..self.state.polyphony] + self.state.voices[..self.state.used_voices] .iter() .filter(|voice| voice.is_active()) .count() as u32 } + /// パラメーターとノートが一定の区間を、Voiceごとのサンプル系列で加算する。 + pub fn generate_samples(&mut self, output: &mut [[f64; 2]]) { + if output.len() <= 1 + || self.state.transition != 0 + || self.state.processing != self.state.requested_processing + { + for out in output { + *out = self.generate_sample(); + } + return; + } + self.state.started = true; + let clipper = self.state.processing; + let gain = self.state.master_gain; + let mut previous_dry = self.state.previous_dry; + output.fill([0.0; 2]); + if clipper == ClipperType::None { + for chunk in output.chunks_mut(32) { + let mut voice_output = [[0.0; 2]; 32]; + for voice in &mut self.state.voices[..self.state.used_voices] { + voice.generate_samples( + self.state.sample_rate, + &self.state.panning_gains, + &self.state.mono_gains, + &mut voice_output[..chunk.len()], + ); + for (out, value) in chunk.iter_mut().zip(&voice_output) { + out[0] += value[0]; + out[1] += value[1]; + } + } + } + for out in output { + let current = out.map(|v| v * gain); + *out = std::mem::replace(&mut previous_dry, current); + } + } else { + for chunk in output.chunks_mut(32) { + let mut dry = [[0.0; 2]; 32]; + let mut distortion = self.state.distortion; + distortion.clipper = clipper; + let mut voice_dry = [[0.0; 2]; 32]; + let mut voice_wet = [[0.0; 2]; 32]; + for voice in &mut self.state.voices[..self.state.used_voices] { + voice.generate_distorted_samples( + self.state.sample_rate, + &self.state.panning_gains, + &self.state.mono_gains, + &distortion, + &mut voice_dry[..chunk.len()], + &mut voice_wet[..chunk.len()], + ); + for i in 0..chunk.len() { + for ch in 0..2 { + dry[i][ch] += voice_dry[i][ch]; + chunk[i][ch] += voice_wet[i][ch]; + } + } + } + for (out, dry) in chunk.iter_mut().zip(&dry) { + let dry = std::mem::replace(&mut previous_dry, dry.map(|v| v * gain)); + *out = std::array::from_fn(|ch| { + dry[ch] * (1.0 - distortion.mix) + (out[ch] * gain) * distortion.mix + }); + } + } + } + self.state.previous_dry = previous_dry; + } + pub fn generate_sample(&mut self) -> [f64; 2] { self.state.started = true; if self.state.transition == 0 && self.state.processing != self.state.requested_processing { @@ -248,7 +340,7 @@ impl Synthesizer { } else { let mut distortion = self.state.distortion; distortion.clipper = clipper; - for voice in &mut self.state.voices[..self.state.polyphony] { + for voice in &mut self.state.voices[..self.state.used_voices] { let (input, output) = voice.generate_distorted_sample( self.state.sample_rate, &self.state.panning_gains, @@ -284,7 +376,7 @@ impl Synthesizer { /// フィルタまでのVoice出力を加算しMasterを適用する。 fn mix_sample(&mut self) -> [f64; 2] { let mut sum = [0.0; 2]; - for voice in &mut self.state.voices[..self.state.polyphony] { + for voice in &mut self.state.voices[..self.state.used_voices] { let sample = voice.generate_sample( self.state.sample_rate, &self.state.panning_gains, @@ -316,6 +408,172 @@ mod tests { Note { id, channel, pitch } } + #[test] + #[cfg_attr(miri, ignore)] // 多数の音声境界のビット比較は実CPUで行う。 + fn constant_input_series_matches_sample_processing_across_boundaries() { + for phase in 0..3 { + let mut values = parameters::sine_preset(); + for (index, value) in [(5, 1.), (12, phase as f64), (32, 18.), (33, 65.)] { + values[index] = parameters::to_normalized(index, value); + } + let mut serial = Synthesizer::new(); + serial.set_sample_rate(48000.); + serial.set_parameters(values); + // ノイズ・Random位相を含む全ての初期乱数状態を同じにする。 + let mut series = serial.clone(); + let mut heard = false; + for step in 0..40 { + let changes: &[(usize, f64)] = match step { + 4 => &[ + (0, 3.), + (6, 3.), + (7, 25.), + (8, 4.), + (9, 2.), + (10, 1200.), + (11, 2.), + (14, 3.), + (15, 1.), + (16, 5.), + (17, 0.25), + (18, 7.), + (19, 1200.), + (20, 75.), + (23, 1.), + (25, -12.), + (26, 2.), + (28, -12.), + (29, 23.), + (30, 17.), + ], + 8 => &[(31, 1.)], + 12 => &[(0, 4.), (23, 4.), (26, 0.)], + 16 => &[(31, 2.)], + 20 => &[(0, 0.), (23, 2.), (26, 1.), (25, -60.), (28, -60.)], + 24 => &[(31, 0.)], + 28 => &[(29, 0.), (30, 0.)], + 32 => &[(25, -12.), (28, -12.), (29, 23.), (30, 17.)], + 36 => &[(23, 4.), (29, 100.)], + _ => &[], + }; + for &(index, value) in changes { + values[index] = parameters::to_normalized(index, value); + } + let events: &[(bool, i32, i16)] = match step { + 0 => &[(true, 1, 60)], + 4 => &[(true, 2, 64), (true, 3, 67)], + 10 => &[(false, 2, 64), (true, 4, 64)], + 16 => &[(true, 5, 64), (false, 4, 64)], + 27 => &[(true, 6, 60)], + 31 => &[(false, 6, 60), (true, 7, 60)], + 35 => &[(true, 8, 60), (false, 7, 60)], + _ => &[], + }; + for synth in [&mut serial, &mut series] { + synth.set_parameters(values); + for &(on, id, pitch) in events { + if on { + assert!(synth.note_on(note(id, 0, pitch), 0., 0.8)); + } else { + synth.note_off(note(id, 0, pitch)); + } + } + if step == 21 { + for id in 1..=5 { + synth.note_off(note(id, 0, 64)); + } + } + if matches!(step, 24 | 39) { + synth.stop(); + } + } + let count = [0, 1, 2, 7, 31, 32, 33, 127][step % 8]; + let mut output = [[f64::NAN; 2]; 127]; + series.generate_samples(&mut output[..count]); + for value in &output[..count] { + let expected = serial.generate_sample(); + assert_eq!( + value.map(f64::to_bits), + expected.map(f64::to_bits), + "phase={phase}, step={step}" + ); + heard |= *value != [0.; 2]; + } + assert_eq!(series.active_voice_count(), serial.active_voice_count()); + } + assert!(heard); + } + } + + #[test] + fn increasing_polyphony_synchronizes_settings_changed_while_disabled() { + let mut delayed = Synthesizer::new(); + let mut reference = Synthesizer::new(); + let mut values = parameters::sine_preset(); + values[8] = parameters::to_normalized(8, 4.0); + for synth in [&mut delayed, &mut reference] { + synth.set_sample_rate(48000.0); + synth.set_parameters(values); + for id in 0..4 { + assert!(synth.note_on(note(id, 0, 60 + id as i16), 0.0, 0.8)); + } + for _ in 0..128 { + synth.generate_sample(); + } + let mut limited = values; + limited[8] = 0.0; + synth.set_parameters(limited); + } + reference.set_parameters(values); + for (i, plain) in [ + (0, 3.), + (1, 2.), + (2, 1.), + (3, 7.), + (4, 0.4), + (5, 3.), + (6, 3.), + (7, 17.), + (9, 6.), + (10, 1200.), + (11, 2.), + (12, 0.), + (14, 1.), + (15, 2.), + (16, 5.), + (17, 0.3), + (18, 4.), + (19, -2400.), + (22, -6.), + (23, 1.), + (24, 300.), + (25, -12.), + (26, 2.), + (27, -700.), + (28, -9.), + (29, 33.), + (30, 71.), + (31, 1.), + (32, 18.), + (33, 75.), + ] { + values[i] = parameters::to_normalized(i, plain); + } + reference.set_parameters(values); + let mut limited = values; + limited[8] = 0.0; + delayed.set_parameters(limited); + delayed.set_parameters(values); + for id in 0..4 { + let n = note(id + 20, 0, 48 + id as i16 * 3); + assert!(delayed.note_on(n, 0.0, 0.7)); + assert!(reference.note_on(n, 0.0, 0.7)); + } + for _ in 0..4096 { + assert_eq!(delayed.generate_sample(), reference.generate_sample()); + } + } + #[test] fn voice_count_tracks_allocation_release_limits_and_stop() { let mut synth = unfiltered(); diff --git a/src/tests.rs b/src/tests.rs index 565beb8..9532ea5 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -659,3 +659,99 @@ fn editor_owns_controller_and_has_fixed_size() { assert_eq!((ft.unknown.release)(factory), 0); } } + +#[test] +fn parameter_queues_are_enumerated_once_and_keep_the_first_duplicate() { + #[repr(C)] + struct Queues { + table: &'static ParameterChangesVTable, + entries: [This; 6], + visits: usize, + } + unsafe extern "system" fn count(_: This) -> i32 { + 6 + } + unsafe extern "system" fn get(this: This, at: i32) -> This { + // SAFETY: このテストの配列を逐次読み、列挙回数だけを記録する。 + let queues = unsafe { &mut *this.cast::() }; + queues.visits += 1; + queues.entries[at as usize] + } + unsafe extern "system" fn no_points(_: This) -> i32 { + 0 + } + static MULTIPLE: ParameterChangesVTable = ParameterChangesVTable { + unknown: UnknownVTable { + query_interface: event_query, + add_ref: event_ref, + release: event_ref, + }, + get_parameter_count: count, + get_parameter_data: get, + add_parameter_data: changes_add, + }; + static EMPTY: ParamValueQueueVTable = ParamValueQueueVTable { + unknown: UnknownVTable { + query_interface: event_query, + add_ref: event_ref, + release: event_ref, + }, + get_parameter_id: point_id, + get_point_count: no_points, + get_point: point_get, + add_point: point_add, + }; + let mut first = TestPoint { + vtable: &POINT_TABLE, + id: parameters::IDS[11], + offset: 0, + value: 0.4, + }; + let mut duplicate = TestPoint { + vtable: &POINT_TABLE, + id: parameters::IDS[11], + offset: 0, + value: 0.9, + }; + let mut empty = TestPoint { + vtable: &EMPTY, + id: parameters::IDS[32], + offset: 0, + value: 0.9, + }; + let mut later = TestPoint { + vtable: &POINT_TABLE, + id: parameters::IDS[32], + offset: 0, + value: 0.9, + }; + let mut unknown = TestPoint { + vtable: &POINT_TABLE, + id: u32::MAX, + offset: 0, + value: 0.9, + }; + let mut queues = Queues { + table: &MULTIPLE, + entries: [ + ptr::from_mut(&mut first).cast(), + ptr::null_mut(), + ptr::from_mut(&mut empty).cast(), + ptr::from_mut(&mut duplicate).cast(), + ptr::from_mut(&mut later).cast(), + ptr::from_mut(&mut unknown).cast(), + ], + visits: 0, + }; + // SAFETY: ProcessDataは整数とnull許容の生ポインターだけで、このスコープのキューを借用する。 + let mut data: ProcessData = unsafe { std::mem::zeroed() }; + data.num_samples = 1; + data.input_parameter_changes = ptr::from_mut(&mut queues).cast(); + let mut values = parameters::defaults(); + values[32] = 0.2; + let mut points = unsafe { parameters::ParameterPoints::all(&data, &values) }; + assert_eq!(queues.visits, 6); + assert_eq!(points[11].value_at(0), 0.4); + assert_eq!(points[32].value_at(0), 0.2); + assert_eq!(points.iter().filter(|p| p.automated).count(), 1); +} diff --git a/src/voice.rs b/src/voice.rs index 66ee3fb..29a1cc9 100644 --- a/src/voice.rs +++ b/src/voice.rs @@ -3,7 +3,7 @@ use crate::distortion::{Distortion, DistortionParameters}; use crate::envelope::{DEFAULT_ENVELOPE, Envelope, EnvelopeParameters}; -use crate::filter::{Filter, FilterParameters, FilterType}; +use crate::filter::{Filter, FilterParameters, FilterType, MIN_SAMPLE_RATE}; use crate::oscillator::{Oscillator, OscillatorInput, PanningGains, PhaseMode, Waveform}; use crate::{parameters, volume}; @@ -21,6 +21,7 @@ pub struct Note { } /// 同時発音の1枠。入力・内部状態・ノートの対応を他の枠から独立させる。 +#[cfg_attr(test, derive(Clone))] pub struct VoiceState { /// Osc1・Osc2・Osc3の定常入力。Osc1だけがユニゾン設定を持つ。 pub(super) oscillator_inputs: [OscillatorInput; 3], @@ -36,10 +37,10 @@ pub struct VoiceState { tune_ratios: [f64; 3], /// ノートを保持している間true。Note Offでは共通AHDSRのreleaseへ移る。 pub(super) gate: bool, - /// Note Onの世代。3発振器と両AHDSRへ同じ番号を渡す。 + /// Note Onの世代。3発振器へ同じ番号を渡す。 note_generation: u64, - /// 即時停止の世代。両AHDSRへ渡す。 - reset_generation: u64, + /// 両Envelopeへ反映済みの有効なレート。生成時に変わった場合だけ再検証する。 + sample_rate: f64, /// ベロシティを反映した共通AHDSRの目標実効振幅。 amplitude: f64, /// 発振器の加算出力へ適用する音量AHDSRの設定。 @@ -69,6 +70,7 @@ pub struct VoiceState { } /// Voiceの処理を担当し、専用のStateを所有するコンポーネント。 +#[cfg_attr(test, derive(Clone))] pub struct Voice { /// このコンポーネントの内部状態。 pub(super) state: VoiceState, @@ -77,6 +79,10 @@ pub struct Voice { impl Voice { pub fn new() -> Self { let values = parameters::defaults(); + let mut envelope = Envelope::new(); + envelope.set_input(&DEFAULT_ENVELOPE, MIN_SAMPLE_RATE, 0.0); + let mut cutoff_envelope = Envelope::new(); + cutoff_envelope.set_input(&DEFAULT_ENVELOPE, MIN_SAMPLE_RATE, 1.0); Self { state: VoiceState { oscillator_inputs: [OscillatorInput { @@ -97,10 +103,10 @@ impl Voice { tune_ratios: [1.0; 3], gate: false, note_generation: 0, - reset_generation: 0, + sample_rate: MIN_SAMPLE_RATE, amplitude: 0.0, envelope_parameters: DEFAULT_ENVELOPE, - envelope: Envelope::new(), + envelope, note: None, filter: Filter::new(), distortion: Distortion::new(), @@ -108,7 +114,7 @@ impl Voice { cutoff_ratio: 2.0_f64.powf(parameters::to_plain(10, values[10]) / 1200.0), resonance_q: parameters::to_plain(11, values[11]), cutoff_envelope_parameters: DEFAULT_ENVELOPE, - cutoff_envelope: Envelope::new(), + cutoff_envelope, cutoff_amount_cents: 0.0, cutoff_modulation: (0.0, 1.0), }, @@ -139,6 +145,13 @@ impl Voice { input.note_generation = self.state.note_generation; } self.state.amplitude = BASE_RMS_AMPLITUDE * f64::from(velocity); + self.state.envelope.set_input( + &self.state.envelope_parameters, + self.state.sample_rate, + self.state.amplitude, + ); + self.state.envelope.note_on(); + self.state.cutoff_envelope.note_on(); self.state.gate = true; self.state.note = Some(note); true @@ -153,6 +166,8 @@ impl Voice { } }) { self.state.gate = false; + self.state.envelope.note_off(); + self.state.cutoff_envelope.note_off(); self.state.note = None; } } @@ -165,7 +180,8 @@ impl Voice { pub fn stop(&mut self) { // releaseとは区別し、次サンプルで即時消音する。位相は保持する。 self.state.gate = false; - self.state.reset_generation = self.state.reset_generation.wrapping_add(1); + self.state.envelope.stop(); + self.state.cutoff_envelope.stop(); self.state.note = None; self.state.filter.reset(); self.reset_distortion(); @@ -184,8 +200,16 @@ impl Voice { self.state.resonance_q = resonance_q; } + /// Qだけが変わるときは、カットオフの指数換算と書込みを省く。 + pub fn set_resonance(&mut self, resonance_q: f64) { + self.state.resonance_q = resonance_q; + } + pub fn set_cutoff_envelope(&mut self, parameters: EnvelopeParameters, amount_cents: f64) { self.state.cutoff_envelope_parameters = parameters; + self.state + .cutoff_envelope + .set_input(¶meters, self.state.sample_rate, 1.0); self.state.cutoff_amount_cents = amount_cents; } @@ -199,6 +223,9 @@ impl Voice { ) { self.state.oscillator_inputs[0].waveform = waveform; self.state.envelope_parameters = envelope; + self.state + .envelope + .set_input(&envelope, self.state.sample_rate, self.state.amplitude); self.state.oscillator_inputs[0].unison_voices = unison; self.state.oscillator_inputs[0].detune_cents = detune; self.refresh_volume(0); @@ -246,32 +273,75 @@ impl Voice { (input, wet) } + /// 同じ長さのDry/Wet系列を、各Voice固有のADAA履歴を用いて生成する。 + pub fn generate_distorted_samples( + &mut self, + sample_rate: f64, + gains: &PanningGains, + mono_gains: &[f64; 2], + parameters: &DistortionParameters, + dry: &mut [[f64; 2]], + wet: &mut [[f64; 2]], + ) { + debug_assert_eq!(dry.len(), wet.len()); + self.generate_samples(sample_rate, gains, mono_gains, dry); + for (input, output) in dry.iter().zip(wet) { + *output = self.state.distortion.process_sample(*input, parameters); + } + } + /// Voiceの3発振器・音量AHDSR・SVFまでをホストレートで処理する。 + #[inline(never)] // 大きい1サンプル本体をSynthesizerへ重複展開しない。 pub fn generate_sample( &mut self, sample_rate: f64, gains: &PanningGains, mono_gains: &[f64; 2], ) -> [f64; 2] { - if !(sample_rate.is_finite() & (sample_rate > 0.0)) { - return [0.0; 2]; + self.generate_one_sample::(sample_rate, gains, mono_gains) + } + + /// 定常入力が同じ区間の先頭で発振器を準備し、残りのサンプルを生成する。 + pub fn generate_samples( + &mut self, + sample_rate: f64, + gains: &PanningGains, + mono_gains: &[f64; 2], + output: &mut [[f64; 2]], + ) { + if let Some((first, rest)) = output.split_first_mut() { + *first = self.generate_sample(sample_rate, gains, mono_gains); + for value in rest { + *value = self.generate_one_sample::(sample_rate, gains, mono_gains); + } } - let amplitude = self.state.envelope.generate_sample( - &self.state.envelope_parameters, - sample_rate, - self.state.gate, - self.state.note_generation, - self.state.reset_generation, - self.state.amplitude, - ); - let level = self.state.cutoff_envelope.generate_sample( - &self.state.cutoff_envelope_parameters, - sample_rate, - self.state.gate, - self.state.note_generation, - self.state.reset_generation, - 1.0, - ); + } + + #[inline] + fn generate_one_sample( + &mut self, + sample_rate: f64, + gains: &PanningGains, + mono_gains: &[f64; 2], + ) -> [f64; 2] { + if sample_rate != self.state.sample_rate { + if !(sample_rate.is_finite() & (sample_rate > 0.0)) { + return [0.0; 2]; + } + self.state.sample_rate = sample_rate; + self.state.envelope.set_input( + &self.state.envelope_parameters, + sample_rate, + self.state.amplitude, + ); + self.state.cutoff_envelope.set_input( + &self.state.cutoff_envelope_parameters, + sample_rate, + 1.0, + ); + } + let amplitude = self.state.envelope.generate_sample(); + let level = self.state.cutoff_envelope.generate_sample(); let cents = level * self.state.cutoff_amount_cents; // バイパス中もEnvelopeは進め、有効化したサンプルで現在値の倍率を求める。 if !matches!(self.state.filter_type, FilterType::None) @@ -282,25 +352,56 @@ impl Voice { let active = self.state.envelope.is_active(); let mono = [*mono_gains; 7]; let mut sample = [0.0; 2]; - let depths = [0.0, self.state.phase_depths[0], self.state.phase_depths[1]]; - let mut modulation = 0.0; - // 同じサンプル時刻の生波形をOsc3→Osc2→Osc1へ渡す。 - for i in (0..3).rev() { - self.state.oscillator_inputs[i].active = active; - let input = &mut self.state.oscillator_inputs[i]; - input.phase_modulation = modulation; - input.phase_modulated = i < 2 && self.state.phase_depths[i] != 0.0; - let current = self.state.oscillators[i].generate_sample(input, sample_rate); - modulation = current.values[0] * depths[i]; - if self.state.oscillator_gains[i] != 0.0 { - // 無音の変調源はrawだけを使い、音声用の定位・加算を省く。 - let audio = volume::process_sample( - ¤t.values[..current.count], - if i == 0 { gains } else { &mono }, - self.state.oscillator_gains[i], - ); - sample[0] += audio[0]; - sample[1] += audio[1]; + if active { + let depths = [0.0, self.state.phase_depths[0], self.state.phase_depths[1]]; + let mut modulation = 0.0; + // 同じサンプル時刻の生波形をOsc3→Osc2→Osc1へ渡す。 + for i in (0..3).rev() { + self.state.oscillator_inputs[i].active = true; + let input = &mut self.state.oscillator_inputs[i]; + input.phase_modulation = modulation; + input.phase_modulated = i < 2 && self.state.phase_depths[i] != 0.0; + if self.state.oscillator_gains[i] == 0.0 && depths[i] == 0.0 { + // SAFETY: 定常設定は親、ノート周波数とレートはVoiceで検証済み。 + // 変調入力は有限の波形と0〜2周期の深度から生成し、i32範囲内に収まる。 + // PREPAREDは同じ設定の区間の2サンプル目以降だけ。 + // ノート変更はなく、activeはtrueからfalseへの遷移だけを許す。 + unsafe { + if PREPARED { + self.state.oscillators[i].generate_prepared_sample::(input); + } else { + self.state.oscillators[i] + .generate_validated_sample::(input, sample_rate); + } + } + modulation = 0.0; + continue; + } + // SAFETY: 上記と同じ検証済みの定常設定・周波数・レート・変調入力を使う。 + let current = unsafe { + if PREPARED { + self.state.oscillators[i].generate_prepared_sample::(input) + } else { + self.state.oscillators[i] + .generate_validated_sample::(input, sample_rate) + } + }; + modulation = current.values[0] * depths[i]; + if self.state.oscillator_gains[i] != 0.0 { + // 無音の変調源はrawだけを使い、音声用の定位・加算を省く。 + let audio = volume::process_sample( + ¤t.values[..current.count], + if i == 0 { gains } else { &mono }, + self.state.oscillator_gains[i], + ); + sample[0] += audio[0]; + sample[1] += audio[1]; + } + } + } else { + // 再発音は必ずNote Onを通り、各Oscillatorの世代変更で履歴を更新する。 + for input in &mut self.state.oscillator_inputs { + input.active = false; } } let sample = sample.map(|value| value * amplitude); @@ -316,16 +417,8 @@ impl Voice { }, sample_rate, ); - self.state.envelope.update_sample( - &self.state.envelope_parameters, - sample_rate, - self.state.amplitude, - ); - self.state.cutoff_envelope.update_sample( - &self.state.cutoff_envelope_parameters, - sample_rate, - 1.0, - ); + self.state.envelope.update_sample(); + self.state.cutoff_envelope.update_sample(); output } }