Add the function ToRtpParameters.

webrtc/ortc/rtpparametersconversion_unittest.cc

 /*
  *  Copyright 2017 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 438 matching lines @@
   ASSERT_EQ(2u, codec.parameters.size());
   EXPECT_EQ("bar", codec.parameters["foo"]);
   EXPECT_EQ("param", codec.parameters["ANOTHER"]);
   EXPECT_EQ(2u, codec.rtcp_feedback.size());
   EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::TRANSPORT_CC),
             codec.rtcp_feedback[0]);
   EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::NACK, RtcpFeedbackMessageType::PLI),
             codec.rtcp_feedback[1]);
 }
 
+// Tests that the StreamParamsVec can be successfully converted to
+// RtpEncodingParameters and vice versa.

[Taylor Brandstetter, 2017/03/08 22:35:49]

Since there are already independent tests for ToCricketStreamParamsVec, I think
this test should test ToRtpEncodings independently.

It also would be good to test some corner cases such as an empty list, or list
with 2+ entries.

[Zhi Huang, 2017/03/08 23:56:49]

Done.

+TEST(RtpParametersConversionTest, StreamParamsVecAndRtpEncodingConversion) {
+  // Translate RtpEncodingParameters to StreamParamVec.
+  std::vector<RtpEncodingParameters> encodings;
+  RtpEncodingParameters encoding;
+  encoding.ssrc.emplace(1234u);
+  encoding.rtx.emplace(0xdeadbeef);
+  encodings.push_back(encoding);
+  auto result = ToCricketStreamParamsVec(encodings);
+  ASSERT_TRUE(result.ok());
+  ASSERT_EQ(1u, result.value().size());
+  EXPECT_EQ(2u, result.value()[0].ssrcs.size());
+  EXPECT_EQ(1234u, result.value()[0].first_ssrc());
+  uint32_t rtx_ssrc = 0;
+  EXPECT_TRUE(result.value()[0].GetFidSsrc(1234u, &rtx_ssrc));
+  EXPECT_EQ(0xdeadbeef, rtx_ssrc);
+  // Translate StreamParamVec back to RtpEncodingParameters.
+  auto rtp_encodings = ToRtpEncodings(result.MoveValue());
+  ASSERT_EQ(1u, rtp_encodings.size());
+  EXPECT_EQ(1234, rtp_encodings[0].ssrc);
+  EXPECT_EQ(0xdeadbeef, rtp_encodings[0].rtx->ssrc);
+}
+
+TEST(RtpParametersConversionTest, ToAudioRtpCodecParameters) {
+  cricket::VideoCodec cricket_codec;

[Taylor Brandstetter, 2017/03/08 22:35:49]

Should be AudioCodec; it looks like this is a copy of the below test.

[Zhi Huang, 2017/03/08 23:56:49]

Oh, I must forgot to update this for some reason. 

+  cricket_codec.name = "VID";
+  cricket_codec.id = 101;
+  cricket_codec.clockrate = 80000;
+  cricket_codec.params["foo"] = "bar";
+  cricket_codec.params["ANOTHER"] = "param";
+  cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
+  cricket_codec.feedback_params.Add({"nack", "pli"});
+  RtpCodecParameters codec = ToRtpCodecParameters(cricket_codec);
+
+  EXPECT_EQ("VID", codec.name);
+  EXPECT_EQ(cricket::MEDIA_TYPE_VIDEO, codec.kind);
+  EXPECT_EQ(101, codec.payload_type);
+  EXPECT_EQ(rtc::Optional<int>(80000), codec.clock_rate);
+  ASSERT_EQ(2u, codec.parameters.size());
+  EXPECT_EQ("bar", codec.parameters["foo"]);
+  EXPECT_EQ("param", codec.parameters["ANOTHER"]);
+  EXPECT_EQ(2u, codec.rtcp_feedback.size());
+  EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::TRANSPORT_CC),
+            codec.rtcp_feedback[0]);
+  EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::NACK, RtcpFeedbackMessageType::PLI),
+            codec.rtcp_feedback[1]);
+}
+
+TEST(RtpParametersConversionTest, ToVideoRtpCodecParameters) {
+  cricket::VideoCodec cricket_codec;
+  cricket_codec.name = "VID";
+  cricket_codec.id = 101;
+  cricket_codec.clockrate = 80000;
+  cricket_codec.params["foo"] = "bar";
+  cricket_codec.params["ANOTHER"] = "param";
+  cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
+  cricket_codec.feedback_params.Add({"nack", "pli"});
+  RtpCodecParameters codec = ToRtpCodecParameters(cricket_codec);
+
+  EXPECT_EQ("VID", codec.name);
+  EXPECT_EQ(cricket::MEDIA_TYPE_VIDEO, codec.kind);
+  EXPECT_EQ(101, codec.payload_type);
+  EXPECT_EQ(rtc::Optional<int>(80000), codec.clock_rate);
+  ASSERT_EQ(2u, codec.parameters.size());
+  EXPECT_EQ("bar", codec.parameters["foo"]);
+  EXPECT_EQ("param", codec.parameters["ANOTHER"]);
+  EXPECT_EQ(2u, codec.rtcp_feedback.size());
+  EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::TRANSPORT_CC),
+            codec.rtcp_feedback[0]);
+  EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::NACK, RtcpFeedbackMessageType::PLI),
+            codec.rtcp_feedback[1]);
+}
+
 // An unknown feedback param should just be ignored.
 TEST(RtpParametersConversionTest, ToRtpCodecCapabilityUnknownFeedbackParam) {
   cricket::AudioCodec cricket_codec;
   cricket_codec.name = "foo";
   cricket_codec.id = 50;
   cricket_codec.clockrate = 22222;
   cricket_codec.channels = 4;
   cricket_codec.params["foo"] = "bar";
   cricket_codec.feedback_params.Add({"unknown", "param"});
   cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
@@ skipping 56 matching lines @@
   EXPECT_EQ(3u, capabilities.codecs.size());
   EXPECT_EQ(2u, capabilities.fec.size());
   EXPECT_NE(capabilities.fec.end(),
             std::find(capabilities.fec.begin(), capabilities.fec.end(),
                       FecMechanism::RED));
   EXPECT_NE(capabilities.fec.end(),
             std::find(capabilities.fec.begin(), capabilities.fec.end(),
                       FecMechanism::FLEXFEC));
 }
 
+TEST(RtpParametersConversionTest, ToRtpParameters) {
+  cricket::VideoCodec vp8;
+  vp8.name = "VP8";
+  vp8.id = 101;
+  vp8.clockrate = 90000;
+
+  cricket::VideoCodec red;
+  red.name = "red";
+  red.id = 102;
+  red.clockrate = 90000;
+
+  cricket::VideoCodec ulpfec;
+  ulpfec.name = "ulpfec";
+  ulpfec.id = 103;
+  ulpfec.clockrate = 90000;
+
+  cricket::StreamParamsVec streams;
+  cricket::StreamParams stream;
+  stream.ssrcs.push_back(1234u);
+  streams.push_back(stream);
+
+  RtpParameters rtp_parameters = ToRtpParameters<cricket::VideoCodec>(
+      {vp8, red, ulpfec}, {{"uri", 1}, {"uri2", 3}}, streams);
+  ASSERT_EQ(3u, rtp_parameters.codecs.size());
+  EXPECT_EQ("VP8", rtp_parameters.codecs[0].name);
+  EXPECT_EQ("red", rtp_parameters.codecs[1].name);
+  EXPECT_EQ("ulpfec", rtp_parameters.codecs[2].name);
+  ASSERT_EQ(2u, rtp_parameters.header_extensions.size());
+  EXPECT_EQ("uri", rtp_parameters.header_extensions[0].uri);
+  EXPECT_EQ(1, rtp_parameters.header_extensions[0].id);
+  EXPECT_EQ("uri2", rtp_parameters.header_extensions[1].uri);
+  EXPECT_EQ(3, rtp_parameters.header_extensions[1].id);
+  ASSERT_EQ(1u, rtp_parameters.encodings.size());
+  EXPECT_EQ(1234u, rtp_parameters.encodings[0].ssrc);
+}
+
 }  // namespace webrtc