Remove VERBOSE logs from frame_dropper.cc.

webrtc/modules/video_coding/utility/frame_dropper.cc

 /*
  *  Copyright (c) 2011 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.
  */
 
@@ skipping 111 matching lines @@
           framesize_kbits / large_frame_accumulation_count_;
       framesize_kbits = 0;
     } else {
       delta_frame_size_avg_kbits_.Apply(1, framesize_kbits);
     }
     key_frame_ratio_.Apply(1.0, 0.0);
   }
   // Change the level of the accumulator (bucket)
   accumulator_ += framesize_kbits;
   CapAccumulator();
-  LOG(LS_VERBOSE) << "FILL acc " << accumulator_ << " max " << accumulator_max_
-                  << " count " << large_frame_accumulation_count_ << " chunk "
-                  << large_frame_accumulation_chunk_size_ << " spread "
-                  << large_frame_accumulation_spread_ << " delta avg "
-                  << delta_frame_size_avg_kbits_.filtered() << " SIZE "
-                  << framesize_kbits << "key frame ratio "
-                  << key_frame_ratio_.filtered();
 }
 
 void FrameDropper::Leak(uint32_t input_framerate) {
   if (!enabled_) {
     return;
   }
   if (input_framerate < 1) {
     return;
   }
   if (target_bitrate_ < 0.0f) {
     return;
   }
   // Add lower bound for large frame accumulation spread.
   large_frame_accumulation_spread_ = std::max(0.5 * input_framerate, 5.0);
   // Expected bits per frame based on current input frame rate.
   float expected_bits_per_frame = target_bitrate_ / input_framerate;
   if (large_frame_accumulation_count_ > 0) {
     expected_bits_per_frame -= large_frame_accumulation_chunk_size_;
     --large_frame_accumulation_count_;
   }
   accumulator_ -= expected_bits_per_frame;
   if (accumulator_ < 0.0f) {
     accumulator_ = 0.0f;
   }
-  LOG(LS_VERBOSE) << "LEAK acc " << accumulator_ << " max " << accumulator_max_
-                  << " count " << large_frame_accumulation_count_ << " spread "
-                  << large_frame_accumulation_spread_ << " delta avg "
-                  << delta_frame_size_avg_kbits_.filtered();
   UpdateRatio();
 }
 
 void FrameDropper::UpdateRatio() {
   if (accumulator_ > 1.3f * accumulator_max_) {
     // Too far above accumulator max, react faster
     drop_ratio_.UpdateBase(0.8f);
   } else {
     // Go back to normal reaction
     drop_ratio_.UpdateBase(0.9f);
@@ skipping 17 matching lines @@
 // dropRatio
 // to smooth out the drops over time.
 bool FrameDropper::DropFrame() {
   if (!enabled_) {
     return false;
   }
   if (drop_next_) {
     drop_next_ = false;
     drop_count_ = 0;
   }
-  LOG(LS_VERBOSE) << " drop_ratio_ " << drop_ratio_.filtered()
-                  << " drop_count_ " << drop_count_;
 
   if (drop_ratio_.filtered() >= 0.5f) {  // Drops per keep
     // limit is the number of frames we should drop between each kept frame
     // to keep our drop ratio. limit is positive in this case.
     float denom = 1.0f - drop_ratio_.filtered();
     if (denom < 1e-5) {
       denom = 1e-5f;
     }
     int32_t limit = static_cast<int32_t>(1.0f / denom - 1.0f + 0.5f);
     // Put a bound on the max amount of dropped frames between each kept
@@ skipping 67 matching lines @@
 // This is a temporary fix for screencasting where very large frames from
 // encoder will cause very slow response (too many frame drops).
 // TODO(isheriff): Remove this now that large delta frames are also spread out ?
 void FrameDropper::CapAccumulator() {
   float max_accumulator = target_bitrate_ * kAccumulatorCapBufferSizeSecs;
   if (accumulator_ > max_accumulator) {
     accumulator_ = max_accumulator;
   }
 }
 }  // namespace webrtc