saf_utility_filters.h

Go to the documentation of this file.

/*
 * Copyright 2019 Leo McCormack
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef SAF_FILTERS_H_INCLUDED
#define SAF_FILTERS_H_INCLUDED
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#include "saf_utilities.h"
 
/* ========================================================================== */
/*                                    Enums                                   */
/* ========================================================================== */
 
typedef enum {
    BIQUAD_FILTER_LPF,            
    BIQUAD_FILTER_LPF_EQCB,       
    BIQUAD_FILTER_HPF,            
    BIQUAD_FILTER_HPF_EQCB,       
    BIQUAD_FILTER_PEAK,           
    BIQUAD_FILTER_PEAK_EQCB,      
    BIQUAD_FILTER_LOW_SHELF,      
    BIQUAD_FILTER_LOW_SHELF_EQCB, 
    BIQUAD_FILTER_HI_SHELF,       
    BIQUAD_FILTER_HI_SHELF_EQCB,  
}BIQUAD_FILTER_TYPES;
 
typedef enum {
    BUTTER_FILTER_LPF, 
    BUTTER_FILTER_HPF, 
    BUTTER_FILTER_BPF, 
    BUTTER_FILTER_BSF  
}BUTTER_FILTER_TYPES;
 
typedef enum {
    FIR_FILTER_LPF, 
    FIR_FILTER_HPF, 
    FIR_FILTER_BPF, 
    FIR_FILTER_BSF  
}FIR_FILTER_TYPES;
 
typedef enum {
    WINDOWING_FUNCTION_RECTANGULAR,      
    WINDOWING_FUNCTION_HAMMING,          
    WINDOWING_FUNCTION_HANN,             
    WINDOWING_FUNCTION_BARTLETT,         
    WINDOWING_FUNCTION_BLACKMAN,         
    WINDOWING_FUNCTION_NUTTALL,          
    WINDOWING_FUNCTION_BLACKMAN_NUTTALL, 
    WINDOWING_FUNCTION_BLACKMAN_HARRIS   
}WINDOWING_FUNCTION_TYPES;
 
 
/* ========================================================================== */
/*                               Misc. Functions                              */
/* ========================================================================== */
 
void getWindowingFunction(WINDOWING_FUNCTION_TYPES type,
                          int winlength,
                          float* win);
 
void getOctaveBandCutoffFreqs(float* centreFreqs,
                              int nCentreFreqs,
                              float* cutoffFreqs);
 
void flattenMinphase(float* x,
                     int len);
 
void interpolateFiltersH(/* Input arguments */
                         int inFFTsize,
                         int outFFTsize,
                         int nFilters,
                         float_complex* filters_in,
                         /* Output arguments */
                         float_complex* filters_out);
 
float convertBW2Q(float BW);
 
float convertQ2BW(float Q);
 
 
/* ========================================================================== */
/*                             IIR Filter Functions                           */
/* ========================================================================== */
 
void biQuadCoeffs(/* input arguments */
                  BIQUAD_FILTER_TYPES filterType,
                  float fc,
                  float fs,
                  float Q,
                  float gain_dB,
                  /* output arguments */
                  float b[3],
                  float a[3]);
 
void applyBiQuadFilter(/* Input arguments */
                       float b[3],
                       float a[3],
                       float w_z_12[2],
                       float* signal,
                       int nSamples);
 
void evalBiQuadTransferFunction(/* Input arguments */
                                float b[3],
                                float a[3],
                                float* freqs,
                                int nFreqs,
                                float fs,
                                int mag2dB,
                                /* Output arguments */
                                float* magnitude,
                                float* phase_rad);
 
void evalIIRTransferFunction(/* Input arguments */
                                double* b,
                                double* a,
                                int nCoeffs,
                                float* freqs,
                                int nFreqs,
                                float fs,
                                int mag2dB,
                                /* Output arguments */
                                float* magnitude,
                                float* phase_rad);
 
void evalIIRTransferFunctionf(/* Input arguments */
                                float* b,
                                float* a,
                                int nCoeffs,
                                float* freqs,
                                int nFreqs,
                                float fs,
                                int mag2dB,
                                /* Output arguments */
                                float* magnitude,
                                float* phase_rad);
 
void applyIIR(/* Input arguments */
              float* in_signal,
              int nSamples,
              int nCoeffs,
              float* b,
              float* a,
              /* Input/output arguments */
              float* wz,
              /* Output arguments */
              float* out_signal);
 
void butterCoeffs(/* Input arguments */
                  BUTTER_FILTER_TYPES filterType,
                  int order,
                  float cutoff1,
                  float cutoff2,
                  float sampleRate,
                  /* Output arguments */
                  double* b_coeffs,
                  double* a_coeffs);
 
void faf_IIRFilterbank_create(void** phFaF,
                              int order,
                              float* fc,
                              int nCutoffFreqs,
                              float sampleRate,
                              int maxNumSamples);
 
void faf_IIRFilterbank_apply(void* hFaF,
                             float* inSig,
                             float** outBands,
                             int nSamples);
 
void faf_IIRFilterbank_flushBuffers(void* hFaF);
 
void faf_IIRFilterbank_destroy(void** hFaF);
 
 
/* ========================================================================== */
/*                            FIR Filter Functions                            */
/* ========================================================================== */
 
void FIRCoeffs(/* Input arguments */
               FIR_FILTER_TYPES filterType,
               int order,
               float cutoff1,
               float cutoff2,
               float sampleRate,
               WINDOWING_FUNCTION_TYPES windowType,
               int scalingFLAG,
               /* Output arguments */
               float* filter);
 
void FIRFilterbank(/* Input arguments */
                   int order,
                   float* fc,
                   int nCutoffFreqs,
                   float sampleRate,
                   WINDOWING_FUNCTION_TYPES windowType,
                   int scalingFLAG,
                   /* Output arguments */
                   float* filterbank);
 
 
#ifdef __cplusplus
}/* extern "C" */
#endif /* __cplusplus */
 
#endif /* SAF_FILTERS_H_INCLUDED */
 
 /* doxygen addtogroup Utilities */