dsp.FIRHalfbandInterpolator

Halfband interpolator

Description

The dsp.FIRHalfbandInterpolator System object™ performs efficient polyphase interpolation of the input signal using an upsampling factor of two. You can use dsp.FIRHalfbandInterpolator to implement the synthesis portion of a two-band filter bank to synthesize a signal from lowpass and highpass subbands. dsp.FIRHalfbandInterpolator uses an FIR equiripple design to construct the halfband filters and a polyphase implementation to filter the input.

To upsample and interpolate your data:

Create the dsp.FIRHalfbandInterpolator object and set its properties.
Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects?.

Creation

Syntax

firhalfbandinterp = dsp.FIRHalfbandInterpolator

firhalfbandinterp = dsp.FIRHalfbandInterpolator(Name,Value)

Description

firhalfbandinterp = dsp.FIRHalfbandInterpolator returns a FIR halfband interpolation filter, firhalfbandinterp, with the default settings. Under the default settings, the System object upsamples and interpolates the input data using a halfband frequency of 11025 Hz, a transition width of 4.1 kHz, and a stopband attenuation of 80 dB.

example

firhalfbandinterp = dsp.FIRHalfbandInterpolator(Name,Value) returns a halfband interpolator, with additional properties specified by one or more Name,Value pair arguments.

Example:

firhalfbandinterp =
                        dsp.FIRHalfbandInterpolator('Specification','Filter order and stopband
                        attenuation')

creates an FIR halfband interpolator object with filter order set to 52 and stopband attenuation set to 80 dB.

Properties

expand all

Unless otherwise indicated, properties are nontunable, which means you cannot change their values after calling the object. Objects lock when you call them, and the release function unlocks them.

If a property is tunable, you can change its value at any time.

For more information on changing property values, see System Design in MATLAB Using System Objects.

`Specification` — Filter design parameters
`'Transition width and stopband attenuation'` (default) | `'Filter order and stopband attenuation'` | `'Filter order and transition width'` | `'Coefficients'`

Filter design parameters, specified as a character vector. When you set Specification to one of the following, you choose two of the three available design parameters to design the FIR Halfband filter.

'Transition width and stopband attenuation' –– Transition width and stopband attenuation are the design parameters.
'Filter order and stopband attenuation' –– Filter order and stopband attenuation are the design parameters.
'Filter order and transition width' –– Filter order and transition width are the design parameters.

The filter is designed using optimal equiripple filter design method.

When you set Specification to 'Coefficients', you specify the halfband filter coefficients directly through the Numerator property.

`FilterOrder` — Filter order
`52` (default) | even positive integer

Filter order, specified as an even positive integer.

Dependencies

This property applies when you set Specification to either 'Filter order and stopband attenuation' or 'Filter order and transition width'.

`StopbandAttenuation` — Stopband attenuation
`80` (default) | positive real scalar

Stopband attenuation in dB, specified as a positive real scalar.

Dependencies

This property applies when you set Specification to either 'Filter order and stopband attenuation' or 'Transition width and stopband attenuation'.

`TransitionWidth` — Transition width
`4100` (default) | positive real scalar

Transition width in Hz, specified as a positive real scalar. The value of the transition width in Hz must be less than 1/2 the input sample rate.

Dependencies

This property applies when you set Specification to either 'Transition width and stopband attenuation' or 'Filter order and transition width'.

`Numerator` — FIR halfband filter coefficients
`2*firhalfband('minorder',0.407,1e-4)` (default) | row vector

FIR halfband filter coefficients, specified as a row vector. The coefficients must comply with the FIR halfband impulse response format. For details on this format, see Halfband Filters and FIR Halfband Filter Design. If half the order of the filter, (length(Numerator) - 1)/2 is even, every other coefficient starting from the first coefficient must be a zero except for the center coefficient which must be a 1.0. If half the order of the filter is odd, the sequence of alternating zeros with a 1.0 at the center starts at the second coefficient.

Dependencies

This property applies when you set Specification to 'Coefficients'.

`SampleRate` — Input sample rate
`44100` (default) | positive real scalar

Input sample rate in Hz, specified as a positive real scalar. The input sample rate defaults to 44100 Hz. If you specify a transition width as one of your filter design parameters, the transition width cannot exceed 1/2 the input sample rate.

Data Types: single | double

`FilterBankInputPort` — Synthesis filter bank
`false` (default) | `true`

Synthesis filter bank, specified as either false or true. If this property is false, dsp.FIRHalfbandInterpolator is an interpolation filter for a single vector- or matrix-valued input when you call the algorithm. If this property is true, dsp.FIRHalfbandInterpolator is a synthesis filter bank and the algorithm accepts two inputs, the lowpass and highpass subbands to synthesize.

Fixed-Point Properties

`CoefficientsDataType` — Word and fraction lengths of coefficients
`numerictype(1,16)` (default) | `numerictype` object

Word and fraction lengths of coefficients, specified as a signed or unsigned numerictype object. The default, numerictype(1,16) corresponds to a signed numeric type object with 16-bit coefficients and a fraction length determined based on the coefficient values, to give the best possible precision.

This property is not tunable.

Word length of the output is same as the word length of the input. Fraction length of the output is computed such that the entire dynamic range of the output can be represented without overflow. For details on how the fraction length of the output is computed, see Fixed-Point Precision Rules for Avoiding Overflow in FIR Filters.

`RoundingMethod` — Rounding method for output fixed-point operations
`'Floor'` (default) | `'Ceiling'` | `'Convergent'` | `'Nearest'` | `'Round'` | `'Simplest'` | `'Zero'`

Rounding method for output fixed-point operations, specified as a character vector. For more information on the rounding modes, see Precision and Range.

Usage

Syntax

y = firhalfbandinterp(x1)

y = firhalfbandinterp(x1,x2)

Description

example

y = firhalfbandinterp(x1) upsamples by two and interpolates the input signal x1 using the FIR halfband interpolator, firhalfbandinterp.

example

y = firhalfbandinterp(x1,x2) implements a halfband synthesis filter bank for the inputs x1 and x2. x1 is the lowpass output of a halfband analysis filter bank and x2 is the highpass output of a halfband analysis filter bank. dsp.FIRHalfbandInterpolator implements a synthesis filter bank only when the 'FilterBankInputPort' property is set to true.

Input Arguments

expand all

`x1` — Data input
column vector | matrix

Data input to the FIR halfband interpolator, specified as a column vector or a matrix. This signal is the lowpass output of a halfband analysis filter bank. If the input signal is a matrix, each column of the matrix is treated as an independent channel.

`x2` — Second data input
column vector | matrix

Second data input to the synthesis filter bank, specified as a column vector or a matrix. This signal is the highpass output of a halfband analysis filter bank. If the input signal is a matrix, each column of the matrix is treated as an independent channel.

The size, data type, and complexity of both the inputs must be the same.

Output Arguments

expand all

`y` — Output of interpolator
column vector | matrix

Output of the interpolator, returned as a column vector or a matrix. The number of rows in the interpolator output is twice the number of rows in the input signal.

Object Functions

To use an object function, specify the System object as the first input argument. For example, to release system resources of a System object named obj, use this syntax:

release(obj)

expand all

Specific to `dsp.FIRHalfbandInterpolator`

`freqz`	Frequency response of discrete-time filter System object
`fvtool`	Visualize frequency response of DSP filters
`info`	Information about filter System object
`cost`	Estimate cost of implementing filter System object
`coeffs`	Returns the filter System object coefficients in a structure
`polyphase`	Polyphase decomposition of multirate filter

Common to All System Objects

`step`	Run System object algorithm
`release`	Release resources and allow changes to System object property values and input characteristics
`reset`	Reset internal states of System object

Examples

collapse all

Impulse and Frequency Response of Halfband Interpolation Filter

Open Live Script

Create a lowpass halfband interpolation filter for upsampling data to 44.1 kHz. Specify a filter order of 52 and a transition width of 4.1 kHz.

Fs = 44.1e3;
InputSampleRate = Fs/2;
Order = 52;
TW = 4.1e3;
filterspec = 'Filter order and transition width';

firhalfbandinterp = dsp.FIRHalfbandInterpolator(...
    'Specification',filterspec,'FilterOrder',Order,...
    'TransitionWidth',TW,'SampleRate',InputSampleRate);

Plot the impulse response. The 0th order coefficient is delayed 26 samples, which is equal to the group delay of the filter. This yields a causal halfband filter.

fvtool(firhalfbandinterp,'Analysis','Impulse');

Plot the magnitude and phase response.

fvtool(firhalfbandinterp,'Analysis','freq');

Extract Low Frequency Subband From Speech

Open Live Script

Use a halfband analysis filter bank and interpolation filter to extract the low frequency subband from a speech signal.

Note: If you are using R2016a or an earlier release, replace each call to the object with the equivalent step syntax. For example, obj(x) becomes step(obj,x).

Note: The audioDeviceWriter System object™ is not supported in MATLAB Online.

Set up the audio file reader, the analysis filter bank, audio device writer, and interpolation filter. The sampling rate of the audio data is 22050 Hz. The order of the halfband filter is 52, with a transition width of 2 kHz.

afr = dsp.AudioFileReader('speech_dft.mp3','SamplesPerFrame',1024);

filterspec = 'Filter order and transition width';
Order = 52;
TW = 2000;

firhalfbanddecim = dsp.FIRHalfbandDecimator(...
    'Specification',filterspec,'FilterOrder',Order,...
    'TransitionWidth',TW,'SampleRate',afr.SampleRate);

firhalfbandinterp = dsp.FIRHalfbandInterpolator(...
    'Specification',filterspec,'FilterOrder',Order,...
    'TransitionWidth',TW,'SampleRate',afr.SampleRate/2);

adw = audioDeviceWriter('SampleRate',afr.SampleRate);

View the magnitude response of the halfband filter.

fvtool(firhalfbanddecim)

Read the speech signal from the audio file in frames of 1024 samples. Filter the speech signal into lowpass and highpass subbands with a halfband frequency of 5512.5 Hz. Reconstruct a lowpass approximation of the speech signal by interpolating the lowpass subband. Play the filtered output.

while ~isDone(afr)
  audioframe = afr();
  xlo = firhalfbanddecim(audioframe);
  ylow = firhalfbandinterp(xlo);
  adw(ylow);
end

Wait until the audio file is played to the end, then close the input file and release the audio output resource.

release(afr);           
release(adw);

Two-Channel Filter Bank

Open Script

Use a halfband decimator and interpolator to implement a two-channel filter bank. This example uses an audio file input and shows that the power spectrum of the filter bank output does not differ significantly from the input.

Note: If you are using R2016a or an earlier release, replace each call to the object with the equivalent step syntax. For example, obj(x) becomes step(obj,x).

Note: The audioDeviceWriter System object™ is not supported in MATLAB Online.

Set up the audio file reader and device writer. Construct the FIR halfband decimator and interpolator. Finally, set up the spectrum analyzer to display the power spectra of the filter-bank input and output.

AF = dsp.AudioFileReader('speech_dft.mp3','SamplesPerFrame',1024);
AP = audioDeviceWriter('SampleRate',AF.SampleRate);

filterspec = 'Filter order and transition width';
Order = 52;
TW = 2000;

firhalfbanddecim = dsp.FIRHalfbandDecimator(...
    'Specification',filterspec,'FilterOrder',Order,...
    'TransitionWidth',TW,'SampleRate',AF.SampleRate);

firhalfbandinterp = dsp.FIRHalfbandInterpolator(...
    'Specification',filterspec,'FilterOrder',Order,...
    'TransitionWidth',TW,'SampleRate',AF.SampleRate/2,...
    'FilterBankInputPort',true);

SpecAna = dsp.SpectrumAnalyzer('SampleRate',AF.SampleRate,...
    'PlotAsTwoSidedSpectrum',false,'ReducePlotRate',false,...
    'ShowLegend',true,...
    'ChannelNames',{'Input signal','Filtered output signal'});

Read the audio 1024 samples at a time. Filter the input to obtain the lowpass and highpass subband signals decimated by a factor of two. This is the analysis filter bank. Use the halfband interpolator as the synthesis filter bank. Display the running power spectrum of the audio input and the output of the synthesis filter bank. Play the output.

while ~isDone(AF)
    audioInput = AF();
    [xlo,xhigh] = firhalfbanddecim(audioInput);
    audioOutput = firhalfbandinterp(xlo,xhigh);
    spectrumInput = [audioInput audioOutput];
    SpecAna(spectrumInput);
    AP(audioOutput);
end

release(AF);
release(AP);
release(SpecAna);

Upsample and Interpolate Multichannel Input

Open Live Script

Create a half-band interpolation filter for data sampled at 44.1 kHz. The filter order is 52 with a transition width of 4.1 kHz. Use the filter to upsample and interpolate a multichannel input.

Fs = 44.1e3; 
filterspec = 'Filter order and transition width';
Order = 52;
TW = 4.1e3;  
firhalfbandinterp = dsp.FIRHalfbandInterpolator(...
                                               'Specification',filterspec,...
                                               'FilterOrder',Order,...
                                               'TransitionWidth',TW,...
                                                'SampleRate',Fs);

x = randn(1024,4);
y = step(firhalfbandinterp,x);

More About

expand all

Halfband Filters

The ideal lowpass halfband filter is given by

$h (n) = \frac{1}{2 π} \int_{- π / 2}^{π / 2} e^{j ω n} d ω = \frac{\sin (\frac{π}{2} n)}{π n} .$

The ideal filter is not realizable because the impulse response is noncausal and not absolutely summable. However, the impulse response of the ideal lowpass filter possesses some important properties that are required of a realizable approximation. Specifically, the ideal lowpass halfband filter’s impulse response is:

equal to 0 for all even-indexed samples
equal to 1/2 at n=0. You can see this by using L’Hopital’s rule on the continuous-valued equivalent of the discrete-time impulse response.

The ideal highpass halfband filter is given by

$g (n) = \frac{1}{2 π} \int_{- π}^{- π / 2} e^{j ω n} d ω + \frac{1}{2 π} \int_{π / 2}^{π} e^{j ω n} d ω .$

Evaluating the preceding integral gives the following impulse response

$g (n) = \frac{\sin (π n)}{π n} - \frac{\sin (\frac{π}{2} n)}{π n} .$

The ideal highpass halfband filter’s impulse is:

Equal to 0 for all even-indexed samples
Equal to 1/2 at n=0.

dsp.FIRHalfbandInterpolator uses a causal FIR approximation to the ideal halfband response, which is based on minimizing the $ℓ^{\infty}$ norm of the error (minimax). See Algorithms for more details.

Algorithms

expand all

Halfband Equiripple Design

dsp.FIRHalfbandInterpolator uses a minimax FIR design to design a fullband linear phase filter with the desired specifications. The fullband filter is upsampled so that the even-indexed samples of the filter are replaced with zeros. The upsampling of the filter produces a halfband filter. Finally, the filter tap corresponding to the group delay of the filter in samples is set equal to 1/2. This yields a causal linear-phase FIR filter approximation to the ideal halfband filter defined in Halfband Filters. See [1] for a description of this filter design method using the Remez exchange algorithm.

The coefficients of the halfband interpolation filter are scaled by the interpolation factor, two, to preserve the output power of the signal.

Polyphase Implementation with Halfband Filters

dsp.FIRHalfbandInterpolator uses an efficient polyphase implementation for halfband filters when you filter the input signal. You can use a polyphase implementation to move the upsampling operation after filtering. This allows you to filter at the lower sampling rate.

Splitting a filter’s impulse response, h(n), into two polyphase components results in an even polyphase component with z-transform

$H_{0} (z) = \sum_{n} h (2 n) z^{- n} .$

and an odd polyphase component with z-transform

$H_{1} (z) = \sum_{n} h (2 n + 1) z^{- n} .$

The z-transform of the filter can be written in terms of the even and odd polyphase components as

$H (z) = H_{0} (z^{2}) + z^{- 1} H_{1} (z^{2}) .$

Graphically, you can represent upsampling by two followed by filtering with the following figure

Using the multirate noble identity for upsampling, you can move the upsampling operation after filtering. This enables you to filter at the lower rate.

For a halfband filter, the only nonzero coefficient in the even polyphase component is the coefficient corresponding to z⁰. Implementing the halfband filter as a causal FIR filter shifts the nonzero coefficient to approximately z^-N/4, where N is the number of filter taps. This process is shown in the following figure.

The top plot shows a halfband filter of order 52. The bottom plot shows the even polyphase component. Both of these filters are noncausal. Delaying the even polyphase component by 13 samples creates a causal FIR filter.

To efficiently implement the halfband interpolator, dsp.FIRHalfbandInterpolator replaces the upsampling operator, delay block, and adder with a commutator switch. This is shown in the following figure, where one polyphase component is replaced by a delay.

The commutator switch takes input samples from the two branches alternately, one sample at a time. This doubles the sampling rate of the input signal. The polyphase component that reduces to a simple delay depends on whether the half order of the filter is even or odd. This is because the delay required to make the even polyphase component causal can be odd or even, depending on the filter half order. For an example of this behavior, inspect the polyphase components of the following filters.

filterspec = 'Filter order and stopband attenuation';
halfOrderEven = dsp.FIRHalfbandInterpolator('Specification',filterspec,...
    'FilterOrder',64,'StopbandAttenuation',80);
halfOrderOdd = dsp.FIRHalfbandInterpolator('Specification',filterspec,...
    'FilterOrder', 54,'StopbandAttenuation',80);
polyphase(halfOrderEven)
polyphase(halfOrderOdd)

One of the polyphase components has a single nonzero coefficient indicating that it is a simple delay. To preserve the output power of the signal, the coefficients are scaled by the interpolation factor, two. To see this scaling, compare the polyphase components of a halfband interpolator with the coefficients of a halfband decimator.

hfirinterp = dsp.FIRHalfbandInterpolator;
hfirdecim = dsp.FIRHalfbandDecimator;
polyphase(hfirdecim)
polyphase(hfirinterp)

To summarize, dsp.FIRHalfbandInterpolator

Filters the input before upsampling with the even and odd polyphase components of the filter.
Exploits the fact that one filter polyphase component is a simple delay for a halfband filter.

References

[1] Harris, F.J. Multirate Signal Processing for Communication Systems, Prentice Hall, 2004, pp. 208–209.

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

See System Objects in MATLAB Code Generation (MATLAB Coder).

This object supports code generation for ARM^® Cortex^®-M and ARM Cortex-A processors.

Documentation

dsp.FIRHalfbandInterpolator

Description

Creation

Syntax

Description

Properties

Specification — Filter design parameters 'Transition width and stopband attenuation' (default) | 'Filter order and stopband attenuation' | 'Filter order and transition width' | 'Coefficients'

FilterOrder — Filter order 52 (default) | even positive integer

Dependencies

StopbandAttenuation — Stopband attenuation 80 (default) | positive real scalar

Dependencies

TransitionWidth — Transition width 4100 (default) | positive real scalar

Dependencies

Numerator — FIR halfband filter coefficients 2*firhalfband('minorder',0.407,1e-4) (default) | row vector

Dependencies

SampleRate — Input sample rate 44100 (default) | positive real scalar

FilterBankInputPort — Synthesis filter bank false (default) | true

Fixed-Point Properties

CoefficientsDataType — Word and fraction lengths of coefficients numerictype(1,16) (default) | numerictype object

RoundingMethod — Rounding method for output fixed-point operations 'Floor' (default) | 'Ceiling' | 'Convergent' | 'Nearest' | 'Round' | 'Simplest' | 'Zero'

Usage

Syntax

Description

Input Arguments

x1 — Data input column vector | matrix

x2 — Second data input column vector | matrix

Output Arguments

y — Output of interpolator column vector | matrix

Object Functions

Specific to dsp.FIRHalfbandInterpolator

Common to All System Objects

Examples

Impulse and Frequency Response of Halfband Interpolation Filter

Extract Low Frequency Subband From Speech

Two-Channel Filter Bank

Upsample and Interpolate Multichannel Input

More About

Halfband Filters

Algorithms

Halfband Equiripple Design

Polyphase Implementation with Halfband Filters

References

Extended Capabilities

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

Fixed-Point Conversion Design and simulate fixed-point systems using Fixed-Point Designer™.

See Also

Functions

Objects

Blocks

Topics

DSP System Toolbox Documentation

Support

`Specification` — Filter design parameters
`'Transition width and stopband attenuation'` (default) | `'Filter order and stopband attenuation'` | `'Filter order and transition width'` | `'Coefficients'`

`FilterOrder` — Filter order
`52` (default) | even positive integer

`StopbandAttenuation` — Stopband attenuation
`80` (default) | positive real scalar

`TransitionWidth` — Transition width
`4100` (default) | positive real scalar

`Numerator` — FIR halfband filter coefficients
`2*firhalfband('minorder',0.407,1e-4)` (default) | row vector

`SampleRate` — Input sample rate
`44100` (default) | positive real scalar

`FilterBankInputPort` — Synthesis filter bank
`false` (default) | `true`

`CoefficientsDataType` — Word and fraction lengths of coefficients
`numerictype(1,16)` (default) | `numerictype` object

`RoundingMethod` — Rounding method for output fixed-point operations
`'Floor'` (default) | `'Ceiling'` | `'Convergent'` | `'Nearest'` | `'Round'` | `'Simplest'` | `'Zero'`

`x1` — Data input
column vector | matrix

`x2` — Second data input
column vector | matrix

`y` — Output of interpolator
column vector | matrix

Specific to `dsp.FIRHalfbandInterpolator`

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Fixed-Point Conversion
Design and simulate fixed-point systems using Fixed-Point Designer™.