llbzow 的摸鱼日记 (づ￣ 3￣)づ

1
import numpy as np
2

3
def generate_adsr_envelope(total_samples: int, sample_rate: int,
4
                           attack=0.01, decay=0.05, sustain=0.7, release=0.1) -> np.ndarray:
5
    """计算标准四段式 ADSR 振幅包络"""
6
    a_samples = int(attack * sample_rate)
7
    d_samples = int(decay * sample_rate)
8
    r_samples = int(release * sample_rate)
9
    s_samples = max(0, total_samples - a_samples - d_samples - r_samples)
10

11
    # 重新平分多余长度
12
    if a_samples + d_samples + r_samples > total_samples:
13
        return np.linspace(1.0, 0.0, total_samples)
14

15
    env_a = np.linspace(0.0, 1.0, a_samples, endpoint=False)
16
    env_d = np.linspace(1.0, sustain, d_samples, endpoint=False)
17
    env_s = np.full(s_samples, sustain)
18
    env_r = np.linspace(sustain, 0.0, r_samples)
19

20
    return np.concatenate([env_a, env_d, env_s, env_r])[:total_samples]

1
def synth_fm_lead(midi_pitch: int, duration_sec: float, sample_rate=44100) -> np.ndarray:
2
    freq = 440.0 * (2.0 ** ((midi_pitch - 69) / 12.0))
3
    total_samples = int(duration_sec * sample_rate)
4
    t = np.linspace(0, duration_sec, total_samples, endpoint=False)
5

6
    # 载波与调制波参数
7
    carrier_freq = freq
8
    mod_freq = freq * 2.0  # 2:1 调制比
9
    mod_index = 2.5
10

11
    # 计算调制与主波形
12
    modulator = np.sin(2 * np.pi * mod_freq * t)
13
    carrier = np.sin(2 * np.pi * carrier_freq * t + mod_index * modulator)
14

15
    # 叠加包络
16
    adsr = generate_adsr_envelope(total_samples, sample_rate, attack=0.005, decay=0.08, sustain=0.6, release=0.05)
17
    return (carrier * adsr).astype(np.float32)

1
def apply_sidechain(bass_track: np.ndarray, kick_track: np.ndarray,
2
                    ducking_amount=0.65, release_samples=4410) -> np.ndarray:
3
    """根据 Kick 的振幅包络，动态衰减 Bass 分轨对应区域"""
4
    # 提取 Kick 能量包络
5
    kick_env = np.abs(kick_track)
6
    # 计算衰减曲线
7
    gain_reduction = np.ones_like(bass_track)
8
    is_kick = kick_env > 0.1
9

10
    for i in range(len(gain_reduction)):
11
        if is_kick[i]:
12
            gain_reduction[i] = 1.0 - ducking_amount
13
        elif i > 0 and gain_reduction[i-1] < 1.0:
14
            # 平滑恢复
15
            gain_reduction[i] = min(1.0, gain_reduction[i-1] + (1.0 / release_samples))
16

17
    return bass_track * gain_reduction

1
def apply_panning(mono_track: np.ndarray, pan: float) -> np.ndarray:
2
    """
3
    pan: -1.0 (全左) 到 +1.0 (全右), 0.0 为正中
4
    使用等功率声相法则 (Constant Power Panning)
5
    """
6
    theta = (pan + 1.0) * (np.pi / 4.0) # 0 到 pi/2
7
    left_gain = np.cos(theta)
8
    right_gain = np.sin(theta)
9

10
    left_channel = mono_track * left_gain
11
    right_channel = mono_track * right_gain
12
    return np.vstack([left_channel, right_channel])