Added offline data logpoints and logging functionality to the gain controller

webrtc/modules/audio_processing/gain_control_impl.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.
  */
 
 #include "webrtc/modules/audio_processing/gain_control_impl.h"
 
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/modules/audio_processing/audio_buffer.h"
 #include "webrtc/modules/audio_processing/agc/legacy/gain_control.h"
+#include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
 
 namespace webrtc {
 
 typedef void Handle;
 
 namespace {
 int16_t MapSetting(GainControl::Mode mode) {
   switch (mode) {
     case GainControl::kAdaptiveAnalog:
       return kAgcModeAdaptiveAnalog;
@@ skipping 50 matching lines @@
 
  private:
   Handle* state_;
   // TODO(peah): Remove the optional once the initialization is moved into the
   // ctor.
   rtc::Optional<int> capture_level_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(GainController);
 };
 
+int GainControlImpl::instance_counter_ = 0;
+
 GainControlImpl::GainControlImpl(rtc::CriticalSection* crit_render,
                                  rtc::CriticalSection* crit_capture)
     : crit_render_(crit_render),
       crit_capture_(crit_capture),
+      data_dumper_(new ApmDataDumper(instance_counter_)),

[ivoc, 2016/10/28 09:20:10]

The experimental AGC and the regular AGC could end up using the same values for
the instance_counter_, but I guess they're not active at the same time, are
they?

[peah-webrtc, 2016/10/28 09:43:41]

They are not in practice active at the same time.
I did, however, for the reason you state name the log files differently in the
experimental and the regular AGC so there will never be any clash.

       mode_(kAdaptiveAnalog),
       minimum_capture_level_(0),
       maximum_capture_level_(255),
       limiter_enabled_(true),
       target_level_dbfs_(3),
       compression_gain_db_(9),
       analog_capture_level_(0),
       was_analog_level_set_(false),
       stream_is_saturated_(false) {
   RTC_DCHECK(crit_render);
@@ skipping 131 matching lines @@
 }
 
 int GainControlImpl::compression_gain_db() const {
   rtc::CritScope cs(crit_capture_);
   return compression_gain_db_;
 }
 
 // TODO(ajm): ensure this is called under kAdaptiveAnalog.
 int GainControlImpl::set_stream_analog_level(int level) {
   rtc::CritScope cs(crit_capture_);
+  data_dumper_->DumpRaw("gain_control_set_stream_analog_level", 1, &level);

[ivoc, 2016/10/28 09:20:10]

Shouldn't there be a way to enable/disable this logging in the regular AGC?

[peah-webrtc, 2016/10/28 09:43:41]

There is. What happens is that this method call expands into an empty method
call if the WEBRTC_APM_DEBUG_DUMP flag is not set. This build flag is only set
to 1 if apm_debug_dump=true when generating the build flags.

Therefore this logging is disabled even when using WebRTC in the default way.

Note that the experimental AGC is actually the standard analog AGC that we use.
That naming is very misleading.

 
   was_analog_level_set_ = true;
   if (level < minimum_capture_level_ || level > maximum_capture_level_) {
     return AudioProcessing::kBadParameterError;
   }
   analog_capture_level_ = level;
 
   return AudioProcessing::kNoError;
 }
 
 int GainControlImpl::stream_analog_level() {
   rtc::CritScope cs(crit_capture_);
+  data_dumper_->DumpRaw("gain_control_stream_analog_level", 1,
+                        &analog_capture_level_);
   // TODO(ajm): enable this assertion?
   //RTC_DCHECK_EQ(kAdaptiveAnalog, mode_);
 
   return analog_capture_level_;
 }
 
 int GainControlImpl::Enable(bool enable) {
   rtc::CritScope cs_render(crit_render_);
   rtc::CritScope cs_capture(crit_capture_);
   if (enable && !enabled_) {
@@ skipping 114 matching lines @@
 }
 
 bool GainControlImpl::is_limiter_enabled() const {
   rtc::CritScope cs(crit_capture_);
   return limiter_enabled_;
 }
 
 void GainControlImpl::Initialize(size_t num_proc_channels, int sample_rate_hz) {
   rtc::CritScope cs_render(crit_render_);
   rtc::CritScope cs_capture(crit_capture_);
+  data_dumper_->InitiateNewSetOfRecordings();
 
   num_proc_channels_ = rtc::Optional<size_t>(num_proc_channels);
   sample_rate_hz_ = rtc::Optional<int>(sample_rate_hz);
 
   if (!enabled_) {
     return;
   }
 
   gain_controllers_.resize(*num_proc_channels_);
   for (auto& gain_controller : gain_controllers_) {
@@ skipping 24 matching lines @@
   for (auto& gain_controller : gain_controllers_) {
     const int handle_error =
         WebRtcAgc_set_config(gain_controller->state(), config);
     if (handle_error != AudioProcessing::kNoError) {
       error = handle_error;
     }
   }
   return error;
 }
 }  // namespace webrtc