diff --git a/src/effects.rs b/src/effects.rs index ea424f7..5ad0b13 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,75 @@ 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 { + self.state.slots[SLOT] + .state + .reverb + .set_parameters(parameters::reverb(values, SLOT)); + } + 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 { + self.state.slots[SLOT] + .state + .compressor + .set_parameters(parameters::compressor(values, SLOT)); + } + // 他のエフェクト設定変更で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 +460,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 +507,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 +538,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 +564,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 +578,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 +604,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 +638,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 +680,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 +701,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 +732,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/envelope.rs b/src/envelope.rs index 4758cdf..d7f79b0 100644 --- a/src/envelope.rs +++ b/src/envelope.rs @@ -112,12 +112,12 @@ enum Segment { struct EnvelopeState { /// 次サンプル時点の正規化値。再ノートオンの開始値に使う。 current_value: f64, - /// 現在の区間。線形区間の値は前回値へ加算せず、絶対時刻から求める。 + /// 現在の区間。線形区間は準備済みの傾きと経過サンプル数から求める。 segment: Segment, - /// Decayのピーク、またはRelease開始時の値。元式と同じ演算順で保持する。 - segment_value: f64, - /// ノートオフ位置を現在のレートで換算したms。設定変更時に再計算する。 - release_start_ms: f64, + /// 準備済み区間の終了値。残りサンプル数から求め、反復加算の誤差を蓄積しない。 + segment_end_value: f64, + /// 現区間の1サンプル当たりの変化量。時間の除算は区間境界でだけ行う。 + segment_step: f64, /// 次の段境界までのサンプル数。設定変更時の0は次回生成での再計算を表す。 remaining: u64, /// 検証・値計算に使用した設定、レート、ピーク。変更時だけ再検証する。 @@ -147,8 +147,8 @@ impl Envelope { state: EnvelopeState { current_value: 0.0, segment: Segment::Constant, - segment_value: 0.0, - release_start_ms: 0.0, + segment_end_value: 0.0, + segment_step: 0.0, remaining: 0, input: None, start_value: 0.0, @@ -252,34 +252,13 @@ impl Envelope { } } - /// 元のvalue_validatedと同じ演算順で、現在段の1つのランプだけを求める。 + /// 線形区間の終了値・傾きから計算し、反復加算の誤差を蓄積しない。 #[inline] fn update_segment_sample(&mut self) { - if self.state.segment == Segment::Constant { - return; + if self.state.segment != Segment::Constant { + self.state.current_value = self.state.segment_end_value + - self.state.remaining as f64 * self.state.segment_step; } - let Some((parameters, sample_rate, peak)) = self.state.input else { - return; - }; - let time = self.state.elapsed_samples as f64 / sample_rate * 1000.0; - self.state.current_value = match self.state.segment { - Segment::Attack => { - let attack = ramp(time, parameters.attack_ms); - self.state.start_value * (1.0 - attack) + peak * attack - } - Segment::Decay => { - let decay = ramp( - time - parameters.attack_ms - parameters.hold_ms, - parameters.decay_ms, - ); - self.state.segment_value * ((1.0 - decay) + parameters.sustain * decay) - } - Segment::Release => { - self.state.segment_value - * (1.0 - ramp(time - self.state.release_start_ms, parameters.release_ms)) - } - Segment::Constant => self.state.current_value, - }; } pub fn is_active(&self) -> bool { @@ -318,7 +297,6 @@ impl Envelope { let (segment, value, boundary) = if let Some(off) = self.state.note_off_sample { let off_ms = off as f64 / sample_rate * 1000.0; let start = value_validated(¶meters, off_ms, None, self.state.start_value, peak); - self.state.release_start_ms = off_ms; ( Segment::Release, start, @@ -344,12 +322,19 @@ impl Envelope { (Segment::Constant, 0.0, boundary) }; self.state.segment = segment; - self.state.segment_value = value; + self.state.segment_step = match segment { + Segment::Constant => 0.0, + Segment::Attack => (peak - self.state.start_value) / parameters.attack_ms, + Segment::Decay => value * (parameters.sustain - 1.0) / parameters.decay_ms, + Segment::Release => -value / parameters.release_ms, + } * (1000.0 / sample_rate); // ms→sampleとsample→msの丸めが境界の両側へ分かれる場合も、 // 境界直前から元式で判定し、0ms段階の切替を遅らせない。 self.state.remaining = boundary .saturating_sub(1) .saturating_sub(self.state.elapsed_samples); + self.state.segment_end_value = self.state.current_value + + self.state.remaining as f64 * self.state.segment_step; } } @@ -633,10 +618,8 @@ mod tests { assert_eq!(envelope.generate_sample(), 0.0); assert_eq!(envelope.is_active(), reset_first); envelope.update_sample(); - assert_eq!( - envelope.generate_sample(), - if reset_first { 0.01 } else { 0.0 } - ); + let expected = if reset_first { 0.01 } else { 0.0 }; + assert!((envelope.generate_sample() - expected).abs() < 1e-15); } let mut envelope = Envelope::new(); let parameters = EnvelopeParameters { @@ -668,7 +651,7 @@ mod tests { envelope.note_on(); assert_eq!(envelope.generate_sample(), 0.0); envelope.update_sample(); - assert_eq!(envelope.generate_sample(), 0.1); + assert!((envelope.generate_sample() - 0.1).abs() < 1e-15); p.attack_ms = 20.0; envelope.set_input(&p, 1000.0, 1.0); assert_eq!(envelope.generate_sample(), 0.05); 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/parameters.rs b/src/parameters.rs index a6b917a..dbb2295 100644 --- a/src/parameters.rs +++ b/src/parameters.rs @@ -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]) { @@ -982,8 +1044,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[to_plain(31, values[clipper]) as usize], + gain: 10.0_f64.powf(to_plain(32, values[gain]) / 20.0), mix: values[mix], } } @@ -991,8 +1053,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: to_plain(51, values[beat]) as usize, + stereo: DELAY_STEREO_MODES[to_plain(60, values[stereo]) as usize], feedback: values[feedback], mix: values[mix], } @@ -1001,9 +1063,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: to_plain(63, values[decay]), + damping_hz: to_plain(64, values[damping]), + size: to_plain(65, values[size]) / 100.0, mix: values[mix], } } @@ -1012,11 +1074,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: to_plain(75, values[time]), + depth_ms: to_plain(76, values[depth]), + rate_hz: to_plain(77, values[rate]), + detune: to_plain(78, values[detune]), + feedback: to_plain(79, values[feedback]) / 100.0, mix: values[mix], } } @@ -1024,10 +1086,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: to_plain(93, values[center]), + depth_cents: to_plain(94, values[depth]), + rate_hz: to_plain(95, values[rate]), + feedback: to_plain(96, values[feedback]) / 100.0, mix: values[mix], } } @@ -1035,12 +1097,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: to_plain(109, values[threshold]), + ratio: to_plain(110, values[ratio]), + attack_ms: to_plain(111, values[attack]), + release_ms: to_plain(112, values[release]), + knee_db: to_plain(113, values[knee]), + makeup_db: to_plain(114, values[makeup]), mix: values[mix], } } @@ -1347,6 +1409,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/synth.rs b/src/synth.rs index fe9d57a..3ab4b60 100644 --- a/src/synth.rs +++ b/src/synth.rs @@ -116,30 +116,43 @@ 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); 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 +162,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 +172,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 +210,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 +241,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 +249,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 +264,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 +281,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 +289,17 @@ impl Synthesizer { ); } } - if values[31..34] != previous[31..34] || values[42..130] != previous[42..130] { - self.state.effects.set_parameters(&values, previous); + if changes.any(31, 34) || changes.any(42, 130) { + self.state.effects.set_parameters(&values, &changes); } - 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);