Replaced the data logging functionality in the AEC with a generic logging functionality

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.
  */
 
 /*
  * Contains the API functions for the AEC.
  */
 #include "webrtc/modules/audio_processing/aec/echo_cancellation.h"
 
 #include <math.h>
-#ifdef WEBRTC_AEC_DEBUG_DUMP
+#if WEBRTC_AEC_DEBUG_DUMP == 1
 #include <stdio.h>
 #endif
 #include <stdlib.h>
 #include <string.h>
 
 extern "C" {
 #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_core.h"
 #include "webrtc/modules/audio_processing/aec/aec_resampler.h"
 #include "webrtc/modules/audio_processing/aec/echo_cancellation_internal.h"
 #include "webrtc/typedefs.h"
 
+// Check to verify that the define is properly set.
+#if !defined(WEBRTC_AEC_DEBUG_DUMP) || \
+    (WEBRTC_AEC_DEBUG_DUMP != 0 && WEBRTC_AEC_DEBUG_DUMP != 1)
+#error "Set WEBRTC_AEC_DEBUG_DUMP to either 0 or 1"
+#endif
+
 namespace webrtc {
 
 // Measured delays [ms]
 // Device                Chrome  GTP
 // MacBook Air           10
 // MacBook Retina        10      100
 // MacPro                30?
 //
 // Win7 Desktop          70      80?
 // Win7 T430s            110
@@ skipping 50 matching lines @@
 // Maximum length of resampled signal. Must be an integer multiple of frames
 // (ceil(1/(1 + MIN_SKEW)*2) + 1)*FRAME_LEN
 // The factor of 2 handles wb, and the + 1 is as a safety margin
 // TODO(bjornv): Replace with kResamplerBufferSize
 #define MAX_RESAMP_LEN (5 * FRAME_LEN)
 
 static const int kMaxBufSizeStart = 62;  // In partitions
 static const int sampMsNb = 8;           // samples per ms in nb
 static const int initCheck = 42;
 
-#ifdef WEBRTC_AEC_DEBUG_DUMP
-int webrtc_aec_instance_count = 0;
-#endif
+int Aec::instance_count = 0;
 
 // Estimates delay to set the position of the far-end buffer read pointer
 // (controlled by knownDelay)
 static void EstBufDelayNormal(Aec* aecInst);
 static void EstBufDelayExtended(Aec* aecInst);
 static int ProcessNormal(Aec* self,
                          const float* const* near,
                          size_t num_bands,
                          float* const* out,
                          size_t num_samples,
                          int16_t reported_delay_ms,
                          int32_t skew);
 static void ProcessExtended(Aec* self,
                             const float* const* near,
                             size_t num_bands,
                             float* const* out,
                             size_t num_samples,
                             int16_t reported_delay_ms,
                             int32_t skew);
 
 void* WebRtcAec_Create() {
   Aec* aecpc = reinterpret_cast<Aec*>(malloc(sizeof(Aec)));
 
   if (!aecpc) {
     return NULL;
   }
 
-  aecpc->aec = WebRtcAec_CreateAec();
+  aecpc->aec = WebRtcAec_CreateAec(aecpc->instance_count);
   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
-  {
-    char filename[64];
-    snprintf(filename, sizeof(filename), "aec_buf%d.dat",
-             webrtc_aec_instance_count);
-    aecpc->bufFile = fopen(filename, "wb");
-    snprintf(filename, sizeof(filename), "aec_skew%d.dat",
-             webrtc_aec_instance_count);
-    aecpc->skewFile = fopen(filename, "wb");
-    snprintf(filename, sizeof(filename), "aec_delay%d.dat",
-             webrtc_aec_instance_count);
-    aecpc->delayFile = fopen(filename, "wb");
-    webrtc_aec_instance_count++;
-  }
+#if WEBRTC_AEC_DEBUG_DUMP == 1
+  char filename[64];
+  snprintf(filename, sizeof(filename), "aec_buf%d.dat", aecpc->instance_count);
+  aecpc->bufFile = fopen(filename, "wb");
+  snprintf(filename, sizeof(filename), "aec_skew%d.dat", aecpc->instance_count);
+  aecpc->skewFile = fopen(filename, "wb");
+  snprintf(filename, sizeof(filename), "aec_delay%d.dat",
+           aecpc->instance_count);
+  aecpc->delayFile = fopen(filename, "wb");
 #endif
+  aecpc->instance_count++;
 
   return aecpc;
 }
 
 void WebRtcAec_Free(void* aecInst) {
   Aec* aecpc = reinterpret_cast<Aec*>(aecInst);
 
   if (aecpc == NULL) {
     return;
   }
 
   WebRtc_FreeBuffer(aecpc->far_pre_buf);
 
-#ifdef WEBRTC_AEC_DEBUG_DUMP
+#if WEBRTC_AEC_DEBUG_DUMP == 1
   fclose(aecpc->bufFile);
   fclose(aecpc->skewFile);
   fclose(aecpc->delayFile);
 #endif
 
   WebRtcAec_FreeAec(aecpc->aec);
   WebRtcAec_FreeResampler(aecpc->resampler);
   free(aecpc);
 }
 
@@ skipping 176 matching lines @@
 
   // 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
+#if WEBRTC_AEC_DEBUG_DUMP == 1
   {
     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;
@@ skipping 206 matching lines @@
       } else {
         aecpc->resample = kAecTrue;
       }
 
       if (aecpc->skew < minSkewEst) {
         aecpc->skew = minSkewEst;
       } else if (aecpc->skew > maxSkewEst) {
         aecpc->skew = maxSkewEst;
       }
 
-#ifdef WEBRTC_AEC_DEBUG_DUMP
+#if WEBRTC_AEC_DEBUG_DUMP == 1
       (void)fwrite(&aecpc->skew, sizeof(aecpc->skew), 1, aecpc->skewFile);
 #endif
     }
   }
 
   nBlocks10ms = nrOfSamples / (FRAME_LEN * aecpc->rate_factor);
 
   if (aecpc->startup_phase) {
     for (i = 0; i < num_bands; ++i) {
       // Only needed if they don't already point to the same place.
@@ skipping 261 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