Adding metrics to AEC3

webrtc/modules/audio_processing/aec3/block_processor.cc

 /*
  *  Copyright (c) 2016 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/aec3/block_processor.h"
 
 #include "webrtc/base/atomicops.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/modules/audio_processing/aec3/aec3_common.h"
+#include "webrtc/modules/audio_processing/aec3/block_processor_metrics.h"
 #include "webrtc/modules/audio_processing/aec3/echo_path_variability.h"
 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
-#include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 namespace {
 
 class BlockProcessorImpl final : public BlockProcessor {
  public:
   BlockProcessorImpl(int sample_rate_hz,
                      std::unique_ptr<RenderDelayBuffer> render_buffer,
                      std::unique_ptr<RenderDelayController> delay_controller,
                      std::unique_ptr<EchoRemover> echo_remover);
 
   ~BlockProcessorImpl() override;
 
   void ProcessCapture(bool echo_path_gain_change,
                       bool capture_signal_saturation,
                       std::vector<std::vector<float>>* capture_block) override;
 
   bool BufferRender(std::vector<std::vector<float>>* block) override;
 
   void UpdateEchoLeakageStatus(bool leakage_detected) override;
 
  private:
   static int instance_count_;
   std::unique_ptr<ApmDataDumper> data_dumper_;
   const size_t sample_rate_hz_;
   std::unique_ptr<RenderDelayBuffer> render_buffer_;
   std::unique_ptr<RenderDelayController> delay_controller_;
   std::unique_ptr<EchoRemover> echo_remover_;
+  BlockProcessorMetrics metrics_;
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(BlockProcessorImpl);
 };
 
 constexpr size_t kRenderBufferSize = 250;
 int BlockProcessorImpl::instance_count_ = 0;
 constexpr size_t kMaxApiJitter = 30;
 
 BlockProcessorImpl::BlockProcessorImpl(
     int sample_rate_hz,
     std::unique_ptr<RenderDelayBuffer> render_buffer,
@@ skipping 24 matching lines @@
   if (render_delay_change) {
     render_buffer_->SetDelay(delay);
   }
 
   if (render_buffer_->IsBlockAvailable()) {
     auto& render_block = render_buffer_->GetNext();
     echo_remover_->ProcessBlock(
         delay_controller_->AlignmentHeadroomSamples(),
         EchoPathVariability(echo_path_gain_change, render_delay_change),
         capture_signal_saturation, render_block, capture_block);
+    metrics_.UpdateCapture(false);
   } else {
-    LOG(LS_INFO) << "AEC3 empty render buffer";
+    metrics_.UpdateCapture(true);
   }
 }
 
 bool BlockProcessorImpl::BufferRender(std::vector<std::vector<float>>* block) {
   RTC_DCHECK(block);
   RTC_DCHECK_EQ(NumBandsForRate(sample_rate_hz_), block->size());
   RTC_DCHECK_EQ(kBlockSize, (*block)[0].size());
 
   const bool delay_controller_overrun =
       !delay_controller_->AnalyzeRender((*block)[0]);
   const bool render_buffer_overrun = !render_buffer_->Insert(block);
   if (delay_controller_overrun || render_buffer_overrun) {
-    LOG(LS_INFO) << "AEC3 buffer overrrun";
+    metrics_.UpdateRender(true);
     return false;
   }
-
+  metrics_.UpdateRender(false);
   return true;
 }
 
 void BlockProcessorImpl::UpdateEchoLeakageStatus(bool leakage_detected) {
   echo_remover_->UpdateEchoLeakageStatus(leakage_detected);
 }
 
 }  // namespace
 
 BlockProcessor* BlockProcessor::Create(int sample_rate_hz) {
@@ skipping 22 matching lines @@
     int sample_rate_hz,
     std::unique_ptr<RenderDelayBuffer> render_buffer,
     std::unique_ptr<RenderDelayController> delay_controller,
     std::unique_ptr<EchoRemover> echo_remover) {
   return new BlockProcessorImpl(sample_rate_hz, std::move(render_buffer),
                                 std::move(delay_controller),
                                 std::move(echo_remover));
 }
 
 }  // namespace webrtc