From 869e7cd8e789b2460f8456ec4acb1fc2eed2a38c Mon Sep 17 00:00:00 2001 From: brandtr Date: Mon, 31 Oct 2016 05:27:07 -0700 Subject: [PATCH] Rename ProducerFec to UlpfecGenerator. BUG=webrtc:5654 Review-Url: https://codereview.webrtc.org/2449783002 Cr-Commit-Position: refs/heads/master@{#14847} --- webrtc/modules/BUILD.gn | 2 +- webrtc/modules/rtp_rtcp/BUILD.gn | 4 +- webrtc/modules/rtp_rtcp/rtp_rtcp.gypi | 4 +- .../rtp_rtcp/source/rtp_sender_video.cc | 19 +++--- .../rtp_rtcp/source/rtp_sender_video.h | 4 +- .../{producer_fec.cc => ulpfec_generator.cc} | 37 +++++------ .../{producer_fec.h => ulpfec_generator.h} | 12 ++-- ...ittest.cc => ulpfec_generator_unittest.cc} | 65 ++++++++++--------- webrtc/test/fuzzers/BUILD.gn | 4 +- ...c_fuzzer.cc => ulpfec_generator_fuzzer.cc} | 18 ++--- 10 files changed, 83 insertions(+), 86 deletions(-) rename webrtc/modules/rtp_rtcp/source/{producer_fec.cc => ulpfec_generator.cc} (88%) rename webrtc/modules/rtp_rtcp/source/{producer_fec.h => ulpfec_generator.h} (93%) rename webrtc/modules/rtp_rtcp/source/{producer_fec_unittest.cc => ulpfec_generator_unittest.cc} (77%) rename webrtc/test/fuzzers/{producer_fec_fuzzer.cc => ulpfec_generator_fuzzer.cc} (78%) diff --git a/webrtc/modules/BUILD.gn b/webrtc/modules/BUILD.gn index c5330eace0..8ee981061b 100644 --- a/webrtc/modules/BUILD.gn +++ b/webrtc/modules/BUILD.gn @@ -421,7 +421,6 @@ if (rtc_include_tests) { "rtp_rtcp/source/nack_rtx_unittest.cc", "rtp_rtcp/source/packet_loss_stats_unittest.cc", "rtp_rtcp/source/playout_delay_oracle_unittest.cc", - "rtp_rtcp/source/producer_fec_unittest.cc", "rtp_rtcp/source/receive_statistics_unittest.cc", "rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc", "rtp_rtcp/source/rtcp_packet/app_unittest.cc", @@ -464,6 +463,7 @@ if (rtc_include_tests) { "rtp_rtcp/source/rtp_rtcp_impl_unittest.cc", "rtp_rtcp/source/rtp_sender_unittest.cc", "rtp_rtcp/source/time_util_unittest.cc", + "rtp_rtcp/source/ulpfec_generator_unittest.cc", "rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc", "rtp_rtcp/source/ulpfec_receiver_unittest.cc", "rtp_rtcp/source/vp8_partition_aggregator_unittest.cc", diff --git a/webrtc/modules/rtp_rtcp/BUILD.gn b/webrtc/modules/rtp_rtcp/BUILD.gn index 14b940ae82..0a580a4edc 100644 --- a/webrtc/modules/rtp_rtcp/BUILD.gn +++ b/webrtc/modules/rtp_rtcp/BUILD.gn @@ -38,8 +38,6 @@ rtc_static_library("rtp_rtcp") { "source/packet_loss_stats.h", "source/playout_delay_oracle.cc", "source/playout_delay_oracle.h", - "source/producer_fec.cc", - "source/producer_fec.h", "source/receive_statistics_impl.cc", "source/receive_statistics_impl.h", "source/remote_ntp_time_estimator.cc", @@ -150,6 +148,8 @@ rtc_static_library("rtp_rtcp") { "source/time_util.h", "source/tmmbr_help.cc", "source/tmmbr_help.h", + "source/ulpfec_generator.cc", + "source/ulpfec_generator.h", "source/ulpfec_header_reader_writer.cc", "source/ulpfec_header_reader_writer.h", "source/ulpfec_receiver_impl.cc", diff --git a/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi b/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi index 062f053e8d..ca9de8029c 100644 --- a/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi +++ b/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi @@ -137,8 +137,6 @@ 'source/forward_error_correction.h', 'source/forward_error_correction_internal.cc', 'source/forward_error_correction_internal.h', - 'source/producer_fec.cc', - 'source/producer_fec.h', 'source/rtp_packet_history.cc', 'source/rtp_packet_history.h', 'source/rtp_payload_registry.cc', @@ -159,6 +157,8 @@ 'source/rtp_format_vp9.h', 'source/rtp_format_video_generic.cc', 'source/rtp_format_video_generic.h', + 'source/ulpfec_generator.cc', + 'source/ulpfec_generator.h', 'source/ulpfec_header_reader_writer.cc', 'source/ulpfec_header_reader_writer.h', 'source/ulpfec_receiver_impl.cc', diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc index 87a8226d23..76fc42bdba 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc @@ -22,7 +22,6 @@ #include "webrtc/base/trace_event.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" -#include "webrtc/modules/rtp_rtcp/source/producer_fec.h" #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h" #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h" #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h" @@ -123,15 +122,15 @@ void RTPSenderVideo::SendVideoPacketAsRed( rtc::CritScope cs(&crit_); red_packet->SetPayloadType(red_payload_type_); if (protect) { - producer_fec_.AddRtpPacketAndGenerateFec(media_packet->data(), - media_packet->payload_size(), - media_packet->headers_size()); + ulpfec_generator_.AddRtpPacketAndGenerateFec( + media_packet->data(), media_packet->payload_size(), + media_packet->headers_size()); } - uint16_t num_fec_packets = producer_fec_.NumAvailableFecPackets(); + uint16_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets(); if (num_fec_packets > 0) { uint16_t first_fec_sequence_number = rtp_sender_->AllocateSequenceNumber(num_fec_packets); - fec_packets = producer_fec_.GetUlpfecPacketsAsRed( + fec_packets = ulpfec_generator_.GetUlpfecPacketsAsRed( red_payload_type_, fec_payload_type_, first_fec_sequence_number, media_packet->headers_size()); RTC_DCHECK_EQ(num_fec_packets, fec_packets.size()); @@ -152,7 +151,7 @@ void RTPSenderVideo::SendVideoPacketAsRed( LOG(LS_WARNING) << "Failed to send RED packet " << media_seq_num; } for (const auto& fec_packet : fec_packets) { - // TODO(danilchap): Make producer_fec_ generate RtpPacketToSend to avoid + // TODO(danilchap): Make ulpfec_generator_ generate RtpPacketToSend to avoid // reparsing them. std::unique_ptr rtp_packet( new RtpPacketToSend(*media_packet)); @@ -202,11 +201,11 @@ size_t RTPSenderVideo::FecPacketOverhead() const { // This reason for the header extensions to be included here is that // from an FEC viewpoint, they are part of the payload to be protected. // (The base RTP header is already protected by the FEC header.) - return producer_fec_.MaxPacketOverhead() + kRedForFecHeaderLength + + return ulpfec_generator_.MaxPacketOverhead() + kRedForFecHeaderLength + (rtp_sender_->RtpHeaderLength() - kRtpHeaderSize); } if (fec_enabled_) - overhead += producer_fec_.MaxPacketOverhead(); + overhead += ulpfec_generator_.MaxPacketOverhead(); return overhead; } @@ -277,7 +276,7 @@ bool RTPSenderVideo::SendVideo(RtpVideoCodecTypes video_type, rtc::CritScope cs(&crit_); FecProtectionParams* fec_params = frame_type == kVideoFrameKey ? &key_fec_params_ : &delta_fec_params_; - producer_fec_.SetFecParameters(fec_params); + ulpfec_generator_.SetFecParameters(fec_params); storage = packetizer->GetStorageType(retransmission_settings_); red_payload_type = red_payload_type_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h index f69b8e370a..003b79f0b8 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h @@ -22,10 +22,10 @@ #include "webrtc/common_types.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" -#include "webrtc/modules/rtp_rtcp/source/producer_fec.h" #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h" #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" +#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h" #include "webrtc/modules/rtp_rtcp/source/video_codec_information.h" #include "webrtc/typedefs.h" @@ -104,7 +104,7 @@ class RTPSenderVideo { 0, 1, kFecMaskRandom}; FecProtectionParams key_fec_params_ GUARDED_BY(crit_) = FecProtectionParams{ 0, 1, kFecMaskRandom}; - ProducerFec producer_fec_ GUARDED_BY(crit_); + UlpfecGenerator ulpfec_generator_ GUARDED_BY(crit_); rtc::CriticalSection stats_crit_; // Bitrate used for FEC payload, RED headers, RTP headers for FEC packets diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec.cc b/webrtc/modules/rtp_rtcp/source/ulpfec_generator.cc similarity index 88% rename from webrtc/modules/rtp_rtcp/source/producer_fec.cc rename to webrtc/modules/rtp_rtcp/source/ulpfec_generator.cc index f96437698b..3c71c63835 100644 --- a/webrtc/modules/rtp_rtcp/source/producer_fec.cc +++ b/webrtc/modules/rtp_rtcp/source/ulpfec_generator.cc @@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "webrtc/modules/rtp_rtcp/source/producer_fec.h" +#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h" #include #include @@ -52,10 +52,7 @@ constexpr float kMinMediaPacketsAdaptationThreshold = 2.0f; } // namespace RedPacket::RedPacket(size_t length) - : data_(new uint8_t[length]), - length_(length), - header_length_(0) { -} + : data_(new uint8_t[length]), length_(length), header_length_(0) {} void RedPacket::CreateHeader(const uint8_t* rtp_header, size_t header_length, @@ -96,7 +93,7 @@ size_t RedPacket::length() const { return length_; } -ProducerFec::ProducerFec() +UlpfecGenerator::UlpfecGenerator() : fec_(ForwardErrorCorrection::CreateUlpfec()), num_protected_frames_(0), min_num_media_packets_(1) { @@ -104,9 +101,9 @@ ProducerFec::ProducerFec() memset(&new_params_, 0, sizeof(new_params_)); } -ProducerFec::~ProducerFec() = default; +UlpfecGenerator::~UlpfecGenerator() = default; -std::unique_ptr ProducerFec::BuildRedPacket( +std::unique_ptr UlpfecGenerator::BuildRedPacket( const uint8_t* data_buffer, size_t payload_length, size_t rtp_header_length, @@ -120,7 +117,7 @@ std::unique_ptr ProducerFec::BuildRedPacket( return red_packet; } -void ProducerFec::SetFecParameters(const FecProtectionParams* params) { +void UlpfecGenerator::SetFecParameters(const FecProtectionParams* params) { RTC_DCHECK_GE(params->fec_rate, 0); RTC_DCHECK_LE(params->fec_rate, 255); // Store the new params and apply them for the next set of FEC packets being @@ -133,9 +130,9 @@ void ProducerFec::SetFecParameters(const FecProtectionParams* params) { } } -int ProducerFec::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer, - size_t payload_length, - size_t rtp_header_length) { +int UlpfecGenerator::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer, + size_t payload_length, + size_t rtp_header_length) { RTC_DCHECK(generated_fec_packets_.empty()); if (media_packets_.empty()) { params_ = new_params_; @@ -175,11 +172,11 @@ int ProducerFec::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer, return 0; } -bool ProducerFec::ExcessOverheadBelowMax() const { +bool UlpfecGenerator::ExcessOverheadBelowMax() const { return ((Overhead() - params_.fec_rate) < kMaxExcessOverhead); } -bool ProducerFec::MinimumMediaPacketsReached() const { +bool UlpfecGenerator::MinimumMediaPacketsReached() const { float average_num_packets_per_frame = static_cast(media_packets_.size()) / num_protected_frames_; int num_media_packets = static_cast(media_packets_.size()); @@ -192,19 +189,19 @@ bool ProducerFec::MinimumMediaPacketsReached() const { } } -bool ProducerFec::FecAvailable() const { +bool UlpfecGenerator::FecAvailable() const { return !generated_fec_packets_.empty(); } -size_t ProducerFec::NumAvailableFecPackets() const { +size_t UlpfecGenerator::NumAvailableFecPackets() const { return generated_fec_packets_.size(); } -size_t ProducerFec::MaxPacketOverhead() const { +size_t UlpfecGenerator::MaxPacketOverhead() const { return fec_->MaxPacketOverhead(); } -std::vector> ProducerFec::GetUlpfecPacketsAsRed( +std::vector> UlpfecGenerator::GetUlpfecPacketsAsRed( int red_payload_type, int ulpfec_payload_type, uint16_t first_seq_num, @@ -234,7 +231,7 @@ std::vector> ProducerFec::GetUlpfecPacketsAsRed( return red_packets; } -int ProducerFec::Overhead() const { +int UlpfecGenerator::Overhead() const { RTC_DCHECK(!media_packets_.empty()); int num_fec_packets = fec_->NumFecPackets(media_packets_.size(), params_.fec_rate); @@ -242,7 +239,7 @@ int ProducerFec::Overhead() const { return (num_fec_packets << 8) / media_packets_.size(); } -void ProducerFec::ResetState() { +void UlpfecGenerator::ResetState() { media_packets_.clear(); generated_fec_packets_.clear(); num_protected_frames_ = 0; diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec.h b/webrtc/modules/rtp_rtcp/source/ulpfec_generator.h similarity index 93% rename from webrtc/modules/rtp_rtcp/source/producer_fec.h rename to webrtc/modules/rtp_rtcp/source/ulpfec_generator.h index 35bb7dafbf..33c4d09c39 100644 --- a/webrtc/modules/rtp_rtcp/source/producer_fec.h +++ b/webrtc/modules/rtp_rtcp/source/ulpfec_generator.h @@ -8,8 +8,8 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_ -#define WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_ +#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_ +#define WEBRTC_MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_ #include #include @@ -39,10 +39,10 @@ class RedPacket { size_t header_length_; }; -class ProducerFec { +class UlpfecGenerator { public: - ProducerFec(); - ~ProducerFec(); + UlpfecGenerator(); + ~UlpfecGenerator(); static std::unique_ptr BuildRedPacket(const uint8_t* data_buffer, size_t payload_length, @@ -106,4 +106,4 @@ class ProducerFec { } // namespace webrtc -#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_ +#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_ diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/ulpfec_generator_unittest.cc similarity index 77% rename from webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc rename to webrtc/modules/rtp_rtcp/source/ulpfec_generator_unittest.cc index 810785acde..9b47ff5c61 100644 --- a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/ulpfec_generator_unittest.cc @@ -17,7 +17,7 @@ #include "webrtc/modules/rtp_rtcp/source/byte_io.h" #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" -#include "webrtc/modules/rtp_rtcp/source/producer_fec.h" +#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h" #include "webrtc/test/gtest.h" namespace webrtc { @@ -50,11 +50,11 @@ void VerifyHeader(uint16_t seq_num, EXPECT_EQ(static_cast(fec_payload_type), data[kRtpHeaderSize]); } -class ProducerFecTest : public ::testing::Test { +class UlpfecGeneratorTest : public ::testing::Test { protected: - ProducerFecTest() : packet_generator_(kMediaSsrc) {} + UlpfecGeneratorTest() : packet_generator_(kMediaSsrc) {} - ProducerFec producer_; + UlpfecGenerator ulpfec_generator_; AugmentedPacketGenerator packet_generator_; }; @@ -62,7 +62,7 @@ class ProducerFecTest : public ::testing::Test { // to move past the end of the current FEC packet mask byte without moving to // the next byte. That likely caused us to repeatedly read from the same byte, // and if that byte didn't protect packets we would generate empty FEC. -TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) { +TEST_F(UlpfecGeneratorTest, NoEmptyFecWithSeqNumGaps) { struct Packet { size_t header_size; size_t payload_size; @@ -81,7 +81,7 @@ TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) { protected_packets.push_back({21, 0, 55, 0}); protected_packets.push_back({13, 3, 57, 1}); FecProtectionParams params = {117, 3, kFecMaskBursty}; - producer_.SetFecParameters(¶ms); + ulpfec_generator_.SetFecParameters(¶ms); uint8_t packet[28] = {0}; for (Packet p : protected_packets) { if (p.marker_bit) { @@ -90,18 +90,19 @@ TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) { packet[1] &= ~0x80; } ByteWriter::WriteBigEndian(&packet[2], p.seq_num); - producer_.AddRtpPacketAndGenerateFec(packet, p.payload_size, p.header_size); - size_t num_fec_packets = producer_.NumAvailableFecPackets(); + ulpfec_generator_.AddRtpPacketAndGenerateFec(packet, p.payload_size, + p.header_size); + size_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets(); if (num_fec_packets > 0) { std::vector> fec_packets = - producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100, - p.header_size); + ulpfec_generator_.GetUlpfecPacketsAsRed( + kRedPayloadType, kFecPayloadType, 100, p.header_size); EXPECT_EQ(num_fec_packets, fec_packets.size()); } } } -TEST_F(ProducerFecTest, OneFrameFec) { +TEST_F(UlpfecGeneratorTest, OneFrameFec) { // The number of media packets (|kNumPackets|), number of frames (one for // this test), and the protection factor (|params->fec_rate|) are set to make // sure the conditions for generating FEC are satisfied. This means: @@ -111,27 +112,27 @@ TEST_F(ProducerFecTest, OneFrameFec) { constexpr size_t kNumPackets = 4; FecProtectionParams params = {15, 3, kFecMaskRandom}; packet_generator_.NewFrame(kNumPackets); - producer_.SetFecParameters(¶ms); // Expecting one FEC packet. + ulpfec_generator_.SetFecParameters(¶ms); // Expecting one FEC packet. uint32_t last_timestamp = 0; for (size_t i = 0; i < kNumPackets; ++i) { std::unique_ptr packet = packet_generator_.NextPacket(i, 10); - EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( + EXPECT_EQ(0, ulpfec_generator_.AddRtpPacketAndGenerateFec( packet->data, packet->length, kRtpHeaderSize)); last_timestamp = packet->header.header.timestamp; } - EXPECT_TRUE(producer_.FecAvailable()); + EXPECT_TRUE(ulpfec_generator_.FecAvailable()); uint16_t seq_num = packet_generator_.NextPacketSeqNum(); std::vector> red_packets = - producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, - kRtpHeaderSize); - EXPECT_FALSE(producer_.FecAvailable()); + ulpfec_generator_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, + seq_num, kRtpHeaderSize); + EXPECT_FALSE(ulpfec_generator_.FecAvailable()); ASSERT_EQ(1u, red_packets.size()); VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, red_packets.front().get(), false); } -TEST_F(ProducerFecTest, TwoFrameFec) { +TEST_F(UlpfecGeneratorTest, TwoFrameFec) { // The number of media packets/frame (|kNumPackets|), the number of frames // (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to // make sure the conditions for generating FEC are satisfied. This means: @@ -143,35 +144,35 @@ TEST_F(ProducerFecTest, TwoFrameFec) { constexpr size_t kNumFrames = 2; FecProtectionParams params = {15, 3, kFecMaskRandom}; - producer_.SetFecParameters(¶ms); // Expecting one FEC packet. + ulpfec_generator_.SetFecParameters(¶ms); // Expecting one FEC packet. uint32_t last_timestamp = 0; for (size_t i = 0; i < kNumFrames; ++i) { packet_generator_.NewFrame(kNumPackets); for (size_t j = 0; j < kNumPackets; ++j) { std::unique_ptr packet = packet_generator_.NextPacket(i * kNumPackets + j, 10); - EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( + EXPECT_EQ(0, ulpfec_generator_.AddRtpPacketAndGenerateFec( packet->data, packet->length, kRtpHeaderSize)); last_timestamp = packet->header.header.timestamp; } } - EXPECT_TRUE(producer_.FecAvailable()); + EXPECT_TRUE(ulpfec_generator_.FecAvailable()); uint16_t seq_num = packet_generator_.NextPacketSeqNum(); std::vector> red_packets = - producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, - kRtpHeaderSize); - EXPECT_FALSE(producer_.FecAvailable()); + ulpfec_generator_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, + seq_num, kRtpHeaderSize); + EXPECT_FALSE(ulpfec_generator_.FecAvailable()); ASSERT_EQ(1u, red_packets.size()); VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, red_packets.front().get(), false); } -TEST_F(ProducerFecTest, BuildRedPacket) { +TEST_F(UlpfecGeneratorTest, BuildRedPacket) { packet_generator_.NewFrame(1); std::unique_ptr packet = packet_generator_.NextPacket(0, 10); - std::unique_ptr red_packet = - ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, - kRtpHeaderSize, kRedPayloadType); + std::unique_ptr red_packet = UlpfecGenerator::BuildRedPacket( + packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize, + kRedPayloadType); EXPECT_EQ(packet->length + 1, red_packet->length()); VerifyHeader(packet->header.header.sequenceNumber, packet->header.header.timestamp, kRedPayloadType, @@ -182,7 +183,7 @@ TEST_F(ProducerFecTest, BuildRedPacket) { } } -TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) { +TEST_F(UlpfecGeneratorTest, BuildRedPacketWithEmptyPayload) { constexpr size_t kNumFrames = 1; constexpr size_t kPayloadLength = 0; constexpr size_t kRedForFecHeaderLength = 1; @@ -190,9 +191,9 @@ TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) { packet_generator_.NewFrame(kNumFrames); std::unique_ptr packet( packet_generator_.NextPacket(0, kPayloadLength)); - std::unique_ptr red_packet = - ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, - kRtpHeaderSize, kRedPayloadType); + std::unique_ptr red_packet = UlpfecGenerator::BuildRedPacket( + packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize, + kRedPayloadType); EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length()); VerifyHeader(packet->header.header.sequenceNumber, packet->header.header.timestamp, kRedPayloadType, diff --git a/webrtc/test/fuzzers/BUILD.gn b/webrtc/test/fuzzers/BUILD.gn index f7b94362ad..764d71917f 100644 --- a/webrtc/test/fuzzers/BUILD.gn +++ b/webrtc/test/fuzzers/BUILD.gn @@ -86,9 +86,9 @@ webrtc_fuzzer_test("ulpfec_header_reader_fuzzer") { ] } -webrtc_fuzzer_test("producer_fec_fuzzer") { +webrtc_fuzzer_test("ulpfec_generator_fuzzer") { sources = [ - "producer_fec_fuzzer.cc", + "ulpfec_generator_fuzzer.cc", ] deps = [ "../../modules/rtp_rtcp/", diff --git a/webrtc/test/fuzzers/producer_fec_fuzzer.cc b/webrtc/test/fuzzers/ulpfec_generator_fuzzer.cc similarity index 78% rename from webrtc/test/fuzzers/producer_fec_fuzzer.cc rename to webrtc/test/fuzzers/ulpfec_generator_fuzzer.cc index fcf5df534a..fd1adc70c6 100644 --- a/webrtc/test/fuzzers/producer_fec_fuzzer.cc +++ b/webrtc/test/fuzzers/ulpfec_generator_fuzzer.cc @@ -13,7 +13,7 @@ #include "webrtc/base/checks.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" -#include "webrtc/modules/rtp_rtcp/source/producer_fec.h" +#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h" namespace webrtc { @@ -23,13 +23,13 @@ constexpr uint8_t kRedPayloadType = 97; } // namespace void FuzzOneInput(const uint8_t* data, size_t size) { - ProducerFec producer; + UlpfecGenerator generator; size_t i = 0; if (size < 4) return; FecProtectionParams params = { data[i++] % 128, static_cast(data[i++] % 10), kFecMaskBursty}; - producer.SetFecParameters(¶ms); + generator.SetFecParameters(¶ms); uint16_t seq_num = data[i++]; while (i + 3 < size) { @@ -43,18 +43,18 @@ void FuzzOneInput(const uint8_t* data, size_t size) { ByteWriter::WriteBigEndian(&packet[2], seq_num++); i += payload_size + rtp_header_length; // Make sure sequence numbers are increasing. - std::unique_ptr red_packet = ProducerFec::BuildRedPacket( + std::unique_ptr red_packet = UlpfecGenerator::BuildRedPacket( packet.get(), payload_size, rtp_header_length, kRedPayloadType); const bool protect = data[i++] % 2 == 1; if (protect) { - producer.AddRtpPacketAndGenerateFec(packet.get(), payload_size, - rtp_header_length); + generator.AddRtpPacketAndGenerateFec(packet.get(), payload_size, + rtp_header_length); } - const size_t num_fec_packets = producer.NumAvailableFecPackets(); + const size_t num_fec_packets = generator.NumAvailableFecPackets(); if (num_fec_packets > 0) { std::vector> fec_packets = - producer.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100, - rtp_header_length); + generator.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100, + rtp_header_length); RTC_CHECK_EQ(num_fec_packets, fec_packets.size()); } }