zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add packet_sequence_checker_ to RtpVideoStreamReceiver2.

Browse Source 
Specifying guards for functions and member variables. Also updating
a few places for VideoReceiveStream2 accordingly.

Bug: webrtc:11993
Change-Id: I2d13b009ec9853c6b2d90b08af555ecdd2b1ced6
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/220765
Commit-Queue: Tommi <tommi@webrtc.org>
Reviewed-by: Markus Handell <handellm@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34174}
This commit is contained in:
Tommi
2021-05-31 19:14:38 +02:00
committed by WebRTC LUCI CQ
parent b6b7d80ea4
commit 376cf07ea2
4 changed files with 149 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
video/rtp_video_stream_receiver2.cc
View File

@ -134,17 +134,18 @@ RtpVideoStreamReceiver2::RtcpFeedbackBuffer::RtcpFeedbackBuffer(
RTC_DCHECK(key_frame_request_sender_); RTC_DCHECK(key_frame_request_sender_);
RTC_DCHECK(nack_sender_); RTC_DCHECK(nack_sender_);
RTC_DCHECK(loss_notification_sender_); RTC_DCHECK(loss_notification_sender_);
packet_sequence_checker_.Detach();
} }
void RtpVideoStreamReceiver2::RtcpFeedbackBuffer::RequestKeyFrame() { void RtpVideoStreamReceiver2::RtcpFeedbackBuffer::RequestKeyFrame() {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
request_key_frame_ = true; request_key_frame_ = true;
} }
void RtpVideoStreamReceiver2::RtcpFeedbackBuffer::SendNack( void RtpVideoStreamReceiver2::RtcpFeedbackBuffer::SendNack(
const std::vector<uint16_t>& sequence_numbers, const std::vector<uint16_t>& sequence_numbers,
bool buffering_allowed) { bool buffering_allowed) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RTC_DCHECK(!sequence_numbers.empty()); RTC_DCHECK(!sequence_numbers.empty());
nack_sequence_numbers_.insert(nack_sequence_numbers_.end(), nack_sequence_numbers_.insert(nack_sequence_numbers_.end(),
sequence_numbers.cbegin(), sequence_numbers.cbegin(),
@ -161,7 +162,7 @@ void RtpVideoStreamReceiver2::RtcpFeedbackBuffer::SendLossNotification(
uint16_t last_received_seq_num, uint16_t last_received_seq_num,
bool decodability_flag, bool decodability_flag,
bool buffering_allowed) { bool buffering_allowed) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RTC_DCHECK(buffering_allowed); RTC_DCHECK(buffering_allowed);
RTC_DCHECK(!lntf_state_) RTC_DCHECK(!lntf_state_)
<< "SendLossNotification() called twice in a row with no call to " << "SendLossNotification() called twice in a row with no call to "
@ -171,7 +172,7 @@ void RtpVideoStreamReceiver2::RtcpFeedbackBuffer::SendLossNotification(
} }
void RtpVideoStreamReceiver2::RtcpFeedbackBuffer::SendBufferedRtcpFeedback() { void RtpVideoStreamReceiver2::RtcpFeedbackBuffer::SendBufferedRtcpFeedback() {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
bool request_key_frame = false; bool request_key_frame = false;
std::vector<uint16_t> nack_sequence_numbers; std::vector<uint16_t> nack_sequence_numbers;
@ -255,6 +256,7 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2(
has_received_frame_(false), has_received_frame_(false),
frames_decryptable_(false), frames_decryptable_(false),
absolute_capture_time_interpolator_(clock) { absolute_capture_time_interpolator_(clock) {
packet_sequence_checker_.Detach();
constexpr bool remb_candidate = true; constexpr bool remb_candidate = true;
if (packet_router_) if (packet_router_)
packet_router_->AddReceiveRtpModule(rtp_rtcp_.get(), remb_candidate); packet_router_->AddReceiveRtpModule(rtp_rtcp_.get(), remb_candidate);
@ -329,7 +331,7 @@ void RtpVideoStreamReceiver2::AddReceiveCodec(
const VideoCodec& video_codec, const VideoCodec& video_codec,
const std::map<std::string, std::string>& codec_params, const std::map<std::string, std::string>& codec_params,
bool raw_payload) { bool raw_payload) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (codec_params.count(cricket::kH264FmtpSpsPpsIdrInKeyframe) || if (codec_params.count(cricket::kH264FmtpSpsPpsIdrInKeyframe) ||
field_trial::IsEnabled("WebRTC-SpsPpsIdrIsH264Keyframe")) { field_trial::IsEnabled("WebRTC-SpsPpsIdrIsH264Keyframe")) {
packet_buffer_.ForceSpsPpsIdrIsH264Keyframe(); packet_buffer_.ForceSpsPpsIdrIsH264Keyframe();
@ -342,7 +344,7 @@ void RtpVideoStreamReceiver2::AddReceiveCodec(
} }
absl::optional<Syncable::Info> RtpVideoStreamReceiver2::GetSyncInfo() const { absl::optional<Syncable::Info> RtpVideoStreamReceiver2::GetSyncInfo() const {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
Syncable::Info info; Syncable::Info info;
if (rtp_rtcp_->RemoteNTP(&info.capture_time_ntp_secs, if (rtp_rtcp_->RemoteNTP(&info.capture_time_ntp_secs,
&info.capture_time_ntp_frac, &info.capture_time_ntp_frac,
@ -362,6 +364,7 @@ absl::optional<Syncable::Info> RtpVideoStreamReceiver2::GetSyncInfo() const {
return info; return info;
} }
// RTC_RUN_ON(packet_sequence_checker_)
RtpVideoStreamReceiver2::ParseGenericDependenciesResult RtpVideoStreamReceiver2::ParseGenericDependenciesResult
RtpVideoStreamReceiver2::ParseGenericDependenciesExtension( RtpVideoStreamReceiver2::ParseGenericDependenciesExtension(
const RtpPacketReceived& rtp_packet, const RtpPacketReceived& rtp_packet,
@ -471,7 +474,7 @@ void RtpVideoStreamReceiver2::OnReceivedPayloadData(
rtc::CopyOnWriteBuffer codec_payload, rtc::CopyOnWriteBuffer codec_payload,
const RtpPacketReceived& rtp_packet, const RtpPacketReceived& rtp_packet,
const RTPVideoHeader& video) { const RTPVideoHeader& video) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
auto packet = auto packet =
std::make_unique<video_coding::PacketBuffer::Packet>(rtp_packet, video); std::make_unique<video_coding::PacketBuffer::Packet>(rtp_packet, video);
@ -629,6 +632,8 @@ void RtpVideoStreamReceiver2::OnReceivedPayloadData(
void RtpVideoStreamReceiver2::OnRecoveredPacket(const uint8_t* rtp_packet, void RtpVideoStreamReceiver2::OnRecoveredPacket(const uint8_t* rtp_packet,
size_t rtp_packet_length) { size_t rtp_packet_length) {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RtpPacketReceived packet; RtpPacketReceived packet;
if (!packet.Parse(rtp_packet, rtp_packet_length)) if (!packet.Parse(rtp_packet, rtp_packet_length))
return; return;
@ -651,11 +656,10 @@ void RtpVideoStreamReceiver2::OnRecoveredPacket(const uint8_t* rtp_packet,
// This method handles both regular RTP packets and packets recovered // This method handles both regular RTP packets and packets recovered
// via FlexFEC. // via FlexFEC.
void RtpVideoStreamReceiver2::OnRtpPacket(const RtpPacketReceived& packet) { void RtpVideoStreamReceiver2::OnRtpPacket(const RtpPacketReceived& packet) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (!receiving_) { if (!receiving_)
return; return;
}
ReceivePacket(packet); ReceivePacket(packet);
@ -712,9 +716,9 @@ bool RtpVideoStreamReceiver2::IsDecryptable() const {
return frames_decryptable_; return frames_decryptable_;
} }
// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::OnInsertedPacket( void RtpVideoStreamReceiver2::OnInsertedPacket(
video_coding::PacketBuffer::InsertResult result) { video_coding::PacketBuffer::InsertResult result) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
video_coding::PacketBuffer::Packet* first_packet = nullptr; video_coding::PacketBuffer::Packet* first_packet = nullptr;
int max_nack_count; int max_nack_count;
int64_t min_recv_time; int64_t min_recv_time;
@ -789,9 +793,9 @@ void RtpVideoStreamReceiver2::OnInsertedPacket(
} }
} }
// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::OnAssembledFrame( void RtpVideoStreamReceiver2::OnAssembledFrame(
std::unique_ptr<RtpFrameObject> frame) { std::unique_ptr<RtpFrameObject> frame) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
RTC_DCHECK(frame); RTC_DCHECK(frame);
const absl::optional<RTPVideoHeader::GenericDescriptorInfo>& descriptor = const absl::optional<RTPVideoHeader::GenericDescriptorInfo>& descriptor =
@ -856,10 +860,10 @@ void RtpVideoStreamReceiver2::OnAssembledFrame(
} }
} }
// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::OnCompleteFrames( void RtpVideoStreamReceiver2::OnCompleteFrames(
RtpFrameReferenceFinder::ReturnVector frames) { RtpFrameReferenceFinder::ReturnVector frames) {
for (auto& frame : frames) { for (auto& frame : frames) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
RtpFrameObject* rtp_frame = static_cast<RtpFrameObject*>(frame.get()); RtpFrameObject* rtp_frame = static_cast<RtpFrameObject*>(frame.get());
last_seq_num_for_pic_id_[rtp_frame->Id()] = rtp_frame->last_seq_num(); last_seq_num_for_pic_id_[rtp_frame->Id()] = rtp_frame->last_seq_num();
@ -871,7 +875,7 @@ void RtpVideoStreamReceiver2::OnCompleteFrames(
void RtpVideoStreamReceiver2::OnDecryptedFrame( void RtpVideoStreamReceiver2::OnDecryptedFrame(
std::unique_ptr<RtpFrameObject> frame) { std::unique_ptr<RtpFrameObject> frame) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
OnCompleteFrames(reference_finder_->ManageFrame(std::move(frame))); OnCompleteFrames(reference_finder_->ManageFrame(std::move(frame)));
} }
@ -886,7 +890,9 @@ void RtpVideoStreamReceiver2::OnDecryptionStatusChange(
void RtpVideoStreamReceiver2::SetFrameDecryptor( void RtpVideoStreamReceiver2::SetFrameDecryptor(
rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) { rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); // TODO(bugs.webrtc.org/11993): Update callers or post the operation over to
// the network thread.
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (buffered_frame_decryptor_ == nullptr) { if (buffered_frame_decryptor_ == nullptr) {
buffered_frame_decryptor_ = buffered_frame_decryptor_ =
std::make_unique<BufferedFrameDecryptor>(this, this); std::make_unique<BufferedFrameDecryptor>(this, this);
@ -911,7 +917,7 @@ void RtpVideoStreamReceiver2::UpdateRtt(int64_t max_rtt_ms) {
} }
absl::optional<int64_t> RtpVideoStreamReceiver2::LastReceivedPacketMs() const { absl::optional<int64_t> RtpVideoStreamReceiver2::LastReceivedPacketMs() const {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (last_received_rtp_system_time_) { if (last_received_rtp_system_time_) {
return absl::optional<int64_t>(last_received_rtp_system_time_->ms()); return absl::optional<int64_t>(last_received_rtp_system_time_->ms());
} }
@ -920,7 +926,7 @@ absl::optional<int64_t> RtpVideoStreamReceiver2::LastReceivedPacketMs() const {
absl::optional<int64_t> RtpVideoStreamReceiver2::LastReceivedKeyframePacketMs() absl::optional<int64_t> RtpVideoStreamReceiver2::LastReceivedKeyframePacketMs()
const { const {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (last_received_keyframe_rtp_system_time_) { if (last_received_keyframe_rtp_system_time_) {
return absl::optional<int64_t>( return absl::optional<int64_t>(
last_received_keyframe_rtp_system_time_->ms()); last_received_keyframe_rtp_system_time_->ms());
@ -930,12 +936,12 @@ absl::optional<int64_t> RtpVideoStreamReceiver2::LastReceivedKeyframePacketMs()
void RtpVideoStreamReceiver2::ManageFrame( void RtpVideoStreamReceiver2::ManageFrame(
std::unique_ptr<RtpFrameObject> frame) { std::unique_ptr<RtpFrameObject> frame) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
OnCompleteFrames(reference_finder_->ManageFrame(std::move(frame))); OnCompleteFrames(reference_finder_->ManageFrame(std::move(frame)));
} }
// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::ReceivePacket(const RtpPacketReceived& packet) { void RtpVideoStreamReceiver2::ReceivePacket(const RtpPacketReceived& packet) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
if (packet.payload_size() == 0) { if (packet.payload_size() == 0) {
// Padding or keep-alive packet. // Padding or keep-alive packet.
// TODO(nisse): Could drop empty packets earlier, but need to figure out how // TODO(nisse): Could drop empty packets earlier, but need to figure out how
@ -963,9 +969,9 @@ void RtpVideoStreamReceiver2::ReceivePacket(const RtpPacketReceived& packet) {
parsed_payload->video_header); parsed_payload->video_header);
} }
// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::ParseAndHandleEncapsulatingHeader( void RtpVideoStreamReceiver2::ParseAndHandleEncapsulatingHeader(
const RtpPacketReceived& packet) { const RtpPacketReceived& packet) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
if (packet.PayloadType() == config_.rtp.red_payload_type && if (packet.PayloadType() == config_.rtp.red_payload_type &&
packet.payload_size() > 0) { packet.payload_size() > 0) {
if (packet.payload()[0] == config_.rtp.ulpfec_payload_type) { if (packet.payload()[0] == config_.rtp.ulpfec_payload_type) {
@ -984,9 +990,8 @@ void RtpVideoStreamReceiver2::ParseAndHandleEncapsulatingHeader(
// In the case of a video stream without picture ids and no rtx the // In the case of a video stream without picture ids and no rtx the
// RtpFrameReferenceFinder will need to know about padding to // RtpFrameReferenceFinder will need to know about padding to
// correctly calculate frame references. // correctly calculate frame references.
// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::NotifyReceiverOfEmptyPacket(uint16_t seq_num) { void RtpVideoStreamReceiver2::NotifyReceiverOfEmptyPacket(uint16_t seq_num) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
OnCompleteFrames(reference_finder_->PaddingReceived(seq_num)); OnCompleteFrames(reference_finder_->PaddingReceived(seq_num));
OnInsertedPacket(packet_buffer_.InsertPadding(seq_num)); OnInsertedPacket(packet_buffer_.InsertPadding(seq_num));
@ -1003,7 +1008,7 @@ void RtpVideoStreamReceiver2::NotifyReceiverOfEmptyPacket(uint16_t seq_num) {
bool RtpVideoStreamReceiver2::DeliverRtcp(const uint8_t* rtcp_packet, bool RtpVideoStreamReceiver2::DeliverRtcp(const uint8_t* rtcp_packet,
size_t rtcp_packet_length) { size_t rtcp_packet_length) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (!receiving_) { if (!receiving_) {
return false; return false;
@ -1045,7 +1050,7 @@ bool RtpVideoStreamReceiver2::DeliverRtcp(const uint8_t* rtcp_packet,
} }
void RtpVideoStreamReceiver2::FrameContinuous(int64_t picture_id) { void RtpVideoStreamReceiver2::FrameContinuous(int64_t picture_id) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (!nack_module_) if (!nack_module_)
return; return;
@ -1058,8 +1063,7 @@ void RtpVideoStreamReceiver2::FrameContinuous(int64_t picture_id) {
} }
void RtpVideoStreamReceiver2::FrameDecoded(int64_t picture_id) { void RtpVideoStreamReceiver2::FrameDecoded(int64_t picture_id) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
// Running on the decoder thread.
int seq_num = -1; int seq_num = -1;
auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id); auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
if (seq_num_it != last_seq_num_for_pic_id_.end()) { if (seq_num_it != last_seq_num_for_pic_id_.end()) {
@ -1084,12 +1088,12 @@ void RtpVideoStreamReceiver2::SignalNetworkState(NetworkState state) {
} }
void RtpVideoStreamReceiver2::StartReceive() { void RtpVideoStreamReceiver2::StartReceive() {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
receiving_ = true; receiving_ = true;
} }
void RtpVideoStreamReceiver2::StopReceive() { void RtpVideoStreamReceiver2::StopReceive() {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
receiving_ = false; receiving_ = false;
} }
@ -1120,9 +1124,8 @@ void RtpVideoStreamReceiver2::UpdateHistograms() {
} }
} }
// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::InsertSpsPpsIntoTracker(uint8_t payload_type) { void RtpVideoStreamReceiver2::InsertSpsPpsIntoTracker(uint8_t payload_type) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
auto codec_params_it = pt_codec_params_.find(payload_type); auto codec_params_it = pt_codec_params_.find(payload_type);
if (codec_params_it == pt_codec_params_.end()) if (codec_params_it == pt_codec_params_.end())
return; return;

98
video/rtp_video_stream_receiver2.h
View File

@ -121,7 +121,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// Returns number of different frames seen. // Returns number of different frames seen.
int GetUniqueFramesSeen() const { int GetUniqueFramesSeen() const {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
return frame_counter_.GetUniqueSeen(); return frame_counter_.GetUniqueSeen();
} }
@ -156,8 +156,6 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// Don't use, still experimental. // Don't use, still experimental.
void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers); void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
void OnCompleteFrames(RtpFrameReferenceFinder::ReturnVector frame);
// Implements OnDecryptedFrameCallback. // Implements OnDecryptedFrameCallback.
void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override; void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override;
@ -185,6 +183,9 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// Implements RtpVideoFrameReceiver. // Implements RtpVideoFrameReceiver.
void ManageFrame(std::unique_ptr<RtpFrameObject> frame) override; void ManageFrame(std::unique_ptr<RtpFrameObject> frame) override;
void OnCompleteFrames(RtpFrameReferenceFinder::ReturnVector frame)
RTC_RUN_ON(packet_sequence_checker_);
// Used for buffering RTCP feedback messages and sending them all together. // Used for buffering RTCP feedback messages and sending them all together.
// Note: // Note:
// 1. Key frame requests and NACKs are mutually exclusive, with the // 1. Key frame requests and NACKs are mutually exclusive, with the
@ -232,20 +233,20 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
bool decodability_flag; bool decodability_flag;
}; };
RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_task_checker_; RTC_NO_UNIQUE_ADDRESS SequenceChecker packet_sequence_checker_;
KeyFrameRequestSender* const key_frame_request_sender_; KeyFrameRequestSender* const key_frame_request_sender_;
NackSender* const nack_sender_; NackSender* const nack_sender_;
LossNotificationSender* const loss_notification_sender_; LossNotificationSender* const loss_notification_sender_;
// Key-frame-request-related state. // Key-frame-request-related state.
bool request_key_frame_ RTC_GUARDED_BY(worker_task_checker_); bool request_key_frame_ RTC_GUARDED_BY(packet_sequence_checker_);
// NACK-related state. // NACK-related state.
std::vector<uint16_t> nack_sequence_numbers_ std::vector<uint16_t> nack_sequence_numbers_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
absl::optional<LossNotificationState> lntf_state_ absl::optional<LossNotificationState> lntf_state_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
}; };
enum ParseGenericDependenciesResult { enum ParseGenericDependenciesResult {
kDropPacket, kDropPacket,
@ -255,22 +256,29 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// Entry point doing non-stats work for a received packet. Called // Entry point doing non-stats work for a received packet. Called
// for the same packet both before and after RED decapsulation. // for the same packet both before and after RED decapsulation.
void ReceivePacket(const RtpPacketReceived& packet); void ReceivePacket(const RtpPacketReceived& packet)
RTC_RUN_ON(packet_sequence_checker_);
// Parses and handles RED headers. // Parses and handles RED headers.
// This function assumes that it's being called from only one thread. // This function assumes that it's being called from only one thread.
void ParseAndHandleEncapsulatingHeader(const RtpPacketReceived& packet); void ParseAndHandleEncapsulatingHeader(const RtpPacketReceived& packet)
void NotifyReceiverOfEmptyPacket(uint16_t seq_num); RTC_RUN_ON(packet_sequence_checker_);
void NotifyReceiverOfEmptyPacket(uint16_t seq_num)
RTC_RUN_ON(packet_sequence_checker_);
void UpdateHistograms(); void UpdateHistograms();
bool IsRedEnabled() const; bool IsRedEnabled() const;
void InsertSpsPpsIntoTracker(uint8_t payload_type); void InsertSpsPpsIntoTracker(uint8_t payload_type)
void OnInsertedPacket(video_coding::PacketBuffer::InsertResult result); RTC_RUN_ON(packet_sequence_checker_);
void OnInsertedPacket(video_coding::PacketBuffer::InsertResult result)
RTC_RUN_ON(packet_sequence_checker_);
ParseGenericDependenciesResult ParseGenericDependenciesExtension( ParseGenericDependenciesResult ParseGenericDependenciesExtension(
const RtpPacketReceived& rtp_packet, const RtpPacketReceived& rtp_packet,
RTPVideoHeader* video_header) RTC_RUN_ON(worker_task_checker_); RTPVideoHeader* video_header) RTC_RUN_ON(packet_sequence_checker_);
void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame); void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame)
RTC_RUN_ON(packet_sequence_checker_);
void UpdatePacketReceiveTimestamps(const RtpPacketReceived& packet, void UpdatePacketReceiveTimestamps(const RtpPacketReceived& packet,
bool is_keyframe) bool is_keyframe)
RTC_RUN_ON(worker_task_checker_); RTC_RUN_ON(packet_sequence_checker_);
Clock* const clock_; Clock* const clock_;
// Ownership of this object lies with VideoReceiveStream, which owns |this|. // Ownership of this object lies with VideoReceiveStream, which owns |this|.
@ -289,8 +297,16 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
std::unique_ptr<UlpfecReceiver> ulpfec_receiver_; std::unique_ptr<UlpfecReceiver> ulpfec_receiver_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_task_checker_; RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_task_checker_;
bool receiving_ RTC_GUARDED_BY(worker_task_checker_); // TODO(bugs.webrtc.org/11993): This checker conceptually represents
int64_t last_packet_log_ms_ RTC_GUARDED_BY(worker_task_checker_); // operations that belong to the network thread. The Call class is currently
// moving towards handling network packets on the network thread and while
// that work is ongoing, this checker may in practice represent the worker
// thread, but still serves as a mechanism of grouping together concepts
// that belong to the network thread. Once the packets are fully delivered
// on the network thread, this comment will be deleted.
RTC_NO_UNIQUE_ADDRESS SequenceChecker packet_sequence_checker_;
bool receiving_ RTC_GUARDED_BY(packet_sequence_checker_);
int64_t last_packet_log_ms_ RTC_GUARDED_BY(packet_sequence_checker_);
const std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_; const std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_;
@ -302,66 +318,68 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
std::unique_ptr<LossNotificationController> loss_notification_controller_; std::unique_ptr<LossNotificationController> loss_notification_controller_;
video_coding::PacketBuffer packet_buffer_ video_coding::PacketBuffer packet_buffer_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
UniqueTimestampCounter frame_counter_ RTC_GUARDED_BY(worker_task_checker_); UniqueTimestampCounter frame_counter_
RTC_GUARDED_BY(packet_sequence_checker_);
SeqNumUnwrapper<uint16_t> frame_id_unwrapper_ SeqNumUnwrapper<uint16_t> frame_id_unwrapper_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
// Video structure provided in the dependency descriptor in a first packet // Video structure provided in the dependency descriptor in a first packet
// of a key frame. It is required to parse dependency descriptor in the // of a key frame. It is required to parse dependency descriptor in the
// following delta packets. // following delta packets.
std::unique_ptr<FrameDependencyStructure> video_structure_ std::unique_ptr<FrameDependencyStructure> video_structure_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
// Frame id of the last frame with the attached video structure. // Frame id of the last frame with the attached video structure.
// absl::nullopt when `video_structure_ == nullptr`; // absl::nullopt when `video_structure_ == nullptr`;
absl::optional<int64_t> video_structure_frame_id_ absl::optional<int64_t> video_structure_frame_id_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
std::unique_ptr<RtpFrameReferenceFinder> reference_finder_ std::unique_ptr<RtpFrameReferenceFinder> reference_finder_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
absl::optional<VideoCodecType> current_codec_ absl::optional<VideoCodecType> current_codec_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
uint32_t last_assembled_frame_rtp_timestamp_ uint32_t last_assembled_frame_rtp_timestamp_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
std::map<int64_t, uint16_t> last_seq_num_for_pic_id_ std::map<int64_t, uint16_t> last_seq_num_for_pic_id_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
video_coding::H264SpsPpsTracker tracker_ RTC_GUARDED_BY(worker_task_checker_); video_coding::H264SpsPpsTracker tracker_
RTC_GUARDED_BY(packet_sequence_checker_);
// Maps payload id to the depacketizer. // Maps payload id to the depacketizer.
std::map<uint8_t, std::unique_ptr<VideoRtpDepacketizer>> payload_type_map_ std::map<uint8_t, std::unique_ptr<VideoRtpDepacketizer>> payload_type_map_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
// TODO(johan): Remove pt_codec_params_ once // TODO(johan): Remove pt_codec_params_ once
// https://bugs.chromium.org/p/webrtc/issues/detail?id=6883 is resolved. // https://bugs.chromium.org/p/webrtc/issues/detail?id=6883 is resolved.
// Maps a payload type to a map of out-of-band supplied codec parameters. // Maps a payload type to a map of out-of-band supplied codec parameters.
std::map<uint8_t, std::map<std::string, std::string>> pt_codec_params_ std::map<uint8_t, std::map<std::string, std::string>> pt_codec_params_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
int16_t last_payload_type_ RTC_GUARDED_BY(worker_task_checker_) = -1; int16_t last_payload_type_ RTC_GUARDED_BY(packet_sequence_checker_) = -1;
bool has_received_frame_ RTC_GUARDED_BY(worker_task_checker_); bool has_received_frame_ RTC_GUARDED_BY(packet_sequence_checker_);
absl::optional<uint32_t> last_received_rtp_timestamp_ absl::optional<uint32_t> last_received_rtp_timestamp_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
absl::optional<uint32_t> last_received_keyframe_rtp_timestamp_ absl::optional<uint32_t> last_received_keyframe_rtp_timestamp_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
absl::optional<Timestamp> last_received_rtp_system_time_ absl::optional<Timestamp> last_received_rtp_system_time_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
absl::optional<Timestamp> last_received_keyframe_rtp_system_time_ absl::optional<Timestamp> last_received_keyframe_rtp_system_time_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
// Handles incoming encrypted frames and forwards them to the // Handles incoming encrypted frames and forwards them to the
// rtp_reference_finder if they are decryptable. // rtp_reference_finder if they are decryptable.
std::unique_ptr<BufferedFrameDecryptor> buffered_frame_decryptor_ std::unique_ptr<BufferedFrameDecryptor> buffered_frame_decryptor_
RTC_PT_GUARDED_BY(worker_task_checker_); RTC_PT_GUARDED_BY(packet_sequence_checker_);
bool frames_decryptable_ RTC_GUARDED_BY(worker_task_checker_); bool frames_decryptable_ RTC_GUARDED_BY(worker_task_checker_);
absl::optional<ColorSpace> last_color_space_; absl::optional<ColorSpace> last_color_space_;
AbsoluteCaptureTimeInterpolator absolute_capture_time_interpolator_ AbsoluteCaptureTimeInterpolator absolute_capture_time_interpolator_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
CaptureClockOffsetUpdater capture_clock_offset_updater_ CaptureClockOffsetUpdater capture_clock_offset_updater_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
int64_t last_completed_picture_id_ = 0; int64_t last_completed_picture_id_ = 0;
@ -369,9 +387,9 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
frame_transformer_delegate_; frame_transformer_delegate_;
SeqNumUnwrapper<uint16_t> rtp_seq_num_unwrapper_ SeqNumUnwrapper<uint16_t> rtp_seq_num_unwrapper_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
std::map<int64_t, RtpPacketInfo> packet_infos_ std::map<int64_t, RtpPacketInfo> packet_infos_
RTC_GUARDED_BY(worker_task_checker_); RTC_GUARDED_BY(packet_sequence_checker_);
}; };
} // namespace webrtc } // namespace webrtc

83
video/video_receive_stream2.cc
View File

@ -384,9 +384,13 @@ void VideoReceiveStream2::Start() {
const bool raw_payload = const bool raw_payload =
config_.rtp.raw_payload_types.count(decoder.payload_type) > 0; config_.rtp.raw_payload_types.count(decoder.payload_type) > 0;
rtp_video_stream_receiver_.AddReceiveCodec(decoder.payload_type, codec, {
decoder.video_format.parameters, // TODO(bugs.webrtc.org/11993): Make this call on the network thread.
raw_payload); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
rtp_video_stream_receiver_.AddReceiveCodec(
decoder.payload_type, codec, decoder.video_format.parameters,
raw_payload);
}
RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec( RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec(
decoder.payload_type, &codec, num_cpu_cores_)); decoder.payload_type, &codec, num_cpu_cores_));
} }
@ -408,12 +412,23 @@ void VideoReceiveStream2::Start() {
StartNextDecode(); StartNextDecode();
}); });
decoder_running_ = true; decoder_running_ = true;
rtp_video_stream_receiver_.StartReceive();
{
// TODO(bugs.webrtc.org/11993): Make this call on the network thread.
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
rtp_video_stream_receiver_.StartReceive();
}
} }
void VideoReceiveStream2::Stop() { void VideoReceiveStream2::Stop() {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_); RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
rtp_video_stream_receiver_.StopReceive(); {
// TODO(bugs.webrtc.org/11993): Make this call on the network thread.
// Also call `GetUniqueFramesSeen()` at the same time (since it's a counter
// that's updated on the network thread).
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
rtp_video_stream_receiver_.StopReceive();
}
stats_proxy_.OnUniqueFramesCounted( stats_proxy_.OnUniqueFramesCounted(
rtp_video_stream_receiver_.GetUniqueFramesSeen()); rtp_video_stream_receiver_.GetUniqueFramesSeen());
@ -636,8 +651,13 @@ void VideoReceiveStream2::OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) {
} }
int64_t last_continuous_pid = frame_buffer_->InsertFrame(std::move(frame)); int64_t last_continuous_pid = frame_buffer_->InsertFrame(std::move(frame));
if (last_continuous_pid != -1) if (last_continuous_pid != -1) {
rtp_video_stream_receiver_.FrameContinuous(last_continuous_pid); {
// TODO(bugs.webrtc.org/11993): Call on the network thread.
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
rtp_video_stream_receiver_.FrameContinuous(last_continuous_pid);
}
}
} }
void VideoReceiveStream2::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { void VideoReceiveStream2::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
@ -653,7 +673,7 @@ uint32_t VideoReceiveStream2::id() const {
} }
absl::optional<Syncable::Info> VideoReceiveStream2::GetInfo() const { absl::optional<Syncable::Info> VideoReceiveStream2::GetInfo() const {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
absl::optional<Syncable::Info> info = absl::optional<Syncable::Info> info =
rtp_video_stream_receiver_.GetSyncInfo(); rtp_video_stream_receiver_.GetSyncInfo();
@ -704,9 +724,10 @@ void VideoReceiveStream2::StartNextDecode() {
HandleEncodedFrame(std::move(frame)); HandleEncodedFrame(std::move(frame));
} else { } else {
int64_t now_ms = clock_->TimeInMilliseconds(); int64_t now_ms = clock_->TimeInMilliseconds();
// TODO(bugs.webrtc.org/11993): PostTask to the network thread.
call_->worker_thread()->PostTask(ToQueuedTask( call_->worker_thread()->PostTask(ToQueuedTask(
task_safety_, [this, now_ms, wait_ms = GetMaxWaitMs()]() { task_safety_, [this, now_ms, wait_ms = GetMaxWaitMs()]() {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
HandleFrameBufferTimeout(now_ms, wait_ms); HandleFrameBufferTimeout(now_ms, wait_ms);
})); }));
} }
@ -765,19 +786,22 @@ void VideoReceiveStream2::HandleEncodedFrame(
force_request_key_frame = true; force_request_key_frame = true;
} }
call_->worker_thread()->PostTask(ToQueuedTask( {
task_safety_, // TODO(bugs.webrtc.org/11993): Make this PostTask to the network thread.
[this, now_ms, received_frame_is_keyframe, force_request_key_frame, call_->worker_thread()->PostTask(ToQueuedTask(
decoded_frame_picture_id, keyframe_request_is_due]() { task_safety_,
RTC_DCHECK_RUN_ON(&worker_sequence_checker_); [this, now_ms, received_frame_is_keyframe, force_request_key_frame,
decoded_frame_picture_id, keyframe_request_is_due]() {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (decoded_frame_picture_id != -1) if (decoded_frame_picture_id != -1)
rtp_video_stream_receiver_.FrameDecoded(decoded_frame_picture_id); rtp_video_stream_receiver_.FrameDecoded(decoded_frame_picture_id);
HandleKeyFrameGeneration(received_frame_is_keyframe, now_ms, HandleKeyFrameGeneration(received_frame_is_keyframe, now_ms,
force_request_key_frame, force_request_key_frame,
keyframe_request_is_due); keyframe_request_is_due);
})); }));
}
} }
int VideoReceiveStream2::DecodeAndMaybeDispatchEncodedFrame( int VideoReceiveStream2::DecodeAndMaybeDispatchEncodedFrame(
@ -840,13 +864,12 @@ int VideoReceiveStream2::DecodeAndMaybeDispatchEncodedFrame(
return decode_result; return decode_result;
} }
// RTC_RUN_ON(packet_sequence_checker_)
void VideoReceiveStream2::HandleKeyFrameGeneration( void VideoReceiveStream2::HandleKeyFrameGeneration(
bool received_frame_is_keyframe, bool received_frame_is_keyframe,
int64_t now_ms, int64_t now_ms,
bool always_request_key_frame, bool always_request_key_frame,
bool keyframe_request_is_due) { bool keyframe_request_is_due) {
// Running on worker_sequence_checker_.
bool request_key_frame = always_request_key_frame; bool request_key_frame = always_request_key_frame;
// Repeat sending keyframe requests if we've requested a keyframe. // Repeat sending keyframe requests if we've requested a keyframe.
@ -870,9 +893,9 @@ void VideoReceiveStream2::HandleKeyFrameGeneration(
} }
} }
// RTC_RUN_ON(packet_sequence_checker_)
void VideoReceiveStream2::HandleFrameBufferTimeout(int64_t now_ms, void VideoReceiveStream2::HandleFrameBufferTimeout(int64_t now_ms,
int64_t wait_ms) { int64_t wait_ms) {
// Running on |worker_sequence_checker_|.
absl::optional<int64_t> last_packet_ms = absl::optional<int64_t> last_packet_ms =
rtp_video_stream_receiver_.LastReceivedPacketMs(); rtp_video_stream_receiver_.LastReceivedPacketMs();
@ -892,8 +915,8 @@ void VideoReceiveStream2::HandleFrameBufferTimeout(int64_t now_ms,
} }
} }
// RTC_RUN_ON(packet_sequence_checker_)
bool VideoReceiveStream2::IsReceivingKeyFrame(int64_t timestamp_ms) const { bool VideoReceiveStream2::IsReceivingKeyFrame(int64_t timestamp_ms) const {
// Running on worker_sequence_checker_.
absl::optional<int64_t> last_keyframe_packet_ms = absl::optional<int64_t> last_keyframe_packet_ms =
rtp_video_stream_receiver_.LastReceivedKeyframePacketMs(); rtp_video_stream_receiver_.LastReceivedKeyframePacketMs();
@ -965,13 +988,13 @@ VideoReceiveStream2::SetAndGetRecordingState(RecordingState state,
event.Set(); event.Set();
}); });
old_state.keyframe_needed = keyframe_generation_requested_;
if (generate_key_frame) { if (generate_key_frame) {
rtp_video_stream_receiver_.RequestKeyFrame(); rtp_video_stream_receiver_.RequestKeyFrame();
keyframe_generation_requested_ = true; {
} else { // TODO(bugs.webrtc.org/11993): Post this to the network thread.
keyframe_generation_requested_ = state.keyframe_needed; RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
keyframe_generation_requested_ = true;
}
} }
event.Wait(rtc::Event::kForever); event.Wait(rtc::Event::kForever);
@ -979,7 +1002,7 @@ VideoReceiveStream2::SetAndGetRecordingState(RecordingState state,
} }
void VideoReceiveStream2::GenerateKeyFrame() { void VideoReceiveStream2::GenerateKeyFrame() {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RequestKeyFrame(clock_->TimeInMilliseconds()); RequestKeyFrame(clock_->TimeInMilliseconds());
keyframe_generation_requested_ = true; keyframe_generation_requested_ = true;
} }

10
video/video_receive_stream2.h
View File

@ -179,18 +179,18 @@ class VideoReceiveStream2
void HandleEncodedFrame(std::unique_ptr<EncodedFrame> frame) void HandleEncodedFrame(std::unique_ptr<EncodedFrame> frame)
RTC_RUN_ON(decode_queue_); RTC_RUN_ON(decode_queue_);
void HandleFrameBufferTimeout(int64_t now_ms, int64_t wait_ms) void HandleFrameBufferTimeout(int64_t now_ms, int64_t wait_ms)
RTC_RUN_ON(worker_sequence_checker_); RTC_RUN_ON(packet_sequence_checker_);
void UpdatePlayoutDelays() const void UpdatePlayoutDelays() const
RTC_EXCLUSIVE_LOCKS_REQUIRED(worker_sequence_checker_); RTC_EXCLUSIVE_LOCKS_REQUIRED(worker_sequence_checker_);
void RequestKeyFrame(int64_t timestamp_ms) void RequestKeyFrame(int64_t timestamp_ms)
RTC_RUN_ON(worker_sequence_checker_); RTC_RUN_ON(packet_sequence_checker_);
void HandleKeyFrameGeneration(bool received_frame_is_keyframe, void HandleKeyFrameGeneration(bool received_frame_is_keyframe,
int64_t now_ms, int64_t now_ms,
bool always_request_key_frame, bool always_request_key_frame,
bool keyframe_request_is_due) bool keyframe_request_is_due)
RTC_RUN_ON(worker_sequence_checker_); RTC_RUN_ON(packet_sequence_checker_);
bool IsReceivingKeyFrame(int64_t timestamp_ms) const bool IsReceivingKeyFrame(int64_t timestamp_ms) const
RTC_RUN_ON(worker_sequence_checker_); RTC_RUN_ON(packet_sequence_checker_);
int DecodeAndMaybeDispatchEncodedFrame(std::unique_ptr<EncodedFrame> frame) int DecodeAndMaybeDispatchEncodedFrame(std::unique_ptr<EncodedFrame> frame)
RTC_RUN_ON(decode_queue_); RTC_RUN_ON(decode_queue_);
@ -284,7 +284,7 @@ class VideoReceiveStream2
std::function<void(const RecordableEncodedFrame&)> std::function<void(const RecordableEncodedFrame&)>
encoded_frame_buffer_function_ RTC_GUARDED_BY(decode_queue_); encoded_frame_buffer_function_ RTC_GUARDED_BY(decode_queue_);
// Set to true while we're requesting keyframes but not yet received one. // Set to true while we're requesting keyframes but not yet received one.
bool keyframe_generation_requested_ RTC_GUARDED_BY(worker_sequence_checker_) = bool keyframe_generation_requested_ RTC_GUARDED_BY(packet_sequence_checker_) =
false; false;
// Lock to avoid unnecessary per-frame idle wakeups in the code. // Lock to avoid unnecessary per-frame idle wakeups in the code.
webrtc::Mutex pending_resolution_mutex_; webrtc::Mutex pending_resolution_mutex_;