Implementing auto pausing of video streams.

webrtc/video/vie_encoder.cc

 /*
  *  Copyright (c) 2012 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 114 matching lines @@
         RTC_NOTREACHED();
         break;
     }
     stats_proxy_->SetContentType(content_type);
   }
 }
 
 int ViEEncoder::GetPaddingNeededBps() const {
   int64_t time_of_last_frame_activity_ms;
   int min_transmit_bitrate_bps;
-  int bitrate_bps;
   VideoCodec send_codec;
+  bool video_is_suspended;
   {
     rtc::CritScope lock(&data_cs_);
     bool send_padding = encoder_config_.numberOfSimulcastStreams > 1 ||
                         video_suspended_ || min_transmit_bitrate_bps_ > 0;
     if (!send_padding)
       return 0;
     time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
     min_transmit_bitrate_bps = min_transmit_bitrate_bps_;
-    bitrate_bps = last_observed_bitrate_bps_;
     send_codec = encoder_config_;
+    video_is_suspended = video_suspended_;
   }
 
-  bool video_is_suspended = video_sender_.VideoSuspended();
-
   // Find the max amount of padding we can allow ourselves to send at this
   // point, based on which streams are currently active and what our current
   // available bandwidth is.
   int pad_up_to_bitrate_bps = 0;
   if (send_codec.numberOfSimulcastStreams == 0) {
     pad_up_to_bitrate_bps = send_codec.minBitrate * 1000;
   } else {
     SimulcastStream* stream_configs = send_codec.simulcastStream;
     pad_up_to_bitrate_bps =
         stream_configs[send_codec.numberOfSimulcastStreams - 1].minBitrate *
@@ skipping 11 matching lines @@
   // The amount of padding should decay to zero if no frames are being
   // captured/encoded unless a min-transmit bitrate is used.
   int64_t now_ms = rtc::TimeMillis();
   if (now_ms - time_of_last_frame_activity_ms > kStopPaddingThresholdMs)
     pad_up_to_bitrate_bps = 0;
 
   // Pad up to min bitrate.
   if (pad_up_to_bitrate_bps < min_transmit_bitrate_bps)
     pad_up_to_bitrate_bps = min_transmit_bitrate_bps;
 
-  // Padding may never exceed bitrate estimate.
-  if (pad_up_to_bitrate_bps > bitrate_bps)
-    pad_up_to_bitrate_bps = bitrate_bps;
-
   return pad_up_to_bitrate_bps;
 }
 
 bool ViEEncoder::EncoderPaused() const {
   // Pause video if paused by caller or as long as the network is down or the
   // pacer queue has grown too large in buffered mode.
   // If the pacer queue has grown to large or the network is down,
   // last_observed_bitrate_bps_ will be 0.
   return encoder_paused_ || video_suspended_ || last_observed_bitrate_bps_ == 0;
 }
@@ skipping 117 matching lines @@
 }
 
 void ViEEncoder::OnBitrateUpdated(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
                                   int64_t round_trip_time_ms) {
   LOG(LS_VERBOSE) << "OnBitrateUpdated, bitrate " << bitrate_bps
                   << " packet loss " << static_cast<int>(fraction_lost)
                   << " rtt " << round_trip_time_ms;
   video_sender_.SetChannelParameters(bitrate_bps, fraction_lost,
                                      round_trip_time_ms);
-  bool video_is_suspended = video_sender_.VideoSuspended();
   bool video_suspension_changed;
+  bool video_is_suspended = bitrate_bps == 0;
   {
     rtc::CritScope lock(&data_cs_);
     last_observed_bitrate_bps_ = bitrate_bps;
     video_suspension_changed = video_suspended_ != video_is_suspended;
     video_suspended_ = video_is_suspended;
   }
 
-  if (!video_suspension_changed)
-    return;
-  // Video suspend-state changed, inform codec observer.
-  LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended;
-
-  if (stats_proxy_)
+  if (stats_proxy_ && video_suspension_changed) {
+    LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended;
     stats_proxy_->OnSuspendChange(video_is_suspended);
+  }
 }
 
 }  // namespace webrtc