diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn
index 2095aad..b078285 100644
--- a/modules/rtp_rtcp/BUILD.gn
+++ b/modules/rtp_rtcp/BUILD.gn
@@ -347,6 +347,7 @@
       "../../api:array_view",
       "../../api:libjingle_peerconnection_api",
       "../../api:transport_api",
+      "../../call:rtp_receiver",
       "../../common_video:common_video",
       "../../rtc_base:rtc_base_approved",
       "../../system_wrappers:system_wrappers",
diff --git a/modules/rtp_rtcp/include/rtp_payload_registry.h b/modules/rtp_rtcp/include/rtp_payload_registry.h
index a84e2d3..4eda28d 100644
--- a/modules/rtp_rtcp/include/rtp_payload_registry.h
+++ b/modules/rtp_rtcp/include/rtp_payload_registry.h
@@ -53,20 +53,8 @@
 
   void SetRtxPayloadType(int payload_type, int associated_payload_type);
 
-  bool IsRtx(const RTPHeader& header) const;
-
-  bool RestoreOriginalPacket(uint8_t* restored_packet,
-                             const uint8_t* packet,
-                             size_t* packet_length,
-                             uint32_t original_ssrc,
-                             const RTPHeader& header);
-
   bool IsRed(const RTPHeader& header) const;
 
-  // Returns true if the media of this RTP packet is encapsulated within an
-  // extra header, such as RTX or RED.
-  bool IsEncapsulated(const RTPHeader& header) const;
-
   bool GetPayloadSpecifics(uint8_t payload_type, PayloadUnion* payload) const;
 
   int GetPayloadTypeFrequency(uint8_t payload_type) const;
diff --git a/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/modules/rtp_rtcp/source/nack_rtx_unittest.cc
index 32c9d5b..1a68726 100644
--- a/modules/rtp_rtcp/source/nack_rtx_unittest.cc
+++ b/modules/rtp_rtcp/source/nack_rtx_unittest.cc
@@ -15,13 +15,13 @@
 #include <set>
 
 #include "webrtc/api/call/transport.h"
+#include "webrtc/call/rtp_stream_receiver_controller.h"
+#include "webrtc/call/rtx_receive_stream.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "webrtc/rtc_base/rate_limiter.h"
 #include "webrtc/test/gtest.h"
 
@@ -29,6 +29,7 @@
 
 const int kVideoNackListSize = 30;
 const uint32_t kTestSsrc = 3456;
+const uint32_t kTestRtxSsrc = kTestSsrc + 1;
 const uint16_t kTestSequenceNumber = 2345;
 const uint32_t kTestNumberOfPackets = 1350;
 const int kTestNumberOfRtxPackets = 149;
@@ -37,35 +38,19 @@
 const int kRtxPayloadType = 98;
 const int64_t kMaxRttMs = 1000;
 
-class VerifyingRtxReceiver : public RtpData {
+class VerifyingMediaStream : public RtpPacketSinkInterface {
  public:
-  VerifyingRtxReceiver() {}
+  VerifyingMediaStream() {}
 
-  int32_t OnReceivedPayloadData(
-      const uint8_t* data,
-      size_t size,
-      const webrtc::WebRtcRTPHeader* rtp_header) override {
+  void OnRtpPacket(const RtpPacketReceived& packet) override {
     if (!sequence_numbers_.empty())
-      EXPECT_EQ(kTestSsrc, rtp_header->header.ssrc);
-    sequence_numbers_.push_back(rtp_header->header.sequenceNumber);
-    return 0;
+      EXPECT_EQ(kTestSsrc, packet.Ssrc());
+
+    sequence_numbers_.push_back(packet.SequenceNumber());
   }
   std::list<uint16_t> sequence_numbers_;
 };
 
-class TestRtpFeedback : public NullRtpFeedback {
- public:
-  explicit TestRtpFeedback(RtpRtcp* rtp_rtcp) : rtp_rtcp_(rtp_rtcp) {}
-  virtual ~TestRtpFeedback() {}
-
-  void OnIncomingSSRCChanged(uint32_t ssrc) override {
-    rtp_rtcp_->SetRemoteSSRC(ssrc);
-  }
-
- private:
-  RtpRtcp* rtp_rtcp_;
-};
-
 class RtxLoopBackTransport : public webrtc::Transport {
  public:
   explicit RtxLoopBackTransport(uint32_t rtx_ssrc)
@@ -75,16 +60,10 @@
         consecutive_drop_end_(0),
         rtx_ssrc_(rtx_ssrc),
         count_rtx_ssrc_(0),
-        rtp_payload_registry_(NULL),
-        rtp_receiver_(NULL),
         module_(NULL) {}
 
-  void SetSendModule(RtpRtcp* rtpRtcpModule,
-                     RTPPayloadRegistry* rtp_payload_registry,
-                     RtpReceiver* receiver) {
+  void SetSendModule(RtpRtcp* rtpRtcpModule) {
     module_ = rtpRtcpModule;
-    rtp_payload_registry_ = rtp_payload_registry;
-    rtp_receiver_ = receiver;
   }
 
   void DropEveryNthPacket(int n) { packet_loss_ = n; }
@@ -99,24 +78,15 @@
                size_t len,
                const PacketOptions& options) override {
     count_++;
-    const unsigned char* ptr = static_cast<const unsigned char*>(data);
-    uint32_t ssrc = (ptr[8] << 24) + (ptr[9] << 16) + (ptr[10] << 8) + ptr[11];
-    if (ssrc == rtx_ssrc_)
-      count_rtx_ssrc_++;
-    uint16_t sequence_number = (ptr[2] << 8) + ptr[3];
-    size_t packet_length = len;
-    uint8_t restored_packet[1500];
-    RTPHeader header;
-    std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
-    if (!parser->Parse(ptr, len, &header)) {
+    RtpPacketReceived packet;
+    if (!packet.Parse(data, len))
       return false;
-    }
-
-    if (!rtp_payload_registry_->IsRtx(header)) {
-      // Don't store retransmitted packets since we compare it to the list
-      // created by the receiver.
+    if (packet.Ssrc() == rtx_ssrc_) {
+      count_rtx_ssrc_++;
+    } else {
+      // For non-RTX packets only.
       expected_sequence_numbers_.insert(expected_sequence_numbers_.end(),
-                                        sequence_number);
+                                        packet.SequenceNumber());
     }
     if (packet_loss_ > 0) {
       if ((count_ % packet_loss_) == 0) {
@@ -126,28 +96,7 @@
                count_ < consecutive_drop_end_) {
       return true;
     }
-    if (rtp_payload_registry_->IsRtx(header)) {
-      // Remove the RTX header and parse the original RTP header.
-      EXPECT_TRUE(rtp_payload_registry_->RestoreOriginalPacket(
-          restored_packet, ptr, &packet_length, rtp_receiver_->SSRC(), header));
-      if (!parser->Parse(restored_packet, packet_length, &header)) {
-        return false;
-      }
-      ptr = restored_packet;
-    } else {
-      rtp_payload_registry_->SetIncomingPayloadType(header);
-    }
-
-    PayloadUnion payload_specific;
-    if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
-                                                    &payload_specific)) {
-      return false;
-    }
-    if (!rtp_receiver_->IncomingRtpPacket(header, ptr + header.headerLength,
-                                          packet_length - header.headerLength,
-                                          payload_specific, true)) {
-      return false;
-    }
+    EXPECT_TRUE(stream_receiver_controller_.OnRtpPacket(packet));
     return true;
   }
 
@@ -160,9 +109,8 @@
   int consecutive_drop_end_;
   uint32_t rtx_ssrc_;
   int count_rtx_ssrc_;
-  RTPPayloadRegistry* rtp_payload_registry_;
-  RtpReceiver* rtp_receiver_;
   RtpRtcp* module_;
+  RtpStreamReceiverController stream_receiver_controller_;
   std::set<uint16_t> expected_sequence_numbers_;
 };
 
@@ -170,8 +118,10 @@
  protected:
   RtpRtcpRtxNackTest()
       : rtp_rtcp_module_(nullptr),
-        transport_(kTestSsrc + 1),
-        receiver_(),
+        transport_(kTestRtxSsrc),
+        rtx_stream_(&media_stream_,
+                    rtx_associated_payload_types_,
+                    kTestSsrc),
         payload_data_length(sizeof(payload_data)),
         fake_clock(123456),
         retransmission_rate_limiter_(&fake_clock, kMaxRttMs) {}
@@ -187,11 +137,6 @@
     configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
     rtp_rtcp_module_ = RtpRtcp::CreateRtpRtcp(configuration);
 
-    rtp_feedback_.reset(new TestRtpFeedback(rtp_rtcp_module_));
-
-    rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
-        &fake_clock, &receiver_, rtp_feedback_.get(), &rtp_payload_registry_));
-
     rtp_rtcp_module_->SetSSRC(kTestSsrc);
     rtp_rtcp_module_->SetRTCPStatus(RtcpMode::kCompound);
     rtp_rtcp_module_->SetStorePacketsStatus(true, 600);
@@ -199,18 +144,16 @@
     rtp_rtcp_module_->SetSequenceNumber(kTestSequenceNumber);
     rtp_rtcp_module_->SetStartTimestamp(111111);
 
-    transport_.SetSendModule(rtp_rtcp_module_, &rtp_payload_registry_,
-                             rtp_receiver_.get());
+    // Used for NACK processing.
+    // TODO(nisse): Unclear on which side? It's confusing to use a
+    // single rtp_rtcp module for both send and receive side.
+    rtp_rtcp_module_->SetRemoteSSRC(kTestSsrc);
 
-    VideoCodec video_codec;
-    memset(&video_codec, 0, sizeof(video_codec));
-    video_codec.plType = kPayloadType;
-    memcpy(video_codec.plName, "I420", 5);
-
-    EXPECT_EQ(0, rtp_rtcp_module_->RegisterSendPayload(video_codec));
+    rtp_rtcp_module_->RegisterVideoSendPayload(kPayloadType, "video");
     rtp_rtcp_module_->SetRtxSendPayloadType(kRtxPayloadType, kPayloadType);
-    EXPECT_EQ(0, rtp_payload_registry_.RegisterReceivePayload(video_codec));
-    rtp_payload_registry_.SetRtxPayloadType(kRtxPayloadType, kPayloadType);
+    transport_.SetSendModule(rtp_rtcp_module_);
+    media_receiver_ = transport_.stream_receiver_controller_.CreateReceiver(
+        kTestSsrc, &media_stream_);
 
     for (size_t n = 0; n < payload_data_length; n++) {
       payload_data[n] = n % 10;
@@ -218,14 +161,14 @@
   }
 
   int BuildNackList(uint16_t* nack_list) {
-    receiver_.sequence_numbers_.sort();
+    media_stream_.sequence_numbers_.sort();
     std::list<uint16_t> missing_sequence_numbers;
-    std::list<uint16_t>::iterator it = receiver_.sequence_numbers_.begin();
+    std::list<uint16_t>::iterator it = media_stream_.sequence_numbers_.begin();
 
-    while (it != receiver_.sequence_numbers_.end()) {
+    while (it != media_stream_.sequence_numbers_.end()) {
       uint16_t sequence_number_1 = *it;
       ++it;
-      if (it != receiver_.sequence_numbers_.end()) {
+      if (it != media_stream_.sequence_numbers_.end()) {
         uint16_t sequence_number_2 = *it;
         // Add all missing sequence numbers to list
         for (uint16_t i = sequence_number_1 + 1; i < sequence_number_2; ++i) {
@@ -243,8 +186,8 @@
 
   bool ExpectedPacketsReceived() {
     std::list<uint16_t> received_sorted;
-    std::copy(receiver_.sequence_numbers_.begin(),
-              receiver_.sequence_numbers_.end(),
+    std::copy(media_stream_.sequence_numbers_.begin(),
+              media_stream_.sequence_numbers_.end(),
               std::back_inserter(received_sorted));
     received_sorted.sort();
     return received_sorted.size() ==
@@ -254,9 +197,10 @@
   }
 
   void RunRtxTest(RtxMode rtx_method, int loss) {
-    rtp_payload_registry_.SetRtxSsrc(kTestSsrc + 1);
+    rtx_receiver_ = transport_.stream_receiver_controller_.CreateReceiver(
+        kTestRtxSsrc, &rtx_stream_);
     rtp_rtcp_module_->SetRtxSendStatus(rtx_method);
-    rtp_rtcp_module_->SetRtxSsrc(kTestSsrc + 1);
+    rtp_rtcp_module_->SetRtxSsrc(kTestRtxSsrc);
     transport_.DropEveryNthPacket(loss);
     uint32_t timestamp = 3000;
     uint16_t nack_list[kVideoNackListSize];
@@ -274,22 +218,24 @@
       // Prepare next frame.
       timestamp += 3000;
     }
-    receiver_.sequence_numbers_.sort();
+    media_stream_.sequence_numbers_.sort();
   }
 
   void TearDown() override { delete rtp_rtcp_module_; }
 
   std::unique_ptr<ReceiveStatistics> receive_statistics_;
-  RTPPayloadRegistry rtp_payload_registry_;
-  std::unique_ptr<RtpReceiver> rtp_receiver_;
   RtpRtcp* rtp_rtcp_module_;
-  std::unique_ptr<TestRtpFeedback> rtp_feedback_;
   RtxLoopBackTransport transport_;
-  VerifyingRtxReceiver receiver_;
+  const std::map<int, int> rtx_associated_payload_types_ =
+      {{kRtxPayloadType, kPayloadType}};
+  VerifyingMediaStream media_stream_;
+  RtxReceiveStream rtx_stream_;
   uint8_t payload_data[65000];
   size_t payload_data_length;
   SimulatedClock fake_clock;
   RateLimiter retransmission_rate_limiter_;
+  std::unique_ptr<RtpStreamReceiverInterface> media_receiver_;
+  std::unique_ptr<RtpStreamReceiverInterface> rtx_receiver_;
 };
 
 TEST_F(RtpRtcpRtxNackTest, LongNackList) {
@@ -316,26 +262,26 @@
     rtp_rtcp_module_->Process();
   }
   EXPECT_FALSE(transport_.expected_sequence_numbers_.empty());
-  EXPECT_FALSE(receiver_.sequence_numbers_.empty());
-  size_t last_receive_count = receiver_.sequence_numbers_.size();
+  EXPECT_FALSE(media_stream_.sequence_numbers_.empty());
+  size_t last_receive_count = media_stream_.sequence_numbers_.size();
   int length = BuildNackList(nack_list);
   for (int i = 0; i < kNumRequiredRtcp - 1; ++i) {
     rtp_rtcp_module_->SendNACK(nack_list, length);
-    EXPECT_GT(receiver_.sequence_numbers_.size(), last_receive_count);
-    last_receive_count = receiver_.sequence_numbers_.size();
+    EXPECT_GT(media_stream_.sequence_numbers_.size(), last_receive_count);
+    last_receive_count = media_stream_.sequence_numbers_.size();
     EXPECT_FALSE(ExpectedPacketsReceived());
   }
   rtp_rtcp_module_->SendNACK(nack_list, length);
-  EXPECT_GT(receiver_.sequence_numbers_.size(), last_receive_count);
+  EXPECT_GT(media_stream_.sequence_numbers_.size(), last_receive_count);
   EXPECT_TRUE(ExpectedPacketsReceived());
 }
 
 TEST_F(RtpRtcpRtxNackTest, RtxNack) {
   RunRtxTest(kRtxRetransmitted, 10);
-  EXPECT_EQ(kTestSequenceNumber, *(receiver_.sequence_numbers_.begin()));
+  EXPECT_EQ(kTestSequenceNumber, *(media_stream_.sequence_numbers_.begin()));
   EXPECT_EQ(kTestSequenceNumber + kTestNumberOfPackets - 1,
-            *(receiver_.sequence_numbers_.rbegin()));
-  EXPECT_EQ(kTestNumberOfPackets, receiver_.sequence_numbers_.size());
+            *(media_stream_.sequence_numbers_.rbegin()));
+  EXPECT_EQ(kTestNumberOfPackets, media_stream_.sequence_numbers_.size());
   EXPECT_EQ(kTestNumberOfRtxPackets, transport_.count_rtx_ssrc_);
   EXPECT_TRUE(ExpectedPacketsReceived());
 }
diff --git a/modules/rtp_rtcp/source/rtp_payload_registry.cc b/modules/rtp_rtcp/source/rtp_payload_registry.cc
index 35616b6..fe2bc80 100644
--- a/modules/rtp_rtcp/source/rtp_payload_registry.cc
+++ b/modules/rtp_rtcp/source/rtp_payload_registry.cc
@@ -14,7 +14,6 @@
 
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/codecs/audio_format_conversion.h"
-#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/stringutils.h"
@@ -270,65 +269,10 @@
   return rtx_;
 }
 
-bool RTPPayloadRegistry::IsRtx(const RTPHeader& header) const {
-  rtc::CritScope cs(&crit_sect_);
-  return IsRtxInternal(header);
-}
-
 bool RTPPayloadRegistry::IsRtxInternal(const RTPHeader& header) const {
   return rtx_ && ssrc_rtx_ == header.ssrc;
 }
 
-bool RTPPayloadRegistry::RestoreOriginalPacket(uint8_t* restored_packet,
-                                               const uint8_t* packet,
-                                               size_t* packet_length,
-                                               uint32_t original_ssrc,
-                                               const RTPHeader& header) {
-  if (kRtxHeaderSize + header.headerLength + header.paddingLength >
-      *packet_length) {
-    return false;
-  }
-  const uint8_t* rtx_header = packet + header.headerLength;
-  uint16_t original_sequence_number = (rtx_header[0] << 8) + rtx_header[1];
-
-  // Copy the packet into the restored packet, except for the RTX header.
-  memcpy(restored_packet, packet, header.headerLength);
-  memcpy(restored_packet + header.headerLength,
-         packet + header.headerLength + kRtxHeaderSize,
-         *packet_length - header.headerLength - kRtxHeaderSize);
-  *packet_length -= kRtxHeaderSize;
-
-  // Replace the SSRC and the sequence number with the originals.
-  ByteWriter<uint16_t>::WriteBigEndian(restored_packet + 2,
-                                       original_sequence_number);
-  ByteWriter<uint32_t>::WriteBigEndian(restored_packet + 8, original_ssrc);
-
-  rtc::CritScope cs(&crit_sect_);
-  if (!rtx_)
-    return true;
-
-  auto apt_mapping = rtx_payload_type_map_.find(header.payloadType);
-  if (apt_mapping == rtx_payload_type_map_.end()) {
-    // No associated payload type found. Warn, unless we have already done so.
-    if (payload_types_with_suppressed_warnings_.find(header.payloadType) ==
-        payload_types_with_suppressed_warnings_.end()) {
-      LOG(LS_WARNING)
-          << "No RTX associated payload type mapping was available; "
-             "not able to restore original packet from RTX packet "
-             "with payload type: "
-          << static_cast<int>(header.payloadType) << ". "
-          << "Suppressing further warnings for this payload type.";
-      payload_types_with_suppressed_warnings_.insert(header.payloadType);
-    }
-    return false;
-  }
-  restored_packet[1] = static_cast<uint8_t>(apt_mapping->second);
-  if (header.markerBit) {
-    restored_packet[1] |= kRtpMarkerBitMask;  // Marker bit is set.
-  }
-  return true;
-}
-
 void RTPPayloadRegistry::SetRtxSsrc(uint32_t ssrc) {
   rtc::CritScope cs(&crit_sect_);
   ssrc_rtx_ = ssrc;
@@ -359,10 +303,6 @@
   return it != payload_type_map_.end() && _stricmp(it->second.name, "red") == 0;
 }
 
-bool RTPPayloadRegistry::IsEncapsulated(const RTPHeader& header) const {
-  return IsRed(header) || IsRtx(header);
-}
-
 bool RTPPayloadRegistry::GetPayloadSpecifics(uint8_t payload_type,
                                              PayloadUnion* payload) const {
   rtc::CritScope cs(&crit_sect_);
diff --git a/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc b/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
index f5707d2..6e17eb9 100644
--- a/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
@@ -13,7 +13,6 @@
 #include "webrtc/common_types.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
-#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
@@ -259,105 +258,6 @@
             rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored));
 }
 
-// Generates an RTX packet for the given length and original sequence number.
-// The RTX sequence number and ssrc will use the default value of 9999. The
-// caller takes ownership of the returned buffer.
-const uint8_t* GenerateRtxPacket(size_t header_length,
-                                 size_t payload_length,
-                                 uint16_t original_sequence_number) {
-  uint8_t* packet =
-      new uint8_t[kRtxHeaderSize + header_length + payload_length]();
-  // Write the RTP version to the first byte, so the resulting header can be
-  // parsed.
-  static const int kRtpExpectedVersion = 2;
-  packet[0] = static_cast<uint8_t>(kRtpExpectedVersion << 6);
-  // Write a junk sequence number. It should be thrown away when the packet is
-  // restored.
-  ByteWriter<uint16_t>::WriteBigEndian(packet + 2, 9999);
-  // Write a junk ssrc. It should also be thrown away when the packet is
-  // restored.
-  ByteWriter<uint32_t>::WriteBigEndian(packet + 8, 9999);
-
-  // Now write the RTX header. It occurs at the start of the payload block, and
-  // contains just the sequence number.
-  ByteWriter<uint16_t>::WriteBigEndian(packet + header_length,
-                                       original_sequence_number);
-  return packet;
-}
-
-void TestRtxPacket(RTPPayloadRegistry* rtp_payload_registry,
-                   int rtx_payload_type,
-                   int expected_payload_type,
-                   bool should_succeed) {
-  size_t header_length = 100;
-  size_t payload_length = 200;
-  size_t original_length = header_length + payload_length + kRtxHeaderSize;
-
-  RTPHeader header;
-  header.ssrc = 1000;
-  header.sequenceNumber = 100;
-  header.payloadType = rtx_payload_type;
-  header.headerLength = header_length;
-
-  uint16_t original_sequence_number = 1234;
-  uint32_t original_ssrc = 500;
-
-  std::unique_ptr<const uint8_t[]> packet(GenerateRtxPacket(
-      header_length, payload_length, original_sequence_number));
-  std::unique_ptr<uint8_t[]> restored_packet(
-      new uint8_t[header_length + payload_length]);
-  size_t length = original_length;
-  bool success = rtp_payload_registry->RestoreOriginalPacket(
-      restored_packet.get(), packet.get(), &length, original_ssrc, header);
-  EXPECT_EQ(should_succeed, success)
-      << "Test success should match should_succeed.";
-  if (!success) {
-    return;
-  }
-
-  EXPECT_EQ(original_length - kRtxHeaderSize, length)
-      << "The restored packet should be exactly kRtxHeaderSize smaller.";
-
-  std::unique_ptr<RtpHeaderParser> header_parser(RtpHeaderParser::Create());
-  RTPHeader restored_header;
-  ASSERT_TRUE(
-      header_parser->Parse(restored_packet.get(), length, &restored_header));
-  EXPECT_EQ(original_sequence_number, restored_header.sequenceNumber)
-      << "The restored packet should have the original sequence number "
-      << "in the correct location in the RTP header.";
-  EXPECT_EQ(expected_payload_type, restored_header.payloadType)
-      << "The restored packet should have the correct payload type.";
-  EXPECT_EQ(original_ssrc, restored_header.ssrc)
-      << "The restored packet should have the correct ssrc.";
-}
-
-TEST(RtpPayloadRegistryTest, MultipleRtxPayloadTypes) {
-  RTPPayloadRegistry rtp_payload_registry;
-  // Set the incoming payload type to 90.
-  RTPHeader header;
-  header.payloadType = 90;
-  header.ssrc = 1;
-  rtp_payload_registry.SetIncomingPayloadType(header);
-  rtp_payload_registry.SetRtxSsrc(100);
-  // Map two RTX payload types.
-  rtp_payload_registry.SetRtxPayloadType(105, 95);
-  rtp_payload_registry.SetRtxPayloadType(106, 96);
-
-  TestRtxPacket(&rtp_payload_registry, 105, 95, true);
-  TestRtxPacket(&rtp_payload_registry, 106, 96, true);
-}
-
-TEST(RtpPayloadRegistryTest, InvalidRtxConfiguration) {
-  RTPPayloadRegistry rtp_payload_registry;
-  rtp_payload_registry.SetRtxSsrc(100);
-  // Fails because no mappings exist and the incoming payload type isn't known.
-  TestRtxPacket(&rtp_payload_registry, 105, 0, false);
-  // Succeeds when the mapping is used, but fails for the implicit fallback.
-  rtp_payload_registry.SetRtxPayloadType(105, 95);
-  TestRtxPacket(&rtp_payload_registry, 105, 95, true);
-  TestRtxPacket(&rtp_payload_registry, 106, 0, false);
-}
-
 INSTANTIATE_TEST_CASE_P(TestDynamicRange,
                         RtpPayloadRegistryGenericTest,
                         testing::Range(96, 127 + 1));
diff --git a/modules/rtp_rtcp/test/testAPI/test_api.cc b/modules/rtp_rtcp/test/testAPI/test_api.cc
index b39c8d7..28be222 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api.cc
@@ -162,23 +162,4 @@
   EXPECT_EQ(kRtxRetransmitted, module_->RtxSendStatus());
 }
 
-TEST_F(RtpRtcpAPITest, RtxReceiver) {
-  const uint32_t kRtxSsrc = 1;
-  const int kRtxPayloadType = 119;
-  const int kPayloadType = 100;
-  EXPECT_FALSE(rtp_payload_registry_->RtxEnabled());
-  rtp_payload_registry_->SetRtxSsrc(kRtxSsrc);
-  rtp_payload_registry_->SetRtxPayloadType(kRtxPayloadType, kPayloadType);
-  EXPECT_TRUE(rtp_payload_registry_->RtxEnabled());
-  RTPHeader rtx_header;
-  rtx_header.ssrc = kRtxSsrc;
-  rtx_header.payloadType = kRtxPayloadType;
-  EXPECT_TRUE(rtp_payload_registry_->IsRtx(rtx_header));
-  rtx_header.ssrc = 0;
-  EXPECT_FALSE(rtp_payload_registry_->IsRtx(rtx_header));
-  rtx_header.ssrc = kRtxSsrc;
-  rtx_header.payloadType = 0;
-  EXPECT_TRUE(rtp_payload_registry_->IsRtx(rtx_header));
-}
-
 }  // namespace webrtc
diff --git a/video/rtp_video_stream_receiver.cc b/video/rtp_video_stream_receiver.cc
index 1dbd869..5aff226 100644
--- a/video/rtp_video_stream_receiver.cc
+++ b/video/rtp_video_stream_receiver.cc
@@ -453,7 +453,7 @@
                                            size_t packet_length,
                                            const RTPHeader& header,
                                            bool in_order) {
-  if (rtp_payload_registry_.IsEncapsulated(header)) {
+  if (rtp_payload_registry_.IsRed(header)) {
     ParseAndHandleEncapsulatingHeader(packet, packet_length, header);
     return;
   }
@@ -485,8 +485,6 @@
       return;
     }
     ulpfec_receiver_->ProcessReceivedFec();
-  } else if (rtp_payload_registry_.IsRtx(header)) {
-    LOG(LS_WARNING) << "Unexpected RTX packet on media ssrc";
   }
 }