blob: f68e044db2a3145285ee93f25ebe456763927285 [file] [log] [blame]
Steve Anton4ab68ee2017-12-19 22:26:111/*
2 * Copyright 2004 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 17:11:0011#ifndef PC_SESSION_DESCRIPTION_H_
12#define PC_SESSION_DESCRIPTION_H_
Steve Anton4ab68ee2017-12-19 22:26:1113
Yves Gerey3e707812018-11-28 15:47:4914#include <stddef.h>
15#include <stdint.h>
Jonas Olssona4d87372019-07-05 17:08:3316
Harald Alvestrand5761e7b2021-01-29 14:45:0817#include <algorithm>
Harald Alvestrand4d7160e2019-04-12 05:01:2918#include <memory>
Steve Anton4ab68ee2017-12-19 22:26:1119#include <string>
Harald Alvestrandc24a2182022-02-23 13:44:5920#include <type_traits>
Harald Alvestrand1716d392019-06-03 18:35:4521#include <utility>
Steve Anton4ab68ee2017-12-19 22:26:1122#include <vector>
23
Harald Alvestrand5fc28b12019-05-13 11:36:1624#include "absl/memory/memory.h"
Niels Möllerf1d822b2022-06-07 11:58:2725#include "absl/strings/string_view.h"
Harald Alvestrand0d018412021-11-04 13:52:3126#include "api/crypto_params.h"
Steve Anton10542f22019-01-11 17:11:0027#include "api/media_types.h"
28#include "api/rtp_parameters.h"
Harald Alvestrand5761e7b2021-01-29 14:45:0829#include "api/rtp_transceiver_direction.h"
Steve Anton10542f22019-01-11 17:11:0030#include "api/rtp_transceiver_interface.h"
Harald Alvestrand5761e7b2021-01-29 14:45:0831#include "media/base/codec.h"
Steve Anton10542f22019-01-11 17:11:0032#include "media/base/media_channel.h"
Taylor Brandstetteree8c2462020-07-27 22:52:0233#include "media/base/media_constants.h"
Harald Alvestrand5761e7b2021-01-29 14:45:0834#include "media/base/rid_description.h"
Steve Anton10542f22019-01-11 17:11:0035#include "media/base/stream_params.h"
36#include "p2p/base/transport_description.h"
37#include "p2p/base/transport_info.h"
Harald Alvestrand5fc28b12019-05-13 11:36:1638#include "pc/media_protocol_names.h"
Steve Anton10542f22019-01-11 17:11:0039#include "pc/simulcast_description.h"
Harald Alvestrand5761e7b2021-01-29 14:45:0840#include "rtc_base/checks.h"
Steve Anton10542f22019-01-11 17:11:0041#include "rtc_base/socket_address.h"
Mirko Bonadei35214fc2019-09-23 12:54:2842#include "rtc_base/system/rtc_export.h"
Steve Anton4ab68ee2017-12-19 22:26:1143
44namespace cricket {
45
Steve Antonafd8e8c2017-12-20 00:35:3546typedef std::vector<AudioCodec> AudioCodecs;
47typedef std::vector<VideoCodec> VideoCodecs;
Harald Alvestrand0d018412021-11-04 13:52:3148typedef std::vector<CryptoParams> CryptoParamsVec;
Steve Antonafd8e8c2017-12-20 00:35:3549typedef std::vector<webrtc::RtpExtension> RtpHeaderExtensions;
50
Steve Antonafd8e8c2017-12-20 00:35:3551// Options to control how session descriptions are generated.
52const int kAutoBandwidth = -1;
53
Steve Anton5adfafd2017-12-21 00:34:0054class AudioContentDescription;
Steve Anton46afbf92019-05-10 18:15:1855class VideoContentDescription;
Harald Alvestrand5fc28b12019-05-13 11:36:1656class SctpDataContentDescription;
Philipp Hancke4e8c1152020-10-13 10:43:1557class UnsupportedContentDescription;
Steve Anton4ab68ee2017-12-19 22:26:1158
Steve Anton5adfafd2017-12-21 00:34:0059// Describes a session description media section. There are subclasses for each
60// media type (audio, video, data) that will have additional information.
61class MediaContentDescription {
Steve Antonafd8e8c2017-12-20 00:35:3562 public:
Steve Anton5adfafd2017-12-21 00:34:0063 MediaContentDescription() = default;
64 virtual ~MediaContentDescription() = default;
Steve Antonafd8e8c2017-12-20 00:35:3565
66 virtual MediaType type() const = 0;
Steve Anton5adfafd2017-12-21 00:34:0067
68 // Try to cast this media description to an AudioContentDescription. Returns
69 // nullptr if the cast fails.
70 virtual AudioContentDescription* as_audio() { return nullptr; }
71 virtual const AudioContentDescription* as_audio() const { return nullptr; }
72
73 // Try to cast this media description to a VideoContentDescription. Returns
74 // nullptr if the cast fails.
75 virtual VideoContentDescription* as_video() { return nullptr; }
76 virtual const VideoContentDescription* as_video() const { return nullptr; }
77
Harald Alvestrand5fc28b12019-05-13 11:36:1678 virtual SctpDataContentDescription* as_sctp() { return nullptr; }
79 virtual const SctpDataContentDescription* as_sctp() const { return nullptr; }
80
Philipp Hancke4e8c1152020-10-13 10:43:1581 virtual UnsupportedContentDescription* as_unsupported() { return nullptr; }
82 virtual const UnsupportedContentDescription* as_unsupported() const {
83 return nullptr;
84 }
85
Steve Antonafd8e8c2017-12-20 00:35:3586 virtual bool has_codecs() const = 0;
87
Harald Alvestrand0fb07f82020-02-27 19:21:3788 // Copy operator that returns an unique_ptr.
89 // Not a virtual function.
90 // If a type-specific variant of Clone() is desired, override it, or
91 // simply use std::make_unique<typename>(*this) instead of Clone().
92 std::unique_ptr<MediaContentDescription> Clone() const {
93 return absl::WrapUnique(CloneInternal());
Harald Alvestrand1716d392019-06-03 18:35:4594 }
Steve Anton5adfafd2017-12-21 00:34:0095
Artem Titov880fa812021-07-30 20:30:2396 // `protocol` is the expected media transport protocol, such as RTP/AVPF,
Steve Antonafd8e8c2017-12-20 00:35:3597 // RTP/SAVPF or SCTP/DTLS.
Ivan Rosales2803ca22022-11-02 16:46:2098 std::string protocol() const { return protocol_; }
Niels Möllerf1d822b2022-06-07 11:58:2799 virtual void set_protocol(absl::string_view protocol) {
100 protocol_ = std::string(protocol);
Harald Alvestrand5fc28b12019-05-13 11:36:16101 }
Steve Antonafd8e8c2017-12-20 00:35:35102
Ivan Rosales2803ca22022-11-02 16:46:20103 webrtc::RtpTransceiverDirection direction() const { return direction_; }
104 void set_direction(webrtc::RtpTransceiverDirection direction) {
Steve Antonafd8e8c2017-12-20 00:35:35105 direction_ = direction;
106 }
107
Ivan Rosales2803ca22022-11-02 16:46:20108 bool rtcp_mux() const { return rtcp_mux_; }
109 void set_rtcp_mux(bool mux) { rtcp_mux_ = mux; }
Steve Antonafd8e8c2017-12-20 00:35:35110
Ivan Rosales2803ca22022-11-02 16:46:20111 bool rtcp_reduced_size() const { return rtcp_reduced_size_; }
112 void set_rtcp_reduced_size(bool reduced_size) {
Steve Antonafd8e8c2017-12-20 00:35:35113 rtcp_reduced_size_ = reduced_size;
114 }
115
Sebastian Jansson97321b62019-07-24 12:01:18116 // Indicates support for the remote network estimate packet type. This
117 // functionality is experimental and subject to change without notice.
Ivan Rosales2803ca22022-11-02 16:46:20118 bool remote_estimate() const { return remote_estimate_; }
119 void set_remote_estimate(bool remote_estimate) {
Sebastian Janssone1795f42019-07-24 09:38:03120 remote_estimate_ = remote_estimate;
121 }
122
Ivan Rosales2803ca22022-11-02 16:46:20123 int bandwidth() const { return bandwidth_; }
124 void set_bandwidth(int bandwidth) { bandwidth_ = bandwidth; }
125 std::string bandwidth_type() const { return bandwidth_type_; }
126 void set_bandwidth_type(std::string bandwidth_type) {
Taylor Brandstetteree8c2462020-07-27 22:52:02127 bandwidth_type_ = bandwidth_type;
128 }
Steve Antonafd8e8c2017-12-20 00:35:35129
Ivan Rosales2803ca22022-11-02 16:46:20130 const std::vector<CryptoParams>& cryptos() const { return cryptos_; }
131 void AddCrypto(const CryptoParams& params) { cryptos_.push_back(params); }
132 void set_cryptos(const std::vector<CryptoParams>& cryptos) {
Harald Alvestrand0d018412021-11-04 13:52:31133 cryptos_ = cryptos;
134 }
135
Lennart Grahl0d0ed762021-05-17 14:06:37136 // List of RTP header extensions. URIs are **NOT** guaranteed to be unique
137 // as they can appear twice when both encrypted and non-encrypted extensions
138 // are present.
139 // Use RtpExtension::FindHeaderExtensionByUri for finding and
140 // RtpExtension::DeduplicateHeaderExtensions for filtering.
Ivan Rosales2803ca22022-11-02 16:46:20141 const RtpHeaderExtensions& rtp_header_extensions() const {
Steve Antonafd8e8c2017-12-20 00:35:35142 return rtp_header_extensions_;
143 }
Ivan Rosales2803ca22022-11-02 16:46:20144 void set_rtp_header_extensions(const RtpHeaderExtensions& extensions) {
Steve Antonafd8e8c2017-12-20 00:35:35145 rtp_header_extensions_ = extensions;
146 rtp_header_extensions_set_ = true;
147 }
Ivan Rosales2803ca22022-11-02 16:46:20148 void AddRtpHeaderExtension(const webrtc::RtpExtension& ext) {
Steve Antonafd8e8c2017-12-20 00:35:35149 rtp_header_extensions_.push_back(ext);
150 rtp_header_extensions_set_ = true;
151 }
Ivan Rosales2803ca22022-11-02 16:46:20152 void ClearRtpHeaderExtensions() {
Steve Antonafd8e8c2017-12-20 00:35:35153 rtp_header_extensions_.clear();
154 rtp_header_extensions_set_ = true;
155 }
156 // We can't always tell if an empty list of header extensions is
157 // because the other side doesn't support them, or just isn't hooked up to
158 // signal them. For now we assume an empty list means no signaling, but
159 // provide the ClearRtpHeaderExtensions method to allow "no support" to be
160 // clearly indicated (i.e. when derived from other information).
Ivan Rosales2803ca22022-11-02 16:46:20161 bool rtp_header_extensions_set() const { return rtp_header_extensions_set_; }
162 const StreamParamsVec& streams() const { return send_streams_; }
Steve Antonafd8e8c2017-12-20 00:35:35163 // TODO(pthatcher): Remove this by giving mediamessage.cc access
164 // to MediaContentDescription
Ivan Rosales2803ca22022-11-02 16:46:20165 StreamParamsVec& mutable_streams() { return send_streams_; }
166 void AddStream(const StreamParams& stream) {
Amit Hilbuchc57d5732018-12-11 23:30:11167 send_streams_.push_back(stream);
168 }
Steve Antonafd8e8c2017-12-20 00:35:35169 // Legacy streams have an ssrc, but nothing else.
170 void AddLegacyStream(uint32_t ssrc) {
Harald Alvestrand5fc28b12019-05-13 11:36:16171 AddStream(StreamParams::CreateLegacy(ssrc));
Steve Antonafd8e8c2017-12-20 00:35:35172 }
173 void AddLegacyStream(uint32_t ssrc, uint32_t fid_ssrc) {
174 StreamParams sp = StreamParams::CreateLegacy(ssrc);
175 sp.AddFidSsrc(ssrc, fid_ssrc);
Harald Alvestrand5fc28b12019-05-13 11:36:16176 AddStream(sp);
Steve Antonafd8e8c2017-12-20 00:35:35177 }
Amit Hilbuchc57d5732018-12-11 23:30:11178
Ivan Rosales2803ca22022-11-02 16:46:20179 uint32_t first_ssrc() const {
Amit Hilbuchc57d5732018-12-11 23:30:11180 if (send_streams_.empty()) {
Steve Antonafd8e8c2017-12-20 00:35:35181 return 0;
182 }
Amit Hilbuchc57d5732018-12-11 23:30:11183 return send_streams_[0].first_ssrc();
Steve Antonafd8e8c2017-12-20 00:35:35184 }
Ivan Rosales2803ca22022-11-02 16:46:20185 bool has_ssrcs() const {
Amit Hilbuchc57d5732018-12-11 23:30:11186 if (send_streams_.empty()) {
Steve Antonafd8e8c2017-12-20 00:35:35187 return false;
188 }
Amit Hilbuchc57d5732018-12-11 23:30:11189 return send_streams_[0].has_ssrcs();
Steve Antonafd8e8c2017-12-20 00:35:35190 }
191
Ivan Rosales2803ca22022-11-02 16:46:20192 void set_conference_mode(bool enable) { conference_mode_ = enable; }
193 bool conference_mode() const { return conference_mode_; }
Steve Antonafd8e8c2017-12-20 00:35:35194
195 // https://tools.ietf.org/html/rfc4566#section-5.7
196 // May be present at the media or session level of SDP. If present at both
197 // levels, the media-level attribute overwrites the session-level one.
Ivan Rosales2803ca22022-11-02 16:46:20198 void set_connection_address(const rtc::SocketAddress& address) {
Steve Antonafd8e8c2017-12-20 00:35:35199 connection_address_ = address;
200 }
Ivan Rosales2803ca22022-11-02 16:46:20201 const rtc::SocketAddress& connection_address() const {
Steve Antonafd8e8c2017-12-20 00:35:35202 return connection_address_;
203 }
204
Johannes Kron0854eb62018-10-10 20:33:20205 // Determines if it's allowed to mix one- and two-byte rtp header extensions
206 // within the same rtp stream.
Johannes Kron9581bc42018-10-23 08:17:39207 enum ExtmapAllowMixed { kNo, kSession, kMedia };
Ivan Rosales2803ca22022-11-02 16:46:20208 void set_extmap_allow_mixed_enum(ExtmapAllowMixed new_extmap_allow_mixed) {
Johannes Kron9ac3c912018-10-12 08:54:26209 if (new_extmap_allow_mixed == kMedia &&
Johannes Kron9581bc42018-10-23 08:17:39210 extmap_allow_mixed_enum_ == kSession) {
Johannes Kron0854eb62018-10-10 20:33:20211 // Do not downgrade from session level to media level.
212 return;
213 }
Johannes Kron9581bc42018-10-23 08:17:39214 extmap_allow_mixed_enum_ = new_extmap_allow_mixed;
Johannes Kron0854eb62018-10-10 20:33:20215 }
Ivan Rosales2803ca22022-11-02 16:46:20216 ExtmapAllowMixed extmap_allow_mixed_enum() const {
Johannes Kron9581bc42018-10-23 08:17:39217 return extmap_allow_mixed_enum_;
Johannes Kron9ac3c912018-10-12 08:54:26218 }
Ivan Rosales2803ca22022-11-02 16:46:20219 bool extmap_allow_mixed() const { return extmap_allow_mixed_enum_ != kNo; }
Johannes Kron0854eb62018-10-10 20:33:20220
Amit Hilbucha2012042018-12-03 19:35:05221 // Simulcast functionality.
Ivan Rosales2803ca22022-11-02 16:46:20222 bool HasSimulcast() const { return !simulcast_.empty(); }
223 SimulcastDescription& simulcast_description() { return simulcast_; }
224 const SimulcastDescription& simulcast_description() const {
Amit Hilbucha2012042018-12-03 19:35:05225 return simulcast_;
226 }
Ivan Rosales2803ca22022-11-02 16:46:20227 void set_simulcast_description(const SimulcastDescription& simulcast) {
Amit Hilbucha2012042018-12-03 19:35:05228 simulcast_ = simulcast;
229 }
Ivan Rosales2803ca22022-11-02 16:46:20230 const std::vector<RidDescription>& receive_rids() const {
Florent Castellib60141b2019-07-03 10:47:54231 return receive_rids_;
232 }
Ivan Rosales2803ca22022-11-02 16:46:20233 void set_receive_rids(const std::vector<RidDescription>& rids) {
Florent Castellib60141b2019-07-03 10:47:54234 receive_rids_ = rids;
235 }
Amit Hilbucha2012042018-12-03 19:35:05236
Steve Antonafd8e8c2017-12-20 00:35:35237 protected:
238 bool rtcp_mux_ = false;
239 bool rtcp_reduced_size_ = false;
Sebastian Janssone1795f42019-07-24 09:38:03240 bool remote_estimate_ = false;
Steve Antonafd8e8c2017-12-20 00:35:35241 int bandwidth_ = kAutoBandwidth;
Taylor Brandstetteree8c2462020-07-27 22:52:02242 std::string bandwidth_type_ = kApplicationSpecificBandwidth;
Steve Antonafd8e8c2017-12-20 00:35:35243 std::string protocol_;
Harald Alvestrand0d018412021-11-04 13:52:31244 std::vector<CryptoParams> cryptos_;
Steve Antonafd8e8c2017-12-20 00:35:35245 std::vector<webrtc::RtpExtension> rtp_header_extensions_;
246 bool rtp_header_extensions_set_ = false;
Amit Hilbuchc57d5732018-12-11 23:30:11247 StreamParamsVec send_streams_;
Steve Antonafd8e8c2017-12-20 00:35:35248 bool conference_mode_ = false;
249 webrtc::RtpTransceiverDirection direction_ =
250 webrtc::RtpTransceiverDirection::kSendRecv;
251 rtc::SocketAddress connection_address_;
Emil Lundmark801c9992021-01-19 12:06:32252 ExtmapAllowMixed extmap_allow_mixed_enum_ = kMedia;
Amit Hilbucha2012042018-12-03 19:35:05253
254 SimulcastDescription simulcast_;
Florent Castellib60141b2019-07-03 10:47:54255 std::vector<RidDescription> receive_rids_;
Bjorn A Mellem8e1343a2019-09-30 22:12:47256
Harald Alvestrand0fb07f82020-02-27 19:21:37257 private:
258 // Copy function that returns a raw pointer. Caller will assert ownership.
259 // Should only be called by the Clone() function. Must be implemented
260 // by each final subclass.
261 virtual MediaContentDescription* CloneInternal() const = 0;
Steve Antonafd8e8c2017-12-20 00:35:35262};
263
264template <class C>
265class MediaContentDescriptionImpl : public MediaContentDescription {
266 public:
Niels Möllerf1d822b2022-06-07 11:58:27267 void set_protocol(absl::string_view protocol) override {
Harald Alvestrand5fc28b12019-05-13 11:36:16268 RTC_DCHECK(IsRtpProtocol(protocol));
Niels Möllerf1d822b2022-06-07 11:58:27269 protocol_ = std::string(protocol);
Harald Alvestrand5fc28b12019-05-13 11:36:16270 }
271
Steve Antonafd8e8c2017-12-20 00:35:35272 typedef C CodecType;
273
274 // Codecs should be in preference order (most preferred codec first).
Ivan Rosales447b9f32022-11-17 20:15:31275 const std::vector<C>& codecs() const { return codecs_; }
276 void set_codecs(const std::vector<C>& codecs) { codecs_ = codecs; }
Harald Alvestrand5fc28b12019-05-13 11:36:16277 bool has_codecs() const override { return !codecs_.empty(); }
Ivan Rosales447b9f32022-11-17 20:15:31278 bool HasCodec(int id) {
Steve Antonafd8e8c2017-12-20 00:35:35279 bool found = false;
280 for (typename std::vector<C>::iterator iter = codecs_.begin();
281 iter != codecs_.end(); ++iter) {
282 if (iter->id == id) {
283 found = true;
284 break;
285 }
286 }
287 return found;
288 }
Ivan Rosales447b9f32022-11-17 20:15:31289 void AddCodec(const C& codec) { codecs_.push_back(codec); }
290 void AddOrReplaceCodec(const C& codec) {
Steve Antonafd8e8c2017-12-20 00:35:35291 for (typename std::vector<C>::iterator iter = codecs_.begin();
292 iter != codecs_.end(); ++iter) {
293 if (iter->id == codec.id) {
294 *iter = codec;
295 return;
296 }
297 }
298 AddCodec(codec);
299 }
Ivan Rosales447b9f32022-11-17 20:15:31300 void AddCodecs(const std::vector<C>& codecs) {
Steve Antonafd8e8c2017-12-20 00:35:35301 typename std::vector<C>::const_iterator codec;
302 for (codec = codecs.begin(); codec != codecs.end(); ++codec) {
303 AddCodec(*codec);
304 }
305 }
306
307 private:
308 std::vector<C> codecs_;
309};
310
311class AudioContentDescription : public MediaContentDescriptionImpl<AudioCodec> {
312 public:
313 AudioContentDescription() {}
314
Steve Antonafd8e8c2017-12-20 00:35:35315 virtual MediaType type() const { return MEDIA_TYPE_AUDIO; }
Steve Anton5adfafd2017-12-21 00:34:00316 virtual AudioContentDescription* as_audio() { return this; }
317 virtual const AudioContentDescription* as_audio() const { return this; }
Harald Alvestrand0fb07f82020-02-27 19:21:37318
319 private:
320 virtual AudioContentDescription* CloneInternal() const {
321 return new AudioContentDescription(*this);
322 }
Steve Antonafd8e8c2017-12-20 00:35:35323};
324
325class VideoContentDescription : public MediaContentDescriptionImpl<VideoCodec> {
326 public:
Steve Antonafd8e8c2017-12-20 00:35:35327 virtual MediaType type() const { return MEDIA_TYPE_VIDEO; }
Steve Anton5adfafd2017-12-21 00:34:00328 virtual VideoContentDescription* as_video() { return this; }
329 virtual const VideoContentDescription* as_video() const { return this; }
Harald Alvestrand0fb07f82020-02-27 19:21:37330
331 private:
332 virtual VideoContentDescription* CloneInternal() const {
333 return new VideoContentDescription(*this);
334 }
Steve Antonafd8e8c2017-12-20 00:35:35335};
336
Harald Alvestrand5fc28b12019-05-13 11:36:16337class SctpDataContentDescription : public MediaContentDescription {
338 public:
339 SctpDataContentDescription() {}
340 SctpDataContentDescription(const SctpDataContentDescription& o)
341 : MediaContentDescription(o),
342 use_sctpmap_(o.use_sctpmap_),
343 port_(o.port_),
Harald Alvestrandc5effc22019-06-11 09:46:59344 max_message_size_(o.max_message_size_) {}
Harald Alvestrand5fc28b12019-05-13 11:36:16345 MediaType type() const override { return MEDIA_TYPE_DATA; }
346 SctpDataContentDescription* as_sctp() override { return this; }
347 const SctpDataContentDescription* as_sctp() const override { return this; }
Harald Alvestrand5fc28b12019-05-13 11:36:16348
349 bool has_codecs() const override { return false; }
Niels Möllerf1d822b2022-06-07 11:58:27350 void set_protocol(absl::string_view protocol) override {
Harald Alvestrand5fc28b12019-05-13 11:36:16351 RTC_DCHECK(IsSctpProtocol(protocol));
Niels Möllerf1d822b2022-06-07 11:58:27352 protocol_ = std::string(protocol);
Harald Alvestrand5fc28b12019-05-13 11:36:16353 }
Steve Antonafd8e8c2017-12-20 00:35:35354
355 bool use_sctpmap() const { return use_sctpmap_; }
356 void set_use_sctpmap(bool enable) { use_sctpmap_ = enable; }
Harald Alvestrand5fc28b12019-05-13 11:36:16357 int port() const { return port_; }
358 void set_port(int port) { port_ = port; }
359 int max_message_size() const { return max_message_size_; }
360 void set_max_message_size(int max_message_size) {
361 max_message_size_ = max_message_size;
362 }
Steve Antonafd8e8c2017-12-20 00:35:35363
364 private:
Harald Alvestrand0fb07f82020-02-27 19:21:37365 SctpDataContentDescription* CloneInternal() const override {
366 return new SctpDataContentDescription(*this);
367 }
Harald Alvestrand5fc28b12019-05-13 11:36:16368 bool use_sctpmap_ = true; // Note: "true" is no longer conformant.
369 // Defaults should be constants imported from SCTP. Quick hack.
370 int port_ = 5000;
Harald Alvestrandfbb45bd2019-05-15 06:07:47371 // draft-ietf-mmusic-sdp-sctp-23: Max message size default is 64K
372 int max_message_size_ = 64 * 1024;
Steve Antonafd8e8c2017-12-20 00:35:35373};
374
Philipp Hancke4e8c1152020-10-13 10:43:15375class UnsupportedContentDescription : public MediaContentDescription {
376 public:
Niels Möllerf1d822b2022-06-07 11:58:27377 explicit UnsupportedContentDescription(absl::string_view media_type)
Philipp Hancke4e8c1152020-10-13 10:43:15378 : media_type_(media_type) {}
379 MediaType type() const override { return MEDIA_TYPE_UNSUPPORTED; }
380
381 UnsupportedContentDescription* as_unsupported() override { return this; }
382 const UnsupportedContentDescription* as_unsupported() const override {
383 return this;
384 }
385
386 bool has_codecs() const override { return false; }
387 const std::string& media_type() const { return media_type_; }
388
389 private:
390 UnsupportedContentDescription* CloneInternal() const override {
391 return new UnsupportedContentDescription(*this);
392 }
393
394 std::string media_type_;
395};
396
Steve Anton5adfafd2017-12-21 00:34:00397// Protocol used for encoding media. This is the "top level" protocol that may
398// be wrapped by zero or many transport protocols (UDP, ICE, etc.).
399enum class MediaProtocolType {
Philipp Hancke4e8c1152020-10-13 10:43:15400 kRtp, // Section will use the RTP protocol (e.g., for audio or video).
401 // https://tools.ietf.org/html/rfc3550
402 kSctp, // Section will use the SCTP protocol (e.g., for a data channel).
403 // https://tools.ietf.org/html/rfc4960
404 kOther // Section will use another top protocol which is not
405 // explicitly supported.
Steve Anton5adfafd2017-12-21 00:34:00406};
407
Steve Anton5adfafd2017-12-21 00:34:00408// Represents a session description section. Most information about the section
409// is stored in the description, which is a subclass of MediaContentDescription.
Harald Alvestrand1716d392019-06-03 18:35:45410// Owns the description.
Mirko Bonadei35214fc2019-09-23 12:54:28411class RTC_EXPORT ContentInfo {
Harald Alvestrand1716d392019-06-03 18:35:45412 public:
Steve Anton5adfafd2017-12-21 00:34:00413 explicit ContentInfo(MediaProtocolType type) : type(type) {}
Harald Alvestrand1716d392019-06-03 18:35:45414 ~ContentInfo();
415 // Copy
416 ContentInfo(const ContentInfo& o);
417 ContentInfo& operator=(const ContentInfo& o);
418 ContentInfo(ContentInfo&& o) = default;
419 ContentInfo& operator=(ContentInfo&& o) = default;
Steve Anton5adfafd2017-12-21 00:34:00420
Artem Titov880fa812021-07-30 20:30:23421 // Alias for `name`.
Steve Anton5adfafd2017-12-21 00:34:00422 std::string mid() const { return name; }
423 void set_mid(const std::string& mid) { this->name = mid; }
424
Artem Titov880fa812021-07-30 20:30:23425 // Alias for `description`.
Harald Alvestrand1716d392019-06-03 18:35:45426 MediaContentDescription* media_description();
427 const MediaContentDescription* media_description() const;
428
429 void set_media_description(std::unique_ptr<MediaContentDescription> desc) {
430 description_ = std::move(desc);
Steve Anton5adfafd2017-12-21 00:34:00431 }
432
Steve Anton81712112018-01-05 19:27:54433 // TODO(bugs.webrtc.org/8620): Rename this to mid.
Steve Anton4ab68ee2017-12-19 22:26:11434 std::string name;
Steve Anton5adfafd2017-12-21 00:34:00435 MediaProtocolType type;
Steve Anton4ab68ee2017-12-19 22:26:11436 bool rejected = false;
437 bool bundle_only = false;
Harald Alvestrand1716d392019-06-03 18:35:45438
439 private:
440 friend class SessionDescription;
441 std::unique_ptr<MediaContentDescription> description_;
Steve Anton4ab68ee2017-12-19 22:26:11442};
443
444typedef std::vector<std::string> ContentNames;
445
446// This class provides a mechanism to aggregate different media contents into a
447// group. This group can also be shared with the peers in a pre-defined format.
Artem Titov880fa812021-07-30 20:30:23448// GroupInfo should be populated only with the `content_name` of the
Steve Anton4ab68ee2017-12-19 22:26:11449// MediaDescription.
450class ContentGroup {
451 public:
452 explicit ContentGroup(const std::string& semantics);
453 ContentGroup(const ContentGroup&);
454 ContentGroup(ContentGroup&&);
455 ContentGroup& operator=(const ContentGroup&);
456 ContentGroup& operator=(ContentGroup&&);
457 ~ContentGroup();
458
459 const std::string& semantics() const { return semantics_; }
460 const ContentNames& content_names() const { return content_names_; }
461
462 const std::string* FirstContentName() const;
Niels Möllerf1d822b2022-06-07 11:58:27463 bool HasContentName(absl::string_view content_name) const;
464 void AddContentName(absl::string_view content_name);
465 bool RemoveContentName(absl::string_view content_name);
Harald Alvestrand7a2db8a2021-06-14 15:41:30466 // for debugging
467 std::string ToString() const;
Steve Anton4ab68ee2017-12-19 22:26:11468
469 private:
470 std::string semantics_;
471 ContentNames content_names_;
472};
473
474typedef std::vector<ContentInfo> ContentInfos;
475typedef std::vector<ContentGroup> ContentGroups;
476
477const ContentInfo* FindContentInfoByName(const ContentInfos& contents,
478 const std::string& name);
479const ContentInfo* FindContentInfoByType(const ContentInfos& contents,
480 const std::string& type);
481
Steve Antone831b8c2018-02-01 20:22:16482// Determines how the MSID will be signaled in the SDP. These can be used as
483// flags to indicate both or none.
484enum MsidSignaling {
485 // Signal MSID with one a=msid line in the media section.
486 kMsidSignalingMediaSection = 0x1,
487 // Signal MSID with a=ssrc: msid lines in the media section.
488 kMsidSignalingSsrcAttribute = 0x2
489};
490
Steve Anton4ab68ee2017-12-19 22:26:11491// Describes a collection of contents, each with its own name and
492// type. Analogous to a <jingle> or <session> stanza. Assumes that
493// contents are unique be name, but doesn't enforce that.
494class SessionDescription {
495 public:
496 SessionDescription();
Steve Anton4ab68ee2017-12-19 22:26:11497 ~SessionDescription();
498
Harald Alvestrand4d7160e2019-04-12 05:01:29499 std::unique_ptr<SessionDescription> Clone() const;
Steve Anton4ab68ee2017-12-19 22:26:11500
501 // Content accessors.
502 const ContentInfos& contents() const { return contents_; }
503 ContentInfos& contents() { return contents_; }
504 const ContentInfo* GetContentByName(const std::string& name) const;
505 ContentInfo* GetContentByName(const std::string& name);
Steve Antonb1c1de12017-12-21 23:14:30506 const MediaContentDescription* GetContentDescriptionByName(
Steve Anton4ab68ee2017-12-19 22:26:11507 const std::string& name) const;
Steve Antonb1c1de12017-12-21 23:14:30508 MediaContentDescription* GetContentDescriptionByName(const std::string& name);
Steve Anton5adfafd2017-12-21 00:34:00509 const ContentInfo* FirstContentByType(MediaProtocolType type) const;
Steve Anton4ab68ee2017-12-19 22:26:11510 const ContentInfo* FirstContent() const;
511
512 // Content mutators.
513 // Adds a content to this description. Takes ownership of ContentDescription*.
514 void AddContent(const std::string& name,
Steve Anton5adfafd2017-12-21 00:34:00515 MediaProtocolType type,
Harald Alvestrand1716d392019-06-03 18:35:45516 std::unique_ptr<MediaContentDescription> description);
Steve Anton4ab68ee2017-12-19 22:26:11517 void AddContent(const std::string& name,
Steve Anton5adfafd2017-12-21 00:34:00518 MediaProtocolType type,
Steve Anton4ab68ee2017-12-19 22:26:11519 bool rejected,
Harald Alvestrand1716d392019-06-03 18:35:45520 std::unique_ptr<MediaContentDescription> description);
Steve Anton4ab68ee2017-12-19 22:26:11521 void AddContent(const std::string& name,
Steve Anton5adfafd2017-12-21 00:34:00522 MediaProtocolType type,
Steve Anton4ab68ee2017-12-19 22:26:11523 bool rejected,
524 bool bundle_only,
Harald Alvestrand1716d392019-06-03 18:35:45525 std::unique_ptr<MediaContentDescription> description);
526 void AddContent(ContentInfo&& content);
Johannes Kron9ac3c912018-10-12 08:54:26527
Steve Anton4ab68ee2017-12-19 22:26:11528 bool RemoveContentByName(const std::string& name);
529
530 // Transport accessors.
531 const TransportInfos& transport_infos() const { return transport_infos_; }
532 TransportInfos& transport_infos() { return transport_infos_; }
533 const TransportInfo* GetTransportInfoByName(const std::string& name) const;
534 TransportInfo* GetTransportInfoByName(const std::string& name);
535 const TransportDescription* GetTransportDescriptionByName(
536 const std::string& name) const {
537 const TransportInfo* tinfo = GetTransportInfoByName(name);
538 return tinfo ? &tinfo->description : NULL;
539 }
540
541 // Transport mutators.
542 void set_transport_infos(const TransportInfos& transport_infos) {
543 transport_infos_ = transport_infos;
544 }
545 // Adds a TransportInfo to this description.
Steve Anton06817cd2018-12-18 23:55:30546 void AddTransportInfo(const TransportInfo& transport_info);
Steve Anton4ab68ee2017-12-19 22:26:11547 bool RemoveTransportInfoByName(const std::string& name);
548
549 // Group accessors.
550 const ContentGroups& groups() const { return content_groups_; }
551 const ContentGroup* GetGroupByName(const std::string& name) const;
Henrik Boströmf8187e02021-04-26 19:04:26552 std::vector<const ContentGroup*> GetGroupsByName(
553 const std::string& name) const;
Steve Anton4ab68ee2017-12-19 22:26:11554 bool HasGroup(const std::string& name) const;
555
556 // Group mutators.
557 void AddGroup(const ContentGroup& group) { content_groups_.push_back(group); }
Artem Titov880fa812021-07-30 20:30:23558 // Remove the first group with the same semantics specified by `name`.
Steve Anton4ab68ee2017-12-19 22:26:11559 void RemoveGroupByName(const std::string& name);
560
561 // Global attributes.
562 void set_msid_supported(bool supported) { msid_supported_ = supported; }
563 bool msid_supported() const { return msid_supported_; }
564
Steve Antone831b8c2018-02-01 20:22:16565 // Determines how the MSIDs were/will be signaled. Flag value composed of
566 // MsidSignaling bits (see enum above).
567 void set_msid_signaling(int msid_signaling) {
568 msid_signaling_ = msid_signaling;
569 }
570 int msid_signaling() const { return msid_signaling_; }
571
Johannes Kron0854eb62018-10-10 20:33:20572 // Determines if it's allowed to mix one- and two-byte rtp header extensions
573 // within the same rtp stream.
Johannes Kron9581bc42018-10-23 08:17:39574 void set_extmap_allow_mixed(bool supported) {
575 extmap_allow_mixed_ = supported;
576 MediaContentDescription::ExtmapAllowMixed media_level_setting =
Johannes Kron0854eb62018-10-10 20:33:20577 supported ? MediaContentDescription::kSession
578 : MediaContentDescription::kNo;
579 for (auto& content : contents_) {
Johannes Kron9ac3c912018-10-12 08:54:26580 // Do not set to kNo if the current setting is kMedia.
Johannes Kron9581bc42018-10-23 08:17:39581 if (supported || content.media_description()->extmap_allow_mixed_enum() !=
582 MediaContentDescription::kMedia) {
583 content.media_description()->set_extmap_allow_mixed_enum(
Johannes Kron9ac3c912018-10-12 08:54:26584 media_level_setting);
585 }
Johannes Kron0854eb62018-10-10 20:33:20586 }
587 }
Johannes Kron9581bc42018-10-23 08:17:39588 bool extmap_allow_mixed() const { return extmap_allow_mixed_; }
Johannes Kron0854eb62018-10-10 20:33:20589
Steve Anton4ab68ee2017-12-19 22:26:11590 private:
591 SessionDescription(const SessionDescription&);
592
593 ContentInfos contents_;
594 TransportInfos transport_infos_;
595 ContentGroups content_groups_;
596 bool msid_supported_ = true;
Steve Antone831b8c2018-02-01 20:22:16597 // Default to what Plan B would do.
598 // TODO(bugs.webrtc.org/8530): Change default to kMsidSignalingMediaSection.
599 int msid_signaling_ = kMsidSignalingSsrcAttribute;
Emil Lundmark801c9992021-01-19 12:06:32600 bool extmap_allow_mixed_ = true;
Steve Anton4ab68ee2017-12-19 22:26:11601};
602
Steve Antonb1c1de12017-12-21 23:14:30603// Indicates whether a session description was sent by the local client or
604// received from the remote client.
Steve Anton4ab68ee2017-12-19 22:26:11605enum ContentSource { CS_LOCAL, CS_REMOTE };
606
607} // namespace cricket
608
Steve Anton10542f22019-01-11 17:11:00609#endif // PC_SESSION_DESCRIPTION_H_