diff --git a/src/distortion.rs b/src/distortion.rs index d292678..a5f397e 100644 --- a/src/distortion.rs +++ b/src/distortion.rs @@ -66,7 +66,19 @@ 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]; + 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] }; @@ -98,12 +110,14 @@ impl Distortion { self.state.input[0][ch] = x; 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 +126,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..3ad77c3 100644 --- a/src/envelope.rs +++ b/src/envelope.rs @@ -98,6 +98,10 @@ fn ramp(time: f64, duration: f64) -> f64 { struct EnvelopeState { /// 次サンプル時点の正規化値。再ノートオンの開始値に使う。 current_value: f64, + /// 現在の線形区間で1サンプル進めたときの増分。 + increment: f64, + /// 次の段境界までのサンプル数。設定変更時の0は次回生成での再計算を表す。 + remaining: u64, /// 検証・値計算に使用した設定、レート、ピーク。変更時だけ再検証する。 input: Option<(EnvelopeParameters, f64, f64)>, /// 直近のノートオン時の値。attack中は固定する。 @@ -126,6 +130,8 @@ impl Envelope { Self { state: EnvelopeState { current_value: 0.0, + increment: 0.0, + remaining: 0, input: None, start_value: 0.0, elapsed_samples: 0, @@ -137,29 +143,41 @@ impl Envelope { } } - /// ノート境界を反映し、現在サンプルの正規化値を生成する。 - /// 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, + peak: f64, + ) -> bool { + let input = (*parameters, sample_rate, peak); + 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; + } + self.state.input = Some(input); + true + } + + /// ノート境界を反映し、設定済み入力から現在サンプルの正規化値を生成する。 + #[inline(always)] + pub fn generate_sample( + &mut self, gate: bool, note_generation: u64, reset_generation: u64, - peak: f64, ) -> f64 { - 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.is_none() { + return 0.0; } let reset = reset_generation != self.state.reset_generation; if reset { @@ -180,17 +198,22 @@ impl Envelope { 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 self.state.remaining == 0 || reset || triggered || released { + 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.state.current_value += self.state.increment; + } else { + self.refresh_value(); + } } } @@ -198,14 +221,17 @@ impl Envelope { 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 +242,44 @@ 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 (slope, 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); + ( + -start / parameters.release_ms, + off.saturating_add(sample_at(parameters.release_ms)), + ) + } else if time < parameters.attack_ms { + ( + (peak - self.state.start_value) / parameters.attack_ms, + sample_at(parameters.attack_ms), + ) + } else if time < decay_start { + (0.0, sample_at(decay_start)) + } else if time < decay_end { + ( + peak * (parameters.sustain - 1.0) / parameters.decay_ms, + 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) + }; + (0.0, boundary) + }; + self.state.increment = slope / sample_rate * 1000.0; + self.state.remaining = boundary.saturating_sub(self.state.elapsed_samples); } } @@ -404,6 +468,51 @@ 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); + for sample in 0..(rate as u32 / 5) { + let time = f64::from(sample) / rate * 1000.0; + let actual = envelope.generate_sample(true, 1, 0); + 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); + 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); + let actual = envelope.generate_sample(sample < off, 1, 0); + assert!((actual - expected).abs() < 1e-11); + envelope.update_sample(); + } + } + } + } + #[test] fn cached_value_tracks_parameters_rate_peak_and_note_boundaries() { let mut envelope = Envelope::new(); @@ -414,37 +523,35 @@ 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)); + assert_eq!(envelope.generate_sample(true, 1, 0), 0.0); + envelope.update_sample(); + assert_eq!(envelope.generate_sample(true, 1, 0), 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(true, 1, 0), 0.05); + envelope.update_sample(); + envelope.set_input(&p, 1000.0, 0.5); + assert_eq!(envelope.generate_sample(true, 1, 0), 0.05); + envelope.set_input(&p, 2000.0, 0.5); + assert_eq!(envelope.generate_sample(true, 1, 0), 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(false, 2, 1), 0.0); + envelope.set_input(&p, 2000.0, 0.5); + assert_eq!(envelope.generate_sample(false, 1, 0), 0.025); + envelope.update_sample(); + let released = envelope.generate_sample(false, 1, 0); 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); + assert_eq!(envelope.generate_sample(true, 2, 0), 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(true, 2, 0) - expected).abs() < 1e-15); + assert_eq!(envelope.generate_sample(false, 2, 1), 0.0); assert!(!envelope.is_active()); } } diff --git a/src/filter.rs b/src/filter.rs index bf411ea..10dd1b3 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 { @@ -161,6 +172,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 { @@ -233,12 +297,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.rs b/src/oscillator.rs index 17ae160..3370d61 100644 --- a/src/oscillator.rs +++ b/src/oscillator.rs @@ -168,8 +168,8 @@ pub struct OscillatorState { bank: [adaa::Bank; 7], /// 履歴を連続使用できるか。ノート・波形・発音数変更時に破棄する。 valid: bool, - /// 履歴に有効なユニゾン数。未使用スロットの再利用を検出する。 - history_count: usize, + /// 定常入力から求めた実ユニゾン数。未使用スロットの再利用も検出する。 + rendered_count: usize, /// Note On時だけ進める位相用乱数。ノイズ用とは独立した状態を持つ。 random: Random, /// ノイズ専用xoshiro256+の状態。各ユニゾンに連続する別の値を割り当てる。 @@ -210,7 +210,7 @@ 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, @@ -225,11 +225,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 +254,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 { @@ -261,47 +295,56 @@ impl Oscillator { }; } 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 { + 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 +381,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 +396,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); @@ -378,13 +422,18 @@ impl Oscillator { 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(); 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); } + 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 @@ -423,9 +472,9 @@ impl Oscillator { } /// 発音中のサンプル生成後に、定常入力を用いて内部状態を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 +1135,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/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/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..1ccc330 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,13 +1024,14 @@ 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 { @@ -1031,24 +1046,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..75ce1c0 100644 --- a/src/synth.rs +++ b/src/synth.rs @@ -15,6 +15,8 @@ pub struct SynthesizerState { next_oscillator_id: usize, /// 現在使用する枠数(1..=32)。範囲外の枠は停止し、位相だけ保持する。 polyphony: usize, + /// 停止後に一度でもNote Onを割り当てた枠の上端。未使用枠のサンプル処理を省く。 + used_voices: usize, /// 全オシレータに共通のサンプルレート(Hz)。 sample_rate: f64, /// 適用済みの正規化値。変更時だけ実単位へ換算する。 @@ -51,6 +53,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 +73,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 +94,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 +115,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 +133,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 +144,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 +190,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 +211,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 +235,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,7 +245,7 @@ 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 @@ -248,7 +268,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 +304,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 +336,75 @@ mod tests { Note { id, channel, pitch } } + #[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..89679b1 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}; @@ -40,6 +40,8 @@ pub struct VoiceState { note_generation: u64, /// 即時停止の世代。両AHDSRへ渡す。 reset_generation: u64, + /// 両Envelopeへ反映済みの有効なレート。生成時に変わった場合だけ再検証する。 + sample_rate: f64, /// ベロシティを反映した共通AHDSRの目標実効振幅。 amplitude: f64, /// 発振器の加算出力へ適用する音量AHDSRの設定。 @@ -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 { @@ -98,9 +104,10 @@ impl Voice { 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 +115,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 +146,11 @@ 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.gate = true; self.state.note = Some(note); true @@ -184,8 +196,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 +219,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); @@ -253,24 +276,31 @@ impl Voice { gains: &PanningGains, mono_gains: &[f64; 2], ) -> [f64; 2] { - if !(sample_rate.is_finite() & (sample_rate > 0.0)) { - return [0.0; 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( - &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, ); let cents = level * self.state.cutoff_amount_cents; // バイパス中もEnvelopeは進め、有効化したサンプルで現在値の倍率を求める。 @@ -290,7 +320,20 @@ impl Voice { 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); + if self.state.oscillator_gains[i] == 0.0 && depths[i] == 0.0 { + // SAFETY: 定常設定は親、ノート周波数とレートはVoiceで検証済み。 + // 変調入力は有限の波形と0〜2周期の深度から生成し、i32範囲内に収まる。 + unsafe { + self.state.oscillators[i] + .generate_validated_sample::(input, sample_rate); + } + modulation = 0.0; + continue; + } + // SAFETY: 上記と同じ検証済みの定常設定・周波数・レート・変調入力を使う。 + let current = unsafe { + 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だけを使い、音声用の定位・加算を省く。 @@ -316,16 +359,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 } }