1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 /*
12 * Contains the API functions for the AEC.
13 */
14 #include "webrtc/modules/audio_processing/aec/include/echo_cancellation.h"
15
16 #include <math.h>
17 #ifdef WEBRTC_AEC_DEBUG_DUMP
18 #include <stdio.h>
19 #endif
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include "webrtc/common_audio/ring_buffer.h"
24 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
25 #include "webrtc/modules/audio_processing/aec/aec_core.h"
26 #include "webrtc/modules/audio_processing/aec/aec_resampler.h"
27 #include "webrtc/modules/audio_processing/aec/echo_cancellation_internal.h"
28 #include "webrtc/typedefs.h"
29
30 // Measured delays [ms]
31 // Device Chrome GTP
32 // MacBook Air 10
33 // MacBook Retina 10 100
34 // MacPro 30?
35 //
36 // Win7 Desktop 70 80?
37 // Win7 T430s 110
38 // Win8 T420s 70
39 //
40 // Daisy 50
41 // Pixel (w/ preproc?) 240
42 // Pixel (w/o preproc?) 110 110
43
44 // The extended filter mode gives us the flexibility to ignore the system's
45 // reported delays. We do this for platforms which we believe provide results
46 // which are incompatible with the AEC's expectations. Based on measurements
47 // (some provided above) we set a conservative (i.e. lower than measured)
48 // fixed delay.
49 //
50 // WEBRTC_UNTRUSTED_DELAY will only have an impact when |extended_filter_mode|
51 // is enabled. See the note along with |DelayCorrection| in
52 // echo_cancellation_impl.h for more details on the mode.
53 //
54 // Justification:
55 // Chromium/Mac: Here, the true latency is so low (~10-20 ms), that it plays
56 // havoc with the AEC's buffering. To avoid this, we set a fixed delay of 20 ms
57 // and then compensate by rewinding by 10 ms (in wideband) through
58 // kDelayDiffOffsetSamples. This trick does not seem to work for larger rewind
59 // values, but fortunately this is sufficient.
60 //
61 // Chromium/Linux(ChromeOS): The values we get on this platform don't correspond
62 // well to reality. The variance doesn't match the AEC's buffer changes, and the
63 // bulk values tend to be too low. However, the range across different hardware
64 // appears to be too large to choose a single value.
65 //
66 // GTP/Linux(ChromeOS): TBD, but for the moment we will trust the values.
67 #if defined(WEBRTC_CHROMIUM_BUILD) && defined(WEBRTC_MAC)
68 #define WEBRTC_UNTRUSTED_DELAY
69 #endif
70
71 #if defined(WEBRTC_UNTRUSTED_DELAY) && defined(WEBRTC_MAC)
72 static const int kDelayDiffOffsetSamples = -160;
73 #else
74 // Not enabled for now.
75 static const int kDelayDiffOffsetSamples = 0;
76 #endif
77
78 #if defined(WEBRTC_MAC)
79 static const int kFixedDelayMs = 20;
80 #else
81 static const int kFixedDelayMs = 50;
82 #endif
83 #if !defined(WEBRTC_UNTRUSTED_DELAY)
84 static const int kMinTrustedDelayMs = 20;
85 #endif
86 static const int kMaxTrustedDelayMs = 500;
87
88 // Maximum length of resampled signal. Must be an integer multiple of frames
89 // (ceil(1/(1 + MIN_SKEW)*2) + 1)*FRAME_LEN
90 // The factor of 2 handles wb, and the + 1 is as a safety margin
91 // TODO(bjornv): Replace with kResamplerBufferSize
92 #define MAX_RESAMP_LEN (5 * FRAME_LEN)
93
94 static const int kMaxBufSizeStart = 62; // In partitions
95 static const int sampMsNb = 8; // samples per ms in nb
96 static const int initCheck = 42;
97
98 #ifdef WEBRTC_AEC_DEBUG_DUMP
99 int webrtc_aec_instance_count = 0;
100 #endif
101
102 // Estimates delay to set the position of the far-end buffer read pointer
103 // (controlled by knownDelay)
104 static void EstBufDelayNormal(Aec* aecInst);
105 static void EstBufDelayExtended(Aec* aecInst);
106 static int ProcessNormal(Aec* self,
107 const float* const* near,
108 size_t num_bands,
109 float* const* out,
110 size_t num_samples,
111 int16_t reported_delay_ms,
112 int32_t skew);
113 static void ProcessExtended(Aec* self,
114 const float* const* near,
115 size_t num_bands,
116 float* const* out,
117 size_t num_samples,
118 int16_t reported_delay_ms,
119 int32_t skew);
120
WebRtcAec_Create()121 void* WebRtcAec_Create() {
122 Aec* aecpc = malloc(sizeof(Aec));
123
124 if (!aecpc) {
125 return NULL;
126 }
127
128 aecpc->aec = WebRtcAec_CreateAec();
129 if (!aecpc->aec) {
130 WebRtcAec_Free(aecpc);
131 return NULL;
132 }
133 aecpc->resampler = WebRtcAec_CreateResampler();
134 if (!aecpc->resampler) {
135 WebRtcAec_Free(aecpc);
136 return NULL;
137 }
138 // Create far-end pre-buffer. The buffer size has to be large enough for
139 // largest possible drift compensation (kResamplerBufferSize) + "almost" an
140 // FFT buffer (PART_LEN2 - 1).
141 aecpc->far_pre_buf =
142 WebRtc_CreateBuffer(PART_LEN2 + kResamplerBufferSize, sizeof(float));
143 if (!aecpc->far_pre_buf) {
144 WebRtcAec_Free(aecpc);
145 return NULL;
146 }
147
148 aecpc->initFlag = 0;
149 aecpc->lastError = 0;
150
151 #ifdef WEBRTC_AEC_DEBUG_DUMP
152 {
153 char filename[64];
154 sprintf(filename, "aec_buf%d.dat", webrtc_aec_instance_count);
155 aecpc->bufFile = fopen(filename, "wb");
156 sprintf(filename, "aec_skew%d.dat", webrtc_aec_instance_count);
157 aecpc->skewFile = fopen(filename, "wb");
158 sprintf(filename, "aec_delay%d.dat", webrtc_aec_instance_count);
159 aecpc->delayFile = fopen(filename, "wb");
160 webrtc_aec_instance_count++;
161 }
162 #endif
163
164 return aecpc;
165 }
166
WebRtcAec_Free(void * aecInst)167 void WebRtcAec_Free(void* aecInst) {
168 Aec* aecpc = aecInst;
169
170 if (aecpc == NULL) {
171 return;
172 }
173
174 WebRtc_FreeBuffer(aecpc->far_pre_buf);
175
176 #ifdef WEBRTC_AEC_DEBUG_DUMP
177 fclose(aecpc->bufFile);
178 fclose(aecpc->skewFile);
179 fclose(aecpc->delayFile);
180 #endif
181
182 WebRtcAec_FreeAec(aecpc->aec);
183 WebRtcAec_FreeResampler(aecpc->resampler);
184 free(aecpc);
185 }
186
WebRtcAec_Init(void * aecInst,int32_t sampFreq,int32_t scSampFreq)187 int32_t WebRtcAec_Init(void* aecInst, int32_t sampFreq, int32_t scSampFreq) {
188 Aec* aecpc = aecInst;
189 AecConfig aecConfig;
190
191 if (sampFreq != 8000 &&
192 sampFreq != 16000 &&
193 sampFreq != 32000 &&
194 sampFreq != 48000) {
195 aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
196 return -1;
197 }
198 aecpc->sampFreq = sampFreq;
199
200 if (scSampFreq < 1 || scSampFreq > 96000) {
201 aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
202 return -1;
203 }
204 aecpc->scSampFreq = scSampFreq;
205
206 // Initialize echo canceller core
207 if (WebRtcAec_InitAec(aecpc->aec, aecpc->sampFreq) == -1) {
208 aecpc->lastError = AEC_UNSPECIFIED_ERROR;
209 return -1;
210 }
211
212 if (WebRtcAec_InitResampler(aecpc->resampler, aecpc->scSampFreq) == -1) {
213 aecpc->lastError = AEC_UNSPECIFIED_ERROR;
214 return -1;
215 }
216
217 WebRtc_InitBuffer(aecpc->far_pre_buf);
218 WebRtc_MoveReadPtr(aecpc->far_pre_buf, -PART_LEN); // Start overlap.
219
220 aecpc->initFlag = initCheck; // indicates that initialization has been done
221
222 if (aecpc->sampFreq == 32000 || aecpc->sampFreq == 48000) {
223 aecpc->splitSampFreq = 16000;
224 } else {
225 aecpc->splitSampFreq = sampFreq;
226 }
227
228 aecpc->delayCtr = 0;
229 aecpc->sampFactor = (aecpc->scSampFreq * 1.0f) / aecpc->splitSampFreq;
230 // Sampling frequency multiplier (SWB is processed as 160 frame size).
231 aecpc->rate_factor = aecpc->splitSampFreq / 8000;
232
233 aecpc->sum = 0;
234 aecpc->counter = 0;
235 aecpc->checkBuffSize = 1;
236 aecpc->firstVal = 0;
237
238 // We skip the startup_phase completely (setting to 0) if DA-AEC is enabled,
239 // but not extended_filter mode.
240 aecpc->startup_phase = WebRtcAec_extended_filter_enabled(aecpc->aec) ||
241 !WebRtcAec_delay_agnostic_enabled(aecpc->aec);
242 aecpc->bufSizeStart = 0;
243 aecpc->checkBufSizeCtr = 0;
244 aecpc->msInSndCardBuf = 0;
245 aecpc->filtDelay = -1; // -1 indicates an initialized state.
246 aecpc->timeForDelayChange = 0;
247 aecpc->knownDelay = 0;
248 aecpc->lastDelayDiff = 0;
249
250 aecpc->skewFrCtr = 0;
251 aecpc->resample = kAecFalse;
252 aecpc->highSkewCtr = 0;
253 aecpc->skew = 0;
254
255 aecpc->farend_started = 0;
256
257 // Default settings.
258 aecConfig.nlpMode = kAecNlpModerate;
259 aecConfig.skewMode = kAecFalse;
260 aecConfig.metricsMode = kAecFalse;
261 aecConfig.delay_logging = kAecFalse;
262
263 if (WebRtcAec_set_config(aecpc, aecConfig) == -1) {
264 aecpc->lastError = AEC_UNSPECIFIED_ERROR;
265 return -1;
266 }
267
268 return 0;
269 }
270
271 // only buffer L band for farend
WebRtcAec_BufferFarend(void * aecInst,const float * farend,size_t nrOfSamples)272 int32_t WebRtcAec_BufferFarend(void* aecInst,
273 const float* farend,
274 size_t nrOfSamples) {
275 Aec* aecpc = aecInst;
276 size_t newNrOfSamples = nrOfSamples;
277 float new_farend[MAX_RESAMP_LEN];
278 const float* farend_ptr = farend;
279
280 if (farend == NULL) {
281 aecpc->lastError = AEC_NULL_POINTER_ERROR;
282 return -1;
283 }
284
285 if (aecpc->initFlag != initCheck) {
286 aecpc->lastError = AEC_UNINITIALIZED_ERROR;
287 return -1;
288 }
289
290 // number of samples == 160 for SWB input
291 if (nrOfSamples != 80 && nrOfSamples != 160) {
292 aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
293 return -1;
294 }
295
296 if (aecpc->skewMode == kAecTrue && aecpc->resample == kAecTrue) {
297 // Resample and get a new number of samples
298 WebRtcAec_ResampleLinear(aecpc->resampler,
299 farend,
300 nrOfSamples,
301 aecpc->skew,
302 new_farend,
303 &newNrOfSamples);
304 farend_ptr = new_farend;
305 }
306
307 aecpc->farend_started = 1;
308 WebRtcAec_SetSystemDelay(
309 aecpc->aec, WebRtcAec_system_delay(aecpc->aec) + (int)newNrOfSamples);
310
311 // Write the time-domain data to |far_pre_buf|.
312 WebRtc_WriteBuffer(aecpc->far_pre_buf, farend_ptr, newNrOfSamples);
313
314 // Transform to frequency domain if we have enough data.
315 while (WebRtc_available_read(aecpc->far_pre_buf) >= PART_LEN2) {
316 // We have enough data to pass to the FFT, hence read PART_LEN2 samples.
317 {
318 float* ptmp = NULL;
319 float tmp[PART_LEN2];
320 WebRtc_ReadBuffer(aecpc->far_pre_buf, (void**)&ptmp, tmp, PART_LEN2);
321 WebRtcAec_BufferFarendPartition(aecpc->aec, ptmp);
322 #ifdef WEBRTC_AEC_DEBUG_DUMP
323 WebRtc_WriteBuffer(
324 WebRtcAec_far_time_buf(aecpc->aec), &ptmp[PART_LEN], 1);
325 #endif
326 }
327
328 // Rewind |far_pre_buf| PART_LEN samples for overlap before continuing.
329 WebRtc_MoveReadPtr(aecpc->far_pre_buf, -PART_LEN);
330 }
331
332 return 0;
333 }
334
WebRtcAec_Process(void * aecInst,const float * const * nearend,size_t num_bands,float * const * out,size_t nrOfSamples,int16_t msInSndCardBuf,int32_t skew)335 int32_t WebRtcAec_Process(void* aecInst,
336 const float* const* nearend,
337 size_t num_bands,
338 float* const* out,
339 size_t nrOfSamples,
340 int16_t msInSndCardBuf,
341 int32_t skew) {
342 Aec* aecpc = aecInst;
343 int32_t retVal = 0;
344
345 if (out == NULL) {
346 aecpc->lastError = AEC_NULL_POINTER_ERROR;
347 return -1;
348 }
349
350 if (aecpc->initFlag != initCheck) {
351 aecpc->lastError = AEC_UNINITIALIZED_ERROR;
352 return -1;
353 }
354
355 // number of samples == 160 for SWB input
356 if (nrOfSamples != 80 && nrOfSamples != 160) {
357 aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
358 return -1;
359 }
360
361 if (msInSndCardBuf < 0) {
362 msInSndCardBuf = 0;
363 aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
364 retVal = -1;
365 } else if (msInSndCardBuf > kMaxTrustedDelayMs) {
366 // The clamping is now done in ProcessExtended/Normal().
367 aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
368 retVal = -1;
369 }
370
371 // This returns the value of aec->extended_filter_enabled.
372 if (WebRtcAec_extended_filter_enabled(aecpc->aec)) {
373 ProcessExtended(aecpc,
374 nearend,
375 num_bands,
376 out,
377 nrOfSamples,
378 msInSndCardBuf,
379 skew);
380 } else {
381 if (ProcessNormal(aecpc,
382 nearend,
383 num_bands,
384 out,
385 nrOfSamples,
386 msInSndCardBuf,
387 skew) != 0) {
388 retVal = -1;
389 }
390 }
391
392 #ifdef WEBRTC_AEC_DEBUG_DUMP
393 {
394 int16_t far_buf_size_ms = (int16_t)(WebRtcAec_system_delay(aecpc->aec) /
395 (sampMsNb * aecpc->rate_factor));
396 (void)fwrite(&far_buf_size_ms, 2, 1, aecpc->bufFile);
397 (void)fwrite(
398 &aecpc->knownDelay, sizeof(aecpc->knownDelay), 1, aecpc->delayFile);
399 }
400 #endif
401
402 return retVal;
403 }
404
WebRtcAec_set_config(void * handle,AecConfig config)405 int WebRtcAec_set_config(void* handle, AecConfig config) {
406 Aec* self = (Aec*)handle;
407 if (self->initFlag != initCheck) {
408 self->lastError = AEC_UNINITIALIZED_ERROR;
409 return -1;
410 }
411
412 if (config.skewMode != kAecFalse && config.skewMode != kAecTrue) {
413 self->lastError = AEC_BAD_PARAMETER_ERROR;
414 return -1;
415 }
416 self->skewMode = config.skewMode;
417
418 if (config.nlpMode != kAecNlpConservative &&
419 config.nlpMode != kAecNlpModerate &&
420 config.nlpMode != kAecNlpAggressive) {
421 self->lastError = AEC_BAD_PARAMETER_ERROR;
422 return -1;
423 }
424
425 if (config.metricsMode != kAecFalse && config.metricsMode != kAecTrue) {
426 self->lastError = AEC_BAD_PARAMETER_ERROR;
427 return -1;
428 }
429
430 if (config.delay_logging != kAecFalse && config.delay_logging != kAecTrue) {
431 self->lastError = AEC_BAD_PARAMETER_ERROR;
432 return -1;
433 }
434
435 WebRtcAec_SetConfigCore(
436 self->aec, config.nlpMode, config.metricsMode, config.delay_logging);
437 return 0;
438 }
439
WebRtcAec_get_echo_status(void * handle,int * status)440 int WebRtcAec_get_echo_status(void* handle, int* status) {
441 Aec* self = (Aec*)handle;
442 if (status == NULL) {
443 self->lastError = AEC_NULL_POINTER_ERROR;
444 return -1;
445 }
446 if (self->initFlag != initCheck) {
447 self->lastError = AEC_UNINITIALIZED_ERROR;
448 return -1;
449 }
450
451 *status = WebRtcAec_echo_state(self->aec);
452
453 return 0;
454 }
455
WebRtcAec_GetMetrics(void * handle,AecMetrics * metrics)456 int WebRtcAec_GetMetrics(void* handle, AecMetrics* metrics) {
457 const float kUpWeight = 0.7f;
458 float dtmp;
459 int stmp;
460 Aec* self = (Aec*)handle;
461 Stats erl;
462 Stats erle;
463 Stats a_nlp;
464
465 if (handle == NULL) {
466 return -1;
467 }
468 if (metrics == NULL) {
469 self->lastError = AEC_NULL_POINTER_ERROR;
470 return -1;
471 }
472 if (self->initFlag != initCheck) {
473 self->lastError = AEC_UNINITIALIZED_ERROR;
474 return -1;
475 }
476
477 WebRtcAec_GetEchoStats(self->aec, &erl, &erle, &a_nlp);
478
479 // ERL
480 metrics->erl.instant = (int)erl.instant;
481
482 if ((erl.himean > kOffsetLevel) && (erl.average > kOffsetLevel)) {
483 // Use a mix between regular average and upper part average.
484 dtmp = kUpWeight * erl.himean + (1 - kUpWeight) * erl.average;
485 metrics->erl.average = (int)dtmp;
486 } else {
487 metrics->erl.average = kOffsetLevel;
488 }
489
490 metrics->erl.max = (int)erl.max;
491
492 if (erl.min < (kOffsetLevel * (-1))) {
493 metrics->erl.min = (int)erl.min;
494 } else {
495 metrics->erl.min = kOffsetLevel;
496 }
497
498 // ERLE
499 metrics->erle.instant = (int)erle.instant;
500
501 if ((erle.himean > kOffsetLevel) && (erle.average > kOffsetLevel)) {
502 // Use a mix between regular average and upper part average.
503 dtmp = kUpWeight * erle.himean + (1 - kUpWeight) * erle.average;
504 metrics->erle.average = (int)dtmp;
505 } else {
506 metrics->erle.average = kOffsetLevel;
507 }
508
509 metrics->erle.max = (int)erle.max;
510
511 if (erle.min < (kOffsetLevel * (-1))) {
512 metrics->erle.min = (int)erle.min;
513 } else {
514 metrics->erle.min = kOffsetLevel;
515 }
516
517 // RERL
518 if ((metrics->erl.average > kOffsetLevel) &&
519 (metrics->erle.average > kOffsetLevel)) {
520 stmp = metrics->erl.average + metrics->erle.average;
521 } else {
522 stmp = kOffsetLevel;
523 }
524 metrics->rerl.average = stmp;
525
526 // No other statistics needed, but returned for completeness.
527 metrics->rerl.instant = stmp;
528 metrics->rerl.max = stmp;
529 metrics->rerl.min = stmp;
530
531 // A_NLP
532 metrics->aNlp.instant = (int)a_nlp.instant;
533
534 if ((a_nlp.himean > kOffsetLevel) && (a_nlp.average > kOffsetLevel)) {
535 // Use a mix between regular average and upper part average.
536 dtmp = kUpWeight * a_nlp.himean + (1 - kUpWeight) * a_nlp.average;
537 metrics->aNlp.average = (int)dtmp;
538 } else {
539 metrics->aNlp.average = kOffsetLevel;
540 }
541
542 metrics->aNlp.max = (int)a_nlp.max;
543
544 if (a_nlp.min < (kOffsetLevel * (-1))) {
545 metrics->aNlp.min = (int)a_nlp.min;
546 } else {
547 metrics->aNlp.min = kOffsetLevel;
548 }
549
550 return 0;
551 }
552
WebRtcAec_GetDelayMetrics(void * handle,int * median,int * std,float * fraction_poor_delays)553 int WebRtcAec_GetDelayMetrics(void* handle,
554 int* median,
555 int* std,
556 float* fraction_poor_delays) {
557 Aec* self = handle;
558 if (median == NULL) {
559 self->lastError = AEC_NULL_POINTER_ERROR;
560 return -1;
561 }
562 if (std == NULL) {
563 self->lastError = AEC_NULL_POINTER_ERROR;
564 return -1;
565 }
566 if (self->initFlag != initCheck) {
567 self->lastError = AEC_UNINITIALIZED_ERROR;
568 return -1;
569 }
570 if (WebRtcAec_GetDelayMetricsCore(self->aec, median, std,
571 fraction_poor_delays) ==
572 -1) {
573 // Logging disabled.
574 self->lastError = AEC_UNSUPPORTED_FUNCTION_ERROR;
575 return -1;
576 }
577
578 return 0;
579 }
580
WebRtcAec_get_error_code(void * aecInst)581 int32_t WebRtcAec_get_error_code(void* aecInst) {
582 Aec* aecpc = aecInst;
583 return aecpc->lastError;
584 }
585
WebRtcAec_aec_core(void * handle)586 AecCore* WebRtcAec_aec_core(void* handle) {
587 if (!handle) {
588 return NULL;
589 }
590 return ((Aec*)handle)->aec;
591 }
592
ProcessNormal(Aec * aecpc,const float * const * nearend,size_t num_bands,float * const * out,size_t nrOfSamples,int16_t msInSndCardBuf,int32_t skew)593 static int ProcessNormal(Aec* aecpc,
594 const float* const* nearend,
595 size_t num_bands,
596 float* const* out,
597 size_t nrOfSamples,
598 int16_t msInSndCardBuf,
599 int32_t skew) {
600 int retVal = 0;
601 size_t i;
602 size_t nBlocks10ms;
603 // Limit resampling to doubling/halving of signal
604 const float minSkewEst = -0.5f;
605 const float maxSkewEst = 1.0f;
606
607 msInSndCardBuf =
608 msInSndCardBuf > kMaxTrustedDelayMs ? kMaxTrustedDelayMs : msInSndCardBuf;
609 // TODO(andrew): we need to investigate if this +10 is really wanted.
610 msInSndCardBuf += 10;
611 aecpc->msInSndCardBuf = msInSndCardBuf;
612
613 if (aecpc->skewMode == kAecTrue) {
614 if (aecpc->skewFrCtr < 25) {
615 aecpc->skewFrCtr++;
616 } else {
617 retVal = WebRtcAec_GetSkew(aecpc->resampler, skew, &aecpc->skew);
618 if (retVal == -1) {
619 aecpc->skew = 0;
620 aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
621 }
622
623 aecpc->skew /= aecpc->sampFactor * nrOfSamples;
624
625 if (aecpc->skew < 1.0e-3 && aecpc->skew > -1.0e-3) {
626 aecpc->resample = kAecFalse;
627 } else {
628 aecpc->resample = kAecTrue;
629 }
630
631 if (aecpc->skew < minSkewEst) {
632 aecpc->skew = minSkewEst;
633 } else if (aecpc->skew > maxSkewEst) {
634 aecpc->skew = maxSkewEst;
635 }
636
637 #ifdef WEBRTC_AEC_DEBUG_DUMP
638 (void)fwrite(&aecpc->skew, sizeof(aecpc->skew), 1, aecpc->skewFile);
639 #endif
640 }
641 }
642
643 nBlocks10ms = nrOfSamples / (FRAME_LEN * aecpc->rate_factor);
644
645 if (aecpc->startup_phase) {
646 for (i = 0; i < num_bands; ++i) {
647 // Only needed if they don't already point to the same place.
648 if (nearend[i] != out[i]) {
649 memcpy(out[i], nearend[i], sizeof(nearend[i][0]) * nrOfSamples);
650 }
651 }
652
653 // The AEC is in the start up mode
654 // AEC is disabled until the system delay is OK
655
656 // Mechanism to ensure that the system delay is reasonably stable.
657 if (aecpc->checkBuffSize) {
658 aecpc->checkBufSizeCtr++;
659 // Before we fill up the far-end buffer we require the system delay
660 // to be stable (+/-8 ms) compared to the first value. This
661 // comparison is made during the following 6 consecutive 10 ms
662 // blocks. If it seems to be stable then we start to fill up the
663 // far-end buffer.
664 if (aecpc->counter == 0) {
665 aecpc->firstVal = aecpc->msInSndCardBuf;
666 aecpc->sum = 0;
667 }
668
669 if (abs(aecpc->firstVal - aecpc->msInSndCardBuf) <
670 WEBRTC_SPL_MAX(0.2 * aecpc->msInSndCardBuf, sampMsNb)) {
671 aecpc->sum += aecpc->msInSndCardBuf;
672 aecpc->counter++;
673 } else {
674 aecpc->counter = 0;
675 }
676
677 if (aecpc->counter * nBlocks10ms >= 6) {
678 // The far-end buffer size is determined in partitions of
679 // PART_LEN samples. Use 75% of the average value of the system
680 // delay as buffer size to start with.
681 aecpc->bufSizeStart =
682 WEBRTC_SPL_MIN((3 * aecpc->sum * aecpc->rate_factor * 8) /
683 (4 * aecpc->counter * PART_LEN),
684 kMaxBufSizeStart);
685 // Buffer size has now been determined.
686 aecpc->checkBuffSize = 0;
687 }
688
689 if (aecpc->checkBufSizeCtr * nBlocks10ms > 50) {
690 // For really bad systems, don't disable the echo canceller for
691 // more than 0.5 sec.
692 aecpc->bufSizeStart = WEBRTC_SPL_MIN(
693 (aecpc->msInSndCardBuf * aecpc->rate_factor * 3) / 40,
694 kMaxBufSizeStart);
695 aecpc->checkBuffSize = 0;
696 }
697 }
698
699 // If |checkBuffSize| changed in the if-statement above.
700 if (!aecpc->checkBuffSize) {
701 // The system delay is now reasonably stable (or has been unstable
702 // for too long). When the far-end buffer is filled with
703 // approximately the same amount of data as reported by the system
704 // we end the startup phase.
705 int overhead_elements =
706 WebRtcAec_system_delay(aecpc->aec) / PART_LEN - aecpc->bufSizeStart;
707 if (overhead_elements == 0) {
708 // Enable the AEC
709 aecpc->startup_phase = 0;
710 } else if (overhead_elements > 0) {
711 // TODO(bjornv): Do we need a check on how much we actually
712 // moved the read pointer? It should always be possible to move
713 // the pointer |overhead_elements| since we have only added data
714 // to the buffer and no delay compensation nor AEC processing
715 // has been done.
716 WebRtcAec_MoveFarReadPtr(aecpc->aec, overhead_elements);
717
718 // Enable the AEC
719 aecpc->startup_phase = 0;
720 }
721 }
722 } else {
723 // AEC is enabled.
724 EstBufDelayNormal(aecpc);
725
726 // Call the AEC.
727 // TODO(bjornv): Re-structure such that we don't have to pass
728 // |aecpc->knownDelay| as input. Change name to something like
729 // |system_buffer_diff|.
730 WebRtcAec_ProcessFrames(aecpc->aec,
731 nearend,
732 num_bands,
733 nrOfSamples,
734 aecpc->knownDelay,
735 out);
736 }
737
738 return retVal;
739 }
740
ProcessExtended(Aec * self,const float * const * near,size_t num_bands,float * const * out,size_t num_samples,int16_t reported_delay_ms,int32_t skew)741 static void ProcessExtended(Aec* self,
742 const float* const* near,
743 size_t num_bands,
744 float* const* out,
745 size_t num_samples,
746 int16_t reported_delay_ms,
747 int32_t skew) {
748 size_t i;
749 const int delay_diff_offset = kDelayDiffOffsetSamples;
750 #if defined(WEBRTC_UNTRUSTED_DELAY)
751 reported_delay_ms = kFixedDelayMs;
752 #else
753 // This is the usual mode where we trust the reported system delay values.
754 // Due to the longer filter, we no longer add 10 ms to the reported delay
755 // to reduce chance of non-causality. Instead we apply a minimum here to avoid
756 // issues with the read pointer jumping around needlessly.
757 reported_delay_ms = reported_delay_ms < kMinTrustedDelayMs
758 ? kMinTrustedDelayMs
759 : reported_delay_ms;
760 // If the reported delay appears to be bogus, we attempt to recover by using
761 // the measured fixed delay values. We use >= here because higher layers
762 // may already clamp to this maximum value, and we would otherwise not
763 // detect it here.
764 reported_delay_ms = reported_delay_ms >= kMaxTrustedDelayMs
765 ? kFixedDelayMs
766 : reported_delay_ms;
767 #endif
768 self->msInSndCardBuf = reported_delay_ms;
769
770 if (!self->farend_started) {
771 for (i = 0; i < num_bands; ++i) {
772 // Only needed if they don't already point to the same place.
773 if (near[i] != out[i]) {
774 memcpy(out[i], near[i], sizeof(near[i][0]) * num_samples);
775 }
776 }
777 return;
778 }
779 if (self->startup_phase) {
780 // In the extended mode, there isn't a startup "phase", just a special
781 // action on the first frame. In the trusted delay case, we'll take the
782 // current reported delay, unless it's less then our conservative
783 // measurement.
784 int startup_size_ms =
785 reported_delay_ms < kFixedDelayMs ? kFixedDelayMs : reported_delay_ms;
786 #if defined(WEBRTC_ANDROID)
787 int target_delay = startup_size_ms * self->rate_factor * 8;
788 #else
789 // To avoid putting the AEC in a non-causal state we're being slightly
790 // conservative and scale by 2. On Android we use a fixed delay and
791 // therefore there is no need to scale the target_delay.
792 int target_delay = startup_size_ms * self->rate_factor * 8 / 2;
793 #endif
794 int overhead_elements =
795 (WebRtcAec_system_delay(self->aec) - target_delay) / PART_LEN;
796 WebRtcAec_MoveFarReadPtr(self->aec, overhead_elements);
797 self->startup_phase = 0;
798 }
799
800 EstBufDelayExtended(self);
801
802 {
803 // |delay_diff_offset| gives us the option to manually rewind the delay on
804 // very low delay platforms which can't be expressed purely through
805 // |reported_delay_ms|.
806 const int adjusted_known_delay =
807 WEBRTC_SPL_MAX(0, self->knownDelay + delay_diff_offset);
808
809 WebRtcAec_ProcessFrames(self->aec,
810 near,
811 num_bands,
812 num_samples,
813 adjusted_known_delay,
814 out);
815 }
816 }
817
EstBufDelayNormal(Aec * aecpc)818 static void EstBufDelayNormal(Aec* aecpc) {
819 int nSampSndCard = aecpc->msInSndCardBuf * sampMsNb * aecpc->rate_factor;
820 int current_delay = nSampSndCard - WebRtcAec_system_delay(aecpc->aec);
821 int delay_difference = 0;
822
823 // Before we proceed with the delay estimate filtering we:
824 // 1) Compensate for the frame that will be read.
825 // 2) Compensate for drift resampling.
826 // 3) Compensate for non-causality if needed, since the estimated delay can't
827 // be negative.
828
829 // 1) Compensating for the frame(s) that will be read/processed.
830 current_delay += FRAME_LEN * aecpc->rate_factor;
831
832 // 2) Account for resampling frame delay.
833 if (aecpc->skewMode == kAecTrue && aecpc->resample == kAecTrue) {
834 current_delay -= kResamplingDelay;
835 }
836
837 // 3) Compensate for non-causality, if needed, by flushing one block.
838 if (current_delay < PART_LEN) {
839 current_delay += WebRtcAec_MoveFarReadPtr(aecpc->aec, 1) * PART_LEN;
840 }
841
842 // We use -1 to signal an initialized state in the "extended" implementation;
843 // compensate for that.
844 aecpc->filtDelay = aecpc->filtDelay < 0 ? 0 : aecpc->filtDelay;
845 aecpc->filtDelay =
846 WEBRTC_SPL_MAX(0, (short)(0.8 * aecpc->filtDelay + 0.2 * current_delay));
847
848 delay_difference = aecpc->filtDelay - aecpc->knownDelay;
849 if (delay_difference > 224) {
850 if (aecpc->lastDelayDiff < 96) {
851 aecpc->timeForDelayChange = 0;
852 } else {
853 aecpc->timeForDelayChange++;
854 }
855 } else if (delay_difference < 96 && aecpc->knownDelay > 0) {
856 if (aecpc->lastDelayDiff > 224) {
857 aecpc->timeForDelayChange = 0;
858 } else {
859 aecpc->timeForDelayChange++;
860 }
861 } else {
862 aecpc->timeForDelayChange = 0;
863 }
864 aecpc->lastDelayDiff = delay_difference;
865
866 if (aecpc->timeForDelayChange > 25) {
867 aecpc->knownDelay = WEBRTC_SPL_MAX((int)aecpc->filtDelay - 160, 0);
868 }
869 }
870
EstBufDelayExtended(Aec * self)871 static void EstBufDelayExtended(Aec* self) {
872 int reported_delay = self->msInSndCardBuf * sampMsNb * self->rate_factor;
873 int current_delay = reported_delay - WebRtcAec_system_delay(self->aec);
874 int delay_difference = 0;
875
876 // Before we proceed with the delay estimate filtering we:
877 // 1) Compensate for the frame that will be read.
878 // 2) Compensate for drift resampling.
879 // 3) Compensate for non-causality if needed, since the estimated delay can't
880 // be negative.
881
882 // 1) Compensating for the frame(s) that will be read/processed.
883 current_delay += FRAME_LEN * self->rate_factor;
884
885 // 2) Account for resampling frame delay.
886 if (self->skewMode == kAecTrue && self->resample == kAecTrue) {
887 current_delay -= kResamplingDelay;
888 }
889
890 // 3) Compensate for non-causality, if needed, by flushing two blocks.
891 if (current_delay < PART_LEN) {
892 current_delay += WebRtcAec_MoveFarReadPtr(self->aec, 2) * PART_LEN;
893 }
894
895 if (self->filtDelay == -1) {
896 self->filtDelay = WEBRTC_SPL_MAX(0, 0.5 * current_delay);
897 } else {
898 self->filtDelay = WEBRTC_SPL_MAX(
899 0, (short)(0.95 * self->filtDelay + 0.05 * current_delay));
900 }
901
902 delay_difference = self->filtDelay - self->knownDelay;
903 if (delay_difference > 384) {
904 if (self->lastDelayDiff < 128) {
905 self->timeForDelayChange = 0;
906 } else {
907 self->timeForDelayChange++;
908 }
909 } else if (delay_difference < 128 && self->knownDelay > 0) {
910 if (self->lastDelayDiff > 384) {
911 self->timeForDelayChange = 0;
912 } else {
913 self->timeForDelayChange++;
914 }
915 } else {
916 self->timeForDelayChange = 0;
917 }
918 self->lastDelayDiff = delay_difference;
919
920 if (self->timeForDelayChange > 25) {
921 self->knownDelay = WEBRTC_SPL_MAX((int)self->filtDelay - 256, 0);
922 }
923 }
924