---

name: matlab-process-streaming-audio description: > Design and implement real-time audio processing chains using Audio Toolbox streaming objects. Use when building frame-based audio processing loops, multiband filters, dynamic range control, parametric EQ, level metering, loudness metering, SPL metering, octave-band analysis, sample rate conversion, frequency-domain filtering (long impulse responses, custom filter banks), or audio chains in Simulink. Covers visualization (visualize method), interactive tuning (parameterTuner), MIDI control, and Audio Toolbox Simulink blocks. Use when the user says "real-time audio", "streaming audio", "audio filter", "compressor", "equalizer", "level meter", "loudness meter", "SPL meter", "octave bands", "crossover filter", "audio chain", "MIDI control", "convolution reverb", "impulse response streaming", "frequency-domain filter", or asks to process audio frame-by-frame. license: https://www.mathworks.com/content/dam/mathworks/license/pmrl/license.md metadata: author: MathWorks version: "1.0"

Streaming Audio Processing

Design and run real-time audio processing in MATLAB and Simulink using Audio Toolbox streaming objects. These objects maintain internal state across frames, support tunable properties, and provide built-in visualization.

When to Use

• Building frame-based audio processing loops
• Filtering audio in real time (crossover, EQ, shelving, octave)
• Applying dynamic range control (compressor, limiter, expander, noise gate)
• Measuring audio levels (peak, loudness, SPL, octave-band spectra)
• Resampling audio signals (sample rate conversion)
• Applying long impulse responses in real time (frequency-domain filtering)
• Tuning audio parameters interactively while streaming
• Visualizing filter responses or compressor characteristics
• Controlling audio parameters with MIDI devices
• Building audio processing chains in Simulink

When NOT to Use

• Audio device I/O setup with audiostreamer — use the matlab-play-record-audio skill
• Audio plugin generation (VST/AU via createAudioPluginClass)
• Deep learning audio features or inference
• Offline batch processing of entire files without streaming

Workflow

Every streaming audio task follows this pattern:

1. Create source — dsp.AudioFileReader (or audiostreamer for live I/O)
2. Create processing objects — Audio Toolbox System objects configured for your sample rate
3. Visualize responses — call visualize(obj) on filter/DRC objects
4. Open tuning UI — call parameterTuner(obj) for interactive control
5. Process in a loop — read frames, process, write output
6. Clean up — release all objects

% Standard streaming audio processing pattern
reader = dsp.AudioFileReader("input.wav", SamplesPerFrame=256);
fs = reader.SampleRate;

crossFilt = crossoverFilter(2, [500 4000], SampleRate=fs);
comp = compressor(Threshold=-20, Ratio=4, SampleRate=fs);

visualize(crossFilt);
visualize(comp);
parameterTuner(crossFilt);
parameterTuner(comp);

while ~isDone(reader)
    audioIn = reader();
    [low, mid, high] = crossFilt(audioIn);
    low = comp(low);
    audioOut = low + mid + high;
    drawnow limitrate  % flush UI events so parameterTuner changes take effect
end

release(reader);
release(crossFilt);
release(comp);

Key Functions

Use These (Audio Toolbox objects)

| Object | Purpose | Use instead of | |--------|---------|---------------| | crossoverFilter | Split signal into frequency bands | butter + filter | | compressor | Dynamic range compression | Custom envelope/gain code | | limiter | Peak limiting | Custom clipping code | | expander | Dynamic range expansion | Custom gate code | | noiseGate | Gate signals below threshold | Manual threshold logic | | multibandParametricEQ | N-band parametric EQ with shelves | Manual biquad coefficient math | | graphicEQ | Graphic equalizer | Manual filter bank | | shelvingFilter | Low/high shelf filter | Manual shelf design | | audioLevelMeter | Digital peak level meter (sample-peak or true-peak, dBFS/dBTP) | Manual peak detection code | | loudnessMeter | EBU R128 loudness (momentary, short-term, integrated, LU range) | Manual loudness computation | | octaveSpectrumEstimator | Octave-band spectrum with weighting (R2024b) | octaveFilterBank + manual RMS/dB | | splMeter | Sound pressure level measurement (time-weighted, per-band) | Manual SPL computation | | weightingFilter | A/C/Z frequency weighting | Manual weighting curves | | octaveFilter | Single octave-band filter | Manual bandpass design | | octaveFilterBank | Multi-band octave filtering | Manual parallel filters | | audioresample | Sample rate conversion (R2023b) | resample or manual interpolation | | designAudioResampler | Design SRC for streaming (R2023b) | dsp.SampleRateConverter alone | | designParamEQ | Design parametric EQ coefficients | Manual biquad formulas | | designShelvingEQ | Design shelving filter coefficients — positional: (gain, slope, Fc, type) | Manual shelf formulas | | designVarSlopeFilter | Design variable-slope LP/HP — positional: (slope, Fc, type) | Manual Butterworth cascades | | reverberator | Artificial reverberation | Custom delay networks | | audioTimeScaler | Real-time time stretching (frame-based, no SampleRate property) | Manual phase vocoder | | dsp.STFT | Streaming short-time FFT with windowing + overlap (R2019a) | Manual buffer/window/FFT code | | dsp.ISTFT | Streaming inverse STFT with perfect reconstruction (R2019a) | Manual IFFT/overlap-add code | | dsp.FrequencyDomainFIRFilter | FFT-based FIR filtering for long IRs (fixed coefficients) | Manual overlap-add/save code |

Universal Methods

| Method/Function | Purpose | |-----------------|---------| | visualize(obj) | Show response plot (frequency, static characteristic, spectrum). Not supported by reverberator or splMeter. | | parameterTuner(obj) | Open interactive slider UI for all tunable properties | | obj(audioIn) | Process one frame (call object like a function) | | release(obj) | Free resources, allow property changes | | reset(obj) | Reset internal states without releasing |

MIDI Control Functions

| Function | Purpose | |----------|---------| | mididevinfo | List available MIDI devices | | mididevice | Connect to a MIDI device | | midimsg | Create MIDI messages | | midisend | Send MIDI messages to device | | midireceive | Receive MIDI messages from device | | midicallback | Define callback for MIDI control changes | | midicontrols | Open a group of MIDI controls for reading | | midiid | Interactively identify a MIDI control | | midiread | Read most recent MIDI control values | | midisync | Send values to MIDI controls to synchronize |

Patterns

Visualization and Tuning

parameterTuner works on every Audio Toolbox streaming object. visualize works on most objects — exceptions: reverberator and splMeter (use parameterTuner instead). Always use these methods instead of building custom UIs.

eq = multibandParametricEQ(NumEQBands=5, ...
    HasLowShelfFilter=true, HasHighShelfFilter=true, SampleRate=fs);

% One-line visualization — shows combined magnitude response
visualize(eq);

% One-line interactive tuning — sliders for all tunable properties
parameterTuner(eq);

Objects supporting parameterTuner: compressor, expander, limiter, noiseGate, octaveFilter, crossoverFilter, multibandParametricEQ, graphicEQ, audioOscillator, wavetableSynthesizer, reverberator, shelvingFilter, octaveSpectrumEstimator.

Multiband Processing

Split → process per band → sum. Use crossoverFilter for the split.

crossFilt = crossoverFilter(2, [500 4000], 48, fs);  % 2 crossovers, 48 dB/oct
compLow = compressor(Threshold=-20, Ratio=4, SampleRate=fs);
compMid = compressor(Threshold=-15, Ratio=3, SampleRate=fs);
compHigh = compressor(Threshold=-10, Ratio=2, SampleRate=fs);

% In the processing loop:
[low, mid, high] = crossFilt(audioIn);
audioOut = compLow(low) + compMid(mid) + compHigh(high);

Parametric Equalization

Use multibandParametricEQ for streaming EQ. It supports N bands, optional low/high shelves, optional lowpass/highpass, and oversampling.

eq = multibandParametricEQ( ...
    NumEQBands=5, ...
    EQOrder=4, ...
    Frequencies=[100 400 1000 4000 8000], ...
    QualityFactors=[0.7 1.5 2.0 1.8 0.7], ...
    PeakGains=[3 -2 4 -1.5 2], ...
    HasLowShelfFilter=true, LowShelfCutoff=80, LowShelfGain=2, ...
    HasHighShelfFilter=true, HighShelfCutoff=12000, HighShelfGain=-1, ...
    SampleRate=fs);

visualize(eq);
parameterTuner(eq);

% In the loop — all properties are tunable while streaming:
audioOut = eq(audioIn);

For coefficient-level control (e.g., feeding a dsp.SOSFilter), use design functions:

% designParamEQ — name-value syntax
[B, A] = designParamEQ(CenterFrequency=1000/(fs/2), ...
    QualityFactor=2, Gain=6, FilterOrder=4);

% designShelvingEQ — positional syntax: (gain, slope, normalizedFc, type)
[B, A] = designShelvingEQ(3, 0.8, 200/(fs/2), "lo", Orientation="row");

% designVarSlopeFilter — positional syntax: (slope, normalizedFc, type)
[B, A] = designVarSlopeFilter(24, 5000/(fs/2), "lo", Orientation="row");

Metering

Choose the metering object based on what you are measuring:

| Object | Measures | Standard | visualize support | |--------|----------|----------|-------------------| | audioLevelMeter | Sample-peak or true-peak (dBFS/dBTP) | IEC 60268-18 | Yes — peak meter bars with decay | | loudnessMeter | Momentary, short-term, integrated loudness + range (LUFS/LU) | EBU R128 / ITU-R BS.1770 | Yes — full EBU Mode meter | | splMeter | Sound pressure level per octave band | IEC 61672 | No — use timescope to plot outputs | | octaveSpectrumEstimator | Octave-band spectrum with weighting (R2024b) | — | Yes — real-time bar chart |

% Digital peak level meter (most common "give me a level meter" answer)
lvl = audioLevelMeter(Method="true-peak", SampleRate=fs);
visualize(lvl);
while ~isDone(reader)
    lvl(reader());
    drawnow limitrate
end

% Broadcast loudness meter (EBU R128)
loud = loudnessMeter(SampleRate=fs);
visualize(loud);
while ~isDone(reader)
    loud(reader());
    drawnow limitrate
end

% octaveSpectrumEstimator — preferred for octave-band visualization
ose = octaveSpectrumEstimator(fs, ...
    Bandwidth="1/3 octave", ...
    FrequencyWeighting="A-weighting", ...
    TimeWeighting="fast");

visualize(ose);         % Built-in real-time bar chart
parameterTuner(ose);    % Tune bandwidth, weighting, etc. while streaming

while ~isDone(reader)
    audioIn = reader();
    [spectrum, centerFreqs] = ose(audioIn);
end

% splMeter — when you need Lt, Leq, Lpeak, Lmax outputs
% NOTE: Initial frames return -Inf until the time-weighted filter
% accumulates sufficient energy (~10-50 frames). This is normal.
spl = splMeter( ...
    Bandwidth="1/3 octave", ...
    FrequencyWeighting="A-weighting", ...
    TimeWeighting="fast", ...
    SampleRate=fs);

[Lt, Leq, Lpeak, Lmax] = spl(audioIn);

Streaming Spectral Processing (Per-Bin Manipulation)

Use dsp.STFT + dsp.ISTFT when you need to manipulate individual frequency bins in a streaming loop (spectral gating, spectral subtraction, phase vocoder effects). These objects handle windowing, overlap, buffering, and perfect reconstruction internally.

% Streaming spectral noise gate using dsp.STFT / dsp.ISTFT
fftLen = 1024;
overlapLen = fftLen * 3/4;  % 75% overlap
win = hann(fftLen, 'periodic');

stf = dsp.STFT(win, overlapLen, fftLen);
istf = dsp.ISTFT(win, overlapLen);

reader = dsp.AudioFileReader("input.wav", SamplesPerFrame=fftLen-overlapLen);
writer = dsp.AudioFileWriter("output.wav", SampleRate=reader.SampleRate);

while ~isDone(reader)
    audioIn = reader()