RingBuffer (Posts about _sound_synthesis:wavetable)

Table Lookup Oscillator in Python

Noel Alben — Sun, 23 Mar 2025 06:59:00 GMT

Wave Table Oscillator Implementation¶

The PPG Wave Synthesizer Block Diagram¶

In [1]:

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

Step By Step Implementation¶

To get a better understanding of table look up oscillators, we will use design less performative but comprehensive program. This exercise provides the structure and implementation of a table look up oscillator which can then be integrated with modulators and envelope generators to build a wavetable synthesizer in python. In this exercise there are some coding gaps needed to be filled. These gaps are marked with the '[CODE]' label.

We will implement 4 classes today

The table look up class to store one cycle of waveforms
The phasor class that implements a phase accumulator that increments at a specific rate (phase_increment)
The voice generator that uses the table look up class and phasor to generate our specified waveforms
A simple interpolator

Table Look Up Class¶

We create an object which stores a dictionary of single cycles of waveforms [sine, square, saw, triangle and noise].

In [2]:

class waveTable:
    
    def __init__(self, table_size, duty_cycle = 0.5):
     # Constructor to Initialize all the parameters for our wavetable
        self.table_size = table_size
        self.duty_cycle = duty_cycle

        # Dictionary to store one cycle of the waveforms

        self.waveTableDictionary = {
            'sine': self.generate_sine(),
            'square': self.generate_square(),
            'saw': self.generate_saw(),
            'triangle': self.generate_triangle(),
            'noise': self.generate_noise()
        }

    # Methods to generate one cycle of our waves given the table_size
    def generate_sine(self):

        # We need an array of length `table_size'
        '[CODE]'
        return sine_wave
    def generate_square(self):
        
        # We need an array of length `table_size'
        '[CODE]'
        return square_wave

    def generate_saw(self):

        # We need an array of length `table_size'
        '[CODE]'
        return saw_wave

    def generate_triangle(self):

        increment_array = 2*np.arange(self.table_size//2) / (self.table_size//2) - 1 
        decrement_array = increment_array[::-1]
        # How would you handle odd entries for table_size
        triangle_wave = np.concatenate((increment_array, decrement_array))

        return triangle_wave

    def generate_noise(self):
        return np.random.uniform(-1, 1, self.table_size)

Phasor Class¶

For a sine wave at $f_0$ Hz with a table size of $N$ samples and a sampling rate of $f_s$ kHz, the sample increment is given by:

$$ \Delta s = \frac{f_0 \times N}{f_s} $$

In [9]:

class phaseGenerator:

    def __init__(self, frequency, duration, sample_rate = 48000):

        self.frequency = frequency
        self.duration = duration
        self.sample_rate = sample_rate
        self.num_samples = '[Code]'


    def generate_phasor(self, table_size):
        phasor = np.zeros(self.num_samples)
        phase = 0.0
        N = table_size
        # calculate the phase sample increment here:
        
        '[Code]'
        
        for i in range(self.num_samples):
            phasor[i] = phase
            
            # Increment phase
            phase += phase_increment
            
            # Wrap phase using modulus
            phase %= N
            
        return phasor

The history saving thread hit an unexpected error (OperationalError('attempt to write a readonly database')).History will not be written to the database.

Interpolator¶

In [4]:

# Can be improved to implement different interpolation methods

class linearInterpolator():
    #Implementing the call method in a class allows its instances to be invoked as functions, returning a value upon being called.
    def __call__(self, values, index):
        
        # Calculate lower index (pl) and fractional part (pf)
        lower_index = int(index)
        fractional_part = index - lower_index
        
        # Calculate upper index with wrapping (pu)
        upper_index = (lower_index + 1) % len(values)
        
        # Handle exact integer case for efficiency
        if fractional_part == 0:
            return values[lower_index]
        
        # Calculate weighted sum: (1 - pf)T[pl] + pf·T[pu]
        '[CODE]'
        
        return interpolated_value

Voice Generator¶

In [11]:

class voiceGenerator:

    def __init__(self, table_size, duty_cycle=0.5, sample_rate = 48000):
        
        self.sample_rate = sample_rate
        self.table_size  = table_size
        self.wave_table = waveTable(table_size, duty_cycle=duty_cycle)
        self.interpolator = linearInterpolator()

    def waveform(self, wave_type, frequency, duration, duty_cycle=0.5):
        phase = phaseGenerator(frequency, duration,self.sample_rate)
        phasor = phase.generate_phasor(self.table_size)
        # Call the appropriate method here
        '[CODE]'
        output = np.zeros(len(phasor))
        for i in range(len(phasor)):
                output[i] = self.interpolator(wavetable, phasor[i])
        return output

Simple Test¶

In [8]:

from scipy.io import wavfile



#vg = voiceGenerator(table_size=1024)
#waveforms = ['sine', 'square', 'saw', 'triangle']
#for wf in waveforms:
#   audio = vg.waveform(wf, 145, 2.0)
#   wavfile.write(f"{wf}_145hz.wav", 48000, (audio * 32767).astype(np.int16))
#print("Waveforms generated!")

Wavetables and SNR in Python

Noel Alben — Sun, 23 Mar 2025 06:59:00 GMT

The PPG Wave Synthesizer Block Diagram¶

In [3]:

import numpy as np
import matplotlib.pyplot as plt
from waveTableOscillator import voiceGenerator, phaseGenerator, waveTable, linearInterpolator
from scipy.io import wavfile

Implementing an ADSR and simple key control

In [5]:

def ADSR(attackTime, decayTime, sustainTime, releaseTime, samplerate):
    # An attack is a linear ramp up
    attack = np.linspace(0, 1, int(samplerate*attackTime))
    # An Decay is a linear ramp down
    decay = np.linspace(1, 0.5, int(samplerate*decayTime))
    # Sustain is a unit-step function
    sustain = np.linspace(0.5, 0.5, int(samplerate*sustainTime))
    # Release is another linear ramp down
    release = np.linspace(0.5, 0, int(samplerate*releaseTime))

    adsr = np.concatenate((attack, decay, sustain, release), axis=None)
    return adsr
    
def key_control(wave_type, table_size, frequency, attackTime, decayTime, sustainTime, releaseTime, samplerate=48000, duty_cycle=0.5):
    wave = voiceGenerator(table_size)
    adsr_env = ADSR(attackTime, decayTime, sustainTime, releaseTime, samplerate)
    duration = len(adsr_env)/samplerate
    audio = wave.waveform(wave_type, frequency, duration, duty_cycle)
    note = adsr_env * audio
    
    return note

Simple Synthesis¶

In [7]:

# Generate some notes
if __name__ == "__main__":

    # Define sample rate and table size
    sample_rate = 48000
    table_size = 2048
    
    # Define frequencies for a C major scale (C4 to C5)
    c_major_scale = {
        'C4': 261.63,
        'D4': 293.66,
        'E4': 329.63,
        'F4': 349.23,
        'G4': 392.00,
        'A4': 440.00,
        'B4': 493.88,
        'C5': 523.25
    }
    
    # ADSR parameters for different note types
    short_note = (0.01, 0.1, 0.1, 0.2)  # Short staccato note
    medium_note = (0.05, 0.2, 0.4, 0.3)  # Medium length note
    long_note = (0.1, 0.3, 1.0, 0.5)     # Long sustained note
    
    # Create an empty array for our song
    song = np.array([])
    
    # Add notes to the song
    sequence = [
        # Note name, waveform, ADSR type
        ('C4', 'sine', medium_note),
        ('E4', 'triangle', medium_note),
        ('G4', 'square', medium_note),
        ('C5', 'saw', long_note),
        ('G4', 'square', short_note),
        ('E4', 'triangle', short_note),
        ('C4', 'sine', long_note)
    ]
    
    for note_name, wave_type, adsr_type in sequence:
        frequency = c_major_scale[note_name]
        attackTime, decayTime, sustainTime, releaseTime = adsr_type
        
        # Generate the note
        note_data = key_control(
            wave_type, 
            table_size, 
            frequency, 
            attackTime, 
            decayTime, 
            sustainTime, 
            releaseTime, 
            sample_rate
        )
        
        song = np.append(song, note_data)
    
    # Normalize to prevent clipping
    song = song / np.max(np.abs(song))
    
    # Convert to 16-bit audio
    song_int16 = (song * 32767).astype(np.int16)
    
    # Save to WAV file
    wavfile.write("wavetable_melody.wav", sample_rate, song_int16)

    
    # Create three notes with different waveforms
    c_note = key_control('sine', table_size, c_major_scale['C4'], 0.1, 0.1, 0.8, 0.5, sample_rate)
    e_note = key_control('triangle', table_size, c_major_scale['E4'], 0.1, 0.1, 0.8, 0.5, sample_rate)
    g_note = key_control('saw', table_size, c_major_scale['G4'], 0.1, 0.1, 0.8, 0.5, sample_rate)
    
    # Mix them together (ensure same length)
    min_length = min(len(c_note), len(e_note), len(g_note))
    chord = (c_note[:min_length] + e_note[:min_length] + g_note[:min_length]) / 3.0
    
    # Convert to 16-bit audio
    chord_int16 = (chord * 32767).astype(np.int16)
    
    # Save to WAV file
    wavfile.write("wavetable_chord.wav", sample_rate, chord_int16)

Modulation¶

In [ ]:

def generate_lfo(lfo_type, lfo_freq, duration, sample_rate=48000):
# Create a voice generator for the LFO
    vg = voiceGenerator(table_size=1024)
    
    # Generate the LFO signal
    lfo_signal = vg.waveform(lfo_type, lfo_freq, duration)
    
    lfo_signal = (lfo_signal + 1) / 2
    
    return lfo_signal

SNR Calculation¶

The SNR for a table lookup sine oscillator can be approximated as, where $N$ is the size of the table:

$$ \text{SNR} \approx 6.02 \cdot \log_2(N) + \text{constant} $$

This can be calculated with the function below

In [21]:

def calculate_wavetable_snr(frequency, duration, table_size=1024, sample_rate=48000):
    
    # Generate wavetable signal
    wave_type = 'sine'
    vg = voiceGenerator(table_size)
    wavetable_signal = vg.waveform(wave_type, frequency, duration)
    
    # Generate ideal reference signal
    num_samples = len(wavetable_signal)
    time = np.arange(num_samples) / sample_rate
    reference_signal = np.sin(2 * np.pi * frequency * time)
    
    # Calculate noise as difference between wavetable and reference
    noise = wavetable_signal - reference_signal
    
    # Calculate SNR
    signal_power = np.mean(reference_signal**2)
    noise_power = np.mean(noise**2)
    
    if noise_power == 0:  # Avoid division by zero
        return float('inf')
    
    snr = 10 * np.log10(signal_power / noise_power)
    
    return snr

The history saving thread hit an unexpected error (OperationalError('attempt to write a readonly database')).History will not be written to the database.

In [20]:

# Experiment with table_size and SNR
snr = calculate_wavetable_snr(440, 2, table_size=24, sample_rate=48000)

Wavetable Synthesis

Henrik von Coler — Sun, 23 Mar 2025 06:59:00 GMT

Wavetable synthesis extends the principle of table-lookup oscillators. The approach became popular in the early 80s because it allowed the creation new, complex sounds. Early hardware instruments relied on a digital waveform generation, paired with analog filters and amplifiers. The novelty were arbitrary waveforms that resulted in timbres that were impossible to achieve with previous technologies. Although the approch was revolutionary, these early wavetable instruments could not compete with other devices of the early 80s (like the DX7).

Notable Instruments¶

PPG Wave:

PPG Wave
- 1981 (Palm Products, Germany)
- 8-voice polyphony
- analog VCA & VCF
- $7,000-10,000
Waldorf Microwave
- 1989 (Waldorf, Germany)
- 8-voice polyphony
- analog VCA & VCF
- $5,000
Massive
- 2006 (Native Instruments, Germany)
- sofwtare synth with 64 voices
Serum
- 2015 (Xfer Records, USA)
Argon8
- eight-voice polyphonic
- 2020 (Modal Electronics, UK)

Well Known Examples¶

PPG Wave I (1983):

PPG Wave II (1985):

Massive (2010):

Synthesis Principle by Example¶

Wavetable synthesis extends the table lookup oscillator principle with a simple feature:

Interpolation between different waveforms (tables).

1: Define the Wavetable¶

A wavetable is a collection of waveforms that can be stored in different data formats, such as arrays/matrices or dictionaries. The following example uses a simple wavetable with three waveforms:

Sine wave
Square wave
Sawtooth

Each of the waveforms has the length $N=4096$, resutling in a matrix $\mathrm{WT}_{M,N}$ with $M=3$ different waveforms:

2: Waveform Interpolation¶

With the matrix representation of the wavetable, the index $m$ can be used to blend between neighboring waveforms, using linear interpolation.

Example A: LFO¶

The following plots and audio example show a LFO modulation through all three waveforms:

Your browser does not support the audio element.

Example B: Exponential Attack¶

The following plots and audio example show a modulation with an exponential envelope, resulting in an attack transient:

Your browser does not support the audio element.

Table Lookup Oscillator

Henrik von Coler — Sun, 23 Mar 2025 06:59:00 GMT

Table-lookup oscillators are essential in digital signal processing and audio synthesis. They are widely used to generate periodic waveforms such as sine, square, triangle, and sawtooth waves. Beyond that, the method can be used to sythesize arbitrary waveforms, which is its key strength.

Advantages¶

Efficiency: By precomputing a waveform and storing it in a lookup table, the computation during runtime is minimal.
Flexibility: The same framework can generate different waveforms - and thus any timbre - by using different tables.

Drawbacks¶

Memory Usage: This is usually not a problem, but the more precise a table lookup oscillator, the more memory it needs.
Distortion: For small tables, this method creates distortions, more precisely quantization noise. For many applications, a well-designed table is accurate enough.

The Lookup Table¶

A lookup table is a sampled version of an arbitray continuous waveform. For basic periodic waveforms, the table holds exactly one cycle, sometimes only half or the quarter of a cycle, making use of symmetries. Table sizes of 256-4096 samples are common in sound synthesis applications.

The following example of a sine wave table $T$ uses a smaller size of $N=32$ for more detailed visualization:

Waveform Generation¶

This method in 3 steps ensures smooth waveform generation with high accuracy and efficiency, suitable for real-time audio or signal processing applications.

1. Phasor¶

A phase accumulator that increments at a rate (phase_increment) that is defined by the table size and the desired frequency.
This example uses the $2\pi$ range, known from trigonometric functions.
- The phase wraps around cyclically when it reaches $2\pi$.

2. Phasor Scaling¶

The phasor is scaled to the size of the lookup-table.
In this example it is cycling between the indexes 0 and 31.

For a sine wave at $f_0=440$ Hz with a table of size of $N=32$ samples and a sampling rate of $f_s=48$ kHz, the sample-increment results in:

$$ \Delta_s = f_0 \frac{N}{f_s} $$

3. Table Lookup with Interpolation:¶

The integer part of the phase determines the index in the table.
The fractional part of the phase is used for interpolation between the current and next index.
When the phasor lands between two indices in the table, linear interpolation is used to compute an in-between value.
This smooths out the waveform, especially for higher frequencies or low-resolution tables.

The interpolation is calculated with the lower and higher sample relative to the fractional position $p$ in the table.

We first get the lower and higher sample next to $p$:

$ p_l = ⌊p⌋ $

$ p_u = l+1 $

And the fractional value between these samples:

$ p_f = p - p_l $

The fractional sample value is then obtained with linear interpolation:

$$ T(p) = (1 - p_f) T[p_l] + p_f T[p_u] $$

Example 2: Frequency Modulation¶

The following example shows how a sinewave with modulated frequency is created:

Efficiency¶

Efficiency of Lookup Table Oscillators¶

A lookup table oscillator uses precomputed values stored in memory.
Generating a waveform involves:
- Memory access: Fetching a value from an array.
- Simple arithmetic: Updating the phase index and performing modulo operations.
These operations are computationally inexpensive compared to computing trigonometric functions.

Efficiency of a `sin()` Function¶

Computing the sine function (e.g., sin() in C++ or Python) involves:
- Trigonometric calculations: Implementations use Taylor series, CORDIC algorithms, or similar methods.
- These calculations require multiple multiplications, additions, and sometimes divisions, making them computationally expensive.

Performance Comparison¶

Lookup Table Oscillator: ( O(1) ) per sample (array lookup + basic arithmetic).
sin() Function: ( O(n) ), where ( n ) depends on the precision required.

In real-world scenarios:

A single sin() computation can take 50–150 nanoseconds [1].
A lookup table operation (memory access + arithmetic) might take 1–5 nanoseconds [2][3].
This results in 10–100x improvement in speed for a lookup table oscillator.

1. Intel Developer Zone: Optimizing Math Functions
  https://www.intel.com/content/www/us/en/developer/articles/technical/optimizing-math-library.html
1. Real-Time DSP Guide: Table Lookup Oscillators
  https://www.dspguide.com/
1. MusicDSP.org: Wavetable Synthesis Techniques
  https://musicdsp.org/

Example¶

Generating a sine wave at 44.1 kHz for 1 second:

Using sin():
- Compute ( 44,100 ) sine values, each taking ~100 ns.
- Total computation time: ~4.41 ms.
Using a Lookup Table:
- Perform ( 44,100 ) memory accesses and phase updates, each taking ~1–5 ns.
- Total computation time: ~0.1 ms.

This shows a potential 40x improvement in speed.

Memory Usage¶

Lookup tables require memory to store precomputed values:
- Example: A 1024-sample table of 32-bit floats requires 4 KB of memory.
Direct sin() does not need additional memory but uses more CPU cycles.

Distortion and SNR¶

The Signal-to-Noise Ratio (SNR) and quantization noise for a table lookup sine oscillator depend on the table size N, which is the number of samples per cycle used in the lookup table. A larger table size improves the accuracy of the sine wave representation and thus reduces the quantization error (noise) and increases the SNR.

The Signal-to-Noise Ratio (SNR) for a table lookup sine oscillator is influenced by the size of the lookup table and the interpolation method used. Larger tables result in more accurate sine wave approximations, while interpolation techniques (like linear or cubic interpolation) reduce quantization noise, improving the overall SNR. The quantization in the time domain has the same effect as a quantization in the amplitude range.

Quantization Noise¶

The quantization noise (in dB) is inversely proportional to the table size N. It can be approximated as:

$$ \text{Noise (dB)} \approx -6.02 \cdot \log_2(N) \quad \text{dB} $$

Where:

N is the number of samples in the lookup table (the table size).
The quantization noise decreases as the table size increases, following a logarithmic relationship.

SNR Formula¶

Basic SNR Formula:¶

The SNR for a table lookup sine oscillator can be approximated as:

$$ \text{SNR} ≈ 6.02⋅log2(N)+constant $$

Without interpolation this results in:

$$ \text{SNR} \approx 6.02 \cdot log2(N) + 1.76 \quad \text{dB} $$

Effect of Interpolation:¶

Lookup tables can use interpolation (e.g., linear or cubic) to improve accuracy, adding some computational overhead.
Even with interpolation, lookup tables remain faster than direct computation.
Without interpolation, the output waveform can sound rough or distorted, especially when the table resolution is low.
Linear interpolation provides a balance between computational cost and accuracy.
For even higher precision, cubic interpolation can be used, but at a greater computational expense.

Linear interpolation reduces the quantization noise compared to using no interpolation, improving the SNR by approximately 3 dB.

Thus, the formula for SNR with linear interpolation becomes:

$$ \text{SNR}_{\text{linear}} = 6.02 \cdot \log_2(N) + 1.76 + 3 \quad \text{dB} $$

For higher-order interpolation methods (e.g., cubic interpolation), the SNR improvement is even greater, but the improvement becomes less significant as the table size grows.

Where:

N is the number of samples in the lookup table (the table size).
The 3 dB accounts for the improvement provided by linear interpolation over simple nearest-neighbor lookup.

The following plot shows the relation between table size and quantization noise, respectively SNR. As the table size N increases, the SNR increases logarithmically while the quantization noise decreases logarithmically:

RingBuffer (Posts about _sound_synthesis:wavetable)

Table Lookup Oscillator in Python

Wave Table Oscillator Implementation¶

The PPG Wave Synthesizer Block Diagram¶

Step By Step Implementation¶

Table Look Up Class¶

Phasor Class¶

Interpolator¶

Voice Generator¶

Simple Test¶

Wavetables and SNR in Python

The PPG Wave Synthesizer Block Diagram¶

Simple Synthesis¶

Modulation¶

SNR Calculation¶

Wavetable Synthesis

Notable Instruments¶

Well Known Examples¶

Synthesis Principle by Example¶

1: Define the Wavetable¶

2: Waveform Interpolation¶

Example A: LFO¶

Example B: Exponential Attack¶

Table Lookup Oscillator

Advantages¶

Drawbacks¶

The Lookup Table¶

Waveform Generation¶

1. Phasor¶

2. Phasor Scaling¶

3. Table Lookup with Interpolation:¶

Example 2: Frequency Modulation¶

Efficiency¶

Efficiency of Lookup Table Oscillators¶

Efficiency of a sin() Function¶

Performance Comparison¶

Example¶

Memory Usage¶

Distortion and SNR¶

Quantization Noise¶

SNR Formula¶

Basic SNR Formula:¶

Effect of Interpolation:¶

Further Reading:¶

Efficiency of a `sin()` Function¶