Delete all log messages depending on system_wrappers.

webrtc/modules/audio_processing/agc/agc_manager_direct.cc

 /*
  *  Copyright (c) 2013 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/agc/agc_manager_direct.h"
 
 #include <cmath>
 
 #ifdef WEBRTC_AGC_DEBUG_DUMP
 #include <cstdio>
 #endif
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/audio_processing/agc/gain_map_internal.h"
 #include "webrtc/modules/audio_processing/gain_control_impl.h"
 #include "webrtc/modules/include/module_common_types.h"
-#include "webrtc/system_wrappers/include/logging.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 
 namespace {
 
 // Amount the microphone level is lowered with every clipping event.
 const int kClippedLevelStep = 15;
 // Proportion of clipped samples required to declare a clipping event.
 const float kClippedRatioThreshold = 0.1f;
@@ skipping 129 matching lines @@
   max_compression_gain_ = kMaxCompressionGain;
   target_compression_ = kDefaultCompressionGain;
   compression_ = target_compression_;
   compression_accumulator_ = compression_;
   capture_muted_ = false;
   check_volume_on_next_process_ = true;
   // TODO(bjornv): Investigate if we need to reset |startup_| as well. For
   // example, what happens when we change devices.
 
   if (gctrl_->set_mode(GainControl::kFixedDigital) != 0) {
-    LOG(LS_ERROR) << "set_mode(GainControl::kFixedDigital) failed.";
     return -1;
   }
   if (gctrl_->set_target_level_dbfs(2) != 0) {
-    LOG(LS_ERROR) << "set_target_level_dbfs(2) failed.";
     return -1;
   }
   if (gctrl_->set_compression_gain_db(kDefaultCompressionGain) != 0) {
-    LOG(LS_ERROR) << "set_compression_gain_db(kDefaultCompressionGain) failed.";
     return -1;
   }
   if (gctrl_->enable_limiter(true) != 0) {
-    LOG(LS_ERROR) << "enable_limiter(true) failed.";
     return -1;
   }
   return 0;
 }
 
 void AgcManagerDirect::AnalyzePreProcess(int16_t* audio,
                                          int num_channels,
                                          size_t samples_per_channel) {
   size_t length = num_channels * samples_per_channel;
   if (capture_muted_) {
@@ skipping 11 matching lines @@
   // under clipping distortion. We do this in the preprocessing phase in order
   // to catch clipped echo as well.
   //
   // If we find a sufficiently clipped frame, drop the current microphone level
   // and enforce a new maximum level, dropped the same amount from the current
   // maximum. This harsh treatment is an effort to avoid repeated clipped echo
   // events. As compensation for this restriction, the maximum compression
   // gain is increased, through SetMaxLevel().
   float clipped_ratio = agc_->AnalyzePreproc(audio, length);
   if (clipped_ratio > kClippedRatioThreshold) {
-    LOG(LS_INFO) << "[agc] Clipping detected. clipped_ratio="
-                 << clipped_ratio;
     // Always decrease the maximum level, even if the current level is below
     // threshold.
     SetMaxLevel(std::max(clipped_level_min_, max_level_ - kClippedLevelStep));
     RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.AgcClippingAdjustmentAllowed",
                           level_ - kClippedLevelStep >= clipped_level_min_);
     if (level_ > clipped_level_min_) {
       // Don't try to adjust the level if we're already below the limit. As
       // a consequence, if the user has brought the level above the limit, we
       // will still not react until the postproc updates the level.
       SetLevel(std::max(clipped_level_min_, level_ - kClippedLevelStep));
@@ skipping 12 matching lines @@
   }
 
   if (check_volume_on_next_process_) {
     check_volume_on_next_process_ = false;
     // We have to wait until the first process call to check the volume,
     // because Chromium doesn't guarantee it to be valid any earlier.
     CheckVolumeAndReset();
   }
 
   if (agc_->Process(audio, length, sample_rate_hz) != 0) {
-    LOG(LS_ERROR) << "Agc::Process failed";
     RTC_NOTREACHED();
   }
 
   UpdateGain();
   UpdateCompressor();
 
   file_postproc_->Write(audio, length);
 }
 
 void AgcManagerDirect::SetLevel(int new_level) {
   int voe_level = volume_callbacks_->GetMicVolume();
   if (voe_level < 0) {
     return;
   }
   if (voe_level == 0) {
-    LOG(LS_INFO) << "[agc] VolumeCallbacks returned level=0, taking no action.";
     return;
   }
   if (voe_level > kMaxMicLevel) {
-    LOG(LS_ERROR) << "VolumeCallbacks returned an invalid level=" << voe_level;
     return;
   }
 
   if (voe_level > level_ + kLevelQuantizationSlack ||
       voe_level < level_ - kLevelQuantizationSlack) {
-    LOG(LS_INFO) << "[agc] Mic volume was manually adjusted. Updating "
-                 << "stored level from " << level_ << " to " << voe_level;
     level_ = voe_level;
     // Always allow the user to increase the volume.
     if (level_ > max_level_) {
       SetMaxLevel(level_);
     }
     // Take no action in this case, since we can't be sure when the volume
     // was manually adjusted. The compressor will still provide some of the
     // desired gain change.
     agc_->Reset();
     return;
   }
 
   new_level = std::min(new_level, max_level_);
   if (new_level == level_) {
     return;
   }
 
   volume_callbacks_->SetMicVolume(new_level);
-  LOG(LS_INFO) << "[agc] voe_level=" << voe_level << ", "
-               << "level_=" << level_ << ", "
-               << "new_level=" << new_level;
   level_ = new_level;
 }
 
 void AgcManagerDirect::SetMaxLevel(int level) {
   RTC_DCHECK_GE(level, clipped_level_min_);
   max_level_ = level;
   // Scale the |kSurplusCompressionGain| linearly across the restricted
   // level range.
   max_compression_gain_ =
       kMaxCompressionGain + std::floor((1.f * kMaxMicLevel - max_level_) /
                                            (kMaxMicLevel - clipped_level_min_) *
                                            kSurplusCompressionGain +
                                        0.5f);
-  LOG(LS_INFO) << "[agc] max_level_=" << max_level_
-               << ", max_compression_gain_="  << max_compression_gain_;
 }
 
 void AgcManagerDirect::SetCaptureMuted(bool muted) {
   if (capture_muted_ == muted) {
     return;
   }
   capture_muted_ = muted;
 
   if (!muted) {
     // When we unmute, we should reset things to be safe.
     check_volume_on_next_process_ = true;
   }
 }
 
 float AgcManagerDirect::voice_probability() {
   return agc_->voice_probability();
 }
 
 int AgcManagerDirect::CheckVolumeAndReset() {
   int level = volume_callbacks_->GetMicVolume();
   if (level < 0) {
     return -1;
   }
   // Reasons for taking action at startup:
   // 1) A person starting a call is expected to be heard.
   // 2) Independent of interpretation of |level| == 0 we should raise it so the
   // AGC can do its job properly.
   if (level == 0 && !startup_) {
-    LOG(LS_INFO) << "[agc] VolumeCallbacks returned level=0, taking no action.";
     return 0;
   }
   if (level > kMaxMicLevel) {
-    LOG(LS_ERROR) << "VolumeCallbacks returned an invalid level=" << level;
     return -1;
   }
-  LOG(LS_INFO) << "[agc] Initial GetMicVolume()=" << level;
 
   int minLevel = startup_ ? startup_min_level_ : kMinMicLevel;
   if (level < minLevel) {
     level = minLevel;
-    LOG(LS_INFO) << "[agc] Initial volume too low, raising to " << level;
     volume_callbacks_->SetMicVolume(level);
   }
   agc_->Reset();
   level_ = level;
   startup_ = false;
   return 0;
 }
 
 // Requests the RMS error from AGC and distributes the required gain change
 // between the digital compression stage and volume slider. We use the
@@ skipping 30 matching lines @@
     target_compression_ = (raw_compression - target_compression_) / 2
         + target_compression_;
   }
 
   // Residual error will be handled by adjusting the volume slider. Use the
   // raw rather than deemphasized compression here as we would otherwise
   // shrink the amount of slack the compressor provides.
   int residual_gain = rms_error - raw_compression;
   residual_gain = std::min(std::max(residual_gain, -kMaxResidualGainChange),
       kMaxResidualGainChange);
-  LOG(LS_INFO) << "[agc] rms_error=" << rms_error << ", "
-               << "target_compression=" << target_compression_ << ", "
-               << "residual_gain=" << residual_gain;
   if (residual_gain == 0)
     return;
 
   int old_level = level_;
   SetLevel(LevelFromGainError(residual_gain, level_));
   if (old_level != level_) {
     // level_ was updated by SetLevel; log the new value.
     RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.AgcSetLevel", level_, 1,
                                 kMaxMicLevel, 50);
   }
@@ skipping 20 matching lines @@
   if (std::fabs(compression_accumulator_ - nearest_neighbor) <
       kCompressionGainStep / 2) {
     new_compression = nearest_neighbor;
   }
 
   // Set the new compression gain.
   if (new_compression != compression_) {
     compression_ = new_compression;
     compression_accumulator_ = new_compression;
     if (gctrl_->set_compression_gain_db(compression_) != 0) {
-      LOG(LS_ERROR) << "set_compression_gain_db(" << compression_
-                    << ") failed.";
     }
   }
 }
 
 }  // namespace webrtc