diff --git a/src/chorus.rs b/src/chorus.rs index 2d16832..6e9c166 100644 --- a/src/chorus.rs +++ b/src/chorus.rs @@ -163,8 +163,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 { diff --git a/src/compressor.rs b/src/compressor.rs index b8fb1b8..fd32d65 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) { @@ -178,6 +187,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..da8b192 100644 --- a/src/delay.rs +++ b/src/delay.rs @@ -156,8 +156,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 { diff --git a/src/effects.rs b/src/effects.rs index ea424f7..73366ea 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(); @@ -304,47 +298,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 +319,79 @@ 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 { + self.state.slots[SLOT] + .state + .chorus + .set_parameters(parameters::chorus(values, SLOT)); + } + if phaser_changed { + self.state.slots[SLOT] + .state + .phaser + .set_parameters(parameters::phaser(values, SLOT)); + } + 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 { + parameters::distortion(values, SLOT) + } else { + self.state.slots[SLOT].state.parameters + }; + if delay_changed { + self.state.slots[SLOT] + .state + .delay + .set_parameters(parameters::delay(values, SLOT)); + } + 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(); @@ -430,7 +464,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 +511,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 { @@ -505,8 +542,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 +568,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 +582,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 +608,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 +642,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 +684,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 +705,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 +736,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/oscillator.rs b/src/oscillator.rs index 56547cf..a918972 100644 --- a/src/oscillator.rs +++ b/src/oscillator.rs @@ -271,7 +271,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,7 +304,8 @@ impl Oscillator { } } - /// 反映済みの定常入力から1サンプルを生成する。 + /// 反映済みの定常入力から1サンプルをvaluesへ生成し、有効な先頭要素数を返す。 + /// 呼出し元は返された要素数だけを使用する。OUTPUT=falseでは状態だけを更新する。 /// /// # Safety /// 直前のprepare_sampleとwaveform・frequency_hz・unison_voices・ @@ -313,18 +316,16 @@ impl Oscillator { 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.generate_waveform_sample::(input, values); self.update_sample(); - sample + self.state.rendered_count } /// 位相変調は読出し位置だけへ適用する。Noiseはユニゾンごとに乱数を一つ進める。 @@ -332,19 +333,21 @@ impl Oscillator { 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]; 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), } } @@ -353,8 +356,9 @@ impl Oscillator { fn generate_bandlimited_sample( &mut self, input: &OscillatorInput, - ) -> OscillatorSample { - self.generate_periodic_sample::(input) + values: &mut [f64; 7], + ) { + self.generate_periodic_sample::(input, values) } /// 波形別に展開する周期波の読出し。位相変調の処理は両経路で共通にする。 @@ -362,21 +366,39 @@ impl Oscillator { fn generate_periodic_sample( &mut self, input: &OscillatorInput, - ) -> OscillatorSample { + values: &mut [f64; 7], + ) { let count = self.state.rendered_count; - let mut values = [0.0; 7]; 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 { + if BANDED && offset == 0.0 { + 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 if offset == 0.0 { for (k, (value, &phase)) in values[..count] .iter_mut() .zip(&self.state.phases) @@ -404,16 +426,15 @@ impl Oscillator { }; } } - OscillatorSample { values, count } } #[inline(never)] fn generate_antialiased_sample( &mut self, input: &OscillatorInput, - ) -> OscillatorSample { + values: &mut [f64; 7], + ) { let count = self.state.rendered_count; - let mut values = [0.; 7]; for (k, value) in values[..count].iter_mut().enumerate() { let phase = self.state.phases[k]; let q = phase + input.phase_modulation; @@ -432,7 +453,6 @@ impl Oscillator { self.state.history[k] = [q - wrap, b - wrap]; } self.state.valid = true; - OscillatorSample { values, count } } #[cfg(test)] diff --git a/src/oscillator/wavetable.rs b/src/oscillator/wavetable.rs index 4afa136..a687bc0 100644 --- a/src/oscillator/wavetable.rs +++ b/src/oscillator/wavetable.rs @@ -34,6 +34,44 @@ impl Table { } } +/// 同一時刻の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 usize; + let j = _mm_cvtsi128_si32(_mm_shuffle_epi32::<0x55>(indexes)) 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,27 @@ 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)); + for n in 0..=1024 { + let phases = [f64::from(n) / 1024.0, f64::from((n * 137) % 1025) / 1024.0]; + 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..579fdab 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,52 @@ 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); + } + 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/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..ef44748 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]]); } @@ -199,7 +218,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]); } } @@ -230,7 +249,7 @@ impl Synthesizer { } } } - 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 +257,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 +272,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 +289,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 +297,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 +416,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 { diff --git a/src/voice.rs b/src/voice.rs index 1a79375..ad408a8 100644 --- a/src/voice.rs +++ b/src/voice.rs @@ -476,12 +476,13 @@ 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] { @@ -489,7 +490,8 @@ impl Voice { // 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; } @@ -497,16 +499,13 @@ impl Voice { for n in 0..active_count { input.phase_modulation = modulation[n]; // 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 +543,47 @@ 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; + // 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 { self.state.oscillators[I].generate_prepared_sample::(input, values) }; + return 0.0; + } + // SAFETY: 上記と同じ準備済み入力。再発音はNote Onを通る。 + let count = + unsafe { 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, @@ -581,47 +621,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; } 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];