ధ్వనిని ఆవిష్కరించడం: ఆడియో సింథసిస్ మరియు డిజిటల్ సిగ్నల్ ప్రాసెసింగ్ కోసం పైథాన్‌లోకి ఒక లోతైన అన్వేషణ

మీ హెడ్‌ఫోన్‌లలో ప్రసారమయ్యే సంగీతం నుండి వీడియో గేమ్‌ల లీనమయ్యే ధ్వని దృశ్యాలు మరియు మా పరికరాలలోని వాయిస్ అసిస్టెంట్‌ల వరకు, డిజిటల్ ఆడియో ఆధునిక జీవితంలో ఒక అంతర్భాగం. అయితే ఈ శబ్దాలు ఎలా సృష్టించబడతాయని మీరు ఎప్పుడైనా ఆలోచించారా? ఇది మాయాజాలం కాదు; ఇది గణితం, భౌతికశాస్త్రం మరియు కంప్యూటర్ సైన్స్ యొక్క అద్భుతమైన కలయిక, దీనిని డిజిటల్ సిగ్నల్ ప్రాసెసింగ్ (DSP) అని పిలుస్తారు. ఈ రోజు, మేము తెరను వెనుకకు లాగి, పైథాన్ శక్తిని ఉపయోగించి మొదటి నుండి ధ్వనిని రూపొందించడం, మార్చడం మరియు సంశ్లేషణ చేయడం ఎలాగో మీకు చూపుతాము.

ఈ గైడ్ డెవలపర్‌లు, డేటా సైంటిస్టులు, సంగీతకారులు, కళాకారులు మరియు కోడ్ మరియు సృజనాత్మకత యొక్క ఖండన గురించి ఆసక్తి ఉన్న ఎవరికైనా ఉద్దేశించబడింది. మీరు DSP నిపుణుడు లేదా అనుభవజ్ఞుడైన ఆడియో ఇంజనీర్ కానవసరం లేదు. పైథాన్ గురించి ప్రాథమిక అవగాహనతో, మీరు త్వరలో మీ స్వంత ప్రత్యేకమైన సౌండ్‌స్కేప్‌లను రూపొందిస్తారు. మేము డిజిటల్ ఆడియో యొక్క ప్రాథమిక నిర్మాణ బ్లాక్‌లను అన్వేషిస్తాము, క్లాసిక్ తరంగ రూపాలను ఉత్పత్తి చేస్తాము, వాటిని ఎన్వలప్‌లు మరియు ఫిల్టర్‌లతో రూపొందిస్తాము మరియు మినీ-సింథసైజర్‌ను కూడా నిర్మిస్తాము. కంప్యూటేషనల్ ఆడియో యొక్క శక్తివంతమైన ప్రపంచంలోకి మన ప్రయాణాన్ని ప్రారంభిద్దాం.

డిజిటల్ ఆడియో యొక్క నిర్మాణ బ్లాక్‌లను అర్థం చేసుకోవడం

మేము ఒక్క లైన్ కోడ్ రాయడానికి ముందు, కంప్యూటర్‌లో ధ్వని ఎలా సూచించబడుతుందో మనం అర్థం చేసుకోవాలి. భౌతిక ప్రపంచంలో, ధ్వని అనేది పీడనం యొక్క నిరంతర అనలాగ్ తరంగం. కంప్యూటర్‌లు, డిజిటల్ కావడంతో, నిరంతర తరంగాన్ని నిల్వ చేయలేవు. బదులుగా, అవి ప్రతి సెకనుకు తరంగం యొక్క వేల స్నాప్‌షాట్‌లను, లేదా శాంపిల్స్‌ను తీసుకుంటాయి. ఈ ప్రక్రియను సాంప్లింగ్ అంటారు.

శాంపిల్ రేటు

శాంపిల్ రేటు ప్రతి సెకనుకు ఎన్ని శాంపిల్స్ తీసుకోబడతాయో నిర్ణయిస్తుంది. దీనిని హెర్ట్జ్ (Hz)లో కొలుస్తారు. అధిక శాంపిల్ రేటు అసలు ధ్వని తరంగాన్ని మరింత ఖచ్చితంగా సూచిస్తుంది, ఇది అధిక ఫిడిలిటీ ఆడియోకి దారితీస్తుంది. సాధారణ శాంపిల్ రేట్లు వీటిని కలిగి ఉంటాయి:

• 44100 Hz (44.1 kHz): ఆడియో CDల కోసం ప్రామాణికం. ఇది నైక్విస్ట్-షానన్ శాంప్లింగ్ సిద్ధాంతం ఆధారంగా ఎంపిక చేయబడింది, ఇది మీరు క్యాప్చర్ చేయాలనుకుంటున్న అత్యధిక ఫ్రీక్వెన్సీకి కనీసం రెండు రెట్లు శాంపిల్ రేటు ఉండాలని పేర్కొంది. మానవ వినికిడి పరిధి 20,000 Hz వరకు ఉంటుంది కాబట్టి, 44.1 kHz సరిపోతుంది.
• 48000 Hz (48 kHz): వృత్తిపరమైన వీడియో మరియు డిజిటల్ ఆడియో వర్క్‌స్టేషన్‌ల (DAWలు) కోసం ప్రామాణికం.
• 96000 Hz (96 kHz): మరింత ఎక్కువ ఖచ్చితత్వం కోసం అధిక-రిజల్యూషన్ ఆడియో ఉత్పత్తిలో ఉపయోగించబడుతుంది.

మా ప్రయోజనాల కోసం, మేము ప్రధానంగా 44100 Hzని ఉపయోగిస్తాము, ఇది నాణ్యత మరియు కంప్యుటేషనల్ సామర్థ్యం మధ్య అద్భుతమైన సమతుల్యతను అందిస్తుంది.

బిట్ డెప్త్

శాంపిల్ రేటు సమయం యొక్క రిజల్యూషన్‌ను నిర్ణయిస్తే, బిట్ డెప్త్ విస్తీర్ణం (శబ్దం) యొక్క రిజల్యూషన్‌ను నిర్ణయిస్తుంది. ప్రతి శాంపిల్ ఆ నిర్దిష్ట క్షణంలో తరంగం యొక్క విస్తీర్ణాన్ని సూచించే సంఖ్య. బిట్ డెప్త్ అనేది ఆ సంఖ్యను నిల్వ చేయడానికి ఉపయోగించే బిట్‌ల సంఖ్య. అధిక బిట్ డెప్త్ ఎక్కువ సాధ్యమైన విస్తీర్ణ విలువల కోసం అనుమతిస్తుంది, ఇది ఎక్కువ డైనమిక్ పరిధికి (అత్యంత నిశ్శబ్ద మరియు అత్యంత బిగ్గరగా సాధ్యమైన శబ్దాల మధ్య వ్యత్యాసం) మరియు తక్కువ నాయిస్ ఫ్లోర్‌కి దారితీస్తుంది.

• 16-బిట్: CDల కోసం ప్రామాణికం, 65,536 సాధ్యమైన విస్తీర్ణ స్థాయిలను అందిస్తుంది.
• 24-బిట్: వృత్తిపరమైన ఆడియో ఉత్పత్తికి ప్రామాణికం, 16.7 మిలియన్లకు పైగా స్థాయిలను అందిస్తుంది.

NumPy వంటి లైబ్రరీలను ఉపయోగించి పైథాన్‌లో ఆడియోను ఉత్పత్తి చేసినప్పుడు, గరిష్ట ఖచ్చితత్వం కోసం మేము సాధారణంగా ఫ్లోటింగ్-పాయింట్ సంఖ్యలతో (ఉదా., -1.0 మరియు 1.0 మధ్య) పని చేస్తాము. ఫైల్‌కు సేవ్ చేసేటప్పుడు లేదా హార్డ్‌వేర్ ద్వారా ప్లే చేసేటప్పుడు ఇవి నిర్దిష్ట బిట్ డెప్త్‌కు (16-బిట్ పూర్ణాంకాలు వంటివి) మార్చబడతాయి.

ఛానెల్‌లు

ఇది కేవలం ఆడియో స్ట్రీమ్‌ల సంఖ్యను సూచిస్తుంది. మోనో ఆడియోకు ఒక ఛానెల్ ఉంటుంది, అయితే స్టీరియో ఆడియోకు రెండు (ఎడమ మరియు కుడి) ఉంటాయి, ఇది స్థలం మరియు దిశను సృష్టిస్తుంది.

మీ పైథాన్ వాతావరణాన్ని ఏర్పాటు చేయడం

ప్రారంభించడానికి, మాకు కొన్ని ముఖ్యమైన పైథాన్ లైబ్రరీలు అవసరం. అవి సంఖ్యా గణన, సిగ్నల్ ప్రాసెసింగ్, విజువలైజేషన్ మరియు ఆడియో ప్లేబ్యాక్ కోసం మా టూల్‌కిట్‌ను ఏర్పరుస్తాయి.

మీరు వాటిని pip ఉపయోగించి ఇన్‌స్టాల్ చేయవచ్చు:

pip install numpy scipy matplotlib sounddevice

వాటి పాత్రలను క్లుప్తంగా సమీక్షిద్దాం:

• NumPy: పైథాన్‌లో శాస్త్రీయ కంప్యూటింగ్ యొక్క మూలస్తంభం. మేము దీనిని సంఖ్యల శ్రేణులను సృష్టించడానికి మరియు మార్చడానికి ఉపయోగిస్తాము, ఇది మా ఆడియో సిగ్నల్‌లను సూచిస్తుంది.
• SciPy: NumPy పైన నిర్మించబడింది, ఇది తరంగ రూప ఉత్పత్తి మరియు వడపోతతో సహా సిగ్నల్ ప్రాసెసింగ్ కోసం విస్తారమైన అల్గారిథమ్‌ల సేకరణను అందిస్తుంది.
• Matplotlib: పైథాన్‌లో ప్రాథమిక ప్లాటింగ్ లైబ్రరీ. మా తరంగ రూపాలను దృశ్యమానం చేయడానికి మరియు మా ప్రాసెసింగ్ ప్రభావాలను అర్థం చేసుకోవడానికి ఇది అమూల్యమైనది.
• SoundDevice: మీ కంప్యూటర్ స్పీకర్‌ల ద్వారా మా NumPy శ్రేణులను ఆడియోగా ప్లేబ్యాక్ చేయడానికి అనుకూలమైన లైబ్రరీ. ఇది సరళమైన మరియు క్రాస్-ప్లాట్‌ఫారమ్ ఇంటర్‌ఫేస్‌ను అందిస్తుంది.

తరంగ రూప ఉత్పత్తి: సింథసిస్ యొక్క గుండె

అన్ని శబ్దాలు, అవి ఎంత సంక్లిష్టంగా ఉన్నా, సాధారణ, ప్రాథమిక తరంగ రూపాల కలయికలుగా విభజించబడతాయి. ఇవి మన ధ్వని పాలెట్‌లోని ప్రాథమిక రంగులు. వాటిని ఎలా ఉత్పత్తి చేయాలో తెలుసుకుందాం.

సైన్ వేవ్: స్వచ్ఛమైన స్వరం

సైన్ వేవ్ అన్ని ధ్వనులకు సంపూర్ణ నిర్మాణ బ్లాక్. ఇది ఓవర్‌టోన్‌లు లేదా హార్మోనిక్‌లు లేకుండా ఒకే ఫ్రీక్వెన్సీని సూచిస్తుంది. ఇది చాలా సున్నితంగా, స్వచ్ఛంగా ఉంటుంది మరియు తరచుగా 'ఫ్లూట్ లాగా' వర్ణించబడుతుంది. గణిత సూత్రం:

y(t) = Amplitude * sin(2 * π * frequency * t)

ఇక్కడ 't' అనేది సమయం. దీన్ని పైథాన్ కోడ్‌లోకి అనువదిద్దాం.

            
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
              
            
          

ఈ కోడ్‌లో, np.linspace సమయ అక్షాన్ని సూచించే శ్రేణిని సృష్టిస్తుంది. ఆపై మేము ఈ సమయ శ్రేణికి సైన్ ఫంక్షన్‌ను వర్తింపజేస్తాము, కావలసిన ఫ్రీక్వెన్సీ ద్వారా స్కేల్ చేస్తాము. ఫలితం NumPy శ్రేణి, ఇక్కడ ప్రతి మూలకం మా ధ్వని తరంగం యొక్క శాంపిల్. మేము దానిని sounddevice తో ప్లే చేయవచ్చు మరియు matplotlib తో దృశ్యమానం చేయవచ్చు.

ఇతర ప్రాథమిక తరంగ రూపాలను అన్వేషించడం

సైన్ వేవ్ స్వచ్ఛమైనది అయినప్పటికీ, అది ఎల్లప్పుడూ అత్యంత ఆసక్తికరమైనది కాదు. ఇతర ప్రాథమిక తరంగ రూపాలు హార్మోనిక్‌లతో నిండి ఉంటాయి, వాటికి మరింత సంక్లిష్టమైన మరియు ప్రకాశవంతమైన లక్షణాన్ని (టింబర్) ఇస్తాయి. scipy.signal మాడ్యూల్ వాటిని ఉత్పత్తి చేయడానికి అనుకూలమైన ఫంక్షన్‌లను అందిస్తుంది.

స్క్వేర్ వేవ్

ఒక స్క్వేర్ వేవ్ దాని గరిష్ట మరియు కనిష్ట విస్తీర్ణాల మధ్య తక్షణమే దూకుతుంది. ఇది కేవలం బేసి-సంఖ్యల హార్మోనిక్‌లను మాత్రమే కలిగి ఉంటుంది. ఇది ప్రకాశవంతమైన, రీడీ మరియు కొంతవరకు 'గుల్ల' లేదా 'డిజిటల్' ధ్వనిని కలిగి ఉంటుంది, ఇది తరచుగా ప్రారంభ వీడియో గేమ్ సంగీతంతో ముడిపడి ఉంటుంది.

            
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
              
            
          

ఏ హార్మోనిక్‌లను ఏ విస్తీర్ణాలతో జోడించాలో జాగ్రత్తగా ఎంచుకోవడం ద్వారా, మీరు నిజ-ప్రపంచ పరికరాల శబ్దాలను అనుకరించడం ప్రారంభించవచ్చు. ఈ సాధారణ ఉదాహరణ ఇప్పటికే సాధారణ సైన్ వేవ్ కంటే చాలా గొప్పగా మరియు మరింత ఆసక్తికరంగా ధ్వనిస్తుంది.

ఎన్వలప్‌లతో (ADSR) ధ్వనిని రూపొందించడం

ఇప్పటివరకు, మన శబ్దాలు అకస్మాత్తుగా మొదలవుతాయి మరియు ఆగిపోతాయి. అవి వాటి వ్యవధి అంతటా స్థిరమైన వాల్యూమ్‌ను కలిగి ఉంటాయి, ఇది చాలా అస్వాభావికంగా మరియు రోబోటిక్‌గా ధ్వనిస్తుంది. నిజ ప్రపంచంలో, శబ్దాలు కాలక్రమేణా అభివృద్ధి చెందుతాయి. పియానో ​​నోట్‌కు పదునైన, బిగ్గరగా ప్రారంభం ఉంటుంది, అది త్వరగా మసకబారుతుంది, అయితే వయోలిన్‌పై వాయించిన నోట్ క్రమంగా వాల్యూమ్‌లో పెరుగుతుంది. మేము విస్తీర్ణ ఎన్వలప్‌ను ఉపయోగించి ఈ డైనమిక్ పరిణామాన్ని నియంత్రిస్తాము.

ADSR మోడల్

అత్యంత సాధారణ రకం ఎన్వలప్ ADSR ఎన్వలప్, దీనికి నాలుగు దశలు ఉన్నాయి:

• అటాక్ (Attack): ధ్వని నిశ్శబ్దం నుండి దాని గరిష్ట విస్తీర్ణానికి వెళ్ళడానికి పట్టే సమయం. వేగవంతమైన అటాక్ పెర్కసివ్, పదునైన ధ్వనిని సృష్టిస్తుంది (డ్రమ్ హిట్ లాగా). నెమ్మదిగా అటాక్ సున్నితమైన, ఉప్పెన ధ్వనిని సృష్టిస్తుంది (స్ట్రింగ్ ప్యాడ్ లాగా).
• డికే (Decay): ధ్వని గరిష్ట అటాక్ స్థాయి నుండి సస్టైన్ స్థాయికి తగ్గడానికి పట్టే సమయం.
• సస్టైన్ (Sustain): నోట్‌ను పట్టుకున్నంత కాలం ధ్వని నిర్వహించే విస్తీర్ణ స్థాయి. ఇది ఒక స్థాయి, సమయం కాదు.
• రిలీజ్ (Release): నోట్‌ను విడుదల చేసిన తర్వాత ధ్వని సస్టైన్ స్థాయి నుండి నిశ్శబ్దానికి మసకబారడానికి పట్టే సమయం. సుదీర్ఘ రిలీజ్ పియానో ​​నోట్ సస్టైన్ పెడల్ నొక్కినట్లు ధ్వనిని నిలిపి ఉంచుతుంది.

పైథాన్‌లో ADSR ఎన్వలప్‌ను అమలు చేయడం

మేము ADSR ఎన్వలప్‌ను NumPy శ్రేణిగా ఉత్పత్తి చేయడానికి ఒక ఫంక్షన్‌ను అమలు చేయవచ్చు. ఆపై మేము దానిని సాధారణ మూలకం-వారీ గుణకారం ద్వారా మా తరంగ రూపానికి వర్తింపజేస్తాము.

            
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
              
            
          

వివిధ ఎన్వలప్‌ను వర్తింపజేయడం ద్వారా అదే అంతర్లీన తరంగ రూపం దాని లక్షణాన్ని ఎంత నాటకీయంగా మారుస్తుందో గమనించండి. ఇది సౌండ్ డిజైన్‌లో ప్రాథమిక సాంకేతికత.

డిజిటల్ ఫిల్టరింగ్‌కు పరిచయం (సబ్‌ట్రాక్టివ్ సింథసిస్)

అడిటివ్ సింథసిస్ సైన్ వేవ్‌లను జోడించడం ద్వారా ధ్వనిని నిర్మిస్తే, సబ్‌ట్రాక్టివ్ సింథసిస్ దీనికి వ్యతిరేక పద్ధతిలో పనిచేస్తుంది. మేము హార్మోనిక్‌లతో నిండిన సిగ్నల్‌తో (సాటూత్ వేవ్ లేదా తెల్ల శబ్దం వంటివి) ప్రారంభించి, ఆపై ఫిల్టర్‌లను ఉపయోగించి నిర్దిష్ట ఫ్రీక్వెన్సీలను తొలగిస్తాము లేదా తగ్గస్తాము. ఇది ఒక శిల్పి పాలరాయి బ్లాక్‌తో ప్రారంభించి, ఒక రూపాన్ని వెల్లడించడానికి చిప్ చేయడం లాంటిది.

కీ ఫిల్టర్ రకాలు

• లో-పాస్ ఫిల్టర్: ఇది సింథసిస్‌లో అత్యంత సాధారణ ఫిల్టర్. ఇది నిర్దిష్ట 'కటఆఫ్' పాయింట్ క్రింద ఉన్న ఫ్రీక్వెన్సీలను దాటడానికి అనుమతిస్తుంది, అయితే దాని పైన ఉన్న ఫ్రీక్వెన్సీలను తగ్గిస్తుంది. ఇది ధ్వనిని మరింత ముదురుగా, వెచ్చగా లేదా మఫిల్డ్‌గా చేస్తుంది.
• హై-పాస్ ఫిల్టర్: లో-పాస్ ఫిల్టర్‌కు వ్యతిరేకం. ఇది కటఆఫ్ పైన ఉన్న ఫ్రీక్వెన్సీలను దాటడానికి అనుమతిస్తుంది, బాస్ మరియు లో-ఎండ్ ఫ్రీక్వెన్సీలను తొలగిస్తుంది. ఇది ధ్వనిని సన్నగా లేదా టిన్నీగా చేస్తుంది.
• బ్యాండ్-పాస్ ఫిల్టర్: నిర్దిష్ట ఫ్రీక్వెన్సీల బ్యాండ్‌ను మాత్రమే దాటడానికి అనుమతిస్తుంది, హైలు మరియు లోలు రెండింటినీ తగ్గిస్తుంది. ఇది 'టెలిఫోన్' లేదా 'రేడియో' ప్రభావాన్ని సృష్టించగలదు.
• బ్యాండ్-స్టాప్ (నాచ్) ఫిల్టర్: బ్యాండ్-పాస్‌కు వ్యతిరేకం. ఇది నిర్దిష్ట ఫ్రీక్వెన్సీల బ్యాండ్‌ను తొలగిస్తుంది.

SciPyతో ఫిల్టర్‌లను అమలు చేయడం

scipy.signal లైబ్రరీ డిజిటల్ ఫిల్టర్‌లను రూపొందించడానికి మరియు వర్తింపజేయడానికి శక్తివంతమైన సాధనాలను అందిస్తుంది. మేము బటర్‌వర్త్ ఫిల్టర్ అని పిలువబడే ఒక సాధారణ రకాన్ని ఉపయోగిస్తాము, ఇది పాస్‌బ్యాండ్‌లో దాని ఫ్లాట్ ప్రతిస్పందనకు ప్రసిద్ధి చెందింది.

ఈ ప్రక్రియలో రెండు దశలు ఉన్నాయి: ముందుగా, దాని గుణకాలను పొందడానికి ఫిల్టర్‌ను రూపొందించడం, మరియు రెండవది, ఆ గుణకాలను మా ఆడియో సిగ్నల్‌కు వర్తింపజేయడం.

            
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
              
            
          

అసలు మరియు ఫిల్టర్ చేయబడిన తరంగాల మధ్య వ్యత్యాసాన్ని వినండి. అసలుది ప్రకాశవంతంగా మరియు బజ్జీగా ఉంటుంది; ఫిల్టర్ చేయబడిన వెర్షన్ చాలా మృదువైనది మరియు ముదురు రంగులో ఉంటుంది, ఎందుకంటే అధిక-ఫ్రీక్వెన్సీ హార్మోనిక్‌లు తొలగించబడ్డాయి. లో-పాస్ ఫిల్టర్ యొక్క కటఆఫ్ ఫ్రీక్వెన్సీని స్వీప్ చేయడం ఎలక్ట్రానిక్ సంగీతంలో అత్యంత వ్యక్తీకరణ మరియు సాధారణ పద్ధతులలో ఒకటి.

మాడ్యులేషన్: కదలిక మరియు జీవితాన్ని జోడించడం

స్టాటిక్ శబ్దాలు బోరింగ్‌గా ఉంటాయి. డైనమిక్, అభివృద్ధి చెందుతున్న మరియు ఆసక్తికరమైన శబ్దాలను సృష్టించడానికి మాడ్యులేషన్ కీలకం. సూత్రం చాలా సులభం: ఒక సిగ్నల్‌ను (మాడ్యులేటర్) మరొక సిగ్నల్ (క్యారియర్) యొక్క పరామితిని నియంత్రించడానికి ఉపయోగించండి. ఒక సాధారణ మాడ్యులేటర్ లో-ఫ్రీక్వెన్సీ ఆసిలేటర్ (LFO), ఇది మానవ వినికిడి పరిధికి దిగువన (ఉదా., 0.1 Hz నుండి 20 Hz వరకు) ఫ్రీక్వెన్సీతో కూడిన ఆసిలేటర్.

విస్తీర్ణ మాడ్యులేషన్ (AM) మరియు ట్రెమొలో

మన ధ్వని యొక్క విస్తీర్ణాన్ని నియంత్రించడానికి LFOను ఉపయోగించినప్పుడు ఇది జరుగుతుంది. దీని ఫలితంగా వాల్యూమ్‌లో లయబద్ధమైన పల్సింగ్ ఏర్పడుతుంది, దీనిని ట్రెమొలో అంటారు.

            
# 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
              
            
          

ఫ్రీక్వెన్సీ మాడ్యులేషన్ (FM) మరియు వైబ్రాటో

మన ధ్వని యొక్క ఫ్రీక్వెన్సీని నియంత్రించడానికి LFOను ఉపయోగించినప్పుడు ఇది జరుగుతుంది. ఫ్రీక్వెన్సీ యొక్క నెమ్మదిగా, సూక్ష్మమైన మాడ్యులేషన్ వైబ్రాటోను సృష్టిస్తుంది, ఇది గాయకులు మరియు వయోలిన్ వాద్యకారులు వ్యక్తీకరణను జోడించడానికి ఉపయోగించే పిచ్ యొక్క సున్నితమైన కదలిక.

            
# 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
              
            
          

ఇది FM సింథసిస్ యొక్క సరళీకృత వెర్షన్. LFO ఫ్రీక్వెన్సీ వినదగిన పరిధిలోకి పెరిగినప్పుడు, అది సంక్లిష్ట సైడ్‌బ్యాండ్ ఫ్రీక్వెన్సీలను సృష్టిస్తుంది, దీని ఫలితంగా గొప్ప, గంట లాంటి మరియు మెటాలిక్ టోన్‌లు వస్తాయి. ఇది Yamaha DX7 వంటి సింథసైజర్‌ల ఐకానిక్ సౌండ్‌కు ఆధారం.

అన్నింటినీ కలిపి: ఒక మినీ సింథసైజర్ ప్రాజెక్ట్

మనం నేర్చుకున్న ప్రతిదాన్ని ఒక సాధారణ, క్రియాత్మక సింథసైజర్ తరగతిలోకి మిళితం చేద్దాం. ఇది మా ఆసిలేటర్, ఎన్వలప్ మరియు ఫిల్టర్‌ను ఒకే, తిరిగి ఉపయోగించగల వస్తువులోకి చేర్చబడుతుంది.

            
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
              
            
          

ఈ సాధారణ తరగతి మనం కవర్ చేసిన సూత్రాలకు శక్తివంతమైన ప్రదర్శన. దీన్ని ప్రయోగించమని నేను మిమ్మల్ని ప్రోత్సహిస్తున్నాను. మీరు ధ్వనిని ఎంత తీవ్రంగా మార్చగలరో చూడటానికి వివిధ తరంగ రూపాలను ప్రయత్నించండి, ADSR పరామితులను సర్దుబాటు చేయండి మరియు ఫిల్టర్ కటఆఫ్‌ను మార్చండి.

ప్రాథమిక అంశాలకు మించి: తరువాత ఎక్కడికి వెళ్లాలి?

ఆడియో సింథసిస్ మరియు DSP యొక్క లోతైన మరియు బహుమతినిచ్చే రంగంలో మనం ఉపరితలం మాత్రమే తాకాము. ఇది మీకు ఆసక్తిని రేకెత్తించినట్లయితే, అన్వేషించడానికి కొన్ని అధునాతన అంశాలు ఇక్కడ ఉన్నాయి:

• వేవ్‌టేబుల్ సింథసిస్: గణితపరంగా ఖచ్చితమైన ఆకృతులను ఉపయోగించకుండా, ఈ సాంకేతికత ముందుగా రికార్డ్ చేయబడిన, సింగిల్-సైకిల్ తరంగ రూపాలను ఆసిలేటర్ సోర్స్‌గా ఉపయోగిస్తుంది, ఇది చాలా సంక్లిష్టమైన మరియు అభివృద్ధి చెందుతున్న టింబర్‌లను అనుమతిస్తుంది.
• గ్రాన్యులర్ సింథసిస్: ఇప్పటికే ఉన్న ఆడియో శాంపిల్‌ను చిన్న ముక్కలుగా (గ్రెయిన్‌లు) విడదీసి, ఆపై వాటిని తిరిగి అమర్చడం, విస్తరించడం మరియు పిచ్ చేయడం ద్వారా కొత్త శబ్దాలను సృష్టిస్తుంది. వాతావరణ అల్లికలు మరియు ప్యాడ్‌లను సృష్టించడానికి ఇది అద్భుతమైనది.
• ఫిజికల్ మోడలింగ్ సింథసిస్: ఒక పరికరం యొక్క భౌతిక లక్షణాలను గణితపరంగా మోడల్ చేయడం ద్వారా ధ్వనిని సృష్టించడానికి ప్రయత్నించే ఒక ఆకర్షణీయమైన విధానం—గిటార్ యొక్క తీగ, క్లారినెట్ యొక్క ట్యూబ్, డ్రమ్ యొక్క పొర.
• రియల్-టైమ్ ఆడియో ప్రాసెసింగ్: PyAudio మరియు SoundCard వంటి లైబ్రరీలు మైక్రోఫోన్‌లు లేదా ఇతర ఇన్‌పుట్‌ల నుండి ఆడియో స్ట్రీమ్‌లతో నిజ సమయంలో పని చేయడానికి మిమ్మల్ని అనుమతిస్తాయి, ప్రత్యక్ష ప్రభావాలు, ఇంటరాక్టివ్ ఇన్‌స్టాలేషన్‌లు మరియు మరిన్నింటికి మార్గం సుగమం చేస్తాయి.
• ఆడియోలో మెషిన్ లెర్నింగ్: AI మరియు డీప్ లెర్నింగ్ ఆడియోలో విప్లవాత్మక మార్పులు తీసుకువస్తున్నాయి. నమూనాలు నవల సంగీతాన్ని ఉత్పత్తి చేయగలవు, వాస్తవిక మానవ ప్రసంగాన్ని సంశ్లేషణ చేయగలవు లేదా మిశ్రమ పాట నుండి వ్యక్తిగత పరికరాలను కూడా వేరు చేయగలవు.

ముగింపు

డిజిటల్ ధ్వని యొక్క ప్రాథమిక స్వభావం నుండి క్రియాత్మక సింథసైజర్‌ను నిర్మించడం వరకు మేము ప్రయాణించాము. పైథాన్, NumPy మరియు SciPyలను ఉపయోగించి స్వచ్ఛమైన మరియు సంక్లిష్ట తరంగ రూపాలను ఎలా ఉత్పత్తి చేయాలో మేము నేర్చుకున్నాము. ADSR ఎన్వలప్‌లను ఉపయోగించి మా శబ్దాలకు జీవం మరియు ఆకారాన్ని ఎలా ఇవ్వాలో, డిజిటల్ ఫిల్టర్‌లతో వాటి లక్షణాన్ని ఎలా రూపొందించాలో మరియు మాడ్యులేషన్‌తో డైనమిక్ కదలికను ఎలా జోడించాలో మేము కనుగొన్నాము. మేము వ్రాసిన కోడ్ కేవలం సాంకేతిక వ్యాయామం కాదు; ఇది ఒక సృజనాత్మక సాధనం.

పైథాన్ యొక్క శక్తివంతమైన శాస్త్రీయ స్టాక్ ఆడియో ప్రపంచంలో నేర్చుకోవడానికి, ప్రయోగాలు చేయడానికి మరియు సృష్టించడానికి అద్భుతమైన వేదికగా చేస్తుంది. ఒక ప్రాజెక్ట్ కోసం కస్టమ్ సౌండ్ ఎఫెక్ట్‌ను సృష్టించడం, ఒక సంగీత పరికరాన్ని నిర్మించడం లేదా మీరు ప్రతిరోజూ వినే శబ్దాల వెనుక ఉన్న సాంకేతికతను అర్థం చేసుకోవడం మీ లక్ష్యం అయినప్పటికీ, మీరు ఇక్కడ నేర్చుకున్న సూత్రాలు మీ ప్రారంభ స్థానం. ఇప్పుడు, ప్రయోగం చేయడానికి మీ వంతు. ఈ పద్ధతులను కలపడం ప్రారంభించండి, కొత్త పరామితులను ప్రయత్నించండి మరియు ఫలితాలను నిశితంగా వినండి. ధ్వని యొక్క విస్తారమైన విశ్వం ఇప్పుడు మీ చేతివేళ్ల వద్ద ఉంది—మీరు ఏమి సృష్టిస్తారు?