Add more logging about the bwe state and VideoSendStream state.

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 379 matching lines @@
       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),
+      encoder_target_rate_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 110 matching lines @@
   }
 }
 
 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->IncomingRtcpPacket(packet, length);
   return true;
 }
 
 void VideoSendStream::Start() {
+  LOG(LS_INFO) << "VideoSendStream::Start";
   if (payload_router_.active())
     return;
   TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Start");
   payload_router_.set_active(true);
   {
     rtc::CritScope lock(&encoder_settings_crit_);
     pending_state_change_ = rtc::Optional<State>(State::kStarted);
   }
   encoder_wakeup_event_.Set();
 }
 
 void VideoSendStream::Stop() {
+  LOG(LS_INFO) << "VideoSendStream::Stop";
   if (!payload_router_.active())
     return;
   TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop");
   payload_router_.set_active(false);
   {
     rtc::CritScope lock(&encoder_settings_crit_);
     pending_state_change_ = rtc::Optional<State>(State::kStopped);
   }
   encoder_wakeup_event_.Set();
 }
@@ skipping 336 matching lines @@
   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);
+    if ((encoder_target_rate_bps_ == 0 && encoder_target_rate_bps > 0) ||
+        (encoder_target_rate_bps_ > 0 && encoder_target_rate_bps == 0)) {
+      LOG(LS_INFO)
+          << "OnBitrateUpdated: Encoder state changed, target bitrate "
+          << encoder_target_rate_bps << " bps.";
+    }
+    encoder_target_rate_bps_ = encoder_target_rate_bps;
   }
   vie_encoder_.OnBitrateUpdated(encoder_target_rate_bps, fraction_loss, rtt);
   stats_proxy_.OnSetEncoderTargetRate(encoder_target_rate_bps);
 
   return protection_bitrate;
 }
 
 int VideoSendStream::ProtectionRequest(const FecProtectionParams* delta_params,
                                        const FecProtectionParams* key_params,
                                        uint32_t* sent_video_rate_bps,
@@ skipping 12 matching lines @@
                           &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