About This Guide

This document describes using the Long FIR module to achieve improved (reduced) CPU utilization when processing very long FIR filters. The specific application described is a convolution reverberator.

Introduction

FIR filters, while very flexible and convenient to use, can take a lot of CPU cycles to process, if they are very long. The number of calculations required to process a single sample goes up as the square of the length of the filter in samples. So, a FIR filter with 100 coefficients will require 4 times as much processing as one with just 50 coefficients.

The Long Fir module improves on this by using a method known as FFT Convolution. Rather than needing N^2 computations per sample, only N * log2(N) computations are needed. The larger N is, the better the savings in CPU cycles. The tradeoff is an increased use of RAM.

This example requires the use of AWE Designer Pro as we use a MATLAB script to process the impulse response (IR) WAV file and upload the coefficients to the Long FIR Modules.

Reference Data Set

We will use data from two WAV files representing the impulse responses of

• the Cathedral Room at Shasta Lake Caverns in California.

  • http://www.echothief.com/cathedral-room-shasta-lake-caverns/

  • WAV file with 67,421 samples at 44.1 kHz sampling rate

• Battery Benson, Jefferson County, Washington.

  • http://www.echothief.com/battery-benson/

  • WAV file with 80,271 samples at 44.1 kHz sampling rate

By using the FIR block to process input audio with the data from these WAV files, we will create a “Convolution Reverb” that makes your audio sound like it would in the physical space.

Baseline Performance using the FIR Module

Open

Load the file “ReferenceFirExample.awd” into AWE Designer. The FIR Block already contains the coefficients from the left side of the stereo WAV file representing the cavern’s impulse response.

Running this program gives the following results on a Windows 10 PC with the following specs:

1. AMD Ryzen 5 2600 CPU @ 3.40 GHz

2. 16 GB RAM

AWE Server display:

Open

Using the Long FIR Module

The steps needed to use the Long FIR module are:

Place the following files in the same folder.

• CathedralReverb.wav

• BatteryBenson.wav

• format_long_fir_coeffs.m

• LongFIRExample.awd

1. Open MATLAB and run “awe_designer” at the command prompt.

2. Open LongFIRExample.awd in AWE Designer.

3. Open the format_long_fir_coeffs.m script in MATLAB

4. Run the script to process the cavern impulse response WAV file and load the coefficients of the 3 Long FIR modules. You will see the following output, which indicates that the coefficients were scaled down by 45.5 dB. This helps to prevent distortion in the filters. The actual value you see will depend on the WAV file being used.

Open

Now run the LongFIRExample1a.awd in AWE Designer. Here is the performance, along with a table comparing these results to the previous example which used the regular FIR module.

As you can see, using the Long FIR module achieves a roughly 28% saving in CPU cycles at the expense of using about 3 times as much RAM on this PC. The actual differences in performance and RAM usage will depend on the actual device running the program.

Using the Long FIR module in your own designs

Let’s take a look at the example patch. The input signal is sent to three parallel processing paths, identified as “First Chunk”, “Second Chunk” and “Third Chunk”.

The impulse response WAV file has been broken into 3 chunks by the MATLAB script, matching the size of the data to the length (in taps) of each filter. The audio data goes directly to FIR1 which is implementing the first chunk of the impulse response (512 taps). The subsequent Long FIR Filter V2 blocks need to have BufferUpV2 blocks added to increase the size of data that is being processed at one time. Here’s how to do it. (The supplied LongFIRExample.awd file implements this).

1. Set the length (Argument “L”) of the first Long FIR module to 512.

2. In the BufferUpV2 block for the second chunk, adjust the BufferUpFactor to be 512/2 * (input pin block size). In this example that is 512/(2 * 32) = 8.

3. Set the length L of the FIR2 module to an integer multiple of the FIR1 module’s length. In this case we have used 512 * 7 = 3584.

4. Note that the total length of FIR1 and FIR2 is 512 + 3584 = 4096.

5. In the BufferUpV2 block for the third chunk, adjust the BufferUpFactor to be 4096/2 * (input pin block size). In this example that is 4096/(2 * 32) = 64.

6. The length of FIR3 is determined by taking the total length of the first two chunks and subtracting that from the total length of the impulse response’s WAV file in samples. In this example, 67,421 - 4096 = 63,325. Now you need to round that to the next highest multiple of (FIR1 + FIR2)’s length. That is calculated as 4096 * (floor (63,325 / 4096) + 1) = 65536. We’ll add (65536 - 63325 = 2211) zeroes at the end of the data.

Running the MATLAB script

A MATLAB script is provided to manage formatting the impulse response data automatically. This includes:

• Reading the WAV file into an array

• If stereo, choosing the left channel

• Breaking the WAV file data into chunks of 512, 3584, and “the rest” (samples).

• Zero-padding the last chunk so that its length is an integer multiple of the sum of the first two (512 + 3584 = 4096).

• Uploading the chunks to the individual filter modules in the LongFIRExample.awd file.

To run the MATLAB script:

1. Place the LongFIRExample.awd file, the MATLAB format_long_fir_coeffs.m file, and the two impulse response WAV files in the same folder.

2. Open the MATLAB application.

3. At MATLAB’s console, run: awe_designer

4. When AWE Designer opens, load the LongFIRExample.awd design file.

5. In MATLAB, open the format_long_fir_coeffs.m script.

6. Confirm that the designerFile and reverbImpulseRespWav variables are set correctly.

7. Run the MATLAB script.

8. If you see this message:

Reconstructing the filter response

The output of FIR1 goes to the first input of Adder Add1.

The output of FIR2 goes through a BufferDownV2 block and then to the second input of Add1.

The output of FIR3 goes through a BufferDownV2 block and then to the third input of Add1.

This design also interleaves the 3 signals onto a single wire and sends them through a Rebuffer module and onto a Sink, so that we can see that the impulse response has been reconstructed from the 3 separate filters and properly time aligned. The Interleave, Rebuffer, and Sink modules are not needed other than to see this and can be omitted from your own designs.

The Multiplexor1’s index checkbox has been selected, so that we are feeding impulses from ImpulseMSecSource1 to the filter. This allows you to check both the basic sound of the reverb and visually compare the reconstructed impulse response with the original signal.

Run the patch, then click on “Sink2” to open the waveform display.

You can see by the colors that the composite impulse response has been reconstructed by adding the 3 signals together.

For comparison, here is the waveform view in Audacity of the original WAV file.

Signal Mixing and Bypass

Scaler2 allows you to adjust the level of the reconstructed reverb signal. This feeds into WetDry module WetDry1, which lets you set the balance between the dry (input) signal and wet (reverb). At a setting of 0, you just hear the dry signal. At 1.0, you only hear the reverb signal.

The MultiplexorV2 Multiplexor2 implements a bypass function. When the index checkbox is selected, the reverb is engaged.

Input Signal Selection

Using the MultiplexorV2 Multiplexor1, you can select either the default signal source, or a series of impulses (clicks) that repeat once a second (if the index is checked). Impulses are a convenient and consistent way to test reverb algorithms.

Appendix A: MATLAB Script format_long_fir_coeffs.m

Appendix B: References

Echothief Impulse Response Library

http://www.echothief.com/

Fast convolution by FFT

Smith, J.O. "Fourier Theorems for the DFT", in

Mathematics of the Discrete Fourier Transform (DFT)

with Audio Applications, Second Edition,

http://ccrma.stanford.edu/~jos/mdft/Fourier_Theorems_DFT.html,

online book, 2007 edition, accessed 02/14/2023.