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:

No description has been provided for this image

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.