1 /*
2  *  Copyright 2019 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 
11 #ifndef PC_AUDIO_RTP_RECEIVER_H_
12 #define PC_AUDIO_RTP_RECEIVER_H_
13 
14 #include <stdint.h>
15 #include <string>
16 #include <vector>
17 
18 #include "absl/types/optional.h"
19 #include "api/crypto/frame_decryptor_interface.h"
20 #include "api/dtls_transport_interface.h"
21 #include "api/frame_transformer_interface.h"
22 #include "api/media_stream_interface.h"
23 #include "api/media_stream_track_proxy.h"
24 #include "api/media_types.h"
25 #include "api/rtp_parameters.h"
26 #include "api/rtp_receiver_interface.h"
27 #include "api/scoped_refptr.h"
28 #include "api/transport/rtp/rtp_source.h"
29 #include "media/base/media_channel.h"
30 #include "pc/audio_track.h"
31 #include "pc/jitter_buffer_delay_interface.h"
32 #include "pc/remote_audio_source.h"
33 #include "pc/rtp_receiver.h"
34 #include "rtc_base/ref_counted_object.h"
35 #include "rtc_base/thread.h"
36 #include "rtc_base/thread_annotations.h"
37 
38 namespace webrtc {
39 
40 class AudioRtpReceiver : public ObserverInterface,
41                          public AudioSourceInterface::AudioObserver,
42                          public rtc::RefCountedObject<RtpReceiverInternal> {
43  public:
44   AudioRtpReceiver(rtc::Thread* worker_thread,
45                    std::string receiver_id,
46                    std::vector<std::string> stream_ids,
47                    bool is_unified_plan);
48   // TODO(https://crbug.com/webrtc/9480): Remove this when streams() is removed.
49   AudioRtpReceiver(
50       rtc::Thread* worker_thread,
51       const std::string& receiver_id,
52       const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams,
53       bool is_unified_plan);
54   virtual ~AudioRtpReceiver();
55 
56   // ObserverInterface implementation
57   void OnChanged() override;
58 
59   // AudioSourceInterface::AudioObserver implementation
60   void OnSetVolume(double volume) override;
61 
audio_track()62   rtc::scoped_refptr<AudioTrackInterface> audio_track() const {
63     return track_.get();
64   }
65 
66   // RtpReceiverInterface implementation
track()67   rtc::scoped_refptr<MediaStreamTrackInterface> track() const override {
68     return track_.get();
69   }
dtls_transport()70   rtc::scoped_refptr<DtlsTransportInterface> dtls_transport() const override {
71     return dtls_transport_;
72   }
73   std::vector<std::string> stream_ids() const override;
streams()74   std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams()
75       const override {
76     return streams_;
77   }
78 
media_type()79   cricket::MediaType media_type() const override {
80     return cricket::MEDIA_TYPE_AUDIO;
81   }
82 
id()83   std::string id() const override { return id_; }
84 
85   RtpParameters GetParameters() const override;
86 
87   void SetFrameDecryptor(
88       rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
89 
90   rtc::scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor()
91       const override;
92 
93   // RtpReceiverInternal implementation.
94   void Stop() override;
95   void StopAndEndTrack() override;
96   void SetupMediaChannel(uint32_t ssrc) override;
97   void SetupUnsignaledMediaChannel() override;
ssrc()98   uint32_t ssrc() const override { return ssrc_.value_or(0); }
99   void NotifyFirstPacketReceived() override;
100   void set_stream_ids(std::vector<std::string> stream_ids) override;
set_transport(rtc::scoped_refptr<DtlsTransportInterface> dtls_transport)101   void set_transport(
102       rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) override {
103     dtls_transport_ = dtls_transport;
104   }
105   void SetStreams(const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
106                       streams) override;
107   void SetObserver(RtpReceiverObserverInterface* observer) override;
108 
109   void SetJitterBufferMinimumDelay(
110       absl::optional<double> delay_seconds) override;
111 
112   void SetMediaChannel(cricket::MediaChannel* media_channel) override;
113 
114   std::vector<RtpSource> GetSources() const override;
AttachmentId()115   int AttachmentId() const override { return attachment_id_; }
116   void SetDepacketizerToDecoderFrameTransformer(
117       rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
118       override;
119 
120  private:
121   void RestartMediaChannel(absl::optional<uint32_t> ssrc);
122   void Reconfigure();
123   bool SetOutputVolume(double volume);
124 
125   rtc::Thread* const worker_thread_;
126   const std::string id_;
127   const rtc::scoped_refptr<RemoteAudioSource> source_;
128   const rtc::scoped_refptr<AudioTrackProxyWithInternal<AudioTrack>> track_;
129   cricket::VoiceMediaChannel* media_channel_ = nullptr;
130   absl::optional<uint32_t> ssrc_;
131   std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams_;
132   bool cached_track_enabled_;
133   double cached_volume_ = 1;
134   bool stopped_ = true;
135   RtpReceiverObserverInterface* observer_ = nullptr;
136   bool received_first_packet_ = false;
137   int attachment_id_ = 0;
138   rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_;
139   rtc::scoped_refptr<DtlsTransportInterface> dtls_transport_;
140   // Allows to thread safely change playout delay. Handles caching cases if
141   // |SetJitterBufferMinimumDelay| is called before start.
142   rtc::scoped_refptr<JitterBufferDelayInterface> delay_;
143   rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_
144       RTC_GUARDED_BY(worker_thread_);
145 };
146 
147 }  // namespace webrtc
148 
149 #endif  // PC_AUDIO_RTP_RECEIVER_H_
150