pc/video_rtp_receiver.cc - src - Git at Google

 /*
  *  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.
  */

 #include "pc/video_rtp_receiver.h"

 #include <stddef.h>

 #include <utility>
 #include <vector>

 #include "api/video/recordable_encoded_frame.h"
 #include "api/video_track_source_proxy_factory.h"
 #include "pc/video_track.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/location.h"
 #include "rtc_base/logging.h"

 namespace webrtc {

 VideoRtpReceiver::VideoRtpReceiver(rtc::Thread* worker_thread,
                                    std::string receiver_id,
                                    std::vector<std::string> stream_ids)
     : VideoRtpReceiver(worker_thread,
                        receiver_id,
                        CreateStreamsFromIds(std::move(stream_ids))) {}

 VideoRtpReceiver::VideoRtpReceiver(
     rtc::Thread* worker_thread,
     const std::string& receiver_id,
     const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams)
     : worker_thread_(worker_thread),
       id_(receiver_id),
       source_(rtc::make_ref_counted<VideoRtpTrackSource>(&source_callback_)),
       track_(VideoTrackProxyWithInternal<VideoTrack>::Create(
           rtc::Thread::Current(),
           worker_thread,
           VideoTrack::Create(receiver_id,
                              CreateVideoTrackSourceProxy(rtc::Thread::Current(),
                                                          worker_thread,
                                                          source_),
                              worker_thread))),
       attachment_id_(GenerateUniqueId()) {
   RTC_DCHECK(worker_thread_);
   SetStreams(streams);
   RTC_DCHECK_EQ(source_->state(), MediaSourceInterface::kLive);
 }

 VideoRtpReceiver::~VideoRtpReceiver() {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   RTC_DCHECK(stopped_);
   RTC_DCHECK(!media_channel_);
 }

 std::vector<std::string> VideoRtpReceiver::stream_ids() const {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   std::vector<std::string> stream_ids(streams_.size());
   for (size_t i = 0; i < streams_.size(); ++i)
     stream_ids[i] = streams_[i]->id();
   return stream_ids;
 }

 rtc::scoped_refptr<DtlsTransportInterface> VideoRtpReceiver::dtls_transport()
     const {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   return dtls_transport_;
 }

 std::vector<rtc::scoped_refptr<MediaStreamInterface>>
 VideoRtpReceiver::streams() const {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   return streams_;
 }

 RtpParameters VideoRtpReceiver::GetParameters() const {
   RTC_DCHECK_RUN_ON(worker_thread_);
   if (!media_channel_)
     return RtpParameters();
   return ssrc_ ? media_channel_->GetRtpReceiveParameters(*ssrc_)
                : media_channel_->GetDefaultRtpReceiveParameters();
 }

 void VideoRtpReceiver::SetFrameDecryptor(
     rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   frame_decryptor_ = std::move(frame_decryptor);
   // Special Case: Set the frame decryptor to any value on any existing channel.
   if (media_channel_ && ssrc_) {
     media_channel_->SetFrameDecryptor(*ssrc_, frame_decryptor_);
   }
 }

 rtc::scoped_refptr<FrameDecryptorInterface>
 VideoRtpReceiver::GetFrameDecryptor() const {
   RTC_DCHECK_RUN_ON(worker_thread_);
   return frame_decryptor_;
 }

 void VideoRtpReceiver::SetDepacketizerToDecoderFrameTransformer(
     rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   frame_transformer_ = std::move(frame_transformer);
   if (media_channel_) {
     media_channel_->SetDepacketizerToDecoderFrameTransformer(
         ssrc_.value_or(0), frame_transformer_);
   }
 }

 void VideoRtpReceiver::Stop() {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   // TODO(deadbeef): Need to do more here to fully stop receiving packets.

   if (!stopped_) {
     source_->SetState(MediaSourceInterface::kEnded);
     stopped_ = true;
   }

   worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
     RTC_DCHECK_RUN_ON(worker_thread_);
     if (media_channel_) {
       SetSink(nullptr);
       SetMediaChannel_w(nullptr);
     }
     source_->ClearCallback();
   });
 }

 void VideoRtpReceiver::StopAndEndTrack() {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   Stop();
   track_->internal()->set_ended();
 }

 void VideoRtpReceiver::RestartMediaChannel(absl::optional<uint32_t> ssrc) {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);

   // `stopped_` will be `true` on construction. RestartMediaChannel
   // can in this case function like "ensure started" and flip `stopped_`
   // to false.

   // TODO(tommi): Can we restart the media channel without blocking?
   bool ok = worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&, was_stopped =
                                                                 stopped_] {
     RTC_DCHECK_RUN_ON(worker_thread_);
     if (!media_channel_) {
       // Ignore further negotiations if we've already been stopped and don't
       // have an associated media channel.
       RTC_DCHECK(was_stopped);
       return false;  // Can't restart.
     }

     if (!was_stopped && ssrc_ == ssrc) {
       // Already running with that ssrc.
       return true;
     }

     // Disconnect from the previous ssrc.
     if (!was_stopped) {
       SetSink(nullptr);
     }

     bool encoded_sink_enabled = saved_encoded_sink_enabled_;
     SetEncodedSinkEnabled(false);

     // Set up the new ssrc.
     ssrc_ = std::move(ssrc);
     SetSink(source_->sink());
     if (encoded_sink_enabled) {
       SetEncodedSinkEnabled(true);
     }

     if (frame_transformer_ && media_channel_) {
       media_channel_->SetDepacketizerToDecoderFrameTransformer(
           ssrc_.value_or(0), frame_transformer_);
     }

     if (media_channel_ && ssrc_) {
       if (frame_decryptor_) {
         media_channel_->SetFrameDecryptor(*ssrc_, frame_decryptor_);
       }

       media_channel_->SetBaseMinimumPlayoutDelayMs(*ssrc_, delay_.GetMs());
     }

     return true;
   });

   if (!ok)
     return;

   stopped_ = false;
 }

 // RTC_RUN_ON(worker_thread_)
 void VideoRtpReceiver::SetSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
   if (ssrc_) {
     media_channel_->SetSink(*ssrc_, sink);
   } else {
     media_channel_->SetDefaultSink(sink);
   }
 }

 void VideoRtpReceiver::SetupMediaChannel(uint32_t ssrc) {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   RestartMediaChannel(ssrc);
 }

 void VideoRtpReceiver::SetupUnsignaledMediaChannel() {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   RestartMediaChannel(absl::nullopt);
 }

 uint32_t VideoRtpReceiver::ssrc() const {
   RTC_DCHECK_RUN_ON(worker_thread_);
   return ssrc_.value_or(0);
 }

 void VideoRtpReceiver::set_stream_ids(std::vector<std::string> stream_ids) {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   SetStreams(CreateStreamsFromIds(std::move(stream_ids)));
 }

 void VideoRtpReceiver::set_transport(
     rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   dtls_transport_ = std::move(dtls_transport);
 }

 void VideoRtpReceiver::SetStreams(
     const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   // Remove remote track from any streams that are going away.
   for (const auto& existing_stream : streams_) {
     bool removed = true;
     for (const auto& stream : streams) {
       if (existing_stream->id() == stream->id()) {
         RTC_DCHECK_EQ(existing_stream.get(), stream.get());
         removed = false;
         break;
       }
     }
     if (removed) {
       existing_stream->RemoveTrack(track_);
     }
   }
   // Add remote track to any streams that are new.
   for (const auto& stream : streams) {
     bool added = true;
     for (const auto& existing_stream : streams_) {
       if (stream->id() == existing_stream->id()) {
         RTC_DCHECK_EQ(stream.get(), existing_stream.get());
         added = false;
         break;
       }
     }
     if (added) {
       stream->AddTrack(track_);
     }
   }
   streams_ = streams;
 }

 void VideoRtpReceiver::SetObserver(RtpReceiverObserverInterface* observer) {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   observer_ = observer;
   // Deliver any notifications the observer may have missed by being set late.
   if (received_first_packet_ && observer_) {
     observer_->OnFirstPacketReceived(media_type());
   }
 }

 void VideoRtpReceiver::SetJitterBufferMinimumDelay(
     absl::optional<double> delay_seconds) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   delay_.Set(delay_seconds);
   if (media_channel_ && ssrc_)
     media_channel_->SetBaseMinimumPlayoutDelayMs(*ssrc_, delay_.GetMs());
 }

 void VideoRtpReceiver::SetMediaChannel(cricket::MediaChannel* media_channel) {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   RTC_DCHECK(media_channel == nullptr ||
              media_channel->media_type() == media_type());

   if (stopped_ && !media_channel)
     return;

   worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
     RTC_DCHECK_RUN_ON(worker_thread_);
     SetMediaChannel_w(media_channel);
   });
 }

 // RTC_RUN_ON(worker_thread_)
 void VideoRtpReceiver::SetMediaChannel_w(cricket::MediaChannel* media_channel) {
   if (media_channel == media_channel_)
     return;

   bool encoded_sink_enabled = saved_encoded_sink_enabled_;
   if (encoded_sink_enabled && media_channel_) {
     // Turn off the old sink, if any.
     SetEncodedSinkEnabled(false);
   }

   media_channel_ = static_cast<cricket::VideoMediaChannel*>(media_channel);

   if (media_channel_) {
     if (saved_generate_keyframe_) {
       // TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC
       media_channel_->GenerateKeyFrame(ssrc_.value_or(0));
       saved_generate_keyframe_ = false;
     }
     if (encoded_sink_enabled) {
       SetEncodedSinkEnabled(true);
     }
     if (frame_transformer_) {
       media_channel_->SetDepacketizerToDecoderFrameTransformer(
           ssrc_.value_or(0), frame_transformer_);
     }
   }
 }

 void VideoRtpReceiver::NotifyFirstPacketReceived() {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
   if (observer_) {
     observer_->OnFirstPacketReceived(media_type());
   }
   received_first_packet_ = true;
 }

 std::vector<RtpSource> VideoRtpReceiver::GetSources() const {
   RTC_DCHECK_RUN_ON(worker_thread_);
   if (!ssrc_ || !media_channel_)
     return std::vector<RtpSource>();
   return media_channel_->GetSources(*ssrc_);
 }

 void VideoRtpReceiver::OnGenerateKeyFrame() {
   RTC_DCHECK_RUN_ON(worker_thread_);
   if (!media_channel_) {
     RTC_LOG(LS_ERROR)
         << "VideoRtpReceiver::OnGenerateKeyFrame: No video channel exists.";
     return;
   }
   // TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC
   media_channel_->GenerateKeyFrame(ssrc_.value_or(0));
   // We need to remember to request generation of a new key frame if the media
   // channel changes, because there's no feedback whether the keyframe
   // generation has completed on the channel.
   saved_generate_keyframe_ = true;
 }

 void VideoRtpReceiver::OnEncodedSinkEnabled(bool enable) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   SetEncodedSinkEnabled(enable);
   // Always save the latest state of the callback in case the media_channel_
   // changes.
   saved_encoded_sink_enabled_ = enable;
 }

 // RTC_RUN_ON(worker_thread_)
 void VideoRtpReceiver::SetEncodedSinkEnabled(bool enable) {
   if (!media_channel_)
     return;

   // TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC
   const auto ssrc = ssrc_.value_or(0);

   if (enable) {
     media_channel_->SetRecordableEncodedFrameCallback(
         ssrc, [source = source_](const RecordableEncodedFrame& frame) {
           source->BroadcastRecordableEncodedFrame(frame);
         });
   } else {
     media_channel_->ClearRecordableEncodedFrameCallback(ssrc);
   }
 }

 }  // namespace webrtc
	/*
	* 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.
	*/

	#include "pc/video_rtp_receiver.h"

	#include <stddef.h>

	#include <utility>
	#include <vector>

	#include "api/video/recordable_encoded_frame.h"
	#include "api/video_track_source_proxy_factory.h"
	#include "pc/video_track.h"
	#include "rtc_base/checks.h"
	#include "rtc_base/location.h"
	#include "rtc_base/logging.h"

	namespace webrtc {

	VideoRtpReceiver::VideoRtpReceiver(rtc::Thread* worker_thread,
	std::string receiver_id,
	std::vector<std::string> stream_ids)
	: VideoRtpReceiver(worker_thread,
	receiver_id,
	CreateStreamsFromIds(std::move(stream_ids))) {}

	VideoRtpReceiver::VideoRtpReceiver(
	rtc::Thread* worker_thread,
	const std::string& receiver_id,
	const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams)
	: worker_thread_(worker_thread),
	id_(receiver_id),
	source_(rtc::make_ref_counted<VideoRtpTrackSource>(&source_callback_)),
	track_(VideoTrackProxyWithInternal<VideoTrack>::Create(
	rtc::Thread::Current(),
	worker_thread,
	VideoTrack::Create(receiver_id,
	CreateVideoTrackSourceProxy(rtc::Thread::Current(),
	worker_thread,
	source_),
	worker_thread))),
	attachment_id_(GenerateUniqueId()) {
	RTC_DCHECK(worker_thread_);
	SetStreams(streams);
	RTC_DCHECK_EQ(source_->state(), MediaSourceInterface::kLive);
	}

	VideoRtpReceiver::~VideoRtpReceiver() {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	RTC_DCHECK(stopped_);
	RTC_DCHECK(!media_channel_);
	}

	std::vector<std::string> VideoRtpReceiver::stream_ids() const {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	std::vector<std::string> stream_ids(streams_.size());
	for (size_t i = 0; i < streams_.size(); ++i)
	stream_ids[i] = streams_[i]->id();
	return stream_ids;
	}

	rtc::scoped_refptr<DtlsTransportInterface> VideoRtpReceiver::dtls_transport()
	const {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	return dtls_transport_;
	}

	std::vector<rtc::scoped_refptr<MediaStreamInterface>>
	VideoRtpReceiver::streams() const {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	return streams_;
	}

	RtpParameters VideoRtpReceiver::GetParameters() const {
	RTC_DCHECK_RUN_ON(worker_thread_);
	if (!media_channel_)
	return RtpParameters();
	return ssrc_ ? media_channel_->GetRtpReceiveParameters(*ssrc_)
	: media_channel_->GetDefaultRtpReceiveParameters();
	}

	void VideoRtpReceiver::SetFrameDecryptor(
	rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
	RTC_DCHECK_RUN_ON(worker_thread_);
	frame_decryptor_ = std::move(frame_decryptor);
	// Special Case: Set the frame decryptor to any value on any existing channel.
	if (media_channel_ && ssrc_) {
	media_channel_->SetFrameDecryptor(*ssrc_, frame_decryptor_);
	}
	}

	rtc::scoped_refptr<FrameDecryptorInterface>
	VideoRtpReceiver::GetFrameDecryptor() const {
	RTC_DCHECK_RUN_ON(worker_thread_);
	return frame_decryptor_;
	}

	void VideoRtpReceiver::SetDepacketizerToDecoderFrameTransformer(
	rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
	RTC_DCHECK_RUN_ON(worker_thread_);
	frame_transformer_ = std::move(frame_transformer);
	if (media_channel_) {
	media_channel_->SetDepacketizerToDecoderFrameTransformer(
	ssrc_.value_or(0), frame_transformer_);
	}
	}

	void VideoRtpReceiver::Stop() {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	// TODO(deadbeef): Need to do more here to fully stop receiving packets.

	if (!stopped_) {
	source_->SetState(MediaSourceInterface::kEnded);
	stopped_ = true;
	}

	worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
	RTC_DCHECK_RUN_ON(worker_thread_);
	if (media_channel_) {
	SetSink(nullptr);
	SetMediaChannel_w(nullptr);
	}
	source_->ClearCallback();
	});
	}

	void VideoRtpReceiver::StopAndEndTrack() {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	Stop();
	track_->internal()->set_ended();
	}

	void VideoRtpReceiver::RestartMediaChannel(absl::optional<uint32_t> ssrc) {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);

	// `stopped_` will be `true` on construction. RestartMediaChannel
	// can in this case function like "ensure started" and flip `stopped_`
	// to false.

	// TODO(tommi): Can we restart the media channel without blocking?
	bool ok = worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&, was_stopped =
	stopped_] {
	RTC_DCHECK_RUN_ON(worker_thread_);
	if (!media_channel_) {
	// Ignore further negotiations if we've already been stopped and don't
	// have an associated media channel.
	RTC_DCHECK(was_stopped);
	return false; // Can't restart.
	}

	if (!was_stopped && ssrc_ == ssrc) {
	// Already running with that ssrc.
	return true;
	}

	// Disconnect from the previous ssrc.
	if (!was_stopped) {
	SetSink(nullptr);
	}

	bool encoded_sink_enabled = saved_encoded_sink_enabled_;
	SetEncodedSinkEnabled(false);

	// Set up the new ssrc.
	ssrc_ = std::move(ssrc);
	SetSink(source_->sink());
	if (encoded_sink_enabled) {
	SetEncodedSinkEnabled(true);
	}

	if (frame_transformer_ && media_channel_) {
	media_channel_->SetDepacketizerToDecoderFrameTransformer(
	ssrc_.value_or(0), frame_transformer_);
	}

	if (media_channel_ && ssrc_) {
	if (frame_decryptor_) {
	media_channel_->SetFrameDecryptor(*ssrc_, frame_decryptor_);
	}

	media_channel_->SetBaseMinimumPlayoutDelayMs(*ssrc_, delay_.GetMs());
	}

	return true;
	});

	if (!ok)
	return;

	stopped_ = false;
	}

	// RTC_RUN_ON(worker_thread_)
	void VideoRtpReceiver::SetSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
	if (ssrc_) {
	media_channel_->SetSink(*ssrc_, sink);
	} else {
	media_channel_->SetDefaultSink(sink);
	}
	}

	void VideoRtpReceiver::SetupMediaChannel(uint32_t ssrc) {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	RestartMediaChannel(ssrc);
	}

	void VideoRtpReceiver::SetupUnsignaledMediaChannel() {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	RestartMediaChannel(absl::nullopt);
	}

	uint32_t VideoRtpReceiver::ssrc() const {
	RTC_DCHECK_RUN_ON(worker_thread_);
	return ssrc_.value_or(0);
	}

	void VideoRtpReceiver::set_stream_ids(std::vector<std::string> stream_ids) {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	SetStreams(CreateStreamsFromIds(std::move(stream_ids)));
	}

	void VideoRtpReceiver::set_transport(
	rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	dtls_transport_ = std::move(dtls_transport);
	}

	void VideoRtpReceiver::SetStreams(
	const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	// Remove remote track from any streams that are going away.
	for (const auto& existing_stream : streams_) {
	bool removed = true;
	for (const auto& stream : streams) {
	if (existing_stream->id() == stream->id()) {
	RTC_DCHECK_EQ(existing_stream.get(), stream.get());
	removed = false;
	break;
	}
	}
	if (removed) {
	existing_stream->RemoveTrack(track_);
	}
	}
	// Add remote track to any streams that are new.
	for (const auto& stream : streams) {
	bool added = true;
	for (const auto& existing_stream : streams_) {
	if (stream->id() == existing_stream->id()) {
	RTC_DCHECK_EQ(stream.get(), existing_stream.get());
	added = false;
	break;
	}
	}
	if (added) {
	stream->AddTrack(track_);
	}
	}
	streams_ = streams;
	}

	void VideoRtpReceiver::SetObserver(RtpReceiverObserverInterface* observer) {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	observer_ = observer;
	// Deliver any notifications the observer may have missed by being set late.
	if (received_first_packet_ && observer_) {
	observer_->OnFirstPacketReceived(media_type());
	}
	}

	void VideoRtpReceiver::SetJitterBufferMinimumDelay(
	absl::optional<double> delay_seconds) {
	RTC_DCHECK_RUN_ON(worker_thread_);
	delay_.Set(delay_seconds);
	if (media_channel_ && ssrc_)
	media_channel_->SetBaseMinimumPlayoutDelayMs(*ssrc_, delay_.GetMs());
	}

	void VideoRtpReceiver::SetMediaChannel(cricket::MediaChannel* media_channel) {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	RTC_DCHECK(media_channel == nullptr \|\|
	media_channel->media_type() == media_type());

	if (stopped_ && !media_channel)
	return;

	worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
	RTC_DCHECK_RUN_ON(worker_thread_);
	SetMediaChannel_w(media_channel);
	});
	}

	// RTC_RUN_ON(worker_thread_)
	void VideoRtpReceiver::SetMediaChannel_w(cricket::MediaChannel* media_channel) {
	if (media_channel == media_channel_)
	return;

	bool encoded_sink_enabled = saved_encoded_sink_enabled_;
	if (encoded_sink_enabled && media_channel_) {
	// Turn off the old sink, if any.
	SetEncodedSinkEnabled(false);
	}

	media_channel_ = static_cast<cricket::VideoMediaChannel*>(media_channel);

	if (media_channel_) {
	if (saved_generate_keyframe_) {
	// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC
	media_channel_->GenerateKeyFrame(ssrc_.value_or(0));
	saved_generate_keyframe_ = false;
	}
	if (encoded_sink_enabled) {
	SetEncodedSinkEnabled(true);
	}
	if (frame_transformer_) {
	media_channel_->SetDepacketizerToDecoderFrameTransformer(
	ssrc_.value_or(0), frame_transformer_);
	}
	}
	}

	void VideoRtpReceiver::NotifyFirstPacketReceived() {
	RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
	if (observer_) {
	observer_->OnFirstPacketReceived(media_type());
	}
	received_first_packet_ = true;
	}

	std::vector<RtpSource> VideoRtpReceiver::GetSources() const {
	RTC_DCHECK_RUN_ON(worker_thread_);
	if (!ssrc_ \|\| !media_channel_)
	return std::vector<RtpSource>();
	return media_channel_->GetSources(*ssrc_);
	}

	void VideoRtpReceiver::OnGenerateKeyFrame() {
	RTC_DCHECK_RUN_ON(worker_thread_);
	if (!media_channel_) {
	RTC_LOG(LS_ERROR)
	<< "VideoRtpReceiver::OnGenerateKeyFrame: No video channel exists.";
	return;
	}
	// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC
	media_channel_->GenerateKeyFrame(ssrc_.value_or(0));
	// We need to remember to request generation of a new key frame if the media
	// channel changes, because there's no feedback whether the keyframe
	// generation has completed on the channel.
	saved_generate_keyframe_ = true;
	}

	void VideoRtpReceiver::OnEncodedSinkEnabled(bool enable) {
	RTC_DCHECK_RUN_ON(worker_thread_);
	SetEncodedSinkEnabled(enable);
	// Always save the latest state of the callback in case the media_channel_
	// changes.
	saved_encoded_sink_enabled_ = enable;
	}

	// RTC_RUN_ON(worker_thread_)
	void VideoRtpReceiver::SetEncodedSinkEnabled(bool enable) {
	if (!media_channel_)
	return;

	// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC
	const auto ssrc = ssrc_.value_or(0);

	if (enable) {
	media_channel_->SetRecordableEncodedFrameCallback(
	ssrc, [source = source_](const RecordableEncodedFrame& frame) {
	source->BroadcastRecordableEncodedFrame(frame);
	});
	} else {
	media_channel_->ClearRecordableEncodedFrameCallback(ssrc);
	}
	}

	} // namespace webrtc