diff options
Diffstat (limited to 'third_party/libwebrtc/pc/session_description.h')
| -rw-r--r-- | third_party/libwebrtc/pc/session_description.h | 620 |
1 files changed, 620 insertions, 0 deletions
diff --git a/third_party/libwebrtc/pc/session_description.h b/third_party/libwebrtc/pc/session_description.h new file mode 100644 index 0000000000..a7259e1f1d --- /dev/null +++ b/third_party/libwebrtc/pc/session_description.h @@ -0,0 +1,620 @@ +/* + * Copyright 2004 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef PC_SESSION_DESCRIPTION_H_ +#define PC_SESSION_DESCRIPTION_H_ + +#include <stddef.h> +#include <stdint.h> + +#include <algorithm> +#include <memory> +#include <string> +#include <type_traits> +#include <utility> +#include <vector> + +#include "absl/memory/memory.h" +#include "absl/strings/string_view.h" +#include "api/crypto_params.h" +#include "api/media_types.h" +#include "api/rtp_parameters.h" +#include "api/rtp_transceiver_direction.h" +#include "api/rtp_transceiver_interface.h" +#include "media/base/codec.h" +#include "media/base/media_channel.h" +#include "media/base/media_constants.h" +#include "media/base/rid_description.h" +#include "media/base/stream_params.h" +#include "p2p/base/transport_description.h" +#include "p2p/base/transport_info.h" +#include "pc/media_protocol_names.h" +#include "pc/simulcast_description.h" +#include "rtc_base/checks.h" +#include "rtc_base/socket_address.h" +#include "rtc_base/system/rtc_export.h" + +namespace cricket { + +typedef std::vector<AudioCodec> AudioCodecs; +typedef std::vector<VideoCodec> VideoCodecs; +typedef std::vector<CryptoParams> CryptoParamsVec; +typedef std::vector<webrtc::RtpExtension> RtpHeaderExtensions; + +// Options to control how session descriptions are generated. +const int kAutoBandwidth = -1; + +class AudioContentDescription; +class VideoContentDescription; +class SctpDataContentDescription; +class UnsupportedContentDescription; + +// Describes a session description media section. There are subclasses for each +// media type (audio, video, data) that will have additional information. +class MediaContentDescription { + public: + MediaContentDescription() = default; + virtual ~MediaContentDescription() = default; + + virtual MediaType type() const = 0; + + // Try to cast this media description to an AudioContentDescription. Returns + // nullptr if the cast fails. + virtual AudioContentDescription* as_audio() { return nullptr; } + virtual const AudioContentDescription* as_audio() const { return nullptr; } + + // Try to cast this media description to a VideoContentDescription. Returns + // nullptr if the cast fails. + virtual VideoContentDescription* as_video() { return nullptr; } + virtual const VideoContentDescription* as_video() const { return nullptr; } + + virtual SctpDataContentDescription* as_sctp() { return nullptr; } + virtual const SctpDataContentDescription* as_sctp() const { return nullptr; } + + virtual UnsupportedContentDescription* as_unsupported() { return nullptr; } + virtual const UnsupportedContentDescription* as_unsupported() const { + return nullptr; + } + + virtual bool has_codecs() const = 0; + + // Copy operator that returns an unique_ptr. + // Not a virtual function. + // If a type-specific variant of Clone() is desired, override it, or + // simply use std::make_unique<typename>(*this) instead of Clone(). + std::unique_ptr<MediaContentDescription> Clone() const { + return absl::WrapUnique(CloneInternal()); + } + + // `protocol` is the expected media transport protocol, such as RTP/AVPF, + // RTP/SAVPF or SCTP/DTLS. + virtual std::string protocol() const { return protocol_; } + virtual void set_protocol(absl::string_view protocol) { + protocol_ = std::string(protocol); + } + + virtual webrtc::RtpTransceiverDirection direction() const { + return direction_; + } + virtual void set_direction(webrtc::RtpTransceiverDirection direction) { + direction_ = direction; + } + + virtual bool rtcp_mux() const { return rtcp_mux_; } + virtual void set_rtcp_mux(bool mux) { rtcp_mux_ = mux; } + + virtual bool rtcp_reduced_size() const { return rtcp_reduced_size_; } + virtual void set_rtcp_reduced_size(bool reduced_size) { + rtcp_reduced_size_ = reduced_size; + } + + // Indicates support for the remote network estimate packet type. This + // functionality is experimental and subject to change without notice. + virtual bool remote_estimate() const { return remote_estimate_; } + virtual void set_remote_estimate(bool remote_estimate) { + remote_estimate_ = remote_estimate; + } + + virtual int bandwidth() const { return bandwidth_; } + virtual void set_bandwidth(int bandwidth) { bandwidth_ = bandwidth; } + virtual std::string bandwidth_type() const { return bandwidth_type_; } + virtual void set_bandwidth_type(std::string bandwidth_type) { + bandwidth_type_ = bandwidth_type; + } + + virtual const std::vector<CryptoParams>& cryptos() const { return cryptos_; } + virtual void AddCrypto(const CryptoParams& params) { + cryptos_.push_back(params); + } + virtual void set_cryptos(const std::vector<CryptoParams>& cryptos) { + cryptos_ = cryptos; + } + + // List of RTP header extensions. URIs are **NOT** guaranteed to be unique + // as they can appear twice when both encrypted and non-encrypted extensions + // are present. + // Use RtpExtension::FindHeaderExtensionByUri for finding and + // RtpExtension::DeduplicateHeaderExtensions for filtering. + virtual const RtpHeaderExtensions& rtp_header_extensions() const { + return rtp_header_extensions_; + } + virtual void set_rtp_header_extensions( + const RtpHeaderExtensions& extensions) { + rtp_header_extensions_ = extensions; + rtp_header_extensions_set_ = true; + } + virtual void AddRtpHeaderExtension(const webrtc::RtpExtension& ext) { + rtp_header_extensions_.push_back(ext); + rtp_header_extensions_set_ = true; + } + virtual void ClearRtpHeaderExtensions() { + rtp_header_extensions_.clear(); + rtp_header_extensions_set_ = true; + } + // We can't always tell if an empty list of header extensions is + // because the other side doesn't support them, or just isn't hooked up to + // signal them. For now we assume an empty list means no signaling, but + // provide the ClearRtpHeaderExtensions method to allow "no support" to be + // clearly indicated (i.e. when derived from other information). + virtual bool rtp_header_extensions_set() const { + return rtp_header_extensions_set_; + } + virtual const StreamParamsVec& streams() const { return send_streams_; } + // TODO(pthatcher): Remove this by giving mediamessage.cc access + // to MediaContentDescription + virtual StreamParamsVec& mutable_streams() { return send_streams_; } + virtual void AddStream(const StreamParams& stream) { + send_streams_.push_back(stream); + } + // Legacy streams have an ssrc, but nothing else. + void AddLegacyStream(uint32_t ssrc) { + AddStream(StreamParams::CreateLegacy(ssrc)); + } + void AddLegacyStream(uint32_t ssrc, uint32_t fid_ssrc) { + StreamParams sp = StreamParams::CreateLegacy(ssrc); + sp.AddFidSsrc(ssrc, fid_ssrc); + AddStream(sp); + } + + virtual uint32_t first_ssrc() const { + if (send_streams_.empty()) { + return 0; + } + return send_streams_[0].first_ssrc(); + } + virtual bool has_ssrcs() const { + if (send_streams_.empty()) { + return false; + } + return send_streams_[0].has_ssrcs(); + } + + virtual void set_conference_mode(bool enable) { conference_mode_ = enable; } + virtual bool conference_mode() const { return conference_mode_; } + + // https://tools.ietf.org/html/rfc4566#section-5.7 + // May be present at the media or session level of SDP. If present at both + // levels, the media-level attribute overwrites the session-level one. + virtual void set_connection_address(const rtc::SocketAddress& address) { + connection_address_ = address; + } + virtual const rtc::SocketAddress& connection_address() const { + return connection_address_; + } + + // Determines if it's allowed to mix one- and two-byte rtp header extensions + // within the same rtp stream. + enum ExtmapAllowMixed { kNo, kSession, kMedia }; + virtual void set_extmap_allow_mixed_enum( + ExtmapAllowMixed new_extmap_allow_mixed) { + if (new_extmap_allow_mixed == kMedia && + extmap_allow_mixed_enum_ == kSession) { + // Do not downgrade from session level to media level. + return; + } + extmap_allow_mixed_enum_ = new_extmap_allow_mixed; + } + virtual ExtmapAllowMixed extmap_allow_mixed_enum() const { + return extmap_allow_mixed_enum_; + } + virtual bool extmap_allow_mixed() const { + return extmap_allow_mixed_enum_ != kNo; + } + + // Simulcast functionality. + virtual bool HasSimulcast() const { return !simulcast_.empty(); } + virtual SimulcastDescription& simulcast_description() { return simulcast_; } + virtual const SimulcastDescription& simulcast_description() const { + return simulcast_; + } + virtual void set_simulcast_description( + const SimulcastDescription& simulcast) { + simulcast_ = simulcast; + } + virtual const std::vector<RidDescription>& receive_rids() const { + return receive_rids_; + } + virtual void set_receive_rids(const std::vector<RidDescription>& rids) { + receive_rids_ = rids; + } + + protected: + bool rtcp_mux_ = false; + bool rtcp_reduced_size_ = false; + bool remote_estimate_ = false; + int bandwidth_ = kAutoBandwidth; + std::string bandwidth_type_ = kApplicationSpecificBandwidth; + std::string protocol_; + std::vector<CryptoParams> cryptos_; + std::vector<webrtc::RtpExtension> rtp_header_extensions_; + bool rtp_header_extensions_set_ = false; + StreamParamsVec send_streams_; + bool conference_mode_ = false; + webrtc::RtpTransceiverDirection direction_ = + webrtc::RtpTransceiverDirection::kSendRecv; + rtc::SocketAddress connection_address_; + ExtmapAllowMixed extmap_allow_mixed_enum_ = kMedia; + + SimulcastDescription simulcast_; + std::vector<RidDescription> receive_rids_; + + private: + // Copy function that returns a raw pointer. Caller will assert ownership. + // Should only be called by the Clone() function. Must be implemented + // by each final subclass. + virtual MediaContentDescription* CloneInternal() const = 0; +}; + +template <class C> +class MediaContentDescriptionImpl : public MediaContentDescription { + public: + void set_protocol(absl::string_view protocol) override { + RTC_DCHECK(IsRtpProtocol(protocol)); + protocol_ = std::string(protocol); + } + + typedef C CodecType; + + // Codecs should be in preference order (most preferred codec first). + virtual const std::vector<C>& codecs() const { return codecs_; } + virtual void set_codecs(const std::vector<C>& codecs) { codecs_ = codecs; } + bool has_codecs() const override { return !codecs_.empty(); } + virtual bool HasCodec(int id) { + bool found = false; + for (typename std::vector<C>::iterator iter = codecs_.begin(); + iter != codecs_.end(); ++iter) { + if (iter->id == id) { + found = true; + break; + } + } + return found; + } + virtual void AddCodec(const C& codec) { codecs_.push_back(codec); } + virtual void AddOrReplaceCodec(const C& codec) { + for (typename std::vector<C>::iterator iter = codecs_.begin(); + iter != codecs_.end(); ++iter) { + if (iter->id == codec.id) { + *iter = codec; + return; + } + } + AddCodec(codec); + } + virtual void AddCodecs(const std::vector<C>& codecs) { + typename std::vector<C>::const_iterator codec; + for (codec = codecs.begin(); codec != codecs.end(); ++codec) { + AddCodec(*codec); + } + } + + private: + std::vector<C> codecs_; +}; + +class AudioContentDescription : public MediaContentDescriptionImpl<AudioCodec> { + public: + AudioContentDescription() {} + + virtual MediaType type() const { return MEDIA_TYPE_AUDIO; } + virtual AudioContentDescription* as_audio() { return this; } + virtual const AudioContentDescription* as_audio() const { return this; } + + private: + virtual AudioContentDescription* CloneInternal() const { + return new AudioContentDescription(*this); + } +}; + +class VideoContentDescription : public MediaContentDescriptionImpl<VideoCodec> { + public: + virtual MediaType type() const { return MEDIA_TYPE_VIDEO; } + virtual VideoContentDescription* as_video() { return this; } + virtual const VideoContentDescription* as_video() const { return this; } + + private: + virtual VideoContentDescription* CloneInternal() const { + return new VideoContentDescription(*this); + } +}; + +class SctpDataContentDescription : public MediaContentDescription { + public: + SctpDataContentDescription() {} + SctpDataContentDescription(const SctpDataContentDescription& o) + : MediaContentDescription(o), + use_sctpmap_(o.use_sctpmap_), + port_(o.port_), + max_message_size_(o.max_message_size_) {} + MediaType type() const override { return MEDIA_TYPE_DATA; } + SctpDataContentDescription* as_sctp() override { return this; } + const SctpDataContentDescription* as_sctp() const override { return this; } + + bool has_codecs() const override { return false; } + void set_protocol(absl::string_view protocol) override { + RTC_DCHECK(IsSctpProtocol(protocol)); + protocol_ = std::string(protocol); + } + + bool use_sctpmap() const { return use_sctpmap_; } + void set_use_sctpmap(bool enable) { use_sctpmap_ = enable; } + int port() const { return port_; } + void set_port(int port) { port_ = port; } + int max_message_size() const { return max_message_size_; } + void set_max_message_size(int max_message_size) { + max_message_size_ = max_message_size; + } + + private: + SctpDataContentDescription* CloneInternal() const override { + return new SctpDataContentDescription(*this); + } + bool use_sctpmap_ = true; // Note: "true" is no longer conformant. + // Defaults should be constants imported from SCTP. Quick hack. + int port_ = 5000; + // draft-ietf-mmusic-sdp-sctp-23: Max message size default is 64K + int max_message_size_ = 64 * 1024; +}; + +class UnsupportedContentDescription : public MediaContentDescription { + public: + explicit UnsupportedContentDescription(absl::string_view media_type) + : media_type_(media_type) {} + MediaType type() const override { return MEDIA_TYPE_UNSUPPORTED; } + + UnsupportedContentDescription* as_unsupported() override { return this; } + const UnsupportedContentDescription* as_unsupported() const override { + return this; + } + + bool has_codecs() const override { return false; } + const std::string& media_type() const { return media_type_; } + + private: + UnsupportedContentDescription* CloneInternal() const override { + return new UnsupportedContentDescription(*this); + } + + std::string media_type_; +}; + +// Protocol used for encoding media. This is the "top level" protocol that may +// be wrapped by zero or many transport protocols (UDP, ICE, etc.). +enum class MediaProtocolType { + kRtp, // Section will use the RTP protocol (e.g., for audio or video). + // https://tools.ietf.org/html/rfc3550 + kSctp, // Section will use the SCTP protocol (e.g., for a data channel). + // https://tools.ietf.org/html/rfc4960 + kOther // Section will use another top protocol which is not + // explicitly supported. +}; + +// Represents a session description section. Most information about the section +// is stored in the description, which is a subclass of MediaContentDescription. +// Owns the description. +class RTC_EXPORT ContentInfo { + public: + explicit ContentInfo(MediaProtocolType type) : type(type) {} + ~ContentInfo(); + // Copy + ContentInfo(const ContentInfo& o); + ContentInfo& operator=(const ContentInfo& o); + ContentInfo(ContentInfo&& o) = default; + ContentInfo& operator=(ContentInfo&& o) = default; + + // Alias for `name`. + std::string mid() const { return name; } + void set_mid(const std::string& mid) { this->name = mid; } + + // Alias for `description`. + MediaContentDescription* media_description(); + const MediaContentDescription* media_description() const; + + void set_media_description(std::unique_ptr<MediaContentDescription> desc) { + description_ = std::move(desc); + } + + // TODO(bugs.webrtc.org/8620): Rename this to mid. + std::string name; + MediaProtocolType type; + bool rejected = false; + bool bundle_only = false; + + private: + friend class SessionDescription; + std::unique_ptr<MediaContentDescription> description_; +}; + +typedef std::vector<std::string> ContentNames; + +// This class provides a mechanism to aggregate different media contents into a +// group. This group can also be shared with the peers in a pre-defined format. +// GroupInfo should be populated only with the `content_name` of the +// MediaDescription. +class ContentGroup { + public: + explicit ContentGroup(const std::string& semantics); + ContentGroup(const ContentGroup&); + ContentGroup(ContentGroup&&); + ContentGroup& operator=(const ContentGroup&); + ContentGroup& operator=(ContentGroup&&); + ~ContentGroup(); + + const std::string& semantics() const { return semantics_; } + const ContentNames& content_names() const { return content_names_; } + + const std::string* FirstContentName() const; + bool HasContentName(absl::string_view content_name) const; + void AddContentName(absl::string_view content_name); + bool RemoveContentName(absl::string_view content_name); + // for debugging + std::string ToString() const; + + private: + std::string semantics_; + ContentNames content_names_; +}; + +typedef std::vector<ContentInfo> ContentInfos; +typedef std::vector<ContentGroup> ContentGroups; + +const ContentInfo* FindContentInfoByName(const ContentInfos& contents, + const std::string& name); +const ContentInfo* FindContentInfoByType(const ContentInfos& contents, + const std::string& type); + +// Determines how the MSID will be signaled in the SDP. These can be used as +// flags to indicate both or none. +enum MsidSignaling { + // Signal MSID with one a=msid line in the media section. + kMsidSignalingMediaSection = 0x1, + // Signal MSID with a=ssrc: msid lines in the media section. + kMsidSignalingSsrcAttribute = 0x2 +}; + +// Describes a collection of contents, each with its own name and +// type. Analogous to a <jingle> or <session> stanza. Assumes that +// contents are unique be name, but doesn't enforce that. +class SessionDescription { + public: + SessionDescription(); + ~SessionDescription(); + + std::unique_ptr<SessionDescription> Clone() const; + + // Content accessors. + const ContentInfos& contents() const { return contents_; } + ContentInfos& contents() { return contents_; } + const ContentInfo* GetContentByName(const std::string& name) const; + ContentInfo* GetContentByName(const std::string& name); + const MediaContentDescription* GetContentDescriptionByName( + const std::string& name) const; + MediaContentDescription* GetContentDescriptionByName(const std::string& name); + const ContentInfo* FirstContentByType(MediaProtocolType type) const; + const ContentInfo* FirstContent() const; + + // Content mutators. + // Adds a content to this description. Takes ownership of ContentDescription*. + void AddContent(const std::string& name, + MediaProtocolType type, + std::unique_ptr<MediaContentDescription> description); + void AddContent(const std::string& name, + MediaProtocolType type, + bool rejected, + std::unique_ptr<MediaContentDescription> description); + void AddContent(const std::string& name, + MediaProtocolType type, + bool rejected, + bool bundle_only, + std::unique_ptr<MediaContentDescription> description); + void AddContent(ContentInfo&& content); + + bool RemoveContentByName(const std::string& name); + + // Transport accessors. + const TransportInfos& transport_infos() const { return transport_infos_; } + TransportInfos& transport_infos() { return transport_infos_; } + const TransportInfo* GetTransportInfoByName(const std::string& name) const; + TransportInfo* GetTransportInfoByName(const std::string& name); + const TransportDescription* GetTransportDescriptionByName( + const std::string& name) const { + const TransportInfo* tinfo = GetTransportInfoByName(name); + return tinfo ? &tinfo->description : NULL; + } + + // Transport mutators. + void set_transport_infos(const TransportInfos& transport_infos) { + transport_infos_ = transport_infos; + } + // Adds a TransportInfo to this description. + void AddTransportInfo(const TransportInfo& transport_info); + bool RemoveTransportInfoByName(const std::string& name); + + // Group accessors. + const ContentGroups& groups() const { return content_groups_; } + const ContentGroup* GetGroupByName(const std::string& name) const; + std::vector<const ContentGroup*> GetGroupsByName( + const std::string& name) const; + bool HasGroup(const std::string& name) const; + + // Group mutators. + void AddGroup(const ContentGroup& group) { content_groups_.push_back(group); } + // Remove the first group with the same semantics specified by `name`. + void RemoveGroupByName(const std::string& name); + + // Global attributes. + void set_msid_supported(bool supported) { msid_supported_ = supported; } + bool msid_supported() const { return msid_supported_; } + + // Determines how the MSIDs were/will be signaled. Flag value composed of + // MsidSignaling bits (see enum above). + void set_msid_signaling(int msid_signaling) { + msid_signaling_ = msid_signaling; + } + int msid_signaling() const { return msid_signaling_; } + + // Determines if it's allowed to mix one- and two-byte rtp header extensions + // within the same rtp stream. + void set_extmap_allow_mixed(bool supported) { + extmap_allow_mixed_ = supported; + MediaContentDescription::ExtmapAllowMixed media_level_setting = + supported ? MediaContentDescription::kSession + : MediaContentDescription::kNo; + for (auto& content : contents_) { + // Do not set to kNo if the current setting is kMedia. + if (supported || content.media_description()->extmap_allow_mixed_enum() != + MediaContentDescription::kMedia) { + content.media_description()->set_extmap_allow_mixed_enum( + media_level_setting); + } + } + } + bool extmap_allow_mixed() const { return extmap_allow_mixed_; } + + private: + SessionDescription(const SessionDescription&); + + ContentInfos contents_; + TransportInfos transport_infos_; + ContentGroups content_groups_; + bool msid_supported_ = true; + // Default to what Plan B would do. + // TODO(bugs.webrtc.org/8530): Change default to kMsidSignalingMediaSection. + int msid_signaling_ = kMsidSignalingSsrcAttribute; + bool extmap_allow_mixed_ = true; +}; + +// Indicates whether a session description was sent by the local client or +// received from the remote client. +enum ContentSource { CS_LOCAL, CS_REMOTE }; + +} // namespace cricket + +#endif // PC_SESSION_DESCRIPTION_H_ |