Simplify {,Set}UlpfecConfig interface.

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include "webrtc/video/video_send_stream.h"
@@ skipping 916 matching lines @@
     }
   }
 
   return result;
 }
 
 void VideoSendStreamImpl::ConfigureProtection() {
   RTC_DCHECK_RUN_ON(worker_queue_);
   // Enable NACK, FEC or both.
   const bool enable_protection_nack = config_->rtp.nack.rtp_history_ms > 0;
-  bool enable_protection_fec = config_->rtp.ulpfec.ulpfec_payload_type != -1;
+  const int red_payload_type = config_->rtp.ulpfec.red_payload_type;
+  int ulpfec_payload_type = config_->rtp.ulpfec.ulpfec_payload_type;
   // Payload types without picture ID cannot determine that a stream is complete
   // without retransmitting FEC, so using FEC + NACK for H.264 (for instance) is
   // a waste of bandwidth since FEC packets still have to be transmitted. Note
   // that this is not the case with FLEXFEC.
   if (enable_protection_nack &&
       !PayloadTypeSupportsSkippingFecPackets(
           config_->encoder_settings.payload_name)) {
     LOG(LS_WARNING) << "Transmitting payload type without picture ID using"
                        "NACK+FEC is a waste of bandwidth since FEC packets "
                        "also have to be retransmitted. Disabling FEC.";
-    enable_protection_fec = false;
+    ulpfec_payload_type = -1;
   }
 
   // TODO(brandtr): Remove the workaround described below.
   //
   // In theory, we should enable RED if and only if ULPFEC is also enabled,
   // and vice versa. (We only support ULPFEC over RED, not multiplexed in any
   // other way.) However, due to the RED/RTX workaround introduced here:
   // https://codereview.webrtc.org/1649493004, we need to send media over RED
   // (even if ULPFEC is disabled), whenever RED has been negotiated in the SDP.
   // This is due to the associated payload type is hardcoded to be RED in the
   // receiver, whenever RED appears in the SDP. If we would not send media over
   // RED in this case, the RTX receiver would recover retransmitted packets
   // using the wrong payload type.
 
   // Verify validity of provided payload types.
-  if (config_->rtp.ulpfec.red_payload_type != -1) {
-    RTC_DCHECK_GE(config_->rtp.ulpfec.red_payload_type, 0);
-    RTC_DCHECK_LE(config_->rtp.ulpfec.red_payload_type, 127);
+  if (red_payload_type != -1) {
+    RTC_DCHECK_GE(red_payload_type, 0);
+    RTC_DCHECK_LE(red_payload_type, 127);
   }
-  if (config_->rtp.ulpfec.ulpfec_payload_type != -1) {
-    RTC_DCHECK_GE(config_->rtp.ulpfec.ulpfec_payload_type, 0);
-    RTC_DCHECK_LE(config_->rtp.ulpfec.ulpfec_payload_type, 127);
+  if (ulpfec_payload_type != -1) {
+    RTC_DCHECK_GE(ulpfec_payload_type, 0);
+    RTC_DCHECK_LE(ulpfec_payload_type, 127);
   }
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     // Set NACK.
     rtp_rtcp->SetStorePacketsStatus(
         enable_protection_nack || congestion_controller_->pacer(),
         kMinSendSidePacketHistorySize);
     // Set FEC.
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
-      rtp_rtcp->SetUlpfecConfig(enable_protection_fec,
-                                config_->rtp.ulpfec.red_payload_type,
-                                config_->rtp.ulpfec.ulpfec_payload_type);
+      rtp_rtcp->SetUlpfecConfig(red_payload_type, ulpfec_payload_type);
     }
   }
 
+  const bool enable_protection_fec = (ulpfec_payload_type != -1);
   protection_bitrate_calculator_.SetProtectionMethod(enable_protection_fec,
                                                      enable_protection_nack);
 }
 
 void VideoSendStreamImpl::ConfigureSsrcs() {
   RTC_DCHECK_RUN_ON(worker_queue_);
   // Configure regular SSRCs.
   for (size_t i = 0; i < config_->rtp.ssrcs.size(); ++i) {
     uint32_t ssrc = config_->rtp.ssrcs[i];
     RtpRtcp* const rtp_rtcp = rtp_rtcp_modules_[i];
@@ skipping 121 matching lines @@
                           &module_nack_rate);
     *sent_video_rate_bps += module_video_rate;
     *sent_nack_rate_bps += module_nack_rate;
     *sent_fec_rate_bps += module_fec_rate;
   }
   return 0;
 }
 
 }  // namespace internal
 }  // namespace webrtc