onepole-float.h

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2010 Krzysztof Foltman
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #ifndef CBOX_ONEPOLE_FLOAT_H
  20 #define CBOX_ONEPOLE_FLOAT_H
  21
  22 #include "dspmath.h"
  23
  24 struct cbox_onepolef_state
  25 {
  26     float x1;
  27     float y1;
  28 };
  29
  30 struct cbox_onepolef_coeffs
  31 {
  32     float a0;
  33     float a1;
  34     float b1;
  35 };
  36
  37 static inline void cbox_onepolef_reset(struct cbox_onepolef_state *state)
  38 {
  39     state->x1 = state->y1 = 0.f;
  40 }
  41
  42 static inline void cbox_onepolef_set_lowpass(struct cbox_onepolef_coeffs *coeffs, float w)
  43 {
  44     float x = tan (w * 0.5f);
  45     float q = 1 / (1 + x);
  46     float a01 = x*q;
  47     float b1 = a01 - q;
  48
  49     coeffs->a0 = a01;
  50     coeffs->a1 = a01;
  51     coeffs->b1 = b1;
  52 }
  53
  54 static inline void cbox_onepolef_set_highpass(struct cbox_onepolef_coeffs *coeffs, float w)
  55 {
  56     float x = tan (w * 0.5f);
  57     float q = 1 / (1 + x);
  58     float a01 = x*q;
  59     float b1 = a01 - q;
  60
  61     coeffs->a0 = q;
  62     coeffs->a1 = -q;
  63     coeffs->b1 = b1;
  64 }
  65
  66 static inline void cbox_onepolef_set_highshelf_tonectl(struct cbox_onepolef_coeffs *coeffs, float w, float g0)
  67 {
  68     float x = tan (w * 0.5f);
  69     float q = 1 / (1 + x);
  70     float b1 = x * q - q;
  71
  72     coeffs->a0 = 0.5 * (1 + b1 + g0 - b1 * g0);
  73     coeffs->a1 = 0.5 * (1 + b1 - g0 + b1 * g0);
  74     coeffs->b1 = b1;
  75 }
  76
  77 static inline void cbox_onepolef_set_highshelf_setgain(struct cbox_onepolef_coeffs *coeffs, float g0)
  78 {
  79     coeffs->a0 = 0.5 * (1 + coeffs->b1 + g0 - coeffs->b1 * g0);
  80     coeffs->a1 = 0.5 * (1 + coeffs->b1 - g0 + coeffs->b1 * g0);
  81 }
  82
  83 static inline void cbox_onepolef_set_allpass(struct cbox_onepolef_coeffs *coeffs, float w)
  84 {
  85     float x = tan (w * 0.5f);
  86     float q = 1 / (1 + x);
  87     float a01 = x*q;
  88     float b1 = a01 - q;
  89
  90     coeffs->a0 = b1;
  91     coeffs->a1 = 1;
  92     coeffs->b1 = b1;
  93 }
  94
  95 static inline float cbox_onepolef_process_sample(struct cbox_onepolef_state *state, struct cbox_onepolef_coeffs *coeffs, float in)
  96 {
  97     float out = sanef(coeffs->a0 * in + coeffs->a1 * state->x1 - coeffs->b1 * state->y1);
  98
  99     state->x1 = in;
 100     state->y1 = out;
 101     return out;
 102 }
 103
 104 static inline void cbox_onepolef_process(struct cbox_onepolef_state *state, struct cbox_onepolef_coeffs *coeffs, float *buffer)
 105 {
 106     int i;
 107     float a0 = coeffs->a0;
 108     float a1 = coeffs->a1;
 109     float b1 = coeffs->b1;
 110
 111     for (i = 0; i < CBOX_BLOCK_SIZE; i++)
 112     {
 113         float in = buffer[i];
 114         double out = a0 * in + a1 * state->x1 - b1 * state->y1;
 115
 116         buffer[i] = out;
 117         state->x1 = in;
 118         state->y1 = out;
 119     }
 120     state->y1 = sanef(state->y1);
 121 }
 122
 123 static inline void cbox_onepolef_process_to(struct cbox_onepolef_state *state, struct cbox_onepolef_coeffs *coeffs, float *buffer_in, float *buffer_out)
 124 {
 125     int i;
 126     float a0 = coeffs->a0;
 127     float a1 = coeffs->a1;
 128     float b1 = coeffs->b1;
 129
 130     for (i = 0; i < CBOX_BLOCK_SIZE; i++)
 131     {
 132         float in = buffer_in[i];
 133         double out = a0 * in + a1 * state->x1 - b1 * state->y1;
 134
 135         buffer_out[i] = out;
 136         state->x1 = in;
 137         state->y1 = out;
 138     }
 139     state->y1 = sanef(state->y1);
 140 }
 141
 142 #endif