diff options
Diffstat (limited to 'third_party/libwebrtc/pc/audio_rtp_receiver.h')
| -rw-r--r-- | third_party/libwebrtc/pc/audio_rtp_receiver.h | 165 |
1 files changed, 165 insertions, 0 deletions
diff --git a/third_party/libwebrtc/pc/audio_rtp_receiver.h b/third_party/libwebrtc/pc/audio_rtp_receiver.h new file mode 100644 index 0000000000..86c42d532a --- /dev/null +++ b/third_party/libwebrtc/pc/audio_rtp_receiver.h @@ -0,0 +1,165 @@ +/* + * Copyright 2019 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_AUDIO_RTP_RECEIVER_H_ +#define PC_AUDIO_RTP_RECEIVER_H_ + +#include <stdint.h> + +#include <string> +#include <vector> + +#include "absl/types/optional.h" +#include "api/crypto/frame_decryptor_interface.h" +#include "api/dtls_transport_interface.h" +#include "api/frame_transformer_interface.h" +#include "api/media_stream_interface.h" +#include "api/media_types.h" +#include "api/rtp_parameters.h" +#include "api/rtp_receiver_interface.h" +#include "api/scoped_refptr.h" +#include "api/sequence_checker.h" +#include "api/task_queue/pending_task_safety_flag.h" +#include "api/transport/rtp/rtp_source.h" +#include "media/base/media_channel.h" +#include "pc/audio_track.h" +#include "pc/jitter_buffer_delay.h" +#include "pc/media_stream_track_proxy.h" +#include "pc/remote_audio_source.h" +#include "pc/rtp_receiver.h" +#include "rtc_base/system/no_unique_address.h" +#include "rtc_base/thread.h" +#include "rtc_base/thread_annotations.h" + +namespace webrtc { + +class AudioRtpReceiver : public ObserverInterface, + public AudioSourceInterface::AudioObserver, + public RtpReceiverInternal { + public: + // The constructor supports optionally passing the voice channel to the + // instance at construction time without having to call `SetMediaChannel()` + // on the worker thread straight after construction. + // However, when using that, the assumption is that right after construction, + // a call to either `SetupUnsignaledMediaChannel` or `SetupMediaChannel` + // will be made, which will internally start the source on the worker thread. + AudioRtpReceiver( + rtc::Thread* worker_thread, + std::string receiver_id, + std::vector<std::string> stream_ids, + bool is_unified_plan, + cricket::VoiceMediaReceiveChannelInterface* voice_channel = nullptr); + // TODO(https://crbug.com/webrtc/9480): Remove this when streams() is removed. + AudioRtpReceiver( + rtc::Thread* worker_thread, + const std::string& receiver_id, + const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams, + bool is_unified_plan, + cricket::VoiceMediaReceiveChannelInterface* media_channel = nullptr); + virtual ~AudioRtpReceiver(); + + // ObserverInterface implementation + void OnChanged() override; + + // AudioSourceInterface::AudioObserver implementation + void OnSetVolume(double volume) override; + + rtc::scoped_refptr<AudioTrackInterface> audio_track() const { return track_; } + + // RtpReceiverInterface implementation + rtc::scoped_refptr<MediaStreamTrackInterface> track() const override { + return track_; + } + rtc::scoped_refptr<DtlsTransportInterface> dtls_transport() const override; + std::vector<std::string> stream_ids() const override; + std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams() + const override; + + cricket::MediaType media_type() const override { + return cricket::MEDIA_TYPE_AUDIO; + } + + std::string id() const override { return id_; } + + RtpParameters GetParameters() const override; + + void SetFrameDecryptor( + rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) override; + + rtc::scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor() + const override; + + // RtpReceiverInternal implementation. + void Stop() override; + void SetupMediaChannel(uint32_t ssrc) override; + void SetupUnsignaledMediaChannel() override; + absl::optional<uint32_t> ssrc() const override; + void NotifyFirstPacketReceived() override; + void set_stream_ids(std::vector<std::string> stream_ids) override; + void set_transport( + rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) override; + void SetStreams(const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& + streams) override; + void SetObserver(RtpReceiverObserverInterface* observer) override; + + void SetJitterBufferMinimumDelay( + absl::optional<double> delay_seconds) override; + + void SetMediaChannel( + cricket::MediaReceiveChannelInterface* media_channel) override; + + std::vector<RtpSource> GetSources() const override; + int AttachmentId() const override { return attachment_id_; } + void SetDepacketizerToDecoderFrameTransformer( + rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) + override; + + private: + void RestartMediaChannel(absl::optional<uint32_t> ssrc) + RTC_RUN_ON(&signaling_thread_checker_); + void RestartMediaChannel_w(absl::optional<uint32_t> ssrc, + bool track_enabled, + MediaSourceInterface::SourceState state) + RTC_RUN_ON(worker_thread_); + void Reconfigure(bool track_enabled) RTC_RUN_ON(worker_thread_); + void SetOutputVolume_w(double volume) RTC_RUN_ON(worker_thread_); + + RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_checker_; + rtc::Thread* const worker_thread_; + const std::string id_; + const rtc::scoped_refptr<RemoteAudioSource> source_; + const rtc::scoped_refptr<AudioTrackProxyWithInternal<AudioTrack>> track_; + cricket::VoiceMediaReceiveChannelInterface* media_channel_ + RTC_GUARDED_BY(worker_thread_) = nullptr; + absl::optional<uint32_t> signaled_ssrc_ RTC_GUARDED_BY(worker_thread_); + std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams_ + RTC_GUARDED_BY(&signaling_thread_checker_); + bool cached_track_enabled_ RTC_GUARDED_BY(&signaling_thread_checker_); + double cached_volume_ RTC_GUARDED_BY(worker_thread_) = 1.0; + RtpReceiverObserverInterface* observer_ + RTC_GUARDED_BY(&signaling_thread_checker_) = nullptr; + bool received_first_packet_ RTC_GUARDED_BY(&signaling_thread_checker_) = + false; + const int attachment_id_; + rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_ + RTC_GUARDED_BY(worker_thread_); + rtc::scoped_refptr<DtlsTransportInterface> dtls_transport_ + RTC_GUARDED_BY(&signaling_thread_checker_); + // Stores and updates the playout delay. Handles caching cases if + // `SetJitterBufferMinimumDelay` is called before start. + JitterBufferDelay delay_ RTC_GUARDED_BY(worker_thread_); + rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_ + RTC_GUARDED_BY(worker_thread_); + const rtc::scoped_refptr<PendingTaskSafetyFlag> worker_thread_safety_; +}; + +} // namespace webrtc + +#endif // PC_AUDIO_RTP_RECEIVER_H_ |