Support multiple rtx codecs.

webrtc/modules/rtp_rtcp/source/rtp_sender.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 150 matching lines @@
       remote_ssrc_(0),
       sequence_number_forced_(false),
       ssrc_forced_(false),
       timestamp_(0),
       capture_time_ms_(0),
       last_timestamp_time_ms_(0),
       media_has_been_sent_(false),
       last_packet_marker_bit_(false),
       csrcs_(),
       rtx_(kRtxOff),
-      rtx_payload_type_(-1),
       target_bitrate_critsect_(CriticalSectionWrapper::CreateCriticalSection()),
       target_bitrate_(0) {
   memset(nack_byte_count_times_, 0, sizeof(nack_byte_count_times_));
   memset(nack_byte_count_, 0, sizeof(nack_byte_count_));
   // We need to seed the random generator for BuildPaddingPacket() below.
   // TODO(holmer,tommi): Note that TimeInMilliseconds might return 0 on Mac
   // early on in the process.
   srand(static_cast<uint32_t>(clock_->TimeInMilliseconds()));
   ssrc_ = ssrc_db_->CreateSSRC();
   RTC_DCHECK(ssrc_ != 0);
@@ skipping 251 matching lines @@
                                   int associated_payload_type) {
   rtc::CritScope lock(&send_critsect_);
   RTC_DCHECK_LE(payload_type, 127);
   RTC_DCHECK_LE(associated_payload_type, 127);
   if (payload_type < 0) {
     LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type;
     return;
   }
 
   rtx_payload_type_map_[associated_payload_type] = payload_type;
-  rtx_payload_type_ = payload_type;
-}
-
-std::pair<int, int> RTPSender::RtxPayloadType() const {
-  rtc::CritScope lock(&send_critsect_);
-  for (const auto& kv : rtx_payload_type_map_) {
-    if (kv.second == rtx_payload_type_) {
-      return std::make_pair(rtx_payload_type_, kv.first);
-    }
-  }
-  return std::make_pair(-1, -1);
 }
 
 int32_t RTPSender::CheckPayloadType(int8_t payload_type,
                                     RtpVideoCodecTypes* video_type) {
   rtc::CritScope lock(&send_critsect_);
 
   if (payload_type < 0) {
     LOG(LS_ERROR) << "Invalid payload_type " << payload_type;
     return -1;
   }
@@ skipping 195 matching lines @@
         // frame (and therefore the same timestamp).
         if (last_timestamp_time_ms_ > 0) {
           timestamp +=
               (clock_->TimeInMilliseconds() - last_timestamp_time_ms_) * 90;
           capture_time_ms +=
               (clock_->TimeInMilliseconds() - last_timestamp_time_ms_);
         }
         ssrc = ssrc_rtx_;
         sequence_number = sequence_number_rtx_;
         ++sequence_number_rtx_;
-        payload_type = rtx_payload_type_;
+        payload_type = rtx_payload_type_map_.begin()->second;
         over_rtx = true;
       }
     }
 
     uint8_t padding_packet[IP_PACKET_SIZE];
     size_t header_length =
         CreateRtpHeader(padding_packet, payload_type, ssrc, false, timestamp,
                         sequence_number, std::vector<uint32_t>());
     BuildPaddingPacket(padding_packet, header_length, padding_bytes_in_packet);
     size_t length = padding_bytes_in_packet + header_length;
@@ skipping 1167 matching lines @@
   RtpUtility::RtpHeaderParser rtp_parser(
       reinterpret_cast<const uint8_t*>(buffer), *length);
 
   RTPHeader rtp_header;
   rtp_parser.Parse(&rtp_header);
 
   // Add original RTP header.
   memcpy(data_buffer_rtx, buffer, rtp_header.headerLength);
 
   // Replace payload type, if a specific type is set for RTX.
-  if (rtx_payload_type_ != -1) {
-    data_buffer_rtx[1] = static_cast<uint8_t>(rtx_payload_type_);
-    if (rtp_header.markerBit)
-      data_buffer_rtx[1] |= kRtpMarkerBitMask;
-  }
+  auto kv = rtx_payload_type_map_.find(rtp_header.payloadType);
+  // Use rtx mapping associated with media codec if we can't find one, assuming
+  // it's red.
+  // TODO(holmer): Remove once old Chrome versions don't rely on this.
+  if (kv == rtx_payload_type_map_.end())
+    kv = rtx_payload_type_map_.find(payload_type_);
+  if (kv != rtx_payload_type_map_.end())
+    data_buffer_rtx[1] = kv->second;
+  if (rtp_header.markerBit)
+    data_buffer_rtx[1] |= kRtpMarkerBitMask;
 
   // Replace sequence number.
   uint8_t* ptr = data_buffer_rtx + 2;
   ByteWriter<uint16_t>::WriteBigEndian(ptr, sequence_number_rtx_++);
 
   // Replace SSRC.
   ptr += 6;
   ByteWriter<uint32_t>::WriteBigEndian(ptr, ssrc_rtx_);
 
   // Add OSN (original sequence number).
@@ skipping 55 matching lines @@
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc