Rename {,Set}GenericFECStatus to {,Set}UlpfecConfig.

webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc

 /*
  *  Copyright (c) 2012 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 29 matching lines @@
   RTC_DCHECK(red_payload);
   red_payload[0] = media_packet.PayloadType();
   memcpy(&red_payload[kRedForFecHeaderLength], media_packet.payload(),
          media_packet.payload_size());
 }
 }  // namespace
 
 RTPSenderVideo::RTPSenderVideo(Clock* clock, RTPSender* rtp_sender)
     : rtp_sender_(rtp_sender),
       clock_(clock),
+      video_type_(kRtpVideoGeneric),
+      retransmission_settings_(kRetransmitBaseLayer),
+      last_rotation_(kVideoRotation_0),
+      fec_enabled_(false),
+      red_payload_type_(-1),
+      fec_payload_type_(-1),
+      delta_fec_params_{0, 1, kFecMaskRandom},
+      key_fec_params_{0, 1, kFecMaskRandom},
       fec_bitrate_(1000, RateStatistics::kBpsScale),
       video_bitrate_(1000, RateStatistics::kBpsScale) {
   encoder_checker_.Detach();
 }
 
 RTPSenderVideo::~RTPSenderVideo() {}
 
 void RTPSenderVideo::SetVideoCodecType(RtpVideoCodecTypes video_type) {
   video_type_ = video_type;
 }
@@ skipping 104 matching lines @@
       fec_bitrate_.Update(fec_packet->length(), clock_->TimeInMilliseconds());
       TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                            "Video::PacketFec", "timestamp", rtp_timestamp,
                            "seqnum", fec_sequence_number);
     } else {
       LOG(LS_WARNING) << "Failed to send FEC packet " << fec_sequence_number;
     }
   }
 }
 
-void RTPSenderVideo::SetGenericFECStatus(bool enable,
-                                         uint8_t payload_type_red,
-                                         uint8_t payload_type_fec) {
-  RTC_DCHECK(!enable || payload_type_red > 0);
+void RTPSenderVideo::SetUlpfecConfig(bool enabled,
+                                     int red_payload_type,
+                                     int ulpfec_payload_type) {
+  RTC_DCHECK(!enabled || red_payload_type > 0);
+  RTC_DCHECK_LE(red_payload_type, 127);
+  RTC_DCHECK_LE(ulpfec_payload_type, 127);
+
   rtc::CritScope cs(&crit_);
-  fec_enabled_ = enable;
-  red_payload_type_ = payload_type_red;
-  fec_payload_type_ = payload_type_fec;
+  fec_enabled_ = enabled;
+  red_payload_type_ = red_payload_type;
+  fec_payload_type_ = ulpfec_payload_type;
+
+  // Reset FEC rates.
   delta_fec_params_ = FecProtectionParams{0, 1, kFecMaskRandom};
   key_fec_params_ = FecProtectionParams{0, 1, kFecMaskRandom};
 }
 
-void RTPSenderVideo::GenericFECStatus(bool* enable,
-                                      uint8_t* payload_type_red,
-                                      uint8_t* payload_type_fec) const {
+void RTPSenderVideo::GetUlpfecConfig(bool* enabled,
+                                     int* red_payload_type,
+                                     int* ulpfec_payload_type) const {
   rtc::CritScope cs(&crit_);
-  *enable = fec_enabled_;
-  *payload_type_red = red_payload_type_;
-  *payload_type_fec = fec_payload_type_;
+  *enabled = fec_enabled_;
+  *red_payload_type = red_payload_type_;
+  *ulpfec_payload_type = fec_payload_type_;
 }
 
 size_t RTPSenderVideo::FecPacketOverhead() const {
   rtc::CritScope cs(&crit_);
   size_t overhead = 0;
-  if (red_payload_type_ != 0) {
+  if (red_payload_type_ != -1) {
     // Overhead is FEC headers plus RED for FEC header plus anything in RTP
     // header beyond the 12 bytes base header (CSRC list, extensions...)
     // This reason for the header extensions to be included here is that
     // from an FEC viewpoint, they are part of the payload to be protected.
     // (The base RTP header is already protected by the FEC header.)
     return ulpfec_generator_.MaxPacketOverhead() + kRedForFecHeaderLength +
            (rtp_sender_->RtpHeaderLength() - kRtpHeaderSize);
   }
   if (fec_enabled_)
     overhead += ulpfec_generator_.MaxPacketOverhead();
@@ skipping 89 matching lines @@
 
     size_t payload_bytes_in_packet = 0;
     if (!packetizer->NextPacket(payload, &payload_bytes_in_packet, &last))
       return false;
 
     packet->SetPayloadSize(payload_bytes_in_packet);
     packet->SetMarker(last);
     if (!rtp_sender_->AssignSequenceNumber(packet.get()))
       return false;
 
-    if (red_payload_type != 0) {
+    if (red_payload_type != -1) {
       SendVideoPacketAsRed(std::move(packet), storage,
                            packetizer->GetProtectionType() == kProtectedPacket);
     } else {
       SendVideoPacket(std::move(packet), storage);
     }
 
     if (first_frame) {
       if (first) {
         LOG(LS_INFO)
             << "Sent first RTP packet of the first video frame (pre-pacer)";
@@ skipping 25 matching lines @@
   rtc::CritScope cs(&crit_);
   return retransmission_settings_;
 }
 
 void RTPSenderVideo::SetSelectiveRetransmissions(uint8_t settings) {
   rtc::CritScope cs(&crit_);
   retransmission_settings_ = settings;
 }
 
 }  // namespace webrtc