Test submission of complete AEC-dump refactoring.

webrtc/modules/audio_processing/audio_processing_impl.cc.orig

 /*
  *  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.
  */
 
 #include "webrtc/modules/audio_processing/audio_processing_impl.h"
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/platform_file.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common_audio/audio_converter.h"
 #include "webrtc/common_audio/channel_buffer.h"
 #include "webrtc/common_audio/include/audio_util.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/aec3/echo_canceller3.h"
+#include "webrtc/modules/audio_processing/aec_dumper/null_aec_dumper.h"
 #include "webrtc/modules/audio_processing/agc/agc_manager_direct.h"
 #include "webrtc/modules/audio_processing/audio_buffer.h"
 #include "webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.h"
 #include "webrtc/modules/audio_processing/common.h"
 #include "webrtc/modules/audio_processing/echo_cancellation_impl.h"
 #include "webrtc/modules/audio_processing/echo_control_mobile_impl.h"
 #include "webrtc/modules/audio_processing/gain_control_for_experimental_agc.h"
 #include "webrtc/modules/audio_processing/gain_control_impl.h"
 #if WEBRTC_INTELLIGIBILITY_ENHANCER
 #include "webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h"
 #endif
 #include "webrtc/modules/audio_processing/level_controller/level_controller.h"
 #include "webrtc/modules/audio_processing/level_estimator_impl.h"
 #include "webrtc/modules/audio_processing/low_cut_filter.h"
 #include "webrtc/modules/audio_processing/noise_suppression_impl.h"
 #include "webrtc/modules/audio_processing/residual_echo_detector.h"
 #include "webrtc/modules/audio_processing/transient/transient_suppressor.h"
 #include "webrtc/modules/audio_processing/voice_detection_impl.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 #include "webrtc/system_wrappers/include/logging.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-// Files generated at build-time by the protobuf compiler.
-#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
-#include "external/webrtc/webrtc/modules/audio_processing/debug.pb.h"
-#else
-#include "webrtc/modules/audio_processing/debug.pb.h"
-#endif
-#endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
-
 // Check to verify that the define for the intelligibility enhancer is properly
 // set.
 #if !defined(WEBRTC_INTELLIGIBILITY_ENHANCER) || \
     (WEBRTC_INTELLIGIBILITY_ENHANCER != 0 &&     \
      WEBRTC_INTELLIGIBILITY_ENHANCER != 1)
 #error "Set WEBRTC_INTELLIGIBILITY_ENHANCER to either 0 or 1"
 #endif
 
 #define RETURN_ON_ERR(expr) \
   do {                      \
@@ skipping 232 matching lines @@
 
   return apm;
 }
 
 AudioProcessingImpl::AudioProcessingImpl(const webrtc::Config& config)
     : AudioProcessingImpl(config, nullptr) {}
 
 AudioProcessingImpl::AudioProcessingImpl(const webrtc::Config& config,
                                          NonlinearBeamformer* beamformer)
     : high_pass_filter_impl_(new HighPassFilterImpl(this)),
+      aec_dumper_(AecDumper::CreateNullDumper()),
       public_submodules_(new ApmPublicSubmodules()),
       private_submodules_(new ApmPrivateSubmodules(beamformer)),
       constants_(config.Get<ExperimentalAgc>().startup_min_volume,
                  config.Get<ExperimentalAgc>().clipped_level_min,
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
                  false),
 #else
                  config.Get<ExperimentalAgc>().enabled),
 #endif
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
@@ skipping 35 matching lines @@
   SetExtraOptions(config);
 }
 
 AudioProcessingImpl::~AudioProcessingImpl() {
   // Depends on gain_control_ and
   // public_submodules_->gain_control_for_experimental_agc.
   private_submodules_->agc_manager.reset();
   // Depends on gain_control_.
   public_submodules_->gain_control_for_experimental_agc.reset();
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  debug_dump_.debug_file->CloseFile();
-#endif
 }
 
 int AudioProcessingImpl::Initialize() {
   // Run in a single-threaded manner during initialization.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
   return InitializeLocked();
 }
 
 int AudioProcessingImpl::Initialize(int capture_input_sample_rate_hz,
@@ skipping 27 matching lines @@
     const ProcessingConfig& processing_config) {
   return MaybeInitialize(processing_config, false);
 }
 
 int AudioProcessingImpl::MaybeInitializeCapture(
     const ProcessingConfig& processing_config,
     bool force_initialization) {
   return MaybeInitialize(processing_config, force_initialization);
 }
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-
-AudioProcessingImpl::ApmDebugDumpThreadState::ApmDebugDumpThreadState()
-    : event_msg(new audioproc::Event()) {}
-
-AudioProcessingImpl::ApmDebugDumpThreadState::~ApmDebugDumpThreadState() {}
-
-AudioProcessingImpl::ApmDebugDumpState::ApmDebugDumpState()
-    : debug_file(FileWrapper::Create()) {}
-
-AudioProcessingImpl::ApmDebugDumpState::~ApmDebugDumpState() {}
-
-#endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 // Calls InitializeLocked() if any of the audio parameters have changed from
 // their current values (needs to be called while holding the crit_render_lock).
 int AudioProcessingImpl::MaybeInitialize(
     const ProcessingConfig& processing_config,
     bool force_initialization) {
   // Called from both threads. Thread check is therefore not possible.
   if (processing_config == formats_.api_format && !force_initialization) {
     return kNoError;
   }
@@ skipping 74 matching lines @@
 #endif
   InitializeLowCutFilter();
   public_submodules_->noise_suppression->Initialize(num_proc_channels(),
                                                     proc_sample_rate_hz());
   public_submodules_->voice_detection->Initialize(proc_split_sample_rate_hz());
   public_submodules_->level_estimator->Initialize();
   InitializeLevelController();
   InitializeResidualEchoDetector();
   InitializeEchoCanceller3();
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->is_open()) {
-    int err = WriteInitMessage();
-    if (err != kNoError) {
-      return err;
-    }
-  }
-#endif
-
+  aec_dumper_->WriteInitMessage(formats_.api_format);
   return kNoError;
 }
 
 int AudioProcessingImpl::InitializeLocked(const ProcessingConfig& config) {
   for (const auto& stream : config.streams) {
     if (stream.num_channels() > 0 && stream.sample_rate_hz() <= 0) {
       return kBadSampleRateError;
     }
   }
 
@@ skipping 255 matching lines @@
   {
     // Do conditional reinitialization.
     rtc::CritScope cs_render(&crit_render_);
     RETURN_ON_ERR(
         MaybeInitializeCapture(processing_config, reinitialization_required));
   }
   rtc::CritScope cs_capture(&crit_capture_);
   RTC_DCHECK_EQ(processing_config.input_stream().num_frames(),
                 formats_.api_format.input_stream().num_frames());
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->is_open()) {
-    RETURN_ON_ERR(WriteConfigMessage(false));
+  std::unique_ptr<AecDumper::CaptureStreamInfo> stream_info =
+      aec_dumper_->GetCaptureStreamInfo();
+  RETURN_ON_ERR(WriteConfigMessage(false));
+  const size_t channel_size =
+      sizeof(float) * formats_.api_format.input_stream().num_frames();
 
-    debug_dump_.capture.event_msg->set_type(audioproc::Event::STREAM);
-    audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
-    const size_t channel_size =
-        sizeof(float) * formats_.api_format.input_stream().num_frames();
+  {
+    std::vector<rtc::ArrayView<const float>> src_view;
     for (size_t i = 0; i < formats_.api_format.input_stream().num_channels();
-         ++i)
-      msg->add_input_channel(src[i], channel_size);
+         ++i) {
+      src_view.emplace_back(src[i], channel_size);
+    }
+    stream_info->AddInput(src_view);
   }
-#endif
+  capture_.capture_audio->CopyFrom(src, formats_.api_format.input_stream());
 
-  capture_.capture_audio->CopyFrom(src, formats_.api_format.input_stream());
+  // This earlier happened in ProcessCaptureStreamLocked().
+  RTC_DCHECK(!(public_submodules_->echo_cancellation->is_enabled() &&
+               public_submodules_->echo_control_mobile->is_enabled()));
+
+  stream_info->set_delay(capture_nonlocked_.stream_delay_ms);
+  stream_info->set_drift(
+      public_submodules_->echo_cancellation->stream_drift_samples());
+  stream_info->set_level(gain_control()->stream_analog_level());
+  stream_info->set_keypress(capture_.key_pressed);
+
   RETURN_ON_ERR(ProcessCaptureStreamLocked());
   capture_.capture_audio->CopyTo(formats_.api_format.output_stream(), dest);
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->is_open()) {
-    audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
+  {
     const size_t channel_size =
         sizeof(float) * formats_.api_format.output_stream().num_frames();
+    std::vector<rtc::ArrayView<const float>> dest_view;
     for (size_t i = 0; i < formats_.api_format.output_stream().num_channels();
-         ++i)
-      msg->add_output_channel(dest[i], channel_size);
-    RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                          &debug_dump_.num_bytes_left_for_log_,
-                                          &crit_debug_, &debug_dump_.capture));
+         ++i) {
+      dest_view.emplace_back(dest[i], channel_size);
+    }
+    stream_info->AddOutput(dest_view);
   }
-#endif
+  aec_dumper_->WriteCaptureStreamMessage(std::move(stream_info));
 
   return kNoError;
 }
 
 void AudioProcessingImpl::QueueRenderAudio(AudioBuffer* audio) {
   EchoCancellationImpl::PackRenderAudioBuffer(audio, num_output_channels(),
                                               num_reverse_channels(),
                                               &aec_render_queue_buffer_);
 
   RTC_DCHECK_GE(160, audio->num_frames_per_band());
@@ skipping 217 matching lines @@
     rtc::CritScope cs_render(&crit_render_);
     RETURN_ON_ERR(
         MaybeInitializeCapture(processing_config, reinitialization_required));
   }
   rtc::CritScope cs_capture(&crit_capture_);
   if (frame->samples_per_channel_ !=
       formats_.api_format.input_stream().num_frames()) {
     return kBadDataLengthError;
   }
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->is_open()) {
-    RETURN_ON_ERR(WriteConfigMessage(false));
-
-    debug_dump_.capture.event_msg->set_type(audioproc::Event::STREAM);
-    audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
-    const size_t data_size =
-        sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
-    msg->set_input_data(frame->data_, data_size);
-  }
-#endif
+  std::unique_ptr<AecDumper::CaptureStreamInfo> stream_info =
+      aec_dumper_->GetCaptureStreamInfo();
+  RETURN_ON_ERR(WriteConfigMessage(false));
+  stream_info->AddInput(*frame);
 
   capture_.capture_audio->DeinterleaveFrom(frame);
+
+  RTC_DCHECK(!(public_submodules_->echo_cancellation->is_enabled() &&
+               public_submodules_->echo_control_mobile->is_enabled()));
+
+  stream_info->set_delay(capture_nonlocked_.stream_delay_ms);
+  stream_info->set_drift(
+      public_submodules_->echo_cancellation->stream_drift_samples());
+  stream_info->set_level(gain_control()->stream_analog_level());
+  stream_info->set_keypress(capture_.key_pressed);
+
   RETURN_ON_ERR(ProcessCaptureStreamLocked());
   capture_.capture_audio->InterleaveTo(
       frame, submodule_states_.CaptureMultiBandProcessingActive());
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->is_open()) {
-    audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
-    const size_t data_size =
-        sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
-    msg->set_output_data(frame->data_, data_size);
-    RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                          &debug_dump_.num_bytes_left_for_log_,
-                                          &crit_debug_, &debug_dump_.capture));
-  }
-#endif
-
+  stream_info->AddOutput(*frame);
+  aec_dumper_->WriteCaptureStreamMessage(std::move(stream_info));
   return kNoError;
 }
 
 int AudioProcessingImpl::ProcessCaptureStreamLocked() {
   // Ensure that not both the AEC and AECM are active at the same time.
   // TODO(peah): Simplify once the public API Enable functions for these
   // are moved to APM.
   RTC_DCHECK(!(public_submodules_->echo_cancellation->is_enabled() &&
                public_submodules_->echo_control_mobile->is_enabled()));
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->is_open()) {
-    audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
-    msg->set_delay(capture_nonlocked_.stream_delay_ms);
-    msg->set_drift(
-        public_submodules_->echo_cancellation->stream_drift_samples());
-    msg->set_level(gain_control()->stream_analog_level());
-    msg->set_keypress(capture_.key_pressed);
-  }
-#endif
 
   MaybeUpdateHistograms();
 
   AudioBuffer* capture_buffer = capture_.capture_audio.get();  // For brevity.
 
   capture_input_rms_.Analyze(rtc::ArrayView<const int16_t>(
       capture_buffer->channels_const()[0],
       capture_nonlocked_.capture_processing_format.num_frames()));
   const bool log_rms = ++capture_rms_interval_counter_ >= 1000;
   if (log_rms) {
@@ skipping 209 matching lines @@
   }
 
   ProcessingConfig processing_config = formats_.api_format;
   processing_config.reverse_input_stream() = input_config;
   processing_config.reverse_output_stream() = output_config;
 
   RETURN_ON_ERR(MaybeInitializeRender(processing_config));
   assert(input_config.num_frames() ==
          formats_.api_format.reverse_input_stream().num_frames());
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->is_open()) {
-    debug_dump_.render.event_msg->set_type(audioproc::Event::REVERSE_STREAM);
-    audioproc::ReverseStream* msg =
-        debug_dump_.render.event_msg->mutable_reverse_stream();
-    const size_t channel_size =
-        sizeof(float) * formats_.api_format.reverse_input_stream().num_frames();
-    for (size_t i = 0;
-         i < formats_.api_format.reverse_input_stream().num_channels(); ++i)
-      msg->add_channel(src[i], channel_size);
-    RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                          &debug_dump_.num_bytes_left_for_log_,
-                                          &crit_debug_, &debug_dump_.render));
+  std::vector<rtc::ArrayView<const float>> src_view;
+  const size_t channel_size =
+      sizeof(float) * formats_.api_format.reverse_input_stream().num_frames();
+
+  for (size_t i = 0;
+       i < formats_.api_format.reverse_input_stream().num_channels(); ++i) {
+    src_view.emplace_back(src[i], channel_size);
   }
-#endif
+  aec_dumper_->WriteReverseStreamMessage(src_view);
 
   render_.render_audio->CopyFrom(src,
                                  formats_.api_format.reverse_input_stream());
   return ProcessRenderStreamLocked();
 }
 
 int AudioProcessingImpl::ProcessReverseStream(AudioFrame* frame) {
   TRACE_EVENT0("webrtc", "AudioProcessing::ProcessReverseStream_AudioFrame");
   rtc::CritScope cs(&crit_render_);
   if (frame == nullptr) {
@@ skipping 20 matching lines @@
       frame->sample_rate_hz_);
   processing_config.reverse_output_stream().set_num_channels(
       frame->num_channels_);
 
   RETURN_ON_ERR(MaybeInitializeRender(processing_config));
   if (frame->samples_per_channel_ !=
       formats_.api_format.reverse_input_stream().num_frames()) {
     return kBadDataLengthError;
   }
 
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->is_open()) {
-    debug_dump_.render.event_msg->set_type(audioproc::Event::REVERSE_STREAM);
-    audioproc::ReverseStream* msg =
-        debug_dump_.render.event_msg->mutable_reverse_stream();
-    const size_t data_size =
-        sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
-    msg->set_data(frame->data_, data_size);
-    RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                          &debug_dump_.num_bytes_left_for_log_,
-                                          &crit_debug_, &debug_dump_.render));
-  }
-#endif
+  aec_dumper_->WriteReverseStreamMessage(*frame);
+
   render_.render_audio->DeinterleaveFrom(frame);
   RETURN_ON_ERR(ProcessRenderStreamLocked());
   render_.render_audio->InterleaveTo(
       frame, submodule_states_.RenderMultiBandProcessingActive());
   return kNoError;
 }
 
 int AudioProcessingImpl::ProcessRenderStreamLocked() {
   AudioBuffer* render_buffer = render_.render_audio.get();  // For brevity.
   if (submodule_states_.RenderMultiBandSubModulesActive() &&
@@ skipping 67 matching lines @@
   capture_.delay_offset_ms = offset;
 }
 
 int AudioProcessingImpl::delay_offset_ms() const {
   rtc::CritScope cs(&crit_capture_);
   return capture_.delay_offset_ms;
 }
 
 int AudioProcessingImpl::StartDebugRecording(
     const char filename[AudioProcessing::kMaxFilenameSize],
-    int64_t max_log_size_bytes) {
-  // Run in a single-threaded manner.
-  rtc::CritScope cs_render(&crit_render_);
+    int64_t max_log_size_bytes,
+    rtc::TaskQueue* worker_queue) {
   rtc::CritScope cs_capture(&crit_capture_);
   static_assert(kMaxFilenameSize == FileWrapper::kMaxFileNameSize, "");
-
-  if (filename == nullptr) {
-    return kNullPointerError;
-  }
-
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  debug_dump_.num_bytes_left_for_log_ = max_log_size_bytes;
-  // Stop any ongoing recording.
-  debug_dump_.debug_file->CloseFile();
-
-  if (!debug_dump_.debug_file->OpenFile(filename, false)) {
-    return kFileError;
-  }
-
+  aec_dumper_ = AecDumper::Create(filename, max_log_size_bytes, worker_queue);
   RETURN_ON_ERR(WriteConfigMessage(true));
-  RETURN_ON_ERR(WriteInitMessage());
+  aec_dumper_->WriteInitMessage(formats_.api_format);
   return kNoError;
-#else
-  return kUnsupportedFunctionError;
-#endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 int AudioProcessingImpl::StartDebugRecording(FILE* handle,
-                                             int64_t max_log_size_bytes) {
-  // Run in a single-threaded manner.
-  rtc::CritScope cs_render(&crit_render_);
+                                             int64_t max_log_size_bytes,
+                                             rtc::TaskQueue* worker_queue) {
   rtc::CritScope cs_capture(&crit_capture_);
-
-  if (handle == nullptr) {
-    return kNullPointerError;
-  }
-
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  debug_dump_.num_bytes_left_for_log_ = max_log_size_bytes;
-
-  // Stop any ongoing recording.
-  debug_dump_.debug_file->CloseFile();
-
-  if (!debug_dump_.debug_file->OpenFromFileHandle(handle)) {
-    return kFileError;
-  }
-
+  aec_dumper_ = AecDumper::Create(handle, max_log_size_bytes, worker_queue);
   RETURN_ON_ERR(WriteConfigMessage(true));
-  RETURN_ON_ERR(WriteInitMessage());
+  aec_dumper_->WriteInitMessage(formats_.api_format);
   return kNoError;
-#else
-  return kUnsupportedFunctionError;
-#endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
-int AudioProcessingImpl::StartDebugRecording(FILE* handle) {
-  return StartDebugRecording(handle, -1);
+int AudioProcessingImpl::StartDebugRecording(FILE* handle,
+                                             rtc::TaskQueue* worker_queue) {
+  return StartDebugRecording(handle, -1, worker_queue);
 }
 
 int AudioProcessingImpl::StartDebugRecordingForPlatformFile(
-    rtc::PlatformFile handle) {
+    rtc::PlatformFile handle,
+    rtc::TaskQueue* worker_queue) {
   // Run in a single-threaded manner.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
   FILE* stream = rtc::FdopenPlatformFileForWriting(handle);
-  return StartDebugRecording(stream, -1);
+  return StartDebugRecording(stream, -1, worker_queue);
 }
 
 int AudioProcessingImpl::StopDebugRecording() {
-  // Run in a single-threaded manner.
-  rtc::CritScope cs_render(&crit_render_);
-  rtc::CritScope cs_capture(&crit_capture_);
-
-#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  // We just return if recording hasn't started.
-  debug_dump_.debug_file->CloseFile();
+  aec_dumper_ = AecDumper::CreateNullDumper();
   return kNoError;
-#else
-  return kUnsupportedFunctionError;
-#endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 AudioProcessing::AudioProcessingStatistics::AudioProcessingStatistics() {
   residual_echo_return_loss.Set(-100.0f, -100.0f, -100.0f, -100.0f);
   echo_return_loss.Set(-100.0f, -100.0f, -100.0f, -100.0f);
   echo_return_loss_enhancement.Set(-100.0f, -100.0f, -100.0f, -100.0f);
   a_nlp.Set(-100.0f, -100.0f, -100.0f, -100.0f);
 }
 
 AudioProcessing::AudioProcessingStatistics::AudioProcessingStatistics(
@@ skipping 223 matching lines @@
   capture_.last_stream_delay_ms = 0;
 
   if (capture_.aec_system_delay_jumps > -1) {
     RTC_HISTOGRAM_ENUMERATION("WebRTC.Audio.NumOfAecSystemDelayJumps",
                               capture_.aec_system_delay_jumps, 51);
   }
   capture_.aec_system_delay_jumps = -1;
   capture_.last_aec_system_delay_ms = 0;
 }
 
+<<<<<<< HEAD
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 int AudioProcessingImpl::WriteMessageToDebugFile(
     FileWrapper* debug_file,
     int64_t* filesize_limit_bytes,
     rtc::CriticalSection* crit_debug,
     ApmDebugDumpThreadState* debug_state) {
   int32_t size = debug_state->event_msg->ByteSize();
   if (size <= 0) {
     return kUnspecifiedError;
   }
@@ skipping 55 matching lines @@
       formats_.api_format.reverse_output_stream().sample_rate_hz());
   msg->set_num_reverse_output_channels(
       formats_.api_format.reverse_output_stream().num_channels());
 
   RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                         &debug_dump_.num_bytes_left_for_log_,
                                         &crit_debug_, &debug_dump_.capture));
   return kNoError;
 }
 
+||||||| parent of 6d4e36d05... aec-dumper and null-aec-dumper. Most parts are implemented.
+#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
+int AudioProcessingImpl::WriteMessageToDebugFile(
+    FileWrapper* debug_file,
+    int64_t* filesize_limit_bytes,
+    rtc::CriticalSection* crit_debug,
+    ApmDebugDumpThreadState* debug_state) {
+  int32_t size = debug_state->event_msg->ByteSize();
+  if (size <= 0) {
+    return kUnspecifiedError;
+  }
+#if defined(WEBRTC_ARCH_BIG_ENDIAN)
+// TODO(ajm): Use little-endian "on the wire". For the moment, we can be
+//            pretty safe in assuming little-endian.
+#endif
+
+  if (!debug_state->event_msg->SerializeToString(&debug_state->event_str)) {
+    return kUnspecifiedError;
+  }
+
+  {
+    // Ensure atomic writes of the message.
+    rtc::CritScope cs_debug(crit_debug);
+
+    RTC_DCHECK(debug_file->is_open());
+    // Update the byte counter.
+    if (*filesize_limit_bytes >= 0) {
+      *filesize_limit_bytes -=
+          (sizeof(int32_t) + debug_state->event_str.length());
+      if (*filesize_limit_bytes < 0) {
+        // Not enough bytes are left to write this message, so stop logging.
+        debug_file->CloseFile();
+        return kNoError;
+      }
+    }
+    // Write message preceded by its size.
+    if (!debug_file->Write(&size, sizeof(int32_t))) {
+      return kFileError;
+    }
+    if (!debug_file->Write(debug_state->event_str.data(),
+                           debug_state->event_str.length())) {
+      return kFileError;
+    }
+  }
+
+  debug_state->event_msg->Clear();
+
+  return kNoError;
+}
+
+int AudioProcessingImpl::WriteInitMessage() {
+  debug_dump_.capture.event_msg->set_type(audioproc::Event::INIT);
+  audioproc::Init* msg = debug_dump_.capture.event_msg->mutable_init();
+  msg->set_sample_rate(formats_.api_format.input_stream().sample_rate_hz());
+
+  msg->set_num_input_channels(static_cast<int32_t>(
+      formats_.api_format.input_stream().num_channels()));
+  msg->set_num_output_channels(static_cast<int32_t>(
+      formats_.api_format.output_stream().num_channels()));
+  msg->set_num_reverse_channels(static_cast<int32_t>(
+      formats_.api_format.reverse_input_stream().num_channels()));
+  msg->set_reverse_sample_rate(
+      formats_.api_format.reverse_input_stream().sample_rate_hz());
+  msg->set_output_sample_rate(
+      formats_.api_format.output_stream().sample_rate_hz());
+  msg->set_reverse_output_sample_rate(
+      formats_.api_format.reverse_output_stream().sample_rate_hz());
+  msg->set_num_reverse_output_channels(
+      formats_.api_format.reverse_output_stream().num_channels());
+
+  RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
+                                        &debug_dump_.num_bytes_left_for_log_,
+                                        &crit_debug_, &debug_dump_.capture));
+  return kNoError;
+}
+
+=======
+>>>>>>> 6d4e36d05... aec-dumper and null-aec-dumper. Most parts are implemented.
 int AudioProcessingImpl::WriteConfigMessage(bool forced) {
-  audioproc::Config config;
+  InternalAPMConfig config;
 
-  config.set_aec_enabled(public_submodules_->echo_cancellation->is_enabled());
-  config.set_aec_delay_agnostic_enabled(
-      public_submodules_->echo_cancellation->is_delay_agnostic_enabled());
-  config.set_aec_drift_compensation_enabled(
-      public_submodules_->echo_cancellation->is_drift_compensation_enabled());
-  config.set_aec_extended_filter_enabled(
-      public_submodules_->echo_cancellation->is_extended_filter_enabled());
-  config.set_aec_suppression_level(static_cast<int>(
-      public_submodules_->echo_cancellation->suppression_level()));
+  config.aec_enabled = public_submodules_->echo_cancellation->is_enabled();
+  config.aec_delay_agnostic_enabled =
+      public_submodules_->echo_cancellation->is_delay_agnostic_enabled();
+  config.aec_drift_compensation_enabled =
+      public_submodules_->echo_cancellation->is_drift_compensation_enabled();
+  config.aec_extended_filter_enabled =
+      public_submodules_->echo_cancellation->is_extended_filter_enabled();
+  config.aec_suppression_level = static_cast<int>(
+      public_submodules_->echo_cancellation->suppression_level());
 
-  config.set_aecm_enabled(
-      public_submodules_->echo_control_mobile->is_enabled());
-  config.set_aecm_comfort_noise_enabled(
-      public_submodules_->echo_control_mobile->is_comfort_noise_enabled());
-  config.set_aecm_routing_mode(static_cast<int>(
-      public_submodules_->echo_control_mobile->routing_mode()));
+  config.aecm_enabled = public_submodules_->echo_control_mobile->is_enabled();
+  config.aecm_comfort_noise_enabled =
+      public_submodules_->echo_control_mobile->is_comfort_noise_enabled();
+  config.aecm_routing_mode =
+      static_cast<int>(public_submodules_->echo_control_mobile->routing_mode());
 
-  config.set_agc_enabled(public_submodules_->gain_control->is_enabled());
-  config.set_agc_mode(
-      static_cast<int>(public_submodules_->gain_control->mode()));
-  config.set_agc_limiter_enabled(
-      public_submodules_->gain_control->is_limiter_enabled());
-  config.set_noise_robust_agc_enabled(constants_.use_experimental_agc);
+  config.agc_enabled = public_submodules_->gain_control->is_enabled();
+  config.agc_mode = static_cast<int>(public_submodules_->gain_control->mode());
+  config.agc_limiter_enabled =
+      public_submodules_->gain_control->is_limiter_enabled();
+  config.noise_robust_agc_enabled = constants_.use_experimental_agc;
 
-  config.set_hpf_enabled(config_.high_pass_filter.enabled);
+  config.hpf_enabled = config_.high_pass_filter.enabled;
 
-  config.set_ns_enabled(public_submodules_->noise_suppression->is_enabled());
-  config.set_ns_level(
-      static_cast<int>(public_submodules_->noise_suppression->level()));
+  config.ns_enabled = public_submodules_->noise_suppression->is_enabled();
+  config.ns_level =
+      static_cast<int>(public_submodules_->noise_suppression->level());
 
-  config.set_transient_suppression_enabled(
-      capture_.transient_suppressor_enabled);
-  config.set_intelligibility_enhancer_enabled(
-      capture_nonlocked_.intelligibility_enabled);
+  config.transient_suppression_enabled = capture_.transient_suppressor_enabled;
+  config.intelligibility_enhancer_enabled =
+      capture_nonlocked_.intelligibility_enabled;
 
   std::string experiments_description =
       public_submodules_->echo_cancellation->GetExperimentsDescription();
   // TODO(peah): Add semicolon-separated concatenations of experiment
   // descriptions for other submodules.
   if (capture_nonlocked_.level_controller_enabled) {
     experiments_description += "LevelController;";
   }
   if (constants_.agc_clipped_level_min != kClippedLevelMin) {
     experiments_description += "AgcClippingLevelExperiment;";
   }
   if (capture_nonlocked_.echo_canceller3_enabled) {
     experiments_description += "EchoCanceller3;";
   }
+<<<<<<< HEAD
   config.set_experiments_description(experiments_description);
 
   std::string serialized_config = config.SerializeAsString();
   if (!forced &&
       debug_dump_.capture.last_serialized_config == serialized_config) {
     return kNoError;
   }
 
   debug_dump_.capture.last_serialized_config = serialized_config;
 
   debug_dump_.capture.event_msg->set_type(audioproc::Event::CONFIG);
   debug_dump_.capture.event_msg->mutable_config()->CopyFrom(config);
+||||||| parent of 6d4e36d05... aec-dumper and null-aec-dumper. Most parts are implemented.
+  config.set_experiments_description(experiments_description);
 
-  RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                        &debug_dump_.num_bytes_left_for_log_,
-                                        &crit_debug_, &debug_dump_.capture));
+  ProtoString serialized_config = config.SerializeAsString();
+  if (!forced &&
+      debug_dump_.capture.last_serialized_config == serialized_config) {
+    return kNoError;
+  }
+
+  debug_dump_.capture.last_serialized_config = serialized_config;
+
+  debug_dump_.capture.event_msg->set_type(audioproc::Event::CONFIG);
+  debug_dump_.capture.event_msg->mutable_config()->CopyFrom(config);
+=======
+  config.experiments_description = experiments_description;
+>>>>>>> 6d4e36d05... aec-dumper and null-aec-dumper. Most parts are implemented.
+
+  aec_dumper_->WriteConfig(config, forced);
   return kNoError;
 }
-#endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 AudioProcessingImpl::ApmCaptureState::ApmCaptureState(
     bool transient_suppressor_enabled,
     const std::vector<Point>& array_geometry,
     SphericalPointf target_direction)
     : aec_system_delay_jumps(-1),
       delay_offset_ms(0),
       was_stream_delay_set(false),
       last_stream_delay_ms(0),
       last_aec_system_delay_ms(0),
       stream_delay_jumps(-1),
       output_will_be_muted(false),
       key_pressed(false),
       transient_suppressor_enabled(transient_suppressor_enabled),
       array_geometry(array_geometry),
       target_direction(target_direction),
       capture_processing_format(kSampleRate16kHz),
       split_rate(kSampleRate16kHz) {}
 
 AudioProcessingImpl::ApmCaptureState::~ApmCaptureState() = default;
 
 AudioProcessingImpl::ApmRenderState::ApmRenderState() = default;
 
 AudioProcessingImpl::ApmRenderState::~ApmRenderState() = default;
 
 }  // namespace webrtc