Reland of Add experimental simulcast screen content mode

webrtc/modules/video_coding/utility/simulcast_rate_allocator.cc

 /*
  *  Copyright (c) 2016 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 88 matching lines @@
 
     uint32_t target_bitrate_kbps =
         allocated_bitrates_bps.GetBitrate(simulcast_id, 0) / 1000;
     const uint32_t expected_allocated_bitrate_kbps = target_bitrate_kbps;
     RTC_DCHECK_EQ(
         target_bitrate_kbps,
         allocated_bitrates_bps.GetSpatialLayerSum(simulcast_id) / 1000);
     const int num_temporal_streams = std::max<uint8_t>(
         1, codec_.numberOfSimulcastStreams == 0
                ? codec_.VP8().numberOfTemporalLayers
-               : codec_.simulcastStream[0].numberOfTemporalLayers);
+               : codec_.simulcastStream[simulcast_id].numberOfTemporalLayers);
 
     uint32_t max_bitrate_kbps;
-    if (num_spatial_streams == 1) {
-      max_bitrate_kbps = codec_.maxBitrate;
-
-      // TODO(holmer): This is a temporary hack for screensharing, where we
+    // Legacy temporal-layered only screenshare, or simulcast screenshare
+    // with legacy mode for simulcast stream 0.
+    if (codec_.mode == kScreensharing && codec_.targetBitrate > 0 &&
+        ((num_spatial_streams == 1 && num_temporal_streams == 2) ||  // Legacy.
+         (num_spatial_streams > 1 && simulcast_id == 0))) {  // Simulcast.
+      // TODO(holmer): This is a "temporary" hack for screensharing, where we
       // interpret the startBitrate as the encoder target bitrate. This is
       // to allow for a different max bitrate, so if the codec can't meet
       // the target we still allow it to overshoot up to the max before dropping
       // frames. This hack should be improved.
-      if (codec_.mode == kScreensharing && codec_.targetBitrate > 0 &&
-          num_temporal_streams == 2) {
-        int tl0_bitrate = std::min(codec_.targetBitrate, target_bitrate_kbps);
-        max_bitrate_kbps = std::min(codec_.maxBitrate, target_bitrate_kbps);
-        target_bitrate_kbps = tl0_bitrate;
-      }
+      int tl0_bitrate = std::min(codec_.targetBitrate, target_bitrate_kbps);
+      max_bitrate_kbps = std::min(codec_.maxBitrate, target_bitrate_kbps);
+      target_bitrate_kbps = tl0_bitrate;
+    } else if (num_spatial_streams == 1) {
+      max_bitrate_kbps = codec_.maxBitrate;
     } else {
       max_bitrate_kbps = codec_.simulcastStream[simulcast_id].maxBitrate;
     }
 
     std::vector<uint32_t> tl_allocation = tl_it->second->OnRatesUpdated(
         target_bitrate_kbps, max_bitrate_kbps, framerate);
     RTC_DCHECK_GT(tl_allocation.size(), 0);
     RTC_DCHECK_LE(tl_allocation.size(), num_temporal_streams);
 
     uint64_t tl_allocation_sum_kbps = 0;
@@ skipping 16 matching lines @@
   BitrateAllocation allocation =
       temp_allocator.GetAllocation(codec_.maxBitrate * 1000, framerate);
   return allocation.get_sum_bps();
 }
 
 const VideoCodec& webrtc::SimulcastRateAllocator::GetCodec() const {
   return codec_;
 }
 
 }  // namespace webrtc