blob: badda074599a93bb5da325bbefdd783b07ff1b18 [file] [log] [blame]
skvladdc1c62c2016-03-17 02:07:431/*
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
Mirko Bonadei92ea95e2017-09-15 04:47:3111#ifndef API_RTPPARAMETERS_H_
12#define API_RTPPARAMETERS_H_
skvladdc1c62c2016-03-17 02:07:4313
Yves Gerey988cc082018-10-23 10:03:0114#include <stdint.h>
Taylor Brandstetter0cd086b2016-04-20 23:23:1015#include <string>
deadbeefe702b302017-02-04 20:09:0116#include <unordered_map>
skvladdc1c62c2016-03-17 02:07:4317#include <vector>
18
Danil Chapovalov0bc58cf2018-06-21 11:32:5619#include "absl/types/optional.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3120#include "api/mediatypes.h"
Mirko Bonadeiac194142018-10-22 15:08:3721#include "rtc_base/system/rtc_export.h"
sakal1fd95952016-06-22 07:46:1522
skvladdc1c62c2016-03-17 02:07:4323namespace webrtc {
24
deadbeefe702b302017-02-04 20:09:0125// 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 20:09:0152 CCM,
53 NACK,
54 REMB, // "goog-remb"
55 TRANSPORT_CC,
56};
57
deadbeefe814a0d2017-02-26 02:15:0958// Used in RtcpFeedback struct when type is NACK or CCM.
deadbeefe702b302017-02-04 20:09:0159enum 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 21:20:4171// 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 20:09:0178enum class DegradationPreference {
Taylor Brandstetter49fcc102018-05-16 21:20:4179 // 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 20:09:0183 MAINTAIN_FRAMERATE,
Taylor Brandstetter49fcc102018-05-16 21:20:4184 // On over-use, request lower resolution, possibly causing down-scaling.
deadbeefe702b302017-02-04 20:09:0185 MAINTAIN_RESOLUTION,
Taylor Brandstetter49fcc102018-05-16 21:20:4186 // Try to strike a "pleasing" balance between frame rate or resolution.
deadbeefe702b302017-02-04 20:09:0187 BALANCED,
88};
89
Seth Hampsonf32795e2017-12-19 19:37:4190extern const double kDefaultBitratePriority;
deadbeefe702b302017-02-04 20:09:0191
92struct RtcpFeedback {
deadbeefe814a0d2017-02-26 02:15:0993 RtcpFeedbackType type = RtcpFeedbackType::CCM;
deadbeefe702b302017-02-04 20:09:0194
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 11:32:5699 absl::optional<RtcpFeedbackMessageType> message_type;
deadbeefe702b302017-02-04 20:09:01100
deadbeefe814a0d2017-02-26 02:15:09101 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 13:29:28102 RtcpFeedback();
103 explicit RtcpFeedback(RtcpFeedbackType type);
104 RtcpFeedback(RtcpFeedbackType type, RtcpFeedbackMessageType message_type);
Mirko Bonadei2ffed6d2018-07-20 09:09:32105 RtcpFeedback(const RtcpFeedback&);
Stefan Holmer1acbd682017-09-01 13:29:28106 ~RtcpFeedback();
deadbeefe814a0d2017-02-26 02:15:09107
deadbeefe702b302017-02-04 20:09:01108 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 13:29:28118 RtpCodecCapability();
119 ~RtpCodecCapability();
120
deadbeefe702b302017-02-04 20:09:01121 // 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 11:32:56131 absl::optional<int> clock_rate;
deadbeefe702b302017-02-04 20:09:01132
133 // Default payload type for this codec. Mainly needed for codecs that use
134 // that have statically assigned payload types.
Danil Chapovalov0bc58cf2018-06-21 11:32:56135 absl::optional<int> preferred_payload_type;
deadbeefe702b302017-02-04 20:09:01136
137 // Maximum packetization time supported by an RtpReceiver for this codec.
138 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 11:32:56139 absl::optional<int> max_ptime;
deadbeefe702b302017-02-04 20:09:01140
141 // Preferred packetization time for an RtpReceiver or RtpSender of this
142 // codec.
143 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 11:32:56144 absl::optional<int> ptime;
deadbeefe702b302017-02-04 20:09:01145
146 // The number of audio channels supported. Unused for video codecs.
Danil Chapovalov0bc58cf2018-06-21 11:32:56147 absl::optional<int> num_channels;
deadbeefe702b302017-02-04 20:09:01148
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-26 02:15:09153 //
deadbeefe702b302017-02-04 20:09:01154 // Corresponds to "a=fmtp" parameters in SDP.
deadbeefe814a0d2017-02-26 02:15:09155 //
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 20:09:01159 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 11:33:35206 // URI of this extension, as defined in RFC8285.
deadbeefe702b302017-02-04 20:09:01207 std::string uri;
208
209 // Preferred value of ID that goes in the packet.
Danil Chapovalov0bc58cf2018-06-21 11:32:56210 absl::optional<int> preferred_id;
deadbeefe702b302017-02-04 20:09:01211
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-26 02:15:09216 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 13:29:28217 RtpHeaderExtensionCapability();
218 explicit RtpHeaderExtensionCapability(const std::string& uri);
219 RtpHeaderExtensionCapability(const std::string& uri, int preferred_id);
220 ~RtpHeaderExtensionCapability();
deadbeefe814a0d2017-02-26 02:15:09221
deadbeefe702b302017-02-04 20:09:01222 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 11:33:35231// RTP header extension, see RFC8285.
Stefan Holmer1acbd682017-09-01 13:29:28232struct 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 20:50:49287 // Header extension for video frame marking.
288 static const char kFrameMarkingUri[];
289 static const int kFrameMarkingDefaultId;
290
Danil Chapovalovf3119ef2018-09-25 10:20:37291 // Experimental codec agnostic frame descriptor.
292 static const char kGenericFrameDescriptorUri[];
293 static const int kGenericFrameDescriptorDefaultId;
294
Stefan Holmer1acbd682017-09-01 13:29:28295 // 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[];
298 static const int kTransportSequenceNumberDefaultId;
299
300 static const char kPlayoutDelayUri[];
301 static const int kPlayoutDelayDefaultId;
302
Steve Antonbb50ce52018-03-26 17:24:32303 // Header extension for identifying media section within a transport.
304 // https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-49#section-15
305 static const char kMidUri[];
306 static const int kMidDefaultId;
307
Stefan Holmer1acbd682017-09-01 13:29:28308 // Encryption of Header Extensions, see RFC 6904 for details:
309 // https://tools.ietf.org/html/rfc6904
310 static const char kEncryptHeaderExtensionsUri[];
311
Johannes Kron07ba2b92018-09-26 11:33:35312 // Inclusive min and max IDs for two-byte header extensions and one-byte
313 // header extensions, per RFC8285 Section 4.2-4.3.
314 static constexpr int kMinId = 1;
315 static constexpr int kMaxId = 255;
Johannes Kron78cdde32018-10-05 08:00:46316 static constexpr int kMaxValueSize = 255;
Johannes Kron07ba2b92018-09-26 11:33:35317 static constexpr int kOneByteHeaderExtensionMaxId = 14;
Johannes Kron78cdde32018-10-05 08:00:46318 static constexpr int kOneByteHeaderExtensionMaxValueSize = 16;
Stefan Holmer1acbd682017-09-01 13:29:28319
320 std::string uri;
321 int id = 0;
322 bool encrypt = false;
323};
324
deadbeefe814a0d2017-02-26 02:15:09325// TODO(deadbeef): This is missing the "encrypt" flag, which is unimplemented.
326typedef RtpExtension RtpHeaderExtensionParameters;
deadbeefe702b302017-02-04 20:09:01327
328struct RtpFecParameters {
329 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-26 02:15:09330 // Works just like RtpEncodingParameters::ssrc.
Danil Chapovalov0bc58cf2018-06-21 11:32:56331 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 20:09:01332
333 FecMechanism mechanism = FecMechanism::RED;
334
deadbeefe814a0d2017-02-26 02:15:09335 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 13:29:28336 RtpFecParameters();
337 explicit RtpFecParameters(FecMechanism mechanism);
338 RtpFecParameters(FecMechanism mechanism, uint32_t ssrc);
Mirko Bonadei2ffed6d2018-07-20 09:09:32339 RtpFecParameters(const RtpFecParameters&);
Stefan Holmer1acbd682017-09-01 13:29:28340 ~RtpFecParameters();
deadbeefe814a0d2017-02-26 02:15:09341
deadbeefe702b302017-02-04 20:09:01342 bool operator==(const RtpFecParameters& o) const {
343 return ssrc == o.ssrc && mechanism == o.mechanism;
344 }
345 bool operator!=(const RtpFecParameters& o) const { return !(*this == o); }
346};
347
348struct RtpRtxParameters {
349 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-26 02:15:09350 // Works just like RtpEncodingParameters::ssrc.
Danil Chapovalov0bc58cf2018-06-21 11:32:56351 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 20:09:01352
deadbeefe814a0d2017-02-26 02:15:09353 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 13:29:28354 RtpRtxParameters();
355 explicit RtpRtxParameters(uint32_t ssrc);
Mirko Bonadei2ffed6d2018-07-20 09:09:32356 RtpRtxParameters(const RtpRtxParameters&);
Stefan Holmer1acbd682017-09-01 13:29:28357 ~RtpRtxParameters();
deadbeefe814a0d2017-02-26 02:15:09358
deadbeefe702b302017-02-04 20:09:01359 bool operator==(const RtpRtxParameters& o) const { return ssrc == o.ssrc; }
360 bool operator!=(const RtpRtxParameters& o) const { return !(*this == o); }
361};
362
363struct RtpEncodingParameters {
Stefan Holmer1acbd682017-09-01 13:29:28364 RtpEncodingParameters();
Mirko Bonadei2ffed6d2018-07-20 09:09:32365 RtpEncodingParameters(const RtpEncodingParameters&);
Stefan Holmer1acbd682017-09-01 13:29:28366 ~RtpEncodingParameters();
367
deadbeefe702b302017-02-04 20:09:01368 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-26 02:15:09369 //
370 // Note that the chosen value is NOT returned by GetParameters, because it
371 // may change due to an SSRC conflict, in which case the conflict is handled
372 // internally without any event. Another way of looking at this is that an
373 // unset SSRC acts as a "wildcard" SSRC.
Danil Chapovalov0bc58cf2018-06-21 11:32:56374 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 20:09:01375
376 // Can be used to reference a codec in the |codecs| member of the
377 // RtpParameters that contains this RtpEncodingParameters. If unset, the
deadbeefe814a0d2017-02-26 02:15:09378 // implementation will choose the first possible codec (if a sender), or
379 // prepare to receive any codec (for a receiver).
380 // TODO(deadbeef): Not implemented. Implementation of RtpSender will always
381 // choose the first codec from the list.
Danil Chapovalov0bc58cf2018-06-21 11:32:56382 absl::optional<int> codec_payload_type;
deadbeefe702b302017-02-04 20:09:01383
384 // Specifies the FEC mechanism, if set.
deadbeefe814a0d2017-02-26 02:15:09385 // TODO(deadbeef): Not implemented. Current implementation will use whatever
386 // FEC codecs are available, including red+ulpfec.
Danil Chapovalov0bc58cf2018-06-21 11:32:56387 absl::optional<RtpFecParameters> fec;
deadbeefe702b302017-02-04 20:09:01388
389 // Specifies the RTX parameters, if set.
deadbeefe814a0d2017-02-26 02:15:09390 // TODO(deadbeef): Not implemented with PeerConnection senders/receivers.
Danil Chapovalov0bc58cf2018-06-21 11:32:56391 absl::optional<RtpRtxParameters> rtx;
deadbeefe702b302017-02-04 20:09:01392
393 // Only used for audio. If set, determines whether or not discontinuous
394 // transmission will be used, if an available codec supports it. If not
395 // set, the implementation default setting will be used.
deadbeefe814a0d2017-02-26 02:15:09396 // TODO(deadbeef): Not implemented. Current implementation will use a CN
397 // codec as long as it's present.
Danil Chapovalov0bc58cf2018-06-21 11:32:56398 absl::optional<DtxStatus> dtx;
deadbeefe702b302017-02-04 20:09:01399
Seth Hampson24722b32017-12-22 17:36:42400 // The relative bitrate priority of this encoding. Currently this is
Seth Hampsona881ac02018-02-12 22:14:39401 // implemented for the entire rtp sender by using the value of the first
402 // encoding parameter.
403 // TODO(webrtc.bugs.org/8630): Implement this per encoding parameter.
404 // Currently there is logic for how bitrate is distributed per simulcast layer
405 // in the VideoBitrateAllocator. This must be updated to incorporate relative
406 // bitrate priority.
Seth Hampson24722b32017-12-22 17:36:42407 double bitrate_priority = kDefaultBitratePriority;
deadbeefe702b302017-02-04 20:09:01408
Tim Haloun648d28a2018-10-18 23:52:22409 // The relative DiffServ Code Point priority for this encoding, allowing
410 // packets to be marked relatively higher or lower without affecting
411 // bandwidth allocations. See https://w3c.github.io/webrtc-dscp-exp/ . NB
412 // we follow chromium's translation of the allowed string enum values for
413 // this field to 1.0, 0.5, et cetera, similar to bitrate_priority above.
414 // TODO(http://crbug.com/webrtc/8630): Implement this per encoding parameter.
415 double network_priority = kDefaultBitratePriority;
416
Seth Hampsonf209cb52018-02-06 22:28:16417 // Indicates the preferred duration of media represented by a packet in
418 // milliseconds for this encoding. If set, this will take precedence over the
419 // ptime set in the RtpCodecParameters. This could happen if SDP negotiation
420 // creates a ptime for a specific codec, which is later changed in the
421 // RtpEncodingParameters by the application.
422 // TODO(bugs.webrtc.org/8819): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 11:32:56423 absl::optional<int> ptime;
Seth Hampsonf209cb52018-02-06 22:28:16424
deadbeefe702b302017-02-04 20:09:01425 // If set, this represents the Transport Independent Application Specific
426 // maximum bandwidth defined in RFC3890. If unset, there is no maximum
Seth Hampsona881ac02018-02-12 22:14:39427 // bitrate. Currently this is implemented for the entire rtp sender by using
428 // the value of the first encoding parameter.
429 //
deadbeefe702b302017-02-04 20:09:01430 // Just called "maxBitrate" in ORTC spec.
deadbeefe814a0d2017-02-26 02:15:09431 //
432 // TODO(deadbeef): With ORTC RtpSenders, this currently sets the total
433 // bandwidth for the entire bandwidth estimator (audio and video). This is
434 // just always how "b=AS" was handled, but it's not correct and should be
435 // fixed.
Danil Chapovalov0bc58cf2018-06-21 11:32:56436 absl::optional<int> max_bitrate_bps;
deadbeefe702b302017-02-04 20:09:01437
Ã…sa Persson55659812018-06-18 15:51:32438 // Specifies the minimum bitrate in bps for video.
439 // TODO(asapersson): Not implemented for ORTC API.
Danil Chapovalov0bc58cf2018-06-21 11:32:56440 absl::optional<int> min_bitrate_bps;
Ã…sa Persson613591a2018-05-29 07:21:31441
Ã…sa Persson8c1bf952018-09-13 08:42:19442 // Specifies the maximum framerate in fps for video.
Ã…sa Persson23eba222018-10-02 12:47:06443 // TODO(asapersson): Different framerates are not supported per simulcast
444 // layer. If set, the maximum |max_framerate| is currently used.
Ã…sa Persson8c1bf952018-09-13 08:42:19445 // Not supported for screencast.
Danil Chapovalov0bc58cf2018-06-21 11:32:56446 absl::optional<int> max_framerate;
deadbeefe702b302017-02-04 20:09:01447
Ã…sa Persson23eba222018-10-02 12:47:06448 // Specifies the number of temporal layers for video (if the feature is
449 // supported by the codec implementation).
450 // TODO(asapersson): Different number of temporal layers are not supported
451 // per simulcast layer.
452 // Not supported for screencast.
453 absl::optional<int> num_temporal_layers;
454
deadbeefe702b302017-02-04 20:09:01455 // For video, scale the resolution down by this factor.
456 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 11:32:56457 absl::optional<double> scale_resolution_down_by;
deadbeefe702b302017-02-04 20:09:01458
459 // Scale the framerate down by this factor.
460 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 11:32:56461 absl::optional<double> scale_framerate_down_by;
deadbeefe702b302017-02-04 20:09:01462
Seth Hampsona881ac02018-02-12 22:14:39463 // For an RtpSender, set to true to cause this encoding to be encoded and
464 // sent, and false for it not to be encoded and sent. This allows control
465 // across multiple encodings of a sender for turning simulcast layers on and
466 // off.
467 // TODO(webrtc.bugs.org/8807): Updating this parameter will trigger an encoder
468 // reset, but this isn't necessarily required.
deadbeefdbe2b872016-03-22 22:42:00469 bool active = true;
deadbeefe702b302017-02-04 20:09:01470
471 // Value to use for RID RTP header extension.
472 // Called "encodingId" in ORTC.
473 // TODO(deadbeef): Not implemented.
474 std::string rid;
475
476 // RIDs of encodings on which this layer depends.
477 // Called "dependencyEncodingIds" in ORTC spec.
478 // TODO(deadbeef): Not implemented.
479 std::vector<std::string> dependency_rids;
Taylor Brandstetter0cd086b2016-04-20 23:23:10480
481 bool operator==(const RtpEncodingParameters& o) const {
deadbeefe702b302017-02-04 20:09:01482 return ssrc == o.ssrc && codec_payload_type == o.codec_payload_type &&
483 fec == o.fec && rtx == o.rtx && dtx == o.dtx &&
Tim Haloun648d28a2018-10-18 23:52:22484 bitrate_priority == o.bitrate_priority &&
485 network_priority == o.network_priority && ptime == o.ptime &&
Seth Hampson24722b32017-12-22 17:36:42486 max_bitrate_bps == o.max_bitrate_bps &&
Ã…sa Persson8c1bf952018-09-13 08:42:19487 min_bitrate_bps == o.min_bitrate_bps &&
deadbeefe702b302017-02-04 20:09:01488 max_framerate == o.max_framerate &&
Ã…sa Persson23eba222018-10-02 12:47:06489 num_temporal_layers == o.num_temporal_layers &&
deadbeefe702b302017-02-04 20:09:01490 scale_resolution_down_by == o.scale_resolution_down_by &&
491 scale_framerate_down_by == o.scale_framerate_down_by &&
492 active == o.active && rid == o.rid &&
493 dependency_rids == o.dependency_rids;
Taylor Brandstetter0cd086b2016-04-20 23:23:10494 }
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30495 bool operator!=(const RtpEncodingParameters& o) const {
496 return !(*this == o);
497 }
Taylor Brandstetter0cd086b2016-04-20 23:23:10498};
499
500struct RtpCodecParameters {
Stefan Holmer1acbd682017-09-01 13:29:28501 RtpCodecParameters();
Mirko Bonadei2ffed6d2018-07-20 09:09:32502 RtpCodecParameters(const RtpCodecParameters&);
Stefan Holmer1acbd682017-09-01 13:29:28503 ~RtpCodecParameters();
504
deadbeefe702b302017-02-04 20:09:01505 // Build MIME "type/subtype" string from |name| and |kind|.
506 std::string mime_type() const { return MediaTypeToString(kind) + "/" + name; }
507
508 // Used to identify the codec. Equivalent to MIME subtype.
509 std::string name;
510
511 // The media type of this codec. Equivalent to MIME top-level type.
512 cricket::MediaType kind = cricket::MEDIA_TYPE_AUDIO;
513
514 // Payload type used to identify this codec in RTP packets.
deadbeefe814a0d2017-02-26 02:15:09515 // This must always be present, and must be unique across all codecs using
deadbeefe702b302017-02-04 20:09:01516 // the same transport.
517 int payload_type = 0;
518
519 // If unset, the implementation default is used.
Danil Chapovalov0bc58cf2018-06-21 11:32:56520 absl::optional<int> clock_rate;
deadbeefe702b302017-02-04 20:09:01521
522 // The number of audio channels used. Unset for video codecs. If unset for
523 // audio, the implementation default is used.
deadbeefe814a0d2017-02-26 02:15:09524 // TODO(deadbeef): The "implementation default" part isn't fully implemented.
525 // Only defaults to 1, even though some codecs (such as opus) should really
526 // default to 2.
Danil Chapovalov0bc58cf2018-06-21 11:32:56527 absl::optional<int> num_channels;
deadbeefe702b302017-02-04 20:09:01528
529 // The maximum packetization time to be used by an RtpSender.
530 // If |ptime| is also set, this will be ignored.
531 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 11:32:56532 absl::optional<int> max_ptime;
deadbeefe702b302017-02-04 20:09:01533
534 // The packetization time to be used by an RtpSender.
535 // If unset, will use any time up to max_ptime.
536 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 11:32:56537 absl::optional<int> ptime;
deadbeefe702b302017-02-04 20:09:01538
539 // Feedback mechanisms to be used for this codec.
deadbeefe814a0d2017-02-26 02:15:09540 // TODO(deadbeef): Not implemented with PeerConnection senders/receivers.
deadbeefe702b302017-02-04 20:09:01541 std::vector<RtcpFeedback> rtcp_feedback;
542
543 // Codec-specific parameters that must be signaled to the remote party.
deadbeefe814a0d2017-02-26 02:15:09544 //
deadbeefe702b302017-02-04 20:09:01545 // Corresponds to "a=fmtp" parameters in SDP.
deadbeefe814a0d2017-02-26 02:15:09546 //
547 // Contrary to ORTC, these parameters are named using all lowercase strings.
548 // This helps make the mapping to SDP simpler, if an application is using
549 // SDP. Boolean values are represented by the string "1".
deadbeefe702b302017-02-04 20:09:01550 std::unordered_map<std::string, std::string> parameters;
Taylor Brandstetter0cd086b2016-04-20 23:23:10551
552 bool operator==(const RtpCodecParameters& o) const {
deadbeefe702b302017-02-04 20:09:01553 return name == o.name && kind == o.kind && payload_type == o.payload_type &&
554 clock_rate == o.clock_rate && num_channels == o.num_channels &&
555 max_ptime == o.max_ptime && ptime == o.ptime &&
556 rtcp_feedback == o.rtcp_feedback && parameters == o.parameters;
Taylor Brandstetter0cd086b2016-04-20 23:23:10557 }
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30558 bool operator!=(const RtpCodecParameters& o) const { return !(*this == o); }
skvladdc1c62c2016-03-17 02:07:43559};
560
deadbeefe702b302017-02-04 20:09:01561// RtpCapabilities is used to represent the static capabilities of an
562// endpoint. An application can use these capabilities to construct an
563// RtpParameters.
564struct RtpCapabilities {
Stefan Holmer1acbd682017-09-01 13:29:28565 RtpCapabilities();
566 ~RtpCapabilities();
567
deadbeefe702b302017-02-04 20:09:01568 // Supported codecs.
569 std::vector<RtpCodecCapability> codecs;
570
571 // Supported RTP header extensions.
572 std::vector<RtpHeaderExtensionCapability> header_extensions;
573
deadbeefe814a0d2017-02-26 02:15:09574 // Supported Forward Error Correction (FEC) mechanisms. Note that the RED,
575 // ulpfec and flexfec codecs used by these mechanisms will still appear in
576 // |codecs|.
deadbeefe702b302017-02-04 20:09:01577 std::vector<FecMechanism> fec;
578
579 bool operator==(const RtpCapabilities& o) const {
580 return codecs == o.codecs && header_extensions == o.header_extensions &&
581 fec == o.fec;
582 }
583 bool operator!=(const RtpCapabilities& o) const { return !(*this == o); }
584};
585
Florent Castellidacec712018-05-24 14:24:21586struct RtcpParameters final {
587 RtcpParameters();
Mirko Bonadei2ffed6d2018-07-20 09:09:32588 RtcpParameters(const RtcpParameters&);
Florent Castellidacec712018-05-24 14:24:21589 ~RtcpParameters();
590
591 // The SSRC to be used in the "SSRC of packet sender" field. If not set, one
592 // will be chosen by the implementation.
593 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 11:32:56594 absl::optional<uint32_t> ssrc;
Florent Castellidacec712018-05-24 14:24:21595
596 // The Canonical Name (CNAME) used by RTCP (e.g. in SDES messages).
597 //
598 // If empty in the construction of the RtpTransport, one will be generated by
599 // the implementation, and returned in GetRtcpParameters. Multiple
600 // RtpTransports created by the same OrtcFactory will use the same generated
601 // CNAME.
602 //
603 // If empty when passed into SetParameters, the CNAME simply won't be
604 // modified.
605 std::string cname;
606
607 // Send reduced-size RTCP?
608 bool reduced_size = false;
609
610 // Send RTCP multiplexed on the RTP transport?
611 // Not used with PeerConnection senders/receivers
612 bool mux = true;
613
614 bool operator==(const RtcpParameters& o) const {
615 return ssrc == o.ssrc && cname == o.cname &&
616 reduced_size == o.reduced_size && mux == o.mux;
617 }
618 bool operator!=(const RtcpParameters& o) const { return !(*this == o); }
619};
620
Mirko Bonadeiac194142018-10-22 15:08:37621struct RTC_EXPORT RtpParameters {
Stefan Holmer1acbd682017-09-01 13:29:28622 RtpParameters();
Mirko Bonadei2ffed6d2018-07-20 09:09:32623 RtpParameters(const RtpParameters&);
Stefan Holmer1acbd682017-09-01 13:29:28624 ~RtpParameters();
625
deadbeefe702b302017-02-04 20:09:01626 // Used when calling getParameters/setParameters with a PeerConnection
627 // RtpSender, to ensure that outdated parameters are not unintentionally
628 // applied successfully.
deadbeefe702b302017-02-04 20:09:01629 std::string transaction_id;
630
631 // Value to use for MID RTP header extension.
632 // Called "muxId" in ORTC.
633 // TODO(deadbeef): Not implemented.
634 std::string mid;
635
Taylor Brandstetter0cd086b2016-04-20 23:23:10636 std::vector<RtpCodecParameters> codecs;
637
deadbeefe702b302017-02-04 20:09:01638 std::vector<RtpHeaderExtensionParameters> header_extensions;
639
640 std::vector<RtpEncodingParameters> encodings;
641
Florent Castellidacec712018-05-24 14:24:21642 // Only available with a Peerconnection RtpSender.
643 // In ORTC, our API includes an additional "RtpTransport"
644 // abstraction on which RTCP parameters are set.
645 RtcpParameters rtcp;
646
Florent Castelli87b3c512018-07-18 14:00:28647 // When bandwidth is constrained and the RtpSender needs to choose between
648 // degrading resolution or degrading framerate, degradationPreference
649 // indicates which is preferred. Only for video tracks.
deadbeefe702b302017-02-04 20:09:01650 DegradationPreference degradation_preference =
651 DegradationPreference::BALANCED;
652
Taylor Brandstetter0cd086b2016-04-20 23:23:10653 bool operator==(const RtpParameters& o) const {
deadbeefe702b302017-02-04 20:09:01654 return mid == o.mid && codecs == o.codecs &&
655 header_extensions == o.header_extensions &&
Florent Castellidacec712018-05-24 14:24:21656 encodings == o.encodings && rtcp == o.rtcp &&
deadbeefe702b302017-02-04 20:09:01657 degradation_preference == o.degradation_preference;
Taylor Brandstetter0cd086b2016-04-20 23:23:10658 }
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30659 bool operator!=(const RtpParameters& o) const { return !(*this == o); }
skvladdc1c62c2016-03-17 02:07:43660};
661
662} // namespace webrtc
663
Mirko Bonadei92ea95e2017-09-15 04:47:31664#endif // API_RTPPARAMETERS_H_