From 0f0668e328995a62f2b7749150a67a6efa373d2e Mon Sep 17 00:00:00 2001 From: Qingsi Wang Date: Thu, 11 Jul 2019 19:51:12 +0000 Subject: [PATCH] Revert "Cleanup FEC code after refactoring" This reverts commit 4e5a41a08674d5b3eaef2508df21613a82c4ee66. Reason for revert: FecTest.UlpfecTest is consistently failing after the refactoring. Original change's description: > Cleanup FEC code after refactoring > > This CL removes length field from Packet class, as COW buffer data > already has length. > > Bug: webrtc:10750 > Change-Id: I5c2a857b72007e82e819e7fa5f5aeb2e074730fa > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/144942 > Commit-Queue: Ilya Nikolaevskiy > Reviewed-by: Artem Titov > Reviewed-by: Stefan Holmer > Reviewed-by: Rasmus Brandt > Cr-Commit-Position: refs/heads/master@{#28540} TBR=brandtr@webrtc.org,ilnik@webrtc.org,asapersson@webrtc.org,stefan@webrtc.org,titovartem@webrtc.org Change-Id: I0adafb513cc151acc510feaef04ef14587b1cb8d No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: webrtc:10750 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/145310 Reviewed-by: Qingsi Wang Commit-Queue: Qingsi Wang Cr-Commit-Position: refs/heads/master@{#28544} --- modules/rtp_rtcp/source/fec_test_helper.cc | 29 ++++++----- .../source/flexfec_header_reader_writer.cc | 11 ++-- .../flexfec_header_reader_writer_unittest.cc | 42 +++++++++------ modules/rtp_rtcp/source/flexfec_receiver.cc | 5 +- .../source/flexfec_receiver_unittest.cc | 52 +++++++++---------- modules/rtp_rtcp/source/flexfec_sender.cc | 5 +- .../source/forward_error_correction.cc | 31 ++++++----- .../source/forward_error_correction.h | 1 + modules/rtp_rtcp/source/rtp_fec_unittest.cc | 5 +- modules/rtp_rtcp/source/ulpfec_generator.cc | 5 +- .../source/ulpfec_header_reader_writer.cc | 4 +- .../ulpfec_header_reader_writer_unittest.cc | 22 +++++--- .../rtp_rtcp/source/ulpfec_receiver_impl.cc | 9 ++-- .../source/ulpfec_receiver_unittest.cc | 10 ++-- modules/rtp_rtcp/test/testFec/test_fec.cc | 19 ++++--- test/fuzzers/flexfec_header_reader_fuzzer.cc | 1 + .../forward_error_correction_fuzzer.cc | 4 +- test/fuzzers/ulpfec_header_reader_fuzzer.cc | 1 + 18 files changed, 144 insertions(+), 112 deletions(-) diff --git a/modules/rtp_rtcp/source/fec_test_helper.cc b/modules/rtp_rtcp/source/fec_test_helper.cc index a98d33f988..8823e8b210 100644 --- a/modules/rtp_rtcp/source/fec_test_helper.cc +++ b/modules/rtp_rtcp/source/fec_test_helper.cc @@ -53,8 +53,8 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets( for (int i = 0; i < num_media_packets; ++i) { std::unique_ptr media_packet( new ForwardErrorCorrection::Packet()); - media_packet->data.SetSize( - random_->Rand(min_packet_size_, max_packet_size_)); + media_packet->length = random_->Rand(min_packet_size_, max_packet_size_); + media_packet->data.SetSize(media_packet->length); // Generate random values for the first 2 bytes media_packet->data[0] = random_->Rand(); @@ -80,7 +80,7 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets( webrtc::ByteWriter::WriteBigEndian(&media_packet->data[8], ssrc_); // Generate random values for payload. - for (size_t j = 12; j < media_packet->data.size(); ++j) + 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)); @@ -124,7 +124,8 @@ std::unique_ptr AugmentedPacketGenerator::NextPacket( packet->data.SetSize(length + kRtpHeaderSize); for (size_t i = 0; i < length; ++i) packet->data[i + kRtpHeaderSize] = offset + i; - packet->data.SetSize(length + kRtpHeaderSize); + packet->length = length + kRtpHeaderSize; + packet->data.SetSize(packet->length); packet->header.headerLength = kRtpHeaderSize; packet->header.markerBit = (num_packets_ == 1); packet->header.payloadType = kVp8PayloadType; @@ -157,7 +158,7 @@ FlexfecPacketGenerator::FlexfecPacketGenerator(uint32_t media_ssrc, std::unique_ptr FlexfecPacketGenerator::BuildFlexfecPacket( const ForwardErrorCorrection::Packet& packet) { - RTC_DCHECK_LE(packet.data.size(), + RTC_DCHECK_LE(packet.length, static_cast(IP_PACKET_SIZE - kRtpHeaderSize)); RTPHeader header; @@ -169,10 +170,11 @@ std::unique_ptr FlexfecPacketGenerator::BuildFlexfecPacket( std::unique_ptr packet_with_rtp_header( new AugmentedPacket()); - packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.data.size()); + packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.length); WriteRtpHeader(header, packet_with_rtp_header->data.data()); memcpy(packet_with_rtp_header->data.data() + kRtpHeaderSize, - packet.data.cdata(), packet.data.size()); + packet.data.cdata(), packet.length); + packet_with_rtp_header->length = kRtpHeaderSize + packet.length; return packet_with_rtp_header; } @@ -186,13 +188,13 @@ std::unique_ptr UlpfecPacketGenerator::BuildMediaRedPacket( const size_t kHeaderLength = packet.header.headerLength; red_packet->header = packet.header; - red_packet->data.SetSize(packet.data.size() + 1); + red_packet->length = packet.length + 1; // 1 byte RED header. + red_packet->data.SetSize(packet.length + 1); // Copy RTP header. memcpy(red_packet->data.data(), packet.data.cdata(), kHeaderLength); SetRedHeader(red_packet->data[1] & 0x7f, kHeaderLength, red_packet.get()); memcpy(red_packet->data.data() + kHeaderLength + 1, - packet.data.cdata() + kHeaderLength, - packet.data.size() - kHeaderLength); + packet.data.cdata() + kHeaderLength, packet.length - kHeaderLength); return red_packet; } @@ -202,14 +204,15 @@ std::unique_ptr UlpfecPacketGenerator::BuildUlpfecRedPacket( // Create a fake media packet to get a correct header. 1 byte RED header. ++num_packets_; std::unique_ptr red_packet = - NextPacket(0, packet.data.size() + 1); + NextPacket(0, packet.length + 1); red_packet->data[1] &= ~0x80; // Clear marker bit. const size_t kHeaderLength = red_packet->header.headerLength; - red_packet->data.SetSize(kHeaderLength + 1 + packet.data.size()); + red_packet->data.SetSize(kHeaderLength + 1 + packet.length); SetRedHeader(kFecPayloadType, kHeaderLength, red_packet.get()); memcpy(red_packet->data.data() + kHeaderLength + 1, packet.data.cdata(), - packet.data.size()); + packet.length); + red_packet->length = kHeaderLength + 1 + packet.length; return red_packet; } diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc index 6acf3681eb..04b48cae0f 100644 --- a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc +++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc @@ -80,8 +80,7 @@ FlexfecHeaderReader::~FlexfecHeaderReader() = default; // retransmissions, and/or several protected SSRCs. bool FlexfecHeaderReader::ReadFecHeader( ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const { - if (fec_packet->pkt->data.size() <= - kBaseHeaderSize + kStreamSpecificHeaderSize) { + if (fec_packet->pkt->length <= kBaseHeaderSize + kStreamSpecificHeaderSize) { RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; return false; } @@ -122,7 +121,7 @@ bool FlexfecHeaderReader::ReadFecHeader( // // We treat the mask parts as unsigned integers with host order endianness // in order to simplify the bit shifting between bytes. - if (fec_packet->pkt->data.size() < kHeaderSizes[0]) { + if (fec_packet->pkt->length < kHeaderSizes[0]) { RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; return false; } @@ -139,7 +138,7 @@ bool FlexfecHeaderReader::ReadFecHeader( // is payload. packet_mask_size = kFlexfecPacketMaskSizes[0]; } else { - if (fec_packet->pkt->data.size() < kHeaderSizes[1]) { + if (fec_packet->pkt->length < kHeaderSizes[1]) { return false; } bool k_bit1 = (packet_mask[2] & 0x80) != 0; @@ -159,7 +158,7 @@ bool FlexfecHeaderReader::ReadFecHeader( // and the rest of the packet is payload. packet_mask_size = kFlexfecPacketMaskSizes[1]; } else { - if (fec_packet->pkt->data.size() < kHeaderSizes[2]) { + if (fec_packet->pkt->length < kHeaderSizes[2]) { RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; return false; } @@ -199,7 +198,7 @@ bool FlexfecHeaderReader::ReadFecHeader( // In FlexFEC, all media packets are protected in their entirety. fec_packet->protection_length = - fec_packet->pkt->data.size() - fec_packet->fec_header_size; + fec_packet->pkt->length - fec_packet->fec_header_size; return true; } diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc index 1d86dd0eb4..7c1e4dbe47 100644 --- a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc +++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc @@ -77,8 +77,9 @@ rtc::scoped_refptr WriteHeader(const uint8_t* packet_mask, size_t packet_mask_size) { FlexfecHeaderWriter writer; rtc::scoped_refptr written_packet(new Packet()); + written_packet->length = kMediaPacketLength; written_packet->data.SetSize(kMediaPacketLength); - for (size_t i = 0; i < written_packet->data.size(); ++i) { + for (size_t i = 0; i < written_packet->length; ++i) { written_packet->data[i] = i; // Actual content doesn't matter. } writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, @@ -92,6 +93,7 @@ std::unique_ptr ReadHeader(const Packet& written_packet) { read_packet->ssrc = kFlexfecSsrc; read_packet->pkt = rtc::scoped_refptr(new Packet()); read_packet->pkt->data = written_packet.data; + read_packet->pkt->length = written_packet.length; EXPECT_TRUE(reader.ReadFecHeader(read_packet.get())); return read_packet; } @@ -108,7 +110,7 @@ void VerifyReadHeaders(size_t expected_fec_header_size, const size_t packet_mask_offset = read_packet.packet_mask_offset; EXPECT_EQ(kFlexfecPacketMaskOffset, packet_mask_offset); EXPECT_EQ(expected_packet_mask_size, read_packet.packet_mask_size); - EXPECT_EQ(read_packet.pkt->data.size() - expected_fec_header_size, + EXPECT_EQ(read_packet.pkt->length - expected_fec_header_size, read_packet.protection_length); // Ensure that the K-bits are removed and the packet mask has been packed. EXPECT_THAT( @@ -145,7 +147,7 @@ void VerifyWrittenAndReadHeaders(size_t expected_fec_header_size, EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base); EXPECT_EQ(kFlexfecPacketMaskOffset, read_packet.packet_mask_offset); ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size); - EXPECT_EQ(written_packet.data.size() - expected_fec_header_size, + EXPECT_EQ(written_packet.length - expected_fec_header_size, read_packet.protection_length); // Verify that the call to ReadFecHeader did normalize the packet masks. EXPECT_THAT(::testing::make_tuple( @@ -156,10 +158,10 @@ void VerifyWrittenAndReadHeaders(size_t expected_fec_header_size, // Verify that the call to ReadFecHeader did not tamper with the payload. EXPECT_THAT(::testing::make_tuple( read_packet.pkt->data.cdata() + read_packet.fec_header_size, - read_packet.pkt->data.size() - read_packet.fec_header_size), + read_packet.pkt->length - read_packet.fec_header_size), ::testing::ElementsAreArray( written_packet.data.cdata() + expected_fec_header_size, - written_packet.data.size() - expected_fec_header_size)); + written_packet.length - expected_fec_header_size)); } } // namespace @@ -183,6 +185,7 @@ TEST(FlexfecHeaderReaderTest, ReadsHeaderWithKBit0Set) { ReceivedFecPacket read_packet; read_packet.pkt = rtc::scoped_refptr(new Packet()); read_packet.pkt->data.SetData(kPacketData, packet_length); + read_packet.pkt->length = packet_length; FlexfecHeaderReader reader; EXPECT_TRUE(reader.ReadFecHeader(&read_packet)); @@ -214,6 +217,7 @@ TEST(FlexfecHeaderReaderTest, ReadsHeaderWithKBit1Set) { ReceivedFecPacket read_packet; read_packet.pkt = rtc::scoped_refptr(new Packet()); read_packet.pkt->data.SetData(kPacketData, packet_length); + read_packet.pkt->length = packet_length; FlexfecHeaderReader reader; EXPECT_TRUE(reader.ReadFecHeader(&read_packet)); @@ -252,6 +256,7 @@ TEST(FlexfecHeaderReaderTest, ReadsHeaderWithKBit2Set) { ReceivedFecPacket read_packet; read_packet.pkt = rtc::scoped_refptr(new Packet()); read_packet.pkt->data.SetData(kPacketData, packet_length); + read_packet.pkt->length = packet_length; FlexfecHeaderReader reader; EXPECT_TRUE(reader.ReadFecHeader(&read_packet)); @@ -269,7 +274,8 @@ TEST(FlexfecHeaderReaderTest, ReadPacketWithoutStreamSpecificHeaderShouldFail) { ReceivedFecPacket read_packet; read_packet.ssrc = kFlexfecSsrc; read_packet.pkt = std::move(written_packet); - read_packet.pkt->data.SetSize(12); + read_packet.pkt->length = 12; + read_packet.pkt->data.SetSize(read_packet.pkt->length); FlexfecHeaderReader reader; EXPECT_FALSE(reader.ReadFecHeader(&read_packet)); @@ -284,7 +290,8 @@ TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit0SetShouldFail) { ReceivedFecPacket read_packet; read_packet.ssrc = kFlexfecSsrc; read_packet.pkt = std::move(written_packet); - read_packet.pkt->data.SetSize(18); + read_packet.pkt->length = 18; + read_packet.pkt->data.SetSize(read_packet.pkt->length); FlexfecHeaderReader reader; EXPECT_FALSE(reader.ReadFecHeader(&read_packet)); @@ -300,7 +307,8 @@ TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit1SetShouldFail) { ReceivedFecPacket read_packet; read_packet.ssrc = kFlexfecSsrc; read_packet.pkt = std::move(written_packet); - read_packet.pkt->data.SetSize(20); + read_packet.pkt->length = 20; + read_packet.pkt->data.SetSize(read_packet.pkt->length); FlexfecHeaderReader reader; EXPECT_FALSE(reader.ReadFecHeader(&read_packet)); @@ -316,7 +324,8 @@ TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit2SetShouldFail) { ReceivedFecPacket read_packet; read_packet.ssrc = kFlexfecSsrc; read_packet.pkt = std::move(written_packet); - read_packet.pkt->data.SetSize(24); + read_packet.pkt->length = 24; + read_packet.pkt->data.SetSize(read_packet.pkt->length); FlexfecHeaderReader reader; EXPECT_FALSE(reader.ReadFecHeader(&read_packet)); @@ -327,8 +336,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit0Set) { constexpr uint8_t kFlexfecPacketMask[] = {0x88, 0x81}; constexpr uint8_t kUlpfecPacketMask[] = {0x11, 0x02}; Packet written_packet; - written_packet.data.SetSize(kMediaPacketLength); - for (size_t i = 0; i < written_packet.data.size(); ++i) { + written_packet.length = kMediaPacketLength; + written_packet.data.SetSize(written_packet.length); + for (size_t i = 0; i < written_packet.length; ++i) { written_packet.data[i] = i; } @@ -345,8 +355,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit1Set) { constexpr uint8_t kFlexfecPacketMask[] = {0x48, 0x81, 0x82, 0x11, 0x00, 0x21}; constexpr uint8_t kUlpfecPacketMask[] = {0x91, 0x02, 0x08, 0x44, 0x00, 0x84}; Packet written_packet; - written_packet.data.SetSize(kMediaPacketLength); - for (size_t i = 0; i < written_packet.data.size(); ++i) { + written_packet.length = kMediaPacketLength; + written_packet.data.SetSize(written_packet.length); + for (size_t i = 0; i < written_packet.length; ++i) { written_packet.data[i] = i; } @@ -367,8 +378,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit2Set) { }; constexpr uint8_t kUlpfecPacketMask[] = {0x22, 0x22, 0x44, 0x44, 0x44, 0x41}; Packet written_packet; - written_packet.data.SetSize(kMediaPacketLength); - for (size_t i = 0; i < written_packet.data.size(); ++i) { + written_packet.length = kMediaPacketLength; + written_packet.data.SetSize(written_packet.length); + for (size_t i = 0; i < written_packet.length; ++i) { written_packet.data[i] = i; } diff --git a/modules/rtp_rtcp/source/flexfec_receiver.cc b/modules/rtp_rtcp/source/flexfec_receiver.cc index ba09db9e1c..da7bda16eb 100644 --- a/modules/rtp_rtcp/source/flexfec_receiver.cc +++ b/modules/rtp_rtcp/source/flexfec_receiver.cc @@ -113,6 +113,7 @@ FlexfecReceiver::AddReceivedPacket(const RtpPacketReceived& packet) { // of initializing COW buffer with ArrayView. auto payload = packet.payload(); received_packet->pkt->data.SetData(payload.data(), payload.size()); + received_packet->pkt->length = payload.size(); } else { // This is a media packet, or a FlexFEC packet belonging to some // other FlexFEC stream. @@ -128,6 +129,7 @@ FlexfecReceiver::AddReceivedPacket(const RtpPacketReceived& packet) { RtpPacketReceived packet_copy(packet); packet_copy.ZeroMutableExtensions(); received_packet->pkt->data = packet_copy.Buffer(); + received_packet->pkt->length = received_packet->pkt->data.size(); } ++packet_counter_.num_packets; @@ -163,8 +165,7 @@ void FlexfecReceiver::ProcessReceivedPacket( recovered_packet->returned = true; RTC_CHECK_GT(recovered_packet->pkt->data.size(), 0); recovered_packet_receiver_->OnRecoveredPacket( - recovered_packet->pkt->data.cdata(), - recovered_packet->pkt->data.size()); + recovered_packet->pkt->data.cdata(), recovered_packet->pkt->length); // Periodically log the incoming packets. int64_t now_ms = clock_->TimeInMilliseconds(); if (now_ms - last_recovered_packet_ms_ > kPacketLogIntervalMs) { diff --git a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc index 224fee6aa0..1542e745fc 100644 --- a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc @@ -149,7 +149,7 @@ TEST_F(FlexfecReceiverTest, FailsOnTruncatedFecPacket) { std::list fec_packets = EncodeFec(media_packets, kNumFecPackets); const auto& media_packet = media_packets.front(); // Simulate truncated FlexFEC payload. - fec_packets.front()->data.SetSize(1); + fec_packets.front()->length = 1; auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front()); std::unique_ptr received_packet = @@ -240,9 +240,9 @@ TEST_F(FlexfecReceiverTest, RecoversFromSingleMediaLoss) { packet_generator_.BuildFlexfecPacket(**fec_it); media_it++; EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_it)->data.size())) - .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), - (*media_it)->data.size()))); + OnRecoveredPacket(_, (*media_it)->length)) + .With(Args<0, 1>( + ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header)); } @@ -262,9 +262,9 @@ TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) { packet_generator_.BuildFlexfecPacket(**fec_it); auto media_it = media_packets.begin(); EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_it)->data.size())) - .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), - (*media_it)->data.size()))); + OnRecoveredPacket(_, (*media_it)->length)) + .With(Args<0, 1>( + ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header)); // Receive second FEC packet and recover second lost media packet. @@ -272,9 +272,9 @@ TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) { packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(**fec_it); media_it++; EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_it)->data.size())) - .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), - (*media_it)->data.size()))); + OnRecoveredPacket(_, (*media_it)->length)) + .With(Args<0, 1>( + ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header)); } @@ -311,9 +311,9 @@ TEST_F(FlexfecReceiverTest, DoesNotCallbackTwice) { packet_generator_.BuildFlexfecPacket(**fec_it); media_it++; EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_it)->data.size())) - .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), - (*media_it)->data.size()))); + OnRecoveredPacket(_, (*media_it)->length)) + .With(Args<0, 1>( + ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header)); // Receive the FEC packet again, but do not call back. @@ -364,9 +364,9 @@ TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) { break; } EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_it)->data.size())) - .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), - (*media_it)->data.size()))); + OnRecoveredPacket(_, (*media_it)->length)) + .With(Args<0, 1>( + ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); receiver_.OnRtpPacket(ParsePacket(*fec_packet_with_rtp_header)); ++media_it; } @@ -404,9 +404,9 @@ TEST_F(FlexfecReceiverTest, DelayedFecPacketDoesHelp) { packet_generator_.BuildFlexfecPacket(**fec_it); media_it = media_packets.begin(); EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_it)->data.size())) - .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), - (*media_it)->data.size()))); + OnRecoveredPacket(_, (*media_it)->length)) + .With(Args<0, 1>( + ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header)); } @@ -533,13 +533,13 @@ TEST_F(FlexfecReceiverTest, RecoversWithMediaPacketsOutOfOrder) { // Expect to recover lost media packets. EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_packet1)->data.size())) + OnRecoveredPacket(_, (*media_packet1)->length)) .With(Args<0, 1>(ElementsAreArray((*media_packet1)->data.cdata(), - (*media_packet1)->data.size()))); + (*media_packet1)->length))); EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_packet4)->data.size())) + OnRecoveredPacket(_, (*media_packet4)->length)) .With(Args<0, 1>(ElementsAreArray((*media_packet4)->data.cdata(), - (*media_packet4)->data.size()))); + (*media_packet4)->length))); // Add FEC packets. auto fec_it = fec_packets.begin(); @@ -635,9 +635,9 @@ TEST_F(FlexfecReceiverTest, CalculatesNumberOfPackets) { packet_generator_.BuildFlexfecPacket(**fec_it); media_it++; EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_it)->data.size())) - .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), - (*media_it)->data.size()))); + OnRecoveredPacket(_, (*media_it)->length)) + .With(Args<0, 1>( + ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header)); // Check stats calculations. diff --git a/modules/rtp_rtcp/source/flexfec_sender.cc b/modules/rtp_rtcp/source/flexfec_sender.cc index d35f4d6eed..3fb51cd4c4 100644 --- a/modules/rtp_rtcp/source/flexfec_sender.cc +++ b/modules/rtp_rtcp/source/flexfec_sender.cc @@ -153,9 +153,8 @@ std::vector> FlexfecSender::GetFecPackets() { } // RTP payload. - uint8_t* payload = - fec_packet_to_send->AllocatePayload(fec_packet->data.size()); - memcpy(payload, fec_packet->data.cdata(), fec_packet->data.size()); + uint8_t* payload = fec_packet_to_send->AllocatePayload(fec_packet->length); + memcpy(payload, fec_packet->data.cdata(), fec_packet->length); fec_packets_to_send.push_back(std::move(fec_packet_to_send)); } diff --git a/modules/rtp_rtcp/source/forward_error_correction.cc b/modules/rtp_rtcp/source/forward_error_correction.cc index a098c4ea56..bfb4c2d35b 100644 --- a/modules/rtp_rtcp/source/forward_error_correction.cc +++ b/modules/rtp_rtcp/source/forward_error_correction.cc @@ -33,7 +33,7 @@ namespace { constexpr size_t kTransportOverhead = 28; } // namespace -ForwardErrorCorrection::Packet::Packet() : data(0), ref_count_(0) {} +ForwardErrorCorrection::Packet::Packet() : length(0), data(), ref_count_(0) {} ForwardErrorCorrection::Packet::~Packet() = default; int32_t ForwardErrorCorrection::Packet::AddRef() { @@ -128,16 +128,16 @@ int ForwardErrorCorrection::EncodeFec(const PacketList& media_packets, // Error check the media packets. for (const auto& media_packet : media_packets) { RTC_DCHECK(media_packet); - if (media_packet->data.size() < kRtpHeaderSize) { - RTC_LOG(LS_WARNING) << "Media packet " << media_packet->data.size() + if (media_packet->length < kRtpHeaderSize) { + RTC_LOG(LS_WARNING) << "Media packet " << media_packet->length << " bytes " << "is smaller than RTP header."; return -1; } // Ensure the FEC packets will fit in a typical MTU. - if (media_packet->data.size() + MaxPacketOverhead() + kTransportOverhead > + if (media_packet->length + MaxPacketOverhead() + kTransportOverhead > IP_PACKET_SIZE) { - RTC_LOG(LS_WARNING) << "Media packet " << media_packet->data.size() + RTC_LOG(LS_WARNING) << "Media packet " << media_packet->length << " bytes " << "with overhead is larger than " << IP_PACKET_SIZE << " bytes."; @@ -153,6 +153,7 @@ int ForwardErrorCorrection::EncodeFec(const PacketList& media_packets, generated_fec_packets_[i].data.EnsureCapacity(IP_PACKET_SIZE); memset(generated_fec_packets_[i].data.data(), 0, IP_PACKET_SIZE); // Use this as a marker for untouched packets. + generated_fec_packets_[i].length = 0; generated_fec_packets_[i].data.SetSize(0); fec_packets->push_back(&generated_fec_packets_[i]); } @@ -218,16 +219,16 @@ void ForwardErrorCorrection::GenerateFecPayloads( Packet* const media_packet = media_packets_it->get(); // Should |media_packet| be protected by |fec_packet|? if (packet_masks_[pkt_mask_idx] & (1 << (7 - media_pkt_idx))) { - size_t media_payload_length = - media_packet->data.size() - kRtpHeaderSize; + size_t media_payload_length = media_packet->length - kRtpHeaderSize; - bool first_protected_packet = (fec_packet->data.size() == 0); + bool first_protected_packet = (fec_packet->length == 0); size_t fec_packet_length = fec_header_size + media_payload_length; - if (fec_packet_length > fec_packet->data.size()) { + if (fec_packet_length > fec_packet->length) { // Recall that XORing with zero (which the FEC packets are prefilled // with) is the identity operator, thus all prior XORs are // still correct even though we expand the packet length here. - fec_packet->data.SetSize(fec_packet_length); + fec_packet->length = fec_packet_length; + fec_packet->data.SetSize(fec_packet->length); } if (first_protected_packet) { // Write P, X, CC, M, and PT recovery fields. @@ -260,7 +261,7 @@ void ForwardErrorCorrection::GenerateFecPayloads( pkt_mask_idx += media_pkt_idx / 8; media_pkt_idx %= 8; } - RTC_DCHECK_GT(fec_packet->data.size(), 0) + RTC_DCHECK_GT(fec_packet->length, 0) << "Packet mask is wrong or poorly designed."; } } @@ -377,6 +378,7 @@ void ForwardErrorCorrection::InsertMediaPacket( recovered_packet->ssrc = received_packet.ssrc; recovered_packet->seq_num = received_packet.seq_num; recovered_packet->pkt = received_packet.pkt; + recovered_packet->pkt->length = received_packet.pkt->length; // TODO(holmer): Consider replacing this with a binary search for the right // position, and then just insert the new packet. Would get rid of the sort. RecoveredPacket* recovered_packet_ptr = recovered_packet.get(); @@ -536,7 +538,7 @@ bool ForwardErrorCorrection::StartPacketRecovery( const ReceivedFecPacket& fec_packet, RecoveredPacket* recovered_packet) { // Sanity check packet length. - if (fec_packet.pkt->data.size() < fec_packet.fec_header_size) { + if (fec_packet.pkt->length < fec_packet.fec_header_size) { RTC_LOG(LS_WARNING) << "The FEC packet is truncated: it does not contain enough room " << "for its own header."; @@ -583,6 +585,7 @@ bool ForwardErrorCorrection::FinishPacketRecovery( << "typical IP packet, and is thus dropped."; return false; } + recovered_packet->pkt->length = new_size; recovered_packet->pkt->data.SetSize(new_size); // Set the SN field. ByteWriter::WriteBigEndian(&recovered_packet->pkt->data[2], @@ -602,7 +605,7 @@ void ForwardErrorCorrection::XorHeaders(const Packet& src, Packet* dst) { // XOR the length recovery field. uint8_t src_payload_length_network_order[2]; ByteWriter::WriteBigEndian(src_payload_length_network_order, - src.data.size() - kRtpHeaderSize); + src.length - kRtpHeaderSize); dst->data[2] ^= src_payload_length_network_order[0]; dst->data[3] ^= src_payload_length_network_order[1]; @@ -639,7 +642,7 @@ bool ForwardErrorCorrection::RecoverPacket(const ReceivedFecPacket& fec_packet, } else { XorHeaders(*protected_packet->pkt, recovered_packet->pkt); XorPayloads(*protected_packet->pkt, - protected_packet->pkt->data.size() - kRtpHeaderSize, + protected_packet->pkt->length - kRtpHeaderSize, kRtpHeaderSize, recovered_packet->pkt); } } diff --git a/modules/rtp_rtcp/source/forward_error_correction.h b/modules/rtp_rtcp/source/forward_error_correction.h index 70ec3c63dd..c00264707d 100644 --- a/modules/rtp_rtcp/source/forward_error_correction.h +++ b/modules/rtp_rtcp/source/forward_error_correction.h @@ -53,6 +53,7 @@ class ForwardErrorCorrection { // reaches zero. virtual int32_t Release(); + size_t length; // Length of packet in bytes. rtc::CopyOnWriteBuffer data; // Packet data. private: diff --git a/modules/rtp_rtcp/source/rtp_fec_unittest.cc b/modules/rtp_rtcp/source/rtp_fec_unittest.cc index eb559f2bd9..7d3b05420b 100644 --- a/modules/rtp_rtcp/source/rtp_fec_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_fec_unittest.cc @@ -120,6 +120,7 @@ void RtpFecTest::ReceivedPackets( std::unique_ptr received_packet( new ForwardErrorCorrection::ReceivedPacket()); received_packet->pkt = new ForwardErrorCorrection::Packet(); + received_packet->pkt->length = packet->length; received_packet->pkt->data = packet->data; received_packet->is_fec = is_fec; if (!is_fec) { @@ -154,12 +155,12 @@ bool RtpFecTest::IsRecoveryComplete() { [](const std::unique_ptr& media_packet, const std::unique_ptr& recovered_packet) { - if (media_packet->data.size() != recovered_packet->pkt->data.size()) { + if (media_packet->length != recovered_packet->pkt->length) { return false; } if (memcmp(media_packet->data.cdata(), recovered_packet->pkt->data.cdata(), - media_packet->data.size()) != 0) { + media_packet->length) != 0) { return false; } return true; diff --git a/modules/rtp_rtcp/source/ulpfec_generator.cc b/modules/rtp_rtcp/source/ulpfec_generator.cc index 92e65df187..791fff9d91 100644 --- a/modules/rtp_rtcp/source/ulpfec_generator.cc +++ b/modules/rtp_rtcp/source/ulpfec_generator.cc @@ -148,6 +148,7 @@ int UlpfecGenerator::AddRtpPacketAndGenerateFec( new ForwardErrorCorrection::Packet()); RTC_DCHECK_GE(data_buffer.size(), rtp_header_length); packet->data = data_buffer; + packet->length = packet->data.size(); media_packets_.push_back(std::move(packet)); // Keep track of the RTP header length, so we can copy the RTP header // from |packet| to newly generated ULPFEC+RED packets. @@ -225,13 +226,13 @@ std::vector> UlpfecGenerator::GetUlpfecPacketsAsRed( RTC_DCHECK_GT(last_media_packet_rtp_header_length_, 0); std::unique_ptr red_packet( new RedPacket(last_media_packet_rtp_header_length_ + - kRedForFecHeaderLength + fec_packet->data.size())); + kRedForFecHeaderLength + fec_packet->length)); red_packet->CreateHeader(last_media_packet->data.data(), last_media_packet_rtp_header_length_, red_payload_type, ulpfec_payload_type); red_packet->SetSeqNum(seq_num++); red_packet->ClearMarkerBit(); - red_packet->AssignPayload(fec_packet->data.data(), fec_packet->data.size()); + red_packet->AssignPayload(fec_packet->data.data(), fec_packet->length); red_packets.push_back(std::move(red_packet)); } diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc index 496fe73ad9..7086b13685 100644 --- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc +++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc @@ -123,8 +123,8 @@ void UlpfecHeaderWriter::FinalizeFecHeader( // Protection length is set to entire packet. (This is not // required in general.) const size_t fec_header_size = FecHeaderSize(packet_mask_size); - ByteWriter::WriteBigEndian( - &fec_packet->data[10], fec_packet->data.size() - fec_header_size); + ByteWriter::WriteBigEndian(&fec_packet->data[10], + fec_packet->length - fec_header_size); // Copy the packet mask. memcpy(&fec_packet->data[12], packet_mask, packet_mask_size); } diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc index 19da2c87c0..fb593b326b 100644 --- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc +++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc @@ -52,8 +52,9 @@ std::unique_ptr WriteHeader(const uint8_t* packet_mask, size_t packet_mask_size) { UlpfecHeaderWriter writer; std::unique_ptr written_packet(new Packet()); - written_packet->data.SetSize(kMediaPacketLength); - for (size_t i = 0; i < written_packet->data.size(); ++i) { + written_packet->length = kMediaPacketLength; + written_packet->data.SetSize(written_packet->length); + for (size_t i = 0; i < written_packet->length; ++i) { written_packet->data[i] = i; // Actual content doesn't matter. } writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, @@ -67,6 +68,7 @@ std::unique_ptr ReadHeader(const Packet& written_packet) { read_packet->ssrc = kMediaSsrc; read_packet->pkt = rtc::scoped_refptr(new Packet()); read_packet->pkt->data = written_packet.data; + read_packet->pkt->length = written_packet.length; EXPECT_TRUE(reader.ReadFecHeader(read_packet.get())); return read_packet; } @@ -82,7 +84,7 @@ void VerifyHeaders(size_t expected_fec_header_size, EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base); EXPECT_EQ(kUlpfecPacketMaskOffset, read_packet.packet_mask_offset); ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size); - EXPECT_EQ(written_packet.data.size() - expected_fec_header_size, + EXPECT_EQ(written_packet.length - expected_fec_header_size, read_packet.protection_length); EXPECT_EQ(0, memcmp(expected_packet_mask, &read_packet.pkt->data[read_packet.packet_mask_offset], @@ -90,7 +92,7 @@ void VerifyHeaders(size_t expected_fec_header_size, // Verify that the call to ReadFecHeader did not tamper with the payload. EXPECT_EQ(0, memcmp(written_packet.data.data() + expected_fec_header_size, read_packet.pkt->data.cdata() + expected_fec_header_size, - written_packet.data.size() - expected_fec_header_size)); + written_packet.length - expected_fec_header_size)); } } // namespace @@ -107,6 +109,7 @@ TEST(UlpfecHeaderReaderTest, ReadsSmallHeader) { ReceivedFecPacket read_packet; read_packet.pkt = rtc::scoped_refptr(new Packet()); read_packet.pkt->data.SetData(packet, packet_length); + read_packet.pkt->length = packet_length; UlpfecHeaderReader reader; EXPECT_TRUE(reader.ReadFecHeader(&read_packet)); @@ -131,6 +134,7 @@ TEST(UlpfecHeaderReaderTest, ReadsLargeHeader) { ReceivedFecPacket read_packet; read_packet.pkt = rtc::scoped_refptr(new Packet()); read_packet.pkt->data.SetData(packet, packet_length); + read_packet.pkt->length = packet_length; UlpfecHeaderReader reader; EXPECT_TRUE(reader.ReadFecHeader(&read_packet)); @@ -146,8 +150,9 @@ TEST(UlpfecHeaderWriterTest, FinalizesSmallHeader) { const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear; auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd); Packet written_packet; - written_packet.data.SetSize(kMediaPacketLength); - for (size_t i = 0; i < written_packet.data.size(); ++i) { + written_packet.length = kMediaPacketLength; + written_packet.data.SetSize(written_packet.length); + for (size_t i = 0; i < written_packet.length; ++i) { written_packet.data[i] = i; } @@ -170,8 +175,9 @@ TEST(UlpfecHeaderWriterTest, FinalizesLargeHeader) { const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet; auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd); Packet written_packet; - written_packet.data.SetSize(kMediaPacketLength); - for (size_t i = 0; i < written_packet.data.size(); ++i) { + written_packet.length = kMediaPacketLength; + written_packet.data.SetSize(written_packet.length); + for (size_t i = 0; i < written_packet.length; ++i) { written_packet.data[i] = i; } diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc index 9088a0c072..b950cbd814 100644 --- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc +++ b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc @@ -133,6 +133,7 @@ int32_t UlpfecReceiverImpl::AddReceivedRedPacket( received_packet->pkt->data.SetData( incoming_rtp_packet + header.headerLength + red_header_length, payload_data_length - red_header_length); + received_packet->pkt->length = payload_data_length - red_header_length; received_packet->ssrc = ByteReader::ReadBigEndian(&incoming_rtp_packet[8]); @@ -151,9 +152,11 @@ int32_t UlpfecReceiverImpl::AddReceivedRedPacket( incoming_rtp_packet + header.headerLength + red_header_length, payload_data_length - red_header_length); } + received_packet->pkt->length = + header.headerLength + payload_data_length - red_header_length; } - if (received_packet->pkt->data.size() == 0) { + if (received_packet->pkt->length == 0) { return 0; } @@ -182,7 +185,7 @@ int32_t UlpfecReceiverImpl::ProcessReceivedFec() { ForwardErrorCorrection::Packet* packet = received_packet->pkt; crit_sect_.Leave(); recovered_packet_callback_->OnRecoveredPacket(packet->data.data(), - packet->data.size()); + packet->length); crit_sect_.Enter(); // Create a packet with the buffer to modify it. RtpPacketReceived rtp_packet; @@ -210,7 +213,7 @@ int32_t UlpfecReceiverImpl::ProcessReceivedFec() { recovered_packet->returned = true; crit_sect_.Leave(); recovered_packet_callback_->OnRecoveredPacket(packet->data.data(), - packet->data.size()); + packet->length); crit_sect_.Enter(); } diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc index 40bf0a5990..bbe616f059 100644 --- a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc @@ -127,7 +127,7 @@ void UlpfecReceiverTest::BuildAndAddRedMediaPacket(AugmentedPacket* packet) { packet_generator_.BuildMediaRedPacket(*packet)); EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( red_packet->header, red_packet->data.cdata(), - red_packet->data.size(), kFecPayloadType)); + red_packet->length, kFecPayloadType)); } void UlpfecReceiverTest::BuildAndAddRedFecPacket(Packet* packet) { @@ -135,7 +135,7 @@ void UlpfecReceiverTest::BuildAndAddRedFecPacket(Packet* packet) { packet_generator_.BuildUlpfecRedPacket(*packet)); EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( red_packet->header, red_packet->data.cdata(), - red_packet->data.size(), kFecPayloadType)); + red_packet->length, kFecPayloadType)); } void UlpfecReceiverTest::VerifyReconstructedMediaPacket( @@ -144,10 +144,8 @@ void UlpfecReceiverTest::VerifyReconstructedMediaPacket( // 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. - EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, packet.data.size())) - .With( - Args<0, 1>(ElementsAreArray(packet.data.cdata(), packet.data.size()))) + EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, packet.length)) + .With(Args<0, 1>(ElementsAreArray(packet.data.cdata(), packet.length))) .Times(times); } diff --git a/modules/rtp_rtcp/test/testFec/test_fec.cc b/modules/rtp_rtcp/test/testFec/test_fec.cc index ff586e95fc..434d3ac4fb 100644 --- a/modules/rtp_rtcp/test/testFec/test_fec.cc +++ b/modules/rtp_rtcp/test/testFec/test_fec.cc @@ -71,6 +71,7 @@ void ReceivePackets( *duplicate_packet = *received_packet; duplicate_packet->pkt = new ForwardErrorCorrection::Packet(); duplicate_packet->pkt->data = received_packet->pkt->data; + duplicate_packet->pkt->length = received_packet->pkt->length; to_decode_list->push_back(std::move(duplicate_packet)); random_variable = random->Rand(); @@ -250,8 +251,9 @@ void RunTest(bool use_flexfec) { const uint32_t kMinPacketSize = 12; const uint32_t kMaxPacketSize = static_cast( IP_PACKET_SIZE - 12 - 28 - fec->MaxPacketOverhead()); - media_packet->data.SetSize( - random.Rand(kMinPacketSize, kMaxPacketSize)); + media_packet->length = + random.Rand(kMinPacketSize, kMaxPacketSize); + media_packet->data.SetSize(media_packet->length); // Generate random values for the first 2 bytes. media_packet->data[0] = random.Rand(); @@ -280,7 +282,7 @@ void RunTest(bool use_flexfec) { ByteWriter::WriteBigEndian(&media_packet->data[8], media_ssrc); // Generate random values for payload - for (size_t j = 12; j < media_packet->data.size(); ++j) { + for (size_t j = 12; j < media_packet->length; ++j) { media_packet->data[j] = random.Rand(); } media_packet_list.push_back(std::move(media_packet)); @@ -309,6 +311,7 @@ void RunTest(bool use_flexfec) { received_packet( new ForwardErrorCorrection::ReceivedPacket()); received_packet->pkt = new ForwardErrorCorrection::Packet(); + received_packet->pkt->length = media_packet->length; received_packet->pkt->data = media_packet->data; received_packet->ssrc = media_ssrc; received_packet->seq_num = @@ -329,6 +332,7 @@ void RunTest(bool use_flexfec) { received_packet( new ForwardErrorCorrection::ReceivedPacket()); received_packet->pkt = new ForwardErrorCorrection::Packet(); + received_packet->pkt->length = fec_packet->length; received_packet->pkt->data = fec_packet->data; received_packet->seq_num = fec_seq_num_offset + seq_num; received_packet->is_fec = true; @@ -417,13 +421,12 @@ void RunTest(bool use_flexfec) { ForwardErrorCorrection::RecoveredPacket* recovered_packet = recovered_packet_list_it->get(); - ASSERT_EQ(recovered_packet->pkt->data.size(), - media_packet->data.size()) + ASSERT_EQ(recovered_packet->pkt->length, media_packet->length) << "Recovered packet length not identical to original " << "media packet"; - ASSERT_EQ(0, memcmp(recovered_packet->pkt->data.cdata(), - media_packet->data.cdata(), - media_packet->data.size())) + ASSERT_EQ( + 0, memcmp(recovered_packet->pkt->data.cdata(), + media_packet->data.cdata(), media_packet->length)) << "Recovered packet payload not identical to original " << "media packet"; recovered_packet_list.pop_front(); diff --git a/test/fuzzers/flexfec_header_reader_fuzzer.cc b/test/fuzzers/flexfec_header_reader_fuzzer.cc index 4eb9a0503d..2f4c498edb 100644 --- a/test/fuzzers/flexfec_header_reader_fuzzer.cc +++ b/test/fuzzers/flexfec_header_reader_fuzzer.cc @@ -27,6 +27,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) { std::min(size, static_cast(IP_PACKET_SIZE)); packet.pkt->data.SetSize(packet_size); memcpy(packet.pkt->data.data(), data, packet_size); + packet.pkt->length = packet_size; FlexfecHeaderReader flexfec_reader; flexfec_reader.ReadFecHeader(&packet); diff --git a/test/fuzzers/forward_error_correction_fuzzer.cc b/test/fuzzers/forward_error_correction_fuzzer.cc index 6c880a3a8e..3e674cda16 100644 --- a/test/fuzzers/forward_error_correction_fuzzer.cc +++ b/test/fuzzers/forward_error_correction_fuzzer.cc @@ -56,7 +56,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) { new ForwardErrorCorrection::RecoveredPacket(); recovered_packet->pkt = rtc::scoped_refptr( new ForwardErrorCorrection::Packet()); - recovered_packet->pkt->data.SetSize(kPacketSize); + recovered_packet->pkt->length = kPacketSize; recovered_packet->ssrc = kMediaSsrc; recovered_packet->seq_num = media_seqnum++; recovered_packets.emplace_back(recovered_packet); @@ -66,7 +66,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) { ForwardErrorCorrection::ReceivedPacket received_packet; received_packet.pkt = rtc::scoped_refptr( new ForwardErrorCorrection::Packet()); - received_packet.pkt->data.SetSize(kPacketSize); + received_packet.pkt->length = kPacketSize; uint8_t* packet_buffer = received_packet.pkt->data.data(); uint8_t reordering; uint16_t seq_num_diff; diff --git a/test/fuzzers/ulpfec_header_reader_fuzzer.cc b/test/fuzzers/ulpfec_header_reader_fuzzer.cc index f3f6581481..cf211f12ea 100644 --- a/test/fuzzers/ulpfec_header_reader_fuzzer.cc +++ b/test/fuzzers/ulpfec_header_reader_fuzzer.cc @@ -27,6 +27,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) { std::min(size, static_cast(IP_PACKET_SIZE)); packet.pkt->data.SetSize(packet_size); memcpy(packet.pkt->data.data(), data, packet_size); + packet.pkt->length = packet_size; UlpfecHeaderReader ulpfec_reader; ulpfec_reader.ReadFecHeader(&packet);