blob: 6138c37320e0a6c97438e46727513800c21508c3 [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"
Elad Alon157540a2019-02-08 23:37:52 +010021#include "rtc_base/deprecation.h"
Mirko Bonadeiac194142018-10-22 17:08:37 +020022#include "rtc_base/system/rtc_export.h"
sakal1fd95952016-06-22 00:46:15 -070023
skvladdc1c62c2016-03-16 19:07:43 -070024namespace webrtc {
25
deadbeefe702b302017-02-04 12:09:01 -080026// These structures are intended to mirror those defined by:
27// http://draft.ortc.org/#rtcrtpdictionaries*
28// Contains everything specified as of 2017 Jan 24.
29//
30// They are used when retrieving or modifying the parameters of an
31// RtpSender/RtpReceiver, or retrieving capabilities.
32//
33// Note on conventions: Where ORTC may use "octet", "short" and "unsigned"
34// types, we typically use "int", in keeping with our style guidelines. The
35// parameter's actual valid range will be enforced when the parameters are set,
36// rather than when the parameters struct is built. An exception is made for
37// SSRCs, since they use the full unsigned 32-bit range, and aren't expected to
38// be used for any numeric comparisons/operations.
39//
40// Additionally, where ORTC uses strings, we may use enums for things that have
41// a fixed number of supported values. However, for things that can be extended
42// (such as codecs, by providing an external encoder factory), a string
43// identifier is used.
44
45enum class FecMechanism {
46 RED,
47 RED_AND_ULPFEC,
48 FLEXFEC,
49};
50
51// Used in RtcpFeedback struct.
52enum class RtcpFeedbackType {
deadbeefe702b302017-02-04 12:09:01 -080053 CCM,
54 NACK,
55 REMB, // "goog-remb"
56 TRANSPORT_CC,
57};
58
deadbeefe814a0d2017-02-25 18:15:09 -080059// Used in RtcpFeedback struct when type is NACK or CCM.
deadbeefe702b302017-02-04 12:09:01 -080060enum class RtcpFeedbackMessageType {
61 // Equivalent to {type: "nack", parameter: undefined} in ORTC.
62 GENERIC_NACK,
63 PLI, // Usable with NACK.
64 FIR, // Usable with CCM.
65};
66
67enum class DtxStatus {
68 DISABLED,
69 ENABLED,
70};
71
Taylor Brandstetter49fcc102018-05-16 14:20:41 -070072// Based on the spec in
73// https://w3c.github.io/webrtc-pc/#idl-def-rtcdegradationpreference.
74// These options are enforced on a best-effort basis. For instance, all of
75// these options may suffer some frame drops in order to avoid queuing.
76// TODO(sprang): Look into possibility of more strictly enforcing the
77// maintain-framerate option.
78// TODO(deadbeef): Default to "balanced", as the spec indicates?
deadbeefe702b302017-02-04 12:09:01 -080079enum class DegradationPreference {
Taylor Brandstetter49fcc102018-05-16 14:20:41 -070080 // Don't take any actions based on over-utilization signals. Not part of the
81 // web API.
82 DISABLED,
83 // On over-use, request lower frame rate, possibly causing frame drops.
deadbeefe702b302017-02-04 12:09:01 -080084 MAINTAIN_FRAMERATE,
Taylor Brandstetter49fcc102018-05-16 14:20:41 -070085 // On over-use, request lower resolution, possibly causing down-scaling.
deadbeefe702b302017-02-04 12:09:01 -080086 MAINTAIN_RESOLUTION,
Taylor Brandstetter49fcc102018-05-16 14:20:41 -070087 // Try to strike a "pleasing" balance between frame rate or resolution.
deadbeefe702b302017-02-04 12:09:01 -080088 BALANCED,
89};
90
Seth Hampsonf32795e2017-12-19 11:37:41 -080091extern const double kDefaultBitratePriority;
deadbeefe702b302017-02-04 12:09:01 -080092
93struct RtcpFeedback {
deadbeefe814a0d2017-02-25 18:15:09 -080094 RtcpFeedbackType type = RtcpFeedbackType::CCM;
deadbeefe702b302017-02-04 12:09:01 -080095
96 // Equivalent to ORTC "parameter" field with slight differences:
97 // 1. It's an enum instead of a string.
98 // 2. Generic NACK feedback is represented by a GENERIC_NACK message type,
99 // rather than an unset "parameter" value.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200100 absl::optional<RtcpFeedbackMessageType> message_type;
deadbeefe702b302017-02-04 12:09:01 -0800101
deadbeefe814a0d2017-02-25 18:15:09 -0800102 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200103 RtcpFeedback();
104 explicit RtcpFeedback(RtcpFeedbackType type);
105 RtcpFeedback(RtcpFeedbackType type, RtcpFeedbackMessageType message_type);
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200106 RtcpFeedback(const RtcpFeedback&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200107 ~RtcpFeedback();
deadbeefe814a0d2017-02-25 18:15:09 -0800108
deadbeefe702b302017-02-04 12:09:01 -0800109 bool operator==(const RtcpFeedback& o) const {
110 return type == o.type && message_type == o.message_type;
111 }
112 bool operator!=(const RtcpFeedback& o) const { return !(*this == o); }
113};
114
115// RtpCodecCapability is to RtpCodecParameters as RtpCapabilities is to
116// RtpParameters. This represents the static capabilities of an endpoint's
117// implementation of a codec.
118struct RtpCodecCapability {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200119 RtpCodecCapability();
120 ~RtpCodecCapability();
121
deadbeefe702b302017-02-04 12:09:01 -0800122 // Build MIME "type/subtype" string from |name| and |kind|.
123 std::string mime_type() const { return MediaTypeToString(kind) + "/" + name; }
124
125 // Used to identify the codec. Equivalent to MIME subtype.
126 std::string name;
127
128 // The media type of this codec. Equivalent to MIME top-level type.
129 cricket::MediaType kind = cricket::MEDIA_TYPE_AUDIO;
130
131 // Clock rate in Hertz. If unset, the codec is applicable to any clock rate.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200132 absl::optional<int> clock_rate;
deadbeefe702b302017-02-04 12:09:01 -0800133
134 // Default payload type for this codec. Mainly needed for codecs that use
135 // that have statically assigned payload types.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200136 absl::optional<int> preferred_payload_type;
deadbeefe702b302017-02-04 12:09:01 -0800137
138 // Maximum packetization time supported by an RtpReceiver for this codec.
139 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200140 absl::optional<int> max_ptime;
deadbeefe702b302017-02-04 12:09:01 -0800141
142 // Preferred packetization time for an RtpReceiver or RtpSender of this
143 // codec.
144 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200145 absl::optional<int> ptime;
deadbeefe702b302017-02-04 12:09:01 -0800146
147 // The number of audio channels supported. Unused for video codecs.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200148 absl::optional<int> num_channels;
deadbeefe702b302017-02-04 12:09:01 -0800149
150 // Feedback mechanisms supported for this codec.
151 std::vector<RtcpFeedback> rtcp_feedback;
152
153 // Codec-specific parameters that must be signaled to the remote party.
deadbeefe814a0d2017-02-25 18:15:09 -0800154 //
deadbeefe702b302017-02-04 12:09:01 -0800155 // Corresponds to "a=fmtp" parameters in SDP.
deadbeefe814a0d2017-02-25 18:15:09 -0800156 //
157 // Contrary to ORTC, these parameters are named using all lowercase strings.
158 // This helps make the mapping to SDP simpler, if an application is using
159 // SDP. Boolean values are represented by the string "1".
deadbeefe702b302017-02-04 12:09:01 -0800160 std::unordered_map<std::string, std::string> parameters;
161
162 // Codec-specific parameters that may optionally be signaled to the remote
163 // party.
164 // TODO(deadbeef): Not implemented.
165 std::unordered_map<std::string, std::string> options;
166
167 // Maximum number of temporal layer extensions supported by this codec.
168 // For example, a value of 1 indicates that 2 total layers are supported.
169 // TODO(deadbeef): Not implemented.
170 int max_temporal_layer_extensions = 0;
171
172 // Maximum number of spatial layer extensions supported by this codec.
173 // For example, a value of 1 indicates that 2 total layers are supported.
174 // TODO(deadbeef): Not implemented.
175 int max_spatial_layer_extensions = 0;
176
177 // Whether the implementation can send/receive SVC layers with distinct
178 // SSRCs. Always false for audio codecs. True for video codecs that support
179 // scalable video coding with MRST.
180 // TODO(deadbeef): Not implemented.
181 bool svc_multi_stream_support = false;
182
183 bool operator==(const RtpCodecCapability& o) const {
184 return name == o.name && kind == o.kind && clock_rate == o.clock_rate &&
185 preferred_payload_type == o.preferred_payload_type &&
186 max_ptime == o.max_ptime && ptime == o.ptime &&
187 num_channels == o.num_channels && rtcp_feedback == o.rtcp_feedback &&
188 parameters == o.parameters && options == o.options &&
189 max_temporal_layer_extensions == o.max_temporal_layer_extensions &&
190 max_spatial_layer_extensions == o.max_spatial_layer_extensions &&
191 svc_multi_stream_support == o.svc_multi_stream_support;
192 }
193 bool operator!=(const RtpCodecCapability& o) const { return !(*this == o); }
194};
195
196// Used in RtpCapabilities; represents the capabilities/preferences of an
197// implementation for a header extension.
198//
199// Just called "RtpHeaderExtension" in ORTC, but the "Capability" suffix was
200// added here for consistency and to avoid confusion with
201// RtpHeaderExtensionParameters.
202//
203// Note that ORTC includes a "kind" field, but we omit this because it's
204// redundant; if you call "RtpReceiver::GetCapabilities(MEDIA_TYPE_AUDIO)",
205// you know you're getting audio capabilities.
206struct RtpHeaderExtensionCapability {
Johannes Kron07ba2b92018-09-26 13:33:35 +0200207 // URI of this extension, as defined in RFC8285.
deadbeefe702b302017-02-04 12:09:01 -0800208 std::string uri;
209
210 // Preferred value of ID that goes in the packet.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200211 absl::optional<int> preferred_id;
deadbeefe702b302017-02-04 12:09:01 -0800212
213 // If true, it's preferred that the value in the header is encrypted.
214 // TODO(deadbeef): Not implemented.
215 bool preferred_encrypt = false;
216
deadbeefe814a0d2017-02-25 18:15:09 -0800217 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200218 RtpHeaderExtensionCapability();
219 explicit RtpHeaderExtensionCapability(const std::string& uri);
220 RtpHeaderExtensionCapability(const std::string& uri, int preferred_id);
221 ~RtpHeaderExtensionCapability();
deadbeefe814a0d2017-02-25 18:15:09 -0800222
deadbeefe702b302017-02-04 12:09:01 -0800223 bool operator==(const RtpHeaderExtensionCapability& o) const {
224 return uri == o.uri && preferred_id == o.preferred_id &&
225 preferred_encrypt == o.preferred_encrypt;
226 }
227 bool operator!=(const RtpHeaderExtensionCapability& o) const {
228 return !(*this == o);
229 }
230};
231
Johannes Kron07ba2b92018-09-26 13:33:35 +0200232// RTP header extension, see RFC8285.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200233struct RtpExtension {
234 RtpExtension();
235 RtpExtension(const std::string& uri, int id);
236 RtpExtension(const std::string& uri, int id, bool encrypt);
237 ~RtpExtension();
238 std::string ToString() const;
239 bool operator==(const RtpExtension& rhs) const {
240 return uri == rhs.uri && id == rhs.id && encrypt == rhs.encrypt;
241 }
242 static bool IsSupportedForAudio(const std::string& uri);
243 static bool IsSupportedForVideo(const std::string& uri);
244 // Return "true" if the given RTP header extension URI may be encrypted.
245 static bool IsEncryptionSupported(const std::string& uri);
246
247 // Returns the named header extension if found among all extensions,
248 // nullptr otherwise.
249 static const RtpExtension* FindHeaderExtensionByUri(
250 const std::vector<RtpExtension>& extensions,
251 const std::string& uri);
252
253 // Return a list of RTP header extensions with the non-encrypted extensions
254 // removed if both the encrypted and non-encrypted extension is present for
255 // the same URI.
256 static std::vector<RtpExtension> FilterDuplicateNonEncrypted(
257 const std::vector<RtpExtension>& extensions);
258
259 // Header extension for audio levels, as defined in:
260 // http://tools.ietf.org/html/draft-ietf-avtext-client-to-mixer-audio-level-03
261 static const char kAudioLevelUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100262 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
263 RTC_DEPRECATED static const int kAudioLevelDefaultId;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200264
265 // Header extension for RTP timestamp offset, see RFC 5450 for details:
266 // http://tools.ietf.org/html/rfc5450
267 static const char kTimestampOffsetUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100268 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
269 RTC_DEPRECATED static const int kTimestampOffsetDefaultId;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200270
271 // Header extension for absolute send time, see url for details:
272 // http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
273 static const char kAbsSendTimeUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100274 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
275 RTC_DEPRECATED static const int kAbsSendTimeDefaultId;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200276
277 // Header extension for coordination of video orientation, see url for
278 // details:
279 // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/ts_126114v120700p.pdf
280 static const char kVideoRotationUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100281 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
282 RTC_DEPRECATED static const int kVideoRotationDefaultId;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200283
284 // Header extension for video content type. E.g. default or screenshare.
285 static const char kVideoContentTypeUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100286 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
287 RTC_DEPRECATED static const int kVideoContentTypeDefaultId;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200288
289 // Header extension for video timing.
290 static const char kVideoTimingUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100291 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
292 RTC_DEPRECATED static const int kVideoTimingDefaultId;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200293
Johnny Leee0c8b232018-09-11 16:50:49 -0400294 // Header extension for video frame marking.
295 static const char kFrameMarkingUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100296 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
297 RTC_DEPRECATED static const int kFrameMarkingDefaultId;
Johnny Leee0c8b232018-09-11 16:50:49 -0400298
Danil Chapovalovf3119ef2018-09-25 12:20:37 +0200299 // Experimental codec agnostic frame descriptor.
300 static const char kGenericFrameDescriptorUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100301 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
302 RTC_DEPRECATED static const int kGenericFrameDescriptorDefaultId;
Danil Chapovalovf3119ef2018-09-25 12:20:37 +0200303
Stefan Holmer1acbd682017-09-01 15:29:28 +0200304 // Header extension for transport sequence number, see url for details:
305 // http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions
306 static const char kTransportSequenceNumberUri[];
Johannes Kron7ff164e2019-02-07 12:50:18 +0100307 static const char kTransportSequenceNumberV2Uri[];
Elad Alon157540a2019-02-08 23:37:52 +0100308 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
309 RTC_DEPRECATED static const int kTransportSequenceNumberDefaultId;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200310
311 static const char kPlayoutDelayUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100312 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
313 RTC_DEPRECATED static const int kPlayoutDelayDefaultId;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200314
Steve Antonbb50ce52018-03-26 10:24:32 -0700315 // Header extension for identifying media section within a transport.
316 // https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-49#section-15
317 static const char kMidUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100318 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
319 RTC_DEPRECATED static const int kMidDefaultId;
Steve Antonbb50ce52018-03-26 10:24:32 -0700320
Stefan Holmer1acbd682017-09-01 15:29:28 +0200321 // Encryption of Header Extensions, see RFC 6904 for details:
322 // https://tools.ietf.org/html/rfc6904
323 static const char kEncryptHeaderExtensionsUri[];
324
Johannes Krond0b69a82018-12-03 14:18:53 +0100325 // Header extension for color space information.
326 static const char kColorSpaceUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100327 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
328 RTC_DEPRECATED static const int kColorSpaceDefaultId;
Johannes Krond0b69a82018-12-03 14:18:53 +0100329
Amit Hilbuch77938e62018-12-21 09:23:38 -0800330 // Header extension for RIDs and Repaired RIDs
331 // https://tools.ietf.org/html/draft-ietf-avtext-rid-09
332 // https://tools.ietf.org/html/draft-ietf-mmusic-rid-15
333 static const char kRidUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100334 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
335 RTC_DEPRECATED static const int kRidDefaultId;
Amit Hilbuch77938e62018-12-21 09:23:38 -0800336 static const char kRepairedRidUri[];
Elad Alon157540a2019-02-08 23:37:52 +0100337 // TODO(bugs.webrtc.org/10288): Remove once dependencies have been updated.
338 RTC_DEPRECATED static const int kRepairedRidDefaultId;
Amit Hilbuch77938e62018-12-21 09:23:38 -0800339
Johannes Kron07ba2b92018-09-26 13:33:35 +0200340 // Inclusive min and max IDs for two-byte header extensions and one-byte
341 // header extensions, per RFC8285 Section 4.2-4.3.
342 static constexpr int kMinId = 1;
343 static constexpr int kMaxId = 255;
Johannes Kron78cdde32018-10-05 10:00:46 +0200344 static constexpr int kMaxValueSize = 255;
Johannes Kron07ba2b92018-09-26 13:33:35 +0200345 static constexpr int kOneByteHeaderExtensionMaxId = 14;
Johannes Kron78cdde32018-10-05 10:00:46 +0200346 static constexpr int kOneByteHeaderExtensionMaxValueSize = 16;
Stefan Holmer1acbd682017-09-01 15:29:28 +0200347
348 std::string uri;
349 int id = 0;
350 bool encrypt = false;
351};
352
deadbeefe814a0d2017-02-25 18:15:09 -0800353// TODO(deadbeef): This is missing the "encrypt" flag, which is unimplemented.
354typedef RtpExtension RtpHeaderExtensionParameters;
deadbeefe702b302017-02-04 12:09:01 -0800355
356struct RtpFecParameters {
357 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-25 18:15:09 -0800358 // Works just like RtpEncodingParameters::ssrc.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200359 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 12:09:01 -0800360
361 FecMechanism mechanism = FecMechanism::RED;
362
deadbeefe814a0d2017-02-25 18:15:09 -0800363 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200364 RtpFecParameters();
365 explicit RtpFecParameters(FecMechanism mechanism);
366 RtpFecParameters(FecMechanism mechanism, uint32_t ssrc);
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200367 RtpFecParameters(const RtpFecParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200368 ~RtpFecParameters();
deadbeefe814a0d2017-02-25 18:15:09 -0800369
deadbeefe702b302017-02-04 12:09:01 -0800370 bool operator==(const RtpFecParameters& o) const {
371 return ssrc == o.ssrc && mechanism == o.mechanism;
372 }
373 bool operator!=(const RtpFecParameters& o) const { return !(*this == o); }
374};
375
376struct RtpRtxParameters {
377 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-25 18:15:09 -0800378 // Works just like RtpEncodingParameters::ssrc.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200379 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 12:09:01 -0800380
deadbeefe814a0d2017-02-25 18:15:09 -0800381 // Constructors for convenience.
Stefan Holmer1acbd682017-09-01 15:29:28 +0200382 RtpRtxParameters();
383 explicit RtpRtxParameters(uint32_t ssrc);
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200384 RtpRtxParameters(const RtpRtxParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200385 ~RtpRtxParameters();
deadbeefe814a0d2017-02-25 18:15:09 -0800386
deadbeefe702b302017-02-04 12:09:01 -0800387 bool operator==(const RtpRtxParameters& o) const { return ssrc == o.ssrc; }
388 bool operator!=(const RtpRtxParameters& o) const { return !(*this == o); }
389};
390
391struct RtpEncodingParameters {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200392 RtpEncodingParameters();
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200393 RtpEncodingParameters(const RtpEncodingParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200394 ~RtpEncodingParameters();
395
deadbeefe702b302017-02-04 12:09:01 -0800396 // If unset, a value is chosen by the implementation.
deadbeefe814a0d2017-02-25 18:15:09 -0800397 //
398 // Note that the chosen value is NOT returned by GetParameters, because it
399 // may change due to an SSRC conflict, in which case the conflict is handled
400 // internally without any event. Another way of looking at this is that an
401 // unset SSRC acts as a "wildcard" SSRC.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200402 absl::optional<uint32_t> ssrc;
deadbeefe702b302017-02-04 12:09:01 -0800403
Henrik Grunelle1301a82018-12-13 12:13:22 +0000404 // Can be used to reference a codec in the |codecs| member of the
405 // RtpParameters that contains this RtpEncodingParameters. If unset, the
406 // implementation will choose the first possible codec (if a sender), or
407 // prepare to receive any codec (for a receiver).
408 // TODO(deadbeef): Not implemented. Implementation of RtpSender will always
409 // choose the first codec from the list.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200410 absl::optional<int> codec_payload_type;
deadbeefe702b302017-02-04 12:09:01 -0800411
412 // Specifies the FEC mechanism, if set.
deadbeefe814a0d2017-02-25 18:15:09 -0800413 // TODO(deadbeef): Not implemented. Current implementation will use whatever
414 // FEC codecs are available, including red+ulpfec.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200415 absl::optional<RtpFecParameters> fec;
deadbeefe702b302017-02-04 12:09:01 -0800416
417 // Specifies the RTX parameters, if set.
deadbeefe814a0d2017-02-25 18:15:09 -0800418 // TODO(deadbeef): Not implemented with PeerConnection senders/receivers.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200419 absl::optional<RtpRtxParameters> rtx;
deadbeefe702b302017-02-04 12:09:01 -0800420
421 // Only used for audio. If set, determines whether or not discontinuous
422 // transmission will be used, if an available codec supports it. If not
423 // set, the implementation default setting will be used.
deadbeefe814a0d2017-02-25 18:15:09 -0800424 // TODO(deadbeef): Not implemented. Current implementation will use a CN
425 // codec as long as it's present.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200426 absl::optional<DtxStatus> dtx;
deadbeefe702b302017-02-04 12:09:01 -0800427
Seth Hampson24722b32017-12-22 09:36:42 -0800428 // The relative bitrate priority of this encoding. Currently this is
Seth Hampsona881ac02018-02-12 14:14:39 -0800429 // implemented for the entire rtp sender by using the value of the first
430 // encoding parameter.
431 // TODO(webrtc.bugs.org/8630): Implement this per encoding parameter.
432 // Currently there is logic for how bitrate is distributed per simulcast layer
433 // in the VideoBitrateAllocator. This must be updated to incorporate relative
434 // bitrate priority.
Seth Hampson24722b32017-12-22 09:36:42 -0800435 double bitrate_priority = kDefaultBitratePriority;
deadbeefe702b302017-02-04 12:09:01 -0800436
Tim Haloun648d28a2018-10-18 16:52:22 -0700437 // The relative DiffServ Code Point priority for this encoding, allowing
438 // packets to be marked relatively higher or lower without affecting
439 // bandwidth allocations. See https://w3c.github.io/webrtc-dscp-exp/ . NB
440 // we follow chromium's translation of the allowed string enum values for
441 // this field to 1.0, 0.5, et cetera, similar to bitrate_priority above.
442 // TODO(http://crbug.com/webrtc/8630): Implement this per encoding parameter.
443 double network_priority = kDefaultBitratePriority;
444
Seth Hampsonf209cb52018-02-06 14:28:16 -0800445 // Indicates the preferred duration of media represented by a packet in
446 // milliseconds for this encoding. If set, this will take precedence over the
447 // ptime set in the RtpCodecParameters. This could happen if SDP negotiation
448 // creates a ptime for a specific codec, which is later changed in the
449 // RtpEncodingParameters by the application.
450 // TODO(bugs.webrtc.org/8819): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200451 absl::optional<int> ptime;
Seth Hampsonf209cb52018-02-06 14:28:16 -0800452
deadbeefe702b302017-02-04 12:09:01 -0800453 // If set, this represents the Transport Independent Application Specific
454 // maximum bandwidth defined in RFC3890. If unset, there is no maximum
Seth Hampsona881ac02018-02-12 14:14:39 -0800455 // bitrate. Currently this is implemented for the entire rtp sender by using
456 // the value of the first encoding parameter.
457 //
deadbeefe702b302017-02-04 12:09:01 -0800458 // Just called "maxBitrate" in ORTC spec.
deadbeefe814a0d2017-02-25 18:15:09 -0800459 //
460 // TODO(deadbeef): With ORTC RtpSenders, this currently sets the total
461 // bandwidth for the entire bandwidth estimator (audio and video). This is
462 // just always how "b=AS" was handled, but it's not correct and should be
463 // fixed.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200464 absl::optional<int> max_bitrate_bps;
deadbeefe702b302017-02-04 12:09:01 -0800465
Ã…sa Persson55659812018-06-18 17:51:32 +0200466 // Specifies the minimum bitrate in bps for video.
467 // TODO(asapersson): Not implemented for ORTC API.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200468 absl::optional<int> min_bitrate_bps;
Ã…sa Persson613591a2018-05-29 09:21:31 +0200469
Ã…sa Persson8c1bf952018-09-13 10:42:19 +0200470 // Specifies the maximum framerate in fps for video.
Ã…sa Persson23eba222018-10-02 14:47:06 +0200471 // TODO(asapersson): Different framerates are not supported per simulcast
472 // layer. If set, the maximum |max_framerate| is currently used.
Ã…sa Persson8c1bf952018-09-13 10:42:19 +0200473 // Not supported for screencast.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200474 absl::optional<int> max_framerate;
deadbeefe702b302017-02-04 12:09:01 -0800475
Ã…sa Persson23eba222018-10-02 14:47:06 +0200476 // Specifies the number of temporal layers for video (if the feature is
477 // supported by the codec implementation).
478 // TODO(asapersson): Different number of temporal layers are not supported
479 // per simulcast layer.
Ilya Nikolaevskiy9f6a0d52019-02-05 10:29:41 +0100480 // Screencast support is experimental.
Ã…sa Persson23eba222018-10-02 14:47:06 +0200481 absl::optional<int> num_temporal_layers;
482
deadbeefe702b302017-02-04 12:09:01 -0800483 // For video, scale the resolution down by this factor.
484 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200485 absl::optional<double> scale_resolution_down_by;
deadbeefe702b302017-02-04 12:09:01 -0800486
487 // Scale the framerate down by this factor.
488 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200489 absl::optional<double> scale_framerate_down_by;
deadbeefe702b302017-02-04 12:09:01 -0800490
Seth Hampsona881ac02018-02-12 14:14:39 -0800491 // For an RtpSender, set to true to cause this encoding to be encoded and
492 // sent, and false for it not to be encoded and sent. This allows control
493 // across multiple encodings of a sender for turning simulcast layers on and
494 // off.
495 // TODO(webrtc.bugs.org/8807): Updating this parameter will trigger an encoder
496 // reset, but this isn't necessarily required.
deadbeefdbe2b872016-03-22 15:42:00 -0700497 bool active = true;
deadbeefe702b302017-02-04 12:09:01 -0800498
499 // Value to use for RID RTP header extension.
500 // Called "encodingId" in ORTC.
501 // TODO(deadbeef): Not implemented.
502 std::string rid;
503
504 // RIDs of encodings on which this layer depends.
505 // Called "dependencyEncodingIds" in ORTC spec.
506 // TODO(deadbeef): Not implemented.
507 std::vector<std::string> dependency_rids;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700508
509 bool operator==(const RtpEncodingParameters& o) const {
deadbeefe702b302017-02-04 12:09:01 -0800510 return ssrc == o.ssrc && codec_payload_type == o.codec_payload_type &&
511 fec == o.fec && rtx == o.rtx && dtx == o.dtx &&
Tim Haloun648d28a2018-10-18 16:52:22 -0700512 bitrate_priority == o.bitrate_priority &&
513 network_priority == o.network_priority && ptime == o.ptime &&
Seth Hampson24722b32017-12-22 09:36:42 -0800514 max_bitrate_bps == o.max_bitrate_bps &&
Ã…sa Persson8c1bf952018-09-13 10:42:19 +0200515 min_bitrate_bps == o.min_bitrate_bps &&
deadbeefe702b302017-02-04 12:09:01 -0800516 max_framerate == o.max_framerate &&
Ã…sa Persson23eba222018-10-02 14:47:06 +0200517 num_temporal_layers == o.num_temporal_layers &&
deadbeefe702b302017-02-04 12:09:01 -0800518 scale_resolution_down_by == o.scale_resolution_down_by &&
519 scale_framerate_down_by == o.scale_framerate_down_by &&
520 active == o.active && rid == o.rid &&
521 dependency_rids == o.dependency_rids;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700522 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700523 bool operator!=(const RtpEncodingParameters& o) const {
524 return !(*this == o);
525 }
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700526};
527
528struct RtpCodecParameters {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200529 RtpCodecParameters();
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200530 RtpCodecParameters(const RtpCodecParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200531 ~RtpCodecParameters();
532
deadbeefe702b302017-02-04 12:09:01 -0800533 // Build MIME "type/subtype" string from |name| and |kind|.
534 std::string mime_type() const { return MediaTypeToString(kind) + "/" + name; }
535
536 // Used to identify the codec. Equivalent to MIME subtype.
537 std::string name;
538
539 // The media type of this codec. Equivalent to MIME top-level type.
540 cricket::MediaType kind = cricket::MEDIA_TYPE_AUDIO;
541
542 // Payload type used to identify this codec in RTP packets.
deadbeefe814a0d2017-02-25 18:15:09 -0800543 // This must always be present, and must be unique across all codecs using
deadbeefe702b302017-02-04 12:09:01 -0800544 // the same transport.
545 int payload_type = 0;
546
547 // If unset, the implementation default is used.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200548 absl::optional<int> clock_rate;
deadbeefe702b302017-02-04 12:09:01 -0800549
550 // The number of audio channels used. Unset for video codecs. If unset for
551 // audio, the implementation default is used.
deadbeefe814a0d2017-02-25 18:15:09 -0800552 // TODO(deadbeef): The "implementation default" part isn't fully implemented.
553 // Only defaults to 1, even though some codecs (such as opus) should really
554 // default to 2.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200555 absl::optional<int> num_channels;
deadbeefe702b302017-02-04 12:09:01 -0800556
557 // The maximum packetization time to be used by an RtpSender.
558 // If |ptime| is also set, this will be ignored.
559 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200560 absl::optional<int> max_ptime;
deadbeefe702b302017-02-04 12:09:01 -0800561
562 // The packetization time to be used by an RtpSender.
563 // If unset, will use any time up to max_ptime.
564 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200565 absl::optional<int> ptime;
deadbeefe702b302017-02-04 12:09:01 -0800566
567 // Feedback mechanisms to be used for this codec.
deadbeefe814a0d2017-02-25 18:15:09 -0800568 // TODO(deadbeef): Not implemented with PeerConnection senders/receivers.
deadbeefe702b302017-02-04 12:09:01 -0800569 std::vector<RtcpFeedback> rtcp_feedback;
570
571 // Codec-specific parameters that must be signaled to the remote party.
deadbeefe814a0d2017-02-25 18:15:09 -0800572 //
deadbeefe702b302017-02-04 12:09:01 -0800573 // Corresponds to "a=fmtp" parameters in SDP.
deadbeefe814a0d2017-02-25 18:15:09 -0800574 //
575 // Contrary to ORTC, these parameters are named using all lowercase strings.
576 // This helps make the mapping to SDP simpler, if an application is using
577 // SDP. Boolean values are represented by the string "1".
deadbeefe702b302017-02-04 12:09:01 -0800578 std::unordered_map<std::string, std::string> parameters;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700579
580 bool operator==(const RtpCodecParameters& o) const {
deadbeefe702b302017-02-04 12:09:01 -0800581 return name == o.name && kind == o.kind && payload_type == o.payload_type &&
582 clock_rate == o.clock_rate && num_channels == o.num_channels &&
583 max_ptime == o.max_ptime && ptime == o.ptime &&
584 rtcp_feedback == o.rtcp_feedback && parameters == o.parameters;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700585 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700586 bool operator!=(const RtpCodecParameters& o) const { return !(*this == o); }
skvladdc1c62c2016-03-16 19:07:43 -0700587};
588
deadbeefe702b302017-02-04 12:09:01 -0800589// RtpCapabilities is used to represent the static capabilities of an
590// endpoint. An application can use these capabilities to construct an
591// RtpParameters.
592struct RtpCapabilities {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200593 RtpCapabilities();
594 ~RtpCapabilities();
595
deadbeefe702b302017-02-04 12:09:01 -0800596 // Supported codecs.
597 std::vector<RtpCodecCapability> codecs;
598
599 // Supported RTP header extensions.
600 std::vector<RtpHeaderExtensionCapability> header_extensions;
601
deadbeefe814a0d2017-02-25 18:15:09 -0800602 // Supported Forward Error Correction (FEC) mechanisms. Note that the RED,
603 // ulpfec and flexfec codecs used by these mechanisms will still appear in
604 // |codecs|.
deadbeefe702b302017-02-04 12:09:01 -0800605 std::vector<FecMechanism> fec;
606
607 bool operator==(const RtpCapabilities& o) const {
608 return codecs == o.codecs && header_extensions == o.header_extensions &&
609 fec == o.fec;
610 }
611 bool operator!=(const RtpCapabilities& o) const { return !(*this == o); }
612};
613
Florent Castellidacec712018-05-24 16:24:21 +0200614struct RtcpParameters final {
615 RtcpParameters();
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200616 RtcpParameters(const RtcpParameters&);
Florent Castellidacec712018-05-24 16:24:21 +0200617 ~RtcpParameters();
618
619 // The SSRC to be used in the "SSRC of packet sender" field. If not set, one
620 // will be chosen by the implementation.
621 // TODO(deadbeef): Not implemented.
Danil Chapovalov0bc58cf2018-06-21 13:32:56 +0200622 absl::optional<uint32_t> ssrc;
Florent Castellidacec712018-05-24 16:24:21 +0200623
624 // The Canonical Name (CNAME) used by RTCP (e.g. in SDES messages).
625 //
626 // If empty in the construction of the RtpTransport, one will be generated by
627 // the implementation, and returned in GetRtcpParameters. Multiple
628 // RtpTransports created by the same OrtcFactory will use the same generated
629 // CNAME.
630 //
631 // If empty when passed into SetParameters, the CNAME simply won't be
632 // modified.
633 std::string cname;
634
635 // Send reduced-size RTCP?
636 bool reduced_size = false;
637
638 // Send RTCP multiplexed on the RTP transport?
639 // Not used with PeerConnection senders/receivers
640 bool mux = true;
641
642 bool operator==(const RtcpParameters& o) const {
643 return ssrc == o.ssrc && cname == o.cname &&
644 reduced_size == o.reduced_size && mux == o.mux;
645 }
646 bool operator!=(const RtcpParameters& o) const { return !(*this == o); }
647};
648
Mirko Bonadeiac194142018-10-22 17:08:37 +0200649struct RTC_EXPORT RtpParameters {
Stefan Holmer1acbd682017-09-01 15:29:28 +0200650 RtpParameters();
Mirko Bonadei2ffed6d2018-07-20 11:09:32 +0200651 RtpParameters(const RtpParameters&);
Stefan Holmer1acbd682017-09-01 15:29:28 +0200652 ~RtpParameters();
653
deadbeefe702b302017-02-04 12:09:01 -0800654 // Used when calling getParameters/setParameters with a PeerConnection
655 // RtpSender, to ensure that outdated parameters are not unintentionally
656 // applied successfully.
deadbeefe702b302017-02-04 12:09:01 -0800657 std::string transaction_id;
658
659 // Value to use for MID RTP header extension.
660 // Called "muxId" in ORTC.
661 // TODO(deadbeef): Not implemented.
662 std::string mid;
663
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700664 std::vector<RtpCodecParameters> codecs;
665
deadbeefe702b302017-02-04 12:09:01 -0800666 std::vector<RtpHeaderExtensionParameters> header_extensions;
667
668 std::vector<RtpEncodingParameters> encodings;
669
Florent Castellidacec712018-05-24 16:24:21 +0200670 // Only available with a Peerconnection RtpSender.
671 // In ORTC, our API includes an additional "RtpTransport"
672 // abstraction on which RTCP parameters are set.
673 RtcpParameters rtcp;
674
Florent Castelli87b3c512018-07-18 16:00:28 +0200675 // When bandwidth is constrained and the RtpSender needs to choose between
676 // degrading resolution or degrading framerate, degradationPreference
677 // indicates which is preferred. Only for video tracks.
deadbeefe702b302017-02-04 12:09:01 -0800678 DegradationPreference degradation_preference =
679 DegradationPreference::BALANCED;
680
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700681 bool operator==(const RtpParameters& o) const {
deadbeefe702b302017-02-04 12:09:01 -0800682 return mid == o.mid && codecs == o.codecs &&
683 header_extensions == o.header_extensions &&
Florent Castellidacec712018-05-24 16:24:21 +0200684 encodings == o.encodings && rtcp == o.rtcp &&
deadbeefe702b302017-02-04 12:09:01 -0800685 degradation_preference == o.degradation_preference;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700686 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700687 bool operator!=(const RtpParameters& o) const { return !(*this == o); }
skvladdc1c62c2016-03-16 19:07:43 -0700688};
689
690} // namespace webrtc
691
Steve Anton10542f22019-01-11 09:11:00 -0800692#endif // API_RTP_PARAMETERS_H_