media_session.h - mozsearch

/*

 *  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.

*/

// Types and classes used in media session descriptions.

#ifndef PC_MEDIA_SESSION_H_

#define PC_MEDIA_SESSION_H_

#include <memory>

#include <string>

#include <vector>

#include "api/crypto/crypto_options.h"

#include "api/media_types.h"

#include "api/rtc_error.h"

#include "api/rtp_parameters.h"

#include "api/rtp_transceiver_direction.h"

#include "media/base/codec.h"

#include "media/base/rid_description.h"

#include "media/base/stream_params.h"

#include "p2p/base/ice_credentials_iterator.h"

#include "p2p/base/transport_description.h"

#include "p2p/base/transport_description_factory.h"

#include "p2p/base/transport_info.h"

#include "pc/session_description.h"

#include "pc/simulcast_description.h"

#include "rtc_base/memory/always_valid_pointer.h"

#include "rtc_base/unique_id_generator.h"

namespace webrtc {

// Forward declaration due to circular dependecy.

class ConnectionContext;

}  // namespace webrtc

namespace cricket {

class MediaEngineInterface;

// Default RTCP CNAME for unit tests.

const char kDefaultRtcpCname[] = "DefaultRtcpCname";

// Options for an RtpSender contained with an media description/"m=" section.

// Note: Spec-compliant Simulcast and legacy simulcast are mutually exclusive.

struct SenderOptions {

  std::string track_id;

  std::vector<std::string> stream_ids;

  // Use RIDs and Simulcast Layers to indicate spec-compliant Simulcast.

  std::vector<RidDescription> rids;

  SimulcastLayerList simulcast_layers;

  // Use `num_sim_layers` to indicate legacy simulcast.

  int num_sim_layers;

};

// Options for an individual media description/"m=" section.

struct MediaDescriptionOptions {

  MediaDescriptionOptions(MediaType type,

                          const std::string& mid,

                          webrtc::RtpTransceiverDirection direction,

                          bool stopped)

      : type(type), mid(mid), direction(direction), stopped(stopped) {}

  // TODO(deadbeef): When we don't support Plan B, there will only be one

  // sender per media description and this can be simplified.

  void AddAudioSender(const std::string& track_id,

                      const std::vector<std::string>& stream_ids);

  void AddVideoSender(const std::string& track_id,

                      const std::vector<std::string>& stream_ids,

                      const std::vector<RidDescription>& rids,

                      const SimulcastLayerList& simulcast_layers,

                      int num_sim_layers);

  MediaType type;

  std::string mid;

  webrtc::RtpTransceiverDirection direction;

  bool stopped;

  TransportOptions transport_options;

  // Note: There's no equivalent "RtpReceiverOptions" because only send

  // stream information goes in the local descriptions.

  std::vector<SenderOptions> sender_options;

  std::vector<webrtc::RtpCodecCapability> codec_preferences;

  std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions;

  // Codecs to include in a generated offer or answer.

  // If this is used, session-level codec lists MUST be ignored.

  std::vector<Codec> codecs_to_include;

 private:

  // Doesn't DCHECK on `type`.

  void AddSenderInternal(const std::string& track_id,

                         const std::vector<std::string>& stream_ids,

                         const std::vector<RidDescription>& rids,

                         const SimulcastLayerList& simulcast_layers,

                         int num_sim_layers);

};

// Provides a mechanism for describing how m= sections should be generated.

// The m= section with index X will use media_description_options[X]. There

// must be an option for each existing section if creating an answer, or a

// subsequent offer.

struct MediaSessionOptions {

  MediaSessionOptions() {}

  bool has_audio() const { return HasMediaDescription(MEDIA_TYPE_AUDIO); }

  bool has_video() const { return HasMediaDescription(MEDIA_TYPE_VIDEO); }

  bool has_data() const { return HasMediaDescription(MEDIA_TYPE_DATA); }

  bool HasMediaDescription(MediaType type) const;

  bool vad_enabled = true;  // When disabled, removes all CN codecs from SDP.

  bool rtcp_mux_enabled = true;

  bool bundle_enabled = false;

  bool offer_extmap_allow_mixed = false;

  bool raw_packetization_for_video = false;

  std::string rtcp_cname = kDefaultRtcpCname;

  webrtc::CryptoOptions crypto_options;

  // List of media description options in the same order that the media

  // descriptions will be generated.

  std::vector<MediaDescriptionOptions> media_description_options;

  std::vector<IceParameters> pooled_ice_credentials;

  // Use the draft-ietf-mmusic-sctp-sdp-03 obsolete syntax for SCTP

  // datachannels.

  // Default is true for backwards compatibility with clients that use

  // this internal interface.

  bool use_obsolete_sctp_sdp = true;

};

// Creates media session descriptions according to the supplied codecs and

// other fields, as well as the supplied per-call options.

// When creating answers, performs the appropriate negotiation

// of the various fields to determine the proper result.

class MediaSessionDescriptionFactory {

 public:

  // This constructor automatically sets up the factory to get its configuration

  // from the specified MediaEngine (when provided).

  // The TransportDescriptionFactory and the UniqueRandomIdGenerator are not

  // owned by MediaSessionDescriptionFactory, so they must be kept alive by the

  // user of this class.

  MediaSessionDescriptionFactory(cricket::MediaEngineInterface* media_engine,

                                 bool rtx_enabled,

                                 rtc::UniqueRandomIdGenerator* ssrc_generator,

                                 const TransportDescriptionFactory* factory);

  const Codecs& audio_sendrecv_codecs() const;

  const Codecs& audio_send_codecs() const;

  const Codecs& audio_recv_codecs() const;

  void set_audio_codecs(const Codecs& send_codecs, const Codecs& recv_codecs);

  const Codecs& video_sendrecv_codecs() const;

  const Codecs& video_send_codecs() const;

  const Codecs& video_recv_codecs() const;

  void set_video_codecs(const Codecs& send_codecs, const Codecs& recv_codecs);

  RtpHeaderExtensions filtered_rtp_header_extensions(

      RtpHeaderExtensions extensions) const;

  void set_enable_encrypted_rtp_header_extensions(bool enable) {

    enable_encrypted_rtp_header_extensions_ = enable;

  void set_is_unified_plan(bool is_unified_plan) {

    is_unified_plan_ = is_unified_plan;

  webrtc::RTCErrorOr<std::unique_ptr<SessionDescription>> CreateOfferOrError(

      const MediaSessionOptions& options,

      const SessionDescription* current_description) const;

  webrtc::RTCErrorOr<std::unique_ptr<SessionDescription>> CreateAnswerOrError(

      const SessionDescription* offer,

      const MediaSessionOptions& options,

      const SessionDescription* current_description) const;

 private:

  struct AudioVideoRtpHeaderExtensions {

    RtpHeaderExtensions audio;

    RtpHeaderExtensions video;

};

  const Codecs& GetAudioCodecsForOffer(

      const webrtc::RtpTransceiverDirection& direction) const;

  const Codecs& GetAudioCodecsForAnswer(

      const webrtc::RtpTransceiverDirection& offer,

      const webrtc::RtpTransceiverDirection& answer) const;

  const Codecs& GetVideoCodecsForOffer(

      const webrtc::RtpTransceiverDirection& direction) const;

  const Codecs& GetVideoCodecsForAnswer(

      const webrtc::RtpTransceiverDirection& offer,

      const webrtc::RtpTransceiverDirection& answer) const;

  void GetCodecsForOffer(

      const std::vector<const ContentInfo*>& current_active_contents,

      Codecs* audio_codecs,

      Codecs* video_codecs) const;

  void GetCodecsForAnswer(

      const std::vector<const ContentInfo*>& current_active_contents,

      const SessionDescription& remote_offer,

      Codecs* audio_codecs,

      Codecs* video_codecs) const;

  AudioVideoRtpHeaderExtensions GetOfferedRtpHeaderExtensionsWithIds(

      const std::vector<const ContentInfo*>& current_active_contents,

      bool extmap_allow_mixed,

      const std::vector<MediaDescriptionOptions>& media_description_options)

      const;

  webrtc::RTCError AddTransportOffer(

      const std::string& content_name,

      const TransportOptions& transport_options,

      const SessionDescription* current_desc,

      SessionDescription* offer,

      IceCredentialsIterator* ice_credentials) const;

  std::unique_ptr<TransportDescription> CreateTransportAnswer(

      const std::string& content_name,

      const SessionDescription* offer_desc,

      const TransportOptions& transport_options,

      const SessionDescription* current_desc,

      bool require_transport_attributes,

      IceCredentialsIterator* ice_credentials) const;

  webrtc::RTCError AddTransportAnswer(

      const std::string& content_name,

      const TransportDescription& transport_desc,

      SessionDescription* answer_desc) const;

  // Helpers for adding media contents to the SessionDescription.

  webrtc::RTCError AddRtpContentForOffer(

      const MediaDescriptionOptions& media_description_options,

      const MediaSessionOptions& session_options,

      const ContentInfo* current_content,

      const SessionDescription* current_description,

      const RtpHeaderExtensions& header_extensions,

      const std::vector<Codec>& codecs,

      StreamParamsVec* current_streams,

      SessionDescription* desc,

      IceCredentialsIterator* ice_credentials) const;

  webrtc::RTCError AddDataContentForOffer(

      const MediaDescriptionOptions& media_description_options,

      const MediaSessionOptions& session_options,

      const ContentInfo* current_content,

      const SessionDescription* current_description,

      StreamParamsVec* current_streams,

      SessionDescription* desc,

      IceCredentialsIterator* ice_credentials) const;

  webrtc::RTCError AddUnsupportedContentForOffer(

      const MediaDescriptionOptions& media_description_options,

      const MediaSessionOptions& session_options,

      const ContentInfo* current_content,

      const SessionDescription* current_description,

      SessionDescription* desc,

      IceCredentialsIterator* ice_credentials) const;

  webrtc::RTCError AddRtpContentForAnswer(

      const MediaDescriptionOptions& media_description_options,

      const MediaSessionOptions& session_options,

      const ContentInfo* offer_content,

      const SessionDescription* offer_description,

      const ContentInfo* current_content,

      const SessionDescription* current_description,

      const TransportInfo* bundle_transport,

      const std::vector<Codec>& codecs,

      const RtpHeaderExtensions& header_extensions,

      StreamParamsVec* current_streams,

      SessionDescription* answer,

      IceCredentialsIterator* ice_credentials) const;

  webrtc::RTCError AddDataContentForAnswer(

      const MediaDescriptionOptions& media_description_options,

      const MediaSessionOptions& session_options,

      const ContentInfo* offer_content,

      const SessionDescription* offer_description,

      const ContentInfo* current_content,

      const SessionDescription* current_description,

      const TransportInfo* bundle_transport,

      StreamParamsVec* current_streams,

      SessionDescription* answer,

      IceCredentialsIterator* ice_credentials) const;

  webrtc::RTCError AddUnsupportedContentForAnswer(

      const MediaDescriptionOptions& media_description_options,

      const MediaSessionOptions& session_options,

      const ContentInfo* offer_content,

      const SessionDescription* offer_description,

      const ContentInfo* current_content,

      const SessionDescription* current_description,

      const TransportInfo* bundle_transport,

      SessionDescription* answer,

      IceCredentialsIterator* ice_credentials) const;

  void ComputeAudioCodecsIntersectionAndUnion();

  void ComputeVideoCodecsIntersectionAndUnion();

  rtc::UniqueRandomIdGenerator* ssrc_generator() const {

    return ssrc_generator_.get();

  bool is_unified_plan_ = false;

  Codecs audio_send_codecs_;

  Codecs audio_recv_codecs_;

  // Intersection of send and recv.

  Codecs audio_sendrecv_codecs_;

  // Union of send and recv.

  Codecs all_audio_codecs_;

  Codecs video_send_codecs_;

  Codecs video_recv_codecs_;

  // Intersection of send and recv.

  Codecs video_sendrecv_codecs_;

  // Union of send and recv.

  Codecs all_video_codecs_;

  // This object may or may not be owned by this class.

  webrtc::AlwaysValidPointer<rtc::UniqueRandomIdGenerator> const

      ssrc_generator_;

  bool enable_encrypted_rtp_header_extensions_ = false;

  const TransportDescriptionFactory* transport_desc_factory_;

};

// Convenience functions.

bool IsMediaContent(const ContentInfo* content);

bool IsAudioContent(const ContentInfo* content);

bool IsVideoContent(const ContentInfo* content);

bool IsDataContent(const ContentInfo* content);

bool IsUnsupportedContent(const ContentInfo* content);

const ContentInfo* GetFirstMediaContent(const ContentInfos& contents,

                                        MediaType media_type);

const ContentInfo* GetFirstAudioContent(const ContentInfos& contents);

const ContentInfo* GetFirstVideoContent(const ContentInfos& contents);

const ContentInfo* GetFirstDataContent(const ContentInfos& contents);

const ContentInfo* GetFirstMediaContent(const SessionDescription* sdesc,

                                        MediaType media_type);

const ContentInfo* GetFirstAudioContent(const SessionDescription* sdesc);

const ContentInfo* GetFirstVideoContent(const SessionDescription* sdesc);

const ContentInfo* GetFirstDataContent(const SessionDescription* sdesc);

const AudioContentDescription* GetFirstAudioContentDescription(

    const SessionDescription* sdesc);

const VideoContentDescription* GetFirstVideoContentDescription(

    const SessionDescription* sdesc);

const SctpDataContentDescription* GetFirstSctpDataContentDescription(

    const SessionDescription* sdesc);

// Non-const versions of the above functions.

// Useful when modifying an existing description.

ContentInfo* GetFirstMediaContent(ContentInfos* contents, MediaType media_type);

ContentInfo* GetFirstAudioContent(ContentInfos* contents);

ContentInfo* GetFirstVideoContent(ContentInfos* contents);

ContentInfo* GetFirstDataContent(ContentInfos* contents);

ContentInfo* GetFirstMediaContent(SessionDescription* sdesc,

                                  MediaType media_type);

ContentInfo* GetFirstAudioContent(SessionDescription* sdesc);

ContentInfo* GetFirstVideoContent(SessionDescription* sdesc);

ContentInfo* GetFirstDataContent(SessionDescription* sdesc);

AudioContentDescription* GetFirstAudioContentDescription(

    SessionDescription* sdesc);

VideoContentDescription* GetFirstVideoContentDescription(

    SessionDescription* sdesc);

SctpDataContentDescription* GetFirstSctpDataContentDescription(

    SessionDescription* sdesc);

}  // namespace cricket

#endif  // PC_MEDIA_SESSION_H_

Source code

Revision control

Copy as Markdown

Other Tools