Fix stats for encoder target bitrate when target rate is zero.

webrtc/video/video_send_stream.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.
  */
 
@@ skipping 378 matching lines @@
       config_(config),
       suspended_ssrcs_(suspended_ssrcs),
       module_process_thread_(module_process_thread),
       call_stats_(call_stats),
       congestion_controller_(congestion_controller),
       bitrate_allocator_(bitrate_allocator),
       remb_(remb),
       encoder_thread_(EncoderThreadFunction, this, "EncoderThread"),
       encoder_wakeup_event_(false, false),
       stop_encoder_thread_(0),
+      encoder_max_bitrate_bps_(0),
       state_(State::kStopped),
       overuse_detector_(
           Clock::GetRealTimeClock(),
           GetCpuOveruseOptions(config.encoder_settings.full_overuse_time),
           this,
           config.post_encode_callback,
           &stats_proxy_),
       vie_encoder_(num_cpu_cores,
                    module_process_thread_,
                    &stats_proxy_,
@@ skipping 215 matching lines @@
             current_encoder_settings_->video_codec.maxBitrate * 1000,
             CalulcateMaxPadBitrateBps(current_encoder_settings_->config,
                                       config_.suspend_below_min_bitrate),
             !config_.suspend_below_min_bitrate);
         vie_encoder_.SendKeyFrame();
         state_ = State::kStarted;
         LOG_F(LS_INFO) << "Encoder started.";
       } else if (*pending_state_change == State::kStopped) {
         bitrate_allocator_->RemoveObserver(this);
         vie_encoder_.OnBitrateUpdated(0, 0, 0);
+        stats_proxy_.OnSetEncoderTargetRate(0);
         state_ = State::kStopped;
         LOG_F(LS_INFO) << "Encoder stopped.";
       }
       encoder_wakeup_event_.Set();
       continue;
     }
 
     // Check if the encoder has produced anything the last kEncoderTimeOutMs.
     // If not, deregister as BitrateAllocatorObserver.
     if (state_ == State::kStarted &&
@@ skipping 33 matching lines @@
 void VideoSendStream::ReconfigureVideoEncoder(
     const VideoEncoderConfig& config) {
   TRACE_EVENT0("webrtc", "VideoSendStream::(Re)configureVideoEncoder");
   LOG(LS_INFO) << "(Re)configureVideoEncoder: " << config.ToString();
   RTC_DCHECK_GE(config_.rtp.ssrcs.size(), config.streams.size());
   VideoCodec video_codec = VideoEncoderConfigToVideoCodec(
       config, config_.encoder_settings.payload_name,
       config_.encoder_settings.payload_type);
   {
     rtc::CritScope lock(&encoder_settings_crit_);
+    encoder_max_bitrate_bps_ = video_codec.maxBitrate * 1000;
     pending_encoder_settings_.reset(new EncoderSettings({video_codec, config}));
   }
   encoder_wakeup_event_.Set();
 }
 
 VideoSendStream::Stats VideoSendStream::GetStats() {
   return stats_proxy_.GetStats();
 }
 
 void VideoSendStream::OveruseDetected() {
@@ skipping 171 matching lines @@
 
 uint32_t VideoSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
                                            uint8_t fraction_loss,
                                            int64_t rtt) {
   payload_router_.SetTargetSendBitrate(bitrate_bps);
   // Get the encoder target rate. It is the estimated network rate -
   // protection overhead.
   uint32_t encoder_target_rate_bps =
       protection_bitrate_calculator_.SetTargetRates(
           bitrate_bps, stats_proxy_.GetSendFrameRate(), fraction_loss, rtt);
+
+  uint32_t protection_bitrate = bitrate_bps - encoder_target_rate_bps;
+  {
+    // Limit the target bitrate to the configured max bitrate.
+    rtc::CritScope lock(&encoder_settings_crit_);
+    encoder_target_rate_bps =
+        std::min(encoder_max_bitrate_bps_, encoder_target_rate_bps);
+  }
   vie_encoder_.OnBitrateUpdated(encoder_target_rate_bps, fraction_loss, rtt);
+  stats_proxy_.OnSetEncoderTargetRate(encoder_target_rate_bps);
 
-  return bitrate_bps - encoder_target_rate_bps;
+  return protection_bitrate;
 }
 
 int VideoSendStream::ProtectionRequest(const FecProtectionParams* delta_params,
                                        const FecProtectionParams* key_params,
                                        uint32_t* sent_video_rate_bps,
                                        uint32_t* sent_nack_rate_bps,
                                        uint32_t* sent_fec_rate_bps) {
   *sent_video_rate_bps = 0;
   *sent_nack_rate_bps = 0;
   *sent_fec_rate_bps = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     uint32_t not_used = 0;
     uint32_t module_video_rate = 0;
     uint32_t module_fec_rate = 0;
     uint32_t module_nack_rate = 0;
     rtp_rtcp->SetFecParameters(delta_params, key_params);
     rtp_rtcp->BitrateSent(&not_used, &module_video_rate, &module_fec_rate,
                           &module_nack_rate);
     *sent_video_rate_bps += module_video_rate;
     *sent_nack_rate_bps += module_nack_rate;
     *sent_fec_rate_bps += module_fec_rate;
   }
   return 0;
 }
 
 }  // namespace internal
 }  // namespace webrtc