第14章：混合合成技术实战

S(t) = A_pcm(t) * E_pcm(t) + A_synth(t) * E_synth(t)

Attack(f, t) = Σ[n=1 to N] A_n(t) * sin(2πf_n(t)t + φ_n(t)) + N(t)

Crossfade(t) = PCM(t) * (1 - α(t)) + Synth(t) * α(t)

α(t) = 1 / (1 + e^(-k(t-t_c)))

    [PCM波形] → [TVF] → [TVA] ↘
                                  → [混合] → [输出]
    [合成波形] → [TVF] → [TVA] ↗

f_synth = f_pcm * 2^(cents/1200)

[引擎1] → [引擎2] → [引擎3] → [输出]

[引擎1] ↘
[引擎2] → [混合器] → [输出]
[引擎3] ↗

每个引擎既可以产生音频，也可以作为调制源

S(n) = Σ[i] w_i * Sample[f_i * n + φ_i]

Mix(t) = Σ[i=1 to N] Level_i(t) * Engine_i(t)

Level_i(t) = Base_i + Σ[j] Mod_j(t) * Depth_ij

延迟补偿 = max(Delay_i) - Delay_i

φ_aligned = φ_original + 2π * f * Δt

调制矩阵：
Source → [Scale] → [Shape] → Destination

矩阵元素 M[i,j] = 
    Source[i] * Depth[i,j] * Shape_func(Source[i])

引擎1（采样）：

- 真实小提琴的弓擦起音（0-100ms）
- 快速衰减包络

引擎2（锯齿波+滤波）：

- 基础谐波内容
- 缓慢起音包络（100ms attack）
- 轻微的音高LFO（颤音）

引擎3（噪声+梳状滤波）：

- 模拟弓毛摩擦
- 跟随力度的混合量

层次结构：
┌─────────────────────────────────┐
│ 引擎1: 波表（演化纹理）          │
│   - 缓慢的波表位置扫描          │
│   - 长释放时间                  │
├─────────────────────────────────┤
│ 引擎2: FM（金属光泽）            │
│   - 高比率FM                    │
│   - 由LFO调制的调制指数         │
├─────────────────────────────────┤
│ 引擎3: 采样（环境纹理）          │
│   - 自然环境音采样              │
│   - 循环播放，低通滤波          │
└─────────────────────────────────┘

if (CPU_load > threshold) {
    降低非关键引擎的复音数
    简化滤波器阶数
    降低过采样率
}

if (amplitude < threshold || !envelope_active) {
    bypass_engine()
}

关键控制器分配：
CC1 (Mod Wheel)：振动/调制深度
CC2 (Breath)：音色亮度/噪声量
CC7 (Volume)：整体音量
CC10 (Pan)：立体声位置
CC11 (Expression)：动态表情
CC64 (Sustain)：延音踏板
CC74 (Brightness)：滤波器截止频率

Output = Input^γ * (Max - Min) + Min

其中γ（gamma）控制响应曲线：
γ < 1: 对小值更敏感
γ = 1: 线性响应
γ > 1: 对大值更敏感

力度映射矩阵：
┌────────────────────────────────┐
│ Velocity → Amplitude (标准)    │
│ Velocity → Filter Cutoff       │
│ Velocity → Attack Time         │
│ Velocity → Sample Layer        │
│ Velocity → FM Index            │
│ Velocity → Effects Mix         │
└────────────────────────────────┘

固定点曲线：
if (velocity < V1) {
    output = velocity * K1
} else if (velocity < V2) {
    output = V1*K1 + (velocity-V1)*K2
} else {
    output = V1*K1 + (V2-V1)*K2 + (velocity-V2)*K3
}

Smoothed_AT(n) = α * AT(n) + (1-α) * Smoothed_AT(n-1)
其中α = 1 - e^(-2π * f_c / f_s)

宏控制器定义：
Macro1 {
    名称: "Brightness"
    范围: [0, 127]
    映射: [
        {目标: Filter1_Cutoff, 范围: [20, 20000], 曲线: exponential},
        {目标: Filter2_Resonance, 范围: [0, 0.95], 曲线: linear},
        {目标: Osc2_Level, 范围: [0.5, 1.0], 曲线: logarithmic},
        {目标: Reverb_Mix, 范围: [0, 0.3], 曲线: square}
    ]
}

表情参数集：
Intensity = f(Velocity, Aftertouch, ModWheel)
Brightness = g(Velocity, CC74, KeyPosition)  
Articulation = h(NoteLength, Velocity, Sustain)

快速响应（打击乐）: τ < 10ms
中速响应（弦乐）: τ ≈ 50-100ms
慢速响应（Pad）: τ > 200ms

Layer1: 基频 + 低次谐波 (< 1kHz)
Layer2: 中高频谐波 (1-5kHz)
Layer3: 高频泛音和空气感 (> 5kHz)

Delay_Layer[i] = i * Δt + random_jitter
其中Δt ≈ 5-20ms，创造自然的群延迟

总动态范围 = 20 * log10(Max_amplitude / Min_amplitude)
每层贡献 = Layer_weight * e^(-λ * layer_index)

分区混合函数：
Weight(key) = {
    1.0,                           key < (split - fade)
    cos²(π/2 * (key-split+fade)/2fade), (split-fade) ≤ key ≤ (split+fade)
    0.0,                           key > (split + fade)
}

速度层权重计算：
Layer1 (pp): weight = max(0, (64-velocity)/64)
Layer2 (mf): weight = 1 - |velocity-64|/64
Layer3 (ff): weight = max(0, (velocity-64)/64)

Layer_Pan[i] = Base_Pan + Width * sin(2π * i/N + φ)

立体声相关性处理：
L_out = L_in + α * R_in
R_out = R_in + α * L_in
其中α控制立体声宽度（-1到1）

L_channel = Dry_signal
R_channel = Dry_signal * gain + Delayed_signal(t - Δt_haas)

相位相干函数：
γ(f) = |Σ[S_i(f)]|² / Σ|S_i(f)|²

当γ(f) < 0.5时，存在严重的相位抵消

φ_random[i] = 2π * random() * spread_factor

detune[i] = base_pitch * 2^(cents[i]/1200)
cents[i] ∈ [-10, +10] cents

H(z) = (z^(-D) + g) / (1 + g*z^(-D))

Unison_voices = 7 (典型值)
频率分布：f[i] = f_0 * (1 + d_i)
其中d_i = detune_amount * (2i/(N-1) - 1)

立体声分布：
pan[i] = (2i/(N-1) - 1) * stereo_spread

相位分布：
φ[i] = 2π * i/N + random_offset[i]

Supersaw(t) = Σ[i=1 to 7] a_i * Saw(2π * f_i * t + φ_i)

权重分布：
a_1 = a_7 = 0.05
a_2 = a_6 = 0.15  
a_3 = a_5 = 0.25
a_4 = 0.5 (中心声音)

激活层数算法：
active_layers = min(max_layers, 
                   floor(velocity/127 * max_layers) + 1)

CPU负载自适应：
if (cpu_load > 80%) {
    reduce_layer_count()
    simplify_processing()
}

交叉包络：
Layer_A_env = 1 - (t/t_cross)^n
Layer_B_env = (t/t_cross)^n
其中n控制过渡曲线的形状（n=1为线性）

层次结构：
┌─────────────────────────────────────┐
│ 层1: Solo Violin (采样)             │
│   - 中央定位，轻微振动              │
├─────────────────────────────────────┤
│ 层2: Section Violins (合成)         │
│   - 7个声音的unison，宽立体声       │
├─────────────────────────────────────┤
│ 层3: Viola Section (采样+合成混合)   │
│   - 低八度，左侧定位                │
├─────────────────────────────────────┤
│ 层4: Cello/Bass (物理建模)          │
│   - 低两个八度，右侧定位            │
├─────────────────────────────────────┤
│ 层5: 泛音层 (加法合成)              │
│   - 仅高次谐波，增加光泽            │
└─────────────────────────────────────┘

动态控制：

- ModWheel: 控制振动深度和层5的混合量
- Expression: 整体动态和层间平衡
- Velocity: 起音速度和亮度

优先级系统：
Priority[layer] = base_priority + 
                 velocity_weight * velocity +
                 recency_weight * (1 - age/max_age)

if (distance_to_listener > threshold) {
    use_simplified_model()
    reduce_layer_count()
}

静态层：预渲染到缓冲区
动态层：实时计算
最终输出 = 静态缓冲 + 动态计算

S(t) = A_pcm(t) * E_pcm(t) + A_synth(t) * E_synth(t)

α(t) = 1 / (1 + e^(-k(t-t_c)))

M[i,j] = Source[i] * Depth[i,j] * Shape_func(Source[i])

γ(f) = |Σ[S_i(f)]|² / Σ|S_i(f)|²

f[i] = f_0 * (1 + detune_amount * (2i/(N-1) - 1))