Add the function ToRtpParameters.

webrtc/ortc/rtpparametersconversion.cc

Index: webrtc/ortc/rtpparametersconversion.cc
diff --git a/webrtc/ortc/rtpparametersconversion.cc b/webrtc/ortc/rtpparametersconversion.cc
index 63ee9c74dac6aec07b304fa73739a4834e2d145b..dfbde883f41e50c3e0d6285f9b8937161a19a678 100644
--- a/webrtc/ortc/rtpparametersconversion.cc
+++ b/webrtc/ortc/rtpparametersconversion.cc
@@ -277,6 +277,23 @@ rtc::Optional<RtcpFeedback> ToRtcpFeedback(
   return rtc::Optional<RtcpFeedback>();
 }
 
+std::vector<RtpEncodingParameters> ToRtpEncodings(
+    const cricket::StreamParamsVec& stream_params) {
+  std::vector<RtpEncodingParameters> rtp_encodings;
+  if (stream_params.size() > 0) {

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

What if there are more than 1 StreamParams? The simplest thing would just be to
change this to a "for each" loop.

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

Oh, I was wrong. I thought that since ORTC api doesn't support more than
RtpEncodingsParameters, StreamParamsVec wouldn't contain more than one.

[Taylor Brandstetter, 2017/03/09 00:41:43]

You're right that the ORTC RtpSender/RtpReceiver doesn't support multiple
encodings (currently). But assuming this is used for the SDP parsing API, it
will be possible to pass in SDP with multiple SSRCs/SSRC groups. The application
might then, for example, pass one of the RtpEncodingParameters into one
RtpSender, and the other into another RtpSender, giving them identical
codec/header extension/etc. parameters. This is basically what "Plan B" SDP
does.

+    const cricket::StreamParams& stream_param = stream_params[0];
+    RtpEncodingParameters rtp_encoding;
+    rtp_encoding.ssrc = rtc::Optional<uint32_t>(stream_param.first_ssrc());

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

nit: Instead of "= rtc::Optional...", you can do ".emplace"

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

Done.

+    uint32_t rtx_ssrc = 0;
+    if (stream_param.GetFidSsrc(stream_param.first_ssrc(), &rtx_ssrc)) {
+      RtpRtxParameters rtx_param(rtx_ssrc);
+      rtp_encoding.rtx = rtc::Optional<RtpRtxParameters>(rtx_param);
+    }
+    rtp_encodings.push_back(std::move(rtp_encoding));
+  }
+  return rtp_encodings;
+}
+
 template <typename C>
 cricket::MediaType KindOfCodec();
 
@@ -332,6 +349,47 @@ template RtpCodecCapability ToRtpCodecCapability<cricket::AudioCodec>(
 template RtpCodecCapability ToRtpCodecCapability<cricket::VideoCodec>(
     const cricket::VideoCodec& cricket_codec);
 
+template <typename C>
+static void ToRtpCodecParametersTypeSpecific(const C& cricket_codec,
+                                             RtpCodecParameters* codec);
+template <>
+void ToRtpCodecParametersTypeSpecific<cricket::AudioCodec>(
+    const cricket::AudioCodec& cricket_codec,
+    RtpCodecParameters* codec) {
+  codec->num_channels =
+      rtc::Optional<int>(static_cast<int>(cricket_codec.channels));
+}
+
+template <>
+void ToRtpCodecParametersTypeSpecific<cricket::VideoCodec>(
+    const cricket::VideoCodec& cricket_codec,
+    RtpCodecParameters* codec) {}
+
+template <typename C>
+RtpCodecParameters ToRtpCodecParameters(const C& cricket_codec) {
+  RtpCodecParameters codec_param;
+  codec_param.name = cricket_codec.name;
+  codec_param.kind = KindOfCodec<C>();
+  codec_param.clock_rate.emplace(cricket_codec.clockrate);
+  codec_param.payload_type = cricket_codec.id;
+  for (const cricket::FeedbackParam& cricket_feedback :
+       cricket_codec.feedback_params.params()) {
+    rtc::Optional<RtcpFeedback> feedback = ToRtcpFeedback(cricket_feedback);
+    if (feedback) {
+      codec_param.rtcp_feedback.push_back(feedback.MoveValue());
+    }
+  }
+  ToRtpCodecParametersTypeSpecific(cricket_codec, &codec_param);
+  codec_param.parameters.insert(cricket_codec.params.begin(),
+                                cricket_codec.params.end());
+  return codec_param;
+}
+
+template RtpCodecParameters ToRtpCodecParameters<cricket::AudioCodec>(
+    const cricket::AudioCodec& cricket_codec);
+template RtpCodecParameters ToRtpCodecParameters<cricket::VideoCodec>(
+    const cricket::VideoCodec& cricket_codec);
+
 template <class C>
 RtpCapabilities ToRtpCapabilities(
     const std::vector<C>& cricket_codecs,
@@ -373,4 +431,30 @@ template RtpCapabilities ToRtpCapabilities<cricket::VideoCodec>(
     const std::vector<cricket::VideoCodec>& cricket_codecs,
     const cricket::RtpHeaderExtensions& cricket_extensions);
 
+template <class C>
+RtpParameters ToRtpParameters(
+    const std::vector<C>& cricket_codecs,
+    const cricket::RtpHeaderExtensions& cricket_extensions,
+    const cricket::StreamParamsVec& stream_params) {
+  RtpParameters rtp_parameters;
+  for (const C& cricket_codec : cricket_codecs) {
+    rtp_parameters.codecs.push_back(ToRtpCodecParameters(cricket_codec));
+  }
+  for (const RtpExtension& cricket_extension : cricket_extensions) {
+    rtp_parameters.header_extensions.emplace_back(cricket_extension.uri,
+                                                  cricket_extension.id);
+  }
+  rtp_parameters.encodings = ToRtpEncodings(stream_params);
+  return rtp_parameters;
+}
+
+template RtpParameters ToRtpParameters<cricket::AudioCodec>(
+    const std::vector<cricket::AudioCodec>& cricket_codecs,
+    const cricket::RtpHeaderExtensions& cricket_extensions,
+    const cricket::StreamParamsVec& stream_params);
+template RtpParameters ToRtpParameters<cricket::VideoCodec>(
+    const std::vector<cricket::VideoCodec>& cricket_codecs,
+    const cricket::RtpHeaderExtensions& cricket_extensions,
+    const cricket::StreamParamsVec& stream_params);
+
 }  // namespace webrtc