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__ 119 static inline void lms_adapt_bg(struct oslec_state *ec, int clean, int shift) 120 { 121 int i; 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; i < n; i++) { 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 190 static 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 220 static 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 228 struct oslec_state *oslec_create(int len, int adaption_mode) 229 { 230 struct oslec_state *ec; 231 int i; 232 const int16_t *history; 233 234 ec = kzalloc(sizeof(*ec), GFP_KERNEL); 235 if (!ec) 236 return NULL; 237 238 ec->taps = len; 239 ec->log2taps = top_bit(len); 240 ec->curr_pos = ec->taps - 1; 241 242 ec->fir_taps16[0] = 243 kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL); 244 if (!ec->fir_taps16[0]) 245 goto error_oom_0; 246 247 ec->fir_taps16[1] = 248 kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL); 249 if (!ec->fir_taps16[1]) 250 goto error_oom_1; 251 252 history = fir16_create(&ec->fir_state, ec->fir_taps16[0], ec->taps); 253 if (!history) 254 goto error_state; 255 history = fir16_create(&ec->fir_state_bg, ec->fir_taps16[1], ec->taps); 256 if (!history) 257 goto error_state_bg; 258 259 for (i = 0; i < 5; i++) 260 ec->xvtx[i] = ec->yvtx[i] = ec->xvrx[i] = ec->yvrx[i] = 0; 261 262 ec->cng_level = 1000; 263 oslec_adaption_mode(ec, adaption_mode); 264 265 ec->snapshot = kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL); 266 if (!ec->snapshot) 267 goto error_snap; 268 269 ec->cond_met = 0; 270 ec->pstates = 0; 271 ec->ltxacc = ec->lrxacc = ec->lcleanacc = ec->lclean_bgacc = 0; 272 ec->ltx = ec->lrx = ec->lclean = ec->lclean_bg = 0; 273 ec->tx_1 = ec->tx_2 = ec->rx_1 = ec->rx_2 = 0; 274 ec->lbgn = ec->lbgn_acc = 0; 275 ec->lbgn_upper = 200; 276 ec->lbgn_upper_acc = ec->lbgn_upper << 13; 277 278 return ec; 279 280 error_snap: 281 fir16_free(&ec->fir_state_bg); 282 error_state_bg: 283 fir16_free(&ec->fir_state); 284 error_state: 285 kfree(ec->fir_taps16[1]); 286 error_oom_1: 287 kfree(ec->fir_taps16[0]); 288 error_oom_0: 289 kfree(ec); 290 return NULL; 291 } 292 EXPORT_SYMBOL_GPL(oslec_create); 293 294 void oslec_free(struct oslec_state *ec) 295 { 296 int i; 297 298 fir16_free(&ec->fir_state); 299 fir16_free(&ec->fir_state_bg); 300 for (i = 0; i < 2; i++) 301 kfree(ec->fir_taps16[i]); 302 kfree(ec->snapshot); 303 kfree(ec); 304 } 305 EXPORT_SYMBOL_GPL(oslec_free); 306 307 void oslec_adaption_mode(struct oslec_state *ec, int adaption_mode) 308 { 309 ec->adaption_mode = adaption_mode; 310 } 311 EXPORT_SYMBOL_GPL(oslec_adaption_mode); 312 313 void oslec_flush(struct oslec_state *ec) 314 { 315 int i; 316 317 ec->ltxacc = ec->lrxacc = ec->lcleanacc = ec->lclean_bgacc = 0; 318 ec->ltx = ec->lrx = ec->lclean = ec->lclean_bg = 0; 319 ec->tx_1 = ec->tx_2 = ec->rx_1 = ec->rx_2 = 0; 320 321 ec->lbgn = ec->lbgn_acc = 0; 322 ec->lbgn_upper = 200; 323 ec->lbgn_upper_acc = ec->lbgn_upper << 13; 324 325 ec->nonupdate_dwell = 0; 326 327 fir16_flush(&ec->fir_state); 328 fir16_flush(&ec->fir_state_bg); 329 ec->fir_state.curr_pos = ec->taps - 1; 330 ec->fir_state_bg.curr_pos = ec->taps - 1; 331 for (i = 0; i < 2; i++) 332 memset(ec->fir_taps16[i], 0, ec->taps * sizeof(int16_t)); 333 334 ec->curr_pos = ec->taps - 1; 335 ec->pstates = 0; 336 } 337 EXPORT_SYMBOL_GPL(oslec_flush); 338 339 void oslec_snapshot(struct oslec_state *ec) 340 { 341 memcpy(ec->snapshot, ec->fir_taps16[0], ec->taps * sizeof(int16_t)); 342 } 343 EXPORT_SYMBOL_GPL(oslec_snapshot); 344 345 /* Dual Path Echo Canceller */ 346 347 int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx) 348 { 349 int32_t echo_value; 350 int clean_bg; 351 int tmp; 352 int tmp1; 353 354 /* 355 * Input scaling was found be required to prevent problems when tx 356 * starts clipping. Another possible way to handle this would be the 357 * filter coefficent scaling. 358 */ 359 360 ec->tx = tx; 361 ec->rx = rx; 362 tx >>= 1; 363 rx >>= 1; 364 365 /* 366 * Filter DC, 3dB point is 160Hz (I think), note 32 bit precision 367 * required otherwise values do not track down to 0. Zero at DC, Pole 368 * at (1-Beta) on real axis. Some chip sets (like Si labs) don't 369 * need this, but something like a $10 X100P card does. Any DC really 370 * slows down convergence. 371 * 372 * Note: removes some low frequency from the signal, this reduces the 373 * speech quality when listening to samples through headphones but may 374 * not be obvious through a telephone handset. 375 * 376 * Note that the 3dB frequency in radians is approx Beta, e.g. for Beta 377 * = 2^(-3) = 0.125, 3dB freq is 0.125 rads = 159Hz. 378 */ 379 380 if (ec->adaption_mode & ECHO_CAN_USE_RX_HPF) { 381 tmp = rx << 15; 382 383 /* 384 * Make sure the gain of the HPF is 1.0. This can still 385 * saturate a little under impulse conditions, and it might 386 * roll to 32768 and need clipping on sustained peak level 387 * signals. However, the scale of such clipping is small, and 388 * the error due to any saturation should not markedly affect 389 * the downstream processing. 390 */ 391 tmp -= (tmp >> 4); 392 393 ec->rx_1 += -(ec->rx_1 >> DC_LOG2BETA) + tmp - ec->rx_2; 394 395 /* 396 * hard limit filter to prevent clipping. Note that at this 397 * stage rx should be limited to +/- 16383 due to right shift 398 * above 399 */ 400 tmp1 = ec->rx_1 >> 15; 401 if (tmp1 > 16383) 402 tmp1 = 16383; 403 if (tmp1 < -16383) 404 tmp1 = -16383; 405 rx = tmp1; 406 ec->rx_2 = tmp; 407 } 408 409 /* Block average of power in the filter states. Used for 410 adaption power calculation. */ 411 412 { 413 int new, old; 414 415 /* efficient "out with the old and in with the new" algorithm so 416 we don't have to recalculate over the whole block of 417 samples. */ 418 new = (int)tx * (int)tx; 419 old = (int)ec->fir_state.history[ec->fir_state.curr_pos] * 420 (int)ec->fir_state.history[ec->fir_state.curr_pos]; 421 ec->pstates += 422 ((new - old) + (1 << (ec->log2taps - 1))) >> ec->log2taps; 423 if (ec->pstates < 0) 424 ec->pstates = 0; 425 } 426 427 /* Calculate short term average levels using simple single pole IIRs */ 428 429 ec->ltxacc += abs(tx) - ec->ltx; 430 ec->ltx = (ec->ltxacc + (1 << 4)) >> 5; 431 ec->lrxacc += abs(rx) - ec->lrx; 432 ec->lrx = (ec->lrxacc + (1 << 4)) >> 5; 433 434 /* Foreground filter */ 435 436 ec->fir_state.coeffs = ec->fir_taps16[0]; 437 echo_value = fir16(&ec->fir_state, tx); 438 ec->clean = rx - echo_value; 439 ec->lcleanacc += abs(ec->clean) - ec->lclean; 440 ec->lclean = (ec->lcleanacc + (1 << 4)) >> 5; 441 442 /* Background filter */ 443 444 echo_value = fir16(&ec->fir_state_bg, tx); 445 clean_bg = rx - echo_value; 446 ec->lclean_bgacc += abs(clean_bg) - ec->lclean_bg; 447 ec->lclean_bg = (ec->lclean_bgacc + (1 << 4)) >> 5; 448 449 /* Background Filter adaption */ 450 451 /* Almost always adap bg filter, just simple DT and energy 452 detection to minimise adaption in cases of strong double talk. 453 However this is not critical for the dual path algorithm. 454 */ 455 ec->factor = 0; 456 ec->shift = 0; 457 if ((ec->nonupdate_dwell == 0)) { 458 int p, logp, shift; 459 460 /* Determine: 461 462 f = Beta * clean_bg_rx/P ------ (1) 463 464 where P is the total power in the filter states. 465 466 The Boffins have shown that if we obey (1) we converge 467 quickly and avoid instability. 468 469 The correct factor f must be in Q30, as this is the fixed 470 point format required by the lms_adapt_bg() function, 471 therefore the scaled version of (1) is: 472 473 (2^30) * f = (2^30) * Beta * clean_bg_rx/P 474 factor = (2^30) * Beta * clean_bg_rx/P ----- (2) 475 476 We have chosen Beta = 0.25 by experiment, so: 477 478 factor = (2^30) * (2^-2) * clean_bg_rx/P 479 480 (30 - 2 - log2(P)) 481 factor = clean_bg_rx 2 ----- (3) 482 483 To avoid a divide we approximate log2(P) as top_bit(P), 484 which returns the position of the highest non-zero bit in 485 P. This approximation introduces an error as large as a 486 factor of 2, but the algorithm seems to handle it OK. 487 488 Come to think of it a divide may not be a big deal on a 489 modern DSP, so its probably worth checking out the cycles 490 for a divide versus a top_bit() implementation. 491 */ 492 493 p = MIN_TX_POWER_FOR_ADAPTION + ec->pstates; 494 logp = top_bit(p) + ec->log2taps; 495 shift = 30 - 2 - logp; 496 ec->shift = shift; 497 498 lms_adapt_bg(ec, clean_bg, shift); 499 } 500 501 /* very simple DTD to make sure we dont try and adapt with strong 502 near end speech */ 503 504 ec->adapt = 0; 505 if ((ec->lrx > MIN_RX_POWER_FOR_ADAPTION) && (ec->lrx > ec->ltx)) 506 ec->nonupdate_dwell = DTD_HANGOVER; 507 if (ec->nonupdate_dwell) 508 ec->nonupdate_dwell--; 509 510 /* Transfer logic */ 511 512 /* These conditions are from the dual path paper [1], I messed with 513 them a bit to improve performance. */ 514 515 if ((ec->adaption_mode & ECHO_CAN_USE_ADAPTION) && 516 (ec->nonupdate_dwell == 0) && 517 /* (ec->Lclean_bg < 0.875*ec->Lclean) */ 518 (8 * ec->lclean_bg < 7 * ec->lclean) && 519 /* (ec->Lclean_bg < 0.125*ec->Ltx) */ 520 (8 * ec->lclean_bg < ec->ltx)) { 521 if (ec->cond_met == 6) { 522 /* 523 * BG filter has had better results for 6 consecutive 524 * samples 525 */ 526 ec->adapt = 1; 527 memcpy(ec->fir_taps16[0], ec->fir_taps16[1], 528 ec->taps * sizeof(int16_t)); 529 } else 530 ec->cond_met++; 531 } else 532 ec->cond_met = 0; 533 534 /* Non-Linear Processing */ 535 536 ec->clean_nlp = ec->clean; 537 if (ec->adaption_mode & ECHO_CAN_USE_NLP) { 538 /* 539 * Non-linear processor - a fancy way to say "zap small 540 * signals, to avoid residual echo due to (uLaw/ALaw) 541 * non-linearity in the channel.". 542 */ 543 544 if ((16 * ec->lclean < ec->ltx)) { 545 /* 546 * Our e/c has improved echo by at least 24 dB (each 547 * factor of 2 is 6dB, so 2*2*2*2=16 is the same as 548 * 6+6+6+6=24dB) 549 */ 550 if (ec->adaption_mode & ECHO_CAN_USE_CNG) { 551 ec->cng_level = ec->lbgn; 552 553 /* 554 * Very elementary comfort noise generation. 555 * Just random numbers rolled off very vaguely 556 * Hoth-like. DR: This noise doesn't sound 557 * quite right to me - I suspect there are some 558 * overflow issues in the filtering as it's too 559 * "crackly". 560 * TODO: debug this, maybe just play noise at 561 * high level or look at spectrum. 562 */ 563 564 ec->cng_rndnum = 565 1664525U * ec->cng_rndnum + 1013904223U; 566 ec->cng_filter = 567 ((ec->cng_rndnum & 0xFFFF) - 32768 + 568 5 * ec->cng_filter) >> 3; 569 ec->clean_nlp = 570 (ec->cng_filter * ec->cng_level * 8) >> 14; 571 572 } else if (ec->adaption_mode & ECHO_CAN_USE_CLIP) { 573 /* This sounds much better than CNG */ 574 if (ec->clean_nlp > ec->lbgn) 575 ec->clean_nlp = ec->lbgn; 576 if (ec->clean_nlp < -ec->lbgn) 577 ec->clean_nlp = -ec->lbgn; 578 } else { 579 /* 580 * just mute the residual, doesn't sound very 581 * good, used mainly in G168 tests 582 */ 583 ec->clean_nlp = 0; 584 } 585 } else { 586 /* 587 * Background noise estimator. I tried a few 588 * algorithms here without much luck. This very simple 589 * one seems to work best, we just average the level 590 * using a slow (1 sec time const) filter if the 591 * current level is less than a (experimentally 592 * derived) constant. This means we dont include high 593 * level signals like near end speech. When combined 594 * with CNG or especially CLIP seems to work OK. 595 */ 596 if (ec->lclean < 40) { 597 ec->lbgn_acc += abs(ec->clean) - ec->lbgn; 598 ec->lbgn = (ec->lbgn_acc + (1 << 11)) >> 12; 599 } 600 } 601 } 602 603 /* Roll around the taps buffer */ 604 if (ec->curr_pos <= 0) 605 ec->curr_pos = ec->taps; 606 ec->curr_pos--; 607 608 if (ec->adaption_mode & ECHO_CAN_DISABLE) 609 ec->clean_nlp = rx; 610 611 /* Output scaled back up again to match input scaling */ 612 613 return (int16_t) ec->clean_nlp << 1; 614 } 615 EXPORT_SYMBOL_GPL(oslec_update); 616 617 /* This function is separated from the echo canceller is it is usually called 618 as part of the tx process. See rx HP (DC blocking) filter above, it's 619 the same design. 620 621 Some soft phones send speech signals with a lot of low frequency 622 energy, e.g. down to 20Hz. This can make the hybrid non-linear 623 which causes the echo canceller to fall over. This filter can help 624 by removing any low frequency before it gets to the tx port of the 625 hybrid. 626 627 It can also help by removing and DC in the tx signal. DC is bad 628 for LMS algorithms. 629 630 This is one of the classic DC removal filters, adjusted to provide 631 sufficient bass rolloff to meet the above requirement to protect hybrids 632 from things that upset them. The difference between successive samples 633 produces a lousy HPF, and then a suitably placed pole flattens things out. 634 The final result is a nicely rolled off bass end. The filtering is 635 implemented with extended fractional precision, which noise shapes things, 636 giving very clean DC removal. 637 */ 638 639 int16_t oslec_hpf_tx(struct oslec_state *ec, int16_t tx) 640 { 641 int tmp; 642 int tmp1; 643 644 if (ec->adaption_mode & ECHO_CAN_USE_TX_HPF) { 645 tmp = tx << 15; 646 647 /* 648 * Make sure the gain of the HPF is 1.0. The first can still 649 * saturate a little under impulse conditions, and it might 650 * roll to 32768 and need clipping on sustained peak level 651 * signals. However, the scale of such clipping is small, and 652 * the error due to any saturation should not markedly affect 653 * the downstream processing. 654 */ 655 tmp -= (tmp >> 4); 656 657 ec->tx_1 += -(ec->tx_1 >> DC_LOG2BETA) + tmp - ec->tx_2; 658 tmp1 = ec->tx_1 >> 15; 659 if (tmp1 > 32767) 660 tmp1 = 32767; 661 if (tmp1 < -32767) 662 tmp1 = -32767; 663 tx = tmp1; 664 ec->tx_2 = tmp; 665 } 666 667 return tx; 668 } 669 EXPORT_SYMBOL_GPL(oslec_hpf_tx); 670 671 MODULE_LICENSE("GPL"); 672 MODULE_AUTHOR("David Rowe"); 673 MODULE_DESCRIPTION("Open Source Line Echo Canceller"); 674 MODULE_VERSION("0.3.0"); 675