diff --git a/webrtc/modules/rtp_rtcp/source/fec_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/fec_receiver_unittest.cc index 1c30f37e8a..110e7c0b85 100644 --- a/webrtc/modules/rtp_rtcp/source/fec_receiver_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/fec_receiver_unittest.cc @@ -22,46 +22,48 @@ #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" +namespace webrtc { + +namespace { +constexpr uint8_t kFecPayloadType = 96; +} // namespace + using ::testing::_; using ::testing::Args; using ::testing::ElementsAreArray; using ::testing::Return; -using Packet = webrtc::ForwardErrorCorrection::Packet; -namespace webrtc { +using ::webrtc::test::fec::FrameGenerator; +using Packet = ::webrtc::ForwardErrorCorrection::Packet; +using ::webrtc::test::fec::RawRtpPacket; class ReceiverFecTest : public ::testing::Test { protected: - virtual void SetUp() { - fec_.reset(new ForwardErrorCorrection()); - receiver_fec_.reset(FecReceiver::Create(&rtp_data_callback_)); - generator_.reset(new FrameGenerator()); - } + ReceiverFecTest() : receiver_fec_(FecReceiver::Create(&rtp_data_callback_)) {} - void GenerateFec(ForwardErrorCorrection::PacketList* media_packets, - std::list* fec_packets, - unsigned int num_fec_packets) { + void EncodeFec(ForwardErrorCorrection::PacketList* media_packets, + std::list* fec_packets, + unsigned int num_fec_packets) { uint8_t protection_factor = num_fec_packets * 255 / media_packets->size(); - EXPECT_EQ(0, fec_->GenerateFec(*media_packets, protection_factor, - 0, false, kFecMaskBursty, fec_packets)); + EXPECT_EQ(0, fec_.EncodeFec(*media_packets, protection_factor, 0, false, + kFecMaskBursty, fec_packets)); ASSERT_EQ(num_fec_packets, fec_packets->size()); } void GenerateFrame(int num_media_packets, int frame_offset, - std::list* media_rtp_packets, + std::list* media_rtp_packets, ForwardErrorCorrection::PacketList* media_packets) { - generator_->NewFrame(num_media_packets); + generator_.NewFrame(num_media_packets); for (int i = 0; i < num_media_packets; ++i) { - std::unique_ptr next_packet( - generator_->NextPacket(frame_offset + i, kRtpHeaderSize + 10)); + std::unique_ptr next_packet( + generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10)); media_rtp_packets->push_back(next_packet.get()); media_packets->push_back(std::move(next_packet)); } } - void VerifyReconstructedMediaPacket(const test::RawRtpPacket* packet, - int times) { + void VerifyReconstructedMediaPacket(const RawRtpPacket* packet, int times) { // Verify that the content of the reconstructed packet is equal to the // content of |packet|, and that the same content is received |times| number // of times in a row. @@ -71,17 +73,17 @@ class ReceiverFecTest : public ::testing::Test { .Times(times).WillRepeatedly(Return(true)); } - void BuildAndAddRedMediaPacket(test::RawRtpPacket* packet) { - std::unique_ptr red_packet( - generator_->BuildMediaRedPacket(packet)); + void BuildAndAddRedMediaPacket(RawRtpPacket* packet) { + std::unique_ptr red_packet( + generator_.BuildMediaRedPacket(packet)); EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( red_packet->header.header, red_packet->data, red_packet->length, kFecPayloadType)); } void BuildAndAddRedFecPacket(Packet* packet) { - std::unique_ptr red_packet( - generator_->BuildFecRedPacket(packet)); + std::unique_ptr red_packet( + generator_.BuildFecRedPacket(packet)); EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( red_packet->header.header, red_packet->data, red_packet->length, kFecPayloadType)); @@ -93,18 +95,18 @@ class ReceiverFecTest : public ::testing::Test { uint8_t ulpfec_payload_type); MockRtpData rtp_data_callback_; - std::unique_ptr fec_; + ForwardErrorCorrection fec_; std::unique_ptr receiver_fec_; - std::unique_ptr generator_; + FrameGenerator generator_; }; TEST_F(ReceiverFecTest, TwoMediaOneFec) { const unsigned int kNumFecPackets = 1u; - std::list media_rtp_packets; + std::list media_rtp_packets; ForwardErrorCorrection::PacketList media_packets; GenerateFrame(2, 0, &media_rtp_packets, &media_packets); std::list fec_packets; - GenerateFec(&media_packets, &fec_packets, kNumFecPackets); + EncodeFec(&media_packets, &fec_packets, kNumFecPackets); // Recovery auto it = media_rtp_packets.begin(); @@ -129,11 +131,11 @@ void ReceiverFecTest::InjectGarbagePacketLength(size_t fec_garbage_offset) { .WillRepeatedly(Return(true)); const unsigned int kNumFecPackets = 1u; - std::list media_rtp_packets; + std::list media_rtp_packets; ForwardErrorCorrection::PacketList media_packets; GenerateFrame(2, 0, &media_rtp_packets, &media_packets); std::list fec_packets; - GenerateFec(&media_packets, &fec_packets, kNumFecPackets); + EncodeFec(&media_packets, &fec_packets, kNumFecPackets); ByteWriter::WriteBigEndian( &fec_packets.front()->data[fec_garbage_offset], 0x4711); @@ -162,11 +164,11 @@ TEST_F(ReceiverFecTest, InjectGarbageFecLevelHeaderProtectionLength) { TEST_F(ReceiverFecTest, TwoMediaTwoFec) { const unsigned int kNumFecPackets = 2u; - std::list media_rtp_packets; + std::list media_rtp_packets; ForwardErrorCorrection::PacketList media_packets; GenerateFrame(2, 0, &media_rtp_packets, &media_packets); std::list fec_packets; - GenerateFec(&media_packets, &fec_packets, kNumFecPackets); + EncodeFec(&media_packets, &fec_packets, kNumFecPackets); // Recovery // Drop both media packets. @@ -184,12 +186,12 @@ TEST_F(ReceiverFecTest, TwoMediaTwoFec) { TEST_F(ReceiverFecTest, TwoFramesOneFec) { const unsigned int kNumFecPackets = 1u; - std::list media_rtp_packets; + std::list media_rtp_packets; ForwardErrorCorrection::PacketList media_packets; GenerateFrame(1, 0, &media_rtp_packets, &media_packets); GenerateFrame(1, 1, &media_rtp_packets, &media_packets); std::list fec_packets; - GenerateFec(&media_packets, &fec_packets, kNumFecPackets); + EncodeFec(&media_packets, &fec_packets, kNumFecPackets); // Recovery auto it = media_rtp_packets.begin(); @@ -205,13 +207,13 @@ TEST_F(ReceiverFecTest, TwoFramesOneFec) { TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) { const unsigned int kNumFecPackets = 1u; - std::list media_rtp_packets; + std::list media_rtp_packets; ForwardErrorCorrection::PacketList media_packets; GenerateFrame(1, 0, &media_rtp_packets, &media_packets); GenerateFrame(2, 1, &media_rtp_packets, &media_packets); std::list fec_packets; - GenerateFec(&media_packets, &fec_packets, kNumFecPackets); + EncodeFec(&media_packets, &fec_packets, kNumFecPackets); // Recovery auto it = media_rtp_packets.begin(); @@ -227,13 +229,13 @@ TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) { TEST_F(ReceiverFecTest, MaxFramesOneFec) { const unsigned int kNumFecPackets = 1u; const unsigned int kNumMediaPackets = 48u; - std::list media_rtp_packets; + std::list media_rtp_packets; ForwardErrorCorrection::PacketList media_packets; for (unsigned int i = 0; i < kNumMediaPackets; ++i) { GenerateFrame(1, i, &media_rtp_packets, &media_packets); } std::list fec_packets; - GenerateFec(&media_packets, &fec_packets, kNumFecPackets); + EncodeFec(&media_packets, &fec_packets, kNumFecPackets); // Recovery auto it = media_rtp_packets.begin(); @@ -252,15 +254,15 @@ TEST_F(ReceiverFecTest, MaxFramesOneFec) { TEST_F(ReceiverFecTest, TooManyFrames) { const unsigned int kNumFecPackets = 1u; const unsigned int kNumMediaPackets = 49u; - std::list media_rtp_packets; + std::list media_rtp_packets; ForwardErrorCorrection::PacketList media_packets; for (unsigned int i = 0; i < kNumMediaPackets; ++i) { GenerateFrame(1, i, &media_rtp_packets, &media_packets); } std::list fec_packets; - EXPECT_EQ(-1, fec_->GenerateFec(media_packets, - kNumFecPackets * 255 / kNumMediaPackets, 0, - false, kFecMaskBursty, &fec_packets)); + EXPECT_EQ( + -1, fec_.EncodeFec(media_packets, kNumFecPackets * 255 / kNumMediaPackets, + 0, false, kFecMaskBursty, &fec_packets)); } TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) { @@ -269,12 +271,12 @@ TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) { Packet* delayed_fec = NULL; const unsigned int kNumFecPacketsBatch1 = 1u; const unsigned int kNumMediaPacketsBatch1 = 2u; - std::list media_rtp_packets_batch1; + std::list media_rtp_packets_batch1; ForwardErrorCorrection::PacketList media_packets_batch1; GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1, &media_packets_batch1); std::list fec_packets; - GenerateFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1); + EncodeFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1); BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front()); EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) @@ -284,7 +286,7 @@ TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) { // Fill the FEC decoder. No packets should be dropped. const unsigned int kNumMediaPacketsBatch2 = 46u; - std::list media_rtp_packets_batch2; + std::list media_rtp_packets_batch2; ForwardErrorCorrection::PacketList media_packets_batch2; for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) { GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2); @@ -310,12 +312,12 @@ TEST_F(ReceiverFecTest, PacketDroppedWhenTooOld) { Packet* delayed_fec = NULL; const unsigned int kNumFecPacketsBatch1 = 1u; const unsigned int kNumMediaPacketsBatch1 = 2u; - std::list media_rtp_packets_batch1; + std::list media_rtp_packets_batch1; ForwardErrorCorrection::PacketList media_packets_batch1; GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1, &media_packets_batch1); std::list fec_packets; - GenerateFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1); + EncodeFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1); BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front()); EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) @@ -325,7 +327,7 @@ TEST_F(ReceiverFecTest, PacketDroppedWhenTooOld) { // Fill the FEC decoder and force the last packet to be dropped. const unsigned int kNumMediaPacketsBatch2 = 48u; - std::list media_rtp_packets_batch2; + std::list media_rtp_packets_batch2; ForwardErrorCorrection::PacketList media_packets_batch2; for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) { GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2); @@ -350,14 +352,14 @@ TEST_F(ReceiverFecTest, OldFecPacketDropped) { // 49 frames with 2 media packets and one FEC packet. All media packets // missing. const unsigned int kNumMediaPackets = 49 * 2; - std::list media_rtp_packets; + std::list media_rtp_packets; ForwardErrorCorrection::PacketList media_packets; for (unsigned int i = 0; i < kNumMediaPackets / 2; ++i) { - std::list frame_media_rtp_packets; + std::list frame_media_rtp_packets; ForwardErrorCorrection::PacketList frame_media_packets; std::list fec_packets; GenerateFrame(2, 0, &frame_media_rtp_packets, &frame_media_packets); - GenerateFec(&frame_media_packets, &fec_packets, 1); + EncodeFec(&frame_media_packets, &fec_packets, 1); for (auto it = fec_packets.begin(); it != fec_packets.end(); ++it) { // Only FEC packets inserted. No packets recoverable at this time. BuildAndAddRedFecPacket(*it); diff --git a/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc b/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc index e767f5a681..235720d819 100644 --- a/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc +++ b/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc @@ -10,10 +10,21 @@ #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" +#include +#include + #include "webrtc/modules/rtp_rtcp/source/byte_io.h" #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" namespace webrtc { +namespace test { +namespace fec { + +namespace { +constexpr uint8_t kFecPayloadType = 96; +constexpr uint8_t kRedPayloadType = 97; +constexpr uint8_t kVp8PayloadType = 120; +} // namespace FrameGenerator::FrameGenerator() : num_packets_(0), seq_num_(0), timestamp_(0) {} @@ -25,8 +36,8 @@ void FrameGenerator::NewFrame(int num_packets) { uint16_t FrameGenerator::NextSeqNum() { return ++seq_num_; } -test::RawRtpPacket* FrameGenerator::NextPacket(int offset, size_t length) { - test::RawRtpPacket* rtp_packet = new test::RawRtpPacket; +RawRtpPacket* FrameGenerator::NextPacket(int offset, size_t length) { + RawRtpPacket* rtp_packet = new RawRtpPacket; for (size_t i = 0; i < length; ++i) rtp_packet->data[i + kRtpHeaderSize] = offset + i; rtp_packet->length = length + kRtpHeaderSize; @@ -44,10 +55,9 @@ test::RawRtpPacket* FrameGenerator::NextPacket(int offset, size_t length) { } // Creates a new RtpPacket with the RED header added to the packet. -test::RawRtpPacket* FrameGenerator::BuildMediaRedPacket( - const test::RawRtpPacket* packet) { +RawRtpPacket* FrameGenerator::BuildMediaRedPacket(const RawRtpPacket* packet) { const size_t kHeaderLength = packet->header.header.headerLength; - test::RawRtpPacket* red_packet = new test::RawRtpPacket; + RawRtpPacket* red_packet = new RawRtpPacket; red_packet->header = packet->header; red_packet->length = packet->length + 1; // 1 byte RED header. memset(red_packet->data, 0, red_packet->length); @@ -59,14 +69,14 @@ test::RawRtpPacket* FrameGenerator::BuildMediaRedPacket( return red_packet; } -// Creates a new RtpPacket with FEC payload and red header. Does this by +// Creates a new RtpPacket with FEC payload and RED header. Does this by // creating a new fake media RtpPacket, clears the marker bit and adds a RED // header. Finally replaces the payload with the content of |packet->data|. -test::RawRtpPacket* FrameGenerator::BuildFecRedPacket( +RawRtpPacket* FrameGenerator::BuildFecRedPacket( const ForwardErrorCorrection::Packet* packet) { // Create a fake media packet to get a correct header. 1 byte RED header. ++num_packets_; - test::RawRtpPacket* red_packet = NextPacket(0, packet->length + 1); + RawRtpPacket* red_packet = NextPacket(0, packet->length + 1); red_packet->data[1] &= ~0x80; // Clear marker bit. const size_t kHeaderLength = red_packet->header.header.headerLength; SetRedHeader(red_packet, kFecPayloadType, kHeaderLength); @@ -95,4 +105,69 @@ void FrameGenerator::BuildRtpHeader(uint8_t* data, const RTPHeader* header) { ByteWriter::WriteBigEndian(data + 8, header->ssrc); } +ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets( + int num_media_packets, + uint16_t start_seq_num) { + RTC_DCHECK_GT(num_media_packets, 0); + uint16_t seq_num = start_seq_num; + int time_stamp = random_->Rand(); + + ForwardErrorCorrection::PacketList media_packets; + + for (int i = 0; i < num_media_packets; ++i) { + std::unique_ptr media_packet( + new ForwardErrorCorrection::Packet()); + media_packet->length = random_->Rand(min_packet_size_, max_packet_size_); + + // Generate random values for the first 2 bytes + media_packet->data[0] = random_->Rand(); + media_packet->data[1] = random_->Rand(); + + // The first two bits are assumed to be 10 by the FEC encoder. + // In fact the FEC decoder will set the two first bits to 10 regardless of + // what they actually were. Set the first two bits to 10 so that a memcmp + // can be performed for the whole restored packet. + media_packet->data[0] |= 0x80; + media_packet->data[0] &= 0xbf; + + // FEC is applied to a whole frame. + // A frame is signaled by multiple packets without the marker bit set + // followed by the last packet of the frame for which the marker bit is set. + // Only push one (fake) frame to the FEC. + media_packet->data[1] &= 0x7f; + + webrtc::ByteWriter::WriteBigEndian(&media_packet->data[2], + seq_num); + webrtc::ByteWriter::WriteBigEndian(&media_packet->data[4], + time_stamp); + webrtc::ByteWriter::WriteBigEndian(&media_packet->data[8], ssrc_); + + // Generate random values for payload. + for (size_t j = 12; j < media_packet->length; ++j) { + media_packet->data[j] = random_->Rand(); + } + seq_num++; + media_packets.push_back(std::move(media_packet)); + } + // Last packet, set marker bit. + ForwardErrorCorrection::Packet* media_packet = media_packets.back().get(); + RTC_DCHECK(media_packet); + media_packet->data[1] |= 0x80; + + fec_seq_num_ = seq_num; + + return media_packets; +} + +ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets( + int num_media_packets) { + return ConstructMediaPackets(num_media_packets, random_->Rand()); +} + +uint16_t MediaPacketGenerator::GetFecSeqNum() { + return fec_seq_num_; +} + +} // namespace fec +} // namespace test } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/fec_test_helper.h b/webrtc/modules/rtp_rtcp/source/fec_test_helper.h index 6af7f9cc7f..9c0a323056 100644 --- a/webrtc/modules/rtp_rtcp/source/fec_test_helper.h +++ b/webrtc/modules/rtp_rtcp/source/fec_test_helper.h @@ -11,19 +11,20 @@ #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_FEC_TEST_HELPER_H_ #define WEBRTC_MODULES_RTP_RTCP_SOURCE_FEC_TEST_HELPER_H_ +#include "webrtc/base/basictypes.h" +#include "webrtc/base/random.h" #include "webrtc/modules/include/module_common_types.h" #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" namespace webrtc { namespace test { + +// Needed to not clash with another webrtc::FrameGenerator. +namespace fec { + struct RawRtpPacket : public ForwardErrorCorrection::Packet { WebRtcRTPHeader header; }; -} // namespace test - -const uint8_t kFecPayloadType = 96; -const uint8_t kRedPayloadType = 97; -const uint8_t kVp8PayloadType = 120; class FrameGenerator { public: @@ -33,16 +34,15 @@ class FrameGenerator { uint16_t NextSeqNum(); - test::RawRtpPacket* NextPacket(int offset, size_t length); + RawRtpPacket* NextPacket(int offset, size_t length); // Creates a new RtpPacket with the RED header added to the packet. - test::RawRtpPacket* BuildMediaRedPacket(const test::RawRtpPacket* packet); + RawRtpPacket* BuildMediaRedPacket(const RawRtpPacket* packet); // Creates a new RtpPacket with FEC payload and red header. Does this by // creating a new fake media RtpPacket, clears the marker bit and adds a RED // header. Finally replaces the payload with the content of |packet->data|. - test::RawRtpPacket* BuildFecRedPacket( - const ForwardErrorCorrection::Packet* packet); + RawRtpPacket* BuildFecRedPacket(const ForwardErrorCorrection::Packet* packet); void SetRedHeader(ForwardErrorCorrection::Packet* red_packet, uint8_t payload_type, @@ -55,6 +55,39 @@ class FrameGenerator { uint16_t seq_num_; uint32_t timestamp_; }; + +class MediaPacketGenerator { + public: + MediaPacketGenerator(uint32_t min_packet_size, + uint32_t max_packet_size, + uint32_t ssrc, + Random* random) + : min_packet_size_(min_packet_size), + max_packet_size_(max_packet_size), + ssrc_(ssrc), + random_(random) {} + + // Construct the media packets, up to |num_media_packets| packets. + ForwardErrorCorrection::PacketList ConstructMediaPackets( + int num_media_packets, + uint16_t start_seq_num); + ForwardErrorCorrection::PacketList ConstructMediaPackets( + int num_media_packets); + + uint16_t GetFecSeqNum(); + + private: + uint32_t min_packet_size_; + uint32_t max_packet_size_; + uint32_t ssrc_; + Random* random_; + + ForwardErrorCorrection::PacketList media_packets_; + uint16_t fec_seq_num_; +}; + +} // namespace fec +} // namespace test } // namespace webrtc #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_FEC_TEST_HELPER_H_ diff --git a/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc b/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc index b214f60c06..a89b71bf94 100644 --- a/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc +++ b/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc @@ -94,19 +94,18 @@ ForwardErrorCorrection::~ForwardErrorCorrection() {} // | | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // -// Note that any potential RED headers are added/removed before calling -// GenerateFec() or DecodeFec(). -int ForwardErrorCorrection::GenerateFec(const PacketList& media_packets, - uint8_t protection_factor, - int num_important_packets, - bool use_unequal_protection, - FecMaskType fec_mask_type, - std::list* fec_packets) { - const uint16_t num_media_packets = media_packets.size(); +int ForwardErrorCorrection::EncodeFec(const PacketList& media_packets, + uint8_t protection_factor, + int num_important_packets, + bool use_unequal_protection, + FecMaskType fec_mask_type, + std::list* fec_packets) { + const size_t num_media_packets = media_packets.size(); + // Sanity check arguments. - RTC_DCHECK_GT(num_media_packets, 0); + RTC_DCHECK_GT(num_media_packets, 0u); RTC_DCHECK_GE(num_important_packets, 0); - RTC_DCHECK_LE(num_important_packets, num_media_packets); + RTC_DCHECK_LE(static_cast(num_important_packets), num_media_packets); RTC_DCHECK(fec_packets->empty()); if (num_media_packets > kMaxMediaPackets) { diff --git a/webrtc/modules/rtp_rtcp/source/forward_error_correction.h b/webrtc/modules/rtp_rtcp/source/forward_error_correction.h index 7d2e5aa51a..21f2afb2c0 100644 --- a/webrtc/modules/rtp_rtcp/source/forward_error_correction.h +++ b/webrtc/modules/rtp_rtcp/source/forward_error_correction.h @@ -147,14 +147,16 @@ class ForwardErrorCorrection { // of type Packet. Must be empty on entry. // The memory available through the list will // be valid until the next call to - // GenerateFec(). + // EncodeFec(). // // Returns 0 on success, -1 on failure. // - int GenerateFec(const PacketList& media_packets, - uint8_t protection_factor, int num_important_packets, - bool use_unequal_protection, FecMaskType fec_mask_type, - std::list* fec_packets); + int EncodeFec(const PacketList& media_packets, + uint8_t protection_factor, + int num_important_packets, + bool use_unequal_protection, + FecMaskType fec_mask_type, + std::list* fec_packets); // // Decodes a list of received media and FEC packets. It will parse the diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec.cc b/webrtc/modules/rtp_rtcp/source/producer_fec.cc index cf58cee1d2..06f15402ba 100644 --- a/webrtc/modules/rtp_rtcp/source/producer_fec.cc +++ b/webrtc/modules/rtp_rtcp/source/producer_fec.cc @@ -24,12 +24,12 @@ namespace webrtc { constexpr size_t kRedForFecHeaderLength = 1; // This controls the maximum amount of excess overhead (actual - target) -// allowed in order to trigger GenerateFec(), before |params_.max_fec_frames| +// allowed in order to trigger EncodeFec(), before |params_.max_fec_frames| // is reached. Overhead here is defined as relative to number of media packets. constexpr int kMaxExcessOverhead = 50; // Q8. // This is the minimum number of media packets required (above some protection -// level) in order to trigger GenerateFec(), before |params_.max_fec_frames| is +// level) in order to trigger EncodeFec(), before |params_.max_fec_frames| is // reached. constexpr size_t kMinMediaPackets = 4; @@ -175,9 +175,9 @@ int ProducerFec::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer, // Since unequal protection is disabled, the value of // |num_important_packets_| has no importance when calling GenerateFec(). constexpr bool kUseUnequalProtection = false; - int ret = fec_.GenerateFec(media_packets_, params_.fec_rate, - num_important_packets_, kUseUnequalProtection, - params_.fec_mask_type, &generated_fec_packets_); + int ret = fec_.EncodeFec(media_packets_, params_.fec_rate, + num_important_packets_, kUseUnequalProtection, + params_.fec_mask_type, &generated_fec_packets_); if (generated_fec_packets_.empty()) { num_protected_frames_ = 0; DeleteMediaPackets(); diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc index 5f26401fa0..ae51605d68 100644 --- a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc @@ -20,6 +20,14 @@ namespace webrtc { +namespace { +constexpr uint8_t kFecPayloadType = 96; +constexpr uint8_t kRedPayloadType = 97; +} // namespace + +using ::webrtc::test::fec::FrameGenerator; +using ::webrtc::test::fec::RawRtpPacket; + void VerifyHeader(uint16_t seq_num, uint32_t timestamp, int red_payload_type, @@ -97,12 +105,12 @@ TEST_F(ProducerFecTest, OneFrameFec) { // media packets for 1 frame is at least |minimum_media_packets_fec_|. const int kNumPackets = 4; FecProtectionParams params = {15, 3, kFecMaskRandom}; - std::list rtp_packets; + std::list rtp_packets; generator_.NewFrame(kNumPackets); producer_.SetFecParameters(¶ms, 0); // Expecting one FEC packet. uint32_t last_timestamp = 0; for (int i = 0; i < kNumPackets; ++i) { - test::RawRtpPacket* rtp_packet = generator_.NextPacket(i, 10); + RawRtpPacket* rtp_packet = generator_.NextPacket(i, 10); rtp_packets.push_back(rtp_packet); EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( rtp_packet->data, rtp_packet->length, kRtpHeaderSize)); @@ -135,14 +143,13 @@ TEST_F(ProducerFecTest, TwoFrameFec) { const int kNumFrames = 2; FecProtectionParams params = {15, 3, kFecMaskRandom}; - std::list rtp_packets; + std::list rtp_packets; producer_.SetFecParameters(¶ms, 0); // Expecting one FEC packet. uint32_t last_timestamp = 0; for (int i = 0; i < kNumFrames; ++i) { generator_.NewFrame(kNumPackets); for (int j = 0; j < kNumPackets; ++j) { - test::RawRtpPacket* rtp_packet = - generator_.NextPacket(i * kNumPackets + j, 10); + RawRtpPacket* rtp_packet = generator_.NextPacket(i * kNumPackets + j, 10); rtp_packets.push_back(rtp_packet); EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( rtp_packet->data, rtp_packet->length, kRtpHeaderSize)); @@ -166,16 +173,14 @@ TEST_F(ProducerFecTest, TwoFrameFec) { TEST_F(ProducerFecTest, BuildRedPacket) { generator_.NewFrame(1); - test::RawRtpPacket* packet = generator_.NextPacket(0, 10); + RawRtpPacket* packet = generator_.NextPacket(0, 10); std::unique_ptr red_packet = ProducerFec::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, - packet->header.header.payloadType, - red_packet.get(), + packet->header.header.timestamp, kRedPayloadType, + packet->header.header.payloadType, red_packet.get(), true); // Marker bit set. for (int i = 0; i < 10; ++i) EXPECT_EQ(i, red_packet->data()[kRtpHeaderSize + 1 + i]); @@ -188,7 +193,7 @@ TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) { constexpr size_t kRedForFecHeaderLength = 1; generator_.NewFrame(kNumFrames); - std::unique_ptr packet( + std::unique_ptr packet( generator_.NextPacket(0, kPayloadLength)); std::unique_ptr red_packet = ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, diff --git a/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc index 1bb1d6543c..9f6dee2be9 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc @@ -10,45 +10,55 @@ #include #include +#include #include "testing/gtest/include/gtest/gtest.h" +#include "webrtc/base/basictypes.h" #include "webrtc/base/random.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/forward_error_correction.h" -using webrtc::ForwardErrorCorrection; +namespace webrtc { -// Minimum RTP header size in bytes. -constexpr uint8_t kRtpHeaderSize = 12; +namespace { // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum. -constexpr uint8_t kTransportOverhead = 28; +constexpr size_t kTransportOverhead = 28; -// Maximum number of media packets used in the FEC (RFC 5109). -constexpr uint8_t kMaxNumberMediaPackets = - ForwardErrorCorrection::kMaxMediaPackets; +constexpr uint32_t kMediaSsrc = 83542; -using PacketList = ForwardErrorCorrection::PacketList; -using ReceivedPacketList = ForwardErrorCorrection::ReceivedPacketList; -using RecoveredPacketList = ForwardErrorCorrection::RecoveredPacketList; +// Deep copies |src| to |dst|, but only keeps every Nth packet. +void DeepCopyEveryNthPacket(const ForwardErrorCorrection::PacketList& src, + int n, + ForwardErrorCorrection::PacketList* dst) { + RTC_DCHECK_GT(n, 0); + int i = 0; + for (const auto& packet : src) { + if (i % n == 0) { + dst->emplace_back(new ForwardErrorCorrection::Packet(*packet)); + } + ++i; + } +} +} // namespace + +using ::testing::Types; + +template class RtpFecTest : public ::testing::Test { protected: RtpFecTest() - : random_(0xfec133700742), - ssrc_(random_.Rand()), - fec_seq_num_(0) {} + : random_(0xabcdef123456), + media_packet_generator_( + kRtpHeaderSize, // Minimum packet size. + IP_PACKET_SIZE - kRtpHeaderSize - kTransportOverhead - + fec_.MaxPacketOverhead(), // Maximum packet size. + kMediaSsrc, + &random_) {} - // Construct the media packet list, up to |num_media_packets| packets. - // Returns the next sequence number after the last media packet. - // (this will be the sequence of the first FEC packet) - int ConstructMediaPacketsSeqNum(int num_media_packets, int start_seq_num); - int ConstructMediaPackets(int num_media_packets); - - // Deep copies |src| to |dst|, but only keeps every Nth packet. - void DeepCopyEveryNthPacket(const PacketList& src, int n, PacketList* dst); - - // Construct |received_packet_list_|: a subset of the media and FEC packets. + // Construct |received_packets_|: a subset of the media and FEC packets. // // Media packet "i" is lost if media_loss_mask_[i] = 1, received if // media_loss_mask_[i] = 0. @@ -66,91 +76,102 @@ class RtpFecTest : public ::testing::Test { // Check for complete recovery after FEC decoding. bool IsRecoveryComplete(); - // Delete the media and FEC packets. - void TearDown(); + ForwardErrorCorrectionType fec_; - webrtc::Random random_; - ForwardErrorCorrection fec_; - int ssrc_; - uint16_t fec_seq_num_; + Random random_; + test::fec::MediaPacketGenerator media_packet_generator_; - PacketList media_packet_list_; - std::list fec_packet_list_; - ReceivedPacketList received_packet_list_; - RecoveredPacketList recovered_packet_list_; + ForwardErrorCorrection::PacketList media_packets_; + std::list generated_fec_packets_; + ForwardErrorCorrection::ReceivedPacketList received_packets_; + ForwardErrorCorrection::RecoveredPacketList recovered_packets_; - int media_loss_mask_[kMaxNumberMediaPackets]; - int fec_loss_mask_[kMaxNumberMediaPackets]; + int media_loss_mask_[ForwardErrorCorrection::kMaxMediaPackets]; + int fec_loss_mask_[ForwardErrorCorrection::kMaxMediaPackets]; }; -TEST_F(RtpFecTest, FecRecoveryNoLoss) { +// Define gTest typed test to loop over both ULPFEC and FlexFEC. +// Since the tests now are parameterized, we need to access +// member variables using |this|, thereby enforcing runtime +// resolution. +using FecTypes = Types; +TYPED_TEST_CASE(RtpFecTest, FecTypes); + +TYPED_TEST(RtpFecTest, FecRecoveryNoLoss) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr int kNumMediaPackets = 4; constexpr uint8_t kProtectionFactor = 60; - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // No packets lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // No packets lost, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); + EXPECT_TRUE(this->IsRecoveryComplete()); } -TEST_F(RtpFecTest, FecRecoveryWithLoss) { +TYPED_TEST(RtpFecTest, FecRecoveryWithLoss) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr int kNumMediaPackets = 4; constexpr uint8_t kProtectionFactor = 60; - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // 1 media packet lost - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // One packet lost, one FEC packet, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 2 media packets lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[1] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[1] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // 2 packets lost, one FEC packet, cannot get complete recovery. - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_FALSE(this->IsRecoveryComplete()); } // Verify that we don't use an old FEC packet for FEC decoding. -TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapTwoFrames) { +TYPED_TEST(RtpFecTest, FecRecoveryWithSeqNumGapTwoFrames) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr uint8_t kProtectionFactor = 20; @@ -163,43 +184,47 @@ TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapTwoFrames) { // try to decode using "old" FEC packet #2. // Construct media packets for first frame, starting at sequence number 0. - fec_seq_num_ = ConstructMediaPacketsSeqNum(2, 0); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(2, 0); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // Add FEC packet (seq#2) of this first frame to received list (i.e., assume // the two media packet were lost). - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_, + true); // Construct media packets for second frame, with sequence number wrap. - media_packet_list_.clear(); - fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65535); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(3, 65535); // Expect 3 media packets for this frame. - EXPECT_EQ(3u, media_packet_list_.size()); + EXPECT_EQ(3u, this->media_packets_.size()); // Second media packet lost (seq#0). - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - media_loss_mask_[1] = 1; + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + this->media_loss_mask_[1] = 1; // Add packets #65535, and #1 to received list. - ReceivedPackets(media_packet_list_, media_loss_mask_, false); + this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Expect that no decoding is done to get missing packet (seq#0) of second // frame, using old FEC packet (seq#2) from first (old) frame. So number of // recovered packets is 2, and not equal to number of media packets (=3). - EXPECT_EQ(2u, recovered_packet_list_.size()); - EXPECT_TRUE(recovered_packet_list_.size() != media_packet_list_.size()); + EXPECT_EQ(2u, this->recovered_packets_.size()); + EXPECT_TRUE(this->recovered_packets_.size() != this->media_packets_.size()); } // Verify we can still recover frame if sequence number wrap occurs within // the frame and FEC packet following wrap is received after media packets. -TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameRecovery) { +TYPED_TEST(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameRecovery) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr uint8_t kProtectionFactor = 20; @@ -207,29 +232,33 @@ TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameRecovery) { // One frame, with sequence number wrap in media packets. // -----Frame 1---- // #65534(media) #65535(media) #0(media) #1(FEC). - fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65534); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(3, 65534); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // Lose one media packet (seq# 65535). - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[1] = 1; - ReceivedPackets(media_packet_list_, media_loss_mask_, false); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[1] = 1; + this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false); // Add FEC packet to received list following the media packets. - ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); + this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_, + true); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Expect 3 media packets in recovered list, and complete recovery. // Wrap-around won't remove FEC packet, as it follows the wrap. - EXPECT_EQ(3u, recovered_packet_list_.size()); - EXPECT_TRUE(IsRecoveryComplete()); + EXPECT_EQ(3u, this->recovered_packets_.size()); + EXPECT_TRUE(this->IsRecoveryComplete()); } // Sequence number wrap occurs within the FEC packets for the frame. @@ -238,7 +267,7 @@ TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameRecovery) { // received before the media packets. This may be improved if timing information // is used to detect old FEC packets. // TODO(marpan): Update test if wrap-around handling changes in FEC decoding. -TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameNoRecovery) { +TYPED_TEST(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameNoRecovery) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr uint8_t kProtectionFactor = 200; @@ -247,36 +276,40 @@ TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameNoRecovery) { // Sequence number wrap in FEC packets. // -----Frame 1---- // #65532(media) #65533(media) #65534(media) #65535(FEC) #0(FEC). - fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65532); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(3, 65532); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 2 FEC packets. - EXPECT_EQ(2u, fec_packet_list_.size()); + EXPECT_EQ(2u, this->generated_fec_packets_.size()); // Lose the last two media packets (seq# 65533, 65534). - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[1] = 1; - media_loss_mask_[2] = 1; - ReceivedPackets(media_packet_list_, media_loss_mask_, false); - ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[1] = 1; + this->media_loss_mask_[2] = 1; + this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false); + this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_, + true); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // The two FEC packets are received and should allow for complete recovery, // but because of the wrap the second FEC packet will be discarded, and only // one media packet is recoverable. So exepct 2 media packets on recovered // list and no complete recovery. - EXPECT_EQ(2u, recovered_packet_list_.size()); - EXPECT_TRUE(recovered_packet_list_.size() != media_packet_list_.size()); - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_EQ(2u, this->recovered_packets_.size()); + EXPECT_TRUE(this->recovered_packets_.size() != this->media_packets_.size()); + EXPECT_FALSE(this->IsRecoveryComplete()); } // Verify we can still recover frame if media packets are reordered. -TEST_F(RtpFecTest, FecRecoveryWithMediaOutOfOrder) { +TYPED_TEST(RtpFecTest, FecRecoveryWithMediaOutOfOrder) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr uint8_t kProtectionFactor = 20; @@ -284,36 +317,39 @@ TEST_F(RtpFecTest, FecRecoveryWithMediaOutOfOrder) { // One frame: 3 media packets, 1 FEC packet. // -----Frame 1---- // #0(media) #1(media) #2(media) #3(FEC). - fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 0); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(3, 0); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // Lose one media packet (seq# 1). - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[1] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[1] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); // Reorder received media packets. - auto it0 = received_packet_list_.begin(); - auto it2 = received_packet_list_.begin(); + auto it0 = this->received_packets_.begin(); + auto it2 = this->received_packets_.begin(); it2++; std::swap(*it0, *it2); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Expect 3 media packets in recovered list, and complete recovery. - EXPECT_EQ(3u, recovered_packet_list_.size()); - EXPECT_TRUE(IsRecoveryComplete()); + EXPECT_EQ(3u, this->recovered_packets_.size()); + EXPECT_TRUE(this->IsRecoveryComplete()); } // Verify we can still recover frame if FEC is received before media packets. -TEST_F(RtpFecTest, FecRecoveryWithFecOutOfOrder) { +TYPED_TEST(RtpFecTest, FecRecoveryWithFecOutOfOrder) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr uint8_t kProtectionFactor = 20; @@ -321,35 +357,39 @@ TEST_F(RtpFecTest, FecRecoveryWithFecOutOfOrder) { // One frame: 3 media packets, 1 FEC packet. // -----Frame 1---- // #0(media) #1(media) #2(media) #3(FEC). - fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 0); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(3, 0); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // Lose one media packet (seq# 1). - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[1] = 1; + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[1] = 1; // Add FEC packet to received list before the media packets. - ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); + this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_, + true); // Add media packets to received list. - ReceivedPackets(media_packet_list_, media_loss_mask_, false); + this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Expect 3 media packets in recovered list, and complete recovery. - EXPECT_EQ(3u, recovered_packet_list_.size()); - EXPECT_TRUE(IsRecoveryComplete()); + EXPECT_EQ(3u, this->recovered_packets_.size()); + EXPECT_TRUE(this->IsRecoveryComplete()); } // Test 50% protection with random mask type: Two cases are considered: // a 50% non-consecutive loss which can be fully recovered, and a 50% // consecutive loss which cannot be fully recovered. -TEST_F(RtpFecTest, FecRecoveryWithLoss50percRandomMask) { +TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percRandomMask) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr int kNumMediaPackets = 4; @@ -365,49 +405,53 @@ TEST_F(RtpFecTest, FecRecoveryWithLoss50percRandomMask) { // fec#3: 0 1 0 1 // - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskRandom, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskRandom, &this->generated_fec_packets_)); // Expect 4 FEC packets. - EXPECT_EQ(4u, fec_packet_list_.size()); + EXPECT_EQ(4u, this->generated_fec_packets_.size()); // 4 packets lost: 3 media packets (0, 2, 3), and one FEC packet (0) lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - fec_loss_mask_[0] = 1; - media_loss_mask_[0] = 1; - media_loss_mask_[2] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->fec_loss_mask_[0] = 1; + this->media_loss_mask_[0] = 1; + this->media_loss_mask_[2] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // With media packet#1 and FEC packets #1, #2, #3, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 4 consecutive packets lost: media packets 0, 1, 2, 3. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[0] = 1; - media_loss_mask_[1] = 1; - media_loss_mask_[2] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[0] = 1; + this->media_loss_mask_[1] = 1; + this->media_loss_mask_[2] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Cannot get complete recovery for this loss configuration with random mask. - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_FALSE(this->IsRecoveryComplete()); } // Test 50% protection with bursty type: Three cases are considered: // two 50% consecutive losses which can be fully recovered, and one // non-consecutive which cannot be fully recovered. -TEST_F(RtpFecTest, FecRecoveryWithLoss50percBurstyMask) { +TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percBurstyMask) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr int kNumMediaPackets = 4; @@ -423,128 +467,140 @@ TEST_F(RtpFecTest, FecRecoveryWithLoss50percBurstyMask) { // fec#3: 0 0 1 1 // - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 4 FEC packets. - EXPECT_EQ(4u, fec_packet_list_.size()); + EXPECT_EQ(4u, this->generated_fec_packets_.size()); // 4 consecutive packets lost: media packets 0,1,2,3. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[0] = 1; - media_loss_mask_[1] = 1; - media_loss_mask_[2] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[0] = 1; + this->media_loss_mask_[1] = 1; + this->media_loss_mask_[2] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Expect complete recovery for consecutive packet loss <= 50%. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 4 consecutive packets lost: media packets 1,2, 3, and FEC packet 0. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - fec_loss_mask_[0] = 1; - media_loss_mask_[1] = 1; - media_loss_mask_[2] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->fec_loss_mask_[0] = 1; + this->media_loss_mask_[1] = 1; + this->media_loss_mask_[2] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Expect complete recovery for consecutive packet loss <= 50%. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 4 packets lost (non-consecutive loss): media packets 0, 3, and FEC# 0, 3. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - fec_loss_mask_[0] = 1; - fec_loss_mask_[3] = 1; - media_loss_mask_[0] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->fec_loss_mask_[0] = 1; + this->fec_loss_mask_[3] = 1; + this->media_loss_mask_[0] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Cannot get complete recovery for this loss configuration. - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_FALSE(this->IsRecoveryComplete()); } -TEST_F(RtpFecTest, FecRecoveryNoLossUep) { +TYPED_TEST(RtpFecTest, FecRecoveryNoLossUep) { constexpr int kNumImportantPackets = 2; constexpr bool kUseUnequalProtection = true; constexpr int kNumMediaPackets = 4; constexpr uint8_t kProtectionFactor = 60; - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // No packets lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // No packets lost, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); + EXPECT_TRUE(this->IsRecoveryComplete()); } -TEST_F(RtpFecTest, FecRecoveryWithLossUep) { +TYPED_TEST(RtpFecTest, FecRecoveryWithLossUep) { constexpr int kNumImportantPackets = 2; constexpr bool kUseUnequalProtection = true; constexpr int kNumMediaPackets = 4; constexpr uint8_t kProtectionFactor = 60; - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // 1 media packet lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // One packet lost, one FEC packet, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 2 media packets lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[1] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[1] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // 2 packets lost, one FEC packet, cannot get complete recovery. - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_FALSE(this->IsRecoveryComplete()); } // Test 50% protection with random mask type for UEP on. -TEST_F(RtpFecTest, FecRecoveryWithLoss50percUepRandomMask) { +TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percUepRandomMask) { constexpr int kNumImportantPackets = 1; constexpr bool kUseUnequalProtection = true; constexpr int kNumMediaPackets = 4; @@ -560,241 +616,254 @@ TEST_F(RtpFecTest, FecRecoveryWithLoss50percUepRandomMask) { // fec#3: 0 1 1 0 // - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); - EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskRandom, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskRandom, &this->generated_fec_packets_)); // Expect 4 FEC packets. - EXPECT_EQ(4u, fec_packet_list_.size()); + EXPECT_EQ(4u, this->generated_fec_packets_.size()); // 4 packets lost: 3 media packets and FEC packet#1 lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - fec_loss_mask_[1] = 1; - media_loss_mask_[0] = 1; - media_loss_mask_[2] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->fec_loss_mask_[1] = 1; + this->media_loss_mask_[0] = 1; + this->media_loss_mask_[2] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // With media packet#3 and FEC packets #0, #1, #3, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 5 packets lost: 4 media packets and one FEC packet#2 lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - fec_loss_mask_[2] = 1; - media_loss_mask_[0] = 1; - media_loss_mask_[1] = 1; - media_loss_mask_[2] = 1; - media_loss_mask_[3] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->fec_loss_mask_[2] = 1; + this->media_loss_mask_[0] = 1; + this->media_loss_mask_[1] = 1; + this->media_loss_mask_[2] = 1; + this->media_loss_mask_[3] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Cannot get complete recovery for this loss configuration. - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_FALSE(this->IsRecoveryComplete()); } -TEST_F(RtpFecTest, FecRecoveryNonConsecutivePackets) { +TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePackets) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr int kNumMediaPackets = 5; constexpr uint8_t kProtectionFactor = 60; - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); // Create a new temporary packet list for generating FEC packets. // This list should have every other packet removed. - PacketList protected_media_packets; - DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); + ForwardErrorCorrection::PacketList protected_media_packets; + DeepCopyEveryNthPacket(this->media_packets_, 2, &protected_media_packets); - EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(protected_media_packets, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 1 FEC packet. - EXPECT_EQ(1u, fec_packet_list_.size()); + EXPECT_EQ(1u, this->generated_fec_packets_.size()); // 1 protected media packet lost - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[2] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[2] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // One packet lost, one FEC packet, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // Unprotected packet lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[1] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[1] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Unprotected packet lost. Recovery not possible. - EXPECT_FALSE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_FALSE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 2 media packets lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[0] = 1; - media_loss_mask_[2] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[0] = 1; + this->media_loss_mask_[2] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // 2 protected packets lost, one FEC packet, cannot get complete recovery. - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_FALSE(this->IsRecoveryComplete()); } -TEST_F(RtpFecTest, FecRecoveryNonConsecutivePacketsExtension) { +TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePacketsExtension) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr int kNumMediaPackets = 21; uint8_t kProtectionFactor = 127; - fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); + this->media_packets_ = + this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); // Create a new temporary packet list for generating FEC packets. // This list should have every other packet removed. - PacketList protected_media_packets; - DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); + ForwardErrorCorrection::PacketList protected_media_packets; + DeepCopyEveryNthPacket(this->media_packets_, 2, &protected_media_packets); // Zero column insertion will have to extend the size of the packet // mask since the number of actual packets are 21, while the number // of protected packets are 11. - EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(protected_media_packets, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 5 FEC packet. - EXPECT_EQ(5u, fec_packet_list_.size()); + EXPECT_EQ(5u, this->generated_fec_packets_.size()); // Last protected media packet lost - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[kNumMediaPackets - 1] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[kNumMediaPackets - 1] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // One packet lost, one FEC packet, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // Last unprotected packet lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[kNumMediaPackets - 2] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[kNumMediaPackets - 2] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Unprotected packet lost. Recovery not possible. - EXPECT_FALSE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_FALSE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 6 media packets lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[kNumMediaPackets - 11] = 1; - media_loss_mask_[kNumMediaPackets - 9] = 1; - media_loss_mask_[kNumMediaPackets - 7] = 1; - media_loss_mask_[kNumMediaPackets - 5] = 1; - media_loss_mask_[kNumMediaPackets - 3] = 1; - media_loss_mask_[kNumMediaPackets - 1] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[kNumMediaPackets - 11] = 1; + this->media_loss_mask_[kNumMediaPackets - 9] = 1; + this->media_loss_mask_[kNumMediaPackets - 7] = 1; + this->media_loss_mask_[kNumMediaPackets - 5] = 1; + this->media_loss_mask_[kNumMediaPackets - 3] = 1; + this->media_loss_mask_[kNumMediaPackets - 1] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // 5 protected packets lost, one FEC packet, cannot get complete recovery. - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_FALSE(this->IsRecoveryComplete()); } -TEST_F(RtpFecTest, FecRecoveryNonConsecutivePacketsWrap) { +TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePacketsWrap) { constexpr int kNumImportantPackets = 0; constexpr bool kUseUnequalProtection = false; constexpr int kNumMediaPackets = 21; uint8_t kProtectionFactor = 127; - fec_seq_num_ = ConstructMediaPacketsSeqNum(kNumMediaPackets, 0xFFFF - 5); + this->media_packets_ = this->media_packet_generator_.ConstructMediaPackets( + kNumMediaPackets, 0xFFFF - 5); // Create a new temporary packet list for generating FEC packets. // This list should have every other packet removed. - PacketList protected_media_packets; - DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); + ForwardErrorCorrection::PacketList protected_media_packets; + DeepCopyEveryNthPacket(this->media_packets_, 2, &protected_media_packets); // Zero column insertion will have to extend the size of the packet // mask since the number of actual packets are 21, while the number // of protected packets are 11. - EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor, - kNumImportantPackets, kUseUnequalProtection, - webrtc::kFecMaskBursty, &fec_packet_list_)); + EXPECT_EQ( + 0, this->fec_.EncodeFec(protected_media_packets, kProtectionFactor, + kNumImportantPackets, kUseUnequalProtection, + kFecMaskBursty, &this->generated_fec_packets_)); // Expect 5 FEC packet. - EXPECT_EQ(5u, fec_packet_list_.size()); + EXPECT_EQ(5u, this->generated_fec_packets_.size()); // Last protected media packet lost - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[kNumMediaPackets - 1] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[kNumMediaPackets - 1] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // One packet lost, one FEC packet, expect complete recovery. - EXPECT_TRUE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_TRUE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // Last unprotected packet lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[kNumMediaPackets - 2] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[kNumMediaPackets - 2] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // Unprotected packet lost. Recovery not possible. - EXPECT_FALSE(IsRecoveryComplete()); - recovered_packet_list_.clear(); + EXPECT_FALSE(this->IsRecoveryComplete()); + this->recovered_packets_.clear(); // 6 media packets lost. - memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); - memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); - media_loss_mask_[kNumMediaPackets - 11] = 1; - media_loss_mask_[kNumMediaPackets - 9] = 1; - media_loss_mask_[kNumMediaPackets - 7] = 1; - media_loss_mask_[kNumMediaPackets - 5] = 1; - media_loss_mask_[kNumMediaPackets - 3] = 1; - media_loss_mask_[kNumMediaPackets - 1] = 1; - NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); + memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); + memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_)); + this->media_loss_mask_[kNumMediaPackets - 11] = 1; + this->media_loss_mask_[kNumMediaPackets - 9] = 1; + this->media_loss_mask_[kNumMediaPackets - 7] = 1; + this->media_loss_mask_[kNumMediaPackets - 5] = 1; + this->media_loss_mask_[kNumMediaPackets - 3] = 1; + this->media_loss_mask_[kNumMediaPackets - 1] = 1; + this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_); - EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); + EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_, + &this->recovered_packets_)); // 5 protected packets lost, one FEC packet, cannot get complete recovery. - EXPECT_FALSE(IsRecoveryComplete()); + EXPECT_FALSE(this->IsRecoveryComplete()); } -void RtpFecTest::TearDown() { - fec_.ResetState(&recovered_packet_list_); - recovered_packet_list_.clear(); - media_packet_list_.clear(); - EXPECT_TRUE(media_packet_list_.empty()); -} - -bool RtpFecTest::IsRecoveryComplete() { +template +bool RtpFecTest::IsRecoveryComplete() { // We must have equally many recovered packets as original packets. - if (recovered_packet_list_.size() != media_packet_list_.size()) { + if (recovered_packets_.size() != media_packets_.size()) { return false; } @@ -815,21 +884,26 @@ bool RtpFecTest::IsRecoveryComplete() { } return true; }; - return std::equal(media_packet_list_.cbegin(), media_packet_list_.cend(), - recovered_packet_list_.cbegin(), cmp); + return std::equal(media_packets_.cbegin(), media_packets_.cend(), + recovered_packets_.cbegin(), cmp); } -void RtpFecTest::NetworkReceivedPackets(int* media_loss_mask, - int* fec_loss_mask) { +template +void RtpFecTest::NetworkReceivedPackets( + int* media_loss_mask, + int* fec_loss_mask) { constexpr bool kFecPacket = true; - ReceivedPackets(media_packet_list_, media_loss_mask, !kFecPacket); - ReceivedPackets(fec_packet_list_, fec_loss_mask, kFecPacket); + ReceivedPackets(media_packets_, media_loss_mask, !kFecPacket); + ReceivedPackets(generated_fec_packets_, fec_loss_mask, kFecPacket); } -template -void RtpFecTest::ReceivedPackets(const T& packet_list, int* loss_mask, - bool is_fec) { - int seq_num = fec_seq_num_; +template +template +void RtpFecTest::ReceivedPackets( + const PacketListType& packet_list, + int* loss_mask, + bool is_fec) { + uint16_t fec_seq_num = media_packet_generator_.GetFecSeqNum(); int packet_idx = 0; for (const auto& packet : packet_list) { @@ -844,91 +918,25 @@ void RtpFecTest::ReceivedPackets(const T& packet_list, int* loss_mask, // For media packets, the sequence number and marker bit is // obtained from RTP header. These were set in ConstructMediaPackets(). received_packet->seq_num = - webrtc::ByteReader::ReadBigEndian(&packet->data[2]); + ByteReader::ReadBigEndian(&packet->data[2]); } else { // The sequence number, marker bit, and ssrc number are defined in the // RTP header of the FEC packet, which is not constructed in this test. // So we set these values below based on the values generated in // ConstructMediaPackets(). - received_packet->seq_num = seq_num; + received_packet->seq_num = fec_seq_num; // The ssrc value for FEC packets is set to the one used for the // media packets in ConstructMediaPackets(). - received_packet->ssrc = ssrc_; + received_packet->ssrc = kMediaSsrc; } - received_packet_list_.push_back(std::move(received_packet)); + received_packets_.push_back(std::move(received_packet)); } packet_idx++; // Sequence number of FEC packets are defined as increment by 1 from // last media packet in frame. - if (is_fec) seq_num++; + if (is_fec) + fec_seq_num++; } } -int RtpFecTest::ConstructMediaPacketsSeqNum(int num_media_packets, - int start_seq_num) { - RTC_DCHECK_GT(num_media_packets, 0); - int sequence_number = start_seq_num; - int time_stamp = random_.Rand(); - - for (int i = 0; i < num_media_packets; ++i) { - std::unique_ptr media_packet( - new ForwardErrorCorrection::Packet()); - constexpr uint32_t kMinPacketSize = kRtpHeaderSize; - const uint32_t kMaxPacketSize = IP_PACKET_SIZE - kRtpHeaderSize - - kTransportOverhead - - fec_.MaxPacketOverhead(); - media_packet->length = random_.Rand(kMinPacketSize, kMaxPacketSize); - - // Generate random values for the first 2 bytes - media_packet->data[0] = random_.Rand(); - media_packet->data[1] = random_.Rand(); - - // The first two bits are assumed to be 10 by the FEC encoder. - // In fact the FEC decoder will set the two first bits to 10 regardless of - // what they actually were. Set the first two bits to 10 so that a memcmp - // can be performed for the whole restored packet. - media_packet->data[0] |= 0x80; - media_packet->data[0] &= 0xbf; - - // FEC is applied to a whole frame. - // A frame is signaled by multiple packets without the marker bit set - // followed by the last packet of the frame for which the marker bit is set. - // Only push one (fake) frame to the FEC. - media_packet->data[1] &= 0x7f; - - webrtc::ByteWriter::WriteBigEndian(&media_packet->data[2], - sequence_number); - webrtc::ByteWriter::WriteBigEndian(&media_packet->data[4], - time_stamp); - webrtc::ByteWriter::WriteBigEndian(&media_packet->data[8], ssrc_); - - // Generate random values for payload. - for (size_t j = 12; j < media_packet->length; ++j) { - media_packet->data[j] = random_.Rand(); - } - sequence_number++; - media_packet_list_.push_back(std::move(media_packet)); - } - // Last packet, set marker bit. - ForwardErrorCorrection::Packet* media_packet = - media_packet_list_.back().get(); - RTC_DCHECK(media_packet); - media_packet->data[1] |= 0x80; - return sequence_number; -} - -int RtpFecTest::ConstructMediaPackets(int num_media_packets) { - return ConstructMediaPacketsSeqNum(num_media_packets, random_.Rand()); -} - -void RtpFecTest::DeepCopyEveryNthPacket(const PacketList& src, int n, - PacketList* dst) { - RTC_DCHECK_GT(n, 0); - int i = 0; - for (const auto& packet : src) { - if (i % n == 0) { - dst->emplace_back(new ForwardErrorCorrection::Packet(*packet)); - } - ++i; - } -} +} // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc index bea52d7cd6..be010382a8 100644 --- a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc +++ b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc @@ -277,14 +277,14 @@ TEST(FecTest, MAYBE_FecTest) { } media_packet_list.back()->data[1] |= 0x80; - ASSERT_EQ(0, fec.GenerateFec(media_packet_list, protection_factor, - num_imp_packets, kUseUnequalProtection, - fec_mask_type, &fec_packet_list)) - << "GenerateFec() failed"; + ASSERT_EQ(0, fec.EncodeFec(media_packet_list, protection_factor, + num_imp_packets, kUseUnequalProtection, + fec_mask_type, &fec_packet_list)) + << "EncodeFec() failed"; ASSERT_EQ(num_fec_packets, fec_packet_list.size()) << "We requested " << num_fec_packets << " FEC packets, but " - << "GenerateFec() produced " << fec_packet_list.size(); + << "EncodeFec() produced " << fec_packet_list.size(); memset(media_loss_mask, 0, sizeof(media_loss_mask)); uint32_t media_packet_idx = 0; @@ -392,8 +392,8 @@ TEST(FecTest, MAYBE_FecTest) { } } } - ASSERT_EQ(0, fec.DecodeFec(&to_decode_list, - &recovered_packet_list)) + ASSERT_EQ(0, + fec.DecodeFec(&to_decode_list, &recovered_packet_list)) << "DecodeFec() failed"; ASSERT_TRUE(to_decode_list.empty()) << "Received packet list is not empty."; diff --git a/webrtc/test/fuzzers/producer_fec_fuzzer.cc b/webrtc/test/fuzzers/producer_fec_fuzzer.cc index 50a5e5e5cd..3319138748 100644 --- a/webrtc/test/fuzzers/producer_fec_fuzzer.cc +++ b/webrtc/test/fuzzers/producer_fec_fuzzer.cc @@ -17,6 +17,11 @@ namespace webrtc { +namespace { +constexpr uint8_t kFecPayloadType = 96; +constexpr uint8_t kRedPayloadType = 97; +} // namespace + void FuzzOneInput(const uint8_t* data, size_t size) { ProducerFec producer; size_t i = 0;