FIR Filter

Example of FIR filter used on Chrono Trigger, which is used as a echo low-pass filter on this case. Screenshot taken from SNES SPC700 PLAYER

A FIR Filter (Finite impulse response filter) is a type of filter used on signal processing. It works by taking the sum of last Nth samples multiplied by a value, called FIR taps. It's finite because if you pass a FIR filter in an impulse response, the impulse will fade out after passing though the N taps. That's easy to notice since the FIR filter never uses itself as feed unlike the IIR Filter.

On the SNES, the FIR filter has 8 taps which are 1.7 fixed point values. The filter is applied on the echo output so it has direct influence to the sound output and can be used to archive different effects which is more detailed on the following topics.

Mathematical Definition

The FIR filter can be defined in the following mathematical formula: $y[n]=\sum _{i=0}^{N-1}b_{i}\cdot x[n-i]$

For the current output sample Y[n], take the sum of previous N samples from source (including current), multiplied by the FIR coefficient, which is:

$y[n]=b_{0}\cdot x[n]+b_{1}\cdot x[n-1]+b_{2}\cdot x[n-2]+...+b_{N-1}\cdot x[n-N-1]$

The SNES has eight FIR taps, which limits N to 8:

$y[n]=\sum _{i=0}^{7}b_{i}\cdot x[n-i]$

However, the samples are processed from the oldest to the newest sample. That means for the first FIR tap is applied to the oldest sample while the 8th tap is applied to the newest sample:

$y[n]=\sum _{i=0}^{7}b_{i}\cdot x[n-(7-i)]$

Which in other words, it yields to the equivalent pseudo-code:

y[n] = FIR[0] * x[n - 7] +
       FIR[1] * x[n - 6] +
       FIR[2] * x[n - 5] +
       FIR[3] * x[n - 4] +
       FIR[4] * x[n - 3] +
       FIR[5] * x[n - 2] + 
       FIR[6] * x[n - 1] + 
       FIR[7] * x[n - 0];

Where FIR is a array containing the eight taps.

S-DSP Implementation

The FIR taps are located on the DSP registers $0F though $7F, where $0F is the first tap (FIR[0]) and $7F is the last tap (FIR[7]).

Because the S-DSP doesn't have floating point capability, the tap values are actually in the 1.7 fixed point, signed format. This means that values between $00-$7F is positive (0 to 127) and $80-$FF is negative (-128 to -1) and after doing the multiplication the value then is divided by 128.

In addition, the tap sum is done on a 16-bit integer type, which means that if an overflow occur the value gets clipped. The only exception for this is the last multiplication (last FIR tap multiplied by the first sample). For this case, the number gets clamped instead of clipped, e.g.: 18623 + 16888 will yield to 32767 instead of overflowing to -30025.

An accurate implementation of the FIR filter using the above rules would be:

S = (FIR[0] * x[n - 7] >> 6) +
    (FIR[1] * x[n - 6] >> 6) +
    (FIR[2] * x[n - 5] >> 6) +
    (FIR[3] * x[n - 4] >> 6) +
    (FIR[4] * x[n - 3] >> 6) +
    (FIR[5] * x[n - 2] >> 6) + 
    (FIR[6] * x[n - 1] >> 6);

The ">>" operator is the arithmetic right shift operation, which on this context is the equivalent by dividing the value by 128 (without decimal places).

With the first 7 taps calculated, we clip it so it's always within the -32768 to 32767 range:

S = S & 0xFFFF;

Now we add the last tap which is multiplied by the current sample, x[n]:

S = S + (FIR[0] * x[n] >> 6);

clamp it to the -32768 to 32767:

S = S > 32767 ? 32767 : S;
S = S < -32768 ? -32768 : S;

It's important to remember that the Echo buffer uses 15-bit samples instead of 16-bit and it's left-aligned, so the binary format is: "seee eeee eeee eee0" and not "ssee eeee eeee eeee". However, when the sample is placed on the sample history (x[]), it end ups right shifted so it gets to the "ssee eeee eeee eeee" format.

So we finally take the last bit and we have our FIR value done:

Result = S & 0xFFFE;

Each sound channel (left and right) is processed separately.

Because of the integer clipping behavior on the first seven taps, it's important to your FIR filter DC gain never exceed 0 dB (or the absolute sum of all FIR taps never exceed 128) for avoiding audio clicks, specially with the first seven taps. Not all games obey that, so the most important is checking out the frequency response of the filter and checking how the gain behaves for the frequency range.

Once done, the FIR is multiplied by the L/R echo volume and it's output together the main volume. It's also multiplied by the echo feedback value and fed back to the echo buffer together the sound output.

Timing Information

The S-DSP generates one stereo sample every 32 SPC700 clocks. During these 32 clocks, some operations are done by the S-DSP regarding echo and FIR filter. These are the following:

Each time a new sample is generated on the S-DSP, one sample is taken from the echo buffer and inserted on the sample history (x[]), then the sample history is used to generate the FIR filter output:

The left echo channel is inserted on the sample history at cycle 22 and written on cycle 29.
The right echo channel is inserted on the sample history at cycle 23 and written on cycle 30.

The FIR taps are not read immediately, but gradually read while the left and right echo channel are being processed:

FIR[0] is accessed during cycle 22.
FIR[1] and FIR[2] are accessed during cycle 23.
FIR[3], FIR[4] and FIR[5] are accessed during cycle 24.
FIR[6] and FIR[7] are accessed during cycle 25.

Uses

The most useful thing that you can do with FIR filters is amplifying or attenuating a frequency range. Effectively, you can create your own sound equalizer depending on the echo settings and main volume combinations.

The most common usages involve:

Using FIR as a low or high pass filters, normally using 4.5 kHz as the cut-off point:
- Low-pass to filter out high frequencies from the echo sound output.
- High-pass to filter out low frequencies from the echo sound output.
Identity filter ($7F on the first tap and $00 on others): output original produced song from the echo buffer.

Frequency response

The FIR Filter frequency response of one of the Chrono Trigger songs. Image generated via !vb fir command of VilelaBot. FIR used: $0C $21 $2B $2B $13 $FE $F3 $F9. It's a low-pass filter with a cut-off frequency of around ~4.5 kHz.

It's possible to view the frequency response of a FIR filter and therefore visualize which frequencies are amplified or attenuated. The calculations involves Discrete-time Fourier transform (DFFT) and are considerably complex. The formula looks like this:

$H(\jmath \omega )=\sum _{n=0}^{N-1}h(n)[cos(n\omega )-\jmath sin(n\omega )]$

Where:

$H(\jmath \omega )$ $H(\jmath \omega )$ is the output power for given frequency $H(\omega )$ $H(\omega )$ . It is a complex number, therefore you will end up having two components, which is the magnitude $|H(\jmath \omega )|$ $|H(\jmath \omega )|$ and phase $\measuredangle H(\jmath \omega )$ $\measuredangle H(\jmath \omega )$ .
- Magnitude is the output volume e.g. 1.0 is 100% volume.
- Phase means how late or early is the signal relative to the original, in radians ( $\pi =+180^{\circ }$ ). Humans normally don't perceive phase changes, but combining two close and oppose phased-signals can generate some odd effects like an oscillating signal used on Square SPC engines.
$h(n)$ is the FIR filter taps.
$N$ is the amount of taps.

Disregarding SNES clipping and clamping effects, the frequency response of its 8-tap FIR would be calculated as the following:

$H(\jmath \omega )=\sum _{n=0}^{7}{\textrm {FIR}}(7-n)[cos(n\omega )-\jmath sin(n\omega )]$

Expanding the sum yields:

$H(\jmath \omega )={\textrm {FIR}}(7)+{\textrm {FIR}}(6)[cos(\omega )-\jmath sin(\omega )]+{\textrm {FIR}}(5)[cos(2\omega )-\jmath sin(2\omega )]+{\textrm {FIR}}(4)[cos(3\omega )-\jmath sin(3\omega )]+{\textrm {FIR}}(3)[cos(4\omega )-\jmath sin(4\omega )]+{\textrm {FIR}}(2)[cos(5\omega )-\jmath sin(5\omega )]+{\textrm {FIR}}(1)[cos(6\omega )-\jmath sin(6\omega )]+{\textrm {FIR}}(0)[cos(7\omega )-\jmath sin(7\omega )]$

When doing a visualization, it's often common to see ripples or signal ringing on certain regions. Even with careful values choice, it's not possible to attenuate them because of the low amount of taps the SNES FIR filter has, but regardless of the amount of taps they are often common on modern DSP applications and other kind of filters.

VilelaBot has a command for viewing FIR filters, using the !vb fir <FIR filter taps in hex> command.