Delete remnants of RTX support in voice_engine.

webrtc/voice_engine/channel.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 887 matching lines @@
       _callbackCritSectPtr(NULL),
       _transportPtr(NULL),
       input_mute_(false),
       previous_frame_muted_(false),
       _outputGain(1.0f),
       _mixFileWithMicrophone(false),
       _includeAudioLevelIndication(false),
       transport_overhead_per_packet_(0),
       rtp_overhead_per_packet_(0),
       _outputSpeechType(AudioFrame::kNormalSpeech),
-      restored_packet_in_use_(false),
       rtcp_observer_(new VoERtcpObserver(this)),
       associate_send_channel_(ChannelOwner(nullptr)),
       pacing_enabled_(config.enable_voice_pacing),
       feedback_observer_proxy_(new TransportFeedbackProxy()),
       seq_num_allocator_proxy_(new TransportSequenceNumberProxy()),
       rtp_packet_sender_proxy_(new RtpPacketSenderProxy()),
       retransmission_rate_limiter_(new RateLimiter(Clock::GetRealTimeClock(),
                                                    kMaxRetransmissionWindowMs)),
       decoder_factory_(config.acm_config.decoder_factory),
       use_twcc_plr_for_ana_(
@@ skipping 821 matching lines @@
 
   RTPHeader header;
   packet.GetHeader(&header);
   OnRtpPacketWithHeader(packet.data(), packet.size(), &header);
 }
 
 bool Channel::ReceivePacket(const uint8_t* packet,
                             size_t packet_length,
                             const RTPHeader& header,
                             bool in_order) {
-  if (rtp_payload_registry_->IsRtx(header)) {
-    return HandleRtxPacket(packet, packet_length, header);
-  }
   const uint8_t* payload = packet + header.headerLength;
   assert(packet_length >= header.headerLength);
   size_t payload_length = packet_length - header.headerLength;
   PayloadUnion payload_specific;
   if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
                                                   &payload_specific)) {
     return false;
   }
   return rtp_receiver_->IncomingRtpPacket(header, payload, payload_length,
                                           payload_specific, in_order);
 }
 
-bool Channel::HandleRtxPacket(const uint8_t* packet,
-                              size_t packet_length,
-                              const RTPHeader& header) {
-  if (!rtp_payload_registry_->IsRtx(header))
-    return false;
-
-  // Remove the RTX header and parse the original RTP header.
-  if (packet_length < header.headerLength)
-    return false;
-  if (packet_length > kVoiceEngineMaxIpPacketSizeBytes)
-    return false;
-  if (restored_packet_in_use_) {
-    WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVoice, _channelId,
-                 "Multiple RTX headers detected, dropping packet");
-    return false;
-  }
-  if (!rtp_payload_registry_->RestoreOriginalPacket(
-          restored_packet_, packet, &packet_length, rtp_receiver_->SSRC(),
-          header)) {
-    WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVoice, _channelId,
-                 "Incoming RTX packet: invalid RTP header");
-    return false;
-  }
-  restored_packet_in_use_ = true;
-  bool ret = OnRecoveredPacket(restored_packet_, packet_length);
-  restored_packet_in_use_ = false;
-  return ret;
-}
-
 bool Channel::IsPacketInOrder(const RTPHeader& header) const {
   StreamStatistician* statistician =
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   return statistician->IsPacketInOrder(header.sequenceNumber);
 }
 
 bool Channel::IsPacketRetransmitted(const RTPHeader& header,
                                     bool in_order) const {
-  // Retransmissions are handled separately if RTX is enabled.
-  if (rtp_payload_registry_->RtxEnabled())
-    return false;
   StreamStatistician* statistician =
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   // Check if this is a retransmission.
   int64_t min_rtt = 0;
   _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), NULL, NULL, &min_rtt, NULL);
   return !in_order && statistician->IsRetransmitOfOldPacket(header, min_rtt);
 }
 
@@ skipping 1348 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc