blob: 8a2e65c1622d228c4acceac70ca3bac27c666b98 [file] [log] [blame]
/*
* 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 <string>
#include <utility>
#include <vector>
#include "api/video/recordable_encoded_frame.h"
#include "pc/video_track.h"
#include "rtc_base/checks.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, source_, worker_thread))),
attachment_id_(GenerateUniqueId()) {
RTC_DCHECK(worker_thread_);
SetStreams(streams);
RTC_DCHECK_EQ(source_->state(), MediaSourceInterface::kInitializing);
}
VideoRtpReceiver::~VideoRtpReceiver() {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
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();
auto current_ssrc = ssrc();
return current_ssrc.has_value()
? media_channel_->GetRtpReceiveParameters(current_ssrc.value())
: 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_ && signaled_ssrc_) {
media_channel_->SetFrameDecryptor(*signaled_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(
signaled_ssrc_.value_or(0), frame_transformer_);
}
}
void VideoRtpReceiver::Stop() {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
source_->SetState(MediaSourceInterface::kEnded);
track_->internal()->set_ended();
}
void VideoRtpReceiver::RestartMediaChannel(absl::optional<uint32_t> ssrc) {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
MediaSourceInterface::SourceState state = source_->state();
// TODO(tommi): Can we restart the media channel without blocking?
worker_thread_->BlockingCall([&] {
RTC_DCHECK_RUN_ON(worker_thread_);
RestartMediaChannel_w(std::move(ssrc), state);
});
source_->SetState(MediaSourceInterface::kLive);
}
void VideoRtpReceiver::RestartMediaChannel_w(
absl::optional<uint32_t> ssrc,
MediaSourceInterface::SourceState state) {
RTC_DCHECK_RUN_ON(worker_thread_);
if (!media_channel_) {
return; // Can't restart.
}
const bool encoded_sink_enabled = saved_encoded_sink_enabled_;
if (state != MediaSourceInterface::kInitializing) {
if (ssrc == signaled_ssrc_)
return;
// Disconnect from a previous ssrc.
SetSink(nullptr);
if (encoded_sink_enabled)
SetEncodedSinkEnabled(false);
}
// Set up the new ssrc.
signaled_ssrc_ = std::move(ssrc);
SetSink(source_->sink());
if (encoded_sink_enabled) {
SetEncodedSinkEnabled(true);
}
if (frame_transformer_ && media_channel_) {
media_channel_->SetDepacketizerToDecoderFrameTransformer(
signaled_ssrc_.value_or(0), frame_transformer_);
}
if (media_channel_ && signaled_ssrc_) {
if (frame_decryptor_) {
media_channel_->SetFrameDecryptor(*signaled_ssrc_, frame_decryptor_);
}
media_channel_->SetBaseMinimumPlayoutDelayMs(*signaled_ssrc_,
delay_.GetMs());
}
}
void VideoRtpReceiver::SetSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
RTC_DCHECK_RUN_ON(worker_thread_);
if (signaled_ssrc_) {
media_channel_->SetSink(*signaled_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);
}
absl::optional<uint32_t> VideoRtpReceiver::ssrc() const {
RTC_DCHECK_RUN_ON(worker_thread_);
if (!signaled_ssrc_.has_value() && media_channel_) {
return media_channel_->GetUnsignaledSsrc();
}
return signaled_ssrc_;
}
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(video_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(video_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_ && signaled_ssrc_)
media_channel_->SetBaseMinimumPlayoutDelayMs(*signaled_ssrc_,
delay_.GetMs());
}
void VideoRtpReceiver::SetMediaChannel(
cricket::MediaReceiveChannelInterface* media_channel) {
RTC_DCHECK_RUN_ON(worker_thread_);
RTC_DCHECK(media_channel == nullptr ||
media_channel->media_type() == media_type());
SetMediaChannel_w(media_channel);
}
void VideoRtpReceiver::SetMediaChannel_w(
cricket::MediaReceiveChannelInterface* media_channel) {
RTC_DCHECK_RUN_ON(worker_thread_);
if (media_channel == media_channel_)
return;
if (!media_channel) {
SetSink(nullptr);
}
bool encoded_sink_enabled = saved_encoded_sink_enabled_;
if (encoded_sink_enabled && media_channel_) {
// Turn off the old sink, if any.
SetEncodedSinkEnabled(false);
}
if (media_channel) {
media_channel_ = media_channel->AsVideoReceiveChannel();
} else {
media_channel_ = nullptr;
}
if (media_channel_) {
if (saved_generate_keyframe_) {
// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC
media_channel_->RequestRecvKeyFrame(signaled_ssrc_.value_or(0));
saved_generate_keyframe_ = false;
}
if (encoded_sink_enabled) {
SetEncodedSinkEnabled(true);
}
if (frame_transformer_) {
media_channel_->SetDepacketizerToDecoderFrameTransformer(
signaled_ssrc_.value_or(0), frame_transformer_);
}
}
if (!media_channel)
source_->ClearCallback();
}
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_);
auto current_ssrc = ssrc();
if (!media_channel_ || !current_ssrc.has_value()) {
return {};
}
return media_channel_->GetSources(current_ssrc.value());
}
void VideoRtpReceiver::SetupMediaChannel(
absl::optional<uint32_t> ssrc,
cricket::MediaReceiveChannelInterface* media_channel) {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
RTC_DCHECK(media_channel);
MediaSourceInterface::SourceState state = source_->state();
worker_thread_->BlockingCall([&] {
RTC_DCHECK_RUN_ON(worker_thread_);
SetMediaChannel_w(media_channel);
RestartMediaChannel_w(std::move(ssrc), state);
});
source_->SetState(MediaSourceInterface::kLive);
}
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_->RequestRecvKeyFrame(signaled_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;
}
void VideoRtpReceiver::SetEncodedSinkEnabled(bool enable) {
RTC_DCHECK_RUN_ON(worker_thread_);
if (!media_channel_)
return;
// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC
const auto ssrc = signaled_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