diff --git a/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.cc b/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.cc index ef0437ab2a..02194391af 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.cc +++ b/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.cc @@ -18,7 +18,6 @@ #include "modules/rtp_rtcp/source/rtp_descriptor_authentication.h" #include "modules/rtp_rtcp/source/rtp_sender_video.h" #include "rtc_base/checks.h" -#include "rtc_base/logging.h" namespace webrtc { namespace { @@ -104,33 +103,15 @@ RTPSenderVideoFrameTransformerDelegate::RTPSenderVideoFrameTransformerDelegate( : sender_(sender), frame_transformer_(std::move(frame_transformer)), ssrc_(ssrc), - task_queue_factory_(task_queue_factory) { - RTC_DCHECK(task_queue_factory_); -} + transformation_queue_(task_queue_factory->CreateTaskQueue( + "video_frame_transformer", + TaskQueueFactory::Priority::NORMAL)) {} void RTPSenderVideoFrameTransformerDelegate::Init() { frame_transformer_->RegisterTransformedFrameSinkCallback( rtc::scoped_refptr(this), ssrc_); } -void RTPSenderVideoFrameTransformerDelegate::EnsureEncoderQueueCreated() { - TaskQueueBase* current = TaskQueueBase::Current(); - - if (!encoder_queue_) { - // Save the current task queue to post the transformed frame for sending - // once it is transformed. When there is no current task queue, i.e. - // encoding is done on an external thread (for example in the case of - // hardware encoders), create a new task queue. - if (current) { - encoder_queue_ = current; - } else { - owned_encoder_queue_ = task_queue_factory_->CreateTaskQueue( - "video_frame_transformer", TaskQueueFactory::Priority::NORMAL); - encoder_queue_ = owned_encoder_queue_.get(); - } - } -} - bool RTPSenderVideoFrameTransformerDelegate::TransformFrame( int payload_type, absl::optional codec_type, @@ -138,18 +119,6 @@ bool RTPSenderVideoFrameTransformerDelegate::TransformFrame( const EncodedImage& encoded_image, RTPVideoHeader video_header, absl::optional expected_retransmission_time_ms) { - EnsureEncoderQueueCreated(); - - TaskQueueBase* current = TaskQueueBase::Current(); - // DCHECK that the current queue does not change, or if does then it was due - // to a hardware encoder fallback and thus there is an owned queue. - RTC_DCHECK(!current || current == encoder_queue_ || owned_encoder_queue_) - << "Current thread must either be an external thread (nullptr) or be the " - "same as the previous encoder queue. The current thread is " - << (current ? "non-null" : "nullptr") << " and the encoder thread is " - << (current == encoder_queue_ ? "the same queue." - : "not the same queue."); - frame_transformer_->Transform(std::make_unique( encoded_image, video_header, payload_type, codec_type, rtp_timestamp, expected_retransmission_time_ms, ssrc_)); @@ -160,22 +129,20 @@ void RTPSenderVideoFrameTransformerDelegate::OnTransformedFrame( std::unique_ptr frame) { MutexLock lock(&sender_lock_); - EnsureEncoderQueueCreated(); - if (!sender_) { return; } rtc::scoped_refptr delegate(this); - encoder_queue_->PostTask( + transformation_queue_->PostTask( [delegate = std::move(delegate), frame = std::move(frame)]() mutable { - RTC_DCHECK_RUN_ON(delegate->encoder_queue_); + RTC_DCHECK_RUN_ON(delegate->transformation_queue_.get()); delegate->SendVideo(std::move(frame)); }); } void RTPSenderVideoFrameTransformerDelegate::SendVideo( std::unique_ptr transformed_frame) const { - RTC_DCHECK_RUN_ON(encoder_queue_); + RTC_DCHECK_RUN_ON(transformation_queue_.get()); RTC_CHECK_EQ(transformed_frame->GetDirection(), TransformableFrameInterface::Direction::kSender); MutexLock lock(&sender_lock_); diff --git a/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.h b/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.h index 04cdfd3c6a..55f7961e2d 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.h +++ b/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.h @@ -53,7 +53,7 @@ class RTPSenderVideoFrameTransformerDelegate : public TransformedFrameCallback { // Delegates the call to RTPSendVideo::SendVideo on the `encoder_queue_`. void SendVideo(std::unique_ptr frame) const - RTC_RUN_ON(encoder_queue_); + RTC_RUN_ON(transformation_queue_); // Delegates the call to RTPSendVideo::SetVideoStructureAfterTransformation // under `sender_lock_`. @@ -80,11 +80,9 @@ class RTPSenderVideoFrameTransformerDelegate : public TransformedFrameCallback { RTPSenderVideo* sender_ RTC_GUARDED_BY(sender_lock_); rtc::scoped_refptr frame_transformer_; const uint32_t ssrc_; - TaskQueueBase* encoder_queue_ = nullptr; - TaskQueueFactory* task_queue_factory_; // Used when the encoded frames arrives without a current task queue. This can // happen if a hardware encoder was used. - std::unique_ptr owned_encoder_queue_; + std::unique_ptr transformation_queue_; }; // Method to support cloning a Sender frame from another frame diff --git a/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc index 8b41e5b4e7..e2d1a73828 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc @@ -1526,75 +1526,6 @@ TEST_F(RtpSenderVideoWithFrameTransformerTest, OnTransformedFrameSendsVideo) { EXPECT_EQ(transport_.packets_sent(), 2); } -// Task queue which behaves as if it was a hardware encoder thread where no -// CurrentTaskQueue is set. -class HardwareEncoderTaskQueue : public TaskQueueBase { - public: - HardwareEncoderTaskQueue() = default; - - void Delete() override {} - void PostTask(absl::AnyInvocable task) override { - CurrentTaskQueueSetter null_setter(nullptr); - std::move(task)(); - } - void PostDelayedTask(absl::AnyInvocable task, - TimeDelta delay) override { - // Not implemented. - RTC_CHECK_NOTREACHED(); - } - void PostDelayedHighPrecisionTask(absl::AnyInvocable task, - TimeDelta delay) override { - // Not implemented. - RTC_CHECK_NOTREACHED(); - } -}; - -TEST_F(RtpSenderVideoWithFrameTransformerTest, - OnTransformedFrameSendsVideoOnNewQueueForHwEncoders) { - auto mock_frame_transformer = - rtc::make_ref_counted>(); - rtc::scoped_refptr callback; - EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameSinkCallback) - .WillOnce(SaveArg<0>(&callback)); - std::unique_ptr rtp_sender_video = - CreateSenderWithFrameTransformer(mock_frame_transformer); - ASSERT_TRUE(callback); - - auto encoded_image = CreateDefaultEncodedImage(); - RTPVideoHeader video_header; - video_header.frame_type = VideoFrameType::kVideoFrameKey; - ON_CALL(*mock_frame_transformer, Transform) - .WillByDefault( - [&callback](std::unique_ptr frame) { - callback->OnTransformedFrame(std::move(frame)); - }); - - // Hardware encoder task queue has no TaskQueue::Current() set, and so a new - // task queue should be created to handle the callback. - HardwareEncoderTaskQueue hw_encoder_queue; - hw_encoder_queue.PostTask([&] { - rtp_sender_video->SendEncodedImage(kPayload, kType, kTimestamp, - *encoded_image, video_header, - kDefaultExpectedRetransmissionTimeMs); - }); - - // No packets sent yet since a task should be posted onto a new task queue. - EXPECT_EQ(transport_.packets_sent(), 0); - time_controller_.AdvanceTime(TimeDelta::Zero()); - EXPECT_EQ(transport_.packets_sent(), 1); - - // Check software encoder fallback. - auto encoder_queue = time_controller_.GetTaskQueueFactory()->CreateTaskQueue( - "encoder_queue", TaskQueueFactory::Priority::NORMAL); - encoder_queue->PostTask([&] { - rtp_sender_video->SendEncodedImage(kPayload, kType, kTimestamp, - *encoded_image, video_header, - kDefaultExpectedRetransmissionTimeMs); - }); - time_controller_.AdvanceTime(TimeDelta::Zero()); - EXPECT_EQ(transport_.packets_sent(), 2); -} - TEST_F(RtpSenderVideoWithFrameTransformerTest, TransformableFrameMetadataHasCorrectValue) { auto mock_frame_transformer =