/[svn]/linuxsampler/trunk/src/engines/common/BiquadFilter.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/common/BiquadFilter.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 563 - (show annotations) (download) (as text)
Sun May 22 20:43:32 2005 UTC (18 years, 10 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 24269 byte(s)
* (re)implemented voice stealing algorithm "oldestvoiceonkey" and made it
  the default voice stealing algorithm
* added new LSCP command "GET SERVER INFO" which currently returns
  description and version about this sampler
* added some API documentation comments
* minor cleanup

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the Free Software *
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20 * MA 02111-1307 USA *
21 ***************************************************************************/
22
23 #ifndef __LS_BIQUADFILTER_H__
24 #define __LS_BIQUADFILTER_H__
25
26 #include <math.h>
27
28 #include "../../common/global.h"
29
30 /// ln(2) / 2
31 #define LN_2_2 0.34657359f
32
33 #ifndef LIMIT
34 # define LIMIT(v,l,u) (v < l ? l : (v > u ? u : v))
35 #endif
36
37 namespace LinuxSampler {
38
39 typedef float bq_t;
40
41 /**
42 * Internal parameters of the biquad filter, which are actually the
43 * final parameters of the filter's transfer function. This strucure is
44 * only needed when these parameters should stored outside the
45 * BiquadFilter class, e.g. to save calculation time by sharing them
46 * between multiple filters.
47 */
48 struct biquad_param_t {
49 bq_t b0;
50 bq_t b1;
51 bq_t b2;
52 bq_t a1;
53 bq_t a2;
54 };
55
56 /**
57 * Bi-quadratic filter
58 * (adapted from lisp code by Eli Brandt, http://www.cs.cmu.edu/~eli/)
59 */
60 class BiquadFilter {
61 protected:
62 // following five variables are only used if no external biquad_param_t reference is used
63 bq_t b0;
64 bq_t b1;
65 bq_t b2;
66 bq_t a1;
67 bq_t a2;
68 // following four variables are used to buffer the feedback
69 bq_t x1;
70 bq_t x2;
71 bq_t y1;
72 bq_t y2;
73
74 const static float fbc = 0.98;
75
76 /**
77 * Prevent \a f from going into denormal mode which would slow down
78 * subsequent floating point calculations, we achieve that by setting
79 * \a f to zero when it falls under the denormal threshold value.
80 */
81 inline void KillDenormal(bq_t& f) {
82 // TODO: this is a generic solution for 32bit floats, should be replaced by CPU specific asm code
83 f += 1e-18f;
84 f -= 1e-18f;
85 }
86 public:
87 BiquadFilter() {
88 Reset();
89 }
90
91 void Reset() {
92 x1 = 0.0f;
93 x2 = 0.0f;
94 y1 = 0.0f;
95 y2 = 0.0f;
96 }
97
98 inline bq_t Apply(const bq_t x) {
99 bq_t y;
100
101 y = this->b0 * x + this->b1 * this->x1 + this->b2 * this->x2 +
102 this->a1 * this->y1 + this->a2 * this->y2;
103 KillDenormal(y);
104 this->x2 = this->x1;
105 this->x1 = x;
106 this->y2 = this->y1;
107 this->y1 = y;
108
109 return y;
110 }
111
112 inline bq_t Apply(biquad_param_t* param, const bq_t x) {
113 bq_t y;
114
115 y = param->b0 * x + param->b1 * this->x1 + param->b2 * this->x2 +
116 param->a1 * this->y1 + param->a2 * this->y2;
117 KillDenormal(y);
118 this->x2 = this->x1;
119 this->x1 = x;
120 this->y2 = this->y1;
121 this->y1 = y;
122
123 return y;
124 }
125
126 #if ARCH_X86
127 // expects to find input in xmm0 (xmm0 stays unmodified) and finally leaves output in xmm6
128 inline void Apply4StepsSSE(biquad_param_t* param) {
129 __asm__ __volatile__ (
130 "movss (%2),%%xmm4 # b0\n\t"
131 "shufps $0x00,%%xmm4,%%xmm4 # copy b0 to other cells\n\t"
132 "mulps %%xmm0,%%xmm4 # xmm4 = x*b0\n\t"
133 "movups (%0),%%xmm2 # load b1,b2,a1,a2\n\t"
134 "movups (%1),%%xmm5 # load x1,x2,y1,y2\n\t"
135 /* sample 0 */
136 "movaps %%xmm5,%%xmm3\n\t"
137 "mulps %%xmm2,%%xmm5 # xmm5 = [b1,b2,a1,a2] * [x1,x2,y1,y2]\n\t"
138 "shufps $0x0a,%%xmm3,%%xmm3 # x2 = x1, y2 = y1\n\t"
139 "movss %%xmm4,%%xmm6\n\t"
140 "addss %%xmm5,%%xmm6\n\t"
141 "shufps $0x39,%%xmm5,%%xmm5\n\t"
142 "addss %%xmm5,%%xmm6\n\t"
143 "shufps $0x39,%%xmm5,%%xmm5\n\t"
144 "addss %%xmm5,%%xmm6\n\t"
145 "shufps $0x39,%%xmm5,%%xmm5\n\t"
146 "addss %%xmm5,%%xmm6 # xmm6 = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2\n\t"
147 /* sample 1 */
148 "shufps $0x39,%%xmm4,%%xmm4 # rotate xmm4 down 1 cell\n\t"
149 "movss %%xmm6,%%xmm3 # y1 = y\n\t"
150 "shufps $0x4e,%%xmm3,%%xmm3 # rotate 2 cells\n\t"
151 "movss %%xmm0,%%xmm3 # x1 = x\n\t"
152 "shufps $0x93,%%xmm6,%%xmm6 # rotate output up 1 cell\n\t"
153 "movaps %%xmm3,%%xmm5\n\t"
154 "shufps $0x39,%%xmm0,%%xmm0 # rotate input down 1 cell\n\t"
155 "mulps %%xmm2,%%xmm5 # xmm5 = [b1,b2,a1,a2] * [x1,x2,y1,y2]\n\t"
156 "movss %%xmm5,%%xmm6\n\t"
157 "addss %%xmm4,%%xmm6\n\t"
158 "shufps $0x39,%%xmm5,%%xmm5\n\t"
159 "addss %%xmm5,%%xmm6\n\t"
160 "shufps $0x39,%%xmm5,%%xmm5\n\t"
161 "addss %%xmm5,%%xmm6\n\t"
162 "shufps $0x39,%%xmm5,%%xmm5\n\t"
163 "addss %%xmm5,%%xmm6 # xmm6 = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2\n\t"
164 /* sample 2 */
165 "shufps $0x0a,%%xmm3,%%xmm3 # x2 = x1, y2 = y1\n\t"
166 "shufps $0x39,%%xmm4,%%xmm4 # rotate xmm4 down 1 cell\n\t"
167 "movss %%xmm6,%%xmm3 # y1 = y\n\t"
168 "shufps $0x4e,%%xmm3,%%xmm3 # rotate 2 cells\n\t"
169 "movss %%xmm0,%%xmm3 # x1 = x\n\t"
170 "shufps $0x93,%%xmm6,%%xmm6 # rotate output up 1 cell\n\t"
171 "movaps %%xmm3,%%xmm5\n\t"
172 "shufps $0x39,%%xmm0,%%xmm0 # rotate input down 1 cell\n\t"
173 "mulps %%xmm2,%%xmm5 # xmm5 = [b1,b2,a1,a2] * [x1,x2,y1,y2]\n\t"
174 "movss %%xmm5,%%xmm6\n\t"
175 "addss %%xmm4,%%xmm6\n\t"
176 "shufps $0x39,%%xmm5,%%xmm5\n\t"
177 "addss %%xmm5,%%xmm6\n\t"
178 "shufps $0x39,%%xmm5,%%xmm5\n\t"
179 "addss %%xmm5,%%xmm6\n\t"
180 "shufps $0x39,%%xmm5,%%xmm5\n\t"
181 "addss %%xmm5,%%xmm6 # xmm6 = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2\n\t"
182 /* sample 3 */
183 "shufps $0x0a,%%xmm3,%%xmm3 # x2 = x1, y2 = y1\n\t"
184 "shufps $0x39,%%xmm4,%%xmm4 # rotate xmm4 down 1 cell\n\t"
185 "movss %%xmm6,%%xmm3 # y1 = y\n\t"
186 "shufps $0x4e,%%xmm3,%%xmm3 # rotate 2 cells\n\t"
187 "movss %%xmm0,%%xmm3 # x1 = x\n\t"
188 "shufps $0x93,%%xmm6,%%xmm6 # rotate output up 1 cell\n\t"
189 "mulps %%xmm3,%%xmm2 # xmm5 = [b1,b2,a1,a2] * [x1,x2,y1,y2]\n\t"
190 "shufps $0x39,%%xmm0,%%xmm0 # rotate input down 1 cell\n\t"
191 "movss %%xmm2,%%xmm6\n\t"
192 "shufps $0x39,%%xmm2,%%xmm2\n\t"
193 "addss %%xmm2,%%xmm6\n\t"
194 "shufps $0x39,%%xmm2,%%xmm2\n\t"
195 "addss %%xmm2,%%xmm6\n\t"
196 "shufps $0x39,%%xmm2,%%xmm2\n\t"
197 "addss %%xmm2,%%xmm6\n\t"
198 "addss %%xmm4,%%xmm6 # xmm6 = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2\n\t"
199 /* done */
200 "shufps $0x0a,%%xmm3,%%xmm3 # x2 = x1, y2 = y1\n\t"
201 "movss %%xmm6,%%xmm3 # y1 = y\n\t"
202 "shufps $0x4e,%%xmm3,%%xmm3 # rotate 2 cells\n\t"
203 "movss %%xmm0,%%xmm3 # x1 = x\n\t"
204 "shufps $0x1b,%%xmm6,%%xmm6 # swap output to correct order\n\t"
205 "shufps $0x39,%%xmm0,%%xmm0 # rotate input down 1 cell, to restore original input\n\t"
206 "movups %%xmm3,(%1) # store x1,x2,y1,y2\n\t"
207 : /* no output */
208 : "r" (&param->b1), /* %0 - [b1,b2,a1,a2] */
209 "r" (&x1), /* %1 - [x1,x2,y1,y2] */
210 "r" (&param->b0) /* %2 */
211 );
212 }
213 #endif // ARCH_X86
214
215 inline bq_t ApplyFB(bq_t x, const bq_t fb) {
216 bq_t y;
217
218 x += this->y1 * fb * 0.98;
219 y = this->b0 * x + this->b1 * this->x1 + this->b2 * this->x2 +
220 this->a1 * this->y1 + this->a2 * this->y2;
221 KillDenormal(y);
222 this->x2 = this->x1;
223 this->x1 = x;
224 this->y2 = this->y1;
225 this->y1 = y;
226
227 return y;
228 }
229
230 inline bq_t ApplyFB(biquad_param_t* param, bq_t x, const bq_t fb) {
231 bq_t y;
232
233 x += this->y1 * fb * 0.98;
234 y = param->b0 * x + param->b1 * this->x1 + param->b2 * this->x2 +
235 param->a1 * this->y1 + param->a2 * this->y2;
236 KillDenormal(y);
237 this->x2 = this->x1;
238 this->x1 = x;
239 this->y2 = this->y1;
240 this->y1 = y;
241
242 return y;
243 }
244
245 #if ARCH_X86
246 // expects to find input in xmm0 (xmm0 stays unmodified) and finally leaves output in xmm7
247 inline void ApplyFB4StepsSSE(biquad_param_t* param, const bq_t &fb) {
248 float xs, ys;
249 float t0, t1, t2, t3, t4, t5, t6, t7, t8; // temporary stack space
250 __asm__ __volatile__ (
251 /* prepare input */
252 "movss %15,%%xmm5\n\t"
253 "movss %%xmm0,(%14)\n\t"
254 /* sample 0 */
255 "movss %0, %%xmm3\n\t"
256 "movss %1, %%xmm4\n\t"
257 "mulss %%xmm4, %%xmm5\n\t"
258 "movss %%xmm3, %2\n\t"
259 "movss %%xmm5, %16\n\t"
260 "mulss %%xmm3, %%xmm5\n\t"
261 "movss %19, %%xmm2\n\t"
262 "movss %3, %%xmm6\n\t"
263 "movss %21, %%xmm3\n\t"
264 "addss %%xmm5, %%xmm6\n\t"
265 "movss %%xmm2, %%xmm5\n\t"
266 "movss %20, %%xmm4\n\t"
267 "movss %%xmm6, %4\n\t"
268 "mulss %%xmm6, %%xmm5\n\t"
269 "movss %5, %%xmm6\n\t"
270 "movss %%xmm2, %6\n\t"
271 "movss %%xmm4, %7\n\t"
272 "movss %%xmm3, %%xmm2\n\t"
273 "mulss %%xmm6, %%xmm4\n\t"
274 "mulss %8, %%xmm2\n\t"
275 "movss %%xmm3, %9\n\t"
276 "addss %%xmm4, %%xmm5\n\t"
277 "movss %18, %%xmm3\n\t"
278 "movss %17, %%xmm4\n\t"
279 "addss %%xmm2, %%xmm5\n\t"
280 "movss %%xmm4, %10\n\t"
281 "movss %%xmm3, %%xmm2\n\t"
282 "mulss %11, %%xmm4\n\t"
283 "mulss %12, %%xmm2\n\t"
284 "movss %%xmm3, %13\n\t"
285 "addss %%xmm4, %%xmm5\n\t"
286 "movss %11, %%xmm3\n\t"
287 "movss %4, %%xmm4\n\t"
288 "addss %%xmm2, %%xmm5\n\t"
289 :: "m" (y1), /* %0 */
290 "m" (fbc), /* %1 */
291 "m" (t0), /* %2 */
292 "m" (xs), /* %3 */
293 "m" (t7), /* %4 */
294 "m" (x1), /* %5 */
295 "m" (t1), /* %6 */
296 "m" (t2), /* %7 */
297 "m" (x2), /* %8 */
298 "m" (t3), /* %9 */
299 "m" (t4), /* %10 */
300 "m" (t0), /* %11 */
301 "m" (y2), /* %12 */
302 "m" (t5), /* %13 */
303 "r" (&xs), /* %14 */
304 "m" (fb), /* %15 */
305 "m" (ys), /* %16 */
306 "m" (param->a1), /* %17 */
307 "m" (param->a2), /* %18 */
308 "m" (param->b0), /* %19 */
309 "m" (param->b1), /* %20 */
310 "m" (param->b2) /* %21 */
311 );
312 __asm__ __volatile__ (
313 "shufps $0x39,%%xmm0,%%xmm0 # rotate down one cell\n\t"
314 "movss %%xmm5,%%xmm7\n\t"
315 ::
316 );
317 /* sample 1 */
318 __asm__ __volatile__ (
319 "movss %0, %%xmm4\n\t"
320 "movss %%xmm0, %%xmm3\n\t"
321 "mulss %%xmm5, %%xmm4\n\t"
322 "mulss %3, %%xmm6\n\t"
323 "movss %5, %%xmm2\n\t"
324 "addss %%xmm4, %%xmm3\n\t"
325 "mulss %7, %%xmm2\n\t"
326 "movss %6, %%xmm4\n\t"
327 "movss %%xmm3, %8\n\t"
328 "mulss %%xmm3, %%xmm4\n\t"
329 "addss %%xmm2, %%xmm4\n\t"
330 "movss %9, %%xmm3\n\t"
331 "mulss %%xmm5, %%xmm3\n\t"
332 "movss %10, %%xmm2\n\t"
333 "addss %%xmm6, %%xmm4\n\t"
334 "mulss %11, %%xmm2\n\t"
335 "addss %%xmm3, %%xmm4\n\t"
336 "addss %%xmm2, %%xmm4\n\t"
337 :: "m" (ys), /* %0 */
338 "m" (fbc), /* %1 */
339 "m" (xs), /* %2 */
340 "m" (t3), /* %3 */
341 "m" (y2), /* %4 */
342 "m" (t2), /* %5 */
343 "m" (t1), /* %6 */
344 "m" (t7), /* %7 */
345 "m" (t8), /* %8 */
346 "m" (t4), /* %9 */
347 "m" (t5), /* %10 */
348 "m" (t0), /* %11 */
349 "m" (x2), /* %12 */
350 "m" (x1), /* %13 */
351 "m" (y1) /* %14 */
352 );
353 __asm__ __volatile__ (
354 "shufps $0x93,%%xmm7,%%xmm7 # rotate up one cell\n\t"
355 "shufps $0x39,%%xmm0,%%xmm0 # rotate down one cell\n\t"
356 "movss %%xmm4,%%xmm7\n\t"
357 ::
358 );
359 /* sample 2 */
360 __asm__ __volatile__ (
361 "movss %2, %%xmm6\n\t"
362 "movss %3, %%xmm3\n\t"
363 "mulss %%xmm4, %%xmm6\n\t"
364 "movss %4, %%xmm2\n\t"
365 "mulss %9, %%xmm2\n\t"
366 "addss %%xmm0, %%xmm6\n\t"
367 "mulss %7, %%xmm5\n\t"
368 "mulss %%xmm6, %%xmm3\n\t"
369 "addss %%xmm2, %%xmm3\n\t"
370 "movss %5, %%xmm2\n\t"
371 "mulss %8, %%xmm2\n\t"
372 "addss %%xmm2, %%xmm3\n\t"
373 "movss %6, %%xmm2\n\t"
374 "mulss %%xmm4, %%xmm2\n\t"
375 "addss %%xmm5, %%xmm2\n\t"
376 "addss %%xmm2, %%xmm3\n\t"
377 :: "m" (xs), /* %0 */
378 "m" (fb), /* %1 */
379 "m" (ys), /* %2 */
380 "m" (t1), /* %3 */
381 "m" (t2), /* %4 */
382 "m" (t3), /* %5 */
383 "m" (t4), /* %6 */
384 "m" (t5), /* %7 */
385 "m" (t7), /* %8 */
386 "m" (t8), /* %9 */
387 "m" (x1), /* %10 */
388 "m" (x2), /* %11 */
389 "m" (y1), /* %12 */
390 "m" (y2) /* %13 */
391 );
392 __asm__ __volatile__ (
393 "shufps $0x39,%%xmm0,%%xmm0 # rotate down one cell\n\t"
394 "shufps $0x93,%%xmm7,%%xmm7 # rotate up one cell\n\t"
395 "movss %%xmm3,%%xmm7\n\t"
396 ::
397 );
398 /* sample 3 */
399 __asm__ __volatile__ (
400 "movss %1, %%xmm2\n\t"
401 "mulss %7, %%xmm4\n\t"
402 "mulss %%xmm3, %%xmm2\n\t"
403 "movss %3, %%xmm5\n\t"
404 "movss %%xmm6, %11\n\t"
405 "addss %%xmm0, %%xmm2\n\t"
406 "movss %%xmm3, %13\n\t"
407 "mulss %%xmm2, %%xmm5\n\t"
408 "mulss %4, %%xmm6\n\t"
409 "movss %%xmm2, %10\n\t"
410 "addss %%xmm6, %%xmm5\n\t"
411 "movss %5, %%xmm2\n\t"
412 "mulss %9, %%xmm2\n\t"
413 "mulss %6, %%xmm3\n\t"
414 "addss %%xmm2, %%xmm5\n\t"
415 "addss %%xmm3, %%xmm4\n\t"
416 "addss %%xmm4, %%xmm5\n\t"
417 "movss %%xmm5, %12\n\t"
418 :: "m" (xs), /* %0 */
419 "m" (ys), /* %1 */
420 "m" (fbc), /* %2 */
421 "m" (t1), /* %3 */
422 "m" (t2), /* %4 */
423 "m" (t3), /* %5 */
424 "m" (t4), /* %6 */
425 "m" (t5), /* %7 */
426 "m" (t6), /* %8 */
427 "m" (t8), /* %9 */
428 "m" (x1), /* %10 */
429 "m" (x2), /* %11 */
430 "m" (y1), /* %12 */
431 "m" (y2) /* %13 */
432 );
433 __asm__ __volatile__ (
434 "shufps $0x93,%%xmm7,%%xmm7 # rotate up one cell\n\t"
435 "shufps $0x39,%%xmm0,%%xmm0 # rotate down one cell to restore original input\n\t"
436 "movss %%xmm5,%%xmm7\n\t"
437 "shufps $0x1b,%%xmm7,%%xmm7 # swap output to correct order\n\t"
438 ::
439 );
440 }
441 #endif // ARCH_X86
442 };
443
444 /** @brief Lowpass Filter
445 *
446 * Lowpass filter based on biquad filter implementation.
447 */
448 class LowpassFilter : public BiquadFilter {
449 public:
450 inline LowpassFilter() : BiquadFilter() {}
451
452 inline void SetParameters(bq_t fc, bq_t bw, bq_t fs) {
453 bq_t omega = 2.0 * M_PI * fc / fs;
454 bq_t sn = sin(omega);
455 bq_t cs = cos(omega);
456 bq_t alpha = sn * sinh(M_LN2 / 2.0 * bw * omega / sn);
457
458 const float a0r = 1.0 / (1.0 + alpha);
459 this->b0 = a0r * (1.0 - cs) * 0.5;
460 this->b1 = a0r * (1.0 - cs);
461 this->b2 = a0r * (1.0 - cs) * 0.5;
462 this->a1 = a0r * (2.0 * cs);
463 this->a2 = a0r * (alpha - 1.0);
464 }
465
466 inline void SetParameters(biquad_param_t* param, bq_t fc, bq_t bw, bq_t fs) {
467 bq_t omega = 2.0 * M_PI * fc / fs;
468 bq_t sn = sin(omega);
469 bq_t cs = cos(omega);
470 bq_t alpha = sn * sinh(M_LN2 / 2.0 * bw * omega / sn);
471
472 const float a0r = 1.0 / (1.0 + alpha);
473 param->b0 = a0r * (1.0 - cs) * 0.5;
474 param->b1 = a0r * (1.0 - cs);
475 param->b2 = a0r * (1.0 - cs) * 0.5;
476 param->a1 = a0r * (2.0 * cs);
477 param->a2 = a0r * (alpha - 1.0);
478 }
479 };
480
481 /** @brief Bandpass Filter
482 *
483 * Bandpass filter based on biquad filter implementation.
484 */
485 class BandpassFilter : public BiquadFilter {
486 public:
487 inline BandpassFilter() : BiquadFilter() {}
488
489 inline void SetParameters(bq_t fc, bq_t bw, bq_t fs) {
490 bq_t omega = 2.0 * M_PI * fc / fs;
491 bq_t sn = sin(omega);
492 bq_t cs = cos(omega);
493 bq_t alpha = sn * sinh(M_LN2 / 2.0 * bw * omega / sn);
494
495 const float a0r = 1.0 / (1.0 + alpha);
496 this->b0 = a0r * alpha;
497 this->b1 = 0.0;
498 this->b2 = a0r * -alpha;
499 this->a1 = a0r * (2.0 * cs);
500 this->a2 = a0r * (alpha - 1.0);
501 }
502
503 inline void SetParameters(biquad_param_t* param, bq_t fc, bq_t bw, bq_t fs) {
504 bq_t omega = 2.0 * M_PI * fc / fs;
505 bq_t sn = sin(omega);
506 bq_t cs = cos(omega);
507 bq_t alpha = sn * sinh(M_LN2 / 2.0 * bw * omega / sn);
508
509 const float a0r = 1.0 / (1.0 + alpha);
510 param->b0 = a0r * alpha;
511 param->b1 = 0.0;
512 param->b2 = a0r * -alpha;
513 param->a1 = a0r * (2.0 * cs);
514 param->a2 = a0r * (alpha - 1.0);
515 }
516 };
517
518 /** @brief Highpass Filter
519 *
520 * Highpass filter based on biquad filter implementation.
521 */
522 class HighpassFilter : public BiquadFilter {
523 public:
524 inline HighpassFilter() : BiquadFilter() {}
525
526 inline void SetParameters(bq_t fc, bq_t bw, bq_t fs) {
527 bq_t omega = 2.0 * M_PI * fc / fs;
528 bq_t sn = sin(omega);
529 bq_t cs = cos(omega);
530 bq_t alpha = sn * sinh(M_LN2 / 2.0 * bw * omega / sn);
531
532 const float a0r = 1.0 / (1.0 + alpha);
533 this->b0 = a0r * (1.0 + cs) * 0.5;
534 this->b1 = a0r * -(1.0 + cs);
535 this->b2 = a0r * (1.0 + cs) * 0.5;
536 this->a1 = a0r * (2.0 * cs);
537 this->a2 = a0r * (alpha - 1.0);
538 }
539
540 inline void SetParameters(biquad_param_t* param, bq_t fc, bq_t bw, bq_t fs) {
541 bq_t omega = 2.0 * M_PI * fc / fs;
542 bq_t sn = sin(omega);
543 bq_t cs = cos(omega);
544 bq_t alpha = sn * sinh(M_LN2 / 2.0 * bw * omega / sn);
545
546 const float a0r = 1.0 / (1.0 + alpha);
547 param->b0 = a0r * (1.0 + cs) * 0.5;
548 param->b1 = a0r * -(1.0 + cs);
549 param->b2 = a0r * (1.0 + cs) * 0.5;
550 param->a1 = a0r * (2.0 * cs);
551 param->a2 = a0r * (alpha - 1.0);
552 }
553 };
554
555 } // namespace LinuxSampler
556
557 #endif // __LS_BIQUADFILTER_H__

  ViewVC Help
Powered by ViewVC