Replaced the wav file dumping functionality in aec_core.c with the newly added corresponding macros

webrtc/modules/audio_processing/aec/aec_core.c

 /*
  *  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 14 matching lines @@
 #include <string.h>
 
 #include "webrtc/common_audio/ring_buffer.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/aec/aec_common.h"
 #include "webrtc/modules/audio_processing/aec/aec_core_internal.h"
 #include "webrtc/modules/audio_processing/aec/aec_rdft.h"
 #include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h"
 #include "webrtc/system_wrappers/interface/cpu_features_wrapper.h"
 #include "webrtc/typedefs.h"
+#include "webrtc/modules/audio_processing/logging/aec_logging.h"
 
 // Buffer size (samples)
 static const size_t kBufSizePartitions = 250;  // 1 second of audio in 16 kHz.
 
 // Metrics
 static const int subCountLen = 4;
 static const int countLen = 50;
 static const int kDelayMetricsAggregationWindow = 1250;  // 5 seconds at 16 kHz.
 
 // Quantities to control H band scaling for SWB input
@@ skipping 1167 matching lines @@
   WebRtc_ReadBuffer(aec->nearFrBuf, (void**)&nearend_ptr, nearend, PART_LEN);
   memcpy(aec->dBuf + PART_LEN, nearend_ptr, sizeof(nearend));
 
   // ---------- Ooura fft ----------
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   {
     float farend[PART_LEN];
     float* farend_ptr = NULL;
     WebRtc_ReadBuffer(aec->far_time_buf, (void**)&farend_ptr, farend, 1);
-    rtc_WavWriteSamples(aec->farFile, farend_ptr, PART_LEN);
-    rtc_WavWriteSamples(aec->nearFile, nearend_ptr, PART_LEN);
+    WEBRTC_AEC_DEBUG_WAV_WRITE(aec->farFile, farend_ptr, PART_LEN);
+    WEBRTC_AEC_DEBUG_WAV_WRITE(aec->nearFile, nearend_ptr, PART_LEN);
   }
 #endif
 
   // We should always have at least one element stored in |far_buf|.
   assert(WebRtc_available_read(aec->far_buf) > 0);
   WebRtc_ReadBuffer(aec->far_buf, (void**)&xf_ptr, &xf[0][0], 1);
 
   // Near fft
   memcpy(fft, aec->dBuf, sizeof(float) * PART_LEN2);
   TimeToFrequency(fft, df, 0);
@@ skipping 106 matching lines @@
 
   ef[1][0] = 0;
   ef[1][PART_LEN] = 0;
   ef[0][0] = fft[0];
   ef[0][PART_LEN] = fft[1];
   for (i = 1; i < PART_LEN; i++) {
     ef[0][i] = fft[2 * i];
     ef[1][i] = fft[2 * i + 1];
   }
 
+  WEBRTC_AEC_DEBUG_RAW_WRITE(aec->e_fft_file,
+                             &ef[0][0],
+                             sizeof(ef[0][0]) * PART_LEN1 * 2);
+
   if (aec->metricsMode == 1) {
     // Note that the first PART_LEN samples in fft (before transformation) are
     // zero. Hence, the scaling by two in UpdateLevel() should not be
     // performed. That scaling is taken care of in UpdateMetrics() instead.
     UpdateLevel(&aec->linoutlevel, ef);
   }
 
   // Scale error signal inversely with far power.
   WebRtcAec_ScaleErrorSignal(aec, ef);
   WebRtcAec_FilterAdaptation(aec, fft, ef);
   NonLinearProcessing(aec, output, outputH_ptr);
 
   if (aec->metricsMode == 1) {
     // Update power levels and echo metrics
     UpdateLevel(&aec->farlevel, (float(*)[PART_LEN1])xf_ptr);
     UpdateLevel(&aec->nearlevel, df);
     UpdateMetrics(aec);
   }
 
   // Store the output block.
   WebRtc_WriteBuffer(aec->outFrBuf, output, PART_LEN);
   // For high bands
   for (i = 0; i < aec->num_bands - 1; ++i) {
     WebRtc_WriteBuffer(aec->outFrBufH[i], outputH[i], PART_LEN);
   }
 
-#ifdef WEBRTC_AEC_DEBUG_DUMP
-  rtc_WavWriteSamples(aec->outLinearFile, e, PART_LEN);
-  rtc_WavWriteSamples(aec->outFile, output, PART_LEN);
-#endif
+  WEBRTC_AEC_DEBUG_WAV_WRITE(aec->outLinearFile, e, PART_LEN);
+  WEBRTC_AEC_DEBUG_WAV_WRITE(aec->outFile, output, PART_LEN);
 }
 
 AecCore* WebRtcAec_CreateAec() {
   int i;
   AecCore* aec = malloc(sizeof(AecCore));
   if (!aec) {
     return NULL;
   }
 
   aec->nearFrBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN, sizeof(float));
@@ skipping 114 matching lines @@
 
   for (i = 0; i < NUM_HIGH_BANDS_MAX; ++i) {
     WebRtc_FreeBuffer(aec->nearFrBufH[i]);
     WebRtc_FreeBuffer(aec->outFrBufH[i]);
   }
 
   WebRtc_FreeBuffer(aec->far_buf);
   WebRtc_FreeBuffer(aec->far_buf_windowed);
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   WebRtc_FreeBuffer(aec->far_time_buf);
-  rtc_WavClose(aec->farFile);
-  rtc_WavClose(aec->nearFile);
-  rtc_WavClose(aec->outFile);
-  rtc_WavClose(aec->outLinearFile);
 #endif
+  WEBRTC_AEC_DEBUG_WAV_CLOSE(aec->farFile);
+  WEBRTC_AEC_DEBUG_WAV_CLOSE(aec->nearFile);
+  WEBRTC_AEC_DEBUG_WAV_CLOSE(aec->outFile);
+  WEBRTC_AEC_DEBUG_WAV_CLOSE(aec->outLinearFile);
+  WEBRTC_AEC_DEBUG_RAW_CLOSE(aec->e_fft_file);
+
   WebRtc_FreeDelayEstimator(aec->delay_estimator);
   WebRtc_FreeDelayEstimatorFarend(aec->delay_estimator_farend);
 
   free(aec);
 }
 
-#ifdef WEBRTC_AEC_DEBUG_DUMP
-// Open a new Wav file for writing. If it was already open with a different
-// sample frequency, close it first.
-static void ReopenWav(rtc_WavWriter** wav_file,
-                      const char* name,
-                      int seq1,
-                      int seq2,
-                      int sample_rate) {
-  int written ATTRIBUTE_UNUSED;
-  char filename[64];
-  if (*wav_file) {
-    if (rtc_WavSampleRate(*wav_file) == sample_rate)
-      return;
-    rtc_WavClose(*wav_file);
-  }
-  written = snprintf(filename, sizeof(filename), "%s%d-%d.wav",
-                     name, seq1, seq2);
-  assert(written >= 0);  // no output error
-  assert((size_t)written < sizeof(filename));  // buffer was large enough
-  *wav_file = rtc_WavOpen(filename, sample_rate, 1);
-}
-#endif  // WEBRTC_AEC_DEBUG_DUMP
-
 int WebRtcAec_InitAec(AecCore* aec, int sampFreq) {
   int i;
 
   aec->sampFreq = sampFreq;
 
   if (sampFreq == 8000) {
     aec->normal_mu = 0.6f;
     aec->normal_error_threshold = 2e-6f;
     aec->num_bands = 1;
   } else {
     aec->normal_mu = 0.5f;
     aec->normal_error_threshold = 1.5e-6f;
     aec->num_bands = sampFreq / 16000;
   }
 
   WebRtc_InitBuffer(aec->nearFrBuf);
   WebRtc_InitBuffer(aec->outFrBuf);
   for (i = 0; i < NUM_HIGH_BANDS_MAX; ++i) {
     WebRtc_InitBuffer(aec->nearFrBufH[i]);
     WebRtc_InitBuffer(aec->outFrBufH[i]);
   }
 
   // Initialize far-end buffers.
   WebRtc_InitBuffer(aec->far_buf);
   WebRtc_InitBuffer(aec->far_buf_windowed);
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   WebRtc_InitBuffer(aec->far_time_buf);
   {
     int process_rate = sampFreq > 16000 ? 16000 : sampFreq;
-    ReopenWav(&aec->farFile, "aec_far",
+    WEBRTC_AEC_DEBUG_WAV_REOPEN(&aec->farFile, "aec_far",
               aec->instance_index, aec->debug_dump_count, process_rate);
-    ReopenWav(&aec->nearFile, "aec_near",
+    WEBRTC_AEC_DEBUG_WAV_REOPEN(&aec->nearFile, "aec_near",
               aec->instance_index, aec->debug_dump_count, process_rate);
-    ReopenWav(&aec->outFile, "aec_out",
+    WEBRTC_AEC_DEBUG_WAV_REOPEN(&aec->outFile, "aec_out",
               aec->instance_index, aec->debug_dump_count, process_rate);
-    ReopenWav(&aec->outLinearFile, "aec_out_linear",
+    WEBRTC_AEC_DEBUG_WAV_REOPEN(&aec->outLinearFile, "aec_out_linear",
               aec->instance_index, aec->debug_dump_count, process_rate);
   }
+
+  WEBRTC_AEC_DEBUG_RAW_OPEN(&aec->e_fft_file,
+                            "aec_eFFT",
+                            aec->debug_dump_count);
+
   ++aec->debug_dump_count;
 #endif
   aec->system_delay = 0;
 
   if (WebRtc_InitDelayEstimatorFarend(aec->delay_estimator_farend) != 0) {
     return -1;
   }
   if (WebRtc_InitDelayEstimator(aec->delay_estimator) != 0) {
     return -1;
   }
@@ skipping 328 matching lines @@
 int WebRtcAec_extended_filter_enabled(AecCore* self) {
   return self->extended_filter_enabled;
 }
 
 int WebRtcAec_system_delay(AecCore* self) { return self->system_delay; }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }