From e488a87753fc289f99e8560cda39e0bf02f3dd6a Mon Sep 17 00:00:00 2001 From: Tommi Date: Tue, 9 Aug 2022 17:50:45 +0200 Subject: [PATCH] Remove UlpfecReceiver virtual interface. There's only one implementation. Bug: none Change-Id: I204c23e7f87102909fcf6ee8632ceeed84e901a1 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/271026 Commit-Queue: Tomas Gunnarsson Reviewed-by: Rasmus Brandt Cr-Commit-Position: refs/heads/main@{#37725} --- modules/rtp_rtcp/BUILD.gn | 5 +- modules/rtp_rtcp/include/flexfec_receiver.h | 2 +- modules/rtp_rtcp/include/ulpfec_receiver.h | 61 --------------- ...ec_receiver_impl.cc => ulpfec_receiver.cc} | 29 +++---- ...pfec_receiver_impl.h => ulpfec_receiver.h} | 35 +++++---- .../source/ulpfec_receiver_unittest.cc | 78 +++++++++---------- test/fuzzers/ulpfec_receiver_fuzzer.cc | 9 +-- video/rtp_video_stream_receiver2.cc | 9 ++- 8 files changed, 82 insertions(+), 146 deletions(-) delete mode 100644 modules/rtp_rtcp/include/ulpfec_receiver.h rename modules/rtp_rtcp/source/{ulpfec_receiver_impl.cc => ulpfec_receiver.cc} (91%) rename modules/rtp_rtcp/source/{ulpfec_receiver_impl.h => ulpfec_receiver.h} (68%) diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn index 19dbbabf9c..01076069ee 100644 --- a/modules/rtp_rtcp/BUILD.gn +++ b/modules/rtp_rtcp/BUILD.gn @@ -145,7 +145,6 @@ rtc_library("rtp_rtcp") { "include/flexfec_sender.h", "include/receive_statistics.h", "include/remote_ntp_time_estimator.h", - "include/ulpfec_receiver.h", "source/absolute_capture_time_interpolator.cc", "source/absolute_capture_time_interpolator.h", "source/absolute_capture_time_sender.cc", @@ -227,8 +226,8 @@ rtc_library("rtp_rtcp") { "source/ulpfec_generator.h", "source/ulpfec_header_reader_writer.cc", "source/ulpfec_header_reader_writer.h", - "source/ulpfec_receiver_impl.cc", - "source/ulpfec_receiver_impl.h", + "source/ulpfec_receiver.cc", + "source/ulpfec_receiver.h", "source/video_fec_generator.h", "source/video_rtp_depacketizer.cc", "source/video_rtp_depacketizer.h", diff --git a/modules/rtp_rtcp/include/flexfec_receiver.h b/modules/rtp_rtcp/include/flexfec_receiver.h index b0caea68ff..d34ba74620 100644 --- a/modules/rtp_rtcp/include/flexfec_receiver.h +++ b/modules/rtp_rtcp/include/flexfec_receiver.h @@ -17,9 +17,9 @@ #include "api/sequence_checker.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" -#include "modules/rtp_rtcp/include/ulpfec_receiver.h" #include "modules/rtp_rtcp/source/forward_error_correction.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h" +#include "modules/rtp_rtcp/source/ulpfec_receiver.h" #include "rtc_base/system/no_unique_address.h" #include "rtc_base/thread_annotations.h" diff --git a/modules/rtp_rtcp/include/ulpfec_receiver.h b/modules/rtp_rtcp/include/ulpfec_receiver.h deleted file mode 100644 index 38957c3f84..0000000000 --- a/modules/rtp_rtcp/include/ulpfec_receiver.h +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (c) 2013 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_INCLUDE_ULPFEC_RECEIVER_H_ -#define MODULES_RTP_RTCP_INCLUDE_ULPFEC_RECEIVER_H_ - -#include - -#include "api/array_view.h" -#include "api/rtp_parameters.h" -#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" -#include "modules/rtp_rtcp/source/rtp_packet_received.h" - -namespace webrtc { - -struct FecPacketCounter { - FecPacketCounter() = default; - size_t num_packets = 0; // Number of received packets. - size_t num_bytes = 0; - size_t num_fec_packets = 0; // Number of received FEC packets. - size_t num_recovered_packets = - 0; // Number of recovered media packets using FEC. - int64_t first_packet_time_ms = -1; // Time when first packet is received. -}; - -class UlpfecReceiver { - public: - static std::unique_ptr Create( - uint32_t ssrc, - RecoveredPacketReceiver* callback, - rtc::ArrayView extensions); - - virtual ~UlpfecReceiver() {} - - // Takes a RED packet, strips the RED header, and adds the resulting - // "virtual" RTP packet(s) into the internal buffer. - // - // TODO(brandtr): Set `ulpfec_payload_type` during constructor call, - // rather than as a parameter here. - virtual bool AddReceivedRedPacket(const RtpPacketReceived& rtp_packet, - uint8_t ulpfec_payload_type) = 0; - - // Sends the received packets to the FEC and returns all packets - // (both original media and recovered) through the callback. - virtual void ProcessReceivedFec() = 0; - - // Returns a counter describing the added and recovered packets. - virtual FecPacketCounter GetPacketCounter() const = 0; - - virtual void SetRtpExtensions( - rtc::ArrayView extensions) = 0; -}; -} // namespace webrtc -#endif // MODULES_RTP_RTCP_INCLUDE_ULPFEC_RECEIVER_H_ diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc b/modules/rtp_rtcp/source/ulpfec_receiver.cc similarity index 91% rename from modules/rtp_rtcp/source/ulpfec_receiver_impl.cc rename to modules/rtp_rtcp/source/ulpfec_receiver.cc index 1e52822614..0558a2b680 100644 --- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc +++ b/modules/rtp_rtcp/source/ulpfec_receiver.cc @@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "modules/rtp_rtcp/source/ulpfec_receiver_impl.h" +#include "modules/rtp_rtcp/source/ulpfec_receiver.h" #include #include @@ -20,34 +20,26 @@ namespace webrtc { -std::unique_ptr UlpfecReceiver::Create( - uint32_t ssrc, - RecoveredPacketReceiver* callback, - rtc::ArrayView extensions) { - return std::make_unique(ssrc, callback, extensions); -} - -UlpfecReceiverImpl::UlpfecReceiverImpl( - uint32_t ssrc, - RecoveredPacketReceiver* callback, - rtc::ArrayView extensions) +UlpfecReceiver::UlpfecReceiver(uint32_t ssrc, + RecoveredPacketReceiver* callback, + rtc::ArrayView extensions) : ssrc_(ssrc), extensions_(extensions), recovered_packet_callback_(callback), fec_(ForwardErrorCorrection::CreateUlpfec(ssrc_)) {} -UlpfecReceiverImpl::~UlpfecReceiverImpl() { +UlpfecReceiver::~UlpfecReceiver() { RTC_DCHECK_RUN_ON(&sequence_checker_); received_packets_.clear(); fec_->ResetState(&recovered_packets_); } -FecPacketCounter UlpfecReceiverImpl::GetPacketCounter() const { +FecPacketCounter UlpfecReceiver::GetPacketCounter() const { RTC_DCHECK_RUN_ON(&sequence_checker_); return packet_counter_; } -void UlpfecReceiverImpl::SetRtpExtensions( +void UlpfecReceiver::SetRtpExtensions( rtc::ArrayView extensions) { RTC_DCHECK_RUN_ON(&sequence_checker_); extensions_.Reset(extensions); @@ -81,9 +73,8 @@ void UlpfecReceiverImpl::SetRtpExtensions( // block length: 10 bits Length in bytes of the corresponding data // block excluding header. -bool UlpfecReceiverImpl::AddReceivedRedPacket( - const RtpPacketReceived& rtp_packet, - uint8_t ulpfec_payload_type) { +bool UlpfecReceiver::AddReceivedRedPacket(const RtpPacketReceived& rtp_packet, + uint8_t ulpfec_payload_type) { RTC_DCHECK_RUN_ON(&sequence_checker_); // TODO(bugs.webrtc.org/11993): We get here via Call::DeliverRtp, so should be // moved to the network thread. @@ -159,7 +150,7 @@ bool UlpfecReceiverImpl::AddReceivedRedPacket( return true; } -void UlpfecReceiverImpl::ProcessReceivedFec() { +void UlpfecReceiver::ProcessReceivedFec() { RTC_DCHECK_RUN_ON(&sequence_checker_); // If we iterate over `received_packets_` and it contains a packet that cause diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_impl.h b/modules/rtp_rtcp/source/ulpfec_receiver.h similarity index 68% rename from modules/rtp_rtcp/source/ulpfec_receiver_impl.h rename to modules/rtp_rtcp/source/ulpfec_receiver.h index 133967c9aa..727dba6439 100644 --- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.h +++ b/modules/rtp_rtcp/source/ulpfec_receiver.h @@ -8,8 +8,8 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef MODULES_RTP_RTCP_SOURCE_ULPFEC_RECEIVER_IMPL_H_ -#define MODULES_RTP_RTCP_SOURCE_ULPFEC_RECEIVER_IMPL_H_ +#ifndef MODULES_RTP_RTCP_SOURCE_ULPFEC_RECEIVER_H_ +#define MODULES_RTP_RTCP_SOURCE_ULPFEC_RECEIVER_H_ #include #include @@ -20,28 +20,37 @@ #include "api/sequence_checker.h" #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" -#include "modules/rtp_rtcp/include/ulpfec_receiver.h" #include "modules/rtp_rtcp/source/forward_error_correction.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/system/no_unique_address.h" namespace webrtc { -class UlpfecReceiverImpl : public UlpfecReceiver { +struct FecPacketCounter { + FecPacketCounter() = default; + size_t num_packets = 0; // Number of received packets. + size_t num_bytes = 0; + size_t num_fec_packets = 0; // Number of received FEC packets. + size_t num_recovered_packets = + 0; // Number of recovered media packets using FEC. + int64_t first_packet_time_ms = -1; // Time when first packet is received. +}; + +class UlpfecReceiver { public: - explicit UlpfecReceiverImpl(uint32_t ssrc, - RecoveredPacketReceiver* callback, - rtc::ArrayView extensions); - ~UlpfecReceiverImpl() override; + UlpfecReceiver(uint32_t ssrc, + RecoveredPacketReceiver* callback, + rtc::ArrayView extensions); + ~UlpfecReceiver(); bool AddReceivedRedPacket(const RtpPacketReceived& rtp_packet, - uint8_t ulpfec_payload_type) override; + uint8_t ulpfec_payload_type); - void ProcessReceivedFec() override; + void ProcessReceivedFec(); - FecPacketCounter GetPacketCounter() const override; + FecPacketCounter GetPacketCounter() const; - void SetRtpExtensions(rtc::ArrayView extensions) override; + void SetRtpExtensions(rtc::ArrayView extensions); private: const uint32_t ssrc_; @@ -63,4 +72,4 @@ class UlpfecReceiverImpl : public UlpfecReceiver { } // namespace webrtc -#endif // MODULES_RTP_RTCP_SOURCE_ULPFEC_RECEIVER_IMPL_H_ +#endif // MODULES_RTP_RTCP_SOURCE_ULPFEC_RECEIVER_H_ diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc index 4537d5d7aa..a0f71e31d8 100644 --- a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc @@ -8,12 +8,13 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "modules/rtp_rtcp/include/ulpfec_receiver.h" +#include "modules/rtp_rtcp/source/ulpfec_receiver.h" #include #include #include +#include #include "modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h" #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" @@ -49,9 +50,7 @@ class UlpfecReceiverTest : public ::testing::Test { protected: UlpfecReceiverTest() : fec_(ForwardErrorCorrection::CreateUlpfec(kMediaSsrc)), - receiver_fec_(UlpfecReceiver::Create(kMediaSsrc, - &recovered_packet_receiver_, - {})), + receiver_fec_(kMediaSsrc, &recovered_packet_receiver_, {}), packet_generator_(kMediaSsrc) {} // Generates `num_fec_packets` FEC packets, given `media_packets`. @@ -87,7 +86,7 @@ class UlpfecReceiverTest : public ::testing::Test { MockRecoveredPacketReceiver recovered_packet_receiver_; std::unique_ptr fec_; - std::unique_ptr receiver_fec_; + UlpfecReceiver receiver_fec_; UlpfecPacketGenerator packet_generator_; }; @@ -126,13 +125,13 @@ void UlpfecReceiverTest::BuildAndAddRedMediaPacket(AugmentedPacket* packet, bool is_recovered) { RtpPacketReceived red_packet = packet_generator_.BuildMediaRedPacket(*packet, is_recovered); - EXPECT_TRUE(receiver_fec_->AddReceivedRedPacket(red_packet, kFecPayloadType)); + EXPECT_TRUE(receiver_fec_.AddReceivedRedPacket(red_packet, kFecPayloadType)); } void UlpfecReceiverTest::BuildAndAddRedFecPacket(Packet* packet) { RtpPacketReceived red_packet = packet_generator_.BuildUlpfecRedPacket(*packet); - EXPECT_TRUE(receiver_fec_->AddReceivedRedPacket(red_packet, kFecPayloadType)); + EXPECT_TRUE(receiver_fec_.AddReceivedRedPacket(red_packet, kFecPayloadType)); } void UlpfecReceiverTest::VerifyReconstructedMediaPacket( @@ -164,9 +163,9 @@ void UlpfecReceiverTest::InjectGarbagePacketLength(size_t fec_garbage_offset) { // packet to cause a recovery from the FEC packet. BuildAndAddRedMediaPacket(augmented_media_packets.front()); BuildAndAddRedFecPacket(fec_packets.front()); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); - FecPacketCounter counter = receiver_fec_->GetPacketCounter(); + FecPacketCounter counter = receiver_fec_.GetPacketCounter(); EXPECT_EQ(2U, counter.num_packets); EXPECT_EQ(1U, counter.num_fec_packets); EXPECT_EQ(0U, counter.num_recovered_packets); @@ -176,12 +175,11 @@ void UlpfecReceiverTest::SurvivesMaliciousPacket(const uint8_t* data, size_t length, uint8_t ulpfec_payload_type) { NullRecoveredPacketReceiver null_callback; - std::unique_ptr receiver_fec( - UlpfecReceiver::Create(kMediaSsrc, &null_callback, {})); + UlpfecReceiver receiver_fec(kMediaSsrc, &null_callback, {}); RtpPacketReceived rtp_packet; ASSERT_TRUE(rtp_packet.Parse(data, length)); - receiver_fec->AddReceivedRedPacket(rtp_packet, ulpfec_payload_type); + receiver_fec.AddReceivedRedPacket(rtp_packet, ulpfec_payload_type); } TEST_F(UlpfecReceiverTest, TwoMediaOneFec) { @@ -192,7 +190,7 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFec) { std::list fec_packets; EncodeFec(media_packets, kNumFecPackets, &fec_packets); - FecPacketCounter counter = receiver_fec_->GetPacketCounter(); + FecPacketCounter counter = receiver_fec_.GetPacketCounter(); EXPECT_EQ(0u, counter.num_packets); EXPECT_EQ(-1, counter.first_packet_time_ms); @@ -200,8 +198,8 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFec) { auto it = augmented_media_packets.begin(); BuildAndAddRedMediaPacket(*it); VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); - counter = receiver_fec_->GetPacketCounter(); + receiver_fec_.ProcessReceivedFec(); + counter = receiver_fec_.GetPacketCounter(); EXPECT_EQ(1u, counter.num_packets); EXPECT_EQ(0u, counter.num_fec_packets); EXPECT_EQ(0u, counter.num_recovered_packets); @@ -213,9 +211,9 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFec) { BuildAndAddRedFecPacket(*fec_it); ++it; VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); - counter = receiver_fec_->GetPacketCounter(); + counter = receiver_fec_.GetPacketCounter(); EXPECT_EQ(2u, counter.num_packets); EXPECT_EQ(1u, counter.num_fec_packets); EXPECT_EQ(1u, counter.num_recovered_packets); @@ -230,7 +228,7 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFecNotUsesRecoveredPackets) { std::list fec_packets; EncodeFec(media_packets, kNumFecPackets, &fec_packets); - FecPacketCounter counter = receiver_fec_->GetPacketCounter(); + FecPacketCounter counter = receiver_fec_.GetPacketCounter(); EXPECT_EQ(0u, counter.num_packets); EXPECT_EQ(-1, counter.first_packet_time_ms); @@ -238,8 +236,8 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFecNotUsesRecoveredPackets) { auto it = augmented_media_packets.begin(); BuildAndAddRedMediaPacket(*it, /*is_recovered=*/true); VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); - counter = receiver_fec_->GetPacketCounter(); + receiver_fec_.ProcessReceivedFec(); + counter = receiver_fec_.GetPacketCounter(); EXPECT_EQ(1u, counter.num_packets); EXPECT_EQ(0u, counter.num_fec_packets); EXPECT_EQ(0u, counter.num_recovered_packets); @@ -250,9 +248,9 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFecNotUsesRecoveredPackets) { auto fec_it = fec_packets.begin(); BuildAndAddRedFecPacket(*fec_it); ++it; - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); - counter = receiver_fec_->GetPacketCounter(); + counter = receiver_fec_.GetPacketCounter(); EXPECT_EQ(2u, counter.num_packets); EXPECT_EQ(1u, counter.num_fec_packets); EXPECT_EQ(0u, counter.num_recovered_packets); @@ -284,12 +282,12 @@ TEST_F(UlpfecReceiverTest, TwoMediaTwoFec) { auto fec_it = fec_packets.begin(); BuildAndAddRedFecPacket(*fec_it); VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); ++fec_it; BuildAndAddRedFecPacket(*fec_it); ++it; VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } TEST_F(UlpfecReceiverTest, TwoFramesOneFec) { @@ -305,12 +303,12 @@ TEST_F(UlpfecReceiverTest, TwoFramesOneFec) { auto it = augmented_media_packets.begin(); BuildAndAddRedMediaPacket(augmented_media_packets.front()); VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); // Drop one media packet. BuildAndAddRedFecPacket(fec_packets.front()); ++it; VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } TEST_F(UlpfecReceiverTest, OneCompleteOneUnrecoverableFrame) { @@ -327,11 +325,11 @@ TEST_F(UlpfecReceiverTest, OneCompleteOneUnrecoverableFrame) { auto it = augmented_media_packets.begin(); BuildAndAddRedMediaPacket(*it); // First frame: one packet. VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); ++it; BuildAndAddRedMediaPacket(*it); // First packet of second frame. VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } TEST_F(UlpfecReceiverTest, MaxFramesOneFec) { @@ -351,12 +349,12 @@ TEST_F(UlpfecReceiverTest, MaxFramesOneFec) { for (; it != augmented_media_packets.end(); ++it) { BuildAndAddRedMediaPacket(*it); VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } BuildAndAddRedFecPacket(fec_packets.front()); it = augmented_media_packets.begin(); VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } TEST_F(UlpfecReceiverTest, TooManyFrames) { @@ -388,7 +386,7 @@ TEST_F(UlpfecReceiverTest, PacketNotDroppedTooEarly) { BuildAndAddRedMediaPacket(augmented_media_packets_batch1.front()); EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, _)).Times(1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); delayed_fec = fec_packets.front(); // Fill the FEC decoder. No packets should be dropped. @@ -403,13 +401,13 @@ TEST_F(UlpfecReceiverTest, PacketNotDroppedTooEarly) { it != augmented_media_packets_batch2.end(); ++it) { BuildAndAddRedMediaPacket(*it); EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, _)).Times(1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } // Add the delayed FEC packet. One packet should be reconstructed. BuildAndAddRedFecPacket(delayed_fec); EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, _)).Times(1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } TEST_F(UlpfecReceiverTest, PacketDroppedWhenTooOld) { @@ -427,7 +425,7 @@ TEST_F(UlpfecReceiverTest, PacketDroppedWhenTooOld) { BuildAndAddRedMediaPacket(augmented_media_packets_batch1.front()); EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, _)).Times(1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); delayed_fec = fec_packets.front(); // Fill the FEC decoder and force the last packet to be dropped. @@ -442,14 +440,14 @@ TEST_F(UlpfecReceiverTest, PacketDroppedWhenTooOld) { it != augmented_media_packets_batch2.end(); ++it) { BuildAndAddRedMediaPacket(*it); EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, _)).Times(1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } // Add the delayed FEC packet. No packet should be reconstructed since the // first media packet of that frame has been dropped due to being too old. BuildAndAddRedFecPacket(delayed_fec); EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, _)).Times(0); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } TEST_F(UlpfecReceiverTest, OldFecPacketDropped) { @@ -468,7 +466,7 @@ TEST_F(UlpfecReceiverTest, OldFecPacketDropped) { // Only FEC packets inserted. No packets recoverable at this time. BuildAndAddRedFecPacket(*it); EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, _)).Times(0); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } // Move unique_ptr's to media_packets for lifetime management. media_packets.insert(media_packets.end(), @@ -483,7 +481,7 @@ TEST_F(UlpfecReceiverTest, OldFecPacketDropped) { // returned. BuildAndAddRedMediaPacket(augmented_media_packets.front()); EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, _)).Times(1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } TEST_F(UlpfecReceiverTest, TruncatedPacketWithFBitSet) { @@ -531,12 +529,12 @@ TEST_F(UlpfecReceiverTest, MediaWithPadding) { BuildAndAddRedMediaPacket(augmented_media_packets.front()); VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); BuildAndAddRedFecPacket(fec_packets.front()); ++it; VerifyReconstructedMediaPacket(**it, 1); - receiver_fec_->ProcessReceivedFec(); + receiver_fec_.ProcessReceivedFec(); } } // namespace webrtc diff --git a/test/fuzzers/ulpfec_receiver_fuzzer.cc b/test/fuzzers/ulpfec_receiver_fuzzer.cc index 042aa5d112..c76744ec13 100644 --- a/test/fuzzers/ulpfec_receiver_fuzzer.cc +++ b/test/fuzzers/ulpfec_receiver_fuzzer.cc @@ -11,9 +11,9 @@ #include #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" -#include "modules/rtp_rtcp/include/ulpfec_receiver.h" #include "modules/rtp_rtcp/source/byte_io.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h" +#include "modules/rtp_rtcp/source/ulpfec_receiver.h" #include "test/fuzzers/fuzz_data_helper.h" namespace webrtc { @@ -36,8 +36,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) { uint16_t media_seq_num = ByteReader::ReadLittleEndian(data + 10); DummyCallback callback; - std::unique_ptr receiver( - UlpfecReceiver::Create(ulpfec_ssrc, &callback, {})); + UlpfecReceiver receiver(ulpfec_ssrc, &callback, {}); test::FuzzDataHelper fuzz_data(rtc::MakeArrayView(data, size)); while (fuzz_data.CanReadBytes(kMinDataNeeded)) { @@ -63,10 +62,10 @@ void FuzzOneInput(const uint8_t* data, size_t size) { parsed_packet.SetSsrc(media_ssrc); } - receiver->AddReceivedRedPacket(parsed_packet, 0); + receiver.AddReceivedRedPacket(parsed_packet, 0); } - receiver->ProcessReceivedFec(); + receiver.ProcessReceivedFec(); } } // namespace webrtc diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc index b506c1e9c2..756b6e4510 100644 --- a/video/rtp_video_stream_receiver2.cc +++ b/video/rtp_video_stream_receiver2.cc @@ -25,7 +25,6 @@ #include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" #include "modules/rtp_rtcp/include/receive_statistics.h" #include "modules/rtp_rtcp/include/rtp_cvo.h" -#include "modules/rtp_rtcp/include/ulpfec_receiver.h" #include "modules/rtp_rtcp/source/create_video_rtp_depacketizer.h" #include "modules/rtp_rtcp/source/rtp_dependency_descriptor_extension.h" #include "modules/rtp_rtcp/source/rtp_format.h" @@ -34,6 +33,7 @@ #include "modules/rtp_rtcp/source/rtp_header_extensions.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "modules/rtp_rtcp/source/rtp_rtcp_config.h" +#include "modules/rtp_rtcp/source/ulpfec_receiver.h" #include "modules/rtp_rtcp/source/video_rtp_depacketizer.h" #include "modules/rtp_rtcp/source/video_rtp_depacketizer_raw.h" #include "modules/video_coding/frame_object.h" @@ -234,9 +234,10 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2( forced_playout_delay_max_ms_("max_ms", absl::nullopt), forced_playout_delay_min_ms_("min_ms", absl::nullopt), rtp_receive_statistics_(rtp_receive_statistics), - ulpfec_receiver_(UlpfecReceiver::Create(config->rtp.remote_ssrc, - this, - config->rtp.extensions)), + ulpfec_receiver_( + std::make_unique(config->rtp.remote_ssrc, + this, + config->rtp.extensions)), packet_sink_(config->rtp.packet_sink_), receiving_(false), last_packet_log_ms_(-1),