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

98
video/rtp_video_stream_receiver2.h
View File

@ -121,7 +121,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// Returns number of different frames seen.
int GetUniqueFramesSeen() const {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
return frame_counter_.GetUniqueSeen();
}
@ -156,8 +156,6 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// Don't use, still experimental.
void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
void OnCompleteFrames(RtpFrameReferenceFinder::ReturnVector frame);
// Implements OnDecryptedFrameCallback.
void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override;
@ -185,6 +183,9 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// Implements RtpVideoFrameReceiver.
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.
// Note:
// 1. Key frame requests and NACKs are mutually exclusive, with the
@ -232,20 +233,20 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
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_;
NackSender* const nack_sender_;
LossNotificationSender* const loss_notification_sender_;
// 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.
std::vector<uint16_t> nack_sequence_numbers_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
absl::optional<LossNotificationState> lntf_state_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
};
enum ParseGenericDependenciesResult {
kDropPacket,
@ -255,22 +256,29 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// Entry point doing non-stats work for a received packet. Called
// 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.
// This function assumes that it's being called from only one thread.
void ParseAndHandleEncapsulatingHeader(const RtpPacketReceived& packet);
void NotifyReceiverOfEmptyPacket(uint16_t seq_num);
void ParseAndHandleEncapsulatingHeader(const RtpPacketReceived& packet)
RTC_RUN_ON(packet_sequence_checker_);
void NotifyReceiverOfEmptyPacket(uint16_t seq_num)
RTC_RUN_ON(packet_sequence_checker_);
void UpdateHistograms();
bool IsRedEnabled() const;
void InsertSpsPpsIntoTracker(uint8_t payload_type);
void OnInsertedPacket(video_coding::PacketBuffer::InsertResult result);
void InsertSpsPpsIntoTracker(uint8_t payload_type)
RTC_RUN_ON(packet_sequence_checker_);
void OnInsertedPacket(video_coding::PacketBuffer::InsertResult result)
RTC_RUN_ON(packet_sequence_checker_);
ParseGenericDependenciesResult ParseGenericDependenciesExtension(
const RtpPacketReceived& rtp_packet,
RTPVideoHeader* video_header) RTC_RUN_ON(worker_task_checker_);
void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame);
RTPVideoHeader* video_header) RTC_RUN_ON(packet_sequence_checker_);
void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame)
RTC_RUN_ON(packet_sequence_checker_);
void UpdatePacketReceiveTimestamps(const RtpPacketReceived& packet,
bool is_keyframe)
RTC_RUN_ON(worker_task_checker_);
RTC_RUN_ON(packet_sequence_checker_);
Clock* const clock_;
// Ownership of this object lies with VideoReceiveStream, which owns |this|.
@ -289,8 +297,16 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
std::unique_ptr<UlpfecReceiver> ulpfec_receiver_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_task_checker_;
bool receiving_ RTC_GUARDED_BY(worker_task_checker_);
int64_t last_packet_log_ms_ RTC_GUARDED_BY(worker_task_checker_);
// TODO(bugs.webrtc.org/11993): This checker conceptually represents
// 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_;
@ -302,66 +318,68 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
std::unique_ptr<LossNotificationController> loss_notification_controller_;
video_coding::PacketBuffer packet_buffer_
RTC_GUARDED_BY(worker_task_checker_);
UniqueTimestampCounter frame_counter_ RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
UniqueTimestampCounter frame_counter_
RTC_GUARDED_BY(packet_sequence_checker_);
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
// of a key frame. It is required to parse dependency descriptor in the
// following delta packets.
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.
// absl::nullopt when `video_structure_ == nullptr`;
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_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
absl::optional<VideoCodecType> current_codec_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
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_
RTC_GUARDED_BY(worker_task_checker_);
video_coding::H264SpsPpsTracker tracker_ RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
video_coding::H264SpsPpsTracker tracker_
RTC_GUARDED_BY(packet_sequence_checker_);
// Maps payload id to the depacketizer.
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
// 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.
std::map<uint8_t, std::map<std::string, std::string>> pt_codec_params_
RTC_GUARDED_BY(worker_task_checker_);
int16_t last_payload_type_ RTC_GUARDED_BY(worker_task_checker_) = -1;
RTC_GUARDED_BY(packet_sequence_checker_);
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_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
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_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
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
// rtp_reference_finder if they are decryptable.
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_);
absl::optional<ColorSpace> last_color_space_;
AbsoluteCaptureTimeInterpolator absolute_capture_time_interpolator_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
CaptureClockOffsetUpdater capture_clock_offset_updater_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
int64_t last_completed_picture_id_ = 0;
@ -369,9 +387,9 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
frame_transformer_delegate_;
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_
RTC_GUARDED_BY(worker_task_checker_);
RTC_GUARDED_BY(packet_sequence_checker_);
};
} // namespace webrtc

53
video/video_receive_stream2.cc
View File

@ -384,9 +384,13 @@ void VideoReceiveStream2::Start() {
const bool raw_payload =
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.
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(
decoder.payload_type, &codec, num_cpu_cores_));
}
@ -408,12 +412,23 @@ void VideoReceiveStream2::Start() {
StartNextDecode();
});
decoder_running_ = true;
{
// 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() {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
{
// 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(
rtp_video_stream_receiver_.GetUniqueFramesSeen());
@ -636,9 +651,14 @@ void VideoReceiveStream2::OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) {
}
int64_t last_continuous_pid = frame_buffer_->InsertFrame(std::move(frame));
if (last_continuous_pid != -1)
if (last_continuous_pid != -1) {
{
// 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) {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
@ -653,7 +673,7 @@ uint32_t VideoReceiveStream2::id() 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 =
rtp_video_stream_receiver_.GetSyncInfo();
@ -704,9 +724,10 @@ void VideoReceiveStream2::StartNextDecode() {
HandleEncodedFrame(std::move(frame));
} else {
int64_t now_ms = clock_->TimeInMilliseconds();
// TODO(bugs.webrtc.org/11993): PostTask to the network thread.
call_->worker_thread()->PostTask(ToQueuedTask(
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);
}));
}
@ -765,11 +786,13 @@ void VideoReceiveStream2::HandleEncodedFrame(
force_request_key_frame = true;
}
{
// TODO(bugs.webrtc.org/11993): Make this PostTask to the network thread.
call_->worker_thread()->PostTask(ToQueuedTask(
task_safety_,
[this, now_ms, received_frame_is_keyframe, force_request_key_frame,
decoded_frame_picture_id, keyframe_request_is_due]() {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (decoded_frame_picture_id != -1)
rtp_video_stream_receiver_.FrameDecoded(decoded_frame_picture_id);
@ -779,6 +802,7 @@ void VideoReceiveStream2::HandleEncodedFrame(
keyframe_request_is_due);
}));
}
}
int VideoReceiveStream2::DecodeAndMaybeDispatchEncodedFrame(
std::unique_ptr<EncodedFrame> frame) {
@ -840,13 +864,12 @@ int VideoReceiveStream2::DecodeAndMaybeDispatchEncodedFrame(
return decode_result;
}
// RTC_RUN_ON(packet_sequence_checker_)
void VideoReceiveStream2::HandleKeyFrameGeneration(
bool received_frame_is_keyframe,
int64_t now_ms,
bool always_request_key_frame,
bool keyframe_request_is_due) {
// Running on worker_sequence_checker_.
bool request_key_frame = always_request_key_frame;
// 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,
int64_t wait_ms) {
// Running on |worker_sequence_checker_|.
absl::optional<int64_t> last_packet_ms =
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 {
// Running on worker_sequence_checker_.
absl::optional<int64_t> last_keyframe_packet_ms =
rtp_video_stream_receiver_.LastReceivedKeyframePacketMs();
@ -965,13 +988,13 @@ VideoReceiveStream2::SetAndGetRecordingState(RecordingState state,
event.Set();
});
old_state.keyframe_needed = keyframe_generation_requested_;
if (generate_key_frame) {
rtp_video_stream_receiver_.RequestKeyFrame();
{
// TODO(bugs.webrtc.org/11993): Post this to the network thread.
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
keyframe_generation_requested_ = true;
} else {
keyframe_generation_requested_ = state.keyframe_needed;
}
}
event.Wait(rtc::Event::kForever);
@ -979,7 +1002,7 @@ VideoReceiveStream2::SetAndGetRecordingState(RecordingState state,
}
void VideoReceiveStream2::GenerateKeyFrame() {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RequestKeyFrame(clock_->TimeInMilliseconds());
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)
RTC_RUN_ON(decode_queue_);
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
RTC_EXCLUSIVE_LOCKS_REQUIRED(worker_sequence_checker_);
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,
int64_t now_ms,
bool always_request_key_frame,
bool keyframe_request_is_due)
RTC_RUN_ON(worker_sequence_checker_);
RTC_RUN_ON(packet_sequence_checker_);
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)
RTC_RUN_ON(decode_queue_);
@ -284,7 +284,7 @@ class VideoReceiveStream2
std::function<void(const RecordableEncodedFrame&)>
encoded_frame_buffer_function_ RTC_GUARDED_BY(decode_queue_);
// 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;
// Lock to avoid unnecessary per-frame idle wakeups in the code.
webrtc::Mutex pending_resolution_mutex_;