释放声音：深入探索用于音频合成和数字信号处理的 Python

            
import numpy as np
import sounddevice as sd
import matplotlib.pyplot as plt

# --- Global Parameters ---
SAMPLE_RATE = 44100  # samples per second
DURATION = 3.0       # seconds

# --- Waveform Generation ---
def generate_sine_wave(frequency, duration, sample_rate, amplitude=0.5):
    """Generate a sine wave.

    Args:
        frequency (float): The frequency of the sine wave in Hz.
        duration (float): The duration of the wave in seconds.
        sample_rate (int): The sample rate in Hz.
        amplitude (float): The amplitude of the wave (0.0 to 1.0).

    Returns:
        np.ndarray: The generated sine wave as a NumPy array.
    """
    # Create an array of time points
    t = np.linspace(0, duration, int(sample_rate * duration), False)

    # Generate the sine wave
    # 2 * pi * frequency is the angular frequency
    wave = amplitude * np.sin(2 * np.pi * frequency * t)
    return wave

# --- Example Usage ---
if __name__ == "__main__":
    # Generate a 440 Hz (A4 note) sine wave
    frequency_a4 = 440.0
    sine_wave = generate_sine_wave(frequency_a4, DURATION, SAMPLE_RATE)

    print("Playing 440 Hz sine wave...")
    # Play the sound
    sd.play(sine_wave, SAMPLE_RATE)
    sd.wait() # Wait for the sound to finish playing
    print("Playback finished.")

    # --- Visualization ---
    # Plot a small portion of the wave to see its shape
    plt.figure(figsize=(12, 4))
    plt.plot(sine_wave[:500])
    plt.title("Sine Wave (440 Hz)")
    plt.xlabel("Sample")
    plt.ylabel("Amplitude")
    plt.grid(True)
    plt.show()

            

              
                Copy
              
            
          

            
from scipy import signal

# Generate a square wave
square_wave = 0.5 * signal.square(2 * np.pi * 440 * np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False))
# sd.play(square_wave, SAMPLE_RATE)
# sd.wait()

            

              
                Copy
              
            
          

            
# Generate a sawtooth wave
sawtooth_wave = 0.5 * signal.sawtooth(2 * np.pi * 440 * np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False))
# sd.play(sawtooth_wave, SAMPLE_RATE)
# sd.wait()

            

              
                Copy
              
            
          

            
# Generate a triangle wave (a sawtooth with 0.5 width)
triangle_wave = 0.5 * signal.sawtooth(2 * np.pi * 440 * np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False), width=0.5)
# sd.play(triangle_wave, SAMPLE_RATE)
# sd.wait()

            

              
                Copy
              
            
          

            
# Generate white noise
num_samples = int(SAMPLE_RATE * DURATION)
white_noise = np.random.uniform(-1, 1, num_samples)
# sd.play(white_noise, SAMPLE_RATE)
# sd.wait()

            

              
                Copy
              
            
          

            
def generate_complex_tone(fundamental_freq, duration, sample_rate):
    t = np.linspace(0, duration, int(sample_rate * duration), False)
    
    # Start with the fundamental frequency
    tone = 0.5 * np.sin(2 * np.pi * fundamental_freq * t)
    
    # Add harmonics (overtones)
    # 2nd harmonic (octave higher), lower amplitude
    tone += 0.25 * np.sin(2 * np.pi * (2 * fundamental_freq) * t)
    # 3rd harmonic, even lower amplitude
    tone += 0.12 * np.sin(2 * np.pi * (3 * fundamental_freq) * t)
    # 5th harmonic
    tone += 0.08 * np.sin(2 * np.pi * (5 * fundamental_freq) * t)
    
    # Normalize the waveform to be between -1 and 1
    tone = tone / np.max(np.abs(tone))
    return tone

# --- Example Usage ---
complex_tone = generate_complex_tone(220, DURATION, SAMPLE_RATE)
sd.play(complex_tone, SAMPLE_RATE)
sd.wait()

            

              
                Copy
              
            
          

            
def adsr_envelope(duration, sample_rate, attack_time, decay_time, sustain_level, release_time):
    num_samples = int(duration * sample_rate)
    attack_samples = int(attack_time * sample_rate)
    decay_samples = int(decay_time * sample_rate)
    release_samples = int(release_time * sample_rate)
    sustain_samples = num_samples - attack_samples - decay_samples - release_samples

    if sustain_samples < 0:
        # If times are too long, adjust them proportionally
        total_time = attack_time + decay_time + release_time
        attack_time, decay_time, release_time = \
            attack_time/total_time*duration, decay_time/total_time*duration, release_time/total_time*duration
        attack_samples = int(attack_time * sample_rate)
        decay_samples = int(decay_time * sample_rate)
        release_samples = int(release_time * sample_rate)
        sustain_samples = num_samples - attack_samples - decay_samples - release_samples

    # Generate each part of the envelope
    attack = np.linspace(0, 1, attack_samples)
    decay = np.linspace(1, sustain_level, decay_samples)
    sustain = np.full(sustain_samples, sustain_level)
    release = np.linspace(sustain_level, 0, release_samples)

    return np.concatenate([attack, decay, sustain, release])

# --- Example Usage: Plucky vs. Pad Sound ---

# Pluck sound (fast attack, quick decay, no sustain)
pluck_envelope = adsr_envelope(DURATION, SAMPLE_RATE, 0.01, 0.2, 0.0, 0.5)

# Pad sound (slow attack, long release)
pad_envelope = adsr_envelope(DURATION, SAMPLE_RATE, 0.5, 0.2, 0.7, 1.0)

# Generate a harmonically rich sawtooth wave to apply envelopes to
saw_wave_for_env = generate_complex_tone(220, DURATION, SAMPLE_RATE)

# Apply envelopes
plucky_sound = saw_wave_for_env * pluck_envelope
pad_sound = saw_wave_for_env * pad_envelope

print("Playing plucky sound...")
sd.play(plucky_sound, SAMPLE_RATE)
sd.wait()

print("Playing pad sound...")
sd.play(pad_sound, SAMPLE_RATE)
sd.wait()

# Visualize the envelopes
plt.figure(figsize=(12, 6))
plt.subplot(2, 1, 1)
plt.plot(pluck_envelope)
plt.title("Pluck ADSR Envelope")
plt.subplot(2, 1, 2)
plt.plot(pad_envelope)
plt.title("Pad ADSR Envelope")
plt.tight_layout()
plt.show()

            

              
                Copy
              
            
          

            
from scipy.signal import butter, lfilter, freqz

def butter_lowpass_filter(data, cutoff, fs, order=5):
    """Apply a low-pass Butterworth filter to a signal."""
    nyquist = 0.5 * fs
    normal_cutoff = cutoff / nyquist
    # Get the filter coefficients 
    b, a = butter(order, normal_cutoff, btype='low', analog=False)
    y = lfilter(b, a, data)
    return y

# --- Example Usage ---
# Start with a rich signal: sawtooth wave
saw_wave_rich = 0.5 * signal.sawtooth(2 * np.pi * 220 * np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False))

print("Playing original sawtooth wave...")
sd.play(saw_wave_rich, SAMPLE_RATE)
sd.wait()

# Apply a low-pass filter with a cutoff of 800 Hz
filtered_saw = butter_lowpass_filter(saw_wave_rich, cutoff=800, fs=SAMPLE_RATE, order=6)

print("Playing filtered sawtooth wave...")
sd.play(filtered_saw, SAMPLE_RATE)
sd.wait()

# --- Visualization of the filter's frequency response ---
cutoff_freq = 800
order = 6
b, a = butter(order, cutoff_freq / (0.5 * SAMPLE_RATE), btype='low')
w, h = freqz(b, a, worN=8000)

plt.figure(figsize=(10, 5))
plt.plot(0.5 * SAMPLE_RATE * w / np.pi, np.abs(h), 'b')
plt.plot(cutoff_freq, 0.5 * np.sqrt(2), 'ko')
plt.axvline(cutoff_freq, color='k', linestyle='--')
plt.xlim(0, 5000)
plt.title("Low-pass Filter Frequency Response")
plt.xlabel('Frequency [Hz]')
plt.grid()
plt.show()

            

              
                Copy
              
            
          

            
# Carrier wave (the sound we hear)
carrier_freq = 300
carrier = generate_sine_wave(carrier_freq, DURATION, SAMPLE_RATE)

# Modulator LFO (controls the volume)
lfo_freq = 5 # 5 Hz LFO
modulator = generate_sine_wave(lfo_freq, DURATION, SAMPLE_RATE, amplitude=1.0)

# Create tremolo effect
# We scale the modulator to be from 0 to 1
tremolo_modulator = (modulator + 1) / 2

tremolo_sound = carrier * tremolo_modulator

print("Playing tremolo effect...")
sd.play(tremolo_sound, SAMPLE_RATE)
sd.wait()

            

              
                Copy
              
            
          

            
# Create vibrato effect
t = np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False)

carrier_freq = 300
lfo_freq = 7
modulation_depth = 10 # How much the frequency will vary

# The LFO will be added to the carrier frequency
modulator_vibrato = modulation_depth * np.sin(2 * np.pi * lfo_freq * t)

# The instantaneous frequency changes over time
instantaneous_freq = carrier_freq + modulator_vibrato

# We need to integrate the frequency to get the phase
phase = np.cumsum(2 * np.pi * instantaneous_freq / SAMPLE_RATE)

vibrato_sound = 0.5 * np.sin(phase)

print("Playing vibrato effect...")
sd.play(vibrato_sound, SAMPLE_RATE)
sd.wait()

            

              
                Copy
              
            
          

            
class MiniSynth:
    def __init__(self, sample_rate=44100):
        self.sample_rate = sample_rate

    def generate_note(self, frequency, duration, waveform='sine', 
                      adsr_params=(0.05, 0.2, 0.5, 0.3), 
                      filter_params=None):
        """Generate a single synthesized note."""
        num_samples = int(duration * self.sample_rate)
        t = np.linspace(0, duration, num_samples, False)

        # 1. Oscillator
        if waveform == 'sine':
            wave = np.sin(2 * np.pi * frequency * t)
        elif waveform == 'square':
            wave = signal.square(2 * np.pi * frequency * t)
        elif waveform == 'sawtooth':
            wave = signal.sawtooth(2 * np.pi * frequency * t)
        elif waveform == 'triangle':
            wave = signal.sawtooth(2 * np.pi * frequency * t, width=0.5)
        else:
            raise ValueError("Unsupported waveform")

        # 2. Envelope
        attack, decay, sustain, release = adsr_params
        envelope = adsr_envelope(duration, self.sample_rate, attack, decay, sustain, release)
        # Ensure envelope and wave are the same length
        min_len = min(len(wave), len(envelope))
        wave = wave[:min_len] * envelope[:min_len]

        # 3. Filter (optional)
        if filter_params:
            cutoff = filter_params.get('cutoff', 1000)
            order = filter_params.get('order', 5)
            filter_type = filter_params.get('type', 'low')
            
            if filter_type == 'low':
                wave = butter_lowpass_filter(wave, cutoff, self.sample_rate, order)
            # ... could add high-pass etc. here

        # Normalize to 0.5 amplitude
        return wave * 0.5

# --- Example Usage of the Synth ---

synth = MiniSynth()

# A bright, plucky bass sound
bass_note = synth.generate_note(
    frequency=110, # A2 note
    duration=1.5,
    waveform='sawtooth',
    adsr_params=(0.01, 0.3, 0.0, 0.2),
    filter_params={'cutoff': 600, 'order': 6}
)

print("Playing synth bass note...")
sd.play(bass_note, SAMPLE_RATE)
sd.wait()

# A soft, atmospheric pad sound
pad_note = synth.generate_note(
    frequency=440, # A4 note
    duration=5.0,
    waveform='triangle',
    adsr_params=(1.0, 0.5, 0.7, 1.5)
)

print("Playing synth pad note...")
sd.play(pad_note, SAMPLE_RATE)
sd.wait()

# A simple melody
melody = [
    ('C4', 261.63, 0.4),
    ('D4', 293.66, 0.4),
    ('E4', 329.63, 0.4),
    ('C4', 261.63, 0.8)
]

final_melody = []
for note, freq, dur in melody:
    sound = synth.generate_note(freq, dur, 'square', adsr_params=(0.01, 0.1, 0.2, 0.1), filter_params={'cutoff': 1500})
    final_melody.append(sound)

full_melody_wave = np.concatenate(final_melody)

print("Playing a short melody...")
sd.play(full_melody_wave, SAMPLE_RATE)
sd.wait()


            

              
                Copy