RtpRtcp: Remove the SetSendREDPayloadType and SendREDPayloadType methods

webrtc/modules/rtp_rtcp/source/rtp_sender_audio.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 17 matching lines @@
       packet_size_samples_(160),
       dtmf_event_is_on_(false),
       dtmf_event_first_packet_sent_(false),
       dtmf_payload_type_(-1),
       dtmf_timestamp_(0),
       dtmf_key_(0),
       dtmf_length_samples_(0),
       dtmf_level_(0),
       dtmf_time_last_sent_(0),
       dtmf_timestamp_last_sent_(0),
-      red_payload_type_(-1),
       inband_vad_active_(false),
       cngnb_payload_type_(-1),
       cngwb_payload_type_(-1),
       cngswb_payload_type_(-1),
       cngfb_payload_type_(-1),
       last_payload_type_(-1),
       audio_level_dbov_(0) {}
 
 RTPSenderAudio::~RTPSenderAudio() {}
 
@@ skipping 100 matching lines @@
                                   int8_t payload_type,
                                   uint32_t capture_timestamp,
                                   const uint8_t* payload_data,
                                   size_t data_size,
                                   const RTPFragmentationHeader* fragmentation) {
   // TODO(pwestin) Breakup function in smaller functions.
   size_t payload_size = data_size;
   size_t max_payload_length = rtp_sender_->MaxPayloadLength();
   uint16_t dtmf_length_ms = 0;
   uint8_t key = 0;
-  int red_payload_type;
   uint8_t audio_level_dbov;
   int8_t dtmf_payload_type;
   uint16_t packet_size_samples;
   {
     rtc::CritScope cs(&send_audio_critsect_);
-    red_payload_type = red_payload_type_;
     audio_level_dbov = audio_level_dbov_;
     dtmf_payload_type = dtmf_payload_type_;
     packet_size_samples = packet_size_samples_;
   }
 
   // Check if we have pending DTMFs to send
   if (!dtmf_event_is_on_ && PendingDTMF()) {
     int64_t delaySinceLastDTMF =
         clock_->TimeInMilliseconds() - dtmf_time_last_sent_;
 
@@ skipping 68 matching lines @@
       // we don't send empty audio RTP packets
       // no error since we use it to drive DTMF when we use VAD
       return true;
     }
     return false;
   }
   uint8_t data_buffer[IP_PACKET_SIZE];
   bool marker_bit = MarkerBit(frame_type, payload_type);
 
   int32_t rtpHeaderLength = 0;
-  uint16_t timestampOffset = 0;
 
-  if (red_payload_type >= 0 && fragmentation && !marker_bit &&
-      fragmentation->fragmentationVectorSize > 1) {
-    // have we configured RED? use its payload type
-    // we need to get the current timestamp to calc the diff
-    uint32_t old_timestamp = rtp_sender_->Timestamp();
-    rtpHeaderLength = rtp_sender_->BuildRtpHeader(data_buffer, red_payload_type,
-                                                  marker_bit, capture_timestamp,
-                                                  clock_->TimeInMilliseconds());
-
-    timestampOffset = uint16_t(rtp_sender_->Timestamp() - old_timestamp);
-  } else {
-    rtpHeaderLength = rtp_sender_->BuildRtpHeader(data_buffer, payload_type,
-                                                  marker_bit, capture_timestamp,
-                                                  clock_->TimeInMilliseconds());
-  }
+  rtpHeaderLength = rtp_sender_->BuildRtpHeader(data_buffer, payload_type,
+                                                marker_bit, capture_timestamp,
+                                                clock_->TimeInMilliseconds());
   if (rtpHeaderLength <= 0) {
     return false;
   }
   if (max_payload_length < (rtpHeaderLength + payload_size)) {
     // Too large payload buffer.
     return false;
   }
-  if (red_payload_type >= 0 &&  // Have we configured RED?
-      fragmentation && fragmentation->fragmentationVectorSize > 1 &&
-      !marker_bit) {
-    if (timestampOffset <= 0x3fff) {
-      if (fragmentation->fragmentationVectorSize != 2) {
-        // we only support 2 codecs when using RED
-        return false;
-      }
-      // only 0x80 if we have multiple blocks
-      data_buffer[rtpHeaderLength++] =
-          0x80 + fragmentation->fragmentationPlType[1];
-      size_t blockLength = fragmentation->fragmentationLength[1];
+  if (fragmentation && fragmentation->fragmentationVectorSize > 0) {
+    // use the fragment info if we have one
+    data_buffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
+    memcpy(data_buffer + rtpHeaderLength,
+           payload_data + fragmentation->fragmentationOffset[0],
+           fragmentation->fragmentationLength[0]);
 
-      // sanity blockLength
-      if (blockLength > 0x3ff) {  // block length 10 bits 1023 bytes
-        return false;
-      }
-      uint32_t REDheader = (timestampOffset << 10) + blockLength;
-      ByteWriter<uint32_t>::WriteBigEndian(data_buffer + rtpHeaderLength,
-                                           REDheader);
-      rtpHeaderLength += 3;
-
-      data_buffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
-      // copy the RED data
-      memcpy(data_buffer + rtpHeaderLength,
-             payload_data + fragmentation->fragmentationOffset[1],
-             fragmentation->fragmentationLength[1]);
-
-      // copy the normal data
-      memcpy(
-          data_buffer + rtpHeaderLength + fragmentation->fragmentationLength[1],
-          payload_data + fragmentation->fragmentationOffset[0],
-          fragmentation->fragmentationLength[0]);
-
-      payload_size = fragmentation->fragmentationLength[0] +
-                     fragmentation->fragmentationLength[1];
-    } else {
-      // silence for too long send only new data
-      data_buffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
-      memcpy(data_buffer + rtpHeaderLength,
-             payload_data + fragmentation->fragmentationOffset[0],
-             fragmentation->fragmentationLength[0]);
-
-      payload_size = fragmentation->fragmentationLength[0];
-    }
+    payload_size = fragmentation->fragmentationLength[0];
   } else {
-    if (fragmentation && fragmentation->fragmentationVectorSize > 0) {
-      // use the fragment info if we have one
-      data_buffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
-      memcpy(data_buffer + rtpHeaderLength,
-             payload_data + fragmentation->fragmentationOffset[0],
-             fragmentation->fragmentationLength[0]);
-
-      payload_size = fragmentation->fragmentationLength[0];
-    } else {
-      memcpy(data_buffer + rtpHeaderLength, payload_data, payload_size);
-    }
+    memcpy(data_buffer + rtpHeaderLength, payload_data, payload_size);
   }
 
   {
     rtc::CritScope cs(&send_audio_critsect_);
     last_payload_type_ = payload_type;
   }
   // Update audio level extension, if included.
   size_t packetSize = payload_size + rtpHeaderLength;
   RtpUtility::RtpHeaderParser rtp_parser(data_buffer, packetSize);
   RTPHeader rtp_header;
@@ skipping 16 matching lines @@
 // Audio level magnitude and voice activity flag are set for each RTP packet
 int32_t RTPSenderAudio::SetAudioLevel(uint8_t level_dbov) {
   if (level_dbov > 127) {
     return -1;
   }
   rtc::CritScope cs(&send_audio_critsect_);
   audio_level_dbov_ = level_dbov;
   return 0;
 }
 
-// Set payload type for Redundant Audio Data RFC 2198
-int32_t RTPSenderAudio::SetRED(int8_t payload_type) {
-  if (payload_type < -1) {
-    return -1;
-  }
-  rtc::CritScope cs(&send_audio_critsect_);
-  red_payload_type_ = payload_type;
-  return 0;
-}
-
-// Get payload type for Redundant Audio Data RFC 2198
-int32_t RTPSenderAudio::RED(int8_t* payload_type) const {
-  rtc::CritScope cs(&send_audio_critsect_);
-  if (red_payload_type_ == -1) {
-    // not configured
-    return -1;
-  }
-  *payload_type = red_payload_type_;
-  return 0;
-}
-
 // Send a TelephoneEvent tone using RFC 2833 (4733)
 int32_t RTPSenderAudio::SendTelephoneEvent(uint8_t key,
                                            uint16_t time_ms,
                                            uint8_t level) {
   {
     rtc::CritScope lock(&send_audio_critsect_);
     if (dtmf_payload_type_ < 0) {
       // TelephoneEvent payloadtype not configured
       return -1;
     }
@@ skipping 51 matching lines @@
         "timestamp", dtmf_timestamp, "seqnum", rtp_sender_->SequenceNumber());
     result = rtp_sender_->SendToNetwork(dtmfbuffer, 4, 12, rtc::TimeMillis(),
                                         kAllowRetransmission,
                                         RtpPacketSender::kHighPriority);
     send_count--;
   } while (send_count > 0 && result);
 
   return result;
 }
 }  // namespace webrtc