Updated structures and functions for setting the max bitrate limit to take rtc::Optional<int>

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 60 matching lines @@
   }
   if (codec.GetParam(kCodecParamStartBitrate, &bitrate_kbps) &&
       bitrate_kbps > 0) {
     config.start_bitrate_bps = bitrate_kbps * 1000;
   } else {
     // Do not reconfigure start bitrate unless it's specified and positive.
     config.start_bitrate_bps = -1;
   }
   if (codec.GetParam(kCodecParamMaxBitrate, &bitrate_kbps) &&
       bitrate_kbps > 0) {
-    config.max_bitrate_bps = bitrate_kbps * 1000;
+    config.max_bitrate_bps = rtc::Optional<int>(bitrate_kbps * 1000);
   } else {
-    config.max_bitrate_bps = -1;
+    config.max_bitrate_bps = rtc::Optional<int>();
   }
   return config;
 }
 
 // An encoder factory that wraps Create requests for simulcastable codec types
 // with a webrtc::SimulcastEncoderAdapter. Non simulcastable codec type
 // requests are just passed through to the contained encoder factory.
 class WebRtcSimulcastEncoderFactory
     : public cricket::WebRtcVideoEncoderFactory {
  public:
@@ skipping 261 matching lines @@
   codecs.push_back(
       VideoCodec::CreateRtxCodec(kDefaultRtxRedPlType, kDefaultRedPlType));
   codecs.push_back(VideoCodec(kDefaultUlpfecType, kUlpfecCodecName));
   return codecs;
 }
 
 std::vector<webrtc::VideoStream>
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateSimulcastVideoStreams(
     const VideoCodec& codec,
     const VideoOptions& options,
-    int max_bitrate_bps,
+    rtc::Optional<int> max_bitrate_bps,
     size_t num_streams) {
   int max_qp = kDefaultQpMax;
   codec.GetParam(kCodecParamMaxQuantization, &max_qp);
 
+  // TODO(skvlad): Consider replacing special case constants with
+  // rtc::Optional<int>
   return GetSimulcastConfig(
       num_streams, codec.width, codec.height, max_bitrate_bps, max_qp,
       codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate);
 }
 
 std::vector<webrtc::VideoStream>
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams(
     const VideoCodec& codec,
     const VideoOptions& options,
-    int max_bitrate_bps,
+    rtc::Optional<int> max_bitrate_bps,
     size_t num_streams) {
   int codec_max_bitrate_kbps;
   if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
-    max_bitrate_bps = codec_max_bitrate_kbps * 1000;
+    max_bitrate_bps = rtc::Optional<int>(codec_max_bitrate_kbps * 1000);
   }
   if (num_streams != 1) {
     return CreateSimulcastVideoStreams(codec, options, max_bitrate_bps,
                                        num_streams);
   }
 
   // For unset max bitrates set default bitrate for non-simulcast.
-  if (max_bitrate_bps <= 0) {
-    max_bitrate_bps =
-        GetMaxDefaultVideoBitrateKbps(codec.width, codec.height) * 1000;
+  if (!max_bitrate_bps) {
+    max_bitrate_bps = rtc::Optional<int>(
+        GetMaxDefaultVideoBitrateKbps(codec.width, codec.height) * 1000);
   }
 
   webrtc::VideoStream stream;
   stream.width = codec.width;
   stream.height = codec.height;
   stream.max_framerate =
       codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
 
   stream.min_bitrate_bps = kMinVideoBitrate * 1000;
-  stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
+  stream.target_bitrate_bps = stream.max_bitrate_bps = *max_bitrate_bps;
 
   int max_qp = kDefaultQpMax;
   codec.GetParam(kCodecParamMaxQuantization, &max_qp);
   stream.max_qp = max_qp;
   std::vector<webrtc::VideoStream> streams;
   streams.push_back(stream);
   return streams;
 }
 
 void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
@@ skipping 305 matching lines @@
 
   // Handle RTP header extensions.
   std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
       params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true);
   if (send_rtp_extensions_ != filtered_extensions) {
     changed_params->rtp_header_extensions =
         rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
   }
 
   // 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);

[Taylor Brandstetter, 2016/03/29 02:26:58]

Are we taking away the behavior where 0 uncaps max bitrate here?

[skvlad, 2016/03/30 19:40:44]

Yes, that is the intention. An unset Optional<int> uncaps the max bitrate, and a
positive value caps it. An Optional with a 0 or negative value is an error.

This may change the treatment of "b=AS:0" in SDP, though: previously it could
uncap the bandwidth for video, or leave it unchanged for audio. Now it will be
an error. Is it important to keep the previous interpretation? I could not find
anything about the meaning of zero bandwidth in any of the relevant RFCs.

+  if (params.max_bitrate_bps != bitrate_config_.max_bitrate_bps) {
+    changed_params->max_bandwidth_bps =
+        rtc::Optional<rtc::Optional<int>>(params.max_bitrate_bps);
   }
 
   // Handle conference mode.
   if (params.conference_mode != send_params_.conference_mode) {
     changed_params->conference_mode =
         rtc::Optional<bool>(params.conference_mode);
   }
 
   // Handle RTCP mode.
   if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) {
@@ skipping 32 matching lines @@
 
   if (changed_params.rtp_header_extensions) {
     send_rtp_extensions_ = *changed_params.rtp_header_extensions;
   }
 
   if (changed_params.max_bandwidth_bps) {
     // TODO(pbos): Figure out whether b=AS means max bitrate for this
     // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC), in
     // which case this should not set a Call::BitrateConfig but rather
     // reconfigure all senders.
-    int max_bitrate_bps = *changed_params.max_bandwidth_bps;
     bitrate_config_.start_bitrate_bps = -1;
-    bitrate_config_.max_bitrate_bps = max_bitrate_bps;
-    if (max_bitrate_bps > 0 &&
-        bitrate_config_.min_bitrate_bps > max_bitrate_bps) {
-      bitrate_config_.min_bitrate_bps = max_bitrate_bps;
+    bitrate_config_.max_bitrate_bps = *changed_params.max_bandwidth_bps;
+    if (bitrate_config_.max_bitrate_bps &&
+        (bitrate_config_.min_bitrate_bps > *bitrate_config_.max_bitrate_bps)) {
+      bitrate_config_.min_bitrate_bps = *bitrate_config_.max_bitrate_bps;
     }
     bitrate_config_changed = true;
   }
 
   if (bitrate_config_changed) {
     call_->SetBitrateConfig(bitrate_config_);
   }
 
   {
     rtc::CritScope stream_lock(&stream_crit_);
@@ skipping 648 matching lines @@
            send_streams_.begin();
        it != send_streams_.end(); ++it) {
     it->second->Stop();
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
     VideoSendStreamParameters(
         const webrtc::VideoSendStream::Config& config,
         const VideoOptions& options,
-        int max_bitrate_bps,
+        rtc::Optional<int> max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings)
     : config(config),
       options(options),
       max_bitrate_bps(max_bitrate_bps),
       codec_settings(codec_settings) {}
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
     webrtc::VideoEncoder* encoder,
     webrtc::VideoCodecType type,
     bool external)
     : encoder(encoder),
       external_encoder(nullptr),
       type(type),
       external(external) {
   if (external) {
     external_encoder = encoder;
     this->encoder =
         new webrtc::VideoEncoderSoftwareFallbackWrapper(type, encoder);
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
     webrtc::Call* call,
     const StreamParams& sp,
     const webrtc::VideoSendStream::Config& config,
     const VideoOptions& options,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     bool enable_cpu_overuse_detection,
-    int max_bitrate_bps,
+    rtc::Optional<int> max_bitrate_bps,
     const rtc::Optional<VideoCodecSettings>& codec_settings,
     const std::vector<webrtc::RtpExtension>& rtp_extensions,
     // 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),
       cpu_restricted_counter_(0),
@@ skipping 338 matching lines @@
   return true;
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::ValidateRtpParameters(
     const webrtc::RtpParameters& rtp_parameters) {
   if (rtp_parameters.encodings.size() != 1) {
     LOG(LS_ERROR)
         << "Attempted to set RtpParameters without exactly one encoding";
     return false;
   }
+  if (rtp_parameters.encodings[0].max_bitrate_bps &&
+      (*rtp_parameters.encodings[0].max_bitrate_bps <= 0)) {
+    LOG(LS_ERROR) << "Attempted to set a negative bitrate limit";
+    return false;
+  }
   return true;
 }
 
 webrtc::VideoEncoderConfig
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
     const Dimensions& dimensions,
     const VideoCodec& codec) const {
   webrtc::VideoEncoderConfig encoder_config;
   bool is_screencast = parameters_.options.is_screencast.value_or(false);
   if (is_screencast) {
@@ skipping 22 matching lines @@
   clamped_codec.height = height;
 
   // 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.
   size_t stream_count = parameters_.config.rtp.ssrcs.size();
   if (IsCodecBlacklistedForSimulcast(codec.name) || is_screencast) {
     stream_count = 1;
   }
 
-  int stream_max_bitrate =
-      MinPositive(rtp_parameters_.encodings[0].max_bitrate_bps,
+  rtc::Optional<int> stream_max_bitrate =
+      OptionalMin(rtp_parameters_.encodings[0].max_bitrate_bps,
                   parameters_.max_bitrate_bps);
   encoder_config.streams = CreateVideoStreams(
       clamped_codec, parameters_.options, stream_max_bitrate, stream_count);
 
   // Conference mode screencast uses 2 temporal layers split at 100kbit.
   if (parameters_.conference_mode && is_screencast &&
       encoder_config.streams.size() == 1) {
     ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
 
     // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked
@@ skipping 665 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