Adding getParameters/setParameters APIs to RtpReceiver.

webrtc/media/engine/webrtcvoiceengine_unittest.cc

 /*
  *  Copyright (c) 2008 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 216 matching lines @@
     EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters));
 
     int channel_num = voe_.GetLastChannel();
     webrtc::CodecInst temp_codec;
     EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec));
     EXPECT_EQ(expected_bitrate, temp_codec.rate);
   }
 
   // Sets the per-stream maximum bitrate limit for the specified SSRC.
   bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) {
-    webrtc::RtpParameters parameters = channel_->GetRtpParameters(ssrc);
+    webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc);
     EXPECT_EQ(1UL, parameters.encodings.size());
 
     parameters.encodings[0].max_bitrate_bps = bitrate;
-    return channel_->SetRtpParameters(ssrc, parameters);
+    return channel_->SetRtpSendParameters(ssrc, parameters);
   }
 
   bool SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) {
     cricket::AudioSendParameters send_parameters;
     send_parameters.codecs.push_back(codec);
     send_parameters.max_bandwidth_bps = bitrate;
     return channel_->SetSendParameters(send_parameters);
   }
 
   int GetCodecBitrate(int32_t ssrc) {
@@ skipping 14 matching lines @@
     // Clear the bitrate limit from the previous test case.
     EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1));
 
     // Attempt to set the requested bitrate limits.
     EXPECT_TRUE(SetGlobalMaxBitrate(codec, global_max));
     EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrc1, stream_max));
 
     // Verify that reading back the parameters gives results
     // consistent with the Set() result.
     webrtc::RtpParameters resulting_parameters =
-        channel_->GetRtpParameters(kSsrc1);
+        channel_->GetRtpSendParameters(kSsrc1);
     EXPECT_EQ(1UL, resulting_parameters.encodings.size());
     EXPECT_EQ(expected_result ? stream_max : -1,
               resulting_parameters.encodings[0].max_bitrate_bps);
 
     // Verify that the codec settings have the expected bitrate.
     EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrc1));
   }
 
   void TestSetSendRtpHeaderExtensions(const std::string& ext) {
     EXPECT_TRUE(SetupSendStream());
@@ skipping 601 matching lines @@
   // CBR codecs don't allow per stream maximums to be too low.
   SetAndExpectMaxBitrate(kPcmuCodec, 0, 63999, false, 64000);
   SetAndExpectMaxBitrate(kPcmuCodec, 64001, 63999, false, 64000);
 }
 
 // Test that an attempt to set RtpParameters for a stream that does not exist
 // fails.
 TEST_F(WebRtcVoiceEngineTestFake, CannotSetMaxBitrateForNonexistentStream) {
   EXPECT_TRUE(SetupChannel());
   webrtc::RtpParameters nonexistent_parameters =
-      channel_->GetRtpParameters(kSsrc1);
+      channel_->GetRtpSendParameters(kSsrc1);
   EXPECT_EQ(0, nonexistent_parameters.encodings.size());
 
   nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
-  EXPECT_FALSE(channel_->SetRtpParameters(kSsrc1, nonexistent_parameters));
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, nonexistent_parameters));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake,
-       CannotSetRtpParametersWithIncorrectNumberOfEncodings) {
+       CannotSetRtpSendParametersWithIncorrectNumberOfEncodings) {
   // This test verifies that setting RtpParameters succeeds only if
   // the structure contains exactly one encoding.
   // TODO(skvlad): Update this test when we start supporting setting parameters
   // for each encoding individually.
 
   EXPECT_TRUE(SetupSendStream());
   // Setting RtpParameters with no encoding is expected to fail.
   webrtc::RtpParameters parameters;
-  EXPECT_FALSE(channel_->SetRtpParameters(kSsrc1, parameters));
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters));
   // Setting RtpParameters with exactly one encoding should succeed.
   parameters.encodings.push_back(webrtc::RtpEncodingParameters());
-  EXPECT_TRUE(channel_->SetRtpParameters(kSsrc1, parameters));
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters));
   // Two or more encodings should result in failure.
   parameters.encodings.push_back(webrtc::RtpEncodingParameters());
-  EXPECT_FALSE(channel_->SetRtpParameters(kSsrc1, parameters));
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters));
 }
 
 // Test that a stream will not be sending if its encoding is made
-// inactive through SetRtpParameters.
+// inactive through SetRtpSendParameters.
 TEST_F(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) {
   EXPECT_TRUE(SetupSendStream());
   SetSend(channel_, true);
   EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
   // Get current parameters and change "active" to false.
-  webrtc::RtpParameters parameters = channel_->GetRtpParameters(kSsrc1);
+  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc1);
   ASSERT_EQ(1u, parameters.encodings.size());
   ASSERT_TRUE(parameters.encodings[0].active);
   parameters.encodings[0].active = false;
-  EXPECT_TRUE(channel_->SetRtpParameters(kSsrc1, parameters));
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters));
   EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
 
   // Now change it back to active and verify we resume sending.
   parameters.encodings[0].active = true;
-  EXPECT_TRUE(channel_->SetRtpParameters(kSsrc1, parameters));
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters));
   EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
 }
 
-// Test that SetRtpParameters configures the correct encoding channel for each
-// SSRC.
+// Test that SetRtpSendParameters configures the correct encoding channel for
+// each SSRC.
 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) {
   SetupForMultiSendStream();
   // Create send streams.
   for (uint32_t ssrc : kSsrcs4) {
     EXPECT_TRUE(
         channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc)));
   }
   // Configure one stream to be limited by the stream config, another to be
   // limited by the global max, and the third one with no per-stream limit
   // (still subject to the global limit).
   EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, 64000));
   EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000));
   EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000));
   EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1));
 
   EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0]));
   EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1]));
   EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2]));
 
   // Remove the global cap; the streams should switch to their respective
   // maximums (or remain unchanged if there was no other limit on them.)
   EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, -1));
   EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0]));
   EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1]));
   EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2]));
 }
 
-// Test that GetRtpParameters returns the currently configured codecs.
-TEST_F(WebRtcVoiceEngineTestFake, GetRtpParametersCodecs) {
+// Test that GetRtpSendParameters returns the currently configured codecs.
+TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
-  webrtc::RtpParameters rtp_parameters = channel_->GetRtpParameters(kSsrc1);
+  webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc1);
   ASSERT_EQ(2u, rtp_parameters.codecs.size());
-  EXPECT_EQ(kIsacCodec.id, rtp_parameters.codecs[0].payload_type);
-  EXPECT_EQ(kIsacCodec.name, rtp_parameters.codecs[0].mime_type);
-  EXPECT_EQ(kIsacCodec.clockrate, rtp_parameters.codecs[0].clock_rate);
-  EXPECT_EQ(kIsacCodec.channels, rtp_parameters.codecs[0].channels);
-  EXPECT_EQ(kPcmuCodec.id, rtp_parameters.codecs[1].payload_type);
-  EXPECT_EQ(kPcmuCodec.name, rtp_parameters.codecs[1].mime_type);
-  EXPECT_EQ(kPcmuCodec.clockrate, rtp_parameters.codecs[1].clock_rate);
-  EXPECT_EQ(kPcmuCodec.channels, rtp_parameters.codecs[1].channels);
+  EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]);
+  EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]);
 }
 
 // Test that if we set/get parameters multiple times, we get the same results.
-TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpParameters) {
+TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
-  webrtc::RtpParameters initial_params = channel_->GetRtpParameters(kSsrc1);
+  webrtc::RtpParameters initial_params = channel_->GetRtpSendParameters(kSsrc1);
 
   // We should be able to set the params we just got.
-  EXPECT_TRUE(channel_->SetRtpParameters(kSsrc1, initial_params));
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, initial_params));
 
-  // ... And this shouldn't change the params returned by GetRtpParameters.
-  webrtc::RtpParameters new_params = channel_->GetRtpParameters(kSsrc1);
-  EXPECT_EQ(initial_params, channel_->GetRtpParameters(kSsrc1));
+  // ... And this shouldn't change the params returned by GetRtpSendParameters.
+  webrtc::RtpParameters new_params = channel_->GetRtpSendParameters(kSsrc1);
+  EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(kSsrc1));
+}
+
+// Test that GetRtpReceiveParameters returns the currently configured codecs.
+TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) {
+  EXPECT_TRUE(SetupRecvStream());
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
+
+  webrtc::RtpParameters rtp_parameters =
+      channel_->GetRtpReceiveParameters(kSsrc1);
+  ASSERT_EQ(2u, rtp_parameters.codecs.size());
+  EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]);
+  EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]);
+}
+
+// Test that if we set/get parameters multiple times, we get the same results.
+TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) {
+  EXPECT_TRUE(SetupRecvStream());
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
+
+  webrtc::RtpParameters initial_params =
+      channel_->GetRtpReceiveParameters(kSsrc1);
+
+  // We should be able to set the params we just got.
+  EXPECT_TRUE(channel_->SetRtpReceiveParameters(kSsrc1, initial_params));
+
+  // ... And this shouldn't change the params returned by
+  // GetRtpReceiveParameters.
+  webrtc::RtpParameters new_params = channel_->GetRtpReceiveParameters(kSsrc1);
+  EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(kSsrc1));
 }
 
 // Test that we apply codecs properly.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kRedCodec);
   parameters.codecs[0].id = 96;
@@ skipping 2625 matching lines @@
 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
   cricket::WebRtcVoiceEngine engine(nullptr);
   std::unique_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(),
                                            cricket::AudioOptions(), call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }