blob: d2d7206a8d105d9dc9e04fd5cdaea0875eecd2d6 [file] [log] [blame]
deadbeef6979b022015-09-24 23:47:531/*
kjellanderb24317b2016-02-10 15:54:432 * Copyright 2015 The WebRTC project authors. All Rights Reserved.
deadbeef6979b022015-09-24 23:47:533 *
kjellanderb24317b2016-02-10 15:54:434 * 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.
deadbeef6979b022015-09-24 23:47:539 */
10
Mirko Bonadei92ea95e2017-09-15 04:47:3111#include "pc/rtpreceiver.h"
deadbeef6979b022015-09-24 23:47:5312
Henrik Boström9e6fd2b2017-11-21 12:41:5113#include <utility>
Steve Anton36b29d12017-10-30 16:57:4214#include <vector>
15
Henrik Boström199e27b2018-07-04 18:51:5316#include "api/mediastreamproxy.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3117#include "api/mediastreamtrackproxy.h"
18#include "api/videosourceproxy.h"
19#include "pc/audiotrack.h"
Henrik Boström199e27b2018-07-04 18:51:5320#include "pc/mediastream.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3121#include "pc/videotrack.h"
22#include "rtc_base/trace_event.h"
deadbeef70ab1a12015-09-28 23:53:5523
24namespace webrtc {
25
Harald Alvestrandc72af932018-01-11 16:18:1926namespace {
27
28// This function is only expected to be called on the signalling thread.
29int GenerateUniqueId() {
30 static int g_unique_id = 0;
31
32 return ++g_unique_id;
33}
34
Henrik Boström199e27b2018-07-04 18:51:5335std::vector<rtc::scoped_refptr<MediaStreamInterface>> CreateStreamsFromIds(
36 std::vector<std::string> stream_ids) {
37 std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams(
38 stream_ids.size());
39 for (size_t i = 0; i < stream_ids.size(); ++i) {
40 streams[i] = MediaStreamProxy::Create(
41 rtc::Thread::Current(), MediaStream::Create(std::move(stream_ids[i])));
42 }
43 return streams;
44}
45
Benjamin Wright84583f62018-10-04 21:22:3446// Attempt to attach the frame decryptor to the current media channel on the
47// correct worker thread only if both the media channel exists and a ssrc has
48// been allocated to the stream.
49void MaybeAttachFrameDecryptorToMediaChannel(
50 const absl::optional<uint32_t>& ssrc,
Benjamin Wrightbfd412e2018-09-10 21:06:0251 rtc::Thread* worker_thread,
Benjamin Wright84583f62018-10-04 21:22:3452 rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor,
Benjamin Wrightbfd412e2018-09-10 21:06:0253 cricket::MediaChannel* media_channel) {
Benjamin Wright6cc9cca2018-10-10 00:29:5454 if (media_channel && frame_decryptor && ssrc.has_value()) {
55 worker_thread->Invoke<void>(RTC_FROM_HERE, [&] {
Benjamin Wright84583f62018-10-04 21:22:3456 media_channel->SetFrameDecryptor(*ssrc, frame_decryptor);
Benjamin Wrightbfd412e2018-09-10 21:06:0257 });
58 }
59}
60
Harald Alvestrandc72af932018-01-11 16:18:1961} // namespace
62
Henrik Boström199e27b2018-07-04 18:51:5363AudioRtpReceiver::AudioRtpReceiver(rtc::Thread* worker_thread,
64 std::string receiver_id,
65 std::vector<std::string> stream_ids)
66 : AudioRtpReceiver(worker_thread,
67 receiver_id,
68 CreateStreamsFromIds(std::move(stream_ids))) {}
69
Henrik Boström9e6fd2b2017-11-21 12:41:5170AudioRtpReceiver::AudioRtpReceiver(
Steve Anton60776752018-01-10 19:51:3471 rtc::Thread* worker_thread,
Steve Anton9158ef62017-11-27 21:01:5272 const std::string& receiver_id,
Steve Antond3679212018-01-18 01:41:0273 const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams)
Steve Anton60776752018-01-10 19:51:3474 : worker_thread_(worker_thread),
75 id_(receiver_id),
Steve Antond3679212018-01-18 01:41:0276 source_(new rtc::RefCountedObject<RemoteAudioSource>(worker_thread)),
77 track_(AudioTrackProxy::Create(rtc::Thread::Current(),
78 AudioTrack::Create(receiver_id, source_))),
Harald Alvestrandc72af932018-01-11 16:18:1979 cached_track_enabled_(track_->enabled()),
80 attachment_id_(GenerateUniqueId()) {
Steve Anton60776752018-01-10 19:51:3481 RTC_DCHECK(worker_thread_);
tommi6eca7e32015-12-15 12:27:1182 RTC_DCHECK(track_->GetSource()->remote());
deadbeef70ab1a12015-09-28 23:53:5583 track_->RegisterObserver(this);
84 track_->GetSource()->RegisterAudioObserver(this);
Steve Antonef65ef12018-01-11 01:15:2085 SetStreams(streams);
deadbeef70ab1a12015-09-28 23:53:5586}
87
88AudioRtpReceiver::~AudioRtpReceiver() {
89 track_->GetSource()->UnregisterAudioObserver(this);
90 track_->UnregisterObserver(this);
91 Stop();
92}
93
94void AudioRtpReceiver::OnChanged() {
95 if (cached_track_enabled_ != track_->enabled()) {
96 cached_track_enabled_ = track_->enabled();
97 Reconfigure();
98 }
99}
100
Steve Anton60776752018-01-10 19:51:34101bool AudioRtpReceiver::SetOutputVolume(double volume) {
102 RTC_DCHECK_GE(volume, 0.0);
103 RTC_DCHECK_LE(volume, 10.0);
104 RTC_DCHECK(media_channel_);
Steve Antond3679212018-01-18 01:41:02105 RTC_DCHECK(ssrc_);
Steve Anton60776752018-01-10 19:51:34106 return worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] {
Steve Antond3679212018-01-18 01:41:02107 return media_channel_->SetOutputVolume(*ssrc_, volume);
Steve Anton60776752018-01-10 19:51:34108 });
109}
110
deadbeef70ab1a12015-09-28 23:53:55111void AudioRtpReceiver::OnSetVolume(double volume) {
kwibergee89e782017-08-10 00:22:01112 RTC_DCHECK_GE(volume, 0);
113 RTC_DCHECK_LE(volume, 10);
Taylor Brandstetterba29c6a2016-06-27 23:30:35114 cached_volume_ = volume;
Steve Antond3679212018-01-18 01:41:02115 if (!media_channel_ || !ssrc_) {
Mirko Bonadei675513b2017-11-09 10:09:25116 RTC_LOG(LS_ERROR)
117 << "AudioRtpReceiver::OnSetVolume: No audio channel exists.";
Taylor Brandstetterba29c6a2016-06-27 23:30:35118 return;
119 }
deadbeef70ab1a12015-09-28 23:53:55120 // When the track is disabled, the volume of the source, which is the
121 // corresponding WebRtc Voice Engine channel will be 0. So we do not allow
122 // setting the volume to the source when the track is disabled.
Taylor Brandstetterba29c6a2016-06-27 23:30:35123 if (!stopped_ && track_->enabled()) {
Steve Anton60776752018-01-10 19:51:34124 if (!SetOutputVolume(cached_volume_)) {
nisseeb4ca4e2017-01-12 10:24:27125 RTC_NOTREACHED();
Taylor Brandstetterba29c6a2016-06-27 23:30:35126 }
127 }
deadbeef70ab1a12015-09-28 23:53:55128}
129
Henrik Boström199e27b2018-07-04 18:51:53130std::vector<std::string> AudioRtpReceiver::stream_ids() const {
131 std::vector<std::string> stream_ids(streams_.size());
132 for (size_t i = 0; i < streams_.size(); ++i)
133 stream_ids[i] = streams_[i]->id();
134 return stream_ids;
135}
136
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30137RtpParameters AudioRtpReceiver::GetParameters() const {
Steve Antond3679212018-01-18 01:41:02138 if (!media_channel_ || !ssrc_ || stopped_) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35139 return RtpParameters();
140 }
Steve Anton60776752018-01-10 19:51:34141 return worker_thread_->Invoke<RtpParameters>(RTC_FROM_HERE, [&] {
Steve Antond3679212018-01-18 01:41:02142 return media_channel_->GetRtpReceiveParameters(*ssrc_);
Steve Anton60776752018-01-10 19:51:34143 });
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30144}
145
146bool AudioRtpReceiver::SetParameters(const RtpParameters& parameters) {
147 TRACE_EVENT0("webrtc", "AudioRtpReceiver::SetParameters");
Steve Antond3679212018-01-18 01:41:02148 if (!media_channel_ || !ssrc_ || stopped_) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35149 return false;
150 }
Steve Anton60776752018-01-10 19:51:34151 return worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] {
Steve Antond3679212018-01-18 01:41:02152 return media_channel_->SetRtpReceiveParameters(*ssrc_, parameters);
Steve Anton60776752018-01-10 19:51:34153 });
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30154}
155
Benjamin Wrightd81ac952018-08-30 00:02:10156void AudioRtpReceiver::SetFrameDecryptor(
157 rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
158 frame_decryptor_ = std::move(frame_decryptor);
Benjamin Wright6cc9cca2018-10-10 00:29:54159 // Special Case: Set the frame decryptor to any value on any existing channel.
160 if (media_channel_ && ssrc_.has_value()) {
161 worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
162 media_channel_->SetFrameDecryptor(*ssrc_, frame_decryptor_);
163 });
164 }
Benjamin Wrightd81ac952018-08-30 00:02:10165}
166
167rtc::scoped_refptr<FrameDecryptorInterface>
168AudioRtpReceiver::GetFrameDecryptor() const {
169 return frame_decryptor_;
170}
171
deadbeefa601f5c2016-06-06 21:27:39172void AudioRtpReceiver::Stop() {
173 // TODO(deadbeef): Need to do more here to fully stop receiving packets.
Taylor Brandstetterba29c6a2016-06-27 23:30:35174 if (stopped_) {
deadbeefa601f5c2016-06-06 21:27:39175 return;
176 }
Steve Antond3679212018-01-18 01:41:02177 if (media_channel_ && ssrc_) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35178 // Allow that SetOutputVolume fail. This is the normal case when the
179 // underlying media channel has already been deleted.
Steve Anton60776752018-01-10 19:51:34180 SetOutputVolume(0.0);
Taylor Brandstetterba29c6a2016-06-27 23:30:35181 }
182 stopped_ = true;
deadbeefa601f5c2016-06-06 21:27:39183}
184
Steve Antond3679212018-01-18 01:41:02185void AudioRtpReceiver::SetupMediaChannel(uint32_t ssrc) {
186 if (!media_channel_) {
187 RTC_LOG(LS_ERROR)
188 << "AudioRtpReceiver::SetupMediaChannel: No audio channel exists.";
189 return;
190 }
191 if (ssrc_ == ssrc) {
192 return;
193 }
194 if (ssrc_) {
195 source_->Stop(media_channel_, *ssrc_);
196 }
197 ssrc_ = ssrc;
198 source_->Start(media_channel_, *ssrc_);
199 Reconfigure();
200}
201
Henrik Boström199e27b2018-07-04 18:51:53202void AudioRtpReceiver::set_stream_ids(std::vector<std::string> stream_ids) {
203 SetStreams(CreateStreamsFromIds(std::move(stream_ids)));
204}
205
Steve Antonef65ef12018-01-11 01:15:20206void AudioRtpReceiver::SetStreams(
207 const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
208 // Remove remote track from any streams that are going away.
209 for (auto existing_stream : streams_) {
210 bool removed = true;
211 for (auto stream : streams) {
Seth Hampson13b8bad2018-03-13 23:05:28212 if (existing_stream->id() == stream->id()) {
Steve Antonef65ef12018-01-11 01:15:20213 RTC_DCHECK_EQ(existing_stream.get(), stream.get());
214 removed = false;
215 break;
216 }
217 }
218 if (removed) {
219 existing_stream->RemoveTrack(track_);
220 }
221 }
222 // Add remote track to any streams that are new.
223 for (auto stream : streams) {
224 bool added = true;
225 for (auto existing_stream : streams_) {
Seth Hampson13b8bad2018-03-13 23:05:28226 if (stream->id() == existing_stream->id()) {
Steve Antonef65ef12018-01-11 01:15:20227 RTC_DCHECK_EQ(stream.get(), existing_stream.get());
228 added = false;
229 break;
230 }
231 }
232 if (added) {
233 stream->AddTrack(track_);
234 }
235 }
236 streams_ = streams;
237}
238
hbos8d609f62017-04-10 14:39:05239std::vector<RtpSource> AudioRtpReceiver::GetSources() const {
Steve Antond3679212018-01-18 01:41:02240 if (!media_channel_ || !ssrc_ || stopped_) {
241 return {};
242 }
Steve Anton60776752018-01-10 19:51:34243 return worker_thread_->Invoke<std::vector<RtpSource>>(
Steve Antond3679212018-01-18 01:41:02244 RTC_FROM_HERE, [&] { return media_channel_->GetSources(*ssrc_); });
hbos8d609f62017-04-10 14:39:05245}
246
deadbeef70ab1a12015-09-28 23:53:55247void AudioRtpReceiver::Reconfigure() {
Taylor Brandstetterba29c6a2016-06-27 23:30:35248 RTC_DCHECK(!stopped_);
Steve Antond3679212018-01-18 01:41:02249 if (!media_channel_ || !ssrc_) {
Mirko Bonadei675513b2017-11-09 10:09:25250 RTC_LOG(LS_ERROR)
251 << "AudioRtpReceiver::Reconfigure: No audio channel exists.";
deadbeef70ab1a12015-09-28 23:53:55252 return;
253 }
Steve Anton60776752018-01-10 19:51:34254 if (!SetOutputVolume(track_->enabled() ? cached_volume_ : 0)) {
nisseeb4ca4e2017-01-12 10:24:27255 RTC_NOTREACHED();
Taylor Brandstetterba29c6a2016-06-27 23:30:35256 }
Benjamin Wright84583f62018-10-04 21:22:34257 // Reattach the frame decryptor if we were reconfigured.
258 MaybeAttachFrameDecryptorToMediaChannel(ssrc_, worker_thread_,
259 frame_decryptor_, media_channel_);
deadbeef70ab1a12015-09-28 23:53:55260}
261
zhihuang184a3fd2016-06-14 18:47:14262void AudioRtpReceiver::SetObserver(RtpReceiverObserverInterface* observer) {
263 observer_ = observer;
Taylor Brandstetterba29c6a2016-06-27 23:30:35264 // Deliver any notifications the observer may have missed by being set late.
zhihuangc4adabf2016-12-07 18:36:40265 if (received_first_packet_ && observer_) {
zhihuang184a3fd2016-06-14 18:47:14266 observer_->OnFirstPacketReceived(media_type());
267 }
268}
269
Benjamin Wrightbfd412e2018-09-10 21:06:02270void AudioRtpReceiver::SetVoiceMediaChannel(
271 cricket::VoiceMediaChannel* voice_media_channel) {
272 media_channel_ = voice_media_channel;
Benjamin Wrightbfd412e2018-09-10 21:06:02273}
274
Steve Anton60776752018-01-10 19:51:34275void AudioRtpReceiver::NotifyFirstPacketReceived() {
zhihuang184a3fd2016-06-14 18:47:14276 if (observer_) {
277 observer_->OnFirstPacketReceived(media_type());
278 }
279 received_first_packet_ = true;
280}
281
Henrik Boström199e27b2018-07-04 18:51:53282VideoRtpReceiver::VideoRtpReceiver(rtc::Thread* worker_thread,
283 std::string receiver_id,
284 std::vector<std::string> stream_ids)
285 : VideoRtpReceiver(worker_thread,
286 receiver_id,
287 CreateStreamsFromIds(std::move(stream_ids))) {}
288
Henrik Boström9e6fd2b2017-11-21 12:41:51289VideoRtpReceiver::VideoRtpReceiver(
Steve Anton60776752018-01-10 19:51:34290 rtc::Thread* worker_thread,
Steve Antonef65ef12018-01-11 01:15:20291 const std::string& receiver_id,
Steve Antond3679212018-01-18 01:41:02292 const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams)
Steve Anton60776752018-01-10 19:51:34293 : worker_thread_(worker_thread),
Steve Antonef65ef12018-01-11 01:15:20294 id_(receiver_id),
Niels Möller5d67f822018-05-23 14:28:17295 source_(new RefCountedObject<VideoRtpTrackSource>()),
perkjf0dcfe22016-03-10 17:32:00296 track_(VideoTrackProxy::Create(
297 rtc::Thread::Current(),
nisse5b68ab52016-04-07 14:45:54298 worker_thread,
299 VideoTrack::Create(
Steve Antonef65ef12018-01-11 01:15:20300 receiver_id,
nisse5b68ab52016-04-07 14:45:54301 VideoTrackSourceProxy::Create(rtc::Thread::Current(),
302 worker_thread,
perkj773be362017-08-01 06:22:01303 source_),
Harald Alvestrandc72af932018-01-11 16:18:19304 worker_thread))),
305 attachment_id_(GenerateUniqueId()) {
Steve Anton60776752018-01-10 19:51:34306 RTC_DCHECK(worker_thread_);
Steve Antonef65ef12018-01-11 01:15:20307 SetStreams(streams);
perkjf0dcfe22016-03-10 17:32:00308 source_->SetState(MediaSourceInterface::kLive);
deadbeef70ab1a12015-09-28 23:53:55309}
310
311VideoRtpReceiver::~VideoRtpReceiver() {
312 // Since cricket::VideoRenderer is not reference counted,
Taylor Brandstetterba29c6a2016-06-27 23:30:35313 // we need to remove it from the channel before we are deleted.
deadbeef70ab1a12015-09-28 23:53:55314 Stop();
315}
316
Henrik Boström199e27b2018-07-04 18:51:53317std::vector<std::string> VideoRtpReceiver::stream_ids() const {
318 std::vector<std::string> stream_ids(streams_.size());
319 for (size_t i = 0; i < streams_.size(); ++i)
320 stream_ids[i] = streams_[i]->id();
321 return stream_ids;
322}
323
Steve Anton60776752018-01-10 19:51:34324bool VideoRtpReceiver::SetSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
325 RTC_DCHECK(media_channel_);
Steve Antond3679212018-01-18 01:41:02326 RTC_DCHECK(ssrc_);
Steve Anton60776752018-01-10 19:51:34327 return worker_thread_->Invoke<bool>(
Steve Antond3679212018-01-18 01:41:02328 RTC_FROM_HERE, [&] { return media_channel_->SetSink(*ssrc_, sink); });
Steve Anton60776752018-01-10 19:51:34329}
330
deadbeefa601f5c2016-06-06 21:27:39331RtpParameters VideoRtpReceiver::GetParameters() const {
Steve Antond3679212018-01-18 01:41:02332 if (!media_channel_ || !ssrc_ || stopped_) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35333 return RtpParameters();
334 }
Steve Anton60776752018-01-10 19:51:34335 return worker_thread_->Invoke<RtpParameters>(RTC_FROM_HERE, [&] {
Steve Antond3679212018-01-18 01:41:02336 return media_channel_->GetRtpReceiveParameters(*ssrc_);
Steve Anton60776752018-01-10 19:51:34337 });
deadbeefa601f5c2016-06-06 21:27:39338}
339
340bool VideoRtpReceiver::SetParameters(const RtpParameters& parameters) {
341 TRACE_EVENT0("webrtc", "VideoRtpReceiver::SetParameters");
Steve Antond3679212018-01-18 01:41:02342 if (!media_channel_ || !ssrc_ || stopped_) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35343 return false;
344 }
Steve Anton60776752018-01-10 19:51:34345 return worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] {
Steve Antond3679212018-01-18 01:41:02346 return media_channel_->SetRtpReceiveParameters(*ssrc_, parameters);
Steve Anton60776752018-01-10 19:51:34347 });
deadbeefa601f5c2016-06-06 21:27:39348}
349
Benjamin Wrightd81ac952018-08-30 00:02:10350void VideoRtpReceiver::SetFrameDecryptor(
351 rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
352 frame_decryptor_ = std::move(frame_decryptor);
Benjamin Wright6cc9cca2018-10-10 00:29:54353 // Special Case: Set the frame decryptor to any value on any existing channel.
354 if (media_channel_ && ssrc_.has_value()) {
355 worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
356 media_channel_->SetFrameDecryptor(*ssrc_, frame_decryptor_);
357 });
358 }
Benjamin Wrightd81ac952018-08-30 00:02:10359}
360
361rtc::scoped_refptr<FrameDecryptorInterface>
362VideoRtpReceiver::GetFrameDecryptor() const {
363 return frame_decryptor_;
364}
365
deadbeef70ab1a12015-09-28 23:53:55366void VideoRtpReceiver::Stop() {
367 // TODO(deadbeef): Need to do more here to fully stop receiving packets.
Taylor Brandstetterba29c6a2016-06-27 23:30:35368 if (stopped_) {
deadbeef70ab1a12015-09-28 23:53:55369 return;
370 }
perkjf0dcfe22016-03-10 17:32:00371 source_->SetState(MediaSourceInterface::kEnded);
Steve Antond3679212018-01-18 01:41:02372 if (!media_channel_ || !ssrc_) {
Mirko Bonadei675513b2017-11-09 10:09:25373 RTC_LOG(LS_WARNING) << "VideoRtpReceiver::Stop: No video channel exists.";
Taylor Brandstetterba29c6a2016-06-27 23:30:35374 } else {
375 // Allow that SetSink fail. This is the normal case when the underlying
376 // media channel has already been deleted.
Steve Anton60776752018-01-10 19:51:34377 SetSink(nullptr);
Taylor Brandstetterba29c6a2016-06-27 23:30:35378 }
379 stopped_ = true;
deadbeef70ab1a12015-09-28 23:53:55380}
381
Steve Antond3679212018-01-18 01:41:02382void VideoRtpReceiver::SetupMediaChannel(uint32_t ssrc) {
383 if (!media_channel_) {
384 RTC_LOG(LS_ERROR)
385 << "VideoRtpReceiver::SetupMediaChannel: No video channel exists.";
386 }
387 if (ssrc_ == ssrc) {
388 return;
389 }
390 if (ssrc_) {
391 SetSink(nullptr);
392 }
393 ssrc_ = ssrc;
Niels Möller5d67f822018-05-23 14:28:17394 SetSink(source_->sink());
Benjamin Wright84583f62018-10-04 21:22:34395 // Attach any existing frame decryptor to the media channel.
396 MaybeAttachFrameDecryptorToMediaChannel(ssrc_, worker_thread_,
397 frame_decryptor_, media_channel_);
Steve Antond3679212018-01-18 01:41:02398}
399
Henrik Boström199e27b2018-07-04 18:51:53400void VideoRtpReceiver::set_stream_ids(std::vector<std::string> stream_ids) {
401 SetStreams(CreateStreamsFromIds(std::move(stream_ids)));
402}
403
Steve Antonef65ef12018-01-11 01:15:20404void VideoRtpReceiver::SetStreams(
405 const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
406 // Remove remote track from any streams that are going away.
407 for (auto existing_stream : streams_) {
408 bool removed = true;
409 for (auto stream : streams) {
Seth Hampson13b8bad2018-03-13 23:05:28410 if (existing_stream->id() == stream->id()) {
Steve Antonef65ef12018-01-11 01:15:20411 RTC_DCHECK_EQ(existing_stream.get(), stream.get());
412 removed = false;
413 break;
414 }
415 }
416 if (removed) {
417 existing_stream->RemoveTrack(track_);
418 }
419 }
420 // Add remote track to any streams that are new.
421 for (auto stream : streams) {
422 bool added = true;
423 for (auto existing_stream : streams_) {
Seth Hampson13b8bad2018-03-13 23:05:28424 if (stream->id() == existing_stream->id()) {
Steve Antonef65ef12018-01-11 01:15:20425 RTC_DCHECK_EQ(stream.get(), existing_stream.get());
426 added = false;
427 break;
428 }
429 }
430 if (added) {
431 stream->AddTrack(track_);
432 }
433 }
434 streams_ = streams;
435}
436
zhihuang184a3fd2016-06-14 18:47:14437void VideoRtpReceiver::SetObserver(RtpReceiverObserverInterface* observer) {
438 observer_ = observer;
Taylor Brandstetterba29c6a2016-06-27 23:30:35439 // Deliver any notifications the observer may have missed by being set late.
zhihuangc4adabf2016-12-07 18:36:40440 if (received_first_packet_ && observer_) {
zhihuang184a3fd2016-06-14 18:47:14441 observer_->OnFirstPacketReceived(media_type());
442 }
443}
444
Benjamin Wrightbfd412e2018-09-10 21:06:02445void VideoRtpReceiver::SetVideoMediaChannel(
446 cricket::VideoMediaChannel* video_media_channel) {
447 media_channel_ = video_media_channel;
Benjamin Wrightbfd412e2018-09-10 21:06:02448}
449
Steve Anton60776752018-01-10 19:51:34450void VideoRtpReceiver::NotifyFirstPacketReceived() {
zhihuang184a3fd2016-06-14 18:47:14451 if (observer_) {
452 observer_->OnFirstPacketReceived(media_type());
453 }
454 received_first_packet_ = true;
455}
456
Jonas Oreland49ac5952018-09-26 14:04:32457std::vector<RtpSource> VideoRtpReceiver::GetSources() const {
458 if (!media_channel_ || !ssrc_ || stopped_) {
459 return {};
460 }
461 return worker_thread_->Invoke<std::vector<RtpSource>>(
462 RTC_FROM_HERE, [&] { return media_channel_->GetSources(*ssrc_); });
463}
464
deadbeef70ab1a12015-09-28 23:53:55465} // namespace webrtc