admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup FEC code after refactoring

Browse Source 
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 <ilnik@webrtc.org>
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28540}
This commit is contained in:
Ilya Nikolaevskiy 2019-07-10 11:28:51 +02:00 committed by Commit Bot
parent 7325bc3917
commit 4e5a41a086
18 changed files with 112 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
modules/rtp_rtcp/source/fec_test_helper.cc
View File

@ -53,8 +53,8 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
for (int i = 0; i < num_media_packets; ++i) {
std::unique_ptr<ForwardErrorCorrection::Packet> 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<uint8_t>();
@ -80,7 +80,7 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
webrtc::ByteWriter<uint32_t>::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<uint8_t>();
seq_num++;
media_packets.push_back(std::move(media_packet));
@ -124,8 +124,7 @@ std::unique_ptr<AugmentedPacket> 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<AugmentedPacket> FlexfecPacketGenerator::BuildFlexfecPacket(
const ForwardErrorCorrection::Packet& packet) {
RTC_DCHECK_LE(packet.length,
RTC_DCHECK_LE(packet.data.size(),
static_cast<size_t>(IP_PACKET_SIZE - kRtpHeaderSize));
RTPHeader header;
@ -170,11 +169,10 @@ std::unique_ptr<AugmentedPacket> FlexfecPacketGenerator::BuildFlexfecPacket(
std::unique_ptr<AugmentedPacket> 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<AugmentedPacket> 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<AugmentedPacket> UlpfecPacketGenerator::BuildUlpfecRedPacket(
// Create a fake media packet to get a correct header. 1 byte RED header.
++num_packets_;
std::unique_ptr<AugmentedPacket> 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;
}

11
modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
View File

@ -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;
}

42
modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc
View File

@ -77,9 +77,8 @@ rtc::scoped_refptr<Packet> WriteHeader(const uint8_t* packet_mask,
size_t packet_mask_size) {
FlexfecHeaderWriter writer;
rtc::scoped_refptr<Packet> 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<ReceivedFecPacket> ReadHeader(const Packet& written_packet) {
read_packet->ssrc = kFlexfecSsrc;
read_packet->pkt = rtc::scoped_refptr<Packet>(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<Packet>(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<Packet>(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<Packet>(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;
}

5
modules/rtp_rtcp/source/flexfec_receiver.cc
View File

@ -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) {

52
modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
View File

@ -149,7 +149,7 @@ TEST_F(FlexfecReceiverTest, FailsOnTruncatedFecPacket) {
std::list<Packet*> 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<ForwardErrorCorrection::ReceivedPacket> 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.

5
modules/rtp_rtcp/source/flexfec_sender.cc
View File

@ -153,8 +153,9 @@ std::vector<std::unique_ptr<RtpPacketToSend>> 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));
}

31
modules/rtp_rtcp/source/forward_error_correction.cc
View File

@ -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<uint16_t>::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<uint16_t>::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);
}
}

1
modules/rtp_rtcp/source/forward_error_correction.h
View File

@ -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:

5
modules/rtp_rtcp/source/rtp_fec_unittest.cc
View File

@ -120,7 +120,6 @@ void RtpFecTest<ForwardErrorCorrectionType>::ReceivedPackets(
std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> 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<ForwardErrorCorrectionType>::IsRecoveryComplete() {
[](const std::unique_ptr<ForwardErrorCorrection::Packet>& media_packet,
const std::unique_ptr<ForwardErrorCorrection::RecoveredPacket>&
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;

5
modules/rtp_rtcp/source/ulpfec_generator.cc
View File

@ -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<std::unique_ptr<RedPacket>> UlpfecGenerator::GetUlpfecPacketsAsRed(
RTC_DCHECK_GT(last_media_packet_rtp_header_length_, 0);
std::unique_ptr<RedPacket> 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));
}

4
modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
View File

@ -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<uint16_t>::WriteBigEndian(&fec_packet->data[10],
fec_packet->length - fec_header_size);
ByteWriter<uint16_t>::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);
}

22
modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
View File

@ -52,9 +52,8 @@ std::unique_ptr<Packet> WriteHeader(const uint8_t* packet_mask,
size_t packet_mask_size) {
UlpfecHeaderWriter writer;
std::unique_ptr<Packet> 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<ReceivedFecPacket> ReadHeader(const Packet& written_packet) {
read_packet->ssrc = kMediaSsrc;
read_packet->pkt = rtc::scoped_refptr<Packet>(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<Packet>(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<Packet>(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;
}

9
modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
View File

@ -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<uint32_t>::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();
}

10
modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
View File

@ -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);
}

19
modules/rtp_rtcp/test/testFec/test_fec.cc
View File

@ -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<float>();
@ -251,9 +250,8 @@ void RunTest(bool use_flexfec) {
const uint32_t kMinPacketSize = 12;
const uint32_t kMaxPacketSize = static_cast<uint32_t>(
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<uint8_t>();
@ -282,7 +280,7 @@ void RunTest(bool use_flexfec) {
ByteWriter<uint32_t>::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<uint8_t>();
}
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();

1
test/fuzzers/flexfec_header_reader_fuzzer.cc
View File

@ -27,7 +27,6 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
std::min(size, static_cast<size_t>(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);

4
test/fuzzers/forward_error_correction_fuzzer.cc
View File

@ -56,7 +56,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
new ForwardErrorCorrection::RecoveredPacket();
recovered_packet->pkt = rtc::scoped_refptr<ForwardErrorCorrection::Packet>(
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<ForwardErrorCorrection::Packet>(
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;

1
test/fuzzers/ulpfec_header_reader_fuzzer.cc
View File

@ -27,7 +27,6 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
std::min(size, static_cast<size_t>(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);