Remove conference_mode flag from AudioOptions and VideoOptions.

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 715 matching lines @@
   }
 
   // Handle max bitrate.
   if (params.max_bandwidth_bps != bitrate_config_.max_bitrate_bps &&
       params.max_bandwidth_bps >= 0) {
     // 0 uncaps max bitrate (-1).
     changed_params->max_bandwidth_bps = rtc::Optional<int>(
         params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps);
   }
 
+  // Handle conference mode.
+  if (params.conference_mode != send_params_.conference_mode) {
+    changed_params->conference_mode =
+        rtc::Optional<bool>(params.conference_mode);
+  }
+
   // Handle options.
   // TODO(pbos): Require VideoSendParameters to contain a full set of options
   // and check if params.options != options_ instead of applying a delta.
   VideoOptions new_options = options_;
   new_options.SetAll(params.options);
   if (!(new_options == options_)) {
     changed_params->options = rtc::Optional<VideoOptions>(new_options);
   }
 
   // Handle RTCP mode.
@@ skipping 750 matching lines @@
       parameters_(config, options, max_bitrate_bps, codec_settings),
       pending_encoder_reconfiguration_(false),
       allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
       capturer_(NULL),
       sending_(false),
       muted_(false),
       old_adapt_changes_(0),
       first_frame_timestamp_ms_(0),
       last_frame_timestamp_ms_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
+  parameters_.conference_mode = send_params.conference_mode;
 
   sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
   sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
                  &parameters_.config.rtp.rtx.ssrcs);
   parameters_.config.rtp.c_name = sp.cname;
   parameters_.config.rtp.extensions = rtp_extensions;
   parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size
                                          ? webrtc::RtcpMode::kReducedSize
                                          : webrtc::RtcpMode::kCompound;
 
@@ skipping 269 matching lines @@
       capturer_->AddOrUpdateSink(this, sink_wants_);
     }
     recreate_stream = true;
   }
   if (params.max_bandwidth_bps) {
     // Max bitrate has changed, reconfigure encoder settings on the next frame
     // or stream recreation.
     parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
     pending_encoder_reconfiguration_ = true;
   }
+  if (params.conference_mode) {
+    parameters_.conference_mode = *params.conference_mode;
+  }
   // Set codecs and options.
   if (params.codec) {
     SetCodecAndOptions(*params.codec,
                        params.options ? *params.options : parameters_.options);
     return;
   } else if (params.options) {
     // Reconfigure if codecs are already set.
     if (parameters_.codec_settings) {
       SetCodecAndOptions(*parameters_.codec_settings, *params.options);
       return;
     } else {
       parameters_.options = *params.options;
     }
   }
+  else if (params.conference_mode && parameters_.codec_settings) {
+    SetCodecAndOptions(*parameters_.codec_settings, parameters_.options);
+    return;
+  }
   if (recreate_stream) {
     LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters";
     RecreateWebRtcStream();
   }
 }
 
 webrtc::VideoEncoderConfig
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
     const Dimensions& dimensions,
     const VideoCodec& codec) const {
@@ skipping 29 matching lines @@
   size_t stream_count = parameters_.config.rtp.ssrcs.size();
   if (IsCodecBlacklistedForSimulcast(codec.name) || dimensions.is_screencast) {
     stream_count = 1;
   }
 
   encoder_config.streams =
       CreateVideoStreams(clamped_codec, parameters_.options,
                          parameters_.max_bitrate_bps, stream_count);
 
   // Conference mode screencast uses 2 temporal layers split at 100kbit.
-  if (parameters_.options.conference_mode.value_or(false) &&
-      dimensions.is_screencast && encoder_config.streams.size() == 1) {
+  if (parameters_.conference_mode && dimensions.is_screencast &&
+      encoder_config.streams.size() == 1) {
     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().
     encoder_config.streams[0].target_bitrate_bps =
         config.tl0_bitrate_kbps * 1000;
     encoder_config.streams[0].max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
     encoder_config.streams[0].temporal_layer_thresholds_bps.clear();
     encoder_config.streams[0].temporal_layer_thresholds_bps.push_back(
@@ skipping 613 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             fec_settings.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket