blob: 90e4a4cf1c39c942a78f6acd8d8d885c5d3482c8 [file] [log] [blame]
skvladdc1c62c2016-03-16 19:07:43 -07001/*
2 * Copyright 2015 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Steve Anton10542f22019-01-11 09:11:00 -080011#ifndef API_RTP_PARAMETERS_H_
12#define API_RTP_PARAMETERS_H_
skvladdc1c62c2016-03-16 19:07:43 -070013
Yves Gerey988cc082018-10-23 12:03:01 +020014#include <stdint.h>
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -070015#include <string>
deadbeefe702b302017-02-04 12:09:01 -080016#include <unordered_map>
skvladdc1c62c2016-03-16 19:07:43 -070017#include <vector>
18
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +020019#include "absl/types/optional.h"
Steve Anton10542f22019-01-11 09:11:00 -080020#include "api/media_types.h"
Mirko Bonadeiac194142018-10-22 17:08:37 +020021#include "rtc_base/system/rtc_export.h"
sakal1fd95952016-06-22 00:46:15 -070022
skvladdc1c62c2016-03-16 19:07:43 -070023namespace webrtc {
24
deadbeefe702b302017-02-04 12:09:01 -080025// These structures are intended to mirror those defined by:
26// http://draft.ortc.org/#rtcrtpdictionaries*
27// Contains everything specified as of 2017 Jan 24.
28//
29// They are used when retrieving or modifying the parameters of an
30// RtpSender/RtpReceiver, or retrieving capabilities.
31//
32// Note on conventions: Where ORTC may use "octet", "short" and "unsigned"
33// types, we typically use "int", in keeping with our style guidelines. The
34// parameter's actual valid range will be enforced when the parameters are set,
35// rather than when the parameters struct is built. An exception is made for
36// SSRCs, since they use the full unsigned 32-bit range, and aren't expected to
37// be used for any numeric comparisons/operations.
38//
39// Additionally, where ORTC uses strings, we may use enums for things that have
40// a fixed number of supported values. However, for things that can be extended
41// (such as codecs, by providing an external encoder factory), a string
42// identifier is used.
43
44enum class FecMechanism {
45 RED,
46 RED_AND_ULPFEC,
47 FLEXFEC,
48};
49
50// Used in RtcpFeedback struct.
51enum class RtcpFeedbackType {
deadbeefe702b302017-02-04 12:09:01 -080052 CCM,
53 NACK,
54 REMB, // "goog-remb"
55 TRANSPORT_CC,
56};
57
deadbeefe814a0d2017-02-25 18:15:09 -080058// Used in RtcpFeedback struct when type is NACK or CCM.
deadbeefe702b302017-02-04 12:09:01 -080059enum class RtcpFeedbackMessageType {
60 // Equivalent to {type: "nack", parameter: undefined} in ORTC.
61 GENERIC_NACK,
62 PLI, // Usable with NACK.
63 FIR, // Usable with CCM.
64};
65
66enum class DtxStatus {
67 DISABLED,
68 ENABLED,
69};
70
Taylor Brandstetter49fcc102018-05-16 14:20:41 -070071// Based on the spec in
72// https://w3c.github.io/webrtc-pc/#idl-def-rtcdegradationpreference.
73// These options are enforced on a best-effort basis. For instance, all of
74// these options may suffer some frame drops in order to avoid queuing.
75// TODO(sprang): Look into possibility of more strictly enforcing the
76// maintain-framerate option.
77// TODO(deadbeef): Default to "balanced", as the spec indicates?
deadbeefe702b302017-02-04 12:09:01 -080078enum class DegradationPreference {
Taylor Brandstetter49fcc102018-05-16 14:20:41 -070079 // Don't take any actions based on over-utilization signals. Not part of the
80 // web API.
81 DISABLED,
82 // On over-use, request lower frame rate, possibly causing frame drops.
deadbeefe702b302017-02-04 12:09:01 -080083 MAINTAIN_FRAMERATE,
Taylor Brandstetter49fcc102018-05-16 14:20:41 -070084 // On over-use, request lower resolution, possibly causing down-scaling.
deadbeefe702b302017-02-04 12:09:01 -080085 MAINTAIN_RESOLUTION,
Taylor Brandstetter49fcc102018-05-16 14:20:41 -070086 // Try to strike a "pleasing" balance between frame rate or resolution.
deadbeefe702b302017-02-04 12:09:01 -080087 BALANCED,
88};
89
Seth Hampsonf32795e2017-12-19 11:37:41 -080090extern const double kDefaultBitratePriority;
deadbeefe702b302017-02-04 12:09:01 -080091
92struct RtcpFeedback {
deadbeefe814a0d2017-02-25 18:15:09 -080093 RtcpFeedbackType type = RtcpFeedbackType::CCM;
deadbeefe702b302017-02-04 12:09:01 -080094
95 // Equivalent to ORTC "parameter" field with slight differences:
96 // 1. It's an enum instead of a string.
97 // 2. Generic NACK feedback is represented by a GENERIC_NACK message type,
98 // rather than an unset "parameter" value.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +020099 absl::optional<RtcpFeedbackMessageType> message_type;
deadbeefe702b302017-02-04 12:09:01 -0800100
deadbeefe814a0d2017-02-25 18:15:09 -0800101 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200102 RtcpFeedback();
103 explicit RtcpFeedback(RtcpFeedbackType type);
104 RtcpFeedback(RtcpFeedbackType type, RtcpFeedbackMessageType message_type);
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200105 RtcpFeedback(const RtcpFeedback&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200106 ~RtcpFeedback();
deadbeefe814a0d2017-02-25 18:15:09 -0800107
deadbeefe702b302017-02-04 12:09:01 -0800108 bool operator==(const RtcpFeedback& o) const {
109 return type == o.type && message_type == o.message_type;
110 }
111 bool operator!=(const RtcpFeedback& o) const { return !(*this == o); }
112};
113
114// RtpCodecCapability is to RtpCodecParameters as RtpCapabilities is to
115// RtpParameters. This represents the static capabilities of an endpoint's
116// implementation of a codec.
117struct RtpCodecCapability {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200118 RtpCodecCapability();
119 ~RtpCodecCapability();
120
deadbeefe702b302017-02-04 12:09:01 -0800121 // Build MIME "type/subtype" string from |name| and |kind|.
122 std::string mime_type() const { return MediaTypeToString(kind) + "/" + name; }
123
124 // Used to identify the codec. Equivalent to MIME subtype.
125 std::string name;
126
127 // The media type of this codec. Equivalent to MIME top-level type.
128 cricket::MediaType kind = cricket::MEDIA_TYPE_AUDIO;
129
130 // Clock rate in Hertz. If unset, the codec is applicable to any clock rate.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200131 absl::optional<int> clock_rate;
deadbeefe702b302017-02-04 12:09:01 -0800132
133 // Default payload type for this codec. Mainly needed for codecs that use
134 // that have statically assigned payload types.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200135 absl::optional<int> preferred_payload_type;
deadbeefe702b302017-02-04 12:09:01 -0800136
137 // Maximum packetization time supported by an RtpReceiver for this codec.
138 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200139 absl::optional<int> max_ptime;
deadbeefe702b302017-02-04 12:09:01 -0800140
141 // Preferred packetization time for an RtpReceiver or RtpSender of this
142 // codec.
143 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200144 absl::optional<int> ptime;
deadbeefe702b302017-02-04 12:09:01 -0800145
146 // The number of audio channels supported. Unused for video codecs.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200147 absl::optional<int> num_channels;
deadbeefe702b302017-02-04 12:09:01 -0800148
149 // Feedback mechanisms supported for this codec.
150 std::vector<RtcpFeedback> rtcp_feedback;
151
152 // Codec-specific parameters that must be signaled to the remote party.
deadbeefe814a0d2017-02-25 18:15:09 -0800153 //
deadbeefe702b302017-02-04 12:09:01 -0800154 // Corresponds to "a=fmtp" parameters in SDP.
deadbeefe814a0d2017-02-25 18:15:09 -0800155 //
156 // Contrary to ORTC, these parameters are named using all lowercase strings.
157 // This helps make the mapping to SDP simpler, if an application is using
158 // SDP. Boolean values are represented by the string "1".
deadbeefe702b302017-02-04 12:09:01 -0800159 std::unordered_map<std::string, std::string> parameters;
160
161 // Codec-specific parameters that may optionally be signaled to the remote
162 // party.
163 // TODO(deadbeef): Not implemented.
164 std::unordered_map<std::string, std::string> options;
165
166 // Maximum number of temporal layer extensions supported by this codec.
167 // For example, a value of 1 indicates that 2 total layers are supported.
168 // TODO(deadbeef): Not implemented.
169 int max_temporal_layer_extensions = 0;
170
171 // Maximum number of spatial layer extensions supported by this codec.
172 // For example, a value of 1 indicates that 2 total layers are supported.
173 // TODO(deadbeef): Not implemented.
174 int max_spatial_layer_extensions = 0;
175
176 // Whether the implementation can send/receive SVC layers with distinct
177 // SSRCs. Always false for audio codecs. True for video codecs that support
178 // scalable video coding with MRST.
179 // TODO(deadbeef): Not implemented.
180 bool svc_multi_stream_support = false;
181
182 bool operator==(const RtpCodecCapability& o) const {
183 return name == o.name && kind == o.kind && clock_rate == o.clock_rate &&
184 preferred_payload_type == o.preferred_payload_type &&
185 max_ptime == o.max_ptime && ptime == o.ptime &&
186 num_channels == o.num_channels && rtcp_feedback == o.rtcp_feedback &&
187 parameters == o.parameters && options == o.options &&
188 max_temporal_layer_extensions == o.max_temporal_layer_extensions &&
189 max_spatial_layer_extensions == o.max_spatial_layer_extensions &&
190 svc_multi_stream_support == o.svc_multi_stream_support;
191 }
192 bool operator!=(const RtpCodecCapability& o) const { return !(*this == o); }
193};
194
195// Used in RtpCapabilities; represents the capabilities/preferences of an
196// implementation for a header extension.
197//
198// Just called "RtpHeaderExtension" in ORTC, but the "Capability" suffix was
199// added here for consistency and to avoid confusion with
200// RtpHeaderExtensionParameters.
201//
202// Note that ORTC includes a "kind" field, but we omit this because it's
203// redundant; if you call "RtpReceiver::GetCapabilities(MEDIA_TYPE_AUDIO)",
204// you know you're getting audio capabilities.
205struct RtpHeaderExtensionCapability {
Johannes Kron07ba2b92018-09-26 13:33:35 +0200206 // URI of this extension, as defined in RFC8285.
deadbeefe702b302017-02-04 12:09:01 -0800207 std::string uri;
208
209 // Preferred value of ID that goes in the packet.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200210 absl::optional<int> preferred_id;
deadbeefe702b302017-02-04 12:09:01 -0800211
212 // If true, it's preferred that the value in the header is encrypted.
213 // TODO(deadbeef): Not implemented.
214 bool preferred_encrypt = false;
215
deadbeefe814a0d2017-02-25 18:15:09 -0800216 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200217 RtpHeaderExtensionCapability();
218 explicit RtpHeaderExtensionCapability(const std::string& uri);
219 RtpHeaderExtensionCapability(const std::string& uri, int preferred_id);
220 ~RtpHeaderExtensionCapability();
deadbeefe814a0d2017-02-25 18:15:09 -0800221
deadbeefe702b302017-02-04 12:09:01 -0800222 bool operator==(const RtpHeaderExtensionCapability& o) const {
223 return uri == o.uri && preferred_id == o.preferred_id &&
224 preferred_encrypt == o.preferred_encrypt;
225 }
226 bool operator!=(const RtpHeaderExtensionCapability& o) const {
227 return !(*this == o);
228 }
229};
230
Johannes Kron07ba2b92018-09-26 13:33:35 +0200231// RTP header extension, see RFC8285.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200232struct RtpExtension {
233 RtpExtension();
234 RtpExtension(const std::string& uri, int id);
235 RtpExtension(const std::string& uri, int id, bool encrypt);
236 ~RtpExtension();
237 std::string ToString() const;
238 bool operator==(const RtpExtension& rhs) const {
239 return uri == rhs.uri && id == rhs.id && encrypt == rhs.encrypt;
240 }
241 static bool IsSupportedForAudio(const std::string& uri);
242 static bool IsSupportedForVideo(const std::string& uri);
243 // Return "true" if the given RTP header extension URI may be encrypted.
244 static bool IsEncryptionSupported(const std::string& uri);
245
246 // Returns the named header extension if found among all extensions,
247 // nullptr otherwise.
248 static const RtpExtension* FindHeaderExtensionByUri(
249 const std::vector<RtpExtension>& extensions,
250 const std::string& uri);
251
252 // Return a list of RTP header extensions with the non-encrypted extensions
253 // removed if both the encrypted and non-encrypted extension is present for
254 // the same URI.
255 static std::vector<RtpExtension> FilterDuplicateNonEncrypted(
256 const std::vector<RtpExtension>& extensions);
257
258 // Header extension for audio levels, as defined in:
259 // http://tools.ietf.org/html/draft-ietf-avtext-client-to-mixer-audio-level-03
260 static const char kAudioLevelUri[];
261 static const int kAudioLevelDefaultId;
262
263 // Header extension for RTP timestamp offset, see RFC 5450 for details:
264 // http://tools.ietf.org/html/rfc5450
265 static const char kTimestampOffsetUri[];
266 static const int kTimestampOffsetDefaultId;
267
268 // Header extension for absolute send time, see url for details:
269 // http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
270 static const char kAbsSendTimeUri[];
271 static const int kAbsSendTimeDefaultId;
272
273 // Header extension for coordination of video orientation, see url for
274 // details:
275 // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/ts_126114v120700p.pdf
276 static const char kVideoRotationUri[];
277 static const int kVideoRotationDefaultId;
278
279 // Header extension for video content type. E.g. default or screenshare.
280 static const char kVideoContentTypeUri[];
281 static const int kVideoContentTypeDefaultId;
282
283 // Header extension for video timing.
284 static const char kVideoTimingUri[];
285 static const int kVideoTimingDefaultId;
286
Johnny Leee0c8b232018-09-11 16:50:49 -0400287 // Header extension for video frame marking.
288 static const char kFrameMarkingUri[];
289 static const int kFrameMarkingDefaultId;
290
Danil Chapovalovf3119ef2018-09-25 12:20:37 +0200291 // Experimental codec agnostic frame descriptor.
292 static const char kGenericFrameDescriptorUri[];
293 static const int kGenericFrameDescriptorDefaultId;
294
Stefan Holmer1acbd682017-09-01 15:29:28 +0200295 // Header extension for transport sequence number, see url for details:
296 // http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions
297 static const char kTransportSequenceNumberUri[];
Johannes Kron7ff164e2019-02-07 12:50:18 +0100298 static const char kTransportSequenceNumberV2Uri[];
Stefan Holmer1acbd682017-09-01 15:29:28 +0200299 static const int kTransportSequenceNumberDefaultId;
300
301 static const char kPlayoutDelayUri[];
302 static const int kPlayoutDelayDefaultId;
303
Steve Antonbb50ce52018-03-26 10:24:32 -0700304 // Header extension for identifying media section within a transport.
305 // https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-49#section-15
306 static const char kMidUri[];
307 static const int kMidDefaultId;
308
Stefan Holmer1acbd682017-09-01 15:29:28 +0200309 // Encryption of Header Extensions, see RFC 6904 for details:
310 // https://tools.ietf.org/html/rfc6904
311 static const char kEncryptHeaderExtensionsUri[];
312
Johannes Krond0b69a82018-12-03 14:18:53 +0100313 // Header extension for color space information.
314 static const char kColorSpaceUri[];
315 static const int kColorSpaceDefaultId;
316
Amit Hilbuch77938e62018-12-21 09:23:38 -0800317 // Header extension for RIDs and Repaired RIDs
318 // https://tools.ietf.org/html/draft-ietf-avtext-rid-09
319 // https://tools.ietf.org/html/draft-ietf-mmusic-rid-15
320 static const char kRidUri[];
321 static const int kRidDefaultId;
322 static const char kRepairedRidUri[];
323 static const int kRepairedRidDefaultId;
324
Johannes Kron07ba2b92018-09-26 13:33:35 +0200325 // Inclusive min and max IDs for two-byte header extensions and one-byte
326 // header extensions, per RFC8285 Section 4.2-4.3.
327 static constexpr int kMinId = 1;
328 static constexpr int kMaxId = 255;
Johannes Kron78cdde32018-10-05 10:00:46 +0200329 static constexpr int kMaxValueSize = 255;
Johannes Kron07ba2b92018-09-26 13:33:35 +0200330 static constexpr int kOneByteHeaderExtensionMaxId = 14;
Johannes Kron78cdde32018-10-05 10:00:46 +0200331 static constexpr int kOneByteHeaderExtensionMaxValueSize = 16;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200332
333 std::string uri;
334 int id = 0;
335 bool encrypt = false;
336};
337
deadbeefe814a0d2017-02-25 18:15:09 -0800338// TODO(deadbeef): This is missing the "encrypt" flag, which is unimplemented.
339typedef RtpExtension RtpHeaderExtensionParameters;
deadbeefe702b302017-02-04 12:09:01 -0800340
341struct RtpFecParameters {
342 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-25 18:15:09 -0800343 // Works just like RtpEncodingParameters::ssrc.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200344 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 12:09:01 -0800345
346 FecMechanism mechanism = FecMechanism::RED;
347
deadbeefe814a0d2017-02-25 18:15:09 -0800348 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200349 RtpFecParameters();
350 explicit RtpFecParameters(FecMechanism mechanism);
351 RtpFecParameters(FecMechanism mechanism, uint32_t ssrc);
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200352 RtpFecParameters(const RtpFecParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200353 ~RtpFecParameters();
deadbeefe814a0d2017-02-25 18:15:09 -0800354
deadbeefe702b302017-02-04 12:09:01 -0800355 bool operator==(const RtpFecParameters& o) const {
356 return ssrc == o.ssrc && mechanism == o.mechanism;
357 }
358 bool operator!=(const RtpFecParameters& o) const { return !(*this == o); }
359};
360
361struct RtpRtxParameters {
362 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-25 18:15:09 -0800363 // Works just like RtpEncodingParameters::ssrc.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200364 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 12:09:01 -0800365
deadbeefe814a0d2017-02-25 18:15:09 -0800366 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200367 RtpRtxParameters();
368 explicit RtpRtxParameters(uint32_t ssrc);
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200369 RtpRtxParameters(const RtpRtxParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200370 ~RtpRtxParameters();
deadbeefe814a0d2017-02-25 18:15:09 -0800371
deadbeefe702b302017-02-04 12:09:01 -0800372 bool operator==(const RtpRtxParameters& o) const { return ssrc == o.ssrc; }
373 bool operator!=(const RtpRtxParameters& o) const { return !(*this == o); }
374};
375
376struct RtpEncodingParameters {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200377 RtpEncodingParameters();
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200378 RtpEncodingParameters(const RtpEncodingParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200379 ~RtpEncodingParameters();
380
deadbeefe702b302017-02-04 12:09:01 -0800381 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-25 18:15:09 -0800382 //
383 // Note that the chosen value is NOT returned by GetParameters, because it
384 // may change due to an SSRC conflict, in which case the conflict is handled
385 // internally without any event. Another way of looking at this is that an
386 // unset SSRC acts as a "wildcard" SSRC.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200387 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 12:09:01 -0800388
Henrik Grunelle1301a82018-12-13 12:13:22 +0000389 // Can be used to reference a codec in the |codecs| member of the
390 // RtpParameters that contains this RtpEncodingParameters. If unset, the
391 // implementation will choose the first possible codec (if a sender), or
392 // prepare to receive any codec (for a receiver).
393 // TODO(deadbeef): Not implemented. Implementation of RtpSender will always
394 // choose the first codec from the list.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200395 absl::optional<int> codec_payload_type;
deadbeefe702b302017-02-04 12:09:01 -0800396
397 // Specifies the FEC mechanism, if set.
deadbeefe814a0d2017-02-25 18:15:09 -0800398 // TODO(deadbeef): Not implemented. Current implementation will use whatever
399 // FEC codecs are available, including red+ulpfec.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200400 absl::optional<RtpFecParameters> fec;
deadbeefe702b302017-02-04 12:09:01 -0800401
402 // Specifies the RTX parameters, if set.
deadbeefe814a0d2017-02-25 18:15:09 -0800403 // TODO(deadbeef): Not implemented with PeerConnection senders/receivers.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200404 absl::optional<RtpRtxParameters> rtx;
deadbeefe702b302017-02-04 12:09:01 -0800405
406 // Only used for audio. If set, determines whether or not discontinuous
407 // transmission will be used, if an available codec supports it. If not
408 // set, the implementation default setting will be used.
deadbeefe814a0d2017-02-25 18:15:09 -0800409 // TODO(deadbeef): Not implemented. Current implementation will use a CN
410 // codec as long as it's present.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200411 absl::optional<DtxStatus> dtx;
deadbeefe702b302017-02-04 12:09:01 -0800412
Seth Hampson24722b32017-12-22 09:36:42 -0800413 // The relative bitrate priority of this encoding. Currently this is
Seth Hampsona881ac02018-02-12 14:14:39 -0800414 // implemented for the entire rtp sender by using the value of the first
415 // encoding parameter.
416 // TODO(webrtc.bugs.org/8630): Implement this per encoding parameter.
417 // Currently there is logic for how bitrate is distributed per simulcast layer
418 // in the VideoBitrateAllocator. This must be updated to incorporate relative
419 // bitrate priority.
Seth Hampson24722b32017-12-22 09:36:42 -0800420 double bitrate_priority = kDefaultBitratePriority;
deadbeefe702b302017-02-04 12:09:01 -0800421
Tim Haloun648d28a2018-10-18 16:52:22 -0700422 // The relative DiffServ Code Point priority for this encoding, allowing
423 // packets to be marked relatively higher or lower without affecting
424 // bandwidth allocations. See https://w3c.github.io/webrtc-dscp-exp/ . NB
425 // we follow chromium's translation of the allowed string enum values for
426 // this field to 1.0, 0.5, et cetera, similar to bitrate_priority above.
427 // TODO(http://crbug.com/webrtc/8630): Implement this per encoding parameter.
428 double network_priority = kDefaultBitratePriority;
429
Seth Hampsonf209cb52018-02-06 14:28:16 -0800430 // Indicates the preferred duration of media represented by a packet in
431 // milliseconds for this encoding. If set, this will take precedence over the
432 // ptime set in the RtpCodecParameters. This could happen if SDP negotiation
433 // creates a ptime for a specific codec, which is later changed in the
434 // RtpEncodingParameters by the application.
435 // TODO(bugs.webrtc.org/8819): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200436 absl::optional<int> ptime;
Seth Hampsonf209cb52018-02-06 14:28:16 -0800437
deadbeefe702b302017-02-04 12:09:01 -0800438 // If set, this represents the Transport Independent Application Specific
439 // maximum bandwidth defined in RFC3890. If unset, there is no maximum
Seth Hampsona881ac02018-02-12 14:14:39 -0800440 // bitrate. Currently this is implemented for the entire rtp sender by using
441 // the value of the first encoding parameter.
442 //
deadbeefe702b302017-02-04 12:09:01 -0800443 // Just called "maxBitrate" in ORTC spec.
deadbeefe814a0d2017-02-25 18:15:09 -0800444 //
445 // TODO(deadbeef): With ORTC RtpSenders, this currently sets the total
446 // bandwidth for the entire bandwidth estimator (audio and video). This is
447 // just always how "b=AS" was handled, but it's not correct and should be
448 // fixed.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200449 absl::optional<int> max_bitrate_bps;
deadbeefe702b302017-02-04 12:09:01 -0800450
Ã…sa Persson55659812018-06-18 17:51:32 +0200451 // Specifies the minimum bitrate in bps for video.
452 // TODO(asapersson): Not implemented for ORTC API.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200453 absl::optional<int> min_bitrate_bps;
Ã…sa Persson613591a2018-05-29 09:21:31 +0200454
Ã…sa Persson8c1bf952018-09-13 10:42:19 +0200455 // Specifies the maximum framerate in fps for video.
Ã…sa Persson23eba222018-10-02 14:47:06 +0200456 // TODO(asapersson): Different framerates are not supported per simulcast
457 // layer. If set, the maximum |max_framerate| is currently used.
Ã…sa Persson8c1bf952018-09-13 10:42:19 +0200458 // Not supported for screencast.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200459 absl::optional<int> max_framerate;
deadbeefe702b302017-02-04 12:09:01 -0800460
Ã…sa Persson23eba222018-10-02 14:47:06 +0200461 // Specifies the number of temporal layers for video (if the feature is
462 // supported by the codec implementation).
463 // TODO(asapersson): Different number of temporal layers are not supported
464 // per simulcast layer.
Ilya Nikolaevskiy9f6a0d52019-02-05 10:29:41 +0100465 // Screencast support is experimental.
Ã…sa Persson23eba222018-10-02 14:47:06 +0200466 absl::optional<int> num_temporal_layers;
467
deadbeefe702b302017-02-04 12:09:01 -0800468 // For video, scale the resolution down by this factor.
469 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200470 absl::optional<double> scale_resolution_down_by;
deadbeefe702b302017-02-04 12:09:01 -0800471
472 // Scale the framerate down by this factor.
473 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200474 absl::optional<double> scale_framerate_down_by;
deadbeefe702b302017-02-04 12:09:01 -0800475
Seth Hampsona881ac02018-02-12 14:14:39 -0800476 // For an RtpSender, set to true to cause this encoding to be encoded and
477 // sent, and false for it not to be encoded and sent. This allows control
478 // across multiple encodings of a sender for turning simulcast layers on and
479 // off.
480 // TODO(webrtc.bugs.org/8807): Updating this parameter will trigger an encoder
481 // reset, but this isn't necessarily required.
deadbeefdbe2b872016-03-22 15:42:00 -0700482 bool active = true;
deadbeefe702b302017-02-04 12:09:01 -0800483
484 // Value to use for RID RTP header extension.
485 // Called "encodingId" in ORTC.
486 // TODO(deadbeef): Not implemented.
487 std::string rid;
488
489 // RIDs of encodings on which this layer depends.
490 // Called "dependencyEncodingIds" in ORTC spec.
491 // TODO(deadbeef): Not implemented.
492 std::vector<std::string> dependency_rids;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700493
494 bool operator==(const RtpEncodingParameters& o) const {
deadbeefe702b302017-02-04 12:09:01 -0800495 return ssrc == o.ssrc && codec_payload_type == o.codec_payload_type &&
496 fec == o.fec && rtx == o.rtx && dtx == o.dtx &&
Tim Haloun648d28a2018-10-18 16:52:22 -0700497 bitrate_priority == o.bitrate_priority &&
498 network_priority == o.network_priority && ptime == o.ptime &&
Seth Hampson24722b32017-12-22 09:36:42 -0800499 max_bitrate_bps == o.max_bitrate_bps &&
Ã…sa Persson8c1bf952018-09-13 10:42:19 +0200500 min_bitrate_bps == o.min_bitrate_bps &&
deadbeefe702b302017-02-04 12:09:01 -0800501 max_framerate == o.max_framerate &&
Ã…sa Persson23eba222018-10-02 14:47:06 +0200502 num_temporal_layers == o.num_temporal_layers &&
deadbeefe702b302017-02-04 12:09:01 -0800503 scale_resolution_down_by == o.scale_resolution_down_by &&
504 scale_framerate_down_by == o.scale_framerate_down_by &&
505 active == o.active && rid == o.rid &&
506 dependency_rids == o.dependency_rids;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700507 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700508 bool operator!=(const RtpEncodingParameters& o) const {
509 return !(*this == o);
510 }
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700511};
512
513struct RtpCodecParameters {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200514 RtpCodecParameters();
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200515 RtpCodecParameters(const RtpCodecParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200516 ~RtpCodecParameters();
517
deadbeefe702b302017-02-04 12:09:01 -0800518 // Build MIME "type/subtype" string from |name| and |kind|.
519 std::string mime_type() const { return MediaTypeToString(kind) + "/" + name; }
520
521 // Used to identify the codec. Equivalent to MIME subtype.
522 std::string name;
523
524 // The media type of this codec. Equivalent to MIME top-level type.
525 cricket::MediaType kind = cricket::MEDIA_TYPE_AUDIO;
526
527 // Payload type used to identify this codec in RTP packets.
deadbeefe814a0d2017-02-25 18:15:09 -0800528 // This must always be present, and must be unique across all codecs using
deadbeefe702b302017-02-04 12:09:01 -0800529 // the same transport.
530 int payload_type = 0;
531
532 // If unset, the implementation default is used.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200533 absl::optional<int> clock_rate;
deadbeefe702b302017-02-04 12:09:01 -0800534
535 // The number of audio channels used. Unset for video codecs. If unset for
536 // audio, the implementation default is used.
deadbeefe814a0d2017-02-25 18:15:09 -0800537 // TODO(deadbeef): The "implementation default" part isn't fully implemented.
538 // Only defaults to 1, even though some codecs (such as opus) should really
539 // default to 2.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200540 absl::optional<int> num_channels;
deadbeefe702b302017-02-04 12:09:01 -0800541
542 // The maximum packetization time to be used by an RtpSender.
543 // If |ptime| is also set, this will be ignored.
544 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200545 absl::optional<int> max_ptime;
deadbeefe702b302017-02-04 12:09:01 -0800546
547 // The packetization time to be used by an RtpSender.
548 // If unset, will use any time up to max_ptime.
549 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200550 absl::optional<int> ptime;
deadbeefe702b302017-02-04 12:09:01 -0800551
552 // Feedback mechanisms to be used for this codec.
deadbeefe814a0d2017-02-25 18:15:09 -0800553 // TODO(deadbeef): Not implemented with PeerConnection senders/receivers.
deadbeefe702b302017-02-04 12:09:01 -0800554 std::vector<RtcpFeedback> rtcp_feedback;
555
556 // Codec-specific parameters that must be signaled to the remote party.
deadbeefe814a0d2017-02-25 18:15:09 -0800557 //
deadbeefe702b302017-02-04 12:09:01 -0800558 // Corresponds to "a=fmtp" parameters in SDP.
deadbeefe814a0d2017-02-25 18:15:09 -0800559 //
560 // Contrary to ORTC, these parameters are named using all lowercase strings.
561 // This helps make the mapping to SDP simpler, if an application is using
562 // SDP. Boolean values are represented by the string "1".
deadbeefe702b302017-02-04 12:09:01 -0800563 std::unordered_map<std::string, std::string> parameters;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700564
565 bool operator==(const RtpCodecParameters& o) const {
deadbeefe702b302017-02-04 12:09:01 -0800566 return name == o.name && kind == o.kind && payload_type == o.payload_type &&
567 clock_rate == o.clock_rate && num_channels == o.num_channels &&
568 max_ptime == o.max_ptime && ptime == o.ptime &&
569 rtcp_feedback == o.rtcp_feedback && parameters == o.parameters;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700570 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700571 bool operator!=(const RtpCodecParameters& o) const { return !(*this == o); }
skvladdc1c62c2016-03-16 19:07:43 -0700572};
573
deadbeefe702b302017-02-04 12:09:01 -0800574// RtpCapabilities is used to represent the static capabilities of an
575// endpoint. An application can use these capabilities to construct an
576// RtpParameters.
577struct RtpCapabilities {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200578 RtpCapabilities();
579 ~RtpCapabilities();
580
deadbeefe702b302017-02-04 12:09:01 -0800581 // Supported codecs.
582 std::vector<RtpCodecCapability> codecs;
583
584 // Supported RTP header extensions.
585 std::vector<RtpHeaderExtensionCapability> header_extensions;
586
deadbeefe814a0d2017-02-25 18:15:09 -0800587 // Supported Forward Error Correction (FEC) mechanisms. Note that the RED,
588 // ulpfec and flexfec codecs used by these mechanisms will still appear in
589 // |codecs|.
deadbeefe702b302017-02-04 12:09:01 -0800590 std::vector<FecMechanism> fec;
591
592 bool operator==(const RtpCapabilities& o) const {
593 return codecs == o.codecs && header_extensions == o.header_extensions &&
594 fec == o.fec;
595 }
596 bool operator!=(const RtpCapabilities& o) const { return !(*this == o); }
597};
598
Florent Castellidacec712018-05-24 16:24:21 +0200599struct RtcpParameters final {
600 RtcpParameters();
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200601 RtcpParameters(const RtcpParameters&);
Florent Castellidacec712018-05-24 16:24:21 +0200602 ~RtcpParameters();
603
604 // The SSRC to be used in the "SSRC of packet sender" field. If not set, one
605 // will be chosen by the implementation.
606 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200607 absl::optional<uint32_t> ssrc;
Florent Castellidacec712018-05-24 16:24:21 +0200608
609 // The Canonical Name (CNAME) used by RTCP (e.g. in SDES messages).
610 //
611 // If empty in the construction of the RtpTransport, one will be generated by
612 // the implementation, and returned in GetRtcpParameters. Multiple
613 // RtpTransports created by the same OrtcFactory will use the same generated
614 // CNAME.
615 //
616 // If empty when passed into SetParameters, the CNAME simply won't be
617 // modified.
618 std::string cname;
619
620 // Send reduced-size RTCP?
621 bool reduced_size = false;
622
623 // Send RTCP multiplexed on the RTP transport?
624 // Not used with PeerConnection senders/receivers
625 bool mux = true;
626
627 bool operator==(const RtcpParameters& o) const {
628 return ssrc == o.ssrc && cname == o.cname &&
629 reduced_size == o.reduced_size && mux == o.mux;
630 }
631 bool operator!=(const RtcpParameters& o) const { return !(*this == o); }
632};
633
Mirko Bonadeiac194142018-10-22 17:08:37 +0200634struct RTC_EXPORT RtpParameters {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200635 RtpParameters();
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200636 RtpParameters(const RtpParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200637 ~RtpParameters();
638
deadbeefe702b302017-02-04 12:09:01 -0800639 // Used when calling getParameters/setParameters with a PeerConnection
640 // RtpSender, to ensure that outdated parameters are not unintentionally
641 // applied successfully.
deadbeefe702b302017-02-04 12:09:01 -0800642 std::string transaction_id;
643
644 // Value to use for MID RTP header extension.
645 // Called "muxId" in ORTC.
646 // TODO(deadbeef): Not implemented.
647 std::string mid;
648
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700649 std::vector<RtpCodecParameters> codecs;
650
deadbeefe702b302017-02-04 12:09:01 -0800651 std::vector<RtpHeaderExtensionParameters> header_extensions;
652
653 std::vector<RtpEncodingParameters> encodings;
654
Florent Castellidacec712018-05-24 16:24:21 +0200655 // Only available with a Peerconnection RtpSender.
656 // In ORTC, our API includes an additional "RtpTransport"
657 // abstraction on which RTCP parameters are set.
658 RtcpParameters rtcp;
659
Florent Castelli87b3c512018-07-18 16:00:28 +0200660 // When bandwidth is constrained and the RtpSender needs to choose between
661 // degrading resolution or degrading framerate, degradationPreference
662 // indicates which is preferred. Only for video tracks.
deadbeefe702b302017-02-04 12:09:01 -0800663 DegradationPreference degradation_preference =
664 DegradationPreference::BALANCED;
665
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700666 bool operator==(const RtpParameters& o) const {
deadbeefe702b302017-02-04 12:09:01 -0800667 return mid == o.mid && codecs == o.codecs &&
668 header_extensions == o.header_extensions &&
Florent Castellidacec712018-05-24 16:24:21 +0200669 encodings == o.encodings && rtcp == o.rtcp &&
deadbeefe702b302017-02-04 12:09:01 -0800670 degradation_preference == o.degradation_preference;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700671 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700672 bool operator!=(const RtpParameters& o) const { return !(*this == o); }
skvladdc1c62c2016-03-16 19:07:43 -0700673};
674
675} // namespace webrtc
676
Steve Anton10542f22019-01-11 09:11:00 -0800677#endif // API_RTP_PARAMETERS_H_