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; 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 (void)fwrite(&aecpc->skew, sizeof(aecpc->skew), 1, aecpc->skewFile); #endif } } nFrames = nrOfSamples / FRAME_LEN; nBlocks10ms = nFrames / aecpc->rate_factor; 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->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->ECstartup = 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->ECstartup = 0; } } } else { // AEC is enabled. EstBufDelay(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|. } } #ifdef WEBRTC_AEC_DEBUG_DUMP { int16_t far_buf_size_ms = (int16_t)(WebRtcAec_system_delay(aecpc->aec) / (sampMsNb * aecpc->rate_factor)); (void)fwrite(&far_buf_size_ms, 2, 1, aecpc->bufFile); (void)fwrite(&aecpc->knownDelay, sizeof(aecpc->knownDelay), 1, aecpc->delayFile); } #endif return retVal; }
static void ProcessExtended(aecpc_t* self, const int16_t* near, const int16_t* near_high, int16_t* out, int16_t* out_high, int16_t num_samples, int16_t reported_delay_ms, int32_t skew) { int i; const int num_frames = num_samples / FRAME_LEN; #if defined(WEBRTC_UNTRUSTED_DELAY) const int delay_diff_offset = kDelayDiffOffsetSamples; reported_delay_ms = kFixedDelayMs; #else // This is the usual mode where we trust the reported system delay values. const int delay_diff_offset = 0; // Due to the longer filter, we no longer add 10 ms to the reported delay // to reduce chance of non-causality. Instead we apply a minimum here to avoid // issues with the read pointer jumping around needlessly. reported_delay_ms = reported_delay_ms < kMinTrustedDelayMs ? kMinTrustedDelayMs : reported_delay_ms; // If the reported delay appears to be bogus, we attempt to recover by using // the measured fixed delay values. We use >= here because higher layers // may already clamp to this maximum value, and we would otherwise not // detect it here. reported_delay_ms = reported_delay_ms >= kMaxTrustedDelayMs ? kFixedDelayMs : reported_delay_ms; #endif self->msInSndCardBuf = reported_delay_ms; if (!self->farend_started) { // Only needed if they don't already point to the same place. if (near != out) { memcpy(out, near, sizeof(short) * num_samples); } if (near_high != out_high) { memcpy(out_high, near_high, sizeof(short) * num_samples); } return; } if (self->startup_phase) { // In the extended mode, there isn't a startup "phase", just a special // action on the first frame. In the trusted delay case, we'll take the // current reported delay, unless it's less then our conservative // measurement. int startup_size_ms = reported_delay_ms < kFixedDelayMs ? kFixedDelayMs : reported_delay_ms; int overhead_elements = (WebRtcAec_system_delay(self->aec) - startup_size_ms / 2 * self->rate_factor * 8) / PART_LEN; WebRtcAec_MoveFarReadPtr(self->aec, overhead_elements); self->startup_phase = 0; } EstBufDelayExtended(self); { // |delay_diff_offset| gives us the option to manually rewind the delay on // very low delay platforms which can't be expressed purely through // |reported_delay_ms|. const int adjusted_known_delay = WEBRTC_SPL_MAX(0, self->knownDelay + delay_diff_offset); for (i = 0; i < num_frames; ++i) { WebRtcAec_ProcessFrame(self->aec, &near[FRAME_LEN * i], &near_high[FRAME_LEN * i], adjusted_known_delay, &out[FRAME_LEN * i], &out_high[FRAME_LEN * i]); } } }