Explosions Through Filtered Noise

This is a fun little algorithm described by David D. Thiel in the chapter Retro Game Sound: What We Can Learn from 1980s Era Synthesis in Audio Anecdotes, Volume I, edited by Ken Greenebaum and Ronen Barzel, published by A K Peters, 2003.

Filtered noise

To make filtered noise, we can draw a waveform like in the following image where the slope between the points determines how much high frequency content is in the sound. Steeper slope = more high frequencies.

The waveform consists of connected line segments. The steepness of the line segments is fixed but their lengths are randomized. Another way to look at this algorithm is that it generates a triangle wave but at random times the direction changes.

When taken to the extreme, with a slope that is steep enough, this creates regular white noise. The shallower the slope, the more muffled the sound is — in other words, the more filtering is applied.

The original code as published in Audio Anecdotes was derived from assembly written for an 8-bit CPU. On a modern CPU with floating-point support it can be implemented like so:

struct FilteredNoise
{
    FilteredNoise()
    {
        seed = uint32_t(time(nullptr));
        target = random();
        direction = 1.0f;
        value = 0.0f;
        slope = 0.0f;
    }

    void setCutoff(float frequency, float sampleRate)
    {
        slope = 3.0f * frequency / sampleRate;
    }

    float nextSample()
    {
        value += direction * slope;

        // Time to reverse direction?
        if (value * direction >= target) {
            value = target * direction;
            direction = -direction;
            target = random();
        }

        return value;
    }

private:
    float random()
    {
        // Generate a pseudorandom number in the interval [0, 1).
        seed = seed * 196314165 + 907633515;
        return float((seed >> 8) & 0xFFFFFF) / 16777216.0f;
    }

    uint32_t seed;    // for the random generator
    float value;      // current value
    float slope;      // speed by which the value changes
    float target;     // destination value (always positive)
    float direction;  // going up (1.0) or down (-1.0)
};

On every timestep, the nextSample() method increments the current sample value by the slope. When the value exceeds the target, the direction is reversed and a new target is picked using a random number generator.

If the previous target was above zero, the new target is below zero, and vice versa. On average, the waveform will be positive as often as it is negative, and there will be no DC offset.

In a frequency analyzer the noise looks like the following:

There is a clear 12 dB/octave roll-off like you’d see with a second-order low-pass filter. There is also a resonant boost around the cutoff point, here at 500 Hz. Where the cutoff frequency is located depends on the chosen slope.

This simple method creates noise that appears to be filtered.

However, if you create white noise in a tool such as Audacity and apply a 12 dB/octave low-pass filter, the filtered white noise sounds quite different. The sloped line segments method sounds a lot “rougher”.

The cutoff frequency

How does the slope relate to the cutoff frequency?

If we were to set slope = 4 * frequency / sampleRate and always have target = 1.0 rather than randomly choosing it, the algorithm creates a normal triangle wave. In the frequency analyzer this shows peaks at the fundamental frequency and for the odd harmonics.

The reason for needing the multiplier 4 is that slope describes how quickly the waveform’s amplitude rises from 0.0 to 1.0, and one period of the triangle wave is made up of four such line segments (0 → 1 → 0 → –1 → 0).

Why does this method cause filtered noise?

Since target can be randomly anywhere between 0.0 and 1.0, it doesn’t generate a regular triangle wave but merely something triangle-ish with a period that is constantly changing. This adds noise around the harmonics.

The signal appears filtered because the triangle-ish harmonics roll off in the same way as a second-order low-pass filter, by 12 dB/octave. The “resonant peak” around the cutoff frequency is simply the fundamental sticking out above the noise level.

Because the noise signal has a smaller period on average than a regular triangle wave, the cut-off frequency will appear higher. To compensate for this, the multiplier in the equation in setCutoff() is not 4 but 3. This is not exactly right, but close enough.

This formula for setting the slope works pretty well for low cutoff values, say anything below 10 kHz. For higher cutoffs, the slope becomes imprecise because at high frequencies there are only a few samples per cycle and the waveform ends up alternating between 1 and 2 samples per line segment.

Just for fun, instead of making target go randomly between 0.0 and 1.0, we can also keep it closer to 1.0. This produces a blend between the noisy sound and a regular triangle wave.

const float mix = 0.3f;
target = (1.0f - mix) + random() * mix;

The smaller the mix value is, the less randomness there is in the signal and the more “pitchy” the sound becomes, which creates an interesting type of noise in its own right. Using mix = 0.3 clearly shows that the noise is added around the harmonics from the triangle wave and that is what creates the shape of the filter roll-off.

Explosions!

To create an explosion, most of the algorithm stays the same, except we now gradually decrease the slope whenever the waveform changes direction. This is like doing a high-to-low filter sweep.

struct Explosion
{
    Explosion()
    {
        seed = uint32_t(time(nullptr));
        target = random();
        direction = 1.0f;
        value = 0.0f;
        slope = 0.0f;
        slopeDecrement = 0.0f;
        slopeEnd = 0.0f;
    }

    void start(float sampleRate)
    {
        slopeDecrement = (random() + 0.5f) / sampleRate;
        slope = slopeDecrement * 250.0f + random() * 250.0f / sampleRate;
        slopeEnd = 20.0f / sampleRate;
    }

    float nextSample()
    {
        // Gently ramp back to the center when done.
        if (slope < slopeEnd) {
            if (direction * value >= 0.0f) {  // finished?
                return 0.0f;
            } else {
                value += direction * slopeEnd / 4.0f;
                return value;
            }
        }

        value += direction * slope;

        // Time to reverse direction?
        if (value * direction >= target) {
            value = target * direction;
            direction = -direction;
            target = random();
            slope -= slopeDecrement;
        }

        return value;
    }

private:
    float random()
    {
        // Generate a pseudorandom number in the interval [0, 1).
        seed = seed * 196314165 + 907633515;
        return float((seed >> 8) & 0xFFFFFF) / 16777216.0f;
    }

    uint32_t seed;    // for the random generator
    float value;      // current value
    float slope;      // speed by which the value changes
    float target;     // destination value (always positive)
    float direction;  // going up (1.0) or down (-1.0)

    float slopeDecrement;  // speed of filter sweep
    float slopeEnd;        // when to stop
};

The start method randomly chooses the initial slope to make every explosion slightly different. The rate at which the slope changes, slopeDecrement, is also randomized.

The values used here were derived from the original implementation and correspond approximately to an initial cutoff frequency between 40 Hz and 200 Hz, and an explosion length between 2 and 8 seconds.

Once the slope has become small enough, determined by slopeEnd, the explosion is done. To avoid a DC offset, the code does a linear ramp back to 0.0 and then stays there.

The generated waveform looks like this:

What it sounds like:

The explosions sound kind of cool at the rather low sampling rate of 5 kHz used by the original article. These sound effects were intended to be played on arcade cabinets and would have made a nice rumble. But at 44.1 kHz and on hi-fi loudspeakers, it doesn’t make for very realistic explosions. Still, it’s a pretty clever algorithm that shows you can do a lot with a little!

Experiment with different values for slope and slopeDecrement to make other sound effects, such as thunder, drums, and wind.