---

mj_filter_iir2.h

/* COPYRIGHT
 *
 * This file is part of Mustajuuri LGPL modules.
 *
 * Author: Tommi Ilmonen, 1999-2001.
 * Tommi.Ilmonen@hut.fi
 *
 * http://www.tml.hut.fi/~tilmonen/mustajuuri/
 *
 *
 * This file is licensed under the Lesser GNU Public License
 * (LGPL). Extra clauses can be found from the file MUSTAJUURI_LGPL and
 * further explanations from the file MUSTAJUURI_LICENSE. The license
 * text can be found in file "LGPL.txt".
 *
 * If you want a parallel license (for commercial reasons for example),
 * you should negotiate the matter with the author(s).
 *    
 */

#ifndef MJ_FILTER_IIR2_H
#define MJ_FILTER_IIR2_H

#include <mj_math.h>
#include <complex.h>

template <class TElem> class MJ_FilterIIR2
{
public:
  MJ_FilterIIR2() {}

  ~MJ_FilterIIR2() {}


  inline void putSample(TElem s)
  {
    m_m2 = m_m1;
    m_m1 = m_m0;
    m_m0 = s - m_a1 * m_m1 - m_a2 * m_m2;
  }

  inline void put(TElem s) { putSample(s); }

  inline TElem getSample() const
  {
    return m_b0 * m_m0 + m_b1 * m_m1 +  m_b2 * m_m2;
  }

  inline TElem get() const { return getSample() ; }

  inline TElem putGetSample(TElem s)
  {
    m_m2 = m_m1;
    m_m1 = m_m0;
    m_m0 = s - m_a1 * m_m1 - m_a2 * m_m2;
    return m_b0 * m_m0 + m_b1 * m_m1 +  m_b2 * m_m2;
  }

  inline TElem putGetSampleOther(MJ_FilterIIR2 *f, TElem s)
  {
    f->m_m2 = f->m_m1;
    f->m_m1 = f->m_m0;
    f->m_m0 = s - m_a1 * f->m_m1 - m_a2 * f->m_m2;
    return m_b0 * f->m_m0 + m_b1 * f->m_m1 +  m_b2 * f->m_m2;
  }

  void putSamples(const TElem *input, unsigned count);

  void putSamples(TElem * output, 
                  const TElem * input, 
                  unsigned count);

  void putGetSamplesInplace(TElem *inputOutput, unsigned count);

  inline void resetMemory()
  { m_m0 = 0.0; m_m1 = 0.0; m_m2 = 0.0; }



  inline void flatResponse()
  {
    m_b0 = 1.0;
    m_b1 = 0.0;
    m_b2 = 0.0;
    m_a1 = 0.0;
    m_a2 = 0.0;    
  }

  inline void designHighShelve1(TElem centerRad, 
                                TElem gainDb, 
                                TElem slope = 1.0)
  { 
    iir2HighShelveEq
      (centerRad, gainDb, slope, bptr(), aptr());
  }

  inline void designHighShelve2(TElem frequencyHz, 
                                TElem sampleRate,
                                TElem gainDb, 
                                TElem slope = 1.0)
  { 
    designHighShelve1(MJ_2pi * frequencyHz / sampleRate, gainDb, slope);
  }

  inline void designLowShelve1(TElem centerRad, 
                               TElem gainDb, 
                               TElem slope = 1.0)
  { 
    iir2LowShelveEq
      (centerRad, gainDb, slope, bptr(), aptr());
  }

  inline void designLowShelve2(TElem frequencyHz, 
                               TElem sampleRate,
                               TElem gainDb, 
                               TElem slope = 1.0)
  { 
    designLowShelve1(MJ_2pi *frequencyHz / sampleRate, gainDb, slope);
  }

  void designParametric1(TElem boostAbs, 
                         TElem centerRad,
                         TElem bandWidthRad);

  void designParametric2(TElem boostDb, 
                         TElem centerHz,
                         TElem bandWidthOctaves,
                         TElem samplingRate);

  void designParametricB1(TElem K,
                          TElem F,
                          TElem omega, 
                          TElem bw)
  { iir2ParametricEqB(K, F, omega, bw, bptr(), aptr()); }

  void designParametricB2(
                          TElem hz, 
                          TElem sr,
                          TElem gainDb,
                          TElem bw)
  { 
    if(MJ_abs(gainDb) < 0.005 || hz == 0.0 || bw == 0.0) flatResponse();
    else designParametricB1(MJ_pow(10.0, gainDb * 0.05), 
                            MJ_pow(10.0, gainDb * 0.025), 
                            hz / sr * MJ_2pi, bw); 
  }
  
  void designParametricC1(
                          TElem K,
                          TElem F,
                          TElem omega, 
                          TElem bw)
  { iir2ParametricEqC(K, F, omega, bw, bptr(), aptr()); }

  void designParametricC2(
                          TElem hz, 
                          TElem sr,
                          TElem gainDb,
                          TElem bw)
  { 
    if(MJ_abs(gainDb) < 0.005) flatResponse();
    else designParametricC1(MJ_pow(10.0, gainDb * 0.05), 
                            MJ_pow(10.0, gainDb * 0.025), 
                            hz / sr * MJ_2pi, bw); 
  }

  void designLowPass1(TElem omega,
                      TElem Q)
  {
    iir2LowPassEq(omega, Q, &m_b0, &m_a1);
  }

  void designLowPass2(
                      TElem hz, 
                      TElem sr,
                      TElem Q)
  {
    designLowPass1(hz / sr * MJ_2pi, Q);
  }

  void designHighPass1(TElem omega,
                      TElem Q)
  {
    iir2HighPassEq(omega, Q, &m_b0, &m_a1);
  }

  void designHighPass2(
                      TElem hz, 
                      TElem sr,
                      TElem Q)
  {
    designHighPass1(hz / sr * MJ_2pi, Q);
  }

  void designBandPass1(
                       TElem omega, 
                       TElem Q)
    { iir2BandPassEq(omega, Q, bptr(), aptr()); }

  void designBandPass2(
                       TElem hz, 
                       TElem sr,
                       TElem Q)
    { designBandPass1(hz / sr * MJ_2pi, Q); }

  void designBandPassB1(
                       TElem omega, 
                       TElem bw)
    { iir2BandPassEqB(omega, bw, bptr(), aptr()); }

  void designBandPassB2(
                        TElem hz, 
                        TElem sr,
                        TElem bw)
    { designBandPassB1(hz / sr * MJ_2pi, bw); }

  inline void copyCoefficients(const MJ_FilterIIR2 &iir)
  {
    m_b0 = iir.m_b0;
    m_b1 = iir.m_b1;
    m_b2 = iir.m_b2;

    m_a1 = iir.m_a1;
    m_a2 = iir.m_a2;
  }

  void mulGain(TElem scale)
  { m_b0 *= scale; m_b1 *= scale; m_b2 *= scale; }



  inline TElem b0() const { return m_b0; }
  inline TElem b1() const { return m_b1; }
  inline TElem b2() const { return m_b2; }

  inline TElem *bptr() { return & m_b0; }

  inline TElem a1() const { return m_a1; }
  inline TElem a2() const { return m_a2; }

  inline TElem *aptr() { return & m_a1; }

  void writeTo(char *);


  static void iir2ParametricEq
    (TElem gr, TElem ga, TElem gb, TElem w0, TElem dw,
     TElem *b, TElem *a);
  
  static void iir2ParametricEqB
    (TElem K, TElem F, TElem omega, TElem bw, 
     TElem *b, TElem *a);
  
  static void iir2ParametricEqC
    (TElem K, TElem F, TElem omega, TElem bw, 
     TElem *b, TElem *a);
  
  static void iir2HighShelveEq
    (TElem rate, TElem gainDb, TElem slope,
     TElem *b, TElem *a);

  static void iir2LowShelveEq
    (TElem rate, TElem gainDb, TElem slope,
     TElem *b, TElem *a);

  static void iir2LowPassEq (TElem omega, TElem Q,
                             TElem *b, TElem *a);
  
  static void iir2HighPassEq (TElem omega, TElem Q,
                              TElem *b, TElem *a);

  static void iir2BandPassEq(TElem omega, TElem Q,
                             TElem *b, TElem *a);

  static void iir2BandPassEqB(TElem omega, TElem bw,
                              TElem *b, TElem *a);


  complex<float> response(complex<float> omega){
    return
      (m_b0 + m_b1 * omega + m_b2 * omega * omega)
      / (1 + m_a1 * omega + m_a2 * omega * omega);
  }

protected:
  TElem m_b0, m_b1, m_b2;
  TElem m_a1, m_a2;
  TElem m_m0, m_m1, m_m2;
};

#endif

---