Add experimental simulcast screen content mode

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 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 283 matching lines @@
         max_qp_(max_qp),
         max_framerate_(max_framerate),
         is_screencast_(is_screencast),
         conference_mode_(conference_mode) {}
 
  private:
   std::vector<webrtc::VideoStream> CreateEncoderStreams(
       int width,
       int height,
       const webrtc::VideoEncoderConfig& encoder_config) override {
-    RTC_DCHECK(encoder_config.number_of_streams > 1 ? !is_screencast_ : true);
-    if (encoder_config.number_of_streams > 1) {
+    if (is_screencast_ &&
+        (!conference_mode_ || !cricket::UseSimulcastScreenshare())) {
+      RTC_DCHECK_EQ(1, encoder_config.number_of_streams);
+    }
+    if (encoder_config.number_of_streams > 1 ||
+        (CodecNamesEq(codec_name_, kVp8CodecName) && is_screencast_ &&
+         conference_mode_)) {
       return GetSimulcastConfig(encoder_config.number_of_streams, width, height,
                                 encoder_config.max_bitrate_bps, max_qp_,
-                                max_framerate_);
+                                max_framerate_, is_screencast_);
     }
 
     // For unset max bitrates set default bitrate for non-simulcast.
     int max_bitrate_bps =
         (encoder_config.max_bitrate_bps > 0)
             ? encoder_config.max_bitrate_bps
             : GetMaxDefaultVideoBitrateKbps(width, height) * 1000;
 
     webrtc::VideoStream stream;
     stream.width = width;
     stream.height = height;
     stream.max_framerate = max_framerate_;
     stream.min_bitrate_bps = kMinVideoBitrateKbps * 1000;
     stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
     stream.max_qp = max_qp_;
 
-    // Conference mode screencast uses 2 temporal layers split at 100kbit.
-    if (conference_mode_ && is_screencast_) {
-      ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
-      // For screenshare in conference mode, tl0 and tl1 bitrates are
-      // piggybacked
-      // on the VideoCodec struct as target and max bitrates, respectively.
-      // See eg. webrtc::VP8EncoderImpl::SetRates().
-      stream.target_bitrate_bps = config.tl0_bitrate_kbps * 1000;
-      stream.max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
-      stream.temporal_layer_thresholds_bps.clear();
-      stream.temporal_layer_thresholds_bps.push_back(config.tl0_bitrate_kbps *
-                                                     1000);
-    }
-
     if (CodecNamesEq(codec_name_, kVp9CodecName) && !is_screencast_) {
       stream.temporal_layer_thresholds_bps.resize(
           GetDefaultVp9TemporalLayers() - 1);
     }
 
     std::vector<webrtc::VideoStream> streams;
     streams.push_back(stream);
     return streams;
   }
 
@@ skipping 1192 matching lines @@
     // TODO(deadbeef): Don't duplicate information between send_params,
     // rtp_extensions, options, etc.
     const VideoSendParameters& send_params)
     : worker_thread_(rtc::Thread::Current()),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       enable_cpu_overuse_detection_(enable_cpu_overuse_detection),
       source_(nullptr),
       external_encoder_factory_(external_encoder_factory),
+      internal_encoder_factory_(new InternalEncoderFactory()),
       stream_(nullptr),
       encoder_sink_(nullptr),
       parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
       rtp_parameters_(CreateRtpParametersWithOneEncoding()),
       allocated_encoder_(nullptr, cricket::VideoCodec(), false),
       sending_(false),
       last_frame_timestamp_us_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
   parameters_.conference_mode = send_params.conference_mode;
 
@@ skipping 167 matching lines @@
   // Try creating external encoder.
   if (external_encoder_factory_ != nullptr &&
       FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) {
     webrtc::VideoEncoder* encoder =
         external_encoder_factory_->CreateVideoEncoder(codec);
     if (encoder != nullptr)
       return AllocatedEncoder(encoder, codec, true /* is_external */);
   }
 
   // Try creating internal encoder.
-  InternalEncoderFactory internal_encoder_factory;
-  if (FindMatchingCodec(internal_encoder_factory.supported_codecs(), codec)) {
-    return AllocatedEncoder(internal_encoder_factory.CreateVideoEncoder(codec),
-                            codec, false /* is_external */);
+  if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(), codec)) {

[perkj_webrtc, 2017/01/17 13:09:03]

internal_encoder_factory_ does not seem to be used by this class after this
function. 
Can who ever needs internal_encoder_factory_ after this method return own it?
create a std::unique_ptr and move it to where its needed.

[sprang_webrtc, 2017/01/17 13:23:27]

It's the SimulcastEncoderAdapter that uses this reference, and it's used in the
InitEncode() call which happens on a separate thread. 

Unfortunately the adapter normally takes a pointer to an external encoder
factory, which we don't want to delete. So in that case it would have to keep
track of if the instance should be deleted or not :(

+    if (parameters_.encoder_config.content_type ==
+            webrtc::VideoEncoderConfig::ContentType::kScreen &&
+        parameters_.conference_mode && UseSimulcastScreenshare()) {
+      // TODO(sprang): Remove this adapter once libvpx supports simulcast with
+      // same-resolution substreams.
+      WebRtcSimulcastEncoderFactory adapter_factory(
+          internal_encoder_factory_.get());
+      return AllocatedEncoder(adapter_factory.CreateVideoEncoder(codec), codec,
+                              false /* is_external */);
+    }
+    return AllocatedEncoder(
+        internal_encoder_factory_->CreateVideoEncoder(codec), codec,
+        false /* is_external */);
   }
 
   // This shouldn't happen, we should not be trying to create something we don't
   // support.
   RTC_DCHECK(false);
   return AllocatedEncoder(NULL, cricket::VideoCodec(), false);
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
     AllocatedEncoder* encoder) {
@@ skipping 156 matching lines @@
     encoder_config.content_type =
         webrtc::VideoEncoderConfig::ContentType::kScreen;
   } else {
     encoder_config.min_transmit_bitrate_bps = 0;
     encoder_config.content_type =
         webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
   }
 
   // By default, the stream count for the codec configuration should match the
   // number of negotiated ssrcs. But if the codec is blacklisted for simulcast
-  // or a screencast, only configure a single stream.
+  // or a screencast (and not in simulcast screenshare experiment), only
+  // configure a single stream.
   encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size();
-  if (IsCodecBlacklistedForSimulcast(codec.name) || is_screencast) {
+  if (IsCodecBlacklistedForSimulcast(codec.name) ||
+      (is_screencast && !UseSimulcastScreenshare())) {
     encoder_config.number_of_streams = 1;
   }
 
   int stream_max_bitrate =
       MinPositive(rtp_parameters_.encodings[0].max_bitrate_bps,
                   parameters_.max_bitrate_bps);
 
   int codec_max_bitrate_kbps;
   if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
     stream_max_bitrate = codec_max_bitrate_kbps * 1000;
@@ skipping 656 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             ulpfec_config.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket