Added diagnostic AEC debug logpoints.

webrtc/modules/audio_processing/aec/aec_core.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 809 matching lines @@
 static int SignalBasedDelayCorrection(AecCore* self) {
   int delay_correction = 0;
   int last_delay = -2;
   assert(self != NULL);
 #if !defined(WEBRTC_ANDROID)
   // On desktops, turn on correction after |kDelayCorrectionStart| frames.  This
   // is to let the delay estimation get a chance to converge.  Also, if the
   // playout audio volume is low (or even muted) the delay estimation can return
   // a very large delay, which will break the AEC if it is applied.
   if (self->frame_count < kDelayCorrectionStart) {
+    self->data_dumper->DumpRaw("aec_da_reported_delay", 1, &last_delay);
     return 0;
   }
 #endif
 
   // 1. Check for non-negative delay estimate.  Note that the estimates we get
   //    from the delay estimation are not compensated for lookahead.  Hence, a
   //    negative |last_delay| is an invalid one.
   // 2. Verify that there is a delay change.  In addition, only allow a change
   //    if the delay is outside a certain region taking the AEC filter length
   //    into account.
   // TODO(bjornv): Investigate if we can remove the non-zero delay change check.
   // 3. Only allow delay correction if the delay estimation quality exceeds
   //    |delay_quality_threshold|.
   // 4. Finally, verify that the proposed |delay_correction| is feasible by
   //    comparing with the size of the far-end buffer.
   last_delay = WebRtc_last_delay(self->delay_estimator);
+  self->data_dumper->DumpRaw("aec_da_reported_delay", 1, &last_delay);
   if ((last_delay >= 0) && (last_delay != self->previous_delay) &&
       (WebRtc_last_delay_quality(self->delay_estimator) >
        self->delay_quality_threshold)) {
     int delay = last_delay - WebRtc_lookahead(self->delay_estimator);
     // Allow for a slack in the actual delay, defined by a |lower_bound| and an
     // |upper_bound|.  The adaptive echo cancellation filter is currently
     // |num_partitions| (of 64 samples) long.  If the delay estimate is negative
     // or at least 3/4 of the filter length we open up for correction.
     const int lower_bound = 0;
     const int upper_bound = self->num_partitions * 3 / 4;
@@ skipping 25 matching lines @@
   if (self->delay_correction_count > 0) {
     float delay_quality = WebRtc_last_delay_quality(self->delay_estimator);
     delay_quality =
         (delay_quality > kDelayQualityThresholdMax ? kDelayQualityThresholdMax
                                                    : delay_quality);
     self->delay_quality_threshold =
         (delay_quality > self->delay_quality_threshold
              ? delay_quality
              : self->delay_quality_threshold);
   }
+  self->data_dumper->DumpRaw("aec_da_delay_correction", 1, &delay_correction);
+
   return delay_correction;
 }
 
 static void RegressorPower(int num_partitions,
                            int latest_added_partition,
                            float x_fft_buf[2]
                                           [kExtendedNumPartitions * PART_LEN1],
                            float x_pow[PART_LEN1]) {
   RTC_DCHECK_LT(latest_added_partition, num_partitions);
   memset(x_pow, 0, PART_LEN1 * sizeof(x_pow[0]));
@@ skipping 246 matching lines @@
 
   // Buffer far.
   memcpy(aec->xfwBuf, xfw_ptr, sizeof(float) * 2 * PART_LEN1);
 
   aec->delayEstCtr++;
   if (aec->delayEstCtr == delayEstInterval) {
     aec->delayEstCtr = 0;
     aec->delayIdx = WebRtcAec_PartitionDelay(aec->num_partitions, aec->wfBuf);
   }
 
+  aec->data_dumper->DumpRaw("aec_nlp_delay", 1, &aec->delayIdx);
+
   // Use delayed far.
   memcpy(xfw, aec->xfwBuf + aec->delayIdx * PART_LEN1,
          sizeof(xfw[0][0]) * 2 * PART_LEN1);
 
   WebRtcAec_UpdateCoherenceSpectra(aec->mult, aec->extended_filter_enabled == 1,
                                    efw, dfw, xfw, &aec->coherence_state,
                                    &aec->divergeState,
                                    &aec->extreme_filter_divergence);
 
   WebRtcAec_ComputeCoherence(&aec->coherence_state, cohde, cohxd);
 
   // Select the microphone signal as output if the filter is deemed to have
   // diverged.
   if (aec->divergeState) {
     memcpy(efw, dfw, sizeof(efw[0][0]) * 2 * PART_LEN1);
   }
 
   FormSuppressionGain(aec, cohde, cohxd, hNl);
 
+  aec->data_dumper->DumpRaw("aec_nlp_gain", PART_LEN1, hNl);
+
   WebRtcAec_Suppress(hNl, efw);
 
   // Add comfort noise.
   ComfortNoise(aec->num_bands > 1, &aec->seed, efw, comfortNoiseHband,
                aec->noisePow, hNl);
 
   // Inverse error fft.
   ScaledInverseFft(efw, fft, 2.0f, 1);
 
   // Overlap and add to obtain output.
@@ skipping 195 matching lines @@
       }
     }
   }
 
   // Perform echo subtraction.
   EchoSubtraction(aec->num_partitions, aec->extended_filter_enabled,
                   &aec->extreme_filter_divergence, aec->filter_step_size,
                   aec->error_threshold, &x_fft[0][0], &aec->xfBufBlockPos,
                   aec->xfBuf, nearend_ptr, aec->xPow, aec->wfBuf,
                   echo_subtractor_output);
+  aec->data_dumper->DumpRaw("aec_h_fft", PART_LEN1 * aec->num_partitions,
+                            &aec->wfBuf[0][0]);
+  aec->data_dumper->DumpRaw("aec_h_fft", PART_LEN1 * aec->num_partitions,
+                            &aec->wfBuf[1][0]);
 
   aec->data_dumper->DumpWav("aec_out_linear", PART_LEN, echo_subtractor_output,
                             std::min(aec->sampFreq, 16000), 1);
 
   if (aec->metricsMode == 1) {
     UpdateLevel(&aec->linoutlevel,
                 CalculatePower(echo_subtractor_output, PART_LEN));
   }
 
   // Perform echo suppression.
@@ skipping 568 matching lines @@
 
 int WebRtcAec_system_delay(AecCore* self) {
   return self->system_delay;
 }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }
 }  // namespace webrtc