Adding "adapter" ORTC objects on top of ChannelManager/BaseChannel/etc.

webrtc/ortc/testrtpparameters.cc

Index: webrtc/ortc/testrtpparameters.cc
diff --git a/webrtc/ortc/testrtpparameters.cc b/webrtc/ortc/testrtpparameters.cc
new file mode 100644
index 0000000000000000000000000000000000000000..de2e7d5bd20bc6ccee8f70db61b769f6e664ac14
--- /dev/null
+++ b/webrtc/ortc/testrtpparameters.cc
@@ -0,0 +1,311 @@
+/*
+ *  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.
+ */
+
+#include "webrtc/ortc/testrtpparameters.h"
+
+#include <algorithm>
+#include <utility>
+
+namespace webrtc {
+
+RtpParameters MakeMinimalOpusParameters() {
+  RtpParameters parameters;
+  RtpCodecParameters opus_codec;
+  opus_codec.name = "opus";
+  opus_codec.kind = cricket::MEDIA_TYPE_AUDIO;
+  opus_codec.payload_type = 111;
+  opus_codec.clock_rate.emplace(48000);
+  opus_codec.num_channels.emplace(2);
+  parameters.codecs.push_back(std::move(opus_codec));
+  RtpEncodingParameters encoding;
+  encoding.codec_payload_type.emplace(111);
+  parameters.encodings.push_back(std::move(encoding));
+  return parameters;
+}
+
+RtpParameters MakeMinimalIsacParameters() {
+  RtpParameters parameters;
+  RtpCodecParameters isac_codec;
+  isac_codec.name = "ISAC";
+  isac_codec.kind = cricket::MEDIA_TYPE_AUDIO;
+  isac_codec.payload_type = 103;
+  isac_codec.clock_rate.emplace(16000);
+  parameters.codecs.push_back(std::move(isac_codec));
+  RtpEncodingParameters encoding;
+  encoding.codec_payload_type.emplace(111);
+  parameters.encodings.push_back(std::move(encoding));
+  return parameters;
+}
+
+RtpParameters MakeMinimalOpusParametersWithSsrc(uint32_t ssrc) {
+  RtpParameters parameters = MakeMinimalOpusParameters();
+  parameters.encodings[0].ssrc.emplace(ssrc);
+  return parameters;
+}
+
+RtpParameters MakeMinimalIsacParametersWithSsrc(uint32_t ssrc) {
+  RtpParameters parameters = MakeMinimalIsacParameters();
+  parameters.encodings[0].ssrc.emplace(ssrc);
+  return parameters;
+}
+
+RtpParameters MakeMinimalVideoParameters(const char* codec_name) {
+  RtpParameters parameters;
+  RtpCodecParameters vp8_codec;
+  vp8_codec.name = codec_name;
+  vp8_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp8_codec.payload_type = 96;
+  parameters.codecs.push_back(std::move(vp8_codec));
+  RtpEncodingParameters encoding;
+  encoding.codec_payload_type.emplace(96);
+  parameters.encodings.push_back(std::move(encoding));
+  return parameters;
+}
+
+RtpParameters MakeMinimalVp8Parameters() {
+  return MakeMinimalVideoParameters("VP8");
+}
+
+RtpParameters MakeMinimalVp9Parameters() {
+  return MakeMinimalVideoParameters("VP9");
+}
+
+RtpParameters MakeMinimalVp8ParametersWithSsrc(uint32_t ssrc) {
+  RtpParameters parameters = MakeMinimalVp8Parameters();
+  parameters.encodings[0].ssrc.emplace(ssrc);
+  return parameters;
+}
+
+RtpParameters MakeMinimalVp9ParametersWithSsrc(uint32_t ssrc) {
+  RtpParameters parameters = MakeMinimalVp9Parameters();
+  parameters.encodings[0].ssrc.emplace(ssrc);
+  return parameters;
+}
+
+// Note: Currently, these "WithNoSsrc" methods are identical to the normal
+// "MakeMinimal" methods, but with the added guarantee that they will never be
+// changed to include an SSRC.
+
+RtpParameters MakeMinimalOpusParametersWithNoSsrc() {
+  RtpParameters parameters = MakeMinimalOpusParameters();
+  RTC_DCHECK(!parameters.encodings[0].ssrc);
+  return parameters;
+}
+
+RtpParameters MakeMinimalIsacParametersWithNoSsrc() {
+  RtpParameters parameters = MakeMinimalIsacParameters();
+  RTC_DCHECK(!parameters.encodings[0].ssrc);
+  return parameters;
+}
+
+RtpParameters MakeMinimalVp8ParametersWithNoSsrc() {
+  RtpParameters parameters = MakeMinimalVp8Parameters();
+  RTC_DCHECK(!parameters.encodings[0].ssrc);
+  return parameters;
+}
+
+RtpParameters MakeMinimalVp9ParametersWithNoSsrc() {
+  RtpParameters parameters = MakeMinimalVp9Parameters();
+  RTC_DCHECK(!parameters.encodings[0].ssrc);
+  return parameters;
+}
+
+// Make audio parameters with all the available properties configured and
+// features used, and with multiple codecs offered. Obtained by taking a
+// snapshot of a default PeerConnection offer (and adding other things, like
+// bitrate limit).
+//
+// See "MakeFullOpusParameters"/"MakeFullIsacParameters" below.
+RtpParameters MakeFullAudioParameters(int preferred_payload_type) {
+  RtpParameters parameters;
+
+  RtpCodecParameters opus_codec;
+  opus_codec.name = "opus";
+  opus_codec.kind = cricket::MEDIA_TYPE_AUDIO;
+  opus_codec.payload_type = 111;
+  opus_codec.clock_rate.emplace(48000);
+  opus_codec.num_channels.emplace(2);
+  opus_codec.parameters["minptime"] = "10";
+  opus_codec.parameters["useinbandfec"] = "1";
+  opus_codec.parameters["usedtx"] = "1";
+  opus_codec.parameters["stereo"] = "1";
+  opus_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC);
+  parameters.codecs.push_back(std::move(opus_codec));
+
+  RtpCodecParameters isac_codec;
+  isac_codec.name = "ISAC";
+  isac_codec.kind = cricket::MEDIA_TYPE_AUDIO;
+  isac_codec.payload_type = 103;
+  isac_codec.clock_rate.emplace(16000);
+  parameters.codecs.push_back(std::move(isac_codec));
+
+  RtpCodecParameters cn_codec;
+  cn_codec.name = "CN";
+  cn_codec.kind = cricket::MEDIA_TYPE_AUDIO;
+  cn_codec.payload_type = 106;
+  cn_codec.clock_rate.emplace(32000);
+  parameters.codecs.push_back(std::move(cn_codec));
+
+  RtpCodecParameters dtmf_codec;
+  dtmf_codec.name = "telephone-event";
+  dtmf_codec.kind = cricket::MEDIA_TYPE_AUDIO;
+  dtmf_codec.payload_type = 126;
+  dtmf_codec.clock_rate.emplace(8000);
+  parameters.codecs.push_back(std::move(dtmf_codec));
+
+  // "codec_payload_type" isn't implemented, so we need to reorder codecs to
+  // cause one to be used.
+  // TODO(deadbeef): Remove this when it becomes unnecessary.
+  std::sort(parameters.codecs.begin(), parameters.codecs.end(),
+            [preferred_payload_type](const RtpCodecParameters& a,
+                                     const RtpCodecParameters& b) {
+              return a.payload_type == preferred_payload_type;
+            });
+
+  // Intentionally leave out SSRC so one's chosen automatically.
+  RtpEncodingParameters encoding;
+  encoding.codec_payload_type.emplace(preferred_payload_type);
+  encoding.dtx.emplace(DtxStatus::ENABLED);
+  // 20 kbps.
+  encoding.max_bitrate_bps.emplace(20000);
+  parameters.encodings.push_back(std::move(encoding));
+
+  parameters.header_extensions.emplace_back(
+      "urn:ietf:params:rtp-hdrext:ssrc-audio-level", 1);
+  return parameters;
+}
+
+RtpParameters MakeFullOpusParameters() {
+  return MakeFullAudioParameters(111);
+}
+
+RtpParameters MakeFullIsacParameters() {
+  return MakeFullAudioParameters(103);
+}
+
+// Make video parameters with all the available properties configured and
+// features used, and with multiple codecs offered. Obtained by taking a
+// snapshot of a default PeerConnection offer (and adding other things, like
+// bitrate limit).
+//
+// See "MakeFullVp8Parameters"/"MakeFullVp9Parameters" below.
+RtpParameters MakeFullVideoParameters(int preferred_payload_type) {
+  RtpParameters parameters;
+
+  RtpCodecParameters vp8_codec;
+  vp8_codec.name = "VP8";
+  vp8_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp8_codec.payload_type = 100;
+  vp8_codec.clock_rate.emplace(90000);
+  vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::CCM,
+                                       RtcpFeedbackMessageType::FIR);
+  vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK,
+                                       RtcpFeedbackMessageType::GENERIC_NACK);
+  vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK,
+                                       RtcpFeedbackMessageType::PLI);
+  vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::REMB);
+  vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC);
+  parameters.codecs.push_back(std::move(vp8_codec));
+
+  RtpCodecParameters vp8_rtx_codec;
+  vp8_rtx_codec.name = "rtx";
+  vp8_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp8_rtx_codec.payload_type = 96;
+  vp8_rtx_codec.clock_rate.emplace(90000);
+  vp8_rtx_codec.parameters["apt"] = "100";
+  parameters.codecs.push_back(std::move(vp8_rtx_codec));
+
+  RtpCodecParameters vp9_codec;
+  vp9_codec.name = "VP9";
+  vp9_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp9_codec.payload_type = 101;
+  vp9_codec.clock_rate.emplace(90000);
+  vp9_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::CCM,
+                                       RtcpFeedbackMessageType::FIR);
+  vp9_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK,
+                                       RtcpFeedbackMessageType::GENERIC_NACK);
+  vp9_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK,
+                                       RtcpFeedbackMessageType::PLI);
+  vp9_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::REMB);
+  vp9_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC);
+  parameters.codecs.push_back(std::move(vp9_codec));
+
+  RtpCodecParameters vp9_rtx_codec;
+  vp9_rtx_codec.name = "rtx";
+  vp9_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp9_rtx_codec.payload_type = 97;
+  vp9_rtx_codec.clock_rate.emplace(90000);
+  vp9_rtx_codec.parameters["apt"] = "101";
+  parameters.codecs.push_back(std::move(vp9_rtx_codec));
+
+  RtpCodecParameters red_codec;
+  red_codec.name = "red";
+  red_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  red_codec.payload_type = 116;
+  red_codec.clock_rate.emplace(90000);
+  parameters.codecs.push_back(std::move(red_codec));
+
+  RtpCodecParameters red_rtx_codec;
+  red_rtx_codec.name = "rtx";
+  red_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  red_rtx_codec.payload_type = 98;
+  red_rtx_codec.clock_rate.emplace(90000);
+  red_rtx_codec.parameters["apt"] = "116";
+  parameters.codecs.push_back(std::move(red_rtx_codec));
+
+  RtpCodecParameters ulpfec_codec;
+  ulpfec_codec.name = "ulpfec";
+  ulpfec_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  ulpfec_codec.payload_type = 117;
+  ulpfec_codec.clock_rate.emplace(90000);
+  parameters.codecs.push_back(std::move(ulpfec_codec));
+
+  // "codec_payload_type" isn't implemented, so we need to reorder codecs to
+  // cause one to be used.
+  // TODO(deadbeef): Remove this when it becomes unnecessary.
+  std::sort(parameters.codecs.begin(), parameters.codecs.end(),
+            [preferred_payload_type](const RtpCodecParameters& a,
+                                     const RtpCodecParameters& b) {
+              return a.payload_type == preferred_payload_type;
+            });
+
+  // Intentionally leave out SSRC so one's chosen automatically.
+  RtpEncodingParameters encoding;
+  encoding.codec_payload_type.emplace(preferred_payload_type);
+  encoding.fec.emplace(FecMechanism::RED_AND_ULPFEC);
+  // Will create default RtxParameters, with unset SSRC.
+  encoding.rtx.emplace();
+  // 100 kbps.
+  encoding.max_bitrate_bps.emplace(100000);
+  parameters.encodings.push_back(std::move(encoding));
+
+  parameters.header_extensions.emplace_back(
+      "urn:ietf:params:rtp-hdrext:toffset", 2);
+  parameters.header_extensions.emplace_back(
+      "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time", 3);
+  parameters.header_extensions.emplace_back("urn:3gpp:video-orientation", 4);
+  parameters.header_extensions.emplace_back(
+      "http://www.ietf.org/id/"
+      "draft-holmer-rmcat-transport-wide-cc-extensions-01",
+      5);
+  parameters.header_extensions.emplace_back(
+      "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay", 6);
+  return parameters;
+}
+
+RtpParameters MakeFullVp8Parameters() {
+  return MakeFullVideoParameters(100);
+}
+
+RtpParameters MakeFullVp9Parameters() {
+  return MakeFullVideoParameters(101);
+}
+
+}  // namespace webrtc