deadbeef | 6979b02 | 2015-09-24 23:47:53 | [diff] [blame] | 1 | /* |
kjellander | b24317b | 2016-02-10 15:54:43 | [diff] [blame] | 2 | * Copyright 2015 The WebRTC project authors. All Rights Reserved. |
deadbeef | 6979b02 | 2015-09-24 23:47:53 | [diff] [blame] | 3 | * |
kjellander | b24317b | 2016-02-10 15:54:43 | [diff] [blame] | 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. |
deadbeef | 6979b02 | 2015-09-24 23:47:53 | [diff] [blame] | 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 11 | #include "pc/rtpreceiver.h" |
deadbeef | 6979b02 | 2015-09-24 23:47:53 | [diff] [blame] | 12 | |
Henrik Boström | 9e6fd2b | 2017-11-21 12:41:51 | [diff] [blame] | 13 | #include <utility> |
Steve Anton | 36b29d1 | 2017-10-30 16:57:42 | [diff] [blame] | 14 | #include <vector> |
| 15 | |
Henrik Boström | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 16 | #include "api/mediastreamproxy.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 17 | #include "api/mediastreamtrackproxy.h" |
| 18 | #include "api/videosourceproxy.h" |
| 19 | #include "pc/audiotrack.h" |
Henrik Boström | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 20 | #include "pc/mediastream.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 21 | #include "pc/videotrack.h" |
| 22 | #include "rtc_base/trace_event.h" |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 23 | |
| 24 | namespace webrtc { |
| 25 | |
Harald Alvestrand | c72af93 | 2018-01-11 16:18:19 | [diff] [blame] | 26 | namespace { |
| 27 | |
| 28 | // This function is only expected to be called on the signalling thread. |
| 29 | int GenerateUniqueId() { |
| 30 | static int g_unique_id = 0; |
| 31 | |
| 32 | return ++g_unique_id; |
| 33 | } |
| 34 | |
Henrik Boström | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 35 | std::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 Wright | 84583f6 | 2018-10-04 21:22:34 | [diff] [blame] | 46 | // 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. |
| 49 | void MaybeAttachFrameDecryptorToMediaChannel( |
| 50 | const absl::optional<uint32_t>& ssrc, |
Benjamin Wright | bfd412e | 2018-09-10 21:06:02 | [diff] [blame] | 51 | rtc::Thread* worker_thread, |
Benjamin Wright | 84583f6 | 2018-10-04 21:22:34 | [diff] [blame] | 52 | rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor, |
Benjamin Wright | bfd412e | 2018-09-10 21:06:02 | [diff] [blame] | 53 | cricket::MediaChannel* media_channel) { |
Benjamin Wright | 6cc9cca | 2018-10-10 00:29:54 | [diff] [blame] | 54 | if (media_channel && frame_decryptor && ssrc.has_value()) { |
| 55 | worker_thread->Invoke<void>(RTC_FROM_HERE, [&] { |
Benjamin Wright | 84583f6 | 2018-10-04 21:22:34 | [diff] [blame] | 56 | media_channel->SetFrameDecryptor(*ssrc, frame_decryptor); |
Benjamin Wright | bfd412e | 2018-09-10 21:06:02 | [diff] [blame] | 57 | }); |
| 58 | } |
| 59 | } |
| 60 | |
Harald Alvestrand | c72af93 | 2018-01-11 16:18:19 | [diff] [blame] | 61 | } // namespace |
| 62 | |
Henrik Boström | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 63 | AudioRtpReceiver::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öm | 9e6fd2b | 2017-11-21 12:41:51 | [diff] [blame] | 70 | AudioRtpReceiver::AudioRtpReceiver( |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 71 | rtc::Thread* worker_thread, |
Steve Anton | 9158ef6 | 2017-11-27 21:01:52 | [diff] [blame] | 72 | const std::string& receiver_id, |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 73 | const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 74 | : worker_thread_(worker_thread), |
| 75 | id_(receiver_id), |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 76 | source_(new rtc::RefCountedObject<RemoteAudioSource>(worker_thread)), |
| 77 | track_(AudioTrackProxy::Create(rtc::Thread::Current(), |
| 78 | AudioTrack::Create(receiver_id, source_))), |
Harald Alvestrand | c72af93 | 2018-01-11 16:18:19 | [diff] [blame] | 79 | cached_track_enabled_(track_->enabled()), |
| 80 | attachment_id_(GenerateUniqueId()) { |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 81 | RTC_DCHECK(worker_thread_); |
tommi | 6eca7e3 | 2015-12-15 12:27:11 | [diff] [blame] | 82 | RTC_DCHECK(track_->GetSource()->remote()); |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 83 | track_->RegisterObserver(this); |
| 84 | track_->GetSource()->RegisterAudioObserver(this); |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 85 | SetStreams(streams); |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | AudioRtpReceiver::~AudioRtpReceiver() { |
| 89 | track_->GetSource()->UnregisterAudioObserver(this); |
| 90 | track_->UnregisterObserver(this); |
| 91 | Stop(); |
| 92 | } |
| 93 | |
| 94 | void AudioRtpReceiver::OnChanged() { |
| 95 | if (cached_track_enabled_ != track_->enabled()) { |
| 96 | cached_track_enabled_ = track_->enabled(); |
| 97 | Reconfigure(); |
| 98 | } |
| 99 | } |
| 100 | |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 101 | bool AudioRtpReceiver::SetOutputVolume(double volume) { |
| 102 | RTC_DCHECK_GE(volume, 0.0); |
| 103 | RTC_DCHECK_LE(volume, 10.0); |
| 104 | RTC_DCHECK(media_channel_); |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 105 | RTC_DCHECK(ssrc_); |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 106 | return worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] { |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 107 | return media_channel_->SetOutputVolume(*ssrc_, volume); |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 108 | }); |
| 109 | } |
| 110 | |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 111 | void AudioRtpReceiver::OnSetVolume(double volume) { |
kwiberg | ee89e78 | 2017-08-10 00:22:01 | [diff] [blame] | 112 | RTC_DCHECK_GE(volume, 0); |
| 113 | RTC_DCHECK_LE(volume, 10); |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 114 | cached_volume_ = volume; |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 115 | if (!media_channel_ || !ssrc_) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 116 | RTC_LOG(LS_ERROR) |
| 117 | << "AudioRtpReceiver::OnSetVolume: No audio channel exists."; |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 118 | return; |
| 119 | } |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 120 | // 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 Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 123 | if (!stopped_ && track_->enabled()) { |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 124 | if (!SetOutputVolume(cached_volume_)) { |
nisse | eb4ca4e | 2017-01-12 10:24:27 | [diff] [blame] | 125 | RTC_NOTREACHED(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 126 | } |
| 127 | } |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 128 | } |
| 129 | |
Henrik Boström | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 130 | std::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 Brandstetter | db0cd9e | 2016-05-16 18:40:30 | [diff] [blame] | 137 | RtpParameters AudioRtpReceiver::GetParameters() const { |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 138 | if (!media_channel_ || !ssrc_ || stopped_) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 139 | return RtpParameters(); |
| 140 | } |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 141 | return worker_thread_->Invoke<RtpParameters>(RTC_FROM_HERE, [&] { |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 142 | return media_channel_->GetRtpReceiveParameters(*ssrc_); |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 143 | }); |
Taylor Brandstetter | db0cd9e | 2016-05-16 18:40:30 | [diff] [blame] | 144 | } |
| 145 | |
| 146 | bool AudioRtpReceiver::SetParameters(const RtpParameters& parameters) { |
| 147 | TRACE_EVENT0("webrtc", "AudioRtpReceiver::SetParameters"); |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 148 | if (!media_channel_ || !ssrc_ || stopped_) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 149 | return false; |
| 150 | } |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 151 | return worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] { |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 152 | return media_channel_->SetRtpReceiveParameters(*ssrc_, parameters); |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 153 | }); |
Taylor Brandstetter | db0cd9e | 2016-05-16 18:40:30 | [diff] [blame] | 154 | } |
| 155 | |
Benjamin Wright | d81ac95 | 2018-08-30 00:02:10 | [diff] [blame] | 156 | void AudioRtpReceiver::SetFrameDecryptor( |
| 157 | rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) { |
| 158 | frame_decryptor_ = std::move(frame_decryptor); |
Benjamin Wright | 6cc9cca | 2018-10-10 00:29:54 | [diff] [blame] | 159 | // 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 Wright | d81ac95 | 2018-08-30 00:02:10 | [diff] [blame] | 165 | } |
| 166 | |
| 167 | rtc::scoped_refptr<FrameDecryptorInterface> |
| 168 | AudioRtpReceiver::GetFrameDecryptor() const { |
| 169 | return frame_decryptor_; |
| 170 | } |
| 171 | |
deadbeef | a601f5c | 2016-06-06 21:27:39 | [diff] [blame] | 172 | void AudioRtpReceiver::Stop() { |
| 173 | // TODO(deadbeef): Need to do more here to fully stop receiving packets. |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 174 | if (stopped_) { |
deadbeef | a601f5c | 2016-06-06 21:27:39 | [diff] [blame] | 175 | return; |
| 176 | } |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 177 | if (media_channel_ && ssrc_) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 178 | // Allow that SetOutputVolume fail. This is the normal case when the |
| 179 | // underlying media channel has already been deleted. |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 180 | SetOutputVolume(0.0); |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 181 | } |
| 182 | stopped_ = true; |
deadbeef | a601f5c | 2016-06-06 21:27:39 | [diff] [blame] | 183 | } |
| 184 | |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 185 | void 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öm | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 202 | void AudioRtpReceiver::set_stream_ids(std::vector<std::string> stream_ids) { |
| 203 | SetStreams(CreateStreamsFromIds(std::move(stream_ids))); |
| 204 | } |
| 205 | |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 206 | void 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 Hampson | 13b8bad | 2018-03-13 23:05:28 | [diff] [blame] | 212 | if (existing_stream->id() == stream->id()) { |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 213 | 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 Hampson | 13b8bad | 2018-03-13 23:05:28 | [diff] [blame] | 226 | if (stream->id() == existing_stream->id()) { |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 227 | 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 | |
hbos | 8d609f6 | 2017-04-10 14:39:05 | [diff] [blame] | 239 | std::vector<RtpSource> AudioRtpReceiver::GetSources() const { |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 240 | if (!media_channel_ || !ssrc_ || stopped_) { |
| 241 | return {}; |
| 242 | } |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 243 | return worker_thread_->Invoke<std::vector<RtpSource>>( |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 244 | RTC_FROM_HERE, [&] { return media_channel_->GetSources(*ssrc_); }); |
hbos | 8d609f6 | 2017-04-10 14:39:05 | [diff] [blame] | 245 | } |
| 246 | |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 247 | void AudioRtpReceiver::Reconfigure() { |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 248 | RTC_DCHECK(!stopped_); |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 249 | if (!media_channel_ || !ssrc_) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 250 | RTC_LOG(LS_ERROR) |
| 251 | << "AudioRtpReceiver::Reconfigure: No audio channel exists."; |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 252 | return; |
| 253 | } |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 254 | if (!SetOutputVolume(track_->enabled() ? cached_volume_ : 0)) { |
nisse | eb4ca4e | 2017-01-12 10:24:27 | [diff] [blame] | 255 | RTC_NOTREACHED(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 256 | } |
Benjamin Wright | 84583f6 | 2018-10-04 21:22:34 | [diff] [blame] | 257 | // Reattach the frame decryptor if we were reconfigured. |
| 258 | MaybeAttachFrameDecryptorToMediaChannel(ssrc_, worker_thread_, |
| 259 | frame_decryptor_, media_channel_); |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 260 | } |
| 261 | |
zhihuang | 184a3fd | 2016-06-14 18:47:14 | [diff] [blame] | 262 | void AudioRtpReceiver::SetObserver(RtpReceiverObserverInterface* observer) { |
| 263 | observer_ = observer; |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 264 | // Deliver any notifications the observer may have missed by being set late. |
zhihuang | c4adabf | 2016-12-07 18:36:40 | [diff] [blame] | 265 | if (received_first_packet_ && observer_) { |
zhihuang | 184a3fd | 2016-06-14 18:47:14 | [diff] [blame] | 266 | observer_->OnFirstPacketReceived(media_type()); |
| 267 | } |
| 268 | } |
| 269 | |
Benjamin Wright | bfd412e | 2018-09-10 21:06:02 | [diff] [blame] | 270 | void AudioRtpReceiver::SetVoiceMediaChannel( |
| 271 | cricket::VoiceMediaChannel* voice_media_channel) { |
| 272 | media_channel_ = voice_media_channel; |
Benjamin Wright | bfd412e | 2018-09-10 21:06:02 | [diff] [blame] | 273 | } |
| 274 | |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 275 | void AudioRtpReceiver::NotifyFirstPacketReceived() { |
zhihuang | 184a3fd | 2016-06-14 18:47:14 | [diff] [blame] | 276 | if (observer_) { |
| 277 | observer_->OnFirstPacketReceived(media_type()); |
| 278 | } |
| 279 | received_first_packet_ = true; |
| 280 | } |
| 281 | |
Henrik Boström | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 282 | VideoRtpReceiver::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öm | 9e6fd2b | 2017-11-21 12:41:51 | [diff] [blame] | 289 | VideoRtpReceiver::VideoRtpReceiver( |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 290 | rtc::Thread* worker_thread, |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 291 | const std::string& receiver_id, |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 292 | const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 293 | : worker_thread_(worker_thread), |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 294 | id_(receiver_id), |
Niels Möller | 5d67f82 | 2018-05-23 14:28:17 | [diff] [blame] | 295 | source_(new RefCountedObject<VideoRtpTrackSource>()), |
perkj | f0dcfe2 | 2016-03-10 17:32:00 | [diff] [blame] | 296 | track_(VideoTrackProxy::Create( |
| 297 | rtc::Thread::Current(), |
nisse | 5b68ab5 | 2016-04-07 14:45:54 | [diff] [blame] | 298 | worker_thread, |
| 299 | VideoTrack::Create( |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 300 | receiver_id, |
nisse | 5b68ab5 | 2016-04-07 14:45:54 | [diff] [blame] | 301 | VideoTrackSourceProxy::Create(rtc::Thread::Current(), |
| 302 | worker_thread, |
perkj | 773be36 | 2017-08-01 06:22:01 | [diff] [blame] | 303 | source_), |
Harald Alvestrand | c72af93 | 2018-01-11 16:18:19 | [diff] [blame] | 304 | worker_thread))), |
| 305 | attachment_id_(GenerateUniqueId()) { |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 306 | RTC_DCHECK(worker_thread_); |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 307 | SetStreams(streams); |
perkj | f0dcfe2 | 2016-03-10 17:32:00 | [diff] [blame] | 308 | source_->SetState(MediaSourceInterface::kLive); |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 309 | } |
| 310 | |
| 311 | VideoRtpReceiver::~VideoRtpReceiver() { |
| 312 | // Since cricket::VideoRenderer is not reference counted, |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 313 | // we need to remove it from the channel before we are deleted. |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 314 | Stop(); |
| 315 | } |
| 316 | |
Henrik Boström | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 317 | std::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 Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 324 | bool VideoRtpReceiver::SetSink(rtc::VideoSinkInterface<VideoFrame>* sink) { |
| 325 | RTC_DCHECK(media_channel_); |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 326 | RTC_DCHECK(ssrc_); |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 327 | return worker_thread_->Invoke<bool>( |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 328 | RTC_FROM_HERE, [&] { return media_channel_->SetSink(*ssrc_, sink); }); |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 329 | } |
| 330 | |
deadbeef | a601f5c | 2016-06-06 21:27:39 | [diff] [blame] | 331 | RtpParameters VideoRtpReceiver::GetParameters() const { |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 332 | if (!media_channel_ || !ssrc_ || stopped_) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 333 | return RtpParameters(); |
| 334 | } |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 335 | return worker_thread_->Invoke<RtpParameters>(RTC_FROM_HERE, [&] { |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 336 | return media_channel_->GetRtpReceiveParameters(*ssrc_); |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 337 | }); |
deadbeef | a601f5c | 2016-06-06 21:27:39 | [diff] [blame] | 338 | } |
| 339 | |
| 340 | bool VideoRtpReceiver::SetParameters(const RtpParameters& parameters) { |
| 341 | TRACE_EVENT0("webrtc", "VideoRtpReceiver::SetParameters"); |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 342 | if (!media_channel_ || !ssrc_ || stopped_) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 343 | return false; |
| 344 | } |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 345 | return worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] { |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 346 | return media_channel_->SetRtpReceiveParameters(*ssrc_, parameters); |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 347 | }); |
deadbeef | a601f5c | 2016-06-06 21:27:39 | [diff] [blame] | 348 | } |
| 349 | |
Benjamin Wright | d81ac95 | 2018-08-30 00:02:10 | [diff] [blame] | 350 | void VideoRtpReceiver::SetFrameDecryptor( |
| 351 | rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) { |
| 352 | frame_decryptor_ = std::move(frame_decryptor); |
Benjamin Wright | 6cc9cca | 2018-10-10 00:29:54 | [diff] [blame] | 353 | // 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 Wright | d81ac95 | 2018-08-30 00:02:10 | [diff] [blame] | 359 | } |
| 360 | |
| 361 | rtc::scoped_refptr<FrameDecryptorInterface> |
| 362 | VideoRtpReceiver::GetFrameDecryptor() const { |
| 363 | return frame_decryptor_; |
| 364 | } |
| 365 | |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 366 | void VideoRtpReceiver::Stop() { |
| 367 | // TODO(deadbeef): Need to do more here to fully stop receiving packets. |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 368 | if (stopped_) { |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 369 | return; |
| 370 | } |
perkj | f0dcfe2 | 2016-03-10 17:32:00 | [diff] [blame] | 371 | source_->SetState(MediaSourceInterface::kEnded); |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 372 | if (!media_channel_ || !ssrc_) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 373 | RTC_LOG(LS_WARNING) << "VideoRtpReceiver::Stop: No video channel exists."; |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 374 | } else { |
| 375 | // Allow that SetSink fail. This is the normal case when the underlying |
| 376 | // media channel has already been deleted. |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 377 | SetSink(nullptr); |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 378 | } |
| 379 | stopped_ = true; |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 380 | } |
| 381 | |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 382 | void 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öller | 5d67f82 | 2018-05-23 14:28:17 | [diff] [blame] | 394 | SetSink(source_->sink()); |
Benjamin Wright | 84583f6 | 2018-10-04 21:22:34 | [diff] [blame] | 395 | // Attach any existing frame decryptor to the media channel. |
| 396 | MaybeAttachFrameDecryptorToMediaChannel(ssrc_, worker_thread_, |
| 397 | frame_decryptor_, media_channel_); |
Steve Anton | d367921 | 2018-01-18 01:41:02 | [diff] [blame] | 398 | } |
| 399 | |
Henrik Boström | 199e27b | 2018-07-04 18:51:53 | [diff] [blame] | 400 | void VideoRtpReceiver::set_stream_ids(std::vector<std::string> stream_ids) { |
| 401 | SetStreams(CreateStreamsFromIds(std::move(stream_ids))); |
| 402 | } |
| 403 | |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 404 | void 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 Hampson | 13b8bad | 2018-03-13 23:05:28 | [diff] [blame] | 410 | if (existing_stream->id() == stream->id()) { |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 411 | 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 Hampson | 13b8bad | 2018-03-13 23:05:28 | [diff] [blame] | 424 | if (stream->id() == existing_stream->id()) { |
Steve Anton | ef65ef1 | 2018-01-11 01:15:20 | [diff] [blame] | 425 | 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 | |
zhihuang | 184a3fd | 2016-06-14 18:47:14 | [diff] [blame] | 437 | void VideoRtpReceiver::SetObserver(RtpReceiverObserverInterface* observer) { |
| 438 | observer_ = observer; |
Taylor Brandstetter | ba29c6a | 2016-06-27 23:30:35 | [diff] [blame] | 439 | // Deliver any notifications the observer may have missed by being set late. |
zhihuang | c4adabf | 2016-12-07 18:36:40 | [diff] [blame] | 440 | if (received_first_packet_ && observer_) { |
zhihuang | 184a3fd | 2016-06-14 18:47:14 | [diff] [blame] | 441 | observer_->OnFirstPacketReceived(media_type()); |
| 442 | } |
| 443 | } |
| 444 | |
Benjamin Wright | bfd412e | 2018-09-10 21:06:02 | [diff] [blame] | 445 | void VideoRtpReceiver::SetVideoMediaChannel( |
| 446 | cricket::VideoMediaChannel* video_media_channel) { |
| 447 | media_channel_ = video_media_channel; |
Benjamin Wright | bfd412e | 2018-09-10 21:06:02 | [diff] [blame] | 448 | } |
| 449 | |
Steve Anton | 6077675 | 2018-01-10 19:51:34 | [diff] [blame] | 450 | void VideoRtpReceiver::NotifyFirstPacketReceived() { |
zhihuang | 184a3fd | 2016-06-14 18:47:14 | [diff] [blame] | 451 | if (observer_) { |
| 452 | observer_->OnFirstPacketReceived(media_type()); |
| 453 | } |
| 454 | received_first_packet_ = true; |
| 455 | } |
| 456 | |
Jonas Oreland | 49ac595 | 2018-09-26 14:04:32 | [diff] [blame] | 457 | std::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 | |
deadbeef | 70ab1a1 | 2015-09-28 23:53:55 | [diff] [blame] | 465 | } // namespace webrtc |