diff --git a/api/frame_transformer_interface.h b/api/frame_transformer_interface.h index 062b31d3e0..e712b3c190 100644 --- a/api/frame_transformer_interface.h +++ b/api/frame_transformer_interface.h @@ -64,14 +64,8 @@ class TransformableAudioFrameInterface : public TransformableFrameInterface { // Objects implement this interface to be notified with the transformed frame. class TransformedFrameCallback : public rtc::RefCountInterface { public: - // TODO(bugs.webrtc.org/11380) remove after updating downstream dependencies - // to use new OnTransformedFrame signature. virtual void OnTransformedFrame( - std::unique_ptr transformed_frame) {} - // TODO(bugs.webrtc.org/11380) make pure virtual after updating usage - // downstream. - virtual void OnTransformedFrame( - std::unique_ptr transformed_frame) {} + std::unique_ptr frame) = 0; protected: ~TransformedFrameCallback() override = default; @@ -82,23 +76,8 @@ class TransformedFrameCallback : public rtc::RefCountInterface { class FrameTransformerInterface : public rtc::RefCountInterface { public: // Transforms |frame| using the implementing class' processing logic. - // |additional_data| holds data that is needed in the frame transformation - // logic, but is not included in |frame|; for example, when the transform - // function is used for encrypting/decrypting the frame, the additional data - // holds the serialized generic frame descriptor extension calculated in - // webrtc::RtpDescriptorAuthentication, needed in the encryption/decryption - // algorithms. - // TODO(bugs.webrtc.org/11380) remove after updating downstream dependencies - // to use new OnTransformedFrame() signature. - virtual void TransformFrame(std::unique_ptr frame, - std::vector additional_data, - uint32_t ssrc) {} - - // Transforms |frame| using the implementing class' processing logic. - // TODO(bugs.webrtc.org/11380) make pure virtual after updating usage - // downstream. virtual void Transform( - std::unique_ptr transformable_frame) {} + std::unique_ptr transformable_frame) = 0; virtual void RegisterTransformedFrameCallback( rtc::scoped_refptr) {} diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn index edad7cef1a..3af0509d77 100644 --- a/modules/rtp_rtcp/BUILD.gn +++ b/modules/rtp_rtcp/BUILD.gn @@ -206,8 +206,6 @@ rtc_library("rtp_rtcp") { "source/time_util.h", "source/tmmbr_help.cc", "source/tmmbr_help.h", - "source/transformable_encoded_frame.cc", - "source/transformable_encoded_frame.h", "source/ulpfec_generator.cc", "source/ulpfec_generator.h", "source/ulpfec_header_reader_writer.cc", diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc index e073315cd7..631feb343b 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video.cc +++ b/modules/rtp_rtcp/source/rtp_sender_video.cc @@ -35,7 +35,6 @@ #include "modules/rtp_rtcp/source/rtp_header_extensions.h" #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" #include "modules/rtp_rtcp/source/time_util.h" -#include "modules/rtp_rtcp/source/transformable_encoded_frame.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" #include "rtc_base/trace_event.h" 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 7107a3d847..25ebd1b64c 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 @@ -16,7 +16,6 @@ #include "absl/memory/memory.h" #include "modules/rtp_rtcp/source/rtp_descriptor_authentication.h" #include "modules/rtp_rtcp/source/rtp_sender_video.h" -#include "modules/rtp_rtcp/source/transformable_encoded_frame.h" #include "rtc_base/task_utils/to_queued_task.h" namespace webrtc { @@ -126,35 +125,12 @@ bool RTPSenderVideoFrameTransformerDelegate::TransformFrame( absl::optional expected_retransmission_time_ms) { if (!encoder_queue_) encoder_queue_ = TaskQueueBase::Current(); - // TODO(bugs.webrtc.org/11380) remove once this version of TransformFrame() is - // deprecated. - frame_transformer_->TransformFrame( - std::make_unique( - encoded_image.GetEncodedData(), video_header, payload_type, - codec_type, rtp_timestamp, encoded_image.capture_time_ms_, - fragmentation, expected_retransmission_time_ms), - RtpDescriptorAuthentication(video_header), ssrc_); frame_transformer_->Transform(std::make_unique( encoded_image, video_header, payload_type, codec_type, rtp_timestamp, fragmentation, expected_retransmission_time_ms, ssrc_)); return true; } -void RTPSenderVideoFrameTransformerDelegate::OnTransformedFrame( - std::unique_ptr frame) { - rtc::CritScope lock(&sender_lock_); - - // The encoder queue gets destroyed after the sender; as long as the sender is - // alive, it's safe to post. - if (!sender_) - return; - rtc::scoped_refptr delegate = this; - encoder_queue_->PostTask(ToQueuedTask( - [delegate = std::move(delegate), frame = std::move(frame)]() mutable { - delegate->SendVideo(std::move(frame)); - })); -} - void RTPSenderVideoFrameTransformerDelegate::OnTransformedFrame( std::unique_ptr frame) { rtc::CritScope lock(&sender_lock_); @@ -170,23 +146,6 @@ void RTPSenderVideoFrameTransformerDelegate::OnTransformedFrame( })); } -void RTPSenderVideoFrameTransformerDelegate::SendVideo( - std::unique_ptr frame) const { - RTC_CHECK(encoder_queue_->IsCurrent()); - rtc::CritScope lock(&sender_lock_); - if (!sender_) - return; - auto* transformed_frame = - static_cast(frame.get()); - sender_->SendVideo( - transformed_frame->PayloadType(), transformed_frame->codec_type(), - transformed_frame->Timestamp(), transformed_frame->capture_time_ms(), - transformed_frame->EncodedImage(), - transformed_frame->fragmentation_header(), - transformed_frame->video_header(), - transformed_frame->expected_retransmission_time_ms()); -} - void RTPSenderVideoFrameTransformerDelegate::SendVideo( std::unique_ptr transformed_frame) const { RTC_CHECK(encoder_queue_->IsCurrent()); 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 4c4713fe99..29ac9e4e1c 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 @@ -16,7 +16,6 @@ #include "api/frame_transformer_interface.h" #include "api/scoped_refptr.h" #include "api/task_queue/task_queue_base.h" -#include "modules/rtp_rtcp/source/transformable_encoded_frame.h" #include "rtc_base/critical_section.h" namespace webrtc { @@ -46,13 +45,10 @@ class RTPSenderVideoFrameTransformerDelegate : public TransformedFrameCallback { // Implements TransformedFrameCallback. Can be called on any thread. Posts // the transformed frame to be sent on the |encoder_queue_|. - void OnTransformedFrame( - std::unique_ptr frame) override; void OnTransformedFrame( std::unique_ptr frame) override; // Delegates the call to RTPSendVideo::SendVideo on the |encoder_queue_|. - void SendVideo(std::unique_ptr frame) const; void SendVideo(std::unique_ptr frame) const; // Delegates the call to RTPSendVideo::SendVideo under |sender_lock_|. diff --git a/modules/rtp_rtcp/source/transformable_encoded_frame.cc b/modules/rtp_rtcp/source/transformable_encoded_frame.cc deleted file mode 100644 index 2e862e3a3a..0000000000 --- a/modules/rtp_rtcp/source/transformable_encoded_frame.cc +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (c) 2020 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 "modules/rtp_rtcp/source/transformable_encoded_frame.h" - -namespace webrtc { - -TransformableEncodedFrame::TransformableEncodedFrame( - rtc::scoped_refptr encoded_data, - const RTPVideoHeader& video_header, - int payload_type, - absl::optional codec_type, - uint32_t rtp_timestamp, - int64_t capture_time_ms, - const RTPFragmentationHeader* fragmentation, - absl::optional expected_retransmission_time_ms) - : video_header_(video_header), - codec_type_(codec_type), - expected_retransmission_time_ms_(expected_retransmission_time_ms) { - SetEncodedData(encoded_data); - _payloadType = payload_type; - SetTimestamp(rtp_timestamp); - capture_time_ms_ = capture_time_ms; - if (fragmentation) { - fragmentation_header_ = std::make_unique(); - fragmentation_header_->CopyFrom(*fragmentation); - } -} - -TransformableEncodedFrame::~TransformableEncodedFrame() = default; - -const RTPVideoHeader& TransformableEncodedFrame::video_header() const { - return video_header_; -} - -absl::optional TransformableEncodedFrame::codec_type() const { - return codec_type_; -} - -int64_t TransformableEncodedFrame::ReceivedTime() const { - return 0; -} - -int64_t TransformableEncodedFrame::RenderTime() const { - return _renderTimeMs; -} - -} // namespace webrtc diff --git a/modules/rtp_rtcp/source/transformable_encoded_frame.h b/modules/rtp_rtcp/source/transformable_encoded_frame.h deleted file mode 100644 index 2d8e7ce645..0000000000 --- a/modules/rtp_rtcp/source/transformable_encoded_frame.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) 2020 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. - */ - -#ifndef MODULES_RTP_RTCP_SOURCE_TRANSFORMABLE_ENCODED_FRAME_H_ -#define MODULES_RTP_RTCP_SOURCE_TRANSFORMABLE_ENCODED_FRAME_H_ - -#include - -#include "absl/types/optional.h" -#include "api/video/encoded_frame.h" -#include "modules/include/module_common_types.h" -#include "modules/rtp_rtcp/source/rtp_video_header.h" - -namespace webrtc { - -class TransformableEncodedFrame : public video_coding::EncodedFrame { - public: - TransformableEncodedFrame( - rtc::scoped_refptr encoded_data, - const RTPVideoHeader& video_header, - int payload_type, - absl::optional codec_type, - uint32_t rtp_timestamp, - int64_t capture_time_ms, - const RTPFragmentationHeader* fragmentation, - absl::optional expected_retransmission_time_ms); - ~TransformableEncodedFrame() override; - - const RTPVideoHeader& video_header() const; - absl::optional codec_type() const; - int64_t capture_time_ms() const { return capture_time_ms_; } - RTPFragmentationHeader* fragmentation_header() const { - return fragmentation_header_.get(); - } - const absl::optional& expected_retransmission_time_ms() const { - return expected_retransmission_time_ms_; - } - - // Implements EncodedFrame. - int64_t ReceivedTime() const override; - int64_t RenderTime() const override; - - private: - RTPVideoHeader video_header_; - absl::optional codec_type_ = absl::nullopt; - std::unique_ptr fragmentation_header_; - absl::optional expected_retransmission_time_ms_ = absl::nullopt; -}; - -} // namespace webrtc - -#endif // MODULES_RTP_RTCP_SOURCE_TRANSFORMABLE_ENCODED_FRAME_H_ diff --git a/test/mock_frame_transformer.h b/test/mock_frame_transformer.h index 2b3b94e459..617cda8a43 100644 --- a/test/mock_frame_transformer.h +++ b/test/mock_frame_transformer.h @@ -21,12 +21,6 @@ namespace webrtc { class MockFrameTransformer : public FrameTransformerInterface { public: - MOCK_METHOD(void, - TransformFrame, - (std::unique_ptr, - std::vector, - uint32_t), - (override)); MOCK_METHOD(void, Transform, (std::unique_ptr), diff --git a/video/rtp_video_stream_receiver_frame_transformer_delegate.cc b/video/rtp_video_stream_receiver_frame_transformer_delegate.cc index c2fb8feb42..8324b19136 100644 --- a/video/rtp_video_stream_receiver_frame_transformer_delegate.cc +++ b/video/rtp_video_stream_receiver_frame_transformer_delegate.cc @@ -89,30 +89,11 @@ void RtpVideoStreamReceiverFrameTransformerDelegate::Reset() { void RtpVideoStreamReceiverFrameTransformerDelegate::TransformFrame( std::unique_ptr frame) { RTC_DCHECK_RUN_ON(&network_sequence_checker_); - // TODO(bugs.webrtc.org/11380) remove once this version of TransformFrame is - // deprecated. - auto additional_data = - RtpDescriptorAuthentication(frame->GetRtpVideoHeader()); - auto frame_copy = - std::make_unique(*frame.get()); - frame_transformer_->TransformFrame(std::move(frame_copy), - std::move(additional_data), ssrc_); - frame_transformer_->Transform( std::make_unique(std::move(frame), ssrc_)); } -void RtpVideoStreamReceiverFrameTransformerDelegate::OnTransformedFrame( - std::unique_ptr frame) { - rtc::scoped_refptr delegate = - this; - network_thread_->PostTask(ToQueuedTask( - [delegate = std::move(delegate), frame = std::move(frame)]() mutable { - delegate->ManageFrame(std::move(frame)); - })); -} - void RtpVideoStreamReceiverFrameTransformerDelegate::OnTransformedFrame( std::unique_ptr frame) { rtc::scoped_refptr delegate = @@ -123,16 +104,6 @@ void RtpVideoStreamReceiverFrameTransformerDelegate::OnTransformedFrame( })); } -void RtpVideoStreamReceiverFrameTransformerDelegate::ManageFrame( - std::unique_ptr frame) { - RTC_DCHECK_RUN_ON(&network_sequence_checker_); - if (!receiver_) - return; - auto transformed_frame = absl::WrapUnique( - static_cast(frame.release())); - receiver_->ManageFrame(std::move(transformed_frame)); -} - void RtpVideoStreamReceiverFrameTransformerDelegate::ManageFrame( std::unique_ptr frame) { RTC_DCHECK_RUN_ON(&network_sequence_checker_); diff --git a/video/rtp_video_stream_receiver_frame_transformer_delegate.h b/video/rtp_video_stream_receiver_frame_transformer_delegate.h index eb3c2625f0..0a106c956a 100644 --- a/video/rtp_video_stream_receiver_frame_transformer_delegate.h +++ b/video/rtp_video_stream_receiver_frame_transformer_delegate.h @@ -41,14 +41,11 @@ class RtpVideoStreamReceiverFrameTransformerDelegate // Implements TransformedFrameCallback. Can be called on any thread. Posts // the transformed frame to be managed on the |network_thread_|. - void OnTransformedFrame( - std::unique_ptr frame) override; void OnTransformedFrame( std::unique_ptr frame) override; // Delegates the call to RtpVideoReceiver::ManageFrame on the // |network_thread_|. - void ManageFrame(std::unique_ptr frame); void ManageFrame(std::unique_ptr frame); protected: diff --git a/video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc b/video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc index 7fe725339c..c481f502a4 100644 --- a/video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc +++ b/video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc @@ -30,6 +30,8 @@ namespace webrtc { namespace { using ::testing::_; +using ::testing::NiceMock; +using ::testing::SaveArg; std::unique_ptr CreateRtpFrameObject() { return std::make_unique( @@ -145,45 +147,34 @@ TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TransformFrame) { &receiver, frame_transformer, rtc::Thread::Current(), /*remote_ssrc*/ 1111)); auto frame = CreateRtpFrameObject(); - EXPECT_CALL(*frame_transformer, - TransformFrame(_, RtpDescriptorAuthentication(RTPVideoHeader()), - /*remote_ssrc*/ 1111)); + EXPECT_CALL(*frame_transformer, Transform); delegate->TransformFrame(std::move(frame)); } TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, ManageFrameOnTransformedFrame) { - auto main_thread = rtc::Thread::Create(); - main_thread->Start(); - auto network_thread = rtc::Thread::Create(); - network_thread->Start(); - TestRtpVideoStreamReceiver receiver; - rtc::scoped_refptr frame_transformer( - new rtc::RefCountedObject()); - auto delegate = network_thread->Invoke< - rtc::scoped_refptr>( - RTC_FROM_HERE, [&]() mutable { - return new rtc::RefCountedObject< - RtpVideoStreamReceiverFrameTransformerDelegate>( - &receiver, frame_transformer, network_thread.get(), - /*remote_ssrc*/ 1111); - }); + rtc::scoped_refptr mock_frame_transformer( + new rtc::RefCountedObject>()); + rtc::scoped_refptr delegate = + new rtc::RefCountedObject( + &receiver, mock_frame_transformer, rtc::Thread::Current(), + /*remote_ssrc*/ 1111); - auto frame = CreateRtpFrameObject(); + rtc::scoped_refptr callback; + EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameSinkCallback) + .WillOnce(SaveArg<0>(&callback)); + delegate->Init(); + ASSERT_TRUE(callback); - EXPECT_CALL(receiver, ManageFrame) - .WillOnce([&network_thread]( - std::unique_ptr frame) { - EXPECT_TRUE(network_thread->IsCurrent()); - }); - main_thread->Invoke(RTC_FROM_HERE, [&]() mutable { - delegate->OnTransformedFrame(std::move(frame)); - }); + EXPECT_CALL(receiver, ManageFrame); + ON_CALL(*mock_frame_transformer, Transform) + .WillByDefault( + [&callback](std::unique_ptr frame) { + callback->OnTransformedFrame(std::move(frame)); + }); + delegate->TransformFrame(CreateRtpFrameObject()); rtc::ThreadManager::ProcessAllMessageQueuesForTesting(); - - main_thread->Stop(); - network_thread->Stop(); } } // namespace diff --git a/video/rtp_video_stream_receiver_unittest.cc b/video/rtp_video_stream_receiver_unittest.cc index 9c7b891679..255de54e8b 100644 --- a/video/rtp_video_stream_receiver_unittest.cc +++ b/video/rtp_video_stream_receiver_unittest.cc @@ -1137,9 +1137,7 @@ TEST_F(RtpVideoStreamReceiverTest, TransformFrame) { GetGenericVideoHeader(VideoFrameType::kVideoFrameKey); mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(), data.size()); - EXPECT_CALL(*mock_frame_transformer, - TransformFrame(_, RtpDescriptorAuthentication(video_header), - config_.rtp.remote_ssrc)); + EXPECT_CALL(*mock_frame_transformer, Transform(_)); receiver->OnReceivedPayloadData(data, rtp_packet, video_header); EXPECT_CALL(*mock_frame_transformer,