# gr_pfb_arb_resampler_fff Class Reference

Polyphase filterbank arbitrary resampler with float input, float output and float taps. More...

`#include <gr_pfb_arb_resampler_fff.h>`

Inheritance diagram for gr_pfb_arb_resampler_fff:

List of all members.

## Public Member Functions

~gr_pfb_arb_resampler_fff ()
void print_taps ()
void set_rate (float rate)
int general_work (int noutput_items, gr_vector_int &ninput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
compute output items from input items

## Friends

GR_CORE_API
gr_pfb_arb_resampler_fff_sptr
gr_make_pfb_arb_resampler_fff (float rate, const std::vector< float > &taps, unsigned int filter_size)

## Detailed Description

Polyphase filterbank arbitrary resampler with float input, float output and float taps.

This block takes in a signal stream and performs arbitrary resampling. The resampling rate can be any real number r. The resampling is done by constructing N filters where N is the interpolation rate. We then calculate D where D = floor(N/r).

Using N and D, we can perform rational resampling where N/D is a rational number close to the input rate r where we have N filters and we cycle through them as a polyphase filterbank with a stride of D so that i+1 = (i + D) % N.

To get the arbitrary rate, we want to interpolate between two points. For each value out, we take an output from the current filter, i, and the next filter i+1 and then linearly interpolate between the two based on the real resampling rate we want.

The linear interpolation only provides us with an approximation to the real sampling rate specified. The error is a quantization error between the two filters we used as our interpolation points. To this end, the number of filters, N, used determines the quantization error; the larger N, the smaller the noise. You can design for a specified noise floor by setting the filter size (parameters filter_size). The size defaults to 32 filters, which is about as good as most implementations need.

The trick with designing this filter is in how to specify the taps of the prototype filter. Like the PFB interpolator, the taps are specified using the interpolated filter rate. In this case, that rate is the input sample rate multiplied by the number of filters in the filterbank, which is also the interpolation rate. All other values should be relative to this rate.

For example, for a 32-filter arbitrary resampler and using the GNU Radio's firdes utility to build the filter, we build a low-pass filter with a sampling rate of fs, a 3-dB bandwidth of BW and a transition bandwidth of TB. We can also specify the out-of-band attenuation to use, ATT, and the filter window function (a Blackman-harris window in this case). The first input is the gain of the filter, which we specify here as the interpolation rate (32).

self._taps = gr.firdes.low_pass_2(32, 32*fs, BW, TB, attenuation_dB=ATT, window=gr.firdes.WIN_BLACKMAN_hARRIS)

The theory behind this block can be found in Chapter 7.5 of the following book.

f. harris, "Multirate Signal Processing for Communication Systems", Upper Saddle River, NJ: Prentice Hall, Inc. 2004.

## Constructor & Destructor Documentation

 gr_pfb_arb_resampler_fff::~gr_pfb_arb_resampler_fff ( )

## Member Function Documentation

 int gr_pfb_arb_resampler_fff::general_work ( int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items ) ` [virtual]`

compute output items from input items

Parameters:
 noutput_items number of output items to write on each output stream ninput_items number of input items available on each input stream input_items vector of pointers to the input items, one entry per input stream output_items vector of pointers to the output items, one entry per output stream
Returns:
number of items actually written to each output stream, or -1 on EOF. It is OK to return a value less than noutput_items. -1 <= return value <= noutput_items

general_work must call consume or consume_each to indicate how many items were consumed on each input stream.

Reimplemented from gr_block.

 void gr_pfb_arb_resampler_fff::print_taps ( )

Print all of the filterbank taps to screen.

 void gr_pfb_arb_resampler_fff::set_rate ( float rate ) ` [inline]`

## Friends And Related Function Documentation

 GR_CORE_API gr_pfb_arb_resampler_fff_sptr gr_make_pfb_arb_resampler_fff ( float rate, const std::vector< float > & taps, unsigned int filter_size ) ` [friend]`

Build the polyphase filterbank arbitray resampler.

Parameters:
 rate (float) Specifies the resampling rate to use taps (vector/list of floats) The prototype filter to populate the filterbank. The taps should be generated at the filter_size sampling rate. filter_size (unsigned int) The number of filters in the filter bank. This is directly related to quantization noise introduced during the resampling. Defaults to 32 filters.

The documentation for this class was generated from the following file: