diff options
Diffstat (limited to 'third_party/libwebrtc/pc/rtp_transmission_manager.h')
| -rw-r--r-- | third_party/libwebrtc/pc/rtp_transmission_manager.h | 279 |
1 files changed, 279 insertions, 0 deletions
diff --git a/third_party/libwebrtc/pc/rtp_transmission_manager.h b/third_party/libwebrtc/pc/rtp_transmission_manager.h new file mode 100644 index 0000000000..b41848c917 --- /dev/null +++ b/third_party/libwebrtc/pc/rtp_transmission_manager.h @@ -0,0 +1,279 @@ +/* + * Copyright 2020 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_RTP_TRANSMISSION_MANAGER_H_ +#define PC_RTP_TRANSMISSION_MANAGER_H_ + +#include <stdint.h> + +#include <functional> +#include <string> +#include <vector> + +#include "api/media_stream_interface.h" +#include "api/media_types.h" +#include "api/peer_connection_interface.h" +#include "api/rtc_error.h" +#include "api/rtp_parameters.h" +#include "api/rtp_receiver_interface.h" +#include "api/rtp_sender_interface.h" +#include "api/scoped_refptr.h" +#include "api/sequence_checker.h" +#include "media/base/media_channel.h" +#include "pc/legacy_stats_collector_interface.h" +#include "pc/rtp_receiver.h" +#include "pc/rtp_receiver_proxy.h" +#include "pc/rtp_sender.h" +#include "pc/rtp_sender_proxy.h" +#include "pc/rtp_transceiver.h" +#include "pc/transceiver_list.h" +#include "pc/usage_pattern.h" +#include "rtc_base/third_party/sigslot/sigslot.h" +#include "rtc_base/thread.h" +#include "rtc_base/thread_annotations.h" +#include "rtc_base/weak_ptr.h" + +namespace rtc { +class Thread; +} + +namespace webrtc { + +// This class contains information about +// an RTPSender, used for things like looking it up by SSRC. +struct RtpSenderInfo { + RtpSenderInfo() : first_ssrc(0) {} + RtpSenderInfo(const std::string& stream_id, + const std::string& sender_id, + uint32_t ssrc) + : stream_id(stream_id), sender_id(sender_id), first_ssrc(ssrc) {} + bool operator==(const RtpSenderInfo& other) { + return this->stream_id == other.stream_id && + this->sender_id == other.sender_id && + this->first_ssrc == other.first_ssrc; + } + std::string stream_id; + std::string sender_id; + // An RtpSender can have many SSRCs. The first one is used as a sort of ID + // for communicating with the lower layers. + uint32_t first_ssrc; +}; + +// The RtpTransmissionManager class is responsible for managing the lifetime +// and relationships between objects of type RtpSender, RtpReceiver and +// RtpTransceiver. +class RtpTransmissionManager : public RtpSenderBase::SetStreamsObserver { + public: + RtpTransmissionManager(bool is_unified_plan, + ConnectionContext* context, + UsagePattern* usage_pattern, + PeerConnectionObserver* observer, + LegacyStatsCollectorInterface* legacy_stats, + std::function<void()> on_negotiation_needed); + + // No move or copy permitted. + RtpTransmissionManager(const RtpTransmissionManager&) = delete; + RtpTransmissionManager& operator=(const RtpTransmissionManager&) = delete; + + // Stop activity. In particular, don't call observer_ any more. + void Close(); + + // RtpSenderBase::SetStreamsObserver override. + void OnSetStreams() override; + + // Add a new track, creating transceiver if required. + RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack( + rtc::scoped_refptr<MediaStreamTrackInterface> track, + const std::vector<std::string>& stream_ids, + const std::vector<RtpEncodingParameters>* init_send_encodings); + + // Create a new RTP sender. Does not associate with a transceiver. + rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> + CreateSender(cricket::MediaType media_type, + const std::string& id, + rtc::scoped_refptr<MediaStreamTrackInterface> track, + const std::vector<std::string>& stream_ids, + const std::vector<RtpEncodingParameters>& send_encodings); + + // Create a new RTP receiver. Does not associate with a transceiver. + rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>> + CreateReceiver(cricket::MediaType media_type, const std::string& receiver_id); + + // Create a new RtpTransceiver of the given type and add it to the list of + // registered transceivers. + rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>> + CreateAndAddTransceiver( + rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender, + rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>> + receiver); + + // Returns the first RtpTransceiver suitable for a newly added track, if such + // transceiver is available. + rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>> + FindFirstTransceiverForAddedTrack( + rtc::scoped_refptr<MediaStreamTrackInterface> track, + const std::vector<RtpEncodingParameters>* init_send_encodings); + + // Returns the list of senders currently associated with some + // registered transceiver + std::vector<rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>> + GetSendersInternal() const; + + // Returns the list of receivers currently associated with a transceiver + std::vector< + rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>> + GetReceiversInternal() const; + + // Plan B: Get the transceiver containing all audio senders and receivers + rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>> + GetAudioTransceiver() const; + // Plan B: Get the transceiver containing all video senders and receivers + rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>> + GetVideoTransceiver() const; + + // Add an audio track, reusing or creating the sender. + void AddAudioTrack(AudioTrackInterface* track, MediaStreamInterface* stream); + // Plan B: Remove an audio track, removing the sender. + void RemoveAudioTrack(AudioTrackInterface* track, + MediaStreamInterface* stream); + // Add a video track, reusing or creating the sender. + void AddVideoTrack(VideoTrackInterface* track, MediaStreamInterface* stream); + // Plan B: Remove a video track, removing the sender. + void RemoveVideoTrack(VideoTrackInterface* track, + MediaStreamInterface* stream); + + // Triggered when a remote sender has been seen for the first time in a remote + // session description. It creates a remote MediaStreamTrackInterface + // implementation and triggers CreateAudioReceiver or CreateVideoReceiver. + void OnRemoteSenderAdded(const RtpSenderInfo& sender_info, + MediaStreamInterface* stream, + cricket::MediaType media_type); + + // Triggered when a remote sender has been removed from a remote session + // description. It removes the remote sender with id `sender_id` from a remote + // MediaStream and triggers DestroyAudioReceiver or DestroyVideoReceiver. + void OnRemoteSenderRemoved(const RtpSenderInfo& sender_info, + MediaStreamInterface* stream, + cricket::MediaType media_type); + + // Triggered when a local sender has been seen for the first time in a local + // session description. + // This method triggers CreateAudioSender or CreateVideoSender if the rtp + // streams in the local SessionDescription can be mapped to a MediaStreamTrack + // in a MediaStream in `local_streams_` + void OnLocalSenderAdded(const RtpSenderInfo& sender_info, + cricket::MediaType media_type); + + // Triggered when a local sender has been removed from a local session + // description. + // This method triggers DestroyAudioSender or DestroyVideoSender if a stream + // has been removed from the local SessionDescription and the stream can be + // mapped to a MediaStreamTrack in a MediaStream in `local_streams_`. + void OnLocalSenderRemoved(const RtpSenderInfo& sender_info, + cricket::MediaType media_type); + + std::vector<RtpSenderInfo>* GetRemoteSenderInfos( + cricket::MediaType media_type); + std::vector<RtpSenderInfo>* GetLocalSenderInfos( + cricket::MediaType media_type); + const RtpSenderInfo* FindSenderInfo(const std::vector<RtpSenderInfo>& infos, + const std::string& stream_id, + const std::string& sender_id) const; + + // Return the RtpSender with the given track attached. + rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> + FindSenderForTrack(MediaStreamTrackInterface* track) const; + + // Return the RtpSender with the given id, or null if none exists. + rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> + FindSenderById(const std::string& sender_id) const; + + // Return the RtpReceiver with the given id, or null if none exists. + rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>> + FindReceiverById(const std::string& receiver_id) const; + + TransceiverList* transceivers() { return &transceivers_; } + const TransceiverList* transceivers() const { return &transceivers_; } + + // Plan B helpers for getting the voice/video media channels for the single + // audio/video transceiver, if it exists. + cricket::VoiceMediaSendChannelInterface* voice_media_send_channel() const; + cricket::VideoMediaSendChannelInterface* video_media_send_channel() const; + cricket::VoiceMediaReceiveChannelInterface* voice_media_receive_channel() + const; + cricket::VideoMediaReceiveChannelInterface* video_media_receive_channel() + const; + + private: + rtc::Thread* signaling_thread() const { return context_->signaling_thread(); } + rtc::Thread* worker_thread() const { return context_->worker_thread(); } + bool IsUnifiedPlan() const { return is_unified_plan_; } + void NoteUsageEvent(UsageEvent event) { + usage_pattern_->NoteUsageEvent(event); + } + + // AddTrack implementation when Unified Plan is specified. + RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrackUnifiedPlan( + rtc::scoped_refptr<MediaStreamTrackInterface> track, + const std::vector<std::string>& stream_ids, + const std::vector<RtpEncodingParameters>* init_send_encodings); + // AddTrack implementation when Plan B is specified. + RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrackPlanB( + rtc::scoped_refptr<MediaStreamTrackInterface> track, + const std::vector<std::string>& stream_ids, + const std::vector<RtpEncodingParameters>* init_send_encodings); + + // Create an RtpReceiver that sources an audio track. + void CreateAudioReceiver(MediaStreamInterface* stream, + const RtpSenderInfo& remote_sender_info) + RTC_RUN_ON(signaling_thread()); + + // Create an RtpReceiver that sources a video track. + void CreateVideoReceiver(MediaStreamInterface* stream, + const RtpSenderInfo& remote_sender_info) + RTC_RUN_ON(signaling_thread()); + rtc::scoped_refptr<RtpReceiverInterface> RemoveAndStopReceiver( + const RtpSenderInfo& remote_sender_info) RTC_RUN_ON(signaling_thread()); + + PeerConnectionObserver* Observer() const; + void OnNegotiationNeeded(); + + cricket::MediaEngineInterface* media_engine() const; + + rtc::UniqueRandomIdGenerator* ssrc_generator() const { + return context_->ssrc_generator(); + } + + TransceiverList transceivers_; + + // These lists store sender info seen in local/remote descriptions. + std::vector<RtpSenderInfo> remote_audio_sender_infos_ + RTC_GUARDED_BY(signaling_thread()); + std::vector<RtpSenderInfo> remote_video_sender_infos_ + RTC_GUARDED_BY(signaling_thread()); + std::vector<RtpSenderInfo> local_audio_sender_infos_ + RTC_GUARDED_BY(signaling_thread()); + std::vector<RtpSenderInfo> local_video_sender_infos_ + RTC_GUARDED_BY(signaling_thread()); + + bool closed_ = false; + bool const is_unified_plan_; + ConnectionContext* context_; + UsagePattern* usage_pattern_; + PeerConnectionObserver* observer_; + LegacyStatsCollectorInterface* const legacy_stats_; + std::function<void()> on_negotiation_needed_; + rtc::WeakPtrFactory<RtpTransmissionManager> weak_ptr_factory_ + RTC_GUARDED_BY(signaling_thread()); +}; + +} // namespace webrtc + +#endif // PC_RTP_TRANSMISSION_MANAGER_H_ |