/drivers/staging/echo/echo.c
C | 666 lines | 272 code | 95 blank | 299 comment | 43 complexity | 7b5faf5cf303616e9659ad8edb25d13c MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
1/*
2 * SpanDSP - a series of DSP components for telephony
3 *
4 * echo.c - A line echo canceller. This code is being developed
5 * against and partially complies with G168.
6 *
7 * Written by Steve Underwood <steveu@coppice.org>
8 * and David Rowe <david_at_rowetel_dot_com>
9 *
10 * Copyright (C) 2001, 2003 Steve Underwood, 2007 David Rowe
11 *
12 * Based on a bit from here, a bit from there, eye of toad, ear of
13 * bat, 15 years of failed attempts by David and a few fried brain
14 * cells.
15 *
16 * All rights reserved.
17 *
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License version 2, as
20 * published by the Free Software Foundation.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 */
31
32/*! \file */
33
34/* Implementation Notes
35 David Rowe
36 April 2007
37
38 This code started life as Steve's NLMS algorithm with a tap
39 rotation algorithm to handle divergence during double talk. I
40 added a Geigel Double Talk Detector (DTD) [2] and performed some
41 G168 tests. However I had trouble meeting the G168 requirements,
42 especially for double talk - there were always cases where my DTD
43 failed, for example where near end speech was under the 6dB
44 threshold required for declaring double talk.
45
46 So I tried a two path algorithm [1], which has so far given better
47 results. The original tap rotation/Geigel algorithm is available
48 in SVN http://svn.rowetel.com/software/oslec/tags/before_16bit.
49 It's probably possible to make it work if some one wants to put some
50 serious work into it.
51
52 At present no special treatment is provided for tones, which
53 generally cause NLMS algorithms to diverge. Initial runs of a
54 subset of the G168 tests for tones (e.g ./echo_test 6) show the
55 current algorithm is passing OK, which is kind of surprising. The
56 full set of tests needs to be performed to confirm this result.
57
58 One other interesting change is that I have managed to get the NLMS
59 code to work with 16 bit coefficients, rather than the original 32
60 bit coefficents. This reduces the MIPs and storage required.
61 I evaulated the 16 bit port using g168_tests.sh and listening tests
62 on 4 real-world samples.
63
64 I also attempted the implementation of a block based NLMS update
65 [2] but although this passes g168_tests.sh it didn't converge well
66 on the real-world samples. I have no idea why, perhaps a scaling
67 problem. The block based code is also available in SVN
68 http://svn.rowetel.com/software/oslec/tags/before_16bit. If this
69 code can be debugged, it will lead to further reduction in MIPS, as
70 the block update code maps nicely onto DSP instruction sets (it's a
71 dot product) compared to the current sample-by-sample update.
72
73 Steve also has some nice notes on echo cancellers in echo.h
74
75 References:
76
77 [1] Ochiai, Areseki, and Ogihara, "Echo Canceller with Two Echo
78 Path Models", IEEE Transactions on communications, COM-25,
79 No. 6, June
80 1977.
81 http://www.rowetel.com/images/echo/dual_path_paper.pdf
82
83 [2] The classic, very useful paper that tells you how to
84 actually build a real world echo canceller:
85 Messerschmitt, Hedberg, Cole, Haoui, Winship, "Digital Voice
86 Echo Canceller with a TMS320020,
87 http://www.rowetel.com/images/echo/spra129.pdf
88
89 [3] I have written a series of blog posts on this work, here is
90 Part 1: http://www.rowetel.com/blog/?p=18
91
92 [4] The source code http://svn.rowetel.com/software/oslec/
93
94 [5] A nice reference on LMS filters:
95 http://en.wikipedia.org/wiki/Least_mean_squares_filter
96
97 Credits:
98
99 Thanks to Steve Underwood, Jean-Marc Valin, and Ramakrishnan
100 Muthukrishnan for their suggestions and email discussions. Thanks
101 also to those people who collected echo samples for me such as
102 Mark, Pawel, and Pavel.
103*/
104
105#include <linux/kernel.h>
106#include <linux/module.h>
107#include <linux/slab.h>
108
109#include "echo.h"
110
111#define MIN_TX_POWER_FOR_ADAPTION 64
112#define MIN_RX_POWER_FOR_ADAPTION 64
113#define DTD_HANGOVER 600 /* 600 samples, or 75ms */
114#define DC_LOG2BETA 3 /* log2() of DC filter Beta */
115
116/* adapting coeffs using the traditional stochastic descent (N)LMS algorithm */
117
118#ifdef __bfin__
119static inline void lms_adapt_bg(struct oslec_state *ec, int clean, int shift)
120{
121 int i, j;
122 int offset1;
123 int offset2;
124 int factor;
125 int exp;
126 int16_t *phist;
127 int n;
128
129 if (shift > 0)
130 factor = clean << shift;
131 else
132 factor = clean >> -shift;
133
134 /* Update the FIR taps */
135
136 offset2 = ec->curr_pos;
137 offset1 = ec->taps - offset2;
138 phist = &ec->fir_state_bg.history[offset2];
139
140 /* st: and en: help us locate the assembler in echo.s */
141
142 /* asm("st:"); */
143 n = ec->taps;
144 for (i = 0, j = offset2; i < n; i++, j++) {
145 exp = *phist++ * factor;
146 ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
147 }
148 /* asm("en:"); */
149
150 /* Note the asm for the inner loop above generated by Blackfin gcc
151 4.1.1 is pretty good (note even parallel instructions used):
152
153 R0 = W [P0++] (X);
154 R0 *= R2;
155 R0 = R0 + R3 (NS) ||
156 R1 = W [P1] (X) ||
157 nop;
158 R0 >>>= 15;
159 R0 = R0 + R1;
160 W [P1++] = R0;
161
162 A block based update algorithm would be much faster but the
163 above can't be improved on much. Every instruction saved in
164 the loop above is 2 MIPs/ch! The for loop above is where the
165 Blackfin spends most of it's time - about 17 MIPs/ch measured
166 with speedtest.c with 256 taps (32ms). Write-back and
167 Write-through cache gave about the same performance.
168 */
169}
170
171/*
172 IDEAS for further optimisation of lms_adapt_bg():
173
174 1/ The rounding is quite costly. Could we keep as 32 bit coeffs
175 then make filter pluck the MS 16-bits of the coeffs when filtering?
176 However this would lower potential optimisation of filter, as I
177 think the dual-MAC architecture requires packed 16 bit coeffs.
178
179 2/ Block based update would be more efficient, as per comments above,
180 could use dual MAC architecture.
181
182 3/ Look for same sample Blackfin LMS code, see if we can get dual-MAC
183 packing.
184
185 4/ Execute the whole e/c in a block of say 20ms rather than sample
186 by sample. Processing a few samples every ms is inefficient.
187*/
188
189#else
190static inline void lms_adapt_bg(struct oslec_state *ec, int clean, int shift)
191{
192 int i;
193
194 int offset1;
195 int offset2;
196 int factor;
197 int exp;
198
199 if (shift > 0)
200 factor = clean << shift;
201 else
202 factor = clean >> -shift;
203
204 /* Update the FIR taps */
205
206 offset2 = ec->curr_pos;
207 offset1 = ec->taps - offset2;
208
209 for (i = ec->taps - 1; i >= offset1; i--) {
210 exp = (ec->fir_state_bg.history[i - offset1] * factor);
211 ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
212 }
213 for (; i >= 0; i--) {
214 exp = (ec->fir_state_bg.history[i + offset2] * factor);
215 ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
216 }
217}
218#endif
219
220static inline int top_bit(unsigned int bits)
221{
222 if (bits == 0)
223 return -1;
224 else
225 return (int)fls((int32_t) bits) - 1;
226}
227
228struct oslec_state *oslec_create(int len, int adaption_mode)
229{
230 struct oslec_state *ec;
231 int i;
232
233 ec = kzalloc(sizeof(*ec), GFP_KERNEL);
234 if (!ec)
235 return NULL;
236
237 ec->taps = len;
238 ec->log2taps = top_bit(len);
239 ec->curr_pos = ec->taps - 1;
240
241 for (i = 0; i < 2; i++) {
242 ec->fir_taps16[i] =
243 kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL);
244 if (!ec->fir_taps16[i])
245 goto error_oom;
246 }
247
248 fir16_create(&ec->fir_state, ec->fir_taps16[0], ec->taps);
249 fir16_create(&ec->fir_state_bg, ec->fir_taps16[1], ec->taps);
250
251 for (i = 0; i < 5; i++)
252 ec->xvtx[i] = ec->yvtx[i] = ec->xvrx[i] = ec->yvrx[i] = 0;
253
254 ec->cng_level = 1000;
255 oslec_adaption_mode(ec, adaption_mode);
256
257 ec->snapshot = kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL);
258 if (!ec->snapshot)
259 goto error_oom;
260
261 ec->cond_met = 0;
262 ec->Pstates = 0;
263 ec->Ltxacc = ec->Lrxacc = ec->Lcleanacc = ec->Lclean_bgacc = 0;
264 ec->Ltx = ec->Lrx = ec->Lclean = ec->Lclean_bg = 0;
265 ec->tx_1 = ec->tx_2 = ec->rx_1 = ec->rx_2 = 0;
266 ec->Lbgn = ec->Lbgn_acc = 0;
267 ec->Lbgn_upper = 200;
268 ec->Lbgn_upper_acc = ec->Lbgn_upper << 13;
269
270 return ec;
271
272error_oom:
273 for (i = 0; i < 2; i++)
274 kfree(ec->fir_taps16[i]);
275
276 kfree(ec);
277 return NULL;
278}
279
280EXPORT_SYMBOL_GPL(oslec_create);
281
282void oslec_free(struct oslec_state *ec)
283{
284 int i;
285
286 fir16_free(&ec->fir_state);
287 fir16_free(&ec->fir_state_bg);
288 for (i = 0; i < 2; i++)
289 kfree(ec->fir_taps16[i]);
290 kfree(ec->snapshot);
291 kfree(ec);
292}
293
294EXPORT_SYMBOL_GPL(oslec_free);
295
296void oslec_adaption_mode(struct oslec_state *ec, int adaption_mode)
297{
298 ec->adaption_mode = adaption_mode;
299}
300
301EXPORT_SYMBOL_GPL(oslec_adaption_mode);
302
303void oslec_flush(struct oslec_state *ec)
304{
305 int i;
306
307 ec->Ltxacc = ec->Lrxacc = ec->Lcleanacc = ec->Lclean_bgacc = 0;
308 ec->Ltx = ec->Lrx = ec->Lclean = ec->Lclean_bg = 0;
309 ec->tx_1 = ec->tx_2 = ec->rx_1 = ec->rx_2 = 0;
310
311 ec->Lbgn = ec->Lbgn_acc = 0;
312 ec->Lbgn_upper = 200;
313 ec->Lbgn_upper_acc = ec->Lbgn_upper << 13;
314
315 ec->nonupdate_dwell = 0;
316
317 fir16_flush(&ec->fir_state);
318 fir16_flush(&ec->fir_state_bg);
319 ec->fir_state.curr_pos = ec->taps - 1;
320 ec->fir_state_bg.curr_pos = ec->taps - 1;
321 for (i = 0; i < 2; i++)
322 memset(ec->fir_taps16[i], 0, ec->taps * sizeof(int16_t));
323
324 ec->curr_pos = ec->taps - 1;
325 ec->Pstates = 0;
326}
327
328EXPORT_SYMBOL_GPL(oslec_flush);
329
330void oslec_snapshot(struct oslec_state *ec)
331{
332 memcpy(ec->snapshot, ec->fir_taps16[0], ec->taps * sizeof(int16_t));
333}
334
335EXPORT_SYMBOL_GPL(oslec_snapshot);
336
337/* Dual Path Echo Canceller */
338
339int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx)
340{
341 int32_t echo_value;
342 int clean_bg;
343 int tmp, tmp1;
344
345 /*
346 * Input scaling was found be required to prevent problems when tx
347 * starts clipping. Another possible way to handle this would be the
348 * filter coefficent scaling.
349 */
350
351 ec->tx = tx;
352 ec->rx = rx;
353 tx >>= 1;
354 rx >>= 1;
355
356 /*
357 * Filter DC, 3dB point is 160Hz (I think), note 32 bit precision
358 * required otherwise values do not track down to 0. Zero at DC, Pole
359 * at (1-Beta) on real axis. Some chip sets (like Si labs) don't
360 * need this, but something like a $10 X100P card does. Any DC really
361 * slows down convergence.
362 *
363 * Note: removes some low frequency from the signal, this reduces the
364 * speech quality when listening to samples through headphones but may
365 * not be obvious through a telephone handset.
366 *
367 * Note that the 3dB frequency in radians is approx Beta, e.g. for Beta
368 * = 2^(-3) = 0.125, 3dB freq is 0.125 rads = 159Hz.
369 */
370
371 if (ec->adaption_mode & ECHO_CAN_USE_RX_HPF) {
372 tmp = rx << 15;
373
374 /*
375 * Make sure the gain of the HPF is 1.0. This can still
376 * saturate a little under impulse conditions, and it might
377 * roll to 32768 and need clipping on sustained peak level
378 * signals. However, the scale of such clipping is small, and
379 * the error due to any saturation should not markedly affect
380 * the downstream processing.
381 */
382 tmp -= (tmp >> 4);
383
384 ec->rx_1 += -(ec->rx_1 >> DC_LOG2BETA) + tmp - ec->rx_2;
385
386 /*
387 * hard limit filter to prevent clipping. Note that at this
388 * stage rx should be limited to +/- 16383 due to right shift
389 * above
390 */
391 tmp1 = ec->rx_1 >> 15;
392 if (tmp1 > 16383)
393 tmp1 = 16383;
394 if (tmp1 < -16383)
395 tmp1 = -16383;
396 rx = tmp1;
397 ec->rx_2 = tmp;
398 }
399
400 /* Block average of power in the filter states. Used for
401 adaption power calculation. */
402
403 {
404 int new, old;
405
406 /* efficient "out with the old and in with the new" algorithm so
407 we don't have to recalculate over the whole block of
408 samples. */
409 new = (int)tx *(int)tx;
410 old = (int)ec->fir_state.history[ec->fir_state.curr_pos] *
411 (int)ec->fir_state.history[ec->fir_state.curr_pos];
412 ec->Pstates +=
413 ((new - old) + (1 << (ec->log2taps - 1))) >> ec->log2taps;
414 if (ec->Pstates < 0)
415 ec->Pstates = 0;
416 }
417
418 /* Calculate short term average levels using simple single pole IIRs */
419
420 ec->Ltxacc += abs(tx) - ec->Ltx;
421 ec->Ltx = (ec->Ltxacc + (1 << 4)) >> 5;
422 ec->Lrxacc += abs(rx) - ec->Lrx;
423 ec->Lrx = (ec->Lrxacc + (1 << 4)) >> 5;
424
425 /* Foreground filter */
426
427 ec->fir_state.coeffs = ec->fir_taps16[0];
428 echo_value = fir16(&ec->fir_state, tx);
429 ec->clean = rx - echo_value;
430 ec->Lcleanacc += abs(ec->clean) - ec->Lclean;
431 ec->Lclean = (ec->Lcleanacc + (1 << 4)) >> 5;
432
433 /* Background filter */
434
435 echo_value = fir16(&ec->fir_state_bg, tx);
436 clean_bg = rx - echo_value;
437 ec->Lclean_bgacc += abs(clean_bg) - ec->Lclean_bg;
438 ec->Lclean_bg = (ec->Lclean_bgacc + (1 << 4)) >> 5;
439
440 /* Background Filter adaption */
441
442 /* Almost always adap bg filter, just simple DT and energy
443 detection to minimise adaption in cases of strong double talk.
444 However this is not critical for the dual path algorithm.
445 */
446 ec->factor = 0;
447 ec->shift = 0;
448 if ((ec->nonupdate_dwell == 0)) {
449 int P, logP, shift;
450
451 /* Determine:
452
453 f = Beta * clean_bg_rx/P ------ (1)
454
455 where P is the total power in the filter states.
456
457 The Boffins have shown that if we obey (1) we converge
458 quickly and avoid instability.
459
460 The correct factor f must be in Q30, as this is the fixed
461 point format required by the lms_adapt_bg() function,
462 therefore the scaled version of (1) is:
463
464 (2^30) * f = (2^30) * Beta * clean_bg_rx/P
465 factor = (2^30) * Beta * clean_bg_rx/P ----- (2)
466
467 We have chosen Beta = 0.25 by experiment, so:
468
469 factor = (2^30) * (2^-2) * clean_bg_rx/P
470
471 (30 - 2 - log2(P))
472 factor = clean_bg_rx 2 ----- (3)
473
474 To avoid a divide we approximate log2(P) as top_bit(P),
475 which returns the position of the highest non-zero bit in
476 P. This approximation introduces an error as large as a
477 factor of 2, but the algorithm seems to handle it OK.
478
479 Come to think of it a divide may not be a big deal on a
480 modern DSP, so its probably worth checking out the cycles
481 for a divide versus a top_bit() implementation.
482 */
483
484 P = MIN_TX_POWER_FOR_ADAPTION + ec->Pstates;
485 logP = top_bit(P) + ec->log2taps;
486 shift = 30 - 2 - logP;
487 ec->shift = shift;
488
489 lms_adapt_bg(ec, clean_bg, shift);
490 }
491
492 /* very simple DTD to make sure we dont try and adapt with strong
493 near end speech */
494
495 ec->adapt = 0;
496 if ((ec->Lrx > MIN_RX_POWER_FOR_ADAPTION) && (ec->Lrx > ec->Ltx))
497 ec->nonupdate_dwell = DTD_HANGOVER;
498 if (ec->nonupdate_dwell)
499 ec->nonupdate_dwell--;
500
501 /* Transfer logic */
502
503 /* These conditions are from the dual path paper [1], I messed with
504 them a bit to improve performance. */
505
506 if ((ec->adaption_mode & ECHO_CAN_USE_ADAPTION) &&
507 (ec->nonupdate_dwell == 0) &&
508 /* (ec->Lclean_bg < 0.875*ec->Lclean) */
509 (8 * ec->Lclean_bg < 7 * ec->Lclean) &&
510 /* (ec->Lclean_bg < 0.125*ec->Ltx) */
511 (8 * ec->Lclean_bg < ec->Ltx)) {
512 if (ec->cond_met == 6) {
513 /*
514 * BG filter has had better results for 6 consecutive
515 * samples
516 */
517 ec->adapt = 1;
518 memcpy(ec->fir_taps16[0], ec->fir_taps16[1],
519 ec->taps * sizeof(int16_t));
520 } else
521 ec->cond_met++;
522 } else
523 ec->cond_met = 0;
524
525 /* Non-Linear Processing */
526
527 ec->clean_nlp = ec->clean;
528 if (ec->adaption_mode & ECHO_CAN_USE_NLP) {
529 /*
530 * Non-linear processor - a fancy way to say "zap small
531 * signals, to avoid residual echo due to (uLaw/ALaw)
532 * non-linearity in the channel.".
533 */
534
535 if ((16 * ec->Lclean < ec->Ltx)) {
536 /*
537 * Our e/c has improved echo by at least 24 dB (each
538 * factor of 2 is 6dB, so 2*2*2*2=16 is the same as
539 * 6+6+6+6=24dB)
540 */
541 if (ec->adaption_mode & ECHO_CAN_USE_CNG) {
542 ec->cng_level = ec->Lbgn;
543
544 /*
545 * Very elementary comfort noise generation.
546 * Just random numbers rolled off very vaguely
547 * Hoth-like. DR: This noise doesn't sound
548 * quite right to me - I suspect there are some
549 * overflow issues in the filtering as it's too
550 * "crackly".
551 * TODO: debug this, maybe just play noise at
552 * high level or look at spectrum.
553 */
554
555 ec->cng_rndnum =
556 1664525U * ec->cng_rndnum + 1013904223U;
557 ec->cng_filter =
558 ((ec->cng_rndnum & 0xFFFF) - 32768 +
559 5 * ec->cng_filter) >> 3;
560 ec->clean_nlp =
561 (ec->cng_filter * ec->cng_level * 8) >> 14;
562
563 } else if (ec->adaption_mode & ECHO_CAN_USE_CLIP) {
564 /* This sounds much better than CNG */
565 if (ec->clean_nlp > ec->Lbgn)
566 ec->clean_nlp = ec->Lbgn;
567 if (ec->clean_nlp < -ec->Lbgn)
568 ec->clean_nlp = -ec->Lbgn;
569 } else {
570 /*
571 * just mute the residual, doesn't sound very
572 * good, used mainly in G168 tests
573 */
574 ec->clean_nlp = 0;
575 }
576 } else {
577 /*
578 * Background noise estimator. I tried a few
579 * algorithms here without much luck. This very simple
580 * one seems to work best, we just average the level
581 * using a slow (1 sec time const) filter if the
582 * current level is less than a (experimentally
583 * derived) constant. This means we dont include high
584 * level signals like near end speech. When combined
585 * with CNG or especially CLIP seems to work OK.
586 */
587 if (ec->Lclean < 40) {
588 ec->Lbgn_acc += abs(ec->clean) - ec->Lbgn;
589 ec->Lbgn = (ec->Lbgn_acc + (1 << 11)) >> 12;
590 }
591 }
592 }
593
594 /* Roll around the taps buffer */
595 if (ec->curr_pos <= 0)
596 ec->curr_pos = ec->taps;
597 ec->curr_pos--;
598
599 if (ec->adaption_mode & ECHO_CAN_DISABLE)
600 ec->clean_nlp = rx;
601
602 /* Output scaled back up again to match input scaling */
603
604 return (int16_t) ec->clean_nlp << 1;
605}
606
607EXPORT_SYMBOL_GPL(oslec_update);
608
609/* This function is separated from the echo canceller is it is usually called
610 as part of the tx process. See rx HP (DC blocking) filter above, it's
611 the same design.
612
613 Some soft phones send speech signals with a lot of low frequency
614 energy, e.g. down to 20Hz. This can make the hybrid non-linear
615 which causes the echo canceller to fall over. This filter can help
616 by removing any low frequency before it gets to the tx port of the
617 hybrid.
618
619 It can also help by removing and DC in the tx signal. DC is bad
620 for LMS algorithms.
621
622 This is one of the classic DC removal filters, adjusted to provide
623 sufficient bass rolloff to meet the above requirement to protect hybrids
624 from things that upset them. The difference between successive samples
625 produces a lousy HPF, and then a suitably placed pole flattens things out.
626 The final result is a nicely rolled off bass end. The filtering is
627 implemented with extended fractional precision, which noise shapes things,
628 giving very clean DC removal.
629*/
630
631int16_t oslec_hpf_tx(struct oslec_state * ec, int16_t tx)
632{
633 int tmp, tmp1;
634
635 if (ec->adaption_mode & ECHO_CAN_USE_TX_HPF) {
636 tmp = tx << 15;
637
638 /*
639 * Make sure the gain of the HPF is 1.0. The first can still
640 * saturate a little under impulse conditions, and it might
641 * roll to 32768 and need clipping on sustained peak level
642 * signals. However, the scale of such clipping is small, and
643 * the error due to any saturation should not markedly affect
644 * the downstream processing.
645 */
646 tmp -= (tmp >> 4);
647
648 ec->tx_1 += -(ec->tx_1 >> DC_LOG2BETA) + tmp - ec->tx_2;
649 tmp1 = ec->tx_1 >> 15;
650 if (tmp1 > 32767)
651 tmp1 = 32767;
652 if (tmp1 < -32767)
653 tmp1 = -32767;
654 tx = tmp1;
655 ec->tx_2 = tmp;
656 }
657
658 return tx;
659}
660
661EXPORT_SYMBOL_GPL(oslec_hpf_tx);
662
663MODULE_LICENSE("GPL");
664MODULE_AUTHOR("David Rowe");
665MODULE_DESCRIPTION("Open Source Line Echo Canceller");
666MODULE_VERSION("0.3.0");