diff --git a/pc/BUILD.gn b/pc/BUILD.gn
index 20bb5d2..fab9632 100644
--- a/pc/BUILD.gn
+++ b/pc/BUILD.gn
@@ -475,6 +475,7 @@
       "peer_connection_media_unittest.cc",
       "peer_connection_rtp_unittest.cc",
       "peer_connection_signaling_unittest.cc",
+      "peer_connection_simulcast_unittest.cc",
       "peer_connection_wrapper.cc",
       "peer_connection_wrapper.h",
       "proxy_unittest.cc",
diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc
index 0fe6732..66d08a3 100644
--- a/pc/peer_connection.cc
+++ b/pc/peer_connection.cc
@@ -1463,23 +1463,50 @@
                        : cricket::MEDIA_TYPE_VIDEO));
   }
 
-  // TODO(bugs.webrtc.org/7600): Verify init.
-  if (init.send_encodings.size() > 1) {
+  size_t num_rids = absl::c_count_if(init.send_encodings,
+                                     [](const RtpEncodingParameters& encoding) {
+                                       return !encoding.rid.empty();
+                                     });
+  if (num_rids > 0 && num_rids != init.send_encodings.size()) {
     LOG_AND_RETURN_ERROR(
-        RTCErrorType::UNSUPPORTED_PARAMETER,
-        "Attempted to create an encoder with more than 1 encoding parameter.");
+        RTCErrorType::INVALID_PARAMETER,
+        "RIDs must be provided for either all or none of the send encodings.");
   }
 
-  for (const auto& encoding : init.send_encodings) {
-    if (encoding.ssrc.has_value()) {
-      LOG_AND_RETURN_ERROR(
-          RTCErrorType::UNSUPPORTED_PARAMETER,
-          "Attempted to set an unimplemented parameter of RtpParameters.");
-    }
+  if (absl::c_any_of(init.send_encodings,
+                     [](const RtpEncodingParameters& encoding) {
+                       return encoding.ssrc.has_value();
+                     })) {
+    LOG_AND_RETURN_ERROR(
+        RTCErrorType::UNSUPPORTED_PARAMETER,
+        "Attempted to set an unimplemented parameter of RtpParameters.");
   }
 
   RtpParameters parameters;
   parameters.encodings = init.send_encodings;
+
+  // Encodings are dropped from the tail if too many are provided.
+  if (parameters.encodings.size() > kMaxSimulcastStreams) {
+    parameters.encodings.erase(
+        parameters.encodings.begin() + kMaxSimulcastStreams,
+        parameters.encodings.end());
+  }
+
+  // Single RID should be removed.
+  if (parameters.encodings.size() == 1 &&
+      !parameters.encodings[0].rid.empty()) {
+    RTC_LOG(LS_INFO) << "Removing RID: " << parameters.encodings[0].rid << ".";
+    parameters.encodings[0].rid.clear();
+  }
+
+  // If RIDs were not provided, they are generated for simulcast scenario.
+  if (parameters.encodings.size() > 1 && num_rids == 0) {
+    rtc::UniqueStringGenerator rid_generator;
+    for (RtpEncodingParameters& encoding : parameters.encodings) {
+      encoding.rid = rid_generator();
+    }
+  }
+
   if (UnimplementedRtpParameterHasValue(parameters)) {
     LOG_AND_RETURN_ERROR(
         RTCErrorType::UNSUPPORTED_PARAMETER,
@@ -1499,7 +1526,7 @@
       (track && !FindSenderById(track->id()) ? track->id()
                                              : rtc::CreateRandomUuid());
   auto sender = CreateSender(media_type, sender_id, track, init.stream_ids,
-                             init.send_encodings);
+                             parameters.encodings);
   auto receiver = CreateReceiver(media_type, rtc::CreateRandomUuid());
   auto transceiver = CreateAndAddTransceiver(sender, receiver);
   transceiver->internal()->set_direction(init.direction);
@@ -3042,8 +3069,11 @@
     RTC_DCHECK_EQ(source, cricket::CS_REMOTE);
     // If the m= section is sendrecv or recvonly, and there are RtpTransceivers
     // of the same type...
+    // When simulcast is requested, a transceiver cannot be associated because
+    // AddTrack cannot be called to initialize it.
     if (!transceiver &&
-        RtpTransceiverDirectionHasRecv(media_desc->direction())) {
+        RtpTransceiverDirectionHasRecv(media_desc->direction()) &&
+        !media_desc->HasSimulcast()) {
       transceiver = FindAvailableTransceiverToReceive(media_desc->type());
     }
     // If no RtpTransceiver was found in the previous step, create one with a
diff --git a/pc/peer_connection_rtp_unittest.cc b/pc/peer_connection_rtp_unittest.cc
index e41791f..cf00138 100644
--- a/pc/peer_connection_rtp_unittest.cc
+++ b/pc/peer_connection_rtp_unittest.cc
@@ -1428,18 +1428,6 @@
   EXPECT_FALSE(caller->observer()->negotiation_needed());
 }
 
-// Test that AddTransceiver fails if trying to use simulcast using
-// send_encodings as it isn't currently supported.
-TEST_F(PeerConnectionRtpTestUnifiedPlan, CheckForUnsupportedSimulcast) {
-  auto caller = CreatePeerConnection();
-
-  RtpTransceiverInit init;
-  init.send_encodings.emplace_back();
-  init.send_encodings.emplace_back();
-  auto result = caller->pc()->AddTransceiver(cricket::MEDIA_TYPE_VIDEO, init);
-  EXPECT_EQ(result.error().type(), RTCErrorType::UNSUPPORTED_PARAMETER);
-}
-
 // Test that AddTransceiver fails if trying to use unimplemented RTP encoding
 // parameters with the send_encodings parameters.
 TEST_F(PeerConnectionRtpTestUnifiedPlan,
@@ -1452,7 +1440,7 @@
   auto default_send_encodings = init.send_encodings;
 
   // Unimplemented RtpParameters: ssrc, codec_payload_type, fec, rtx, dtx,
-  // ptime, scale_framerate_down_by, rid, dependency_rids.
+  // ptime, scale_framerate_down_by, dependency_rids.
   init.send_encodings[0].ssrc = 1;
   EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
             caller->pc()
@@ -1501,14 +1489,6 @@
                 .type());
   init.send_encodings = default_send_encodings;
 
-  init.send_encodings[0].rid = "dummy_rid";
-  EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
-            caller->pc()
-                ->AddTransceiver(cricket::MEDIA_TYPE_AUDIO, init)
-                .error()
-                .type());
-  init.send_encodings = default_send_encodings;
-
   init.send_encodings[0].dependency_rids.push_back("dummy_rid");
   EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
             caller->pc()
diff --git a/pc/peer_connection_simulcast_unittest.cc b/pc/peer_connection_simulcast_unittest.cc
new file mode 100644
index 0000000..f9e3d93
--- /dev/null
+++ b/pc/peer_connection_simulcast_unittest.cc
@@ -0,0 +1,417 @@
+/*
+ *  Copyright 2019 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.
+ */
+
+#include <ostream>  // no-presubmit-check TODO(webrtc:8982)
+
+#include "absl/algorithm/container.h"
+#include "absl/memory/memory.h"
+#include "api/audio_codecs/builtin_audio_decoder_factory.h"
+#include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/create_peerconnection_factory.h"
+#include "api/rtp_transceiver_interface.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
+#include "pc/peer_connection.h"
+#include "pc/peer_connection_wrapper.h"
+#include "pc/test/fake_audio_capture_module.h"
+#include "pc/test/mock_peer_connection_observers.h"
+#include "rtc_base/gunit.h"
+#include "test/gmock.h"
+
+using ::testing::Contains;
+using ::testing::Each;
+using ::testing::ElementsAre;
+using ::testing::ElementsAreArray;
+using ::testing::Eq;
+using ::testing::Field;
+using ::testing::IsEmpty;
+using ::testing::Ne;
+using ::testing::Property;
+using ::testing::SizeIs;
+
+using cricket::MediaContentDescription;
+using cricket::RidDescription;
+using cricket::SimulcastDescription;
+using cricket::SimulcastLayer;
+using cricket::StreamParams;
+
+namespace cricket {
+
+std::ostream& operator<<(  // no-presubmit-check TODO(webrtc:8982)
+    std::ostream& os,      // no-presubmit-check TODO(webrtc:8982)
+    const SimulcastLayer& layer) {
+  if (layer.is_paused) {
+    os << "~";
+  }
+  return os << layer.rid;
+}
+
+}  // namespace cricket
+
+namespace {
+
+std::vector<SimulcastLayer> CreateLayers(const std::vector<std::string>& rids,
+                                         const std::vector<bool>& active) {
+  RTC_DCHECK_EQ(rids.size(), active.size());
+  std::vector<SimulcastLayer> result;
+  absl::c_transform(rids, active, std::back_inserter(result),
+                    [](const std::string& rid, bool is_active) {
+                      return SimulcastLayer(rid, !is_active);
+                    });
+  return result;
+}
+std::vector<SimulcastLayer> CreateLayers(const std::vector<std::string>& rids,
+                                         bool active) {
+  return CreateLayers(rids, std::vector<bool>(rids.size(), active));
+}
+
+}  // namespace
+namespace webrtc {
+
+class PeerConnectionSimulcastTests : public testing::Test {
+ public:
+  PeerConnectionSimulcastTests()
+      : pc_factory_(
+            CreatePeerConnectionFactory(rtc::Thread::Current(),
+                                        rtc::Thread::Current(),
+                                        rtc::Thread::Current(),
+                                        FakeAudioCaptureModule::Create(),
+                                        CreateBuiltinAudioEncoderFactory(),
+                                        CreateBuiltinAudioDecoderFactory(),
+                                        CreateBuiltinVideoEncoderFactory(),
+                                        CreateBuiltinVideoDecoderFactory(),
+                                        nullptr,
+                                        nullptr)) {}
+
+  rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
+      MockPeerConnectionObserver* observer) {
+    PeerConnectionInterface::RTCConfiguration config;
+    config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+    PeerConnectionDependencies pcd(observer);
+    auto pc = pc_factory_->CreatePeerConnection(config, std::move(pcd));
+    EXPECT_TRUE(pc);
+    observer->SetPeerConnectionInterface(pc);
+    return pc;
+  }
+
+  std::unique_ptr<PeerConnectionWrapper> CreatePeerConnectionWrapper() {
+    auto observer = absl::make_unique<MockPeerConnectionObserver>();
+    auto pc = CreatePeerConnection(observer.get());
+    return absl::make_unique<PeerConnectionWrapper>(pc_factory_, pc,
+                                                    std::move(observer));
+  }
+
+  RtpTransceiverInit CreateTransceiverInit(
+      const std::vector<SimulcastLayer>& layers) {
+    RtpTransceiverInit init;
+    for (const SimulcastLayer& layer : layers) {
+      RtpEncodingParameters encoding;
+      encoding.rid = layer.rid;
+      encoding.active = !layer.is_paused;
+      init.send_encodings.push_back(encoding);
+    }
+    return init;
+  }
+
+  rtc::scoped_refptr<RtpTransceiverInterface> AddTransceiver(
+      PeerConnectionWrapper* pc,
+      const std::vector<SimulcastLayer>& layers) {
+    auto init = CreateTransceiverInit(layers);
+    return pc->AddTransceiver(cricket::MEDIA_TYPE_VIDEO, init);
+  }
+
+  SimulcastDescription RemoveSimulcast(SessionDescriptionInterface* sd) {
+    auto mcd = sd->description()->contents()[0].media_description();
+    auto result = mcd->simulcast_description();
+    mcd->set_simulcast_description(SimulcastDescription());
+    return result;
+  }
+
+  void AddRequestToReceiveSimulcast(const std::vector<SimulcastLayer>& layers,
+                                    SessionDescriptionInterface* sd) {
+    auto mcd = sd->description()->contents()[0].media_description();
+    SimulcastDescription simulcast;
+    auto& receive_layers = simulcast.receive_layers();
+    for (const SimulcastLayer& layer : layers) {
+      receive_layers.AddLayer(layer);
+    }
+    mcd->set_simulcast_description(simulcast);
+  }
+
+  bool ValidateTransceiverParameters(
+      rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
+      const std::vector<SimulcastLayer>& layers) {
+    bool errors_before = ::testing::Test::HasFailure();
+    auto parameters = transceiver->sender()->GetParameters();
+    std::vector<SimulcastLayer> result_layers;
+    absl::c_transform(parameters.encodings, std::back_inserter(result_layers),
+                      [](const RtpEncodingParameters& encoding) {
+                        return SimulcastLayer(encoding.rid, !encoding.active);
+                      });
+    EXPECT_THAT(result_layers, ElementsAreArray(layers));
+    // If there were errors before this code ran, we cannot tell if this
+    // validation succeeded or not.
+    return errors_before || !::testing::Test::HasFailure();
+  }
+
+ private:
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
+};
+
+// Validates that RIDs are supported arguments when adding a transceiver.
+TEST_F(PeerConnectionSimulcastTests, CanCreateTransceiverWithRid) {
+  auto pc = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"f"}, true);
+  auto transceiver = AddTransceiver(pc.get(), layers);
+  ASSERT_TRUE(transceiver);
+  auto parameters = transceiver->sender()->GetParameters();
+  // Single RID should be removed.
+  EXPECT_THAT(parameters.encodings,
+              ElementsAre(Field(&RtpEncodingParameters::rid, Eq(""))));
+}
+
+TEST_F(PeerConnectionSimulcastTests, CanCreateTransceiverWithSimulcast) {
+  auto pc = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"f", "h", "q"}, true);
+  auto transceiver = AddTransceiver(pc.get(), layers);
+  ASSERT_TRUE(transceiver);
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, layers));
+}
+
+TEST_F(PeerConnectionSimulcastTests, RidsAreAutogeneratedIfNotProvided) {
+  auto pc = CreatePeerConnectionWrapper();
+  auto init = CreateTransceiverInit(CreateLayers({"f", "h", "q"}, true));
+  for (RtpEncodingParameters& parameters : init.send_encodings) {
+    parameters.rid = "";
+  }
+  auto transceiver = pc->AddTransceiver(cricket::MEDIA_TYPE_VIDEO, init);
+  auto parameters = transceiver->sender()->GetParameters();
+  ASSERT_EQ(3u, parameters.encodings.size());
+  EXPECT_THAT(parameters.encodings,
+              Each(Field(&RtpEncodingParameters::rid, Ne(""))));
+}
+
+// Validates that an error is returned when there is a mix of supplied and not
+// supplied RIDs in a call to AddTransceiver.
+TEST_F(PeerConnectionSimulcastTests, MustSupplyAllOrNoRidsInSimulcast) {
+  auto pc_wrapper = CreatePeerConnectionWrapper();
+  auto pc = pc_wrapper->pc();
+  // Cannot create a layer with empty RID. Remove the RID after init is created.
+  auto layers = CreateLayers({"f", "h", "remove"}, true);
+  auto init = CreateTransceiverInit(layers);
+  init.send_encodings[2].rid = "";
+  auto error = pc->AddTransceiver(cricket::MEDIA_TYPE_VIDEO, init);
+  EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, error.error().type());
+}
+
+// Validates that a single RID does not get negotiated.
+// This test is currently disabled because a single RID is not supported.
+TEST_F(PeerConnectionSimulcastTests, SingleRidIsRemovedFromSessionDescription) {
+  auto pc = CreatePeerConnectionWrapper();
+  auto transceiver = AddTransceiver(pc.get(), CreateLayers({"1"}, true));
+  auto offer = pc->CreateOfferAndSetAsLocal();
+  ASSERT_TRUE(offer);
+  auto contents = offer->description()->contents();
+  ASSERT_EQ(1u, contents.size());
+  EXPECT_THAT(contents[0].media_description()->streams(),
+              ElementsAre(Property(&StreamParams::has_rids, false)));
+}
+
+TEST_F(PeerConnectionSimulcastTests, SimulcastLayersRemovedFromTail) {
+  static_assert(
+      kMaxSimulcastStreams < 8,
+      "Test assumes that the platform does not allow 8 simulcast layers");
+  auto pc = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"1", "2", "3", "4", "5", "6", "7", "8"}, true);
+  std::vector<SimulcastLayer> expected_layers;
+  std::copy_n(layers.begin(), kMaxSimulcastStreams,
+              std::back_inserter(expected_layers));
+  auto transceiver = AddTransceiver(pc.get(), layers);
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, expected_layers));
+}
+
+// Checks that an offfer to send simulcast contains a SimulcastDescription.
+TEST_F(PeerConnectionSimulcastTests, SimulcastAppearsInSessionDescription) {
+  auto pc = CreatePeerConnectionWrapper();
+  std::vector<std::string> rids({"f", "h", "q"});
+  auto layers = CreateLayers(rids, true);
+  auto transceiver = AddTransceiver(pc.get(), layers);
+  auto offer = pc->CreateOffer();
+  ASSERT_TRUE(offer);
+  auto contents = offer->description()->contents();
+  ASSERT_EQ(1u, contents.size());
+  auto content = contents[0];
+  auto mcd = content.media_description();
+  ASSERT_TRUE(mcd->HasSimulcast());
+  auto simulcast = mcd->simulcast_description();
+  EXPECT_THAT(simulcast.receive_layers(), IsEmpty());
+  // The size is validated separately because GetAllLayers() flattens the list.
+  EXPECT_THAT(simulcast.send_layers(), SizeIs(3));
+  std::vector<SimulcastLayer> result = simulcast.send_layers().GetAllLayers();
+  EXPECT_THAT(result, ElementsAreArray(layers));
+  auto streams = mcd->streams();
+  ASSERT_EQ(1u, streams.size());
+  auto stream = streams[0];
+  EXPECT_FALSE(stream.has_ssrcs());
+  EXPECT_TRUE(stream.has_rids());
+  std::vector<std::string> result_rids;
+  absl::c_transform(stream.rids(), std::back_inserter(result_rids),
+                    [](const RidDescription& rid) { return rid.rid; });
+  EXPECT_THAT(result_rids, ElementsAreArray(rids));
+}
+
+// Checks that Simulcast layers propagate to the sender parameters.
+TEST_F(PeerConnectionSimulcastTests, SimulcastLayersAreSetInSender) {
+  auto local = CreatePeerConnectionWrapper();
+  auto remote = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"f", "h", "q"}, true);
+  auto transceiver = AddTransceiver(local.get(), layers);
+  auto offer = local->CreateOfferAndSetAsLocal();
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, layers));
+
+  // Remove simulcast as the second peer connection won't support it.
+  auto simulcast = RemoveSimulcast(offer.get());
+  std::string error;
+  EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
+  auto answer = remote->CreateAnswerAndSetAsLocal();
+
+  // Setup an answer that mimics a server accepting simulcast.
+  auto mcd_answer = answer->description()->contents()[0].media_description();
+  mcd_answer->mutable_streams().clear();
+  auto simulcast_layers = simulcast.send_layers().GetAllLayers();
+  auto& receive_layers = mcd_answer->simulcast_description().receive_layers();
+  for (const auto& layer : simulcast_layers) {
+    receive_layers.AddLayer(layer);
+  }
+  EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, layers));
+}
+
+// Checks that paused Simulcast layers propagate to the sender parameters.
+TEST_F(PeerConnectionSimulcastTests, PausedSimulcastLayersAreDisabledInSender) {
+  auto local = CreatePeerConnectionWrapper();
+  auto remote = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"f", "h", "q"}, {true, false, true});
+  auto server_layers = CreateLayers({"f", "h", "q"}, {true, false, false});
+  RTC_DCHECK_EQ(layers.size(), server_layers.size());
+  auto transceiver = AddTransceiver(local.get(), layers);
+  auto offer = local->CreateOfferAndSetAsLocal();
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, layers));
+
+  // Remove simulcast as the second peer connection won't support it.
+  RemoveSimulcast(offer.get());
+  std::string error;
+  EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
+  auto answer = remote->CreateAnswerAndSetAsLocal();
+
+  // Setup an answer that mimics a server accepting simulcast.
+  auto mcd_answer = answer->description()->contents()[0].media_description();
+  mcd_answer->mutable_streams().clear();
+  auto& receive_layers = mcd_answer->simulcast_description().receive_layers();
+  for (const SimulcastLayer& layer : server_layers) {
+    receive_layers.AddLayer(layer);
+  }
+  EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, server_layers));
+}
+
+// Checks that when Simulcast is not supported by the remote party, then all
+// the layers (except the first) are marked as disabled.
+TEST_F(PeerConnectionSimulcastTests, SimulcastRejectedDisablesExtraLayers) {
+  auto local = CreatePeerConnectionWrapper();
+  auto remote = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"1", "2", "3", "4"}, true);
+  // The number of layers does not change.
+  auto expected_layers = CreateLayers({"1", "2", "3", "4"}, false);
+  RTC_DCHECK_EQ(layers.size(), expected_layers.size());
+  expected_layers[0].is_paused = false;
+  auto transceiver = AddTransceiver(local.get(), layers);
+  auto offer = local->CreateOfferAndSetAsLocal();
+  // Remove simulcast as the second peer connection won't support it.
+  RemoveSimulcast(offer.get());
+  std::string error;
+  EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
+  auto answer = remote->CreateAnswerAndSetAsLocal();
+  EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, expected_layers));
+}
+
+// Checks that if Simulcast is supported by remote party, but some layer is
+// rejected, then only that layer is marked as disabled.
+TEST_F(PeerConnectionSimulcastTests, RejectedSimulcastLayersAreDeactivated) {
+  auto local = CreatePeerConnectionWrapper();
+  auto remote = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"1", "2", "3", "4"}, true);
+  auto transceiver = AddTransceiver(local.get(), layers);
+  auto offer = local->CreateOfferAndSetAsLocal();
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, layers));
+  // Remove simulcast as the second peer connection won't support it.
+  auto removed_simulcast = RemoveSimulcast(offer.get());
+  std::string error;
+  EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
+  auto answer = remote->CreateAnswerAndSetAsLocal();
+  auto mcd_answer = answer->description()->contents()[0].media_description();
+  // Setup the answer to look like a server response.
+  // Remove one of the layers to reject it in the answer.
+  auto simulcast_layers = removed_simulcast.send_layers().GetAllLayers();
+  simulcast_layers.erase(simulcast_layers.begin());
+  auto& receive_layers = mcd_answer->simulcast_description().receive_layers();
+  for (const auto& layer : simulcast_layers) {
+    receive_layers.AddLayer(layer);
+  }
+  ASSERT_TRUE(mcd_answer->HasSimulcast());
+  EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
+  layers[0].is_paused = true;
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, layers));
+}
+
+// Checks that simulcast is set up correctly when the server sends an offer
+// requesting to receive simulcast.
+TEST_F(PeerConnectionSimulcastTests, ServerSendsOfferToReceiveSimulcast) {
+  auto local = CreatePeerConnectionWrapper();
+  auto remote = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"f", "h", "q"}, true);
+  AddTransceiver(local.get(), layers);
+  auto offer = local->CreateOfferAndSetAsLocal();
+  // Remove simulcast as a sender and set it up as a receiver.
+  RemoveSimulcast(offer.get());
+  AddRequestToReceiveSimulcast(layers, offer.get());
+  std::string error;
+  EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
+  auto transceiver = remote->pc()->GetTransceivers()[0];
+  transceiver->SetDirection(RtpTransceiverDirection::kSendRecv);
+  EXPECT_TRUE(remote->CreateAnswerAndSetAsLocal());
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, layers));
+}
+
+// Checks that SetRemoteDescription doesn't attempt to associate a transceiver
+// when simulcast is requested by the server.
+TEST_F(PeerConnectionSimulcastTests, TransceiverIsNotRecycledWithSimulcast) {
+  auto local = CreatePeerConnectionWrapper();
+  auto remote = CreatePeerConnectionWrapper();
+  auto layers = CreateLayers({"f", "h", "q"}, true);
+  AddTransceiver(local.get(), layers);
+  auto offer = local->CreateOfferAndSetAsLocal();
+  // Remove simulcast as a sender and set it up as a receiver.
+  RemoveSimulcast(offer.get());
+  AddRequestToReceiveSimulcast(layers, offer.get());
+  // Call AddTrack so that a transceiver is created.
+  remote->AddVideoTrack("fake_track");
+  std::string error;
+  EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
+  auto transceivers = remote->pc()->GetTransceivers();
+  ASSERT_EQ(2u, transceivers.size());
+  auto transceiver = transceivers[1];
+  transceiver->SetDirection(RtpTransceiverDirection::kSendRecv);
+  EXPECT_TRUE(remote->CreateAnswerAndSetAsLocal());
+  EXPECT_TRUE(ValidateTransceiverParameters(transceiver, layers));
+}
+
+}  // namespace webrtc
diff --git a/pc/rtp_sender.cc b/pc/rtp_sender.cc
index d88b1fc..b9a269a 100644
--- a/pc/rtp_sender.cc
+++ b/pc/rtp_sender.cc
@@ -41,7 +41,6 @@
   if (encoding_params.codec_payload_type.has_value() ||
       encoding_params.fec.has_value() || encoding_params.rtx.has_value() ||
       encoding_params.dtx.has_value() || encoding_params.ptime.has_value() ||
-      !encoding_params.rid.empty() ||
       encoding_params.scale_framerate_down_by.has_value() ||
       !encoding_params.dependency_rids.empty()) {
     return true;
@@ -251,7 +250,7 @@
   if (stopped_) {
     return RtpParameters();
   }
-  if (!media_channel_) {
+  if (!media_channel_ || !ssrc_) {
     RtpParameters result = init_parameters_;
     last_transaction_id_ = rtc::CreateRandomUuid();
     result.transaction_id = last_transaction_id_.value();
@@ -288,7 +287,7 @@
         RTCErrorType::UNSUPPORTED_PARAMETER,
         "Attempted to set an unimplemented parameter of RtpParameters.");
   }
-  if (!media_channel_) {
+  if (!media_channel_ || !ssrc_) {
     auto result = cricket::CheckRtpParametersInvalidModificationAndValues(
         init_parameters_, parameters);
     if (result.ok()) {
@@ -506,7 +505,7 @@
   if (stopped_) {
     return RtpParameters();
   }
-  if (!media_channel_) {
+  if (!media_channel_ || !ssrc_) {
     RtpParameters result = init_parameters_;
     last_transaction_id_ = rtc::CreateRandomUuid();
     result.transaction_id = last_transaction_id_.value();
@@ -543,7 +542,7 @@
         RTCErrorType::UNSUPPORTED_PARAMETER,
         "Attempted to set an unimplemented parameter of RtpParameters.");
   }
-  if (!media_channel_) {
+  if (!media_channel_ || !ssrc_) {
     auto result = cricket::CheckRtpParametersInvalidModificationAndValues(
         init_parameters_, parameters);
     if (result.ok()) {
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index e3a8d5e..b172460 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -812,7 +812,7 @@
   EXPECT_EQ(1u, params.encodings.size());
 
   // Unimplemented RtpParameters: codec_payload_type, fec, rtx, dtx, ptime,
-  // scale_framerate_down_by, rid, dependency_rids.
+  // scale_framerate_down_by, dependency_rids.
   params.encodings[0].codec_payload_type = 1;
   EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
             audio_rtp_sender_->SetParameters(params).type());
@@ -838,11 +838,6 @@
             audio_rtp_sender_->SetParameters(params).type());
   params = audio_rtp_sender_->GetParameters();
 
-  params.encodings[0].rid = "dummy_rid";
-  EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
-            audio_rtp_sender_->SetParameters(params).type());
-  params = audio_rtp_sender_->GetParameters();
-
   params.encodings[0].dependency_rids.push_back("dummy_rid");
   EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
             audio_rtp_sender_->SetParameters(params).type());
@@ -1084,7 +1079,7 @@
   EXPECT_EQ(1u, params.encodings.size());
 
   // Unimplemented RtpParameters: codec_payload_type, fec, rtx, dtx, ptime,
-  // scale_framerate_down_by, rid, dependency_rids.
+  // scale_framerate_down_by, dependency_rids.
   params.encodings[0].codec_payload_type = 1;
   EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
             video_rtp_sender_->SetParameters(params).type());
@@ -1110,11 +1105,6 @@
             video_rtp_sender_->SetParameters(params).type());
   params = video_rtp_sender_->GetParameters();
 
-  params.encodings[0].rid = "dummy_rid";
-  EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
-            video_rtp_sender_->SetParameters(params).type());
-  params = video_rtp_sender_->GetParameters();
-
   params.encodings[0].dependency_rids.push_back("dummy_rid");
   EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
             video_rtp_sender_->SetParameters(params).type());
@@ -1122,6 +1112,20 @@
   DestroyVideoRtpSender();
 }
 
+TEST_F(RtpSenderReceiverTest, VideoSenderCanSetRid) {
+  CreateVideoRtpSender();
+  RtpParameters params = video_rtp_sender_->GetParameters();
+  EXPECT_EQ(1u, params.encodings.size());
+  const std::string rid = "dummy_rid";
+  params.encodings[0].rid = rid;
+  EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok());
+  params = video_rtp_sender_->GetParameters();
+  EXPECT_EQ(1u, params.encodings.size());
+  EXPECT_EQ(rid, params.encodings[0].rid);
+
+  DestroyVideoRtpSender();
+}
+
 TEST_F(RtpSenderReceiverTest, VideoSenderCanSetScaleResolutionDownBy) {
   CreateVideoRtpSender();
 
@@ -1153,7 +1157,7 @@
   EXPECT_EQ(kVideoSimulcastLayerCount, params.encodings.size());
 
   // Unimplemented RtpParameters: codec_payload_type, fec, rtx, dtx, ptime,
-  // scale_framerate_down_by, rid, dependency_rids.
+  // scale_framerate_down_by, dependency_rids.
   for (size_t i = 0; i < params.encodings.size(); i++) {
     params.encodings[i].codec_payload_type = 1;
     EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
@@ -1180,11 +1184,6 @@
               video_rtp_sender_->SetParameters(params).type());
     params = video_rtp_sender_->GetParameters();
 
-    params.encodings[i].rid = "dummy_rid";
-    EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
-              video_rtp_sender_->SetParameters(params).type());
-    params = video_rtp_sender_->GetParameters();
-
     params.encodings[i].dependency_rids.push_back("dummy_rid");
     EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER,
               video_rtp_sender_->SetParameters(params).type());