aboutsummaryrefslogtreecommitdiff
path: root/src/modules/audio_processing/aec/echo_cancellation.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/modules/audio_processing/aec/echo_cancellation.c')
-rw-r--r--src/modules/audio_processing/aec/echo_cancellation.c940
1 files changed, 940 insertions, 0 deletions
diff --git a/src/modules/audio_processing/aec/echo_cancellation.c b/src/modules/audio_processing/aec/echo_cancellation.c
new file mode 100644
index 0000000000..66c9b979f1
--- /dev/null
+++ b/src/modules/audio_processing/aec/echo_cancellation.c
@@ -0,0 +1,940 @@
+/*
+ * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+/*
+ * Contains the API functions for the AEC.
+ */
+#include "echo_cancellation.h"
+
+#include <math.h>
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+#include <stdio.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+
+#include "aec_core.h"
+#include "aec_resampler.h"
+#include "ring_buffer.h"
+#include "typedefs.h"
+
+// Maximum length of resampled signal. Must be an integer multiple of frames
+// (ceil(1/(1 + MIN_SKEW)*2) + 1)*FRAME_LEN
+// The factor of 2 handles wb, and the + 1 is as a safety margin
+// TODO(bjornv): Replace with kResamplerBufferSize
+#define MAX_RESAMP_LEN (5 * FRAME_LEN)
+
+static const int kMaxBufSizeStart = 62; // In partitions
+static const int sampMsNb = 8; // samples per ms in nb
+// Target suppression levels for nlp modes
+// log{0.001, 0.00001, 0.00000001}
+static const float targetSupp[3] = {-6.9f, -11.5f, -18.4f};
+static const float minOverDrive[3] = {1.0f, 2.0f, 5.0f};
+static const int initCheck = 42;
+
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+static int instance_count = 0;
+#endif
+
+typedef struct {
+ int delayCtr;
+ int sampFreq;
+ int splitSampFreq;
+ int scSampFreq;
+ float sampFactor; // scSampRate / sampFreq
+ short nlpMode;
+ short autoOnOff;
+ short activity;
+ short skewMode;
+ int bufSizeStart;
+ //short bufResetCtr; // counts number of noncausal frames
+ int knownDelay;
+
+ short initFlag; // indicates if AEC has been initialized
+
+ // Variables used for averaging far end buffer size
+ short counter;
+ int sum;
+ short firstVal;
+ short checkBufSizeCtr;
+
+ // Variables used for delay shifts
+ short msInSndCardBuf;
+ short filtDelay; // Filtered delay estimate.
+ int timeForDelayChange;
+ int ECstartup;
+ int checkBuffSize;
+ short lastDelayDiff;
+
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ void* far_pre_buf_s16; // Time domain far-end pre-buffer in int16_t.
+ FILE *bufFile;
+ FILE *delayFile;
+ FILE *skewFile;
+#endif
+
+ // Structures
+ void *resampler;
+
+ int skewFrCtr;
+ int resample; // if the skew is small enough we don't resample
+ int highSkewCtr;
+ float skew;
+
+ void* far_pre_buf; // Time domain far-end pre-buffer.
+
+ int lastError;
+
+ aec_t *aec;
+} aecpc_t;
+
+// Estimates delay to set the position of the far-end buffer read pointer
+// (controlled by knownDelay)
+static int EstBufDelay(aecpc_t *aecInst);
+
+WebRtc_Word32 WebRtcAec_Create(void **aecInst)
+{
+ aecpc_t *aecpc;
+ if (aecInst == NULL) {
+ return -1;
+ }
+
+ aecpc = malloc(sizeof(aecpc_t));
+ *aecInst = aecpc;
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ if (WebRtcAec_CreateAec(&aecpc->aec) == -1) {
+ WebRtcAec_Free(aecpc);
+ aecpc = NULL;
+ return -1;
+ }
+
+ if (WebRtcAec_CreateResampler(&aecpc->resampler) == -1) {
+ WebRtcAec_Free(aecpc);
+ aecpc = NULL;
+ return -1;
+ }
+ // Create far-end pre-buffer. The buffer size has to be large enough for
+ // largest possible drift compensation (kResamplerBufferSize) + "almost" an
+ // FFT buffer (PART_LEN2 - 1).
+ if (WebRtc_CreateBuffer(&aecpc->far_pre_buf,
+ PART_LEN2 + kResamplerBufferSize,
+ sizeof(float)) == -1) {
+ WebRtcAec_Free(aecpc);
+ aecpc = NULL;
+ return -1;
+ }
+
+ aecpc->initFlag = 0;
+ aecpc->lastError = 0;
+
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ if (WebRtc_CreateBuffer(&aecpc->far_pre_buf_s16,
+ PART_LEN2 + kResamplerBufferSize,
+ sizeof(int16_t)) == -1) {
+ WebRtcAec_Free(aecpc);
+ aecpc = NULL;
+ return -1;
+ }
+ {
+ char filename[64];
+ sprintf(filename, "aec_far%d.pcm", instance_count);
+ aecpc->aec->farFile = fopen(filename, "wb");
+ sprintf(filename, "aec_near%d.pcm", instance_count);
+ aecpc->aec->nearFile = fopen(filename, "wb");
+ sprintf(filename, "aec_out%d.pcm", instance_count);
+ aecpc->aec->outFile = fopen(filename, "wb");
+ sprintf(filename, "aec_out_linear%d.pcm", instance_count);
+ aecpc->aec->outLinearFile = fopen(filename, "wb");
+ sprintf(filename, "aec_buf%d.dat", instance_count);
+ aecpc->bufFile = fopen(filename, "wb");
+ sprintf(filename, "aec_skew%d.dat", instance_count);
+ aecpc->skewFile = fopen(filename, "wb");
+ sprintf(filename, "aec_delay%d.dat", instance_count);
+ aecpc->delayFile = fopen(filename, "wb");
+ instance_count++;
+ }
+#endif
+
+ return 0;
+}
+
+WebRtc_Word32 WebRtcAec_Free(void *aecInst)
+{
+ aecpc_t *aecpc = aecInst;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ WebRtc_FreeBuffer(aecpc->far_pre_buf);
+
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ WebRtc_FreeBuffer(aecpc->far_pre_buf_s16);
+ fclose(aecpc->aec->farFile);
+ fclose(aecpc->aec->nearFile);
+ fclose(aecpc->aec->outFile);
+ fclose(aecpc->aec->outLinearFile);
+ fclose(aecpc->bufFile);
+ fclose(aecpc->skewFile);
+ fclose(aecpc->delayFile);
+#endif
+
+ WebRtcAec_FreeAec(aecpc->aec);
+ WebRtcAec_FreeResampler(aecpc->resampler);
+ free(aecpc);
+
+ return 0;
+}
+
+WebRtc_Word32 WebRtcAec_Init(void *aecInst, WebRtc_Word32 sampFreq, WebRtc_Word32 scSampFreq)
+{
+ aecpc_t *aecpc = aecInst;
+ AecConfig aecConfig;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ if (sampFreq != 8000 && sampFreq != 16000 && sampFreq != 32000) {
+ aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
+ return -1;
+ }
+ aecpc->sampFreq = sampFreq;
+
+ if (scSampFreq < 1 || scSampFreq > 96000) {
+ aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
+ return -1;
+ }
+ aecpc->scSampFreq = scSampFreq;
+
+ // Initialize echo canceller core
+ if (WebRtcAec_InitAec(aecpc->aec, aecpc->sampFreq) == -1) {
+ aecpc->lastError = AEC_UNSPECIFIED_ERROR;
+ return -1;
+ }
+
+ if (WebRtcAec_InitResampler(aecpc->resampler, aecpc->scSampFreq) == -1) {
+ aecpc->lastError = AEC_UNSPECIFIED_ERROR;
+ return -1;
+ }
+
+ if (WebRtc_InitBuffer(aecpc->far_pre_buf) == -1) {
+ aecpc->lastError = AEC_UNSPECIFIED_ERROR;
+ return -1;
+ }
+ WebRtc_MoveReadPtr(aecpc->far_pre_buf, -PART_LEN); // Start overlap.
+
+ aecpc->initFlag = initCheck; // indicates that initialization has been done
+
+ if (aecpc->sampFreq == 32000) {
+ aecpc->splitSampFreq = 16000;
+ }
+ else {
+ aecpc->splitSampFreq = sampFreq;
+ }
+
+ aecpc->skewFrCtr = 0;
+ aecpc->activity = 0;
+
+ aecpc->delayCtr = 0;
+
+ aecpc->sum = 0;
+ aecpc->counter = 0;
+ aecpc->checkBuffSize = 1;
+ aecpc->firstVal = 0;
+
+ aecpc->ECstartup = 1;
+ aecpc->bufSizeStart = 0;
+ aecpc->checkBufSizeCtr = 0;
+ aecpc->filtDelay = 0;
+ aecpc->timeForDelayChange = 0;
+ aecpc->knownDelay = 0;
+ aecpc->lastDelayDiff = 0;
+
+ aecpc->skew = 0;
+ aecpc->resample = kAecFalse;
+ aecpc->highSkewCtr = 0;
+ aecpc->sampFactor = (aecpc->scSampFreq * 1.0f) / aecpc->splitSampFreq;
+
+ // Default settings.
+ aecConfig.nlpMode = kAecNlpModerate;
+ aecConfig.skewMode = kAecFalse;
+ aecConfig.metricsMode = kAecFalse;
+ aecConfig.delay_logging = kAecFalse;
+
+ if (WebRtcAec_set_config(aecpc, aecConfig) == -1) {
+ aecpc->lastError = AEC_UNSPECIFIED_ERROR;
+ return -1;
+ }
+
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ if (WebRtc_InitBuffer(aecpc->far_pre_buf_s16) == -1) {
+ aecpc->lastError = AEC_UNSPECIFIED_ERROR;
+ return -1;
+ }
+ WebRtc_MoveReadPtr(aecpc->far_pre_buf_s16, -PART_LEN); // Start overlap.
+#endif
+
+ return 0;
+}
+
+// only buffer L band for farend
+WebRtc_Word32 WebRtcAec_BufferFarend(void *aecInst, const WebRtc_Word16 *farend,
+ WebRtc_Word16 nrOfSamples)
+{
+ aecpc_t *aecpc = aecInst;
+ WebRtc_Word32 retVal = 0;
+ int newNrOfSamples = (int) nrOfSamples;
+ short newFarend[MAX_RESAMP_LEN];
+ const int16_t* farend_ptr = farend;
+ float tmp_farend[MAX_RESAMP_LEN];
+ const float* farend_float = tmp_farend;
+ float skew;
+ int i = 0;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ if (farend == NULL) {
+ aecpc->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+
+ if (aecpc->initFlag != initCheck) {
+ aecpc->lastError = AEC_UNINITIALIZED_ERROR;
+ return -1;
+ }
+
+ // number of samples == 160 for SWB input
+ if (nrOfSamples != 80 && nrOfSamples != 160) {
+ aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
+ return -1;
+ }
+
+ skew = aecpc->skew;
+
+ if (aecpc->skewMode == kAecTrue && aecpc->resample == kAecTrue) {
+ // Resample and get a new number of samples
+ newNrOfSamples = WebRtcAec_ResampleLinear(aecpc->resampler,
+ farend,
+ nrOfSamples,
+ skew,
+ newFarend);
+ farend_ptr = (const int16_t*) newFarend;
+ }
+
+ aecpc->aec->system_delay += newNrOfSamples;
+
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ WebRtc_WriteBuffer(aecpc->far_pre_buf_s16, farend_ptr,
+ (size_t) newNrOfSamples);
+#endif
+ // Cast to float and write the time-domain data to |far_pre_buf|.
+ for (i = 0; i < newNrOfSamples; i++) {
+ tmp_farend[i] = (float) farend_ptr[i];
+ }
+ WebRtc_WriteBuffer(aecpc->far_pre_buf, farend_float,
+ (size_t) newNrOfSamples);
+
+ // Transform to frequency domain if we have enough data.
+ while (WebRtc_available_read(aecpc->far_pre_buf) >= PART_LEN2) {
+ // We have enough data to pass to the FFT, hence read PART_LEN2 samples.
+ WebRtc_ReadBuffer(aecpc->far_pre_buf, (void**) &farend_float, tmp_farend,
+ PART_LEN2);
+
+ WebRtcAec_BufferFarendPartition(aecpc->aec, farend_float);
+
+ // Rewind |far_pre_buf| PART_LEN samples for overlap before continuing.
+ WebRtc_MoveReadPtr(aecpc->far_pre_buf, -PART_LEN);
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ WebRtc_ReadBuffer(aecpc->far_pre_buf_s16, (void**) &farend_ptr, newFarend,
+ PART_LEN2);
+ WebRtc_WriteBuffer(aecpc->aec->far_time_buf, &farend_ptr[PART_LEN], 1);
+ WebRtc_MoveReadPtr(aecpc->far_pre_buf_s16, -PART_LEN);
+#endif
+ }
+
+ return retVal;
+}
+
+WebRtc_Word32 WebRtcAec_Process(void *aecInst, const WebRtc_Word16 *nearend,
+ const WebRtc_Word16 *nearendH, WebRtc_Word16 *out, WebRtc_Word16 *outH,
+ WebRtc_Word16 nrOfSamples, WebRtc_Word16 msInSndCardBuf, WebRtc_Word32 skew)
+{
+ aecpc_t *aecpc = aecInst;
+ WebRtc_Word32 retVal = 0;
+ short i;
+ short nBlocks10ms;
+ short nFrames;
+ // Limit resampling to doubling/halving of signal
+ const float minSkewEst = -0.5f;
+ const float maxSkewEst = 1.0f;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ if (nearend == NULL) {
+ aecpc->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+
+ if (out == NULL) {
+ aecpc->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+
+ if (aecpc->initFlag != initCheck) {
+ aecpc->lastError = AEC_UNINITIALIZED_ERROR;
+ return -1;
+ }
+
+ // number of samples == 160 for SWB input
+ if (nrOfSamples != 80 && nrOfSamples != 160) {
+ aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
+ return -1;
+ }
+
+ // Check for valid pointers based on sampling rate
+ if (aecpc->sampFreq == 32000 && nearendH == NULL) {
+ aecpc->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+
+ if (msInSndCardBuf < 0) {
+ msInSndCardBuf = 0;
+ aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
+ retVal = -1;
+ }
+ else if (msInSndCardBuf > 500) {
+ msInSndCardBuf = 500;
+ aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
+ retVal = -1;
+ }
+ // TODO(andrew): we need to investigate if this +10 is really wanted.
+ msInSndCardBuf += 10;
+ aecpc->msInSndCardBuf = msInSndCardBuf;
+
+ if (aecpc->skewMode == kAecTrue) {
+ if (aecpc->skewFrCtr < 25) {
+ aecpc->skewFrCtr++;
+ }
+ else {
+ retVal = WebRtcAec_GetSkew(aecpc->resampler, skew, &aecpc->skew);
+ if (retVal == -1) {
+ aecpc->skew = 0;
+ aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
+ }
+
+ aecpc->skew /= aecpc->sampFactor*nrOfSamples;
+
+ if (aecpc->skew < 1.0e-3 && aecpc->skew > -1.0e-3) {
+ aecpc->resample = kAecFalse;
+ }
+ else {
+ aecpc->resample = kAecTrue;
+ }
+
+ if (aecpc->skew < minSkewEst) {
+ aecpc->skew = minSkewEst;
+ }
+ else if (aecpc->skew > maxSkewEst) {
+ aecpc->skew = maxSkewEst;
+ }
+
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ fwrite(&aecpc->skew, sizeof(aecpc->skew), 1, aecpc->skewFile);
+#endif
+ }
+ }
+
+ nFrames = nrOfSamples / FRAME_LEN;
+ nBlocks10ms = nFrames / aecpc->aec->mult;
+
+ if (aecpc->ECstartup) {
+ if (nearend != out) {
+ // Only needed if they don't already point to the same place.
+ memcpy(out, nearend, sizeof(short) * nrOfSamples);
+ }
+
+ // The AEC is in the start up mode
+ // AEC is disabled until the system delay is OK
+
+ // Mechanism to ensure that the system delay is reasonably stable.
+ if (aecpc->checkBuffSize) {
+ aecpc->checkBufSizeCtr++;
+ // Before we fill up the far-end buffer we require the system delay
+ // to be stable (+/-8 ms) compared to the first value. This
+ // comparison is made during the following 6 consecutive 10 ms
+ // blocks. If it seems to be stable then we start to fill up the
+ // far-end buffer.
+ if (aecpc->counter == 0) {
+ aecpc->firstVal = aecpc->msInSndCardBuf;
+ aecpc->sum = 0;
+ }
+
+ if (abs(aecpc->firstVal - aecpc->msInSndCardBuf) <
+ WEBRTC_SPL_MAX(0.2 * aecpc->msInSndCardBuf, sampMsNb)) {
+ aecpc->sum += aecpc->msInSndCardBuf;
+ aecpc->counter++;
+ }
+ else {
+ aecpc->counter = 0;
+ }
+
+ if (aecpc->counter * nBlocks10ms >= 6) {
+ // The far-end buffer size is determined in partitions of
+ // PART_LEN samples. Use 75% of the average value of the system
+ // delay as buffer size to start with.
+ aecpc->bufSizeStart = WEBRTC_SPL_MIN((3 * aecpc->sum *
+ aecpc->aec->mult * 8) / (4 * aecpc->counter * PART_LEN),
+ kMaxBufSizeStart);
+ // Buffer size has now been determined.
+ aecpc->checkBuffSize = 0;
+ }
+
+ if (aecpc->checkBufSizeCtr * nBlocks10ms > 50) {
+ // For really bad systems, don't disable the echo canceller for
+ // more than 0.5 sec.
+ aecpc->bufSizeStart = WEBRTC_SPL_MIN((aecpc->msInSndCardBuf *
+ aecpc->aec->mult * 3) / 40, kMaxBufSizeStart);
+ aecpc->checkBuffSize = 0;
+ }
+ }
+
+ // If |checkBuffSize| changed in the if-statement above.
+ if (!aecpc->checkBuffSize) {
+ // The system delay is now reasonably stable (or has been unstable
+ // for too long). When the far-end buffer is filled with
+ // approximately the same amount of data as reported by the system
+ // we end the startup phase.
+ int overhead_elements = aecpc->aec->system_delay / PART_LEN -
+ aecpc->bufSizeStart;
+ if (overhead_elements == 0) {
+ // Enable the AEC
+ aecpc->ECstartup = 0;
+ } else if (overhead_elements > 0) {
+ WebRtc_MoveReadPtr(aecpc->aec->far_buf_windowed,
+ overhead_elements);
+ WebRtc_MoveReadPtr(aecpc->aec->far_buf, overhead_elements);
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ WebRtc_MoveReadPtr(aecpc->aec->far_time_buf, overhead_elements);
+#endif
+ // TODO(bjornv): Do we need a check on how much we actually
+ // moved the read pointer? It should always be possible to move
+ // the pointer |overhead_elements| since we have only added data
+ // to the buffer and no delay compensation nor AEC processing
+ // has been done.
+ aecpc->aec->system_delay -= overhead_elements * PART_LEN;
+
+ // Enable the AEC
+ aecpc->ECstartup = 0;
+ }
+ }
+ } else {
+ // AEC is enabled.
+
+ int out_elements = 0;
+
+ EstBufDelay(aecpc);
+
+ // Note that 1 frame is supported for NB and 2 frames for WB.
+ for (i = 0; i < nFrames; i++) {
+ int16_t* out_ptr = NULL;
+ int16_t out_tmp[FRAME_LEN];
+
+ // Call the AEC.
+ WebRtcAec_ProcessFrame(aecpc->aec,
+ &nearend[FRAME_LEN * i],
+ &nearendH[FRAME_LEN * i],
+ aecpc->knownDelay);
+ // TODO(bjornv): Re-structure such that we don't have to pass
+ // |aecpc->knownDelay| as input. Change name to something like
+ // |system_buffer_diff|.
+
+ // Stuff the out buffer if we have less than a frame to output.
+ // This should only happen for the first frame.
+ out_elements = (int) WebRtc_available_read(aecpc->aec->outFrBuf);
+ if (out_elements < FRAME_LEN) {
+ WebRtc_MoveReadPtr(aecpc->aec->outFrBuf,
+ out_elements - FRAME_LEN);
+ if (aecpc->sampFreq == 32000) {
+ WebRtc_MoveReadPtr(aecpc->aec->outFrBufH,
+ out_elements - FRAME_LEN);
+ }
+ }
+
+ // Obtain an output frame.
+ WebRtc_ReadBuffer(aecpc->aec->outFrBuf, (void**) &out_ptr,
+ out_tmp, FRAME_LEN);
+ memcpy(&out[FRAME_LEN * i], out_ptr, sizeof(int16_t) * FRAME_LEN);
+ // For H band
+ if (aecpc->sampFreq == 32000) {
+ WebRtc_ReadBuffer(aecpc->aec->outFrBufH, (void**) &out_ptr,
+ out_tmp, FRAME_LEN);
+ memcpy(&outH[FRAME_LEN * i], out_ptr,
+ sizeof(int16_t) * FRAME_LEN);
+ }
+ }
+ }
+
+#ifdef WEBRTC_AEC_DEBUG_DUMP
+ {
+ int16_t far_buf_size_ms = (int16_t) (aecpc->aec->system_delay /
+ (sampMsNb * aecpc->aec->mult));
+ fwrite(&far_buf_size_ms, 2, 1, aecpc->bufFile);
+ fwrite(&(aecpc->knownDelay), sizeof(aecpc->knownDelay), 1, aecpc->delayFile);
+ }
+#endif
+
+ return retVal;
+}
+
+WebRtc_Word32 WebRtcAec_set_config(void *aecInst, AecConfig config)
+{
+ aecpc_t *aecpc = aecInst;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ if (aecpc->initFlag != initCheck) {
+ aecpc->lastError = AEC_UNINITIALIZED_ERROR;
+ return -1;
+ }
+
+ if (config.skewMode != kAecFalse && config.skewMode != kAecTrue) {
+ aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
+ return -1;
+ }
+ aecpc->skewMode = config.skewMode;
+
+ if (config.nlpMode != kAecNlpConservative && config.nlpMode !=
+ kAecNlpModerate && config.nlpMode != kAecNlpAggressive) {
+ aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
+ return -1;
+ }
+ aecpc->nlpMode = config.nlpMode;
+ aecpc->aec->targetSupp = targetSupp[aecpc->nlpMode];
+ aecpc->aec->minOverDrive = minOverDrive[aecpc->nlpMode];
+
+ if (config.metricsMode != kAecFalse && config.metricsMode != kAecTrue) {
+ aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
+ return -1;
+ }
+ aecpc->aec->metricsMode = config.metricsMode;
+ if (aecpc->aec->metricsMode == kAecTrue) {
+ WebRtcAec_InitMetrics(aecpc->aec);
+ }
+
+ if (config.delay_logging != kAecFalse && config.delay_logging != kAecTrue) {
+ aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
+ return -1;
+ }
+ aecpc->aec->delay_logging_enabled = config.delay_logging;
+ if (aecpc->aec->delay_logging_enabled == kAecTrue) {
+ memset(aecpc->aec->delay_histogram, 0, sizeof(aecpc->aec->delay_histogram));
+ }
+
+ return 0;
+}
+
+WebRtc_Word32 WebRtcAec_get_config(void *aecInst, AecConfig *config)
+{
+ aecpc_t *aecpc = aecInst;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ if (config == NULL) {
+ aecpc->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+
+ if (aecpc->initFlag != initCheck) {
+ aecpc->lastError = AEC_UNINITIALIZED_ERROR;
+ return -1;
+ }
+
+ config->nlpMode = aecpc->nlpMode;
+ config->skewMode = aecpc->skewMode;
+ config->metricsMode = aecpc->aec->metricsMode;
+ config->delay_logging = aecpc->aec->delay_logging_enabled;
+
+ return 0;
+}
+
+WebRtc_Word32 WebRtcAec_get_echo_status(void *aecInst, WebRtc_Word16 *status)
+{
+ aecpc_t *aecpc = aecInst;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ if (status == NULL) {
+ aecpc->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+
+ if (aecpc->initFlag != initCheck) {
+ aecpc->lastError = AEC_UNINITIALIZED_ERROR;
+ return -1;
+ }
+
+ *status = aecpc->aec->echoState;
+
+ return 0;
+}
+
+WebRtc_Word32 WebRtcAec_GetMetrics(void *aecInst, AecMetrics *metrics)
+{
+ const float upweight = 0.7f;
+ float dtmp;
+ short stmp;
+ aecpc_t *aecpc = aecInst;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ if (metrics == NULL) {
+ aecpc->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+
+ if (aecpc->initFlag != initCheck) {
+ aecpc->lastError = AEC_UNINITIALIZED_ERROR;
+ return -1;
+ }
+
+ // ERL
+ metrics->erl.instant = (short) aecpc->aec->erl.instant;
+
+ if ((aecpc->aec->erl.himean > offsetLevel) && (aecpc->aec->erl.average > offsetLevel)) {
+ // Use a mix between regular average and upper part average
+ dtmp = upweight * aecpc->aec->erl.himean + (1 - upweight) * aecpc->aec->erl.average;
+ metrics->erl.average = (short) dtmp;
+ }
+ else {
+ metrics->erl.average = offsetLevel;
+ }
+
+ metrics->erl.max = (short) aecpc->aec->erl.max;
+
+ if (aecpc->aec->erl.min < (offsetLevel * (-1))) {
+ metrics->erl.min = (short) aecpc->aec->erl.min;
+ }
+ else {
+ metrics->erl.min = offsetLevel;
+ }
+
+ // ERLE
+ metrics->erle.instant = (short) aecpc->aec->erle.instant;
+
+ if ((aecpc->aec->erle.himean > offsetLevel) && (aecpc->aec->erle.average > offsetLevel)) {
+ // Use a mix between regular average and upper part average
+ dtmp = upweight * aecpc->aec->erle.himean + (1 - upweight) * aecpc->aec->erle.average;
+ metrics->erle.average = (short) dtmp;
+ }
+ else {
+ metrics->erle.average = offsetLevel;
+ }
+
+ metrics->erle.max = (short) aecpc->aec->erle.max;
+
+ if (aecpc->aec->erle.min < (offsetLevel * (-1))) {
+ metrics->erle.min = (short) aecpc->aec->erle.min;
+ } else {
+ metrics->erle.min = offsetLevel;
+ }
+
+ // RERL
+ if ((metrics->erl.average > offsetLevel) && (metrics->erle.average > offsetLevel)) {
+ stmp = metrics->erl.average + metrics->erle.average;
+ }
+ else {
+ stmp = offsetLevel;
+ }
+ metrics->rerl.average = stmp;
+
+ // No other statistics needed, but returned for completeness
+ metrics->rerl.instant = stmp;
+ metrics->rerl.max = stmp;
+ metrics->rerl.min = stmp;
+
+ // A_NLP
+ metrics->aNlp.instant = (short) aecpc->aec->aNlp.instant;
+
+ if ((aecpc->aec->aNlp.himean > offsetLevel) && (aecpc->aec->aNlp.average > offsetLevel)) {
+ // Use a mix between regular average and upper part average
+ dtmp = upweight * aecpc->aec->aNlp.himean + (1 - upweight) * aecpc->aec->aNlp.average;
+ metrics->aNlp.average = (short) dtmp;
+ }
+ else {
+ metrics->aNlp.average = offsetLevel;
+ }
+
+ metrics->aNlp.max = (short) aecpc->aec->aNlp.max;
+
+ if (aecpc->aec->aNlp.min < (offsetLevel * (-1))) {
+ metrics->aNlp.min = (short) aecpc->aec->aNlp.min;
+ }
+ else {
+ metrics->aNlp.min = offsetLevel;
+ }
+
+ return 0;
+}
+
+int WebRtcAec_GetDelayMetrics(void* handle, int* median, int* std) {
+ aecpc_t* self = handle;
+ int i = 0;
+ int delay_values = 0;
+ int num_delay_values = 0;
+ int my_median = 0;
+ const int kMsPerBlock = (PART_LEN * 1000) / self->splitSampFreq;
+ float l1_norm = 0;
+
+ if (self == NULL) {
+ return -1;
+ }
+ if (median == NULL) {
+ self->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+ if (std == NULL) {
+ self->lastError = AEC_NULL_POINTER_ERROR;
+ return -1;
+ }
+ if (self->initFlag != initCheck) {
+ self->lastError = AEC_UNINITIALIZED_ERROR;
+ return -1;
+ }
+ if (self->aec->delay_logging_enabled == 0) {
+ // Logging disabled
+ self->lastError = AEC_UNSUPPORTED_FUNCTION_ERROR;
+ return -1;
+ }
+
+ // Get number of delay values since last update
+ for (i = 0; i < kHistorySizeBlocks; i++) {
+ num_delay_values += self->aec->delay_histogram[i];
+ }
+ if (num_delay_values == 0) {
+ // We have no new delay value data. Even though -1 is a valid estimate, it
+ // will practically never be used since multiples of |kMsPerBlock| will
+ // always be returned.
+ *median = -1;
+ *std = -1;
+ return 0;
+ }
+
+ delay_values = num_delay_values >> 1; // Start value for median count down
+ // Get median of delay values since last update
+ for (i = 0; i < kHistorySizeBlocks; i++) {
+ delay_values -= self->aec->delay_histogram[i];
+ if (delay_values < 0) {
+ my_median = i;
+ break;
+ }
+ }
+ // Account for lookahead.
+ *median = (my_median - kLookaheadBlocks) * kMsPerBlock;
+
+ // Calculate the L1 norm, with median value as central moment
+ for (i = 0; i < kHistorySizeBlocks; i++) {
+ l1_norm += (float) (fabs(i - my_median) * self->aec->delay_histogram[i]);
+ }
+ *std = (int) (l1_norm / (float) num_delay_values + 0.5f) * kMsPerBlock;
+
+ // Reset histogram
+ memset(self->aec->delay_histogram, 0, sizeof(self->aec->delay_histogram));
+
+ return 0;
+}
+
+WebRtc_Word32 WebRtcAec_get_version(WebRtc_Word8 *versionStr, WebRtc_Word16 len)
+{
+ const char version[] = "AEC 2.5.0";
+ const short versionLen = (short)strlen(version) + 1; // +1 for null-termination
+
+ if (versionStr == NULL) {
+ return -1;
+ }
+
+ if (versionLen > len) {
+ return -1;
+ }
+
+ strncpy(versionStr, version, versionLen);
+ return 0;
+}
+
+WebRtc_Word32 WebRtcAec_get_error_code(void *aecInst)
+{
+ aecpc_t *aecpc = aecInst;
+
+ if (aecpc == NULL) {
+ return -1;
+ }
+
+ return aecpc->lastError;
+}
+
+static int EstBufDelay(aecpc_t* aecpc) {
+ int nSampSndCard = aecpc->msInSndCardBuf * sampMsNb * aecpc->aec->mult;
+ int current_delay = nSampSndCard - aecpc->aec->system_delay;
+ int delay_difference = 0;
+
+ // Before we proceed with the delay estimate filtering we:
+ // 1) Compensate for the frame that will be read.
+ // 2) Compensate for drift resampling.
+
+ // 1) Compensating for the frame(s) that will be read/processed.
+ current_delay += FRAME_LEN * aecpc->aec->mult;
+
+ // 2) Account for resampling frame delay.
+ if (aecpc->skewMode == kAecTrue && aecpc->resample == kAecTrue) {
+ current_delay -= kResamplingDelay;
+ }
+
+ aecpc->filtDelay = WEBRTC_SPL_MAX(0, (short) (0.8 * aecpc->filtDelay +
+ 0.2 * current_delay));
+
+ delay_difference = aecpc->filtDelay - aecpc->knownDelay;
+ if (delay_difference > 224) {
+ if (aecpc->lastDelayDiff < 96) {
+ aecpc->timeForDelayChange = 0;
+ } else {
+ aecpc->timeForDelayChange++;
+ }
+ } else if (delay_difference < 96 && aecpc->knownDelay > 0) {
+ if (aecpc->lastDelayDiff > 224) {
+ aecpc->timeForDelayChange = 0;
+ } else {
+ aecpc->timeForDelayChange++;
+ }
+ } else {
+ aecpc->timeForDelayChange = 0;
+ }
+ aecpc->lastDelayDiff = delay_difference;
+
+ if (aecpc->timeForDelayChange > 25) {
+ aecpc->knownDelay = WEBRTC_SPL_MAX((int) aecpc->filtDelay - 160, 0);
+ }
+
+ return 0;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-06 02:36:55 +0000