diff --git a/modules/rtp_rtcp/source/fec_test_helper.cc b/modules/rtp_rtcp/source/fec_test_helper.cc index 8823e8b210..a98d33f988 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->length = random_->Rand(min_packet_size_, max_packet_size_); - media_packet->data.SetSize(media_packet->length); + media_packet->data.SetSize( + random_->Rand(min_packet_size_, max_packet_size_)); // 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->length; ++j) + for (size_t j = 12; j < media_packet->data.size(); ++j) media_packet->data[j] = random_->Rand(); seq_num++; media_packets.push_back(std::move(media_packet)); @@ -124,8 +124,7 @@ 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->length = length + kRtpHeaderSize; - packet->data.SetSize(packet->length); + packet->data.SetSize(length + kRtpHeaderSize); packet->header.headerLength = kRtpHeaderSize; packet->header.markerBit = (num_packets_ == 1); packet->header.payloadType = kVp8PayloadType; @@ -158,7 +157,7 @@ FlexfecPacketGenerator::FlexfecPacketGenerator(uint32_t media_ssrc, std::unique_ptr FlexfecPacketGenerator::BuildFlexfecPacket( const ForwardErrorCorrection::Packet& packet) { - RTC_DCHECK_LE(packet.length, + RTC_DCHECK_LE(packet.data.size(), static_cast(IP_PACKET_SIZE - kRtpHeaderSize)); RTPHeader header; @@ -170,11 +169,10 @@ std::unique_ptr FlexfecPacketGenerator::BuildFlexfecPacket( std::unique_ptr packet_with_rtp_header( new AugmentedPacket()); - packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.length); + packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.data.size()); WriteRtpHeader(header, packet_with_rtp_header->data.data()); memcpy(packet_with_rtp_header->data.data() + kRtpHeaderSize, - packet.data.cdata(), packet.length); - packet_with_rtp_header->length = kRtpHeaderSize + packet.length; + packet.data.cdata(), packet.data.size()); return packet_with_rtp_header; } @@ -188,13 +186,13 @@ std::unique_ptr UlpfecPacketGenerator::BuildMediaRedPacket( const size_t kHeaderLength = packet.header.headerLength; red_packet->header = packet.header; - red_packet->length = packet.length + 1; // 1 byte RED header. - red_packet->data.SetSize(packet.length + 1); + red_packet->data.SetSize(packet.data.size() + 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.length - kHeaderLength); + packet.data.cdata() + kHeaderLength, + packet.data.size() - kHeaderLength); return red_packet; } @@ -204,15 +202,14 @@ 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.length + 1); + NextPacket(0, packet.data.size() + 1); red_packet->data[1] &= ~0x80; // Clear marker bit. const size_t kHeaderLength = red_packet->header.headerLength; - red_packet->data.SetSize(kHeaderLength + 1 + packet.length); + red_packet->data.SetSize(kHeaderLength + 1 + packet.data.size()); SetRedHeader(kFecPayloadType, kHeaderLength, red_packet.get()); memcpy(red_packet->data.data() + kHeaderLength + 1, packet.data.cdata(), - packet.length); - red_packet->length = kHeaderLength + 1 + packet.length; + packet.data.size()); 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 04b48cae0f..6acf3681eb 100644 --- a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc +++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc @@ -80,7 +80,8 @@ FlexfecHeaderReader::~FlexfecHeaderReader() = default; // retransmissions, and/or several protected SSRCs. bool FlexfecHeaderReader::ReadFecHeader( ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const { - if (fec_packet->pkt->length <= kBaseHeaderSize + kStreamSpecificHeaderSize) { + if (fec_packet->pkt->data.size() <= + kBaseHeaderSize + kStreamSpecificHeaderSize) { RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; return false; } @@ -121,7 +122,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->length < kHeaderSizes[0]) { + if (fec_packet->pkt->data.size() < kHeaderSizes[0]) { RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; return false; } @@ -138,7 +139,7 @@ bool FlexfecHeaderReader::ReadFecHeader( // is payload. packet_mask_size = kFlexfecPacketMaskSizes[0]; } else { - if (fec_packet->pkt->length < kHeaderSizes[1]) { + if (fec_packet->pkt->data.size() < kHeaderSizes[1]) { return false; } bool k_bit1 = (packet_mask[2] & 0x80) != 0; @@ -158,7 +159,7 @@ bool FlexfecHeaderReader::ReadFecHeader( // and the rest of the packet is payload. packet_mask_size = kFlexfecPacketMaskSizes[1]; } else { - if (fec_packet->pkt->length < kHeaderSizes[2]) { + if (fec_packet->pkt->data.size() < kHeaderSizes[2]) { RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; return false; } @@ -198,7 +199,7 @@ bool FlexfecHeaderReader::ReadFecHeader( // In FlexFEC, all media packets are protected in their entirety. fec_packet->protection_length = - fec_packet->pkt->length - fec_packet->fec_header_size; + fec_packet->pkt->data.size() - 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 7c1e4dbe47..1d86dd0eb4 100644 --- a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc +++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc @@ -77,9 +77,8 @@ 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->length; ++i) { + for (size_t i = 0; i < written_packet->data.size(); ++i) { written_packet->data[i] = i; // Actual content doesn't matter. } writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, @@ -93,7 +92,6 @@ 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; } @@ -110,7 +108,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->length - expected_fec_header_size, + EXPECT_EQ(read_packet.pkt->data.size() - expected_fec_header_size, read_packet.protection_length); // Ensure that the K-bits are removed and the packet mask has been packed. EXPECT_THAT( @@ -147,7 +145,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.length - expected_fec_header_size, + EXPECT_EQ(written_packet.data.size() - expected_fec_header_size, read_packet.protection_length); // Verify that the call to ReadFecHeader did normalize the packet masks. EXPECT_THAT(::testing::make_tuple( @@ -158,10 +156,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->length - read_packet.fec_header_size), + read_packet.pkt->data.size() - read_packet.fec_header_size), ::testing::ElementsAreArray( written_packet.data.cdata() + expected_fec_header_size, - written_packet.length - expected_fec_header_size)); + written_packet.data.size() - expected_fec_header_size)); } } // namespace @@ -185,7 +183,6 @@ 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)); @@ -217,7 +214,6 @@ 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)); @@ -256,7 +252,6 @@ 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)); @@ -274,8 +269,7 @@ TEST(FlexfecHeaderReaderTest, ReadPacketWithoutStreamSpecificHeaderShouldFail) { ReceivedFecPacket read_packet; read_packet.ssrc = kFlexfecSsrc; read_packet.pkt = std::move(written_packet); - read_packet.pkt->length = 12; - read_packet.pkt->data.SetSize(read_packet.pkt->length); + read_packet.pkt->data.SetSize(12); FlexfecHeaderReader reader; EXPECT_FALSE(reader.ReadFecHeader(&read_packet)); @@ -290,8 +284,7 @@ TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit0SetShouldFail) { ReceivedFecPacket read_packet; read_packet.ssrc = kFlexfecSsrc; read_packet.pkt = std::move(written_packet); - read_packet.pkt->length = 18; - read_packet.pkt->data.SetSize(read_packet.pkt->length); + read_packet.pkt->data.SetSize(18); FlexfecHeaderReader reader; EXPECT_FALSE(reader.ReadFecHeader(&read_packet)); @@ -307,8 +300,7 @@ TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit1SetShouldFail) { ReceivedFecPacket read_packet; read_packet.ssrc = kFlexfecSsrc; read_packet.pkt = std::move(written_packet); - read_packet.pkt->length = 20; - read_packet.pkt->data.SetSize(read_packet.pkt->length); + read_packet.pkt->data.SetSize(20); FlexfecHeaderReader reader; EXPECT_FALSE(reader.ReadFecHeader(&read_packet)); @@ -324,8 +316,7 @@ TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit2SetShouldFail) { ReceivedFecPacket read_packet; read_packet.ssrc = kFlexfecSsrc; read_packet.pkt = std::move(written_packet); - read_packet.pkt->length = 24; - read_packet.pkt->data.SetSize(read_packet.pkt->length); + read_packet.pkt->data.SetSize(24); FlexfecHeaderReader reader; EXPECT_FALSE(reader.ReadFecHeader(&read_packet)); @@ -336,9 +327,8 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit0Set) { constexpr uint8_t kFlexfecPacketMask[] = {0x88, 0x81}; constexpr uint8_t kUlpfecPacketMask[] = {0x11, 0x02}; Packet written_packet; - written_packet.length = kMediaPacketLength; - written_packet.data.SetSize(written_packet.length); - for (size_t i = 0; i < written_packet.length; ++i) { + written_packet.data.SetSize(kMediaPacketLength); + for (size_t i = 0; i < written_packet.data.size(); ++i) { written_packet.data[i] = i; } @@ -355,9 +345,8 @@ 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.length = kMediaPacketLength; - written_packet.data.SetSize(written_packet.length); - for (size_t i = 0; i < written_packet.length; ++i) { + written_packet.data.SetSize(kMediaPacketLength); + for (size_t i = 0; i < written_packet.data.size(); ++i) { written_packet.data[i] = i; } @@ -378,9 +367,8 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit2Set) { }; constexpr uint8_t kUlpfecPacketMask[] = {0x22, 0x22, 0x44, 0x44, 0x44, 0x41}; Packet written_packet; - written_packet.length = kMediaPacketLength; - written_packet.data.SetSize(written_packet.length); - for (size_t i = 0; i < written_packet.length; ++i) { + written_packet.data.SetSize(kMediaPacketLength); + for (size_t i = 0; i < written_packet.data.size(); ++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 da7bda16eb..ba09db9e1c 100644 --- a/modules/rtp_rtcp/source/flexfec_receiver.cc +++ b/modules/rtp_rtcp/source/flexfec_receiver.cc @@ -113,7 +113,6 @@ 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. @@ -129,7 +128,6 @@ 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; @@ -165,7 +163,8 @@ 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->length); + recovered_packet->pkt->data.cdata(), + recovered_packet->pkt->data.size()); // 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 1542e745fc..224fee6aa0 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()->length = 1; + fec_packets.front()->data.SetSize(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)->length)) - .With(Args<0, 1>( - ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); + OnRecoveredPacket(_, (*media_it)->data.size())) + .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), + (*media_it)->data.size()))); 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)->length)) - .With(Args<0, 1>( - ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); + OnRecoveredPacket(_, (*media_it)->data.size())) + .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), + (*media_it)->data.size()))); 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)->length)) - .With(Args<0, 1>( - ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); + OnRecoveredPacket(_, (*media_it)->data.size())) + .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), + (*media_it)->data.size()))); 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)->length)) - .With(Args<0, 1>( - ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); + OnRecoveredPacket(_, (*media_it)->data.size())) + .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), + (*media_it)->data.size()))); 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)->length)) - .With(Args<0, 1>( - ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); + OnRecoveredPacket(_, (*media_it)->data.size())) + .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), + (*media_it)->data.size()))); 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)->length)) - .With(Args<0, 1>( - ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); + OnRecoveredPacket(_, (*media_it)->data.size())) + .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), + (*media_it)->data.size()))); 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)->length)) + OnRecoveredPacket(_, (*media_packet1)->data.size())) .With(Args<0, 1>(ElementsAreArray((*media_packet1)->data.cdata(), - (*media_packet1)->length))); + (*media_packet1)->data.size()))); EXPECT_CALL(recovered_packet_receiver_, - OnRecoveredPacket(_, (*media_packet4)->length)) + OnRecoveredPacket(_, (*media_packet4)->data.size())) .With(Args<0, 1>(ElementsAreArray((*media_packet4)->data.cdata(), - (*media_packet4)->length))); + (*media_packet4)->data.size()))); // 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)->length)) - .With(Args<0, 1>( - ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length))); + OnRecoveredPacket(_, (*media_it)->data.size())) + .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(), + (*media_it)->data.size()))); 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 3fb51cd4c4..d35f4d6eed 100644 --- a/modules/rtp_rtcp/source/flexfec_sender.cc +++ b/modules/rtp_rtcp/source/flexfec_sender.cc @@ -153,8 +153,9 @@ std::vector> FlexfecSender::GetFecPackets() { } // RTP payload. - uint8_t* payload = fec_packet_to_send->AllocatePayload(fec_packet->length); - memcpy(payload, fec_packet->data.cdata(), fec_packet->length); + uint8_t* payload = + fec_packet_to_send->AllocatePayload(fec_packet->data.size()); + memcpy(payload, fec_packet->data.cdata(), fec_packet->data.size()); 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 bfb4c2d35b..a098c4ea56 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() : length(0), data(), ref_count_(0) {} +ForwardErrorCorrection::Packet::Packet() : data(0), 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->length < kRtpHeaderSize) { - RTC_LOG(LS_WARNING) << "Media packet " << media_packet->length + if (media_packet->data.size() < kRtpHeaderSize) { + RTC_LOG(LS_WARNING) << "Media packet " << media_packet->data.size() << " bytes " << "is smaller than RTP header."; return -1; } // Ensure the FEC packets will fit in a typical MTU. - if (media_packet->length + MaxPacketOverhead() + kTransportOverhead > + if (media_packet->data.size() + MaxPacketOverhead() + kTransportOverhead > IP_PACKET_SIZE) { - RTC_LOG(LS_WARNING) << "Media packet " << media_packet->length + RTC_LOG(LS_WARNING) << "Media packet " << media_packet->data.size() << " bytes " << "with overhead is larger than " << IP_PACKET_SIZE << " bytes."; @@ -153,7 +153,6 @@ 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]); } @@ -219,16 +218,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->length - kRtpHeaderSize; + size_t media_payload_length = + media_packet->data.size() - kRtpHeaderSize; - bool first_protected_packet = (fec_packet->length == 0); + bool first_protected_packet = (fec_packet->data.size() == 0); size_t fec_packet_length = fec_header_size + media_payload_length; - if (fec_packet_length > fec_packet->length) { + if (fec_packet_length > fec_packet->data.size()) { // 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->length = fec_packet_length; - fec_packet->data.SetSize(fec_packet->length); + fec_packet->data.SetSize(fec_packet_length); } if (first_protected_packet) { // Write P, X, CC, M, and PT recovery fields. @@ -261,7 +260,7 @@ void ForwardErrorCorrection::GenerateFecPayloads( pkt_mask_idx += media_pkt_idx / 8; media_pkt_idx %= 8; } - RTC_DCHECK_GT(fec_packet->length, 0) + RTC_DCHECK_GT(fec_packet->data.size(), 0) << "Packet mask is wrong or poorly designed."; } } @@ -378,7 +377,6 @@ 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(); @@ -538,7 +536,7 @@ bool ForwardErrorCorrection::StartPacketRecovery( const ReceivedFecPacket& fec_packet, RecoveredPacket* recovered_packet) { // Sanity check packet length. - if (fec_packet.pkt->length < fec_packet.fec_header_size) { + if (fec_packet.pkt->data.size() < fec_packet.fec_header_size) { RTC_LOG(LS_WARNING) << "The FEC packet is truncated: it does not contain enough room " << "for its own header."; @@ -585,7 +583,6 @@ 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], @@ -605,7 +602,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.length - kRtpHeaderSize); + src.data.size() - kRtpHeaderSize); dst->data[2] ^= src_payload_length_network_order[0]; dst->data[3] ^= src_payload_length_network_order[1]; @@ -642,7 +639,7 @@ bool ForwardErrorCorrection::RecoverPacket(const ReceivedFecPacket& fec_packet, } else { XorHeaders(*protected_packet->pkt, recovered_packet->pkt); XorPayloads(*protected_packet->pkt, - protected_packet->pkt->length - kRtpHeaderSize, + protected_packet->pkt->data.size() - 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 c00264707d..70ec3c63dd 100644 --- a/modules/rtp_rtcp/source/forward_error_correction.h +++ b/modules/rtp_rtcp/source/forward_error_correction.h @@ -53,7 +53,6 @@ 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 7d3b05420b..eb559f2bd9 100644 --- a/modules/rtp_rtcp/source/rtp_fec_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_fec_unittest.cc @@ -120,7 +120,6 @@ 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) { @@ -155,12 +154,12 @@ bool RtpFecTest::IsRecoveryComplete() { [](const std::unique_ptr& media_packet, const std::unique_ptr& recovered_packet) { - if (media_packet->length != recovered_packet->pkt->length) { + if (media_packet->data.size() != recovered_packet->pkt->data.size()) { return false; } if (memcmp(media_packet->data.cdata(), recovered_packet->pkt->data.cdata(), - media_packet->length) != 0) { + media_packet->data.size()) != 0) { return false; } return true; diff --git a/modules/rtp_rtcp/source/ulpfec_generator.cc b/modules/rtp_rtcp/source/ulpfec_generator.cc index 791fff9d91..92e65df187 100644 --- a/modules/rtp_rtcp/source/ulpfec_generator.cc +++ b/modules/rtp_rtcp/source/ulpfec_generator.cc @@ -148,7 +148,6 @@ 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. @@ -226,13 +225,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->length)); + kRedForFecHeaderLength + fec_packet->data.size())); 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->length); + red_packet->AssignPayload(fec_packet->data.data(), fec_packet->data.size()); 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 7086b13685..496fe73ad9 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->length - fec_header_size); + ByteWriter::WriteBigEndian( + &fec_packet->data[10], fec_packet->data.size() - 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 fb593b326b..19da2c87c0 100644 --- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc +++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc @@ -52,9 +52,8 @@ 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->length = kMediaPacketLength; - written_packet->data.SetSize(written_packet->length); - for (size_t i = 0; i < written_packet->length; ++i) { + written_packet->data.SetSize(kMediaPacketLength); + for (size_t i = 0; i < written_packet->data.size(); ++i) { written_packet->data[i] = i; // Actual content doesn't matter. } writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, @@ -68,7 +67,6 @@ 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; } @@ -84,7 +82,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.length - expected_fec_header_size, + EXPECT_EQ(written_packet.data.size() - expected_fec_header_size, read_packet.protection_length); EXPECT_EQ(0, memcmp(expected_packet_mask, &read_packet.pkt->data[read_packet.packet_mask_offset], @@ -92,7 +90,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.length - expected_fec_header_size)); + written_packet.data.size() - expected_fec_header_size)); } } // namespace @@ -109,7 +107,6 @@ 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)); @@ -134,7 +131,6 @@ 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)); @@ -150,9 +146,8 @@ TEST(UlpfecHeaderWriterTest, FinalizesSmallHeader) { const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear; auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd); Packet written_packet; - written_packet.length = kMediaPacketLength; - written_packet.data.SetSize(written_packet.length); - for (size_t i = 0; i < written_packet.length; ++i) { + written_packet.data.SetSize(kMediaPacketLength); + for (size_t i = 0; i < written_packet.data.size(); ++i) { written_packet.data[i] = i; } @@ -175,9 +170,8 @@ TEST(UlpfecHeaderWriterTest, FinalizesLargeHeader) { const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet; auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd); Packet written_packet; - written_packet.length = kMediaPacketLength; - written_packet.data.SetSize(written_packet.length); - for (size_t i = 0; i < written_packet.length; ++i) { + written_packet.data.SetSize(kMediaPacketLength); + for (size_t i = 0; i < written_packet.data.size(); ++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 b950cbd814..9088a0c072 100644 --- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc +++ b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc @@ -133,7 +133,6 @@ 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]); @@ -152,11 +151,9 @@ 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->length == 0) { + if (received_packet->pkt->data.size() == 0) { return 0; } @@ -185,7 +182,7 @@ int32_t UlpfecReceiverImpl::ProcessReceivedFec() { ForwardErrorCorrection::Packet* packet = received_packet->pkt; crit_sect_.Leave(); recovered_packet_callback_->OnRecoveredPacket(packet->data.data(), - packet->length); + packet->data.size()); crit_sect_.Enter(); // Create a packet with the buffer to modify it. RtpPacketReceived rtp_packet; @@ -213,7 +210,7 @@ int32_t UlpfecReceiverImpl::ProcessReceivedFec() { recovered_packet->returned = true; crit_sect_.Leave(); recovered_packet_callback_->OnRecoveredPacket(packet->data.data(), - packet->length); + packet->data.size()); crit_sect_.Enter(); } diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc index bbe616f059..40bf0a5990 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->length, kFecPayloadType)); + red_packet->data.size(), 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->length, kFecPayloadType)); + red_packet->data.size(), kFecPayloadType)); } void UlpfecReceiverTest::VerifyReconstructedMediaPacket( @@ -144,8 +144,10 @@ 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.length)) - .With(Args<0, 1>(ElementsAreArray(packet.data.cdata(), packet.length))) + EXPECT_CALL(recovered_packet_receiver_, + OnRecoveredPacket(_, packet.data.size())) + .With( + Args<0, 1>(ElementsAreArray(packet.data.cdata(), packet.data.size()))) .Times(times); } diff --git a/modules/rtp_rtcp/test/testFec/test_fec.cc b/modules/rtp_rtcp/test/testFec/test_fec.cc index 434d3ac4fb..ff586e95fc 100644 --- a/modules/rtp_rtcp/test/testFec/test_fec.cc +++ b/modules/rtp_rtcp/test/testFec/test_fec.cc @@ -71,7 +71,6 @@ 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(); @@ -251,9 +250,8 @@ 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->length = - random.Rand(kMinPacketSize, kMaxPacketSize); - media_packet->data.SetSize(media_packet->length); + media_packet->data.SetSize( + random.Rand(kMinPacketSize, kMaxPacketSize)); // Generate random values for the first 2 bytes. media_packet->data[0] = random.Rand(); @@ -282,7 +280,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->length; ++j) { + for (size_t j = 12; j < media_packet->data.size(); ++j) { media_packet->data[j] = random.Rand(); } media_packet_list.push_back(std::move(media_packet)); @@ -311,7 +309,6 @@ 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 = @@ -332,7 +329,6 @@ 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; @@ -421,12 +417,13 @@ void RunTest(bool use_flexfec) { ForwardErrorCorrection::RecoveredPacket* recovered_packet = recovered_packet_list_it->get(); - ASSERT_EQ(recovered_packet->pkt->length, media_packet->length) + ASSERT_EQ(recovered_packet->pkt->data.size(), + media_packet->data.size()) << "Recovered packet length not identical to original " << "media packet"; - ASSERT_EQ( - 0, memcmp(recovered_packet->pkt->data.cdata(), - media_packet->data.cdata(), media_packet->length)) + ASSERT_EQ(0, memcmp(recovered_packet->pkt->data.cdata(), + media_packet->data.cdata(), + media_packet->data.size())) << "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 2f4c498edb..4eb9a0503d 100644 --- a/test/fuzzers/flexfec_header_reader_fuzzer.cc +++ b/test/fuzzers/flexfec_header_reader_fuzzer.cc @@ -27,7 +27,6 @@ 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 3e674cda16..6c880a3a8e 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->length = kPacketSize; + recovered_packet->pkt->data.SetSize(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->length = kPacketSize; + received_packet.pkt->data.SetSize(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 cf211f12ea..f3f6581481 100644 --- a/test/fuzzers/ulpfec_header_reader_fuzzer.cc +++ b/test/fuzzers/ulpfec_header_reader_fuzzer.cc @@ -27,7 +27,6 @@ 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);