diff --git a/src/chorus.rs b/src/chorus.rs index 2d16832..1dc86dd 100644 --- a/src/chorus.rs +++ b/src/chorus.rs @@ -120,6 +120,14 @@ impl Chorus { } } + pub fn set_depth_ms(&mut self, depth_ms: f64) { + self.state.parameters.depth_ms = depth_ms; + if self.state.sample_rate != 0.0 { + self.state.delay[1] = + (depth_ms * self.state.sample_rate * 0.001).min(self.state.delay[0] - 1.0); + } + } + fn update_delay(&mut self) { let p = self.state.parameters; let center = p.time_ms * self.state.sample_rate * 0.001; @@ -163,8 +171,10 @@ impl Chorus { let mut output = input; for ch in 0..2 { let delay = (state.delay[0] + state.delay[1] * state.sine[ch]).max(1.0); - let whole = delay as usize; - let fraction = delay - whole as f64; + // 準備時の上限は2^20 sample。u64相当のusizeとの浮動小数点変換を避ける。 + let whole = delay as u32; + let fraction = delay - f64::from(whole); + let whole = whole as usize; let a = if whole < state.valid { state.buffer[state.write.wrapping_sub(whole) & mask][ch] } else { @@ -202,6 +212,30 @@ mod tests { } } + #[test] + fn depth_update_matches_full_settings_with_live_history() { + let mut p = settings(); + let mut full = Chorus::new(p); + let mut depth = full.clone(); + depth.set_depth_ms(3.0); + p.depth_ms = 3.0; + full.set_parameters(p); + assert_eq!(depth.state.parameters, full.state.parameters); + for rate in [44100.0, 48000.0, 96000.0] { + assert!(full.prepare(rate)); + assert!(depth.prepare(rate)); + for n in 0..10000 { + if n % 37 == 0 { + p.depth_ms = (n % 101) as f64 * 0.1; + full.set_parameters(p); + depth.set_depth_ms(p.depth_ms); + } + let input = [(n as f64 * 0.13).sin(), (n as f64 * 0.37).cos()]; + assert_eq!(full.process_sample(input), depth.process_sample(input)); + } + } + } + #[test] fn integer_delay_feedback_and_fractional_readout() { for feedback in [-0.95, 0.0, 0.5, 0.95] { diff --git a/src/compressor.rs b/src/compressor.rs index b8fb1b8..d67ffc3 100644 --- a/src/compressor.rs +++ b/src/compressor.rs @@ -77,6 +77,7 @@ impl Compressor { pub fn set_parameters(&mut self, parameters: CompressorParameters) { let sample_rate = self.state.sample_rate; let old = self.state.parameters; + self.state.parameters = parameters; if parameters.attack_ms != old.attack_ms { self.state.coefficients[0] = coefficient(parameters.attack_ms, sample_rate); } @@ -87,10 +88,18 @@ impl Compressor { self.state.makeup_gain = 10.0_f64.powf(parameters.makeup_db / 20.0); } if parameters.threshold_db != old.threshold_db || parameters.knee_db != old.knee_db { - self.state.lower_gain = - 10.0_f64.powf((parameters.threshold_db - parameters.knee_db * 0.5) / 20.0); + self.update_lower_gain(); } - self.state.parameters = parameters; + } + + pub fn set_threshold_db(&mut self, threshold_db: f64) { + self.state.parameters.threshold_db = threshold_db; + self.update_lower_gain(); + } + + fn update_lower_gain(&mut self) { + let p = self.state.parameters; + self.state.lower_gain = 10.0_f64.powf((p.threshold_db - p.knee_db * 0.5) / 20.0); } pub fn reset(&mut self) { @@ -117,8 +126,11 @@ impl Compressor { if peak == 0.0 { return input.map(|sample| sample * 0.0); } - let gain = (-self.state.reduction_db * (std::f64::consts::LOG2_10 / 20.0)).exp2() - * self.state.makeup_gain; + let gain = if cfg!(target_os = "windows") { + (-self.state.reduction_db * (std::f64::consts::LN_10 / 20.0)).exp() + } else { + (-self.state.reduction_db * (std::f64::consts::LOG2_10 / 20.0)).exp2() + } * self.state.makeup_gain; let mixed_gain = (1.0 - p.mix) + gain * p.mix; input.map(|sample| sample * mixed_gain) } @@ -178,6 +190,27 @@ mod tests { } } + #[test] + fn threshold_only_update_matches_full_settings() { + let mut p = parameters(); + p.attack_ms = 10.0; + p.release_ms = 100.0; + p.knee_db = 6.0; + p.makeup_db = 3.0; + let mut direct = Compressor::new(p); + let mut full = direct.clone(); + for threshold in [-60.0, -18.0, 0.0, -30.0, -30.0] { + p.threshold_db = threshold; + direct.set_threshold_db(threshold); + full.set_parameters(p); + assert!(direct.state.parameters == full.state.parameters); + for n in 0..1000 { + let input = [(n as f64 * 0.13).sin(), (n as f64 * 0.17).cos()]; + assert_eq!(direct.process_sample(input), full.process_sample(input)); + } + } + } + #[test] fn static_curve_and_stereo_link_follow_the_requested_ratio() { let mut c = Compressor::new(parameters()); diff --git a/src/delay.rs b/src/delay.rs index 2ab354e..539a1b3 100644 --- a/src/delay.rs +++ b/src/delay.rs @@ -125,6 +125,10 @@ impl Delay { } } + pub fn set_feedback(&mut self, feedback: f64) { + self.state.parameters.feedback = feedback; + } + /// 有効フラグを確認したホストBPMを受け取る。欠測・不正値は保持する。 pub fn set_tempo(&mut self, tempo: f64) { if tempo.is_finite() && tempo > 0.0 && tempo != self.state.tempo { @@ -156,8 +160,10 @@ impl Delay { } fn read_sample(&self, delay: f64) -> [f64; 2] { - let whole = delay as usize; - let frac = delay - whole as f64; + // prepareで履歴を2^22 frames以下に制限済み。u64相当のusizeとの変換を避ける。 + let whole = delay as u32; + let frac = delay - f64::from(whole); + let whole = whole as usize; let mask = self.state.buffer.len() - 1; let index = self.state.write.wrapping_sub(whole) & mask; let a = if whole <= self.state.valid { @@ -241,6 +247,34 @@ mod tests { } } + #[test] + fn feedback_update_preserves_time_fades_and_reset_history() { + for rate in [44100.0, 48000.0, 96000.0] { + let mut full = make(rate, 0, 0.5, 0.5, 120.0); + let mut direct = full.clone(); + for n in 0..24000 { + if n % 193 == 0 { + let feedback = (n % 101) as f64 * 0.01; + full.set_parameters(DelayParameters { + feedback, + ..full.state.parameters + }); + direct.set_feedback(feedback); + } + if n == 8000 { + full.set_tempo(137.0); + direct.set_tempo(137.0); + } + if n == 16000 { + full.reset(); + direct.reset(); + } + let input = [(n as f64 * 0.13).sin(), (n as f64 * 0.37).cos()]; + assert_eq!(full.process_sample(input), direct.process_sample(input)); + } + } + } + #[test] fn full_feedback_repeats_without_decay_and_mix_leaves_dry_untouched() { let mut delay = make(48000.0, 0, 1.0, 1.0, 120.0); // 3000 samples diff --git a/src/effects.rs b/src/effects.rs index ea424f7..cce1326 100644 --- a/src/effects.rs +++ b/src/effects.rs @@ -84,16 +84,10 @@ impl Effect { } } - fn set_parameters( - &mut self, - kind: EffectType, - parameters: DistortionParameters, - delay_parameters: DelayParameters, - ) { + fn set_parameters(&mut self, kind: EffectType, parameters: DistortionParameters) { let changed = kind != self.state.kind; self.state.parameters = parameters; self.state.kind = kind; - self.state.delay.set_parameters(delay_parameters); // Off中は設定だけ更新し、種類の選択時または有効スロットの処理開始前に初期化する。 if changed || (!self.state.started && kind != EffectType::Off) { self.reset(); @@ -130,14 +124,20 @@ impl Effect { } let mut parameters = self.state.parameters; parameters.clipper = self.state.processing; - let wet = self.state.distortion.process_sample(input, ¶meters); - let fade = match remaining { - 0 => 1.0, - 1..=32 => f64::from(32 - remaining) / 32.0, - 33..=34 => 0.0, - _ => f64::from(remaining - 35) / 32.0, - }; - std::array::from_fn(|ch| dry[ch] * (1.0 - parameters.mix) + wet[ch] * parameters.mix * fade) + let mut wet = self + .state + .distortion + .process_sample(input, ¶meters) + .map(|value| value * parameters.mix); + if remaining != 0 { + let fade = match remaining { + 1..=32 => f64::from(32 - remaining) / 32.0, + 33..=34 => 0.0, + _ => f64::from(remaining - 35) / 32.0, + }; + wet = wet.map(|value| value * fade); + } + std::array::from_fn(|ch| dry[ch] * (1.0 - parameters.mix) + wet[ch]) } fn process_samples(&mut self, samples: &mut [[f64; 2]]) { @@ -304,47 +304,14 @@ impl Effects { pub fn set_parameters( &mut self, values: &[f64; parameters::COUNT], - previous: &[f64; parameters::COUNT], + changes: ¶meters::ParameterChanges, ) { - for (slot, indices) in EFFECT_SLOTS.into_iter().enumerate() { - if indices.into_iter().any(|i| values[i] != previous[i]) { - if indices[8..12].iter().any(|&i| values[i] != previous[i]) { - self.state.slots[slot] - .state - .reverb - .set_parameters(parameters::reverb(values, slot)); - } - if indices[12..18].iter().any(|&i| values[i] != previous[i]) { - self.state.slots[slot] - .state - .chorus - .set_parameters(parameters::chorus(values, slot)); - } - if indices[18..23].iter().any(|&i| values[i] != previous[i]) { - self.state.slots[slot] - .state - .phaser - .set_parameters(parameters::phaser(values, slot)); - } - if indices[23..].iter().any(|&i| values[i] != previous[i]) { - self.state.slots[slot] - .state - .compressor - .set_parameters(parameters::compressor(values, slot)); - } - // 他のエフェクト設定変更でDistortionのGain換算をやり直さない。 - let distortion = if indices[1..4].iter().any(|&i| values[i] != previous[i]) { - parameters::distortion(values, slot) - } else { - self.state.slots[slot].state.parameters - }; - self.state.slots[slot].set_parameters( - parameters::EFFECT_TYPES - [parameters::to_plain(indices[0], values[indices[0]]) as usize], - distortion, - parameters::delay(values, slot), - ); - } + // 共有した変更位置を使う。|は3スロットすべての更新を実行する。 + let changed = self.set_slot_parameters::<0>(values, changes) + | self.set_slot_parameters::<1>(values, changes) + | self.set_slot_parameters::<2>(values, changes); + if !changed { + return; } let padding = self .state @@ -358,6 +325,95 @@ impl Effects { } } + fn set_slot_parameters( + &mut self, + values: &[f64; parameters::COUNT], + changes: ¶meters::ParameterChanges, + ) -> bool { + let indices = &EFFECT_SLOTS[SLOT]; + let changed = |first, last| changes.any(first, last + 1); + let kind_changed = changes.contains(indices[0]); + let distortion_changed = changed(indices[1], indices[3]); + let delay_changed = changed(indices[4], indices[6]) | (changes.contains(indices[7])); + let reverb_changed = changed(indices[8], indices[11]); + let chorus_changed = changed(indices[12], indices[17]); + let phaser_changed = changed(indices[18], indices[22]); + let compressor_changed = changed(indices[23], indices[29]); + if kind_changed + | distortion_changed + | delay_changed + | reverb_changed + | chorus_changed + | phaser_changed + | compressor_changed + { + if reverb_changed { + let reverb = &mut self.state.slots[SLOT].state.reverb; + if changed(indices[8], indices[10]) { + reverb.set_parameters(parameters::reverb(values, SLOT)); + } else { + reverb.set_mix(values[indices[11]]); + } + } + if chorus_changed { + let chorus = &mut self.state.slots[SLOT].state.chorus; + if changes.contains(indices[12]) | changed(indices[14], indices[17]) { + chorus.set_parameters(parameters::chorus(values, SLOT)); + } else { + chorus.set_depth_ms(parameters::plain_for::<76>(values[indices[13]])); + } + } + if phaser_changed { + let phaser = &mut self.state.slots[SLOT].state.phaser; + if changed(indices[19], indices[22]) { + phaser.set_parameters(parameters::phaser(values, SLOT)); + } else { + phaser.set_center_hz(parameters::plain_for::<93>(values[indices[18]])); + } + } + if compressor_changed { + let compressor = &mut self.state.slots[SLOT].state.compressor; + if changed(indices[24], indices[29]) { + compressor.set_parameters(parameters::compressor(values, SLOT)); + } else { + compressor.set_threshold_db(parameters::plain_for::<109>(values[indices[23]])); + } + } + // 他のエフェクト設定変更でDistortionのGain換算をやり直さない。 + let distortion = if distortion_changed { + if changed(indices[1], indices[2]) { + parameters::distortion(values, SLOT) + } else { + DistortionParameters { + mix: values[indices[3]], + ..self.state.slots[SLOT].state.parameters + } + } + } else { + self.state.slots[SLOT].state.parameters + }; + if delay_changed { + let delay = &mut self.state.slots[SLOT].state.delay; + if changes.contains(indices[4]) + | changes.contains(indices[6]) + | changes.contains(indices[7]) + { + delay.set_parameters(parameters::delay(values, SLOT)); + } else { + delay.set_feedback(values[indices[5]]); + } + } + let kind = if kind_changed { + parameters::EFFECT_TYPES + [parameters::to_plain(indices[0], values[indices[0]]) as usize] + } else { + self.state.slots[SLOT].state.kind + }; + self.state.slots[SLOT].set_parameters(kind, distortion); + } + kind_changed + } + pub fn reset(&mut self) { for slot in &mut self.state.slots { slot.reset(); @@ -399,8 +455,33 @@ impl Effects { for slot in &mut self.state.slots { slot.process_samples(samples); } - for sample in samples { - *sample = self.delay_sample(*sample); + self.delay_samples(samples); + } + + fn delay_samples(&mut self, samples: &mut [[f64; 2]]) { + let padding = self.state.padding; + if padding == 0 { + return; + } + if samples.len() < padding { + for sample in samples { + *sample = self.delay_sample(*sample); + } + return; + } + let previous = self.state.delay; + for (delay, input) in self.state.delay[..padding] + .iter_mut() + .zip(samples.iter().rev()) + { + *delay = *input; + } + samples.copy_within(..samples.len() - padding, padding); + for (output, delay) in samples[..padding] + .iter_mut() + .zip(previous[..padding].iter().rev()) + { + *output = *delay; } } @@ -430,7 +511,10 @@ mod tests { values[mix] = 0.3 + slot as f64 * 0.2; } let mut effects = Effects::new(); - effects.set_parameters(&values, ¶meters::defaults()); + effects.set_parameters( + &values, + ¶meters::ParameterChanges::new(&values, ¶meters::defaults()), + ); (values, effects) } @@ -474,7 +558,7 @@ mod tests { for [_, _, _, mix, ..] in EFFECT_SLOTS { p[mix] = 0.0; } - effects.set_parameters(&p, &previous); + effects.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); for n in 0..16 { let input = if n == 0 { [0.75, -0.25] } else { [0.0; 2] }; let expected = if n == LATENCY { @@ -490,6 +574,32 @@ mod tests { } } + #[test] + fn padding_blocks_preserve_history_at_every_short_length() { + let (mut values, mut scalar) = configured(0); + let mut blocks = scalar.clone(); + for mask in [0, 1, 3, 7, 5, 2, 6, 4, 0] { + let previous = values; + for (slot, [kind, ..]) in EFFECT_SLOTS.into_iter().enumerate() { + values[kind] = parameters::to_normalized( + kind, + if mask & (1 << slot) == 0 { 0.0 } else { 4.0 }, + ); + } + let changes = parameters::ParameterChanges::new(&values, &previous); + scalar.set_parameters(&values, &changes); + blocks.set_parameters(&values, &changes); + for length in [0, 1, 2, 3, 4, 31, 256, 2, 1, 0] { + let mut samples: Vec<_> = (0..length) + .map(|n| [(n as f64 * 0.13).sin(), (n as f64 * 0.37).cos()]) + .collect(); + let expected: Vec<_> = samples.iter().map(|&x| scalar.process_sample(x)).collect(); + blocks.process_samples(&mut samples); + assert_eq!(samples, expected, "mask={mask} length={length}"); + } + } + } + #[test] fn blocks_match_samples_during_selection_and_clipper_changes() { let (mut p, mut scalar) = configured(7); @@ -505,8 +615,8 @@ mod tests { p[clipper] = (step % 2) as f64; p[gain] = (step % 7) as f64 / 6.0; p[mix] = (step % 5) as f64 / 4.0; - scalar.set_parameters(&p, &previous); - blocks.set_parameters(&p, &previous); + scalar.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); + blocks.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); let len = [0, 1, 2, 31, 32, 33, 127, 256][step % 8]; let mut samples: Vec<_> = (0..len) .map(|n| [(n as f64 * 0.17).sin(), (n as f64 * 0.19).cos()]) @@ -531,7 +641,7 @@ mod tests { p[feedback] = (step % 6) as f64 / 5.0; p[mix] = (step % 5) as f64 / 4.0; for effects in [&mut scalar, &mut blocks] { - effects.set_parameters(&p, &previous); + effects.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); effects.set_tempo(120.0 + step as f64 * 2.0); } let mut samples: Vec<_> = (0..1024) @@ -545,13 +655,13 @@ mod tests { for [kind, ..] in EFFECT_SLOTS { p[kind] = 0.0; } - scalar.set_parameters(&p, &previous); + scalar.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); scalar.process_samples(&mut [[0.0; 2]; 32]); let previous = p; for [kind, ..] in EFFECT_SLOTS { p[kind] = parameters::to_normalized(kind, 3.0); } - scalar.set_parameters(&p, &previous); + scalar.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); for _ in 0..24000 { assert_eq!(scalar.process_sample([0.0; 2]), [0.0; 2]); } @@ -571,8 +681,8 @@ mod tests { p[i] = ((step + j + slot) % 11) as f64 / 10.0; } } - scalar.set_parameters(&p, &previous); - blocks.set_parameters(&p, &previous); + scalar.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); + blocks.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); let len = [0, 1, 17, 63, 64, 65, 257][step % 7]; let mut samples: Vec<_> = (0..len) .map(|n| [(n as f64 * 0.2).sin(), (n as f64 * 0.07).cos()]) @@ -605,7 +715,10 @@ mod tests { } let mut effects = Effects::new(); assert!(effects.prepare(48000.0, &values)); - effects.set_parameters(&values, ¶meters::defaults()); + effects.set_parameters( + &values, + ¶meters::ParameterChanges::new(&values, ¶meters::defaults()), + ); let mut reference: [Compressor; 3] = std::array::from_fn(|slot| { let mut c = Compressor::new(parameters::compressor(&values, slot)); assert!(c.prepare(48000.0)); @@ -644,8 +757,8 @@ mod tests { p[i] = ((step + j + slot) % 11) as f64 / 10.0; } } - scalar.set_parameters(&p, &previous); - blocks.set_parameters(&p, &previous); + scalar.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); + blocks.set_parameters(&p, ¶meters::ParameterChanges::new(&p, &previous)); let len = [0, 1, 17, 63, 64, 65, 257][step % 7]; let mut samples: Vec<_> = (0..len) .map(|n| [(n as f64 * 0.2).sin(), (n as f64 * 0.07).cos()]) @@ -665,7 +778,10 @@ mod tests { let previous = p; parameters::swap_effects(&mut p, 0); let mut reversed = Effects::new(); - reversed.set_parameters(&p, ¶meters::defaults()); + reversed.set_parameters( + &p, + ¶meters::ParameterChanges::new(&p, ¶meters::defaults()), + ); let mut difference = 0.0; for n in 0..200 { let input = [(n as f64 * 0.1).sin(); 2]; @@ -693,13 +809,12 @@ mod tests { parameters::phaser(¶meters::defaults(), 0), parameters::compressor(¶meters::defaults(), 0), ); - effect.set_parameters(EffectType::Distortion, p, delay_parameters); + effect.set_parameters(EffectType::Distortion, p); let mut dry = [0.0; 2]; for clipper in [ClipperType::Soft, ClipperType::Hard, ClipperType::None] { effect.set_parameters( EffectType::Distortion, DistortionParameters { clipper, ..p }, - delay_parameters, ); for n in 0..100 { let input = [n as f64 / 100.0, -(n as f64) / 100.0]; diff --git a/src/eq.rs b/src/eq.rs index 52d888f..f12dc51 100644 --- a/src/eq.rs +++ b/src/eq.rs @@ -66,6 +66,10 @@ impl Eq { self.state.parameters.enabled } + pub fn parameters(&self) -> EqParameters { + self.state.parameters + } + pub fn set_parameters(&mut self, parameters: EqParameters) { let old = self.state.parameters; self.state.parameters = parameters; diff --git a/src/filter.rs b/src/filter.rs index 5a5052c..60b5160 100644 --- a/src/filter.rs +++ b/src/filter.rs @@ -81,8 +81,8 @@ struct SvfCoefficients { pub struct SvfState { /// 台形積分器の履歴。[帯域通過側, 低域通過側]。設定変更時も保持する。 integrators: [f64; 2], - /// 最後に使用した係数。未計算時はNone。 - coefficients: Option<(FilterParameters, f64, SvfCoefficients)>, + /// 最後に使用した係数。検証済み正レートのbitを非ゼロ整数で保持し、Noneの判別領域を共有する。 + coefficients: Option<(FilterParameters, std::num::NonZeroU64, SvfCoefficients)>, } /// TPT SVFの処理。Stateは積分器の履歴と計算済み係数を保持する。 @@ -123,7 +123,7 @@ impl Svf { ) -> SvfCoefficients { if let Some((previous, rate, cached)) = self.state.coefficients && previous == *parameters - && rate == sample_rate + && rate.get() == sample_rate.to_bits() { return cached; } @@ -134,10 +134,15 @@ impl Svf { // Qも同じなら全係数を再利用し、次回の高速判定用に要求値だけ更新する。 let g = match self.state.coefficients { Some((previous, rate, cached)) - if previous.cutoff_hz.clamp(20.0, 20_000.0) == cutoff_hz && rate == sample_rate => + if previous.cutoff_hz.clamp(20.0, 20_000.0) == cutoff_hz + && rate.get() == sample_rate.to_bits() => { if previous.resonance_q == parameters.resonance_q { - self.state.coefficients = Some((*parameters, sample_rate, cached)); + self.state.coefficients = Some(( + *parameters, + std::num::NonZeroU64::new(sample_rate.to_bits()).unwrap(), + cached, + )); return cached; } cached.g @@ -150,7 +155,11 @@ impl Svf { damping_plus_g: damping + g, inverse_denominator: 1.0 / (1.0 + g * (g + damping)), }; - self.state.coefficients = Some((*parameters, sample_rate, coefficients)); + self.state.coefficients = Some(( + *parameters, + std::num::NonZeroU64::new(sample_rate.to_bits()).unwrap(), + coefficients, + )); coefficients } diff --git a/src/limiter.rs b/src/limiter.rs index 3a479d3..fc7b1db 100644 --- a/src/limiter.rs +++ b/src/limiter.rs @@ -120,7 +120,14 @@ impl Limiter { self.state.sum = 0.0; } + #[inline(never)] pub fn process_sample(&mut self, input: [f64; 2]) -> [f64; 2] { + self.process_one_sample(input) + } + + /// 系列ではloop内へ展開し、単sampleの呼出し側を大きくしない。 + #[inline(always)] + fn process_one_sample(&mut self, input: [f64; 2]) -> [f64; 2] { let s = &mut self.state; let peak = input[0].abs().max(input[1].abs()); let size = s.history.len(); @@ -167,7 +174,7 @@ impl Limiter { pub fn process_samples(&mut self, samples: &mut [[f64; 2]]) { for sample in samples { - *sample = self.process_sample(*sample); + *sample = self.process_one_sample(*sample); } } } diff --git a/src/oscillator.rs b/src/oscillator.rs index 56547cf..527c9a5 100644 --- a/src/oscillator.rs +++ b/src/oscillator.rs @@ -127,7 +127,7 @@ pub struct OscillatorInput { pub frequency_hz: f64, /// 波形を読む位置への位相変調(周期単位)。有限のi32範囲を受け取り、保持位相には累積しない。 pub phase_modulation: f64, - /// 位相変調が有効な周期波には2階ADAAを適用する。瞬間的に変調量0でも有効。 + /// 位相変調を有効にし、周期波には2階ADAAを適用する。falseでは保持位相を直接読む。 pub phase_modulated: bool, /// 音量AHDSRの発音期間。release中もtrue、終了・停止後はfalse。 pub active: bool, @@ -178,8 +178,8 @@ pub struct OscillatorState { note_generation: u64, /// 周波数倍率の計算に使った(ユニゾン数, Detune)。初期値の0音は未計算を表す。 unison_input: (u32, f64), - /// 位相増分・帯域選択の計算に使った(基音Hz, サンプルレート, 波形)。初期レート0は未計算。 - frequency_input: (f64, f64, Waveform), + /// 位相増分・帯域選択を準備した(基音Hz, レート, 波形, 位相変調の有無)。初期レート0は未計算。 + frequency_input: (f64, f64, Waveform, u8), /// 各ユニゾンの帯域とクロスフェード係数。 bands: [wavetable::Selection; 7], /// 各ユニゾンの基音に対する周波数倍率。入力の音程幅が変わったときだけ更新する。 @@ -189,6 +189,7 @@ pub struct OscillatorState { } /// 同じサンプル時刻の、音量・定位適用前のユニゾン波形。 +#[allow(dead_code)] // 入力検証付きの単体入口。音源は出力配列を直接渡す。 pub struct OscillatorSample { /// 理想波形のピーク振幅1を基準とする生波形。帯域制限のオーバーシュートを含み、未使用要素は0。 pub values: [f64; 7], @@ -216,7 +217,7 @@ impl Oscillator { noise: Random::new(), note_generation: 0, unison_input: (0, 0.0), - frequency_input: (0.0, 0.0, Waveform::Sine), + frequency_input: (0.0, 0.0, Waveform::Sine, 0), bands: [wavetable::Selection::EMPTY; 7], frequency_ratios: [1.0; 7], phase_increments: [0.0; 7], @@ -271,7 +272,9 @@ impl Oscillator { // SAFETY: 上の検証で入力とレートの全条件を満たすことを確認した。 unsafe { self.prepare_sample(input, sample_rate); - self.generate_prepared_sample::(input) + let mut values = [0.0; 7]; + let count = self.generate_prepared_sample::(input, &mut values); + OscillatorSample { values, count } } } @@ -302,118 +305,112 @@ impl Oscillator { } } - /// 反映済みの定常入力から1サンプルを生成する。 + /// 反映済みの定常入力から1サンプルをvaluesへ生成し、有効な先頭要素数を返す。 + /// 呼出し元は返された要素数だけを使用する。OUTPUT=falseでは状態だけを更新する。 /// /// # Safety /// 直前のprepare_sampleとwaveform・frequency_hz・unison_voices・ /// detune_cents・note_generation・phase_mode・phase_modulatedが同じこと。 /// activeがfalseからtrueへ変わる場合は、改めてprepare_sampleで準備すること。 /// phase_modulationは変化してよいが、有限のi32範囲内であること。 + /// SINGLE=trueでは発音中の実発音数が1であること。 #[inline] - pub(super) unsafe fn generate_prepared_sample( + pub(super) unsafe fn generate_prepared_sample( &mut self, input: &OscillatorInput, - ) -> OscillatorSample { + values: &mut [f64; 7], + ) -> usize { debug_assert!(input.is_valid()); if !input.active { self.state.valid = false; - return OscillatorSample { - values: [0.; 7], - count: 0, - }; + return 0; } - let sample = self.generate_waveform_sample::(input); - self.update_sample(); - sample + debug_assert!(!SINGLE || self.state.rendered_count == 1); + self.generate_waveform_sample::(input, values); + self.update_sample::(); + if SINGLE { 1 } else { self.state.rendered_count } } /// 位相変調は読出し位置だけへ適用する。Noiseはユニゾンごとに乱数を一つ進める。 #[inline(always)] - fn generate_waveform_sample( + fn generate_waveform_sample( &mut self, input: &OscillatorInput, - ) -> OscillatorSample { + values: &mut [f64; 7], + ) { match input.waveform { Waveform::Noise => { self.state.valid = false; - let count = self.state.rendered_count; - let mut values = [0.0; 7]; + let count = if SINGLE { 1 } else { self.state.rendered_count }; for value in &mut values[..count] { - *value = 2.0 * self.state.noise.next_f64() - 1.0; + let noise = self.state.noise.next_f64(); + if OUTPUT { + *value = 2.0 * noise - 1.0; + } } - OscillatorSample { values, count } } - Waveform::Sine => self.generate_periodic_sample::(input), - _ => self.generate_bandlimited_sample::(input), + Waveform::Sine => self.generate_periodic_sample::(input, values), + _ => self.generate_bandlimited_sample::(input, values), } } // 帯域別のループを分離してSine/Noiseを小さく保ち、ユニゾンごとの関数呼出しを省く。 #[inline(never)] - fn generate_bandlimited_sample( + fn generate_bandlimited_sample( &mut self, input: &OscillatorInput, - ) -> OscillatorSample { - self.generate_periodic_sample::(input) + values: &mut [f64; 7], + ) { + self.generate_periodic_sample::(input, values) } /// 波形別に展開する周期波の読出し。位相変調の処理は両経路で共通にする。 #[inline(always)] - fn generate_periodic_sample( + fn generate_periodic_sample( &mut self, input: &OscillatorInput, - ) -> OscillatorSample { - let count = self.state.rendered_count; - let mut values = [0.0; 7]; + values: &mut [f64; 7], + ) { + let count = if SINGLE { 1 } else { self.state.rendered_count }; if input.phase_modulated { - return self.generate_antialiased_sample::(input); + self.generate_antialiased_sample::(input, values); + return; } self.state.valid = false; if !OUTPUT { - return OscillatorSample { values, count }; + return; } - // 整数周期を先に除き、±1/±2回転では元の位相を厳密に保持する。 - // SAFETY: generate_prepared_sampleの契約で、位相変調は有限のi32範囲内。 - let cycles = unsafe { input.phase_modulation.to_int_unchecked::() }; - let offset = input.phase_modulation - f64::from(cycles); - if offset == 0.0 { - for (k, (value, &phase)) in values[..count] - .iter_mut() - .zip(&self.state.phases) - .enumerate() - { - *value = if BANDED { - self.state.bands[k].generate_sample(input.waveform, phase) - } else { - sine_sample(phase) - }; + if BANDED { + let pairs = count / 2; + for pair in 0..pairs { + let k = pair * 2; + let sample = wavetable::Selection::generate_pair_sample( + &self.state.bands[k], + &self.state.bands[k + 1], + input.waveform, + [self.state.phases[k], self.state.phases[k + 1]], + ); + values[k..k + 2].copy_from_slice(&sample); + } + if count % 2 != 0 { + let k = count - 1; + values[k] = + self.state.bands[k].generate_sample(input.waveform, self.state.phases[k]); } } else { - for (k, (value, &phase)) in values[..count] - .iter_mut() - .zip(&self.state.phases) - .enumerate() - { - let position = phase + offset; - let wrapped = position + f64::from((position < 0.0) as u8) - - f64::from((position >= 1.0) as u8); - *value = if BANDED { - self.state.bands[k].generate_sample(input.waveform, wrapped) - } else { - sine_sample(wrapped) - }; + for (value, &phase) in values[..count].iter_mut().zip(&self.state.phases) { + *value = sine_sample(phase); } } - OscillatorSample { values, count } } #[inline(never)] - fn generate_antialiased_sample( + fn generate_antialiased_sample( &mut self, input: &OscillatorInput, - ) -> OscillatorSample { - let count = self.state.rendered_count; - let mut values = [0.; 7]; + values: &mut [f64; 7], + ) { + let count = if SINGLE { 1 } else { self.state.rendered_count }; for (k, value) in values[..count].iter_mut().enumerate() { let phase = self.state.phases[k]; let q = phase + input.phase_modulation; @@ -432,7 +429,6 @@ impl Oscillator { self.state.history[k] = [q - wrap, b - wrap]; } self.state.valid = true; - OscillatorSample { values, count } } #[cfg(test)] @@ -461,7 +457,12 @@ impl Oscillator { self.state.unison_input = unison; } let count = self.state.rendered_count; - let frequency = (input.frequency_hz, sample_rate, input.waveform); + let frequency = ( + input.frequency_hz, + sample_rate, + input.waveform, + u8::from(input.phase_modulated), + ); if changed || self.state.frequency_input != frequency { if self.state.frequency_input.2 != input.waveform { self.state.valid = false; @@ -482,7 +483,10 @@ impl Oscillator { }, ); } - self.state.bank[k] = adaa::Bank::new(input.waveform, (hz / sample_rate).min(1.0)); + if input.phase_modulated { + self.state.bank[k] = + adaa::Bank::new(input.waveform, (hz / sample_rate).min(1.0)); + } // 通常音程では剰余を省く。高周波では除算のオーバーフローを防ぐ。 *increment = if hz < sample_rate { hz @@ -495,9 +499,10 @@ impl Oscillator { } /// 発音中のサンプル生成後に、定常入力を用いて内部状態を1サンプル分進める。 - fn update_sample(&mut self) { + fn update_sample(&mut self) { // generate_prepared_sampleが発音中であることを確認してから呼ぶ。 - for (phase, increment) in self.state.phases[..self.state.rendered_count] + let count = if SINGLE { 1 } else { self.state.rendered_count }; + for (phase, increment) in self.state.phases[..count] .iter_mut() .zip(&self.state.phase_increments) { @@ -514,6 +519,54 @@ mod tests { const BANDLIMITED: [Waveform; 3] = [Waveform::Triangle, Waveform::Square, Waveform::Sawtooth]; + #[test] + fn single_voice_path_preserves_samples_and_state_at_changes() { + for waveform in [ + Waveform::Sine, + Waveform::Triangle, + Waveform::Square, + Waveform::Sawtooth, + Waveform::Noise, + ] { + let mut reference = Oscillator::new(); + reference.state.phases = [1.0; 7]; + let mut single = reference.clone(); + let mut input = OscillatorInput { + waveform, + ..test_input() + }; + for step in 0..384 { + let rate = [44100.0, 48000.0, 96000.0][step / 128]; + input.frequency_hz = [0.0, 440.0, 20000.0, 96000.0][step % 4]; + input.phase_mode = [PhaseMode::Keep, PhaseMode::Zero, PhaseMode::Random][step % 3]; + input.note_generation = (step / 17 + 1) as u64; + input.active = step % 19 != 0; + input.phase_modulated = step / 31 % 2 == 0; + input.phase_modulation = (step % 23) as f64 / 5.0 - 2.0; + let expected = reference.generate_sample(&input, rate); + let mut values = [f64::NAN; 7]; + // SAFETY: inputとrateは有効で、実発音数は常に1。 + let count = unsafe { + single.prepare_sample(&input, rate); + single.generate_prepared_sample::(&input, &mut values) + }; + assert_eq!(count, expected.count); + for (a, b) in values[..count].iter().zip(&expected.values) { + assert_eq!(a.to_bits(), b.to_bits()); + } + assert_eq!(single.state.phases, reference.state.phases); + assert_eq!(single.state.history, reference.state.history); + assert_eq!(single.state.valid, reference.state.valid); + // 出力しない場合も、位相・ADAA履歴・Noise列は同じだけ進む。 + reference.advance_sample(&input, rate); + // SAFETY: 直前から同じ定常入力を保ち、実発音数も1。 + unsafe { + single.generate_prepared_sample::(&input, &mut values); + } + } + } + } + #[test] #[cfg_attr(miri, ignore)] // 多数のFourier係数との数値照合は通常のCPUテストで行う。 fn bandlimited_samples_match_retained_fourier_harmonics() { @@ -690,7 +743,7 @@ mod tests { } #[test] - fn phase_modulation_wraps_without_changing_stored_phase() { + fn disabled_modulation_reads_held_phase_without_changing_it() { for wave in [ Waveform::Sine, Waveform::Triangle, @@ -725,8 +778,7 @@ mod tests { let result = oscillator.generate_sample(&input, 48000.0); assert_eq!(result.count, 7); for (k, phase) in before.into_iter().enumerate() { - let expected = - oscillator.read_sample(wave, (phase + offset).rem_euclid(1.0), k); + let expected = oscillator.read_sample(wave, phase, k); assert_eq!(result.values[k], expected); assert!(result.values[k].is_finite()); assert_eq!( @@ -1077,6 +1129,43 @@ mod tests { assert_eq!(oscillator.state.random, random); } + #[test] + fn enabling_modulation_uses_the_current_frequency_band() { + for wave in [ + Waveform::Sine, + Waveform::Triangle, + Waveform::Square, + Waveform::Sawtooth, + ] { + for rate in [44100.0, 96000.0] { + for hz in [55.0, 1900.0, 21000.0] { + let mut oscillator = Oscillator::new(); + let mut input = OscillatorInput { + waveform: wave, + unison_voices: 7, + detune_cents: 25.0, + frequency_hz: 440.0, + ..test_input() + }; + oscillator.generate_sample(&input, rate); + input.frequency_hz = hz; + oscillator.generate_sample(&input, rate); + input.phase_modulated = true; + input.phase_modulation = 0.234; + let expected: [f64; 7] = std::array::from_fn(|k| { + let q = oscillator.state.phases[k] + input.phase_modulation; + let inc = oscillator.state.phase_increments[k]; + let bank = + adaa::Bank::new(wave, (hz * input.frequency_ratio(k) / rate).min(1.0)); + bank.generate_sample(q, q - inc, q - 2.0 * inc) + }); + let actual = oscillator.generate_sample(&input, rate); + assert_eq!(actual.values.map(f64::to_bits), expected.map(f64::to_bits)); + } + } + } + } + #[test] fn smoothing_tracks_unwrapped_phase_and_resets_new_unison_slots() { let mut oscillator = Oscillator::new(); @@ -1332,13 +1421,13 @@ mod tests { } #[test] - fn frequency_changes_preserve_phase_and_modulation_is_not_accumulated() { + fn frequency_changes_preserve_phase_and_disabled_modulation_is_ignored() { let mut oscillator = sustained(); let mut input = test_input(); assert_eq!(oscillator.generate_sample(&input, 4.0).values[0], 0.0); input.frequency_hz = 2.0; input.phase_modulation = 0.25; - assert_eq!(oscillator.generate_sample(&input, 8.0).values[0], 0.0); + assert_eq!(oscillator.generate_sample(&input, 8.0).values[0], 1.0); input.phase_modulation = 0.0; assert_eq!(oscillator.generate_sample(&input, 8.0).values[0], 0.0); assert_eq!(oscillator.generate_sample(&input, 8.0).values[0], -1.0); diff --git a/src/oscillator/wavetable.rs b/src/oscillator/wavetable.rs index 4afa136..223e52e 100644 --- a/src/oscillator/wavetable.rs +++ b/src/oscillator/wavetable.rs @@ -27,13 +27,51 @@ impl Table { // 生成済みテーブルのlengthは最大131072なのでpositionは有限の[0,65536]。 let index = unsafe { position.to_int_unchecked::() }; let t = position - f64::from(index); - let at = self.offset + index as usize * 16; + let at = self.offset + index as u32 as usize * 16; let bytes: &[u8; 16] = COEFFICIENTS[at..at + 16].try_into().unwrap(); let coefficient = |i| f64::from(f32::from_le_bytes(bytes[i..i + 4].try_into().unwrap())); coefficient(0) + t * (coefficient(4) + t * (coefficient(8) + t * coefficient(12))) } } +/// 同一時刻の2ユニゾンを同じHorner順で評価する。 +#[inline] +fn read_pair_sample( + a: &Table, + b: &Table, + phase: std::arch::x86_64::__m128d, +) -> std::arch::x86_64::__m128d { + use std::arch::x86_64::*; + // SAFETY: x86_64必須のSSE2だけを使う。位相の折返しと生成済みlengthから + // positionは有限の[0,65536]。各読出しは範囲検査済みの16byteセル内。 + unsafe { + let position = _mm_mul_pd(phase, _mm_set_pd(b.length, a.length)); + let indexes = _mm_cvttpd_epi32(position); + let i = _mm_cvtsi128_si32(indexes) as u32 as usize; + let j = _mm_cvtsi128_si32(_mm_shuffle_epi32::<0x55>(indexes)) as u32 as usize; + let at_a = a.offset + i * 16; + let at_b = b.offset + j * 16; + let bytes_a = &COEFFICIENTS[at_a..at_a + 16]; + let bytes_b = &COEFFICIENTS[at_b..at_b + 16]; + let a = _mm_loadu_ps(bytes_a.as_ptr().cast::()); + let b = _mm_loadu_ps(bytes_b.as_ptr().cast::()); + let lo = _mm_unpacklo_ps(a, b); + let hi = _mm_unpackhi_ps(a, b); + let c0 = _mm_cvtps_pd(lo); + let c1 = _mm_cvtps_pd(_mm_movehl_ps(lo, lo)); + let c2 = _mm_cvtps_pd(hi); + let c3 = _mm_cvtps_pd(_mm_movehl_ps(hi, hi)); + let t = _mm_sub_pd(position, _mm_cvtepi32_pd(indexes)); + _mm_add_pd( + c0, + _mm_mul_pd( + t, + _mm_add_pd(c1, _mm_mul_pd(t, _mm_add_pd(c2, _mm_mul_pd(t, c3)))), + ), + ) + } +} + fn tables(wave: Waveform) -> &'static [Table] { match wave { Waveform::Sawtooth => &data::SAW, @@ -88,6 +126,41 @@ impl Selection { } } + /// 同一時刻の2ユニゾンを並列に読む。各位相は有限の[0,1]。 + #[inline(always)] + pub fn generate_pair_sample(a: &Self, b: &Self, wave: Waveform, phases: [f64; 2]) -> [f64; 2] { + use std::arch::x86_64::*; + // SAFETY: x86_64必須のSSE2。load/storeは2要素の配列内。 + unsafe { + let phase = _mm_loadu_pd(phases.as_ptr()); + let half_cycle = _mm_set1_pd(0.5); + let sign_bit = _mm_set1_pd(-0.0); + let half = _mm_sub_pd( + half_cycle, + _mm_andnot_pd(sign_bit, _mm_sub_pd(phase, half_cycle)), + ); + let folded = if wave == Waveform::Sawtooth { + half + } else { + let quarter = _mm_set1_pd(0.25); + _mm_sub_pd(quarter, _mm_andnot_pd(sign_bit, _mm_sub_pd(half, quarter))) + }; + let mut value = read_pair_sample(a.hi, b.hi, folded); + if a.mix != 0.0 || b.mix != 0.0 { + let mix = _mm_set_pd(b.mix, a.mix); + let low = read_pair_sample(a.lo, b.lo, folded); + let blended = _mm_add_pd(value, _mm_mul_pd(_mm_sub_pd(low, value), mix)); + let changed = _mm_cmpneq_pd(mix, _mm_setzero_pd()); + value = _mm_or_pd(_mm_and_pd(changed, blended), _mm_andnot_pd(changed, value)); + } + let signs = _mm_and_pd(sign_bit, _mm_sub_pd(half_cycle, phase)); + let gain = _mm_or_pd(_mm_set_pd(b.gain, a.gain), signs); + let mut result = [0.0; 2]; + _mm_storeu_pd(result.as_mut_ptr(), _mm_mul_pd(value, gain)); + result + } + } + /// phaseは発振器の保持位相または変調後の、有限の[0,1]。 #[inline(always)] // 帯域別のユニゾンループ内へ展開し、サンプルごとの呼出しを省く。 pub fn generate_sample(&self, wave: Waveform, phase: f64) -> f64 { @@ -139,6 +212,31 @@ mod tests { } } + #[test] + fn paired_unison_matches_scalar_cells_and_crossfades() { + for wave in [Waveform::Sawtooth, Waveform::Square, Waveform::Triangle] { + for table in tables(wave) { + for factor in [0.88, 0.91, 0.95, 0.999, 1.01] { + let a = Selection::new(wave, factor * 0.5 / table.harmonic); + let b = Selection::new(wave, factor * 0.5 / (table.harmonic * 1.013)); + let steps = if cfg!(miri) { 4 } else { 1024 }; + for n in 0..=steps { + let phases = [ + f64::from(n) / f64::from(steps), + f64::from((n * 137) % (steps + 1)) / f64::from(steps), + ]; + let actual = Selection::generate_pair_sample(&a, &b, wave, phases); + let expected = [ + a.generate_sample(wave, phases[0]), + b.generate_sample(wave, phases[1]), + ]; + assert_eq!(actual.map(f64::to_bits), expected.map(f64::to_bits)); + } + } + } + } + } + #[test] fn generated_table_positions_fit_fast_integer_conversion() { for wave in [Waveform::Sawtooth, Waveform::Square, Waveform::Triangle] { diff --git a/src/parameters.rs b/src/parameters.rs index a6b917a..11a9710 100644 --- a/src/parameters.rs +++ b/src/parameters.rs @@ -54,7 +54,7 @@ pub const DELAY_BEATS: [&str; 14] = [ ]; /// 同じ種類の設定は全スロットで同じ単位・量子化を用いる。 -pub fn control_kind(index: usize) -> usize { +pub const fn control_kind(index: usize) -> usize { match index { PORTAMENTO => 1, // AHDSRと同じ時間軸。 45 | 48 => 31, @@ -90,6 +90,68 @@ pub fn control_kind(index: usize) -> usize { } } +/// 1回の比較で得た変更位置を、Synthと各エフェクトへ共有する。 +pub(crate) struct ParameterChanges([u64; COUNT.div_ceil(64)]); + +impl ParameterChanges { + #[inline] + pub fn new(values: &[f64; COUNT], previous: &[f64; COUNT]) -> Self { + use std::arch::x86_64::*; + let mut words = [0; COUNT.div_ceil(64)]; + for (word, output) in words.iter_mut().enumerate().take(COUNT / 64) { + for group in 0..4 { + let offset = word * 64 + group * 16; + // 対応するx86_64ではSSE2を常備する。offset..offset+16は両配列内。 + // !=比較はNaNを変更、+0/-0を同値とし、符号付きpackは-1/0を保持する。 + let bits = unsafe { + let pairs = std::array::from_fn::<_, 8, _>(|pair| { + _mm_cmpneq_pd( + _mm_loadu_pd(values.as_ptr().add(offset + pair * 2)), + _mm_loadu_pd(previous.as_ptr().add(offset + pair * 2)), + ) + }); + let quarters = std::array::from_fn::<_, 4, _>(|i| { + _mm_castps_si128(_mm_shuffle_ps::<0x88>( + _mm_castpd_ps(pairs[2 * i]), + _mm_castpd_ps(pairs[2 * i + 1]), + )) + }); + _mm_movemask_epi8(_mm_packs_epi16( + _mm_packs_epi32(quarters[0], quarters[1]), + _mm_packs_epi32(quarters[2], quarters[3]), + )) + }; + *output |= (bits as u64) << (group * 16); + } + } + for index in COUNT / 64 * 64..COUNT { + words[index / 64] |= u64::from(values[index] != previous[index]) << (index % 64); + } + Self(words) + } + + #[inline] + pub fn contains(&self, index: usize) -> bool { + self.0[index / 64] & (1 << (index % 64)) != 0 + } + + #[inline] + pub fn any(&self, first: usize, end: usize) -> bool { + let first_word = first / 64; + let last_word = (end - 1) / 64; + let low = u64::MAX << (first % 64); + let high = u64::MAX >> (63 - (end - 1) % 64); + if first_word == last_word { + self.0[first_word] & low & high != 0 + } else { + (self.0[first_word] & low | self.0[last_word] & high) != 0 + || self.0[first_word + 1..last_word] + .iter() + .any(|word| *word != 0) + } + } +} + /// 隣接スロットの種類と全設定を交換する。ホストのIDは移動しない。 pub fn swap_effects(values: &mut [f64; COUNT], first: usize) { for (a, b) in EFFECT_SLOTS[first].into_iter().zip(EFFECT_SLOTS[first + 1]) { @@ -646,7 +708,17 @@ pub fn tick_to_plain(index: usize, tick: u32) -> f64 { } } pub fn to_plain(index: usize, normalized: f64) -> f64 { - let index = control_kind(index); + control_to_plain(control_kind(index), normalized) +} + +/// 対象コントロールが既知のDSPでは、種別の検索をコンパイル時に済ませる。 +#[inline] +pub fn plain_for(normalized: f64) -> f64 { + control_to_plain(const { control_kind(INDEX) }, normalized) +} + +#[inline] +fn control_to_plain(index: usize, normalized: f64) -> f64 { if is_volume(index) { return if normalized == 0.0 { f64::NEG_INFINITY @@ -982,8 +1054,8 @@ pub fn eq(values: &[f64; COUNT]) -> crate::eq::EqParameters { pub fn distortion(values: &[f64; COUNT], slot: usize) -> DistortionParameters { let [_, clipper, gain, mix, ..] = EFFECT_SLOTS[slot]; DistortionParameters { - clipper: CLIPPER_TYPES[to_plain(clipper, values[clipper]) as usize], - gain: 10.0_f64.powf(to_plain(gain, values[gain]) / 20.0), + clipper: CLIPPER_TYPES[plain_for::<31>(values[clipper]) as usize], + gain: 10.0_f64.powf(plain_for::<32>(values[gain]) / 20.0), mix: values[mix], } } @@ -991,8 +1063,8 @@ pub fn distortion(values: &[f64; COUNT], slot: usize) -> DistortionParameters { pub fn delay(values: &[f64; COUNT], slot: usize) -> crate::delay::DelayParameters { let [_, _, _, _, beat, feedback, mix, stereo, ..] = EFFECT_SLOTS[slot]; crate::delay::DelayParameters { - division: to_plain(beat, values[beat]) as usize, - stereo: DELAY_STEREO_MODES[to_plain(stereo, values[stereo]) as usize], + division: plain_for::<51>(values[beat]) as usize, + stereo: DELAY_STEREO_MODES[plain_for::<60>(values[stereo]) as usize], feedback: values[feedback], mix: values[mix], } @@ -1001,9 +1073,9 @@ pub fn delay(values: &[f64; COUNT], slot: usize) -> crate::delay::DelayParameter pub fn reverb(values: &[f64; COUNT], slot: usize) -> crate::reverb::ReverbParameters { let [_, _, _, _, _, _, _, _, decay, damping, size, mix, ..] = EFFECT_SLOTS[slot]; crate::reverb::ReverbParameters { - decay_seconds: to_plain(decay, values[decay]), - damping_hz: to_plain(damping, values[damping]), - size: to_plain(size, values[size]) / 100.0, + decay_seconds: plain_for::<63>(values[decay]), + damping_hz: plain_for::<64>(values[damping]), + size: plain_for::<65>(values[size]) / 100.0, mix: values[mix], } } @@ -1012,11 +1084,11 @@ pub fn chorus(values: &[f64; COUNT], slot: usize) -> crate::chorus::ChorusParame let [time, depth, rate, detune, feedback, mix] = [12, 13, 14, 15, 16, 17].map(|i| EFFECT_SLOTS[slot][i]); crate::chorus::ChorusParameters { - time_ms: to_plain(time, values[time]), - depth_ms: to_plain(depth, values[depth]), - rate_hz: to_plain(rate, values[rate]), - detune: to_plain(detune, values[detune]), - feedback: to_plain(feedback, values[feedback]) / 100.0, + time_ms: plain_for::<75>(values[time]), + depth_ms: plain_for::<76>(values[depth]), + rate_hz: plain_for::<77>(values[rate]), + detune: plain_for::<78>(values[detune]), + feedback: plain_for::<79>(values[feedback]) / 100.0, mix: values[mix], } } @@ -1024,10 +1096,10 @@ pub fn chorus(values: &[f64; COUNT], slot: usize) -> crate::chorus::ChorusParame pub fn phaser(values: &[f64; COUNT], slot: usize) -> crate::phaser::PhaserParameters { let [center, depth, rate, feedback, mix] = [18, 19, 20, 21, 22].map(|i| EFFECT_SLOTS[slot][i]); crate::phaser::PhaserParameters { - center_hz: to_plain(center, values[center]), - depth_cents: to_plain(depth, values[depth]), - rate_hz: to_plain(rate, values[rate]), - feedback: to_plain(feedback, values[feedback]) / 100.0, + center_hz: plain_for::<93>(values[center]), + depth_cents: plain_for::<94>(values[depth]), + rate_hz: plain_for::<95>(values[rate]), + feedback: plain_for::<96>(values[feedback]) / 100.0, mix: values[mix], } } @@ -1035,12 +1107,12 @@ pub fn phaser(values: &[f64; COUNT], slot: usize) -> crate::phaser::PhaserParame pub fn compressor(values: &[f64; COUNT], slot: usize) -> crate::compressor::CompressorParameters { let [.., threshold, ratio, attack, release, knee, makeup, mix] = EFFECT_SLOTS[slot]; crate::compressor::CompressorParameters { - threshold_db: to_plain(threshold, values[threshold]), - ratio: to_plain(ratio, values[ratio]), - attack_ms: to_plain(attack, values[attack]), - release_ms: to_plain(release, values[release]), - knee_db: to_plain(knee, values[knee]), - makeup_db: to_plain(makeup, values[makeup]), + threshold_db: plain_for::<109>(values[threshold]), + ratio: plain_for::<110>(values[ratio]), + attack_ms: plain_for::<111>(values[attack]), + release_ms: plain_for::<112>(values[release]), + knee_db: plain_for::<113>(values[knee]), + makeup_db: plain_for::<114>(values[makeup]), mix: values[mix], } } @@ -1347,6 +1419,57 @@ pub unsafe fn write_state(stream: This, values: [f64; COUNT]) -> TResult { mod tests { use super::*; + #[test] + fn effect_fields_use_the_same_conversion_in_every_slot() { + for indices in &EFFECT_SLOTS[1..] { + for (&first, &other) in EFFECT_SLOTS[0].iter().zip(indices) { + assert_eq!(control_kind(first), control_kind(other)); + for step in 0..=100 { + let value = f64::from(step) / 100.0; + assert_eq!(to_plain(first, value), to_plain(other, value)); + } + } + } + } + + #[test] + fn change_mask_preserves_float_comparison_and_range_membership() { + let mut values = [0.0; COUNT]; + let mut previous = values; + for index in 0..COUNT { + for (a, b) in [ + (0.0, -0.0), + (0.0, 0.5), + (0.5, 0.5), + (f64::NAN, f64::NAN), + (f64::INFINITY, f64::INFINITY), + (-0.5, 0.5), + ] { + values[index] = a; + previous[index] = b; + let changes = ParameterChanges::new(&values, &previous); + for position in 0..COUNT { + assert_eq!(changes.contains(position), index == position && a != b); + } + if cfg!(miri) { + // Miriでは全SIMD laneの読出しを上で検査し、全範囲の総当たりは通常テストで行う。 + assert_eq!(changes.any(0, COUNT), a != b); + continue; + } + for first in 0..COUNT { + for end in first + 1..=COUNT { + assert_eq!( + changes.any(first, end), + (first..end).contains(&index) && a != b + ); + } + } + } + values[index] = 0.0; + previous[index] = 0.0; + } + } + #[test] fn knob_values_increase_and_round_trip_with_exact_defaults() { for (index, value) in defaults().into_iter().enumerate() { diff --git a/src/phaser.rs b/src/phaser.rs index ec4e6a8..3c69a92 100644 --- a/src/phaser.rs +++ b/src/phaser.rs @@ -85,6 +85,9 @@ impl Phaser { self.update_rate(); } } + pub fn set_center_hz(&mut self, center_hz: f64) { + self.state.parameters.center_hz = center_hz; + } fn update_rate(&mut self) { let s = &mut self.state; let cosine = (s.lfo[1] + s.lfo[0] * s.half[0]) / s.half[1]; @@ -155,6 +158,24 @@ mod tests { mix: 1.0, } } + #[test] + fn center_only_update_matches_full_settings() { + let mut p = settings(); + p.depth_cents = 1200.0; + p.feedback = 0.5; + let mut direct = Phaser::new(p); + let mut full = direct.clone(); + for n in 0..10000 { + if n % 37 == 0 { + p.center_hz = [100.0, 1000.0, 4000.0][n / 37 % 3]; + direct.set_center_hz(p.center_hz); + full.set_parameters(p); + } + let input = [(n as f64 * 0.13).sin(), (n as f64 * 0.17).cos()]; + assert_eq!(direct.process_sample(input), full.process_sample(input)); + } + } + #[test] #[cfg_attr(miri, ignore)] // 長い数値応答の照合は実CPUで行う。 fn fixed_allpass_preserves_impulse_energy_and_channel_independence() { diff --git a/src/reverb.rs b/src/reverb.rs index cc26506..3ef0aca 100644 --- a/src/reverb.rs +++ b/src/reverb.rs @@ -104,6 +104,10 @@ impl Reverb { self.state.sample_rate == sample_rate && sample_rate >= 44100.0 } + pub fn set_mix(&mut self, mix: f64) { + self.state.parameters.mix = mix; + } + pub fn set_parameters(&mut self, parameters: ReverbParameters) { let old = self.state.parameters; self.state.parameters = parameters; diff --git a/src/synth.rs b/src/synth.rs index fe9d57a..86be1c8 100644 --- a/src/synth.rs +++ b/src/synth.rs @@ -116,30 +116,51 @@ impl Synthesizer { /// 設定は有効な枠の入力へ反映し、Polyphony増加時は追加した枠も同期する。 pub fn set_parameters(&mut self, values: [f64; parameters::COUNT]) -> bool { - if values == self.state.parameters { + let changes = parameters::ParameterChanges::new(&values, &self.state.parameters); + if !changes.any(0, parameters::COUNT) { return false; } - if values[13] != self.state.parameters[13] { + if changes.contains(13) { self.state.master_gain = 10.0_f64.powf(parameters::to_plain(13, values[13]) / 20.0); // 全体の音量だけが変わる場合は、各Voiceへの設定配送を省く。 - if values[..13] == self.state.parameters[..13] - && values[14..] == self.state.parameters[14..] - { + if !changes.any(0, 13) && !changes.any(14, parameters::COUNT) { self.state.parameters = values; return true; } } - if values[34..42] != self.state.parameters[34..42] { - self.state.eq.set_parameters(parameters::eq(&values)); + if changes.any(34, 42) { + let mut eq = self.state.eq.parameters(); + eq.enabled = values[34] >= 0.5; + for (indices, fields) in [ + ([35, 37, 40], &mut eq.frequencies_hz), + ([36, 38, 41], &mut eq.gains_db), + ] { + for (i, field) in indices.into_iter().zip(fields) { + if changes.contains(i) { + *field = parameters::to_plain(i, values[i]); + } + } + } + if changes.contains(39) { + eq.mid_q = parameters::to_plain(39, values[39]); + } + self.state.eq.set_parameters(eq); } self.state.limiter.set_enabled(values[108] >= 0.5); + if changes.any(31, 34) || changes.any(42, 130) { + self.state.effects.set_parameters(&values, &changes); + } + // Voiceへ渡す入力が同じなら、合成後の処理だけを更新して終える。 + if !changes.any(0, 13) && !changes.any(14, 31) && !changes.any(130, parameters::COUNT) { + self.state.parameters = values; + return true; + } let previous = &self.state.parameters; // 有効範囲が広がるときは、休止していた枠へ現在の全設定を配送する。 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 oscillator_changed = expanded || changes.any(0, 8) || changes.contains(12); + let envelope_changed = expanded || changes.any(14, 20); + if changes.contains(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(); @@ -149,9 +170,7 @@ impl Synthesizer { self.state.used_voices = self.state.used_voices.min(count); self.state.next_oscillator_id %= count; } - if values[8] != previous[8] - || values[parameters::PORTAMENTO] != previous[parameters::PORTAMENTO] - { + if changes.contains(8) || changes.contains(parameters::PORTAMENTO) { let time = if self.state.polyphony == 1 { parameters::to_plain(parameters::PORTAMENTO, values[parameters::PORTAMENTO]) } else { @@ -161,14 +180,14 @@ impl Synthesizer { voice.set_portamento(time); } } - if expanded || values[parameters::PITCH] != previous[parameters::PITCH] { + if expanded || changes.contains(parameters::PITCH) { let cents = parameters::to_plain(parameters::PITCH, values[parameters::PITCH]); let ratio = ((self.state.pitch_bend * 2.0 - 1.0) * cents / 1200.0).exp2(); for voice in &mut self.state.voices[..self.state.polyphony] { voice.set_pitch_ratio(ratio); } } - if expanded || values[130..132] != previous[130..132] { + if expanded || changes.any(130, 132) { for voice in &mut self.state.voices[..self.state.polyphony] { voice.set_velocity_sensitivity([values[130], values[131]]); } @@ -177,6 +196,8 @@ impl Synthesizer { if oscillator_changed || envelope_changed { // Voice 0は常に有効で、適用済みの実単位を保持している。 let mut envelopes = self.state.voices[0].envelope_parameters(); + let cutoff_shape_changed = + expanded || changes.any(14, 19) || envelopes[1] == DEFAULT_ENVELOPE; for (update, first, envelope) in [oscillator_changed, envelope_changed] .into_iter() .zip([1, 14]) @@ -199,7 +220,7 @@ impl Synthesizer { .into_iter() .enumerate() { - if values[first + i] != previous[first + i] { + if changes.contains(first + i) { *field = parameters::to_plain(first + i, values[first + i]); } } @@ -226,11 +247,15 @@ impl Synthesizer { let cutoff_envelope = envelopes[1]; let cutoff_amount = parameters::to_plain(19, values[19]); for voice in &mut self.state.voices[..self.state.polyphony] { - voice.set_cutoff_envelope(cutoff_envelope, cutoff_amount); + if cutoff_shape_changed { + voice.set_cutoff_envelope(cutoff_envelope, cutoff_amount); + } else { + voice.set_cutoff_amount(cutoff_amount); + } } } } - if values[21] != previous[21] { + if changes.contains(21) { self.state.mono_gains = panning_gains(1, 0.0, parameters::to_plain(21, values[21]) / 100.0)[0]; } @@ -238,9 +263,9 @@ impl Synthesizer { let wave = [0, 23, 26][osc]; let tune = [None, Some(24), Some(27)][osc]; if expanded - || values[volume] != previous[volume] - || values[wave] != previous[wave] - || tune.is_some_and(|i| values[i] != previous[i]) + || changes.contains(volume) + || changes.contains(wave) + || tune.is_some_and(|i| changes.contains(i)) { let waveform = parameters::from_normalized(values[wave]).expect("validated waveform"); @@ -253,14 +278,12 @@ impl Synthesizer { } } } - if expanded || values[29..31] != previous[29..31] { + if expanded || changes.any(29, 31) { for voice in &mut self.state.voices[..self.state.polyphony] { voice.set_phase_modulation([values[29] * 2.0, values[30] * 2.0]); } } - if values[20..22] != previous[20..22] - || values[6] != previous[6] - || (values[7] == 0.0) != (previous[7] == 0.0) + if changes.any(20, 22) || changes.contains(6) || (values[7] == 0.0) != (previous[7] == 0.0) { let count = if values[7] == 0.0 { 1 @@ -272,10 +295,7 @@ impl Synthesizer { } else { parameters::to_plain(6, previous[6]) as usize }; - if count != old_count - || values[21] != previous[21] - || (count > 1 && values[20] != previous[20]) - { + if count != old_count || changes.contains(21) || (count > 1 && changes.contains(20)) { self.state.panning_gains = panning_gains( count, parameters::to_plain(20, values[20]) / 100.0, @@ -283,17 +303,14 @@ impl Synthesizer { ); } } - if values[31..34] != previous[31..34] || values[42..130] != previous[42..130] { - self.state.effects.set_parameters(&values, previous); - } - if expanded || values[9..11] != previous[9..11] { + if expanded || changes.any(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[..self.state.polyphony] { voice.set_filter(filter_type, cutoff_cents, resonance_q); } - } else if values[11] != previous[11] { + } else if changes.contains(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); @@ -405,8 +422,10 @@ impl Synthesizer { /// EQ・Limiter・Masterを系列で適用する。 #[inline(never)] fn finish_samples(&mut self, samples: &mut [[f64; 2]]) { - for sample in &mut *samples { - *sample = self.state.eq.process_sample(*sample); + if self.state.eq.enabled() { + for sample in &mut *samples { + *sample = self.state.eq.process_sample(*sample); + } } self.state.limiter.process_samples(samples); for sample in samples { @@ -1123,6 +1142,64 @@ mod tests { } } + #[test] + fn amount_only_updates_preserve_envelope_history_across_rate_and_voice_changes() { + let mut synth = Synthesizer::new(); + let mut reference = Synthesizer::new(); + let mut values = parameters::defaults(); + values[9] = parameters::to_normalized(9, 2.0); + values[12] = parameters::to_normalized(12, 1.0); + for sample in 0..1024 { + if sample % 64 == 0 { + values[19] = parameters::to_normalized(19, (sample % 257) as f64 * 16.0); + if sample == 128 { + values[14] = parameters::to_normalized(14, 20.0); + } + if sample == 256 { + values[8] = parameters::to_normalized(8, 4.0); + } + if sample == 512 { + values[14..19].copy_from_slice(¶meters::defaults()[14..19]); + } + if sample == 768 { + values[8] = parameters::to_normalized(8, 1.0); + } + synth.set_parameters(values); + reference.set_parameters(values); + // Amountの更新でも従来どおりAHDSR全体を通知する基準経路。 + for voice in &mut reference.state.voices[..reference.state.polyphony] { + voice.set_cutoff_envelope( + parameters::envelope(&values, 14), + parameters::to_plain(19, values[19]), + ); + } + } + if sample == 0 || sample == 256 || sample == 768 { + for id in 0..synth.state.polyphony { + let event = note(id as i32, 0, 60 + id as i16); + synth.note_on(event, 0.0, 0.8); + reference.note_on(event, 0.0, 0.8); + } + } + if sample == 640 { + for id in 0..synth.state.polyphony { + let event = note(id as i32, 0, 60 + id as i16); + synth.note_off(event); + reference.note_off(event); + } + } + if sample == 384 { + assert!(synth.set_sample_rate(96000.0)); + assert!(reference.set_sample_rate(96000.0)); + } + assert_eq!( + synth.mix_sample(), + reference.mix_sample(), + "sample {sample}" + ); + } + } + fn polyphonic(count: usize) -> Synthesizer { let mut synth = unfiltered(); let mut values = parameters::defaults(); diff --git a/src/voice.rs b/src/voice.rs index 1a79375..639b2d8 100644 --- a/src/voice.rs +++ b/src/voice.rs @@ -321,6 +321,11 @@ impl Voice { self.state .cutoff_envelope .set_input(¶meters, self.state.sample_rate, 1.0); + self.set_cutoff_amount(amount_cents); + } + + /// Amountだけの変更では、AHDSRの入力と時間履歴を保持する。 + pub fn set_cutoff_amount(&mut self, amount_cents: f64) { self.state.cutoff_amount_cents = amount_cents; self.refresh_cutoff_amount(); } @@ -416,6 +421,10 @@ impl Voice { mono_gains: &[f64; 2], output: &mut [[f64; 2]], ) { + if !(sample_rate.is_finite() && sample_rate > 0.0) { + output.fill([0.0; 2]); + return; + } if let Some((first, rest)) = output.split_first_mut() { *first = self.generate_sample(sample_rate, gains, mono_gains); // 先頭を生成した時点で既に停止済みなら、後続の入力・時計も変化しない。 @@ -476,37 +485,38 @@ impl Voice { self.state.cutoff_envelope.update_sample(); } rest.fill([0.0; 2]); - let mono = [*mono_gains; 7]; + let mono = std::slice::from_ref(mono_gains); + let mut values = [0.0; 7]; let depths = [0.0, self.state.phase_depths[0], self.state.phase_depths[1]]; // 変調配列をOsc3→Osc2→Osc1の順に上書きし、同じ順で音声へ加算する。 for i in (0..3).rev() { let gain = self.state.oscillator_gains[i]; - let pans = if i == 0 { gains } else { &mono }; + let pans: &[[f64; 2]] = if i == 0 { gains } else { mono }; let input = &mut self.state.oscillator_inputs[i]; if gain == 0.0 && depths[i] == 0.0 { for phase_modulation in &mut modulation[..active_count] { input.phase_modulation = *phase_modulation; + debug_assert!(input.phase_modulated || input.phase_modulation == 0.0); // SAFETY: 区間の先頭で同じ定常入力を反映済み。 // activeはtrue→falseだけ、変調は有限のi32範囲内。 unsafe { - self.state.oscillators[i].generate_prepared_sample::(input); + self.state.oscillators[i] + .generate_prepared_sample::(input, &mut values); } *phase_modulation = 0.0; } } else { for n in 0..active_count { input.phase_modulation = modulation[n]; + debug_assert!(input.phase_modulated || input.phase_modulation == 0.0); // SAFETY: 上と同じ準備済みの定常入力と発音期間を使う。 - let current = unsafe { - self.state.oscillators[i].generate_prepared_sample::(input) + let count = unsafe { + self.state.oscillators[i] + .generate_prepared_sample::(input, &mut values) }; - modulation[n] = current.values[0] * depths[i]; + modulation[n] = values[0] * depths[i]; if gain != 0.0 { - let audio = volume::process_sample( - ¤t.values[..current.count], - pans, - gain, - ); + let audio = volume::process_sample(&values[..count], pans, gain); rest[n][0] += audio[0]; rest[n][1] += audio[1]; } @@ -544,6 +554,62 @@ impl Voice { } } + /// 配送先が固定の3発振器を同じ処理で生成し、次の発振器への変調を返す。 + #[inline(always)] + fn generate_oscillator_sample( + &mut self, + sample_rate: f64, + panning: &[[f64; 2]], + modulation: f64, + values: &mut [f64; 7], + sample: &mut [f64; 2], + ) -> f64 { + let depth = if I == 0 { + 0.0 + } else { + self.state.phase_depths[I - 1] + }; + let input = &mut self.state.oscillator_inputs[I]; + input.active = true; + input.phase_modulation = modulation; + input.phase_modulated = I < 2 && self.state.phase_depths[I] != 0.0; + debug_assert!(input.phase_modulated || input.phase_modulation == 0.0); + // SAFETY: 定常入力は親とVoiceで検証済み。設定・ノート変更で準備を失効させる。 + if !PREPARED && self.state.oscillators_prepared & (1 << I) == 0 { + unsafe { self.state.oscillators[I].prepare_sample(input, sample_rate) }; + } + if self.state.oscillator_gains[I] == 0.0 && depth == 0.0 { + // SAFETY: 同じ定常入力を上記か前サンプルで反映済み。 + unsafe { + if I == 0 { + self.state.oscillators[I] + .generate_prepared_sample::(input, values); + } else { + self.state.oscillators[I] + .generate_prepared_sample::(input, values); + } + }; + return 0.0; + } + // SAFETY: 上記と同じ準備済み入力。再発音はNote Onを通る。 + // Osc2/3のUnisonは常に1として設定する。 + let count = unsafe { + if I == 0 { + self.state.oscillators[I].generate_prepared_sample::(input, values) + } else { + self.state.oscillators[I].generate_prepared_sample::(input, values) + } + }; + let modulation = values[0] * depth; + if self.state.oscillator_gains[I] != 0.0 { + let audio = + volume::process_sample(&values[..count], panning, self.state.oscillator_gains[I]); + sample[0] += audio[0]; + sample[1] += audio[1]; + } + modulation + } + #[inline] fn generate_one_sample( &mut self, @@ -551,7 +617,8 @@ impl Voice { gains: &PanningGains, mono_gains: &[f64; 2], ) -> [f64; 2] { - if sample_rate != self.state.sample_rate { + // PREPAREDでは系列の先頭で同じレートを反映済み。 + if !PREPARED && sample_rate != self.state.sample_rate { if !(sample_rate.is_finite() & (sample_rate > 0.0)) { return [0.0; 2]; } @@ -581,47 +648,32 @@ impl Voice { self.state.cutoff_modulation = (cents, 2.0_f64.powf(cents / 1200.0)); } let active = self.state.envelope.is_active(); - let mono = [*mono_gains; 7]; + let mono = std::slice::from_ref(mono_gains); let mut sample = [0.0; 2]; + let mut values = [0.0; 7]; if active { - let prepared = self.state.oscillators_prepared; - 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; - // SAFETY: 定常設定・周波数・レートは親とVoiceで検証済み。 - // 設定・ノート変更は各入口で対応する準備済みビットを失効させる。 - // 変調入力は有限の生波形と0〜2周期の深度から生成する。 - if !PREPARED && prepared & (1 << i) == 0 { - unsafe { self.state.oscillators[i].prepare_sample(input, sample_rate) }; - } - if self.state.oscillator_gains[i] == 0.0 && depths[i] == 0.0 { - // SAFETY: 同じ定常入力を上記の入口か前サンプルで反映済み。 - unsafe { - self.state.oscillators[i].generate_prepared_sample::(input); - } - modulation = 0.0; - continue; - } - // SAFETY: 上記と同じ準備済み入力。再発音はNote Onを通る。 - let current = - unsafe { self.state.oscillators[i].generate_prepared_sample::(input) }; - 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]; - } - } + let modulation = self.generate_oscillator_sample::<2, PREPARED>( + sample_rate, + mono, + 0.0, + &mut values, + &mut sample, + ); + let modulation = self.generate_oscillator_sample::<1, PREPARED>( + sample_rate, + mono, + modulation, + &mut values, + &mut sample, + ); + self.generate_oscillator_sample::<0, PREPARED>( + sample_rate, + gains, + modulation, + &mut values, + &mut sample, + ); if !PREPARED { self.state.oscillators_prepared = 0b111; } @@ -657,6 +709,47 @@ impl Voice { mod tests { use super::*; + #[test] + fn prepared_series_rate_validation_matches_scalar_generation() { + for wave in [Waveform::Sine, Waveform::Sawtooth] { + for modulation in [0.0, 0.75] { + let mut voice = Voice::new(); + voice.set_parameters(wave, DEFAULT_ENVELOPE, 3, 7.0, PhaseMode::Zero); + voice.set_phase_modulation([modulation; 2]); + assert!(voice.note_on( + Note { + id: 1, + channel: 0, + pitch: 69 + }, + 0.0, + 0.8 + )); + let mut scalar = voice.clone(); + for rate in [ + 44100.0, + f64::NAN, + -1.0, + f64::INFINITY, + 96000.0, + 0.0, + 44100.0, + ] { + for length in [0, 1, 2, 33, 127] { + let mut output = vec![[0.0; 2]; length]; + voice.generate_samples(rate, &[[1.0; 2]; 7], &[1.0; 2], &mut output); + for actual in output { + assert_eq!( + actual, + scalar.generate_sample(rate, &[[1.0; 2]; 7], &[1.0; 2]) + ); + } + } + } + } + } + } + #[test] fn portamento_tracks_cents_retargets_and_starts_silent_notes_immediately() { for rate in [44100.0, 48000.0, 96000.0] { diff --git a/src/volume.rs b/src/volume.rs index 6d5b42a..3b222ea 100644 --- a/src/volume.rs +++ b/src/volume.rs @@ -3,7 +3,7 @@ //! 発振器の生波形に対する実効値補正・ユニゾン合成・Vol・定位。 -use crate::oscillator::{PanningGains, Waveform}; +use crate::oscillator::Waveform; /// 波形の実効値補正とユニゾン補正にVolの線形倍率を掛ける。設定変更時に計算する。 /// countは検証済みの実発音数(1〜7)。 @@ -19,7 +19,7 @@ pub fn gain(waveform: Waveform, count: usize, volume: f64) -> f64 { /// 同時刻のユニゾン波形を定位・加算し、計算済みの音量倍率を適用する。 /// valuesは最大7要素。空の場合は無音。 #[inline] -pub fn process_sample(values: &[f64], panning: &PanningGains, gain: f64) -> [f64; 2] { +pub fn process_sample(values: &[f64], panning: &[[f64; 2]], gain: f64) -> [f64; 2] { let mut sum = [0.0; 2]; for (&value, gains) in values.iter().zip(panning) { sum[0] += value * gains[0];