Refactoring of the farend buffering scheme inside the AEC

webrtc/modules/audio_processing/aec/echo_cancellation.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 278 matching lines @@
     farend_ptr = new_farend;
   }
 
   aecpc->farend_started = 1;
   WebRtcAec_SetSystemDelay(aecpc->aec, WebRtcAec_system_delay(aecpc->aec) +
                            static_cast<int>(newNrOfSamples));
 
   // Write the time-domain data to |far_pre_buf|.
   WebRtc_WriteBuffer(aecpc->far_pre_buf, farend_ptr, newNrOfSamples);
 
-  // TODO(minyue): reduce to |PART_LEN| samples for each buffering, when
-  // WebRtcAec_BufferFarendPartition() is changed to take |PART_LEN| samples.
+  // TODO(minyue): reduce to |PART_LEN| samples for each buffering.
   while (WebRtc_available_read(aecpc->far_pre_buf) >= PART_LEN2) {
     // We have enough data to pass to the FFT, hence read PART_LEN2 samples.
     {
       float* ptmp = NULL;
       float tmp[PART_LEN2];
       WebRtc_ReadBuffer(aecpc->far_pre_buf,
                         reinterpret_cast<void**>(&ptmp), tmp, PART_LEN2);
-      WebRtcAec_BufferFarendPartition(aecpc->aec, ptmp);
+      WebRtcAec_BufferFarendBlock(aecpc->aec, &ptmp[PART_LEN]);
     }
 
     // Rewind |far_pre_buf| PART_LEN samples for overlap before continuing.
     WebRtc_MoveReadPtr(aecpc->far_pre_buf, -PART_LEN);
   }
 
   return 0;
 }
 
 int32_t WebRtcAec_Process(void* aecInst,
@@ skipping 327 matching lines @@
           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);
+        WebRtcAec_AdjustFarendBufferSizeAndSystemDelay(aecpc->aec,
+                                                       overhead_elements);
 
         // Enable the AEC
         aecpc->startup_phase = 0;
       }
     }
   } else {
     // AEC is enabled.
     EstBufDelayNormal(aecpc);
 
     // Call the AEC.
@@ skipping 56 matching lines @@
 #if defined(WEBRTC_ANDROID)
     int target_delay = startup_size_ms * self->rate_factor * 8;
 #else
     // To avoid putting the AEC in a non-causal state we're being slightly
     // conservative and scale by 2. On Android we use a fixed delay and
     // therefore there is no need to scale the target_delay.
     int target_delay = startup_size_ms * self->rate_factor * 8 / 2;
 #endif
     int overhead_elements =
         (WebRtcAec_system_delay(self->aec) - target_delay) / PART_LEN;
-    WebRtcAec_MoveFarReadPtr(self->aec, overhead_elements);
+    WebRtcAec_AdjustFarendBufferSizeAndSystemDelay(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 =
@@ skipping 18 matching lines @@
   // 1) Compensating for the frame(s) that will be read/processed.
   current_delay += FRAME_LEN * aecpc->rate_factor;
 
   // 2) Account for resampling frame delay.
   if (aecpc->skewMode == kAecTrue && aecpc->resample == kAecTrue) {
     current_delay -= kResamplingDelay;
   }
 
   // 3) Compensate for non-causality, if needed, by flushing one block.
   if (current_delay < PART_LEN) {
-    current_delay += WebRtcAec_MoveFarReadPtr(aecpc->aec, 1) * PART_LEN;
+    current_delay +=
+        WebRtcAec_AdjustFarendBufferSizeAndSystemDelay(aecpc->aec, 1) *
+        PART_LEN;
   }
 
   // We use -1 to signal an initialized state in the "extended" implementation;
   // compensate for that.
   aecpc->filtDelay = aecpc->filtDelay < 0 ? 0 : aecpc->filtDelay;
   aecpc->filtDelay =
       WEBRTC_SPL_MAX(0, static_cast<int16_t>(0.8 *
                                              aecpc->filtDelay +
                                              0.2 * current_delay));
 
@@ skipping 34 matching lines @@
   // 1) Compensating for the frame(s) that will be read/processed.
   current_delay += FRAME_LEN * self->rate_factor;
 
   // 2) Account for resampling frame delay.
   if (self->skewMode == kAecTrue && self->resample == kAecTrue) {
     current_delay -= kResamplingDelay;
   }
 
   // 3) Compensate for non-causality, if needed, by flushing two blocks.
   if (current_delay < PART_LEN) {
-    current_delay += WebRtcAec_MoveFarReadPtr(self->aec, 2) * PART_LEN;
+    current_delay +=
+        WebRtcAec_AdjustFarendBufferSizeAndSystemDelay(self->aec, 2) * PART_LEN;
   }
 
   if (self->filtDelay == -1) {
     self->filtDelay = WEBRTC_SPL_MAX(0, 0.5 * current_delay);
   } else {
     self->filtDelay = WEBRTC_SPL_MAX(
         0, static_cast<int16_t>(0.95 * self->filtDelay + 0.05 * current_delay));
   }
 
   delay_difference = self->filtDelay - self->knownDelay;
@@ skipping 12 matching lines @@
   } else {
     self->timeForDelayChange = 0;
   }
   self->lastDelayDiff = delay_difference;
 
   if (self->timeForDelayChange > 25) {
     self->knownDelay = WEBRTC_SPL_MAX((int)self->filtDelay - 256, 0);
   }
 }
 }  // namespace webrtc