int32_t 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). aecpc->far_pre_buf = WebRtc_CreateBuffer(PART_LEN2 + kResamplerBufferSize, sizeof(float)); if (!aecpc->far_pre_buf) { WebRtcAec_Free(aecpc); aecpc = NULL; return -1; } aecpc->initFlag = 0; aecpc->lastError = 0; #ifdef WEBRTC_AEC_DEBUG_DUMP aecpc->far_pre_buf_s16 = WebRtc_CreateBuffer(PART_LEN2 + kResamplerBufferSize, sizeof(int16_t)); if (!aecpc->far_pre_buf_s16) { WebRtcAec_Free(aecpc); aecpc = NULL; return -1; } aecpc->bufFile = aecpc->skewFile = aecpc->delayFile = NULL; OpenDebugFiles(aecpc, &webrtc_aec_instance_count); #endif return 0; }
void* WebRtcAec_Create() { Aec* aecpc = malloc(sizeof(Aec)); if (!aecpc) { return NULL; } aecpc->aec = WebRtcAec_CreateAec(); if (!aecpc->aec) { WebRtcAec_Free(aecpc); return NULL; } aecpc->resampler = WebRtcAec_CreateResampler(); if (!aecpc->resampler) { WebRtcAec_Free(aecpc); return NULL; } // 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). aecpc->far_pre_buf = WebRtc_CreateBuffer(PART_LEN2 + kResamplerBufferSize, sizeof(float)); if (!aecpc->far_pre_buf) { WebRtcAec_Free(aecpc); return NULL; } aecpc->initFlag = 0; #ifdef WEBRTC_AEC_DEBUG_DUMP aecpc->bufFile = aecpc->skewFile = aecpc->delayFile = NULL; OpenDebugFiles(aecpc, &webrtc_aec_instance_count); #endif return aecpc; }
static int ProcessNormal(aecpc_t* aecpc, const int16_t* nearend, const int16_t* nearendH, int16_t* out, int16_t* outH, int16_t nrOfSamples, int16_t msInSndCardBuf, int32_t skew) { int 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; msInSndCardBuf = msInSndCardBuf > kMaxTrustedDelayMs ? kMaxTrustedDelayMs : msInSndCardBuf; // 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 OpenDebugFiles(aecpc, &webrtc_aec_instance_count); if (aecpc->skewFile) { (void)fwrite(&aecpc->skew, sizeof(aecpc->skew), 1, aecpc->skewFile); } #endif } } nFrames = nrOfSamples / FRAME_LEN; nBlocks10ms = nFrames / aecpc->rate_factor; if (aecpc->startup_phase) { // Only needed if they don't already point to the same place. if (nearend != out) { memcpy(out, nearend, sizeof(short) * nrOfSamples); } if (nearendH != outH) { memcpy(outH, nearendH, 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->rate_factor * 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->rate_factor * 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 = WebRtcAec_system_delay(aecpc->aec) / PART_LEN - aecpc->bufSizeStart; if (overhead_elements == 0) { // Enable the AEC aecpc->startup_phase = 0; } else if (overhead_elements > 0) { // 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. WebRtcAec_MoveFarReadPtr(aecpc->aec, overhead_elements); // Enable the AEC aecpc->startup_phase = 0; } } } else { // AEC is enabled. EstBufDelayNormal(aecpc); // Note that 1 frame is supported for NB and 2 frames for WB. for (i = 0; i < nFrames; i++) { // Call the AEC. WebRtcAec_ProcessFrame(aecpc->aec, &nearend[FRAME_LEN * i], &nearendH[FRAME_LEN * i], aecpc->knownDelay, &out[FRAME_LEN * i], &outH[FRAME_LEN * i]); // TODO(bjornv): Re-structure such that we don't have to pass // |aecpc->knownDelay| as input. Change name to something like // |system_buffer_diff|. } } return retVal; }
int32_t WebRtcAec_Process(void* aecInst, const int16_t* nearend, const int16_t* nearendH, int16_t* out, int16_t* outH, int16_t nrOfSamples, int16_t msInSndCardBuf, int32_t skew) { aecpc_t* aecpc = aecInst; int32_t retVal = 0; 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 > kMaxTrustedDelayMs) { // The clamping is now done in ProcessExtended/Normal(). aecpc->lastError = AEC_BAD_PARAMETER_WARNING; retVal = -1; } // This returns the value of aec->extended_filter_enabled. if (WebRtcAec_delay_correction_enabled(aecpc->aec)) { ProcessExtended( aecpc, nearend, nearendH, out, outH, nrOfSamples, msInSndCardBuf, skew); } else { if (ProcessNormal(aecpc, nearend, nearendH, out, outH, nrOfSamples, msInSndCardBuf, skew) != 0) { retVal = -1; } } #ifdef WEBRTC_AEC_DEBUG_DUMP { int16_t far_buf_size_ms = (int16_t)(WebRtcAec_system_delay(aecpc->aec) / (sampMsNb * aecpc->rate_factor)); OpenDebugFiles(aecpc, &webrtc_aec_instance_count); if (aecpc->bufFile) { (void)fwrite(&far_buf_size_ms, 2, 1, aecpc->bufFile); (void)fwrite( &aecpc->knownDelay, sizeof(aecpc->knownDelay), 1, aecpc->delayFile); } } #endif return retVal; }
int32_t WebRtcAec_Process(void* aecInst, const float* const* nearend, size_t num_bands, float* const* out, size_t nrOfSamples, int16_t msInSndCardBuf, int32_t skew) { Aec* aecpc = aecInst; int32_t retVal = 0; if (out == NULL) { return AEC_NULL_POINTER_ERROR; } if (aecpc->initFlag != initCheck) { return AEC_UNINITIALIZED_ERROR; } // number of samples == 160 for SWB input if (nrOfSamples != 80 && nrOfSamples != 160) { return AEC_BAD_PARAMETER_ERROR; } if (msInSndCardBuf < 0) { msInSndCardBuf = 0; retVal = AEC_BAD_PARAMETER_WARNING; } else if (msInSndCardBuf > kMaxTrustedDelayMs) { // The clamping is now done in ProcessExtended/Normal(). retVal = AEC_BAD_PARAMETER_WARNING; } // This returns the value of aec->extended_filter_enabled. if (WebRtcAec_extended_filter_enabled(aecpc->aec)) { ProcessExtended(aecpc, nearend, num_bands, out, nrOfSamples, msInSndCardBuf, skew); } else { retVal = ProcessNormal(aecpc, nearend, num_bands, out, nrOfSamples, msInSndCardBuf, skew); } #ifdef WEBRTC_AEC_DEBUG_DUMP { int16_t far_buf_size_ms = (int16_t)(WebRtcAec_system_delay(aecpc->aec) / (sampMsNb * aecpc->rate_factor)); OpenDebugFiles(aecpc, &webrtc_aec_instance_count); if (aecpc->bufFile) { (void)fwrite(&far_buf_size_ms, 2, 1, aecpc->bufFile); (void)fwrite( &aecpc->knownDelay, sizeof(aecpc->knownDelay), 1, aecpc->delayFile); } } #endif return retVal; }