Refactor how padding is calculated.

webrtc/video/video_send_stream.cc

Index: webrtc/video/video_send_stream.cc
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 31ba5ee31c0aaa537e51f6ea5f0b13f977748361..6c58840dccd5986317c704af62666b7a6fdd6888 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -342,6 +342,28 @@ VideoCodec VideoEncoderConfigToVideoCodec(const VideoEncoderConfig& config,
   return video_codec;
 }
 
+int CalulcateMaxPadBitrateBps(const VideoEncoderConfig& config,
+                              bool pad_to_min_bitrate) {
+  int pad_up_to_bitrate_bps = 0;
+  // Calulate max padding bitrate for a multi layer codec.
+  if (config.streams.size() > 1) {
+    // Pad to min bitrate of the highest layer.
+    pad_up_to_bitrate_bps =
+        config.streams[config.streams.size() - 1].min_bitrate_bps;
+    // + target_bitrate_bps of the lower layers.
+    for (size_t i = 0; i < config.streams.size() - 1; ++i) {
+      pad_up_to_bitrate_bps += config.streams[i].target_bitrate_bps;
+    }
+  } else if (pad_to_min_bitrate) {
+    pad_up_to_bitrate_bps = config.streams[0].min_bitrate_bps;
+  }
+
+  pad_up_to_bitrate_bps =
+      std::max(pad_up_to_bitrate_bps, config.min_transmit_bitrate_bps);
+
+  return pad_up_to_bitrate_bps;
+}
+
 }  // namespace
 
 namespace internal {
@@ -533,7 +555,8 @@ void VideoSendStream::EncoderProcess() {
                       config_.encoder_settings.internal_source));
 
   while (true) {
-    encoder_wakeup_event_.Wait(rtc::Event::kForever);
+    const int kEncodeCheckForActiviyPeriodMs = 1000;
+    encoder_wakeup_event_.Wait(kEncodeCheckForActiviyPeriodMs);
     if (rtc::AtomicOps::AcquireLoad(&stop_encoder_thread_))
       break;
     rtc::Optional<EncoderSettings> encoder_settings;
@@ -549,12 +572,13 @@ void VideoSendStream::EncoderProcess() {
           bitrate_allocator_->AddObserver(
               this, encoder_settings->video_codec.minBitrate * 1000,
               encoder_settings->video_codec.maxBitrate * 1000,
+              CalulcateMaxPadBitrateBps(encoder_settings->config,
+                                        config_.suspend_below_min_bitrate),
               !config_.suspend_below_min_bitrate) /
           1000;
 
-      payload_router_.SetSendStreams(encoder_settings->streams);
+      payload_router_.SetSendStreams(encoder_settings->config.streams);
       vie_encoder_.SetEncoder(encoder_settings->video_codec,
-                              encoder_settings->min_transmit_bitrate_bps,
                               payload_router_.MaxPayloadLength());
 
       // vie_encoder_.SetEncoder must be called before this.
@@ -562,7 +586,7 @@ void VideoSendStream::EncoderProcess() {
         video_sender_->SuspendBelowMinBitrate();
 
       // Clear stats for disabled layers.
-      for (size_t i = encoder_settings->streams.size();
+      for (size_t i = encoder_settings->config.streams.size();
            i < config_.rtp.ssrcs.size(); ++i) {
         stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
       }
@@ -583,6 +607,10 @@ void VideoSendStream::EncoderProcess() {
       }
       vie_encoder_.EncodeVideoFrame(frame);
     }
+
+    // TODO(perkj): This is temporary. Activity should be notified by ViEncoder
+    // once it owns its own thread.
+    vie_encoder_.CheckForActivity();
   }
   vie_encoder_.DeRegisterExternalEncoder(config_.encoder_settings.payload_type);
 }
@@ -597,8 +625,8 @@ void VideoSendStream::ReconfigureVideoEncoder(
       config_.encoder_settings.payload_type);
   {
     rtc::CritScope lock(&encoder_settings_crit_);
-    pending_encoder_settings_ = rtc::Optional<EncoderSettings>(
-        {video_codec, config.min_transmit_bitrate_bps, config.streams});
+    pending_encoder_settings_ =
+        rtc::Optional<EncoderSettings>({video_codec, config});
   }
   encoder_wakeup_event_.Set();
 }
@@ -652,6 +680,12 @@ int32_t VideoSendStream::Encoded(const EncodedImage& encoded_image,
   return return_value;
 }
 
+void VideoSendStream::OnEncoderActivityChanged(bool active) {
+  // Notify the |bitrate_allocator_| if the encoder have timed out so it can
+  // stop sending padding if applicable.
+  bitrate_allocator_->NotifyObserverInactive(this, !active);
+}
+
 void VideoSendStream::ConfigureProtection() {
   // Enable NACK, FEC or both.
   const bool enable_protection_nack = config_.rtp.nack.rtp_history_ms > 0;
@@ -773,10 +807,6 @@ void VideoSendStream::SignalNetworkState(NetworkState state) {
   }
 }
 
-int VideoSendStream::GetPaddingNeededBps() const {
-  return vie_encoder_.GetPaddingNeededBps();
-}
-
 void VideoSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
                                        uint8_t fraction_loss,
                                        int64_t rtt) {