Adding getParameters/setParameters APIs to RtpReceiver.

This is similar to how a "receive" method is used to apply
RtpParameters to an RtpReceiver in ORTC. Currently, SetParameters
doesn't allow changing the parameters, so the main use of the API is
to retrieve the set of configured codecs. But other uses will likely
be made possible in the future.

R=glaznev@webrtc.org, pthatcher@webrtc.org, tkchin@webrtc.org

Review URL: https://codereview.webrtc.org/1917193008 .

Cr-Commit-Position: refs/heads/master@{#12761}

webrtc/api/java/jni/peerconnection_jni.cc

@@ -2031,10 +2031,19 @@ JOW(jlong, RtpSender_nativeGetTrack)(JNIEnv* jni,
           .release());
 }
 
-static bool JavaEncodingToJsepRtpEncodingParameters(
+static void JavaRtpParametersToJsepRtpParameters(
     JNIEnv* jni,
-    jobject j_encodings,
-    std::vector<webrtc::RtpEncodingParameters>* encodings) {
+    jobject j_parameters,
+    webrtc::RtpParameters* parameters) {
+  RTC_CHECK(parameters != nullptr);
+  jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
+  jfieldID encodings_id =
+      GetFieldID(jni, parameters_class, "encodings", "Ljava/util/LinkedList;");
+  jfieldID codecs_id =
+      GetFieldID(jni, parameters_class, "codecs", "Ljava/util/LinkedList;");
+
+  // Convert encodings.
+  jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id);
   const int kBitrateUnlimited = -1;
   jclass j_encoding_parameters_class =
       jni->FindClass("org/webrtc/RtpParameters$Encoding");
@@ -2057,15 +2066,11 @@ static bool JavaEncodingToJsepRtpEncodingParameters(
     } else {
       encoding.max_bitrate_bps = kBitrateUnlimited;
     }
-    encodings->push_back(encoding);
+    parameters->encodings.push_back(encoding);
   }
-  return true;
-}
 
-static bool JavaCodecToJsepRtpCodecParameters(
-    JNIEnv* jni,
-    jobject j_codecs,
-    std::vector<webrtc::RtpCodecParameters>* codecs) {
+  // Convert codecs.
+  jobject j_codecs = GetObjectField(jni, j_parameters, codecs_id);
   jclass codec_class = jni->FindClass("org/webrtc/RtpParameters$Codec");
   jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I");
   jfieldID mime_type_id =
@@ -2080,45 +2085,20 @@ static bool JavaCodecToJsepRtpCodecParameters(
         JavaToStdString(jni, GetStringField(jni, j_codec, mime_type_id));
     codec.clock_rate = GetIntField(jni, j_codec, clock_rate_id);
     codec.channels = GetIntField(jni, j_codec, channels_id);
-    codecs->push_back(codec);
+    parameters->codecs.push_back(codec);
   }
-  return true;
 }
 
-JOW(jboolean, RtpSender_nativeSetParameters)
-(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer, jobject j_parameters) {
-  if (IsNull(jni, j_parameters)) {
-    return false;
-  }
-  jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
-  jclass encoding_class = jni->FindClass("org/webrtc/RtpParameters$Encoding");
-  jfieldID encodings_id =
-      GetFieldID(jni, parameters_class, "encodings", "Ljava/util/LinkedList;");
-  jfieldID codecs_id =
-      GetFieldID(jni, parameters_class, "codecs", "Ljava/util/LinkedList;");
-
-  jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id);
-  jobject j_codecs = GetObjectField(jni, j_parameters, codecs_id);
-  webrtc::RtpParameters parameters;
-  JavaEncodingToJsepRtpEncodingParameters(jni, j_encodings,
-                                          &parameters.encodings);
-  JavaCodecToJsepRtpCodecParameters(jni, j_codecs, &parameters.codecs);
-  return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
-      ->SetParameters(parameters);
-}
-
-JOW(jobject, RtpSender_nativeGetParameters)
-(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) {
-  webrtc::RtpParameters parameters =
-      reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
-          ->GetParameters();
-
+static jobject JsepRtpParametersToJavaRtpParameters(
+    JNIEnv* jni,
+    const webrtc::RtpParameters& parameters) {
   jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
   jmethodID parameters_ctor =
       GetMethodID(jni, parameters_class, "<init>", "()V");
   jobject j_parameters = jni->NewObject(parameters_class, parameters_ctor);
   CHECK_EXCEPTION(jni) << "error during NewObject";
 
+  // Add encodings.
   jclass encoding_class = jni->FindClass("org/webrtc/RtpParameters$Encoding");
   jmethodID encoding_ctor = GetMethodID(jni, encoding_class, "<init>", "()V");
   jfieldID encodings_id =
@@ -2153,6 +2133,7 @@ JOW(jobject, RtpSender_nativeGetParameters)
     RTC_CHECK(added);
   }
 
+  // Add codecs.
   jclass codec_class = jni->FindClass("org/webrtc/RtpParameters$Codec");
   jmethodID codec_ctor = GetMethodID(jni, codec_class, "<init>", "()V");
   jfieldID codecs_id =
@@ -2186,6 +2167,25 @@ JOW(jobject, RtpSender_nativeGetParameters)
   return j_parameters;
 }
 
+JOW(jboolean, RtpSender_nativeSetParameters)
+(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer, jobject j_parameters) {
+  if (IsNull(jni, j_parameters)) {
+    return false;
+  }
+  webrtc::RtpParameters parameters;
+  JavaRtpParametersToJsepRtpParameters(jni, j_parameters, &parameters);
+  return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
+      ->SetParameters(parameters);
+}
+
+JOW(jobject, RtpSender_nativeGetParameters)
+(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) {
+  webrtc::RtpParameters parameters =
+      reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
+          ->GetParameters();
+  return JsepRtpParametersToJavaRtpParameters(jni, parameters);
+}
+
 JOW(jstring, RtpSender_nativeId)(
     JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) {
   return JavaStringFromStdString(
@@ -2206,6 +2206,25 @@ JOW(jlong, RtpReceiver_nativeGetTrack)(JNIEnv* jni,
           .release());
 }
 
+JOW(jboolean, RtpReceiver_nativeSetParameters)
+(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer, jobject j_parameters) {
+  if (IsNull(jni, j_parameters)) {
+    return false;
+  }
+  webrtc::RtpParameters parameters;
+  JavaRtpParametersToJsepRtpParameters(jni, j_parameters, &parameters);
+  return reinterpret_cast<RtpReceiverInterface*>(j_rtp_sender_pointer)
+      ->SetParameters(parameters);
+}
+
+JOW(jobject, RtpReceiver_nativeGetParameters)
+(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) {
+  webrtc::RtpParameters parameters =
+      reinterpret_cast<RtpReceiverInterface*>(j_rtp_sender_pointer)
+          ->GetParameters();
+  return JsepRtpParametersToJavaRtpParameters(jni, parameters);
+}
+
 JOW(jstring, RtpReceiver_nativeId)(
     JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) {
   return JavaStringFromStdString(

webrtc/api/java/src/org/webrtc/RtpReceiver.java

@@ -27,6 +27,14 @@ public class RtpReceiver {
     return cachedTrack;
   }
 
+  public boolean setParameters(RtpParameters parameters) {
+    return nativeSetParameters(nativeRtpReceiver, parameters);
+  }
+
+  public RtpParameters getParameters() {
+    return nativeGetParameters(nativeRtpReceiver);
+  }
+
   public String id() {
     return nativeId(nativeRtpReceiver);
   }
@@ -40,6 +48,11 @@ public class RtpReceiver {
   // Will be released in dispose().
   private static native long nativeGetTrack(long nativeRtpReceiver);
 
+  private static native boolean nativeSetParameters(long nativeRtpReceiver,
+                                                    RtpParameters parameters);
+
+  private static native RtpParameters nativeGetParameters(long nativeRtpReceiver);
+
   private static native String nativeId(long nativeRtpReceiver);
 
   private static native void free(long nativeRtpReceiver);

webrtc/api/mediastreamprovider.h

@@ -63,9 +63,14 @@ class AudioProviderInterface {
       uint32_t ssrc,
       std::unique_ptr<webrtc::AudioSinkInterface> sink) = 0;
 
-  virtual RtpParameters GetAudioRtpParameters(uint32_t ssrc) const = 0;
-  virtual bool SetAudioRtpParameters(uint32_t ssrc,
-                                     const RtpParameters& parameters) = 0;
+  virtual RtpParameters GetAudioRtpSendParameters(uint32_t ssrc) const = 0;
+  virtual bool SetAudioRtpSendParameters(uint32_t ssrc,
+                                         const RtpParameters& parameters) = 0;
+
+  virtual RtpParameters GetAudioRtpReceiveParameters(uint32_t ssrc) const = 0;
+  virtual bool SetAudioRtpReceiveParameters(
+      uint32_t ssrc,
+      const RtpParameters& parameters) = 0;
 
  protected:
   virtual ~AudioProviderInterface() {}
@@ -88,9 +93,14 @@ class VideoProviderInterface {
                             bool enable,
                             const cricket::VideoOptions* options) = 0;
 
-  virtual RtpParameters GetVideoRtpParameters(uint32_t ssrc) const = 0;
-  virtual bool SetVideoRtpParameters(uint32_t ssrc,
-                                     const RtpParameters& parameters) = 0;
+  virtual RtpParameters GetVideoRtpSendParameters(uint32_t ssrc) const = 0;
+  virtual bool SetVideoRtpSendParameters(uint32_t ssrc,
+                                         const RtpParameters& parameters) = 0;
+
+  virtual RtpParameters GetVideoRtpReceiveParameters(uint32_t ssrc) const = 0;
+  virtual bool SetVideoRtpReceiveParameters(
+      uint32_t ssrc,
+      const RtpParameters& parameters) = 0;
 
  protected:
   virtual ~VideoProviderInterface() {}

webrtc/api/rtpparameters.h

@@ -25,6 +25,9 @@ struct RtpEncodingParameters {
   bool operator==(const RtpEncodingParameters& o) const {
     return active == o.active && max_bitrate_bps == o.max_bitrate_bps;
   }
+  bool operator!=(const RtpEncodingParameters& o) const {
+    return !(*this == o);
+  }
 };
 
 struct RtpCodecParameters {
@@ -38,6 +41,7 @@ struct RtpCodecParameters {
     return payload_type == o.payload_type && mime_type == o.mime_type &&
            clock_rate == o.clock_rate && channels == o.channels;
   }
+  bool operator!=(const RtpCodecParameters& o) const { return !(*this == o); }
 };
 
 struct RtpParameters {
@@ -47,6 +51,7 @@ struct RtpParameters {
   bool operator==(const RtpParameters& o) const {
     return encodings == o.encodings && codecs == o.codecs;
   }
+  bool operator!=(const RtpParameters& o) const { return !(*this == o); }
 };
 
 }  // namespace webrtc

webrtc/api/rtpreceiver.cc

@@ -14,6 +14,7 @@
 #include "webrtc/api/audiotrack.h"
 #include "webrtc/api/videosourceproxy.h"
 #include "webrtc/api/videotrack.h"
+#include "webrtc/base/trace_event.h"
 
 namespace webrtc {
 
@@ -66,6 +67,15 @@ void AudioRtpReceiver::Stop() {
   provider_ = nullptr;
 }
 
+RtpParameters AudioRtpReceiver::GetParameters() const {
+  return provider_->GetAudioRtpReceiveParameters(ssrc_);
+}
+
+bool AudioRtpReceiver::SetParameters(const RtpParameters& parameters) {
+  TRACE_EVENT0("webrtc", "AudioRtpReceiver::SetParameters");
+  return provider_->SetAudioRtpReceiveParameters(ssrc_, parameters);
+}
+
 void AudioRtpReceiver::Reconfigure() {
   if (!provider_) {
     return;
@@ -113,4 +123,13 @@ void VideoRtpReceiver::Stop() {
   provider_ = nullptr;
 }
 
+RtpParameters VideoRtpReceiver::GetParameters() const {
+  return provider_->GetVideoRtpReceiveParameters(ssrc_);
+}
+
+bool VideoRtpReceiver::SetParameters(const RtpParameters& parameters) {
+  TRACE_EVENT0("webrtc", "VideoRtpReceiver::SetParameters");
+  return provider_->SetVideoRtpReceiveParameters(ssrc_, parameters);
+}
+
 }  // namespace webrtc

webrtc/api/rtpreceiver.h

@@ -56,6 +56,9 @@ class AudioRtpReceiver : public ObserverInterface,
 
   void Stop() override;
 
+  RtpParameters GetParameters() const override;
+  bool SetParameters(const RtpParameters& parameters) override;
+
  private:
   void Reconfigure();
 
@@ -89,6 +92,9 @@ class VideoRtpReceiver : public rtc::RefCountedObject<RtpReceiverInterface> {
 
   void Stop() override;
 
+  RtpParameters GetParameters() const override;
+  bool SetParameters(const RtpParameters& parameters) override;
+
  private:
   std::string id_;
   uint32_t ssrc_;

webrtc/api/rtpreceiverinterface.h

@@ -33,6 +33,12 @@ class RtpReceiverInterface : public rtc::RefCountInterface {
 
   virtual void Stop() = 0;
 
+  // The WebRTC specification only defines RTCRtpParameters in terms of senders,
+  // but this API also applies them to receivers, similar to ORTC:
+  // http://ortc.org/wp-content/uploads/2016/03/ortc.html#rtcrtpparameters*.
+  virtual RtpParameters GetParameters() const = 0;
+  virtual bool SetParameters(const RtpParameters& parameters) = 0;
+
  protected:
   virtual ~RtpReceiverInterface() {}
 };
@@ -42,6 +48,8 @@ BEGIN_SIGNALING_PROXY_MAP(RtpReceiver)
 PROXY_CONSTMETHOD0(rtc::scoped_refptr<MediaStreamTrackInterface>, track)
 PROXY_CONSTMETHOD0(std::string, id)
 PROXY_METHOD0(void, Stop)
+PROXY_CONSTMETHOD0(RtpParameters, GetParameters);
+PROXY_METHOD1(bool, SetParameters, const RtpParameters&)
 END_SIGNALING_PROXY()
 
 }  // namespace webrtc

webrtc/api/rtpsender.cc

@@ -208,12 +208,12 @@ void AudioRtpSender::SetAudioSend() {
 }
 
 RtpParameters AudioRtpSender::GetParameters() const {
-  return provider_->GetAudioRtpParameters(ssrc_);
+  return provider_->GetAudioRtpSendParameters(ssrc_);
 }
 
 bool AudioRtpSender::SetParameters(const RtpParameters& parameters) {
   TRACE_EVENT0("webrtc", "AudioRtpSender::SetParameters");
-  return provider_->SetAudioRtpParameters(ssrc_, parameters);
+  return provider_->SetAudioRtpSendParameters(ssrc_, parameters);
 }
 
 VideoRtpSender::VideoRtpSender(VideoTrackInterface* track,
@@ -350,12 +350,12 @@ void VideoRtpSender::SetVideoSend() {
 }
 
 RtpParameters VideoRtpSender::GetParameters() const {
-  return provider_->GetVideoRtpParameters(ssrc_);
+  return provider_->GetVideoRtpSendParameters(ssrc_);
 }
 
 bool VideoRtpSender::SetParameters(const RtpParameters& parameters) {
   TRACE_EVENT0("webrtc", "VideoRtpSender::SetParameters");
-  return provider_->SetVideoRtpParameters(ssrc_, parameters);
+  return provider_->SetVideoRtpSendParameters(ssrc_, parameters);
 }
 
 }  // namespace webrtc

webrtc/api/rtpsenderreceiver_unittest.cc

@@ -59,8 +59,12 @@ class MockAudioProvider : public AudioProviderInterface {
                     const cricket::AudioOptions& options,
                     cricket::AudioSource* source));
   MOCK_METHOD2(SetAudioPlayoutVolume, void(uint32_t ssrc, double volume));
-  MOCK_CONST_METHOD1(GetAudioRtpParameters, RtpParameters(uint32_t ssrc));
-  MOCK_METHOD2(SetAudioRtpParameters,
+  MOCK_CONST_METHOD1(GetAudioRtpSendParameters, RtpParameters(uint32_t ssrc));
+  MOCK_METHOD2(SetAudioRtpSendParameters,
+               bool(uint32_t ssrc, const RtpParameters&));
+  MOCK_CONST_METHOD1(GetAudioRtpReceiveParameters,
+                     RtpParameters(uint32_t ssrc));
+  MOCK_METHOD2(SetAudioRtpReceiveParameters,
                bool(uint32_t ssrc, const RtpParameters&));
 
   void SetRawAudioSink(
@@ -88,8 +92,12 @@ class MockVideoProvider : public VideoProviderInterface {
                     bool enable,
                     const cricket::VideoOptions* options));
 
-  MOCK_CONST_METHOD1(GetVideoRtpParameters, RtpParameters(uint32_t ssrc));
-  MOCK_METHOD2(SetVideoRtpParameters,
+  MOCK_CONST_METHOD1(GetVideoRtpSendParameters, RtpParameters(uint32_t ssrc));
+  MOCK_METHOD2(SetVideoRtpSendParameters,
+               bool(uint32_t ssrc, const RtpParameters&));
+  MOCK_CONST_METHOD1(GetVideoRtpReceiveParameters,
+                     RtpParameters(uint32_t ssrc));
+  MOCK_METHOD2(SetVideoRtpReceiveParameters,
                bool(uint32_t ssrc, const RtpParameters&));
 };
 
@@ -504,9 +512,9 @@ TEST_F(RtpSenderReceiverTest, VideoSenderSsrcChanged) {
 TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParameters) {
   CreateAudioRtpSender();
 
-  EXPECT_CALL(audio_provider_, GetAudioRtpParameters(kAudioSsrc))
+  EXPECT_CALL(audio_provider_, GetAudioRtpSendParameters(kAudioSsrc))
       .WillOnce(Return(RtpParameters()));
-  EXPECT_CALL(audio_provider_, SetAudioRtpParameters(kAudioSsrc, _))
+  EXPECT_CALL(audio_provider_, SetAudioRtpSendParameters(kAudioSsrc, _))
       .WillOnce(Return(true));
   RtpParameters params = audio_rtp_sender_->GetParameters();
   EXPECT_TRUE(audio_rtp_sender_->SetParameters(params));
@@ -517,9 +525,9 @@ TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParameters) {
 TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParameters) {
   CreateVideoRtpSender();
 
-  EXPECT_CALL(video_provider_, GetVideoRtpParameters(kVideoSsrc))
+  EXPECT_CALL(video_provider_, GetVideoRtpSendParameters(kVideoSsrc))
       .WillOnce(Return(RtpParameters()));
-  EXPECT_CALL(video_provider_, SetVideoRtpParameters(kVideoSsrc, _))
+  EXPECT_CALL(video_provider_, SetVideoRtpSendParameters(kVideoSsrc, _))
       .WillOnce(Return(true));
   RtpParameters params = video_rtp_sender_->GetParameters();
   EXPECT_TRUE(video_rtp_sender_->SetParameters(params));
@@ -527,4 +535,30 @@ TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParameters) {
   DestroyVideoRtpSender();
 }
 
+TEST_F(RtpSenderReceiverTest, AudioReceiverCanSetParameters) {
+  CreateAudioRtpReceiver();
+
+  EXPECT_CALL(audio_provider_, GetAudioRtpReceiveParameters(kAudioSsrc))
+      .WillOnce(Return(RtpParameters()));
+  EXPECT_CALL(audio_provider_, SetAudioRtpReceiveParameters(kAudioSsrc, _))
+      .WillOnce(Return(true));
+  RtpParameters params = audio_rtp_receiver_->GetParameters();
+  EXPECT_TRUE(audio_rtp_receiver_->SetParameters(params));
+
+  DestroyAudioRtpReceiver();
+}
+
+TEST_F(RtpSenderReceiverTest, VideoReceiverCanSetParameters) {
+  CreateVideoRtpReceiver();
+
+  EXPECT_CALL(video_provider_, GetVideoRtpReceiveParameters(kVideoSsrc))
+      .WillOnce(Return(RtpParameters()));
+  EXPECT_CALL(video_provider_, SetVideoRtpReceiveParameters(kVideoSsrc, _))
+      .WillOnce(Return(true));
+  RtpParameters params = video_rtp_receiver_->GetParameters();
+  EXPECT_TRUE(video_rtp_receiver_->SetParameters(params));
+
+  DestroyVideoRtpReceiver();
+}
+
 }  // namespace webrtc

webrtc/api/webrtcsession.cc

@@ -1219,21 +1219,39 @@ void WebRtcSession::SetRawAudioSink(uint32_t ssrc,
   voice_channel_->SetRawAudioSink(ssrc, std::move(sink));
 }
 
-RtpParameters WebRtcSession::GetAudioRtpParameters(uint32_t ssrc) const {
+RtpParameters WebRtcSession::GetAudioRtpSendParameters(uint32_t ssrc) const {
   ASSERT(signaling_thread()->IsCurrent());
   if (voice_channel_) {
-    return voice_channel_->GetRtpParameters(ssrc);
+    return voice_channel_->GetRtpSendParameters(ssrc);
   }
   return RtpParameters();
 }
 
-bool WebRtcSession::SetAudioRtpParameters(uint32_t ssrc,
-                                          const RtpParameters& parameters) {
+bool WebRtcSession::SetAudioRtpSendParameters(uint32_t ssrc,
+                                              const RtpParameters& parameters) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     return false;
   }
-  return voice_channel_->SetRtpParameters(ssrc, parameters);
+  return voice_channel_->SetRtpSendParameters(ssrc, parameters);
+}
+
+RtpParameters WebRtcSession::GetAudioRtpReceiveParameters(uint32_t ssrc) const {
+  ASSERT(signaling_thread()->IsCurrent());
+  if (voice_channel_) {
+    return voice_channel_->GetRtpReceiveParameters(ssrc);
+  }
+  return RtpParameters();
+}
+
+bool WebRtcSession::SetAudioRtpReceiveParameters(
+    uint32_t ssrc,
+    const RtpParameters& parameters) {
+  ASSERT(signaling_thread()->IsCurrent());
+  if (!voice_channel_) {
+    return false;
+  }
+  return voice_channel_->SetRtpReceiveParameters(ssrc, parameters);
 }
 
 bool WebRtcSession::SetSource(
@@ -1284,21 +1302,39 @@ void WebRtcSession::SetVideoSend(uint32_t ssrc,
   }
 }
 
-RtpParameters WebRtcSession::GetVideoRtpParameters(uint32_t ssrc) const {
+RtpParameters WebRtcSession::GetVideoRtpSendParameters(uint32_t ssrc) const {
   ASSERT(signaling_thread()->IsCurrent());
   if (video_channel_) {
-    return video_channel_->GetRtpParameters(ssrc);
+    return video_channel_->GetRtpSendParameters(ssrc);
   }
   return RtpParameters();
 }
 
-bool WebRtcSession::SetVideoRtpParameters(uint32_t ssrc,
-                                          const RtpParameters& parameters) {
+bool WebRtcSession::SetVideoRtpSendParameters(uint32_t ssrc,
+                                              const RtpParameters& parameters) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!video_channel_) {
     return false;
   }
-  return video_channel_->SetRtpParameters(ssrc, parameters);
+  return video_channel_->SetRtpSendParameters(ssrc, parameters);
+}
+
+RtpParameters WebRtcSession::GetVideoRtpReceiveParameters(uint32_t ssrc) const {
+  ASSERT(signaling_thread()->IsCurrent());
+  if (video_channel_) {
+    return video_channel_->GetRtpReceiveParameters(ssrc);
+  }
+  return RtpParameters();
+}
+
+bool WebRtcSession::SetVideoRtpReceiveParameters(
+    uint32_t ssrc,
+    const RtpParameters& parameters) {
+  ASSERT(signaling_thread()->IsCurrent());
+  if (!video_channel_) {
+    return false;
+  }
+  return video_channel_->SetRtpReceiveParameters(ssrc, parameters);
 }
 
 bool WebRtcSession::CanInsertDtmf(const std::string& track_id) {

webrtc/api/webrtcsession.h

@@ -243,9 +243,12 @@ class WebRtcSession : public AudioProviderInterface,
   void SetRawAudioSink(uint32_t ssrc,
                        std::unique_ptr<AudioSinkInterface> sink) override;
 
-  RtpParameters GetAudioRtpParameters(uint32_t ssrc) const override;
-  bool SetAudioRtpParameters(uint32_t ssrc,
-                             const RtpParameters& parameters) override;
+  RtpParameters GetAudioRtpSendParameters(uint32_t ssrc) const override;
+  bool SetAudioRtpSendParameters(uint32_t ssrc,
+                                 const RtpParameters& parameters) override;
+  RtpParameters GetAudioRtpReceiveParameters(uint32_t ssrc) const override;
+  bool SetAudioRtpReceiveParameters(uint32_t ssrc,
+                                    const RtpParameters& parameters) override;
 
   // Implements VideoMediaProviderInterface.
   bool SetSource(
@@ -259,9 +262,12 @@ class WebRtcSession : public AudioProviderInterface,
                     bool enable,
                     const cricket::VideoOptions* options) override;
 
-  RtpParameters GetVideoRtpParameters(uint32_t ssrc) const override;
-  bool SetVideoRtpParameters(uint32_t ssrc,
-                             const RtpParameters& parameters) override;
+  RtpParameters GetVideoRtpSendParameters(uint32_t ssrc) const override;
+  bool SetVideoRtpSendParameters(uint32_t ssrc,
+                                 const RtpParameters& parameters) override;
+  RtpParameters GetVideoRtpReceiveParameters(uint32_t ssrc) const override;
+  bool SetVideoRtpReceiveParameters(uint32_t ssrc,
+                                    const RtpParameters& parameters) override;
 
   // Implements DtmfProviderInterface.
   bool CanInsertDtmf(const std::string& track_id) override;

webrtc/api/webrtcsession_unittest.cc

@@ -3358,19 +3358,19 @@ TEST_F(WebRtcSessionTest, SetAudioMaxSendBitrate) {
   ASSERT_TRUE(channel != NULL);
   uint32_t send_ssrc = channel->send_streams()[0].first_ssrc();
   EXPECT_EQ(-1, channel->max_bps());
-  webrtc::RtpParameters params = session_->GetAudioRtpParameters(send_ssrc);
+  webrtc::RtpParameters params = session_->GetAudioRtpSendParameters(send_ssrc);
   EXPECT_EQ(1, params.encodings.size());
   EXPECT_EQ(-1, params.encodings[0].max_bitrate_bps);
   params.encodings[0].max_bitrate_bps = 1000;
-  EXPECT_TRUE(session_->SetAudioRtpParameters(send_ssrc, params));
+  EXPECT_TRUE(session_->SetAudioRtpSendParameters(send_ssrc, params));
 
   // Read back the parameters and verify they have been changed.
-  params = session_->GetAudioRtpParameters(send_ssrc);
+  params = session_->GetAudioRtpSendParameters(send_ssrc);
   EXPECT_EQ(1, params.encodings.size());
   EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
 
   // Verify that the audio channel received the new parameters.
-  params = channel->GetRtpParameters(send_ssrc);
+  params = channel->GetRtpSendParameters(send_ssrc);
   EXPECT_EQ(1, params.encodings.size());
   EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
 
@@ -3452,19 +3452,19 @@ TEST_F(WebRtcSessionTest, SetVideoMaxSendBitrate) {
   ASSERT_TRUE(channel != NULL);
   uint32_t send_ssrc = channel->send_streams()[0].first_ssrc();
   EXPECT_EQ(-1, channel->max_bps());
-  webrtc::RtpParameters params = session_->GetVideoRtpParameters(send_ssrc);
+  webrtc::RtpParameters params = session_->GetVideoRtpSendParameters(send_ssrc);
   EXPECT_EQ(1, params.encodings.size());
   EXPECT_EQ(-1, params.encodings[0].max_bitrate_bps);
   params.encodings[0].max_bitrate_bps = 1000;
-  EXPECT_TRUE(session_->SetVideoRtpParameters(send_ssrc, params));
+  EXPECT_TRUE(session_->SetVideoRtpSendParameters(send_ssrc, params));
 
   // Read back the parameters and verify they have been changed.
-  params = session_->GetVideoRtpParameters(send_ssrc);
+  params = session_->GetVideoRtpSendParameters(send_ssrc);
   EXPECT_EQ(1, params.encodings.size());
   EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
 
   // Verify that the video channel received the new parameters.
-  params = channel->GetRtpParameters(send_ssrc);
+  params = channel->GetRtpSendParameters(send_ssrc);
   EXPECT_EQ(1, params.encodings.size());
   EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);