IIR.h

Go to the documentation of this file.

/*
 *  IIR.h - IIR(biquad cascade) Library Header
 *  Copyright 2019, 2021 Sony Semiconductor Solutions Corporation
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef _IIR_H_
#define _IIR_H_
 
/*------------------------------------------------------------------*/
/* For compatibility                                                */
/*------------------------------------------------------------------*/
/* An execution sample of frame */
/* For compatibility. Please do not use! */
#define FRAMSIZE IIRClass::DEFAULT_FRAMESIZE
 
/* Use CMSIS library */
#define ARM_MATH_CM4
#define __FPU_PRESENT 1U
#include <cmsis/arm_math.h>
 
#include "RingBuff.h"
 
/*------------------------------------------------------------------*/
/* Type Definition                                                  */
/*------------------------------------------------------------------*/
typedef enum e_filterType {
  TYPE_LPF,
  TYPE_HPF,
  TYPE_BPF,
  TYPE_BEF
} filterType_t;
 
/*------------------------------------------------------------------*/
/* IIR Class                                                        */
/*------------------------------------------------------------------*/
class IIRClass
{
public:
 
  /*------------------------------------------------------------------*/
  /* Configurations                                                   */
  /*------------------------------------------------------------------*/
 
  static const int BITLEN = 16;
  //static const int  BITLEN 32
 
  static const int DEFAULT_FRAMESIZE = 768;
 
  static const int MIN_FRAMESIZE = 240;
 
  static const int MAX_CHANNEL_NUM = 8;
 
  static const int INPUT_BUFFER_SIZE = 4; /* Times */
 
  typedef enum e_format {
    Interleave,
    Planar
  } format_t;
 
  typedef enum e_error {
    ERR_OK = 0,
    ERR_CH_NUM = -1,
    ERR_FORMAT = -2,
    ERR_MEMORY = -3,
    ERR_FILTER_TYPE = -4,
    ERR_FRAME_SIZE = -5,
    ERR_BUF_FULL = -6,
    ERR_FS = -7
  } error_t;
 
  IIRClass() {
    for (int i = 0; i < MAX_CHANNEL_NUM; i++) {
      m_ringbuff[i] = NULL;
    }
    m_tmpInBuff = NULL;
    m_tmpOutBuff = NULL;
    m_InterleaveBuff = NULL;
  }
 
  bool begin(
    filterType_t type,  
    int channel,        
    int cutoff,         
    float q,            
    int sample = DEFAULT_FRAMESIZE,   
    format_t output = Planar,        
    int fs = 48000      
  );
 
  bool put(
    q15_t* pSrc, 
    int size     
  );
 
  int  get(
    q15_t* pDst, 
    int channel  
  );
 
  int  get(
    q15_t* pDsts 
  );
 
  void end();
 
  bool empty(
    int channel 
  );
 
  error_t getErrorCause(){ return m_err; }
 
 
private:
 
  int      m_channel;
  int      m_framesize;
  format_t m_output;
  error_t  m_err;
  int      m_fs;
 
  arm_biquad_cascade_df2T_instance_f32 S[MAX_CHANNEL_NUM];
 
  float32_t m_coef[5];
  float32_t m_buffer[MAX_CHANNEL_NUM][4];
 
  RingBuff* m_ringbuff[MAX_CHANNEL_NUM];
 
  /* Temporary buffer */
  float* m_tmpInBuff;
  float* m_tmpOutBuff;
 
  q15_t* m_InterleaveBuff;
 
  bool create_coef(filterType_t, int cutoff, float q);
 
};
 
#endif /*_IIR_H_*/