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_VIDEO_RTP_RECEIVER_H_
12 #define PC_VIDEO_RTP_RECEIVER_H_
13 
14 #include <stdint.h>
15 
16 #include <string>
17 #include <vector>
18 
19 #include "absl/types/optional.h"
20 #include "api/crypto/frame_decryptor_interface.h"
21 #include "api/dtls_transport_interface.h"
22 #include "api/frame_transformer_interface.h"
23 #include "api/media_stream_interface.h"
24 #include "api/media_stream_track_proxy.h"
25 #include "api/media_types.h"
26 #include "api/rtp_parameters.h"
27 #include "api/rtp_receiver_interface.h"
28 #include "api/scoped_refptr.h"
29 #include "api/sequence_checker.h"
30 #include "api/transport/rtp/rtp_source.h"
31 #include "api/video/video_frame.h"
32 #include "api/video/video_sink_interface.h"
33 #include "api/video/video_source_interface.h"
34 #include "media/base/media_channel.h"
35 #include "pc/jitter_buffer_delay_interface.h"
36 #include "pc/rtp_receiver.h"
37 #include "pc/video_rtp_track_source.h"
38 #include "pc/video_track.h"
39 #include "rtc_base/ref_counted_object.h"
40 #include "rtc_base/thread.h"
41 #include "rtc_base/thread_annotations.h"
42 
43 namespace webrtc {
44 
45 class VideoRtpReceiver : public rtc::RefCountedObject<RtpReceiverInternal>,
46                          public VideoRtpTrackSource::Callback {
47  public:
48   // An SSRC of 0 will create a receiver that will match the first SSRC it
49   // sees. Must be called on signaling thread.
50   VideoRtpReceiver(rtc::Thread* worker_thread,
51                    std::string receiver_id,
52                    std::vector<std::string> streams_ids);
53   // TODO(hbos): Remove this when streams() is removed.
54   // https://crbug.com/webrtc/9480
55   VideoRtpReceiver(
56       rtc::Thread* worker_thread,
57       const std::string& receiver_id,
58       const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams);
59 
60   virtual ~VideoRtpReceiver();
61 
video_track()62   rtc::scoped_refptr<VideoTrackInterface> video_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_VIDEO;
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   void SetDepacketizerToDecoderFrameTransformer(
94       rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) override;
95 
96   // RtpReceiverInternal implementation.
97   void Stop() override;
98   void StopAndEndTrack() override;
99   void SetupMediaChannel(uint32_t ssrc) override;
100   void SetupUnsignaledMediaChannel() override;
ssrc()101   uint32_t ssrc() const override { return ssrc_.value_or(0); }
102   void NotifyFirstPacketReceived() override;
103   void set_stream_ids(std::vector<std::string> stream_ids) override;
set_transport(rtc::scoped_refptr<DtlsTransportInterface> dtls_transport)104   void set_transport(
105       rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) override {
106     dtls_transport_ = dtls_transport;
107   }
108   void SetStreams(const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
109                       streams) override;
110 
111   void SetObserver(RtpReceiverObserverInterface* observer) override;
112 
113   void SetJitterBufferMinimumDelay(
114       absl::optional<double> delay_seconds) override;
115 
116   void SetMediaChannel(cricket::MediaChannel* media_channel) override;
117 
AttachmentId()118   int AttachmentId() const override { return attachment_id_; }
119 
120   std::vector<RtpSource> GetSources() const override;
121 
122  private:
123   void RestartMediaChannel(absl::optional<uint32_t> ssrc);
124   void SetSink(rtc::VideoSinkInterface<VideoFrame>* sink)
125       RTC_RUN_ON(worker_thread_);
126 
127   // VideoRtpTrackSource::Callback
128   void OnGenerateKeyFrame() override;
129   void OnEncodedSinkEnabled(bool enable) override;
130   void SetEncodedSinkEnabled(bool enable) RTC_RUN_ON(worker_thread_);
131 
132   rtc::Thread* const worker_thread_;
133 
134   const std::string id_;
135   cricket::VideoMediaChannel* media_channel_ = nullptr;
136   absl::optional<uint32_t> ssrc_;
137   // |source_| is held here to be able to change the state of the source when
138   // the VideoRtpReceiver is stopped.
139   rtc::scoped_refptr<VideoRtpTrackSource> source_;
140   rtc::scoped_refptr<VideoTrackProxyWithInternal<VideoTrack>> track_;
141   std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams_;
142   bool stopped_ = true;
143   RtpReceiverObserverInterface* observer_ = nullptr;
144   bool received_first_packet_ = false;
145   int attachment_id_ = 0;
146   rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_;
147   rtc::scoped_refptr<DtlsTransportInterface> dtls_transport_;
148   rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_
149       RTC_GUARDED_BY(worker_thread_);
150   // Allows to thread safely change jitter buffer delay. Handles caching cases
151   // if |SetJitterBufferMinimumDelay| is called before start.
152   rtc::scoped_refptr<JitterBufferDelayInterface> delay_;
153   // Records if we should generate a keyframe when |media_channel_| gets set up
154   // or switched.
155   bool saved_generate_keyframe_ RTC_GUARDED_BY(worker_thread_) = false;
156   bool saved_encoded_sink_enabled_ RTC_GUARDED_BY(worker_thread_) = false;
157 };
158 
159 }  // namespace webrtc
160 
161 #endif  // PC_VIDEO_RTP_RECEIVER_H_
162