commit 141682b66e42a424b4870b2a934db1488304578d
parent c541a5e7973c6c95075a7f4589da9c85e0eb3681
Author: Michael Froman <mfroman@mozilla.com>
Date: Wed, 15 Oct 2025 11:28:36 -0500
Bug 1993083 - Vendor libwebrtc from 8d884426cc
Upstream commit: https://webrtc.googlesource.com/src/+/8d884426cc2fc6b44a4315ed4917035d218992d9
In fec test helpers remove AugmentedPacket type
Use RtpPacket derived classes instead as most callers already expect one
of those
Bug: webrtc:42225366
Change-Id: I719a0133608d86ba5ff2f2a93be8efa46ee159d3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/402382
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#45249}
Diffstat:
8 files changed, 151 insertions(+), 212 deletions(-)
diff --git a/third_party/libwebrtc/README.mozilla.last-vendor b/third_party/libwebrtc/README.mozilla.last-vendor
@@ -1,4 +1,4 @@
# ./mach python dom/media/webrtc/third_party_build/vendor-libwebrtc.py --from-local /home/mfroman/mozilla/elm/.moz-fast-forward/moz-libwebrtc --commit mozpatches libwebrtc
-libwebrtc updated from /home/mfroman/mozilla/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-10-15T16:27:25.406441+00:00.
+libwebrtc updated from /home/mfroman/mozilla/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-10-15T16:28:27.038112+00:00.
# base of lastest vendoring
-75c4772c98
+8d884426cc
diff --git a/third_party/libwebrtc/modules/rtp_rtcp/BUILD.gn b/third_party/libwebrtc/modules/rtp_rtcp/BUILD.gn
@@ -498,7 +498,6 @@ rtc_library("fec_test_helper") {
deps = [
":rtp_rtcp",
":rtp_rtcp_format",
- "../../api:rtp_headers",
"../../rtc_base:checks",
"../../rtc_base:copy_on_write_buffer",
"../../rtc_base:random",
@@ -706,7 +705,7 @@ if (rtc_include_tests) {
"../../api:scoped_refptr",
"../../api:time_controller",
"../../api:transport_api",
- "../../api/environment:environment",
+ "../../api/environment",
"../../api/environment:environment_factory",
"../../api/rtc_event_log",
"../../api/task_queue",
@@ -759,7 +758,7 @@ if (rtc_include_tests) {
"../../test:rtp_test_utils",
"../../test:run_loop",
"../../test:test_support",
- "../../test/time_controller:time_controller",
+ "../../test/time_controller",
"../audio_coding:audio_coding_module_typedefs",
"../video_coding:codec_globals_headers",
"//testing/gtest",
diff --git a/third_party/libwebrtc/modules/rtp_rtcp/source/fec_test_helper.cc b/third_party/libwebrtc/modules/rtp_rtcp/source/fec_test_helper.cc
@@ -16,7 +16,6 @@
#include <memory>
#include <utility>
-#include "api/rtp_headers.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/byte_io.h"
#include "modules/rtp_rtcp/source/forward_error_correction.h"
@@ -31,8 +30,6 @@ namespace fec {
namespace {
-constexpr uint8_t kRtpMarkerBitMask = 0x80;
-
constexpr uint8_t kFecPayloadType = 96;
constexpr uint8_t kRedPayloadType = 97;
constexpr uint8_t kVp8PayloadType = 120;
@@ -125,37 +122,23 @@ uint16_t AugmentedPacketGenerator::NextPacketSeqNum() {
return ++seq_num_;
}
-std::unique_ptr<AugmentedPacket> AugmentedPacketGenerator::NextPacket(
- size_t offset,
- size_t length) {
- std::unique_ptr<AugmentedPacket> packet(new AugmentedPacket());
-
- packet->data.SetSize(length + kRtpHeaderSize);
- uint8_t* data = packet->data.MutableData();
+void AugmentedPacketGenerator::NextPacket(size_t offset,
+ size_t length,
+ RtpPacket& packet) {
+ // Write Rtp Header
+ packet.SetMarker(num_packets_ == 1);
+ packet.SetPayloadType(kVp8PayloadType);
+ packet.SetSequenceNumber(seq_num_);
+ packet.SetTimestamp(timestamp_);
+ packet.SetSsrc(ssrc_);
+
+ // Generate RTP payload.
+ uint8_t* data = packet.AllocatePayload(length);
for (size_t i = 0; i < length; ++i)
- data[i + kRtpHeaderSize] = offset + i;
- packet->data.SetSize(length + kRtpHeaderSize);
- packet->header.headerLength = kRtpHeaderSize;
- packet->header.markerBit = (num_packets_ == 1);
- packet->header.payloadType = kVp8PayloadType;
- packet->header.sequenceNumber = seq_num_;
- packet->header.timestamp = timestamp_;
- packet->header.ssrc = ssrc_;
- WriteRtpHeader(packet->header, data);
+ data[i] = offset + i;
+
++seq_num_;
--num_packets_;
-
- return packet;
-}
-
-void AugmentedPacketGenerator::WriteRtpHeader(const RTPHeader& header,
- uint8_t* data) {
- data[0] = 0x80; // Version 2.
- data[1] = header.payloadType;
- data[1] |= (header.markerBit ? kRtpMarkerBitMask : 0);
- ByteWriter<uint16_t>::WriteBigEndian(data + 2, header.sequenceNumber);
- ByteWriter<uint32_t>::WriteBigEndian(data + 4, header.timestamp);
- ByteWriter<uint32_t>::WriteBigEndian(data + 8, header.ssrc);
}
FlexfecPacketGenerator::FlexfecPacketGenerator(uint32_t media_ssrc,
@@ -165,48 +148,37 @@ FlexfecPacketGenerator::FlexfecPacketGenerator(uint32_t media_ssrc,
flexfec_seq_num_(0),
flexfec_timestamp_(0) {}
-std::unique_ptr<AugmentedPacket> FlexfecPacketGenerator::BuildFlexfecPacket(
+RtpPacketReceived FlexfecPacketGenerator::BuildFlexfecPacket(
const ForwardErrorCorrection::Packet& packet) {
- RTC_DCHECK_LE(packet.data.size(),
- static_cast<size_t>(IP_PACKET_SIZE - kRtpHeaderSize));
+ RtpPacketReceived flexfec_packet;
- RTPHeader header;
- header.sequenceNumber = flexfec_seq_num_;
+ flexfec_packet.SetSequenceNumber(flexfec_seq_num_);
++flexfec_seq_num_;
- header.timestamp = flexfec_timestamp_;
+ flexfec_packet.SetTimestamp(flexfec_timestamp_);
flexfec_timestamp_ += kPacketTimestampIncrement;
- header.ssrc = flexfec_ssrc_;
-
- std::unique_ptr<AugmentedPacket> packet_with_rtp_header(
- new AugmentedPacket());
- packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.data.size());
- WriteRtpHeader(header, packet_with_rtp_header->data.MutableData());
- memcpy(packet_with_rtp_header->data.MutableData() + kRtpHeaderSize,
- packet.data.cdata(), packet.data.size());
+ flexfec_packet.SetSsrc(flexfec_ssrc_);
+ flexfec_packet.SetPayload(packet.data);
- return packet_with_rtp_header;
+ return flexfec_packet;
}
UlpfecPacketGenerator::UlpfecPacketGenerator(uint32_t ssrc)
: AugmentedPacketGenerator(ssrc) {}
RtpPacketReceived UlpfecPacketGenerator::BuildMediaRedPacket(
- const AugmentedPacket& packet,
+ const RtpPacket& packet,
bool is_recovered) {
- // Create a temporary buffer used to wrap the media packet in RED.
- CopyOnWriteBuffer red_buffer;
- const size_t kHeaderLength = packet.header.headerLength;
+ RtpPacketReceived red_packet;
// Append header.
- red_buffer.SetData(packet.data.data(), kHeaderLength);
+ red_packet.CopyHeaderFrom(packet);
// Find payload type and add it as RED header.
- uint8_t media_payload_type = red_buffer[1] & 0x7F;
- red_buffer.AppendData({media_payload_type});
+ uint8_t* rtp_payload = red_packet.SetPayloadSize(1 + packet.payload_size());
+ rtp_payload[0] = packet.PayloadType();
// Append rest of payload/padding.
- red_buffer.AppendData(
- packet.data.Slice(kHeaderLength, packet.data.size() - kHeaderLength));
+ std::memcpy(rtp_payload + 1, packet.payload().data(),
+ packet.payload().size());
+ red_packet.SetPadding(packet.padding_size());
- RtpPacketReceived red_packet;
- RTC_CHECK(red_packet.Parse(std::move(red_buffer)));
red_packet.SetPayloadType(kRedPayloadType);
red_packet.set_recovered(is_recovered);
@@ -217,11 +189,9 @@ RtpPacketReceived UlpfecPacketGenerator::BuildUlpfecRedPacket(
const ForwardErrorCorrection::Packet& packet) {
// Create a fake media packet to get a correct header. 1 byte RED header.
++num_packets_;
- std::unique_ptr<AugmentedPacket> fake_packet =
- NextPacket(0, packet.data.size() + 1);
+ RtpPacketReceived red_packet =
+ NextPacket<RtpPacketReceived>(0, packet.data.size() + 1);
- RtpPacketReceived red_packet;
- red_packet.Parse(fake_packet->data);
red_packet.SetMarker(false);
uint8_t* rtp_payload = red_packet.AllocatePayload(packet.data.size() + 1);
rtp_payload[0] = kFecPayloadType;
diff --git a/third_party/libwebrtc/modules/rtp_rtcp/source/fec_test_helper.h b/third_party/libwebrtc/modules/rtp_rtcp/source/fec_test_helper.h
@@ -13,10 +13,9 @@
#include <cstddef>
#include <cstdint>
-#include <memory>
-#include "api/rtp_headers.h"
#include "modules/rtp_rtcp/source/forward_error_correction.h"
+#include "modules/rtp_rtcp/source/rtp_packet.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/random.h"
@@ -24,10 +23,6 @@ namespace webrtc {
namespace test {
namespace fec {
-struct AugmentedPacket : public ForwardErrorCorrection::Packet {
- RTPHeader header;
-};
-
// TODO(brandtr): Consider merging MediaPacketGenerator and
// AugmentedPacketGenerator into a single class, since their functionality is
// similar.
@@ -72,16 +67,20 @@ class AugmentedPacketGenerator {
uint16_t NextPacketSeqNum();
// Return the next packet in the current frame.
- std::unique_ptr<AugmentedPacket> NextPacket(size_t offset, size_t length);
+ template <typename T = RtpPacket>
+ T NextPacket(size_t offset, size_t length) {
+ T rtp_packet(/*extensions=*/nullptr);
+ NextPacket(offset, length, rtp_packet);
+ return rtp_packet;
+ }
protected:
- // Given `header`, writes the appropriate RTP header fields in `data`.
- static void WriteRtpHeader(const RTPHeader& header, uint8_t* data);
-
// Number of packets left to generate, in the current frame.
size_t num_packets_;
private:
+ void NextPacket(size_t offset, size_t length, RtpPacket& packet);
+
uint32_t ssrc_;
uint16_t seq_num_;
uint32_t timestamp_;
@@ -94,7 +93,7 @@ class FlexfecPacketGenerator : public AugmentedPacketGenerator {
// Creates a new AugmentedPacket (with RTP headers) from a
// FlexFEC packet (without RTP headers).
- std::unique_ptr<AugmentedPacket> BuildFlexfecPacket(
+ RtpPacketReceived BuildFlexfecPacket(
const ForwardErrorCorrection::Packet& packet);
private:
@@ -110,7 +109,7 @@ class UlpfecPacketGenerator : public AugmentedPacketGenerator {
explicit UlpfecPacketGenerator(uint32_t ssrc);
// Creates a new RtpPacket with the RED header added to the packet.
- static RtpPacketReceived BuildMediaRedPacket(const AugmentedPacket& packet,
+ static RtpPacketReceived BuildMediaRedPacket(const RtpPacket& packet,
bool is_recovered);
// Creates a new RtpPacket with FEC payload and RED header. Does this by
diff --git a/third_party/libwebrtc/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc b/third_party/libwebrtc/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
@@ -95,8 +95,9 @@ void FlexfecReceiverTest::PacketizeFrame(size_t num_media_packets,
PacketList* media_packets) {
packet_generator_.NewFrame(num_media_packets);
for (size_t i = 0; i < num_media_packets; ++i) {
- std::unique_ptr<Packet> next_packet(
- packet_generator_.NextPacket(frame_offset + i, kPayloadLength));
+ auto next_packet = std::make_unique<Packet>();
+ next_packet->data =
+ packet_generator_.NextPacket(frame_offset + i, kPayloadLength).Buffer();
media_packets->push_back(std::move(next_packet));
}
}
@@ -119,11 +120,11 @@ std::list<Packet*> FlexfecReceiverTest::EncodeFec(
TEST_F(FlexfecReceiverTest, ReceivesMediaPacket) {
packet_generator_.NewFrame(1);
- std::unique_ptr<Packet> media_packet(
- packet_generator_.NextPacket(0, kPayloadLength));
+ RtpPacketReceived media_packet =
+ packet_generator_.NextPacket<RtpPacketReceived>(0, kPayloadLength);
std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> received_packet =
- receiver_.AddReceivedPacket(ParsePacket(*media_packet));
+ receiver_.AddReceivedPacket(media_packet);
ASSERT_TRUE(received_packet);
receiver_.ProcessReceivedPacket(*received_packet);
}
@@ -142,7 +143,7 @@ TEST_F(FlexfecReceiverTest, ReceivesMediaAndFecPackets) {
receiver_.AddReceivedPacket(ParsePacket(*media_packet));
ASSERT_TRUE(received_packet);
receiver_.ProcessReceivedPacket(*received_packet);
- received_packet = receiver_.AddReceivedPacket(ParsePacket(*fec_packet));
+ received_packet = receiver_.AddReceivedPacket(fec_packet);
ASSERT_TRUE(received_packet);
receiver_.ProcessReceivedPacket(*received_packet);
}
@@ -163,7 +164,7 @@ TEST_F(FlexfecReceiverTest, FailsOnTruncatedFecPacket) {
receiver_.AddReceivedPacket(ParsePacket(*media_packet));
ASSERT_TRUE(received_packet);
receiver_.ProcessReceivedPacket(*received_packet);
- EXPECT_FALSE(receiver_.AddReceivedPacket(ParsePacket(*fec_packet)));
+ EXPECT_FALSE(receiver_.AddReceivedPacket(fec_packet));
}
TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) {
@@ -191,16 +192,13 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) {
const auto& media_packet = media_packets.front();
auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
// Corrupt the SSRC.
- fec_packet->data.MutableData()[8] = 4;
- fec_packet->data.MutableData()[9] = 5;
- fec_packet->data.MutableData()[10] = 6;
- fec_packet->data.MutableData()[11] = 7;
+ fec_packet.SetSsrc(0x04050607);
std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> received_packet =
receiver_.AddReceivedPacket(ParsePacket(*media_packet));
ASSERT_TRUE(received_packet);
receiver_.ProcessReceivedPacket(*received_packet);
- EXPECT_FALSE(receiver_.AddReceivedPacket(ParsePacket(*fec_packet)));
+ EXPECT_FALSE(receiver_.AddReceivedPacket(fec_packet));
}
TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) {
@@ -221,10 +219,10 @@ TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) {
// Receive FEC packet.
auto* fec_packet = fec_packets.front();
- std::unique_ptr<Packet> packet_with_rtp_header =
+ RtpPacketReceived packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(*fec_packet);
std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> received_packet =
- receiver_.AddReceivedPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.AddReceivedPacket(packet_with_rtp_header);
ASSERT_TRUE(received_packet);
receiver_.ProcessReceivedPacket(*received_packet);
}
@@ -243,13 +241,13 @@ TEST_F(FlexfecReceiverTest, RecoversFromSingleMediaLoss) {
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> packet_with_rtp_header =
+ RtpPacketReceived packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(**fec_it);
media_it++;
EXPECT_CALL(recovered_packet_receiver_,
OnRecoveredPacket(
Property(&RtpPacketReceived::Buffer, Eq((*media_it)->data))));
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_with_rtp_header);
}
TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
@@ -264,13 +262,13 @@ TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
// Receive first FEC packet and recover first lost media packet.
auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> packet_with_rtp_header =
+ RtpPacketReceived packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(**fec_it);
auto media_it = media_packets.begin();
EXPECT_CALL(recovered_packet_receiver_,
OnRecoveredPacket(
Property(&RtpPacketReceived::Buffer, Eq((*media_it)->data))));
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_with_rtp_header);
// Receive second FEC packet and recover second lost media packet.
fec_it++;
@@ -280,7 +278,7 @@ TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
OnRecoveredPacket(
Property(&RtpPacketReceived::Buffer, Eq((*media_it)->data))));
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_with_rtp_header);
}
TEST_F(FlexfecReceiverTest, DoesNotRecoverFromMediaAndFecLoss) {
@@ -312,16 +310,16 @@ TEST_F(FlexfecReceiverTest, DoesNotCallbackTwice) {
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> packet_with_rtp_header =
+ RtpPacketReceived packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(**fec_it);
media_it++;
EXPECT_CALL(recovered_packet_receiver_,
OnRecoveredPacket(
Property(&RtpPacketReceived::Buffer, Eq((*media_it)->data))));
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_with_rtp_header);
// Receive the FEC packet again, but do not call back.
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_with_rtp_header);
// Receive the first media packet again, but do not call back.
media_it = media_packets.begin();
@@ -361,7 +359,7 @@ TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) {
// Receive all FEC packets.
media_it = media_packets.begin();
for (const auto* fec_packet : fec_packets) {
- std::unique_ptr<Packet> fec_packet_with_rtp_header =
+ RtpPacketReceived fec_packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(*fec_packet);
++media_it;
if (media_it == media_packets.end()) {
@@ -370,7 +368,7 @@ TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) {
EXPECT_CALL(recovered_packet_receiver_,
OnRecoveredPacket(Property(&RtpPacketReceived::Buffer,
Eq((*media_it)->data))));
- receiver_.OnRtpPacket(ParsePacket(*fec_packet_with_rtp_header));
+ receiver_.OnRtpPacket(fec_packet_with_rtp_header);
++media_it;
}
}
@@ -404,13 +402,13 @@ TEST_F(FlexfecReceiverTest, DelayedFecPacketDoesHelp) {
// Receive FEC packet and recover first media packet.
auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> packet_with_rtp_header =
+ RtpPacketReceived packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(**fec_it);
media_it = media_packets.begin();
EXPECT_CALL(recovered_packet_receiver_,
OnRecoveredPacket(
Property(&RtpPacketReceived::Buffer, Eq((*media_it)->data))));
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_with_rtp_header);
}
TEST_F(FlexfecReceiverTest, TooDelayedFecPacketDoesNotHelp) {
@@ -443,9 +441,9 @@ TEST_F(FlexfecReceiverTest, TooDelayedFecPacketDoesNotHelp) {
// Receive FEC packet.
auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> packet_with_rtp_header =
+ RtpPacketReceived packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(**fec_it);
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_with_rtp_header);
// Do not expect a call back.
}
@@ -490,7 +488,7 @@ TEST_F(FlexfecReceiverTest, SurvivesOldRecoveredPacketBeingReinserted) {
PacketizeFrame(1, 0, &protected_media_packet);
const std::list<Packet*> fec_packets = EncodeFec(protected_media_packet, 1);
EXPECT_EQ(1u, fec_packets.size());
- std::unique_ptr<Packet> fec_packet_with_rtp_header =
+ RtpPacketReceived fec_packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(*fec_packets.front());
// Lose some packets, thus introducing a sequence number gap.
@@ -507,7 +505,7 @@ TEST_F(FlexfecReceiverTest, SurvivesOldRecoveredPacketBeingReinserted) {
}
// Receive delayed FEC packet.
- receiver.OnRtpPacket(ParsePacket(*fec_packet_with_rtp_header));
+ receiver.OnRtpPacket(fec_packet_with_rtp_header);
// Expect no crash.
}
@@ -541,12 +539,8 @@ TEST_F(FlexfecReceiverTest, RecoversWithMediaPacketsOutOfOrder) {
OnRecoveredPacket(Property(&RtpPacketReceived::Buffer,
Eq((*media_packet4)->data))));
// Add FEC packets.
- auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> packet_with_rtp_header;
- while (fec_it != fec_packets.end()) {
- packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(**fec_it);
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
- ++fec_it;
+ for (Packet* fec_packet : fec_packets) {
+ receiver_.OnRtpPacket(packet_generator_.BuildFlexfecPacket(*fec_packet));
}
}
@@ -606,9 +600,7 @@ TEST_F(FlexfecReceiverTest, RecoveryCallbackDoesNotLoopInfinitely) {
// Receive FEC packet and verify that a packet was recovered.
auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> packet_with_rtp_header =
- packet_generator_.BuildFlexfecPacket(**fec_it);
- receiver.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver.OnRtpPacket(packet_generator_.BuildFlexfecPacket(**fec_it));
EXPECT_TRUE(loopback_recovered_packet_receiver.DidReceiveCallback());
EXPECT_FALSE(loopback_recovered_packet_receiver.DeepRecursion());
}
@@ -627,13 +619,13 @@ TEST_F(FlexfecReceiverTest, CalculatesNumberOfPackets) {
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> packet_with_rtp_header =
+ RtpPacketReceived packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(**fec_it);
media_it++;
EXPECT_CALL(recovered_packet_receiver_,
OnRecoveredPacket(
Property(&RtpPacketReceived::Buffer, Eq((*media_it)->data))));
- receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_with_rtp_header);
// Check stats calculations.
FecPacketCounter packet_counter = receiver_.GetPacketCounter();
@@ -680,9 +672,7 @@ TEST_F(FlexfecReceiverTest, DoesNotDecodeWrappedMediaSequenceUsingOldFec) {
// expect no recovery callback since it is delayed from first frame
// by more than 192 packets.
auto fec_it = fec_packets.begin();
- std::unique_ptr<Packet> fec_packet_with_rtp_header =
- packet_generator_.BuildFlexfecPacket(**fec_it);
- receiver_.OnRtpPacket(ParsePacket(*fec_packet_with_rtp_header));
+ receiver_.OnRtpPacket(packet_generator_.BuildFlexfecPacket(**fec_it));
// Receive remaining media packets.
// NOTE: Because we sent enough to simulate wrap around, sequence 0 is
diff --git a/third_party/libwebrtc/modules/rtp_rtcp/source/flexfec_sender_unittest.cc b/third_party/libwebrtc/modules/rtp_rtcp/source/flexfec_sender_unittest.cc
@@ -34,7 +34,6 @@ namespace webrtc {
namespace {
-using test::fec::AugmentedPacket;
using test::fec::AugmentedPacketGenerator;
constexpr int kFlexfecPayloadType = 123;
@@ -74,10 +73,8 @@ std::unique_ptr<RtpPacketToSend> GenerateSingleFlexfecPacket(
AugmentedPacketGenerator packet_generator(kMediaSsrc);
packet_generator.NewFrame(kNumPackets);
for (size_t i = 0; i < kNumPackets; ++i) {
- std::unique_ptr<AugmentedPacket> packet =
- packet_generator.NextPacket(i, kPayloadLength);
- RtpPacketToSend rtp_packet(nullptr); // No header extensions.
- rtp_packet.Parse(packet->data);
+ RtpPacketToSend rtp_packet =
+ packet_generator.NextPacket<RtpPacketToSend>(i, kPayloadLength);
sender->AddPacketAndGenerateFec(rtp_packet);
}
std::vector<std::unique_ptr<RtpPacketToSend>> fec_packets =
@@ -146,10 +143,8 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithOneFecPacket) {
for (size_t i = 0; i < kNumFrames; ++i) {
packet_generator.NewFrame(kNumPacketsPerFrame);
for (size_t j = 0; j < kNumPacketsPerFrame; ++j) {
- std::unique_ptr<AugmentedPacket> packet =
- packet_generator.NextPacket(i, kPayloadLength);
- RtpPacketToSend rtp_packet(nullptr);
- rtp_packet.Parse(packet->data);
+ RtpPacketToSend rtp_packet =
+ packet_generator.NextPacket<RtpPacketToSend>(i, kPayloadLength);
sender.AddPacketAndGenerateFec(rtp_packet);
}
}
@@ -186,10 +181,8 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithTwoFecPackets) {
for (size_t i = 0; i < kNumFrames; ++i) {
packet_generator.NewFrame(kNumPacketsPerFrame);
for (size_t j = 0; j < kNumPacketsPerFrame; ++j) {
- std::unique_ptr<AugmentedPacket> packet =
- packet_generator.NextPacket(i, kPayloadLength);
- RtpPacketToSend rtp_packet(nullptr);
- rtp_packet.Parse(packet->data);
+ RtpPacketToSend rtp_packet =
+ packet_generator.NextPacket<RtpPacketToSend>(i, kPayloadLength);
sender.AddPacketAndGenerateFec(rtp_packet);
}
std::vector<std::unique_ptr<RtpPacketToSend>> fec_packets =
diff --git a/third_party/libwebrtc/modules/rtp_rtcp/source/ulpfec_generator_unittest.cc b/third_party/libwebrtc/modules/rtp_rtcp/source/ulpfec_generator_unittest.cc
@@ -29,7 +29,6 @@
namespace webrtc {
namespace {
-using test::fec::AugmentedPacket;
using test::fec::AugmentedPacketGenerator;
constexpr int kFecPayloadType = 96;
@@ -122,12 +121,10 @@ TEST_F(UlpfecGeneratorTest, OneFrameFec) {
ulpfec_generator_.SetProtectionParameters(params, params);
uint32_t last_timestamp = 0;
for (size_t i = 0; i < kNumPackets; ++i) {
- std::unique_ptr<AugmentedPacket> packet =
- packet_generator_.NextPacket(i, 10);
- RtpPacketToSend rtp_packet(nullptr);
- EXPECT_TRUE(rtp_packet.Parse(packet->data.data(), packet->data.size()));
+ RtpPacketToSend rtp_packet =
+ packet_generator_.NextPacket<RtpPacketToSend>(i, 10);
ulpfec_generator_.AddPacketAndGenerateFec(rtp_packet);
- last_timestamp = packet->header.timestamp;
+ last_timestamp = rtp_packet.Timestamp();
}
std::vector<std::unique_ptr<RtpPacketToSend>> fec_packets =
ulpfec_generator_.GetFecPackets();
@@ -160,12 +157,11 @@ TEST_F(UlpfecGeneratorTest, TwoFrameFec) {
for (size_t i = 0; i < kNumFrames; ++i) {
packet_generator_.NewFrame(kNumPackets);
for (size_t j = 0; j < kNumPackets; ++j) {
- std::unique_ptr<AugmentedPacket> packet =
- packet_generator_.NextPacket(i * kNumPackets + j, 10);
- RtpPacketToSend rtp_packet(nullptr);
- EXPECT_TRUE(rtp_packet.Parse(packet->data.data(), packet->data.size()));
+ RtpPacketToSend rtp_packet =
+ packet_generator_.NextPacket<RtpPacketToSend>(i * kNumPackets + j,
+ 10);
ulpfec_generator_.AddPacketAndGenerateFec(rtp_packet);
- last_timestamp = packet->header.timestamp;
+ last_timestamp = rtp_packet.Timestamp();
}
}
std::vector<std::unique_ptr<RtpPacketToSend>> fec_packets =
@@ -188,10 +184,8 @@ TEST_F(UlpfecGeneratorTest, MixedMediaRtpHeaderLengths) {
// Fill up internal buffer with media packets with short RTP header length.
packet_generator_.NewFrame(kUlpfecMaxMediaPackets + 1);
for (size_t i = 0; i < kUlpfecMaxMediaPackets; ++i) {
- std::unique_ptr<AugmentedPacket> packet =
- packet_generator_.NextPacket(i, 10);
- RtpPacketToSend rtp_packet(nullptr);
- EXPECT_TRUE(rtp_packet.Parse(packet->data.data(), packet->data.size()));
+ RtpPacketToSend rtp_packet =
+ packet_generator_.NextPacket<RtpPacketToSend>(i, 10);
EXPECT_EQ(rtp_packet.headers_size(), kShortRtpHeaderLength);
ulpfec_generator_.AddPacketAndGenerateFec(rtp_packet);
EXPECT_TRUE(ulpfec_generator_.GetFecPackets().empty());
@@ -199,10 +193,8 @@ TEST_F(UlpfecGeneratorTest, MixedMediaRtpHeaderLengths) {
// Kick off FEC generation with media packet with long RTP header length.
// Since the internal buffer is full, this packet will not be protected.
- std::unique_ptr<AugmentedPacket> packet =
- packet_generator_.NextPacket(kUlpfecMaxMediaPackets, 10);
- RtpPacketToSend rtp_packet(nullptr);
- EXPECT_TRUE(rtp_packet.Parse(packet->data.data(), packet->data.size()));
+ RtpPacketToSend rtp_packet =
+ packet_generator_.NextPacket<RtpPacketToSend>(kUlpfecMaxMediaPackets, 10);
EXPECT_TRUE(rtp_packet.SetPayloadSize(0) != nullptr);
const uint32_t csrcs[]{1};
rtp_packet.SetCsrcs(csrcs);
@@ -238,10 +230,8 @@ TEST_F(UlpfecGeneratorTest, UpdatesProtectionParameters) {
// or delta-frame.
auto add_frame = [&](bool is_keyframe) {
packet_generator_.NewFrame(1);
- std::unique_ptr<AugmentedPacket> packet =
- packet_generator_.NextPacket(0, 10);
- RtpPacketToSend rtp_packet(nullptr);
- EXPECT_TRUE(rtp_packet.Parse(packet->data.data(), packet->data.size()));
+ RtpPacketToSend rtp_packet =
+ packet_generator_.NextPacket<RtpPacketToSend>(0, 10);
rtp_packet.set_is_key_frame(is_keyframe);
ulpfec_generator_.AddPacketAndGenerateFec(rtp_packet);
};
diff --git a/third_party/libwebrtc/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc b/third_party/libwebrtc/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
@@ -37,7 +37,6 @@ using ::testing::_;
using ::testing::Eq;
using ::testing::Property;
-using test::fec::AugmentedPacket;
using Packet = ForwardErrorCorrection::Packet;
using test::fec::UlpfecPacketGenerator;
@@ -69,12 +68,12 @@ class UlpfecReceiverTest : public ::testing::Test {
// Generates `num_media_packets` corresponding to a single frame.
void PacketizeFrame(size_t num_media_packets,
size_t frame_offset,
- std::list<AugmentedPacket*>* augmented_packets,
+ std::list<RtpPacketReceived>* augmented_packets,
ForwardErrorCorrection::PacketList* packets);
// Build a media packet using `packet_generator_` and add it
// to the receiver.
- void BuildAndAddRedMediaPacket(AugmentedPacket* packet,
+ void BuildAndAddRedMediaPacket(const RtpPacketReceived& packet,
bool is_recovered = false);
// Build a FEC packet using `packet_generator_` and add it
@@ -83,8 +82,7 @@ class UlpfecReceiverTest : public ::testing::Test {
// Ensure that `recovered_packet_receiver_` will be called correctly
// and that the recovered packet will be identical to the lost packet.
- void VerifyReconstructedMediaPacket(const AugmentedPacket& packet,
- size_t times);
+ void VerifyReconstructedMediaPacket(const RtpPacket& packet, size_t times);
void InjectGarbagePacketLength(size_t fec_garbage_offset);
@@ -118,22 +116,25 @@ void UlpfecReceiverTest::EncodeFec(
void UlpfecReceiverTest::PacketizeFrame(
size_t num_media_packets,
size_t frame_offset,
- std::list<AugmentedPacket*>* augmented_packets,
+ std::list<RtpPacketReceived>* augmented_packets,
ForwardErrorCorrection::PacketList* packets) {
packet_generator_.NewFrame(num_media_packets);
for (size_t i = 0; i < num_media_packets; ++i) {
- std::unique_ptr<AugmentedPacket> next_packet(
- packet_generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10));
- augmented_packets->push_back(next_packet.get());
- packets->push_back(std::move(next_packet));
+ RtpPacketReceived next_packet =
+ packet_generator_.NextPacket<RtpPacketReceived>(frame_offset + i,
+ kRtpHeaderSize + 10);
+ auto packet = std::make_unique<Packet>();
+ packet->data = next_packet.Buffer();
+ augmented_packets->push_back(std::move(next_packet));
+ packets->push_back(std::move(packet));
}
}
-void UlpfecReceiverTest::BuildAndAddRedMediaPacket(AugmentedPacket* packet,
- bool is_recovered) {
- RtpPacketReceived red_packet =
- packet_generator_.BuildMediaRedPacket(*packet, is_recovered);
- EXPECT_TRUE(receiver_fec_.AddReceivedRedPacket(red_packet));
+void UlpfecReceiverTest::BuildAndAddRedMediaPacket(
+ const RtpPacketReceived& packet,
+ bool is_recovered) {
+ EXPECT_TRUE(receiver_fec_.AddReceivedRedPacket(
+ packet_generator_.BuildMediaRedPacket(packet, is_recovered)));
}
void UlpfecReceiverTest::BuildAndAddRedFecPacket(Packet* packet) {
@@ -142,15 +143,14 @@ void UlpfecReceiverTest::BuildAndAddRedFecPacket(Packet* packet) {
EXPECT_TRUE(receiver_fec_.AddReceivedRedPacket(red_packet));
}
-void UlpfecReceiverTest::VerifyReconstructedMediaPacket(
- const AugmentedPacket& packet,
- size_t times) {
+void UlpfecReceiverTest::VerifyReconstructedMediaPacket(const RtpPacket& packet,
+ size_t times) {
// Verify that the content of the reconstructed packet is equal to the
// content of `packet`, and that the same content is received `times` number
// of times in a row.
- EXPECT_CALL(
- recovered_packet_receiver_,
- OnRecoveredPacket(Property(&RtpPacketReceived::Buffer, Eq(packet.data))))
+ EXPECT_CALL(recovered_packet_receiver_,
+ OnRecoveredPacket(
+ Property(&RtpPacketReceived::Buffer, Eq(packet.Buffer()))))
.Times(times);
}
@@ -158,7 +158,7 @@ void UlpfecReceiverTest::InjectGarbagePacketLength(size_t fec_garbage_offset) {
EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_));
const size_t kNumFecPackets = 1;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
PacketizeFrame(2, 0, &augmented_media_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
@@ -192,7 +192,7 @@ void UlpfecReceiverTest::SurvivesMaliciousPacket(const uint8_t* data,
TEST_F(UlpfecReceiverTest, TwoMediaOneFec) {
constexpr size_t kNumFecPackets = 1u;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
PacketizeFrame(2, 0, &augmented_media_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
@@ -205,7 +205,8 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFec) {
// Recovery
auto it = augmented_media_packets.begin();
BuildAndAddRedMediaPacket(*it);
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
+
receiver_fec_.ProcessReceivedFec();
counter = receiver_fec_.GetPacketCounter();
EXPECT_EQ(1u, counter.num_packets);
@@ -218,7 +219,7 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFec) {
auto fec_it = fec_packets.begin();
BuildAndAddRedFecPacket(*fec_it);
++it;
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
counter = receiver_fec_.GetPacketCounter();
@@ -230,7 +231,7 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFec) {
TEST_F(UlpfecReceiverTest, TwoMediaOneFecNotUsesRecoveredPackets) {
constexpr size_t kNumFecPackets = 1u;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
PacketizeFrame(2, 0, &augmented_media_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
@@ -243,7 +244,7 @@ TEST_F(UlpfecReceiverTest, TwoMediaOneFecNotUsesRecoveredPackets) {
// Recovery
auto it = augmented_media_packets.begin();
BuildAndAddRedMediaPacket(*it, /*is_recovered=*/true);
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
counter = receiver_fec_.GetPacketCounter();
EXPECT_EQ(1u, counter.num_packets);
@@ -278,7 +279,7 @@ TEST_F(UlpfecReceiverTest, InjectGarbageFecLevelHeaderProtectionLength) {
TEST_F(UlpfecReceiverTest, TwoMediaTwoFec) {
const size_t kNumFecPackets = 2;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
PacketizeFrame(2, 0, &augmented_media_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
@@ -289,18 +290,18 @@ TEST_F(UlpfecReceiverTest, TwoMediaTwoFec) {
auto it = augmented_media_packets.begin();
auto fec_it = fec_packets.begin();
BuildAndAddRedFecPacket(*fec_it);
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
++fec_it;
BuildAndAddRedFecPacket(*fec_it);
++it;
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
}
TEST_F(UlpfecReceiverTest, TwoFramesOneFec) {
const size_t kNumFecPackets = 1;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
PacketizeFrame(1, 0, &augmented_media_packets, &media_packets);
PacketizeFrame(1, 1, &augmented_media_packets, &media_packets);
@@ -310,18 +311,18 @@ TEST_F(UlpfecReceiverTest, TwoFramesOneFec) {
// Recovery
auto it = augmented_media_packets.begin();
BuildAndAddRedMediaPacket(augmented_media_packets.front());
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
// Drop one media packet.
BuildAndAddRedFecPacket(fec_packets.front());
++it;
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
}
TEST_F(UlpfecReceiverTest, OneCompleteOneUnrecoverableFrame) {
const size_t kNumFecPackets = 1;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
PacketizeFrame(1, 0, &augmented_media_packets, &media_packets);
PacketizeFrame(2, 1, &augmented_media_packets, &media_packets);
@@ -332,18 +333,18 @@ TEST_F(UlpfecReceiverTest, OneCompleteOneUnrecoverableFrame) {
// Recovery
auto it = augmented_media_packets.begin();
BuildAndAddRedMediaPacket(*it); // First frame: one packet.
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
++it;
BuildAndAddRedMediaPacket(*it); // First packet of second frame.
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
}
TEST_F(UlpfecReceiverTest, MaxFramesOneFec) {
const size_t kNumFecPackets = 1;
const size_t kNumMediaPackets = 48;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
for (size_t i = 0; i < kNumMediaPackets; ++i) {
PacketizeFrame(1, i, &augmented_media_packets, &media_packets);
@@ -356,19 +357,19 @@ TEST_F(UlpfecReceiverTest, MaxFramesOneFec) {
++it; // Drop first packet.
for (; it != augmented_media_packets.end(); ++it) {
BuildAndAddRedMediaPacket(*it);
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
}
BuildAndAddRedFecPacket(fec_packets.front());
it = augmented_media_packets.begin();
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
}
TEST_F(UlpfecReceiverTest, TooManyFrames) {
const size_t kNumFecPackets = 1;
const size_t kNumMediaPackets = 49;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
for (size_t i = 0; i < kNumMediaPackets; ++i) {
PacketizeFrame(1, i, &augmented_media_packets, &media_packets);
@@ -385,7 +386,7 @@ TEST_F(UlpfecReceiverTest, PacketNotDroppedTooEarly) {
Packet* delayed_fec = nullptr;
const size_t kNumFecPacketsBatch1 = 1;
const size_t kNumMediaPacketsBatch1 = 2;
- std::list<AugmentedPacket*> augmented_media_packets_batch1;
+ std::list<RtpPacketReceived> augmented_media_packets_batch1;
ForwardErrorCorrection::PacketList media_packets_batch1;
PacketizeFrame(kNumMediaPacketsBatch1, 0, &augmented_media_packets_batch1,
&media_packets_batch1);
@@ -399,7 +400,7 @@ TEST_F(UlpfecReceiverTest, PacketNotDroppedTooEarly) {
// Fill the FEC decoder. No packets should be dropped.
const size_t kNumMediaPacketsBatch2 = 191;
- std::list<AugmentedPacket*> augmented_media_packets_batch2;
+ std::list<RtpPacketReceived> augmented_media_packets_batch2;
ForwardErrorCorrection::PacketList media_packets_batch2;
for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) {
PacketizeFrame(1, i, &augmented_media_packets_batch2,
@@ -424,7 +425,7 @@ TEST_F(UlpfecReceiverTest, PacketDroppedWhenTooOld) {
Packet* delayed_fec = nullptr;
const size_t kNumFecPacketsBatch1 = 1;
const size_t kNumMediaPacketsBatch1 = 2;
- std::list<AugmentedPacket*> augmented_media_packets_batch1;
+ std::list<RtpPacketReceived> augmented_media_packets_batch1;
ForwardErrorCorrection::PacketList media_packets_batch1;
PacketizeFrame(kNumMediaPacketsBatch1, 0, &augmented_media_packets_batch1,
&media_packets_batch1);
@@ -438,7 +439,7 @@ TEST_F(UlpfecReceiverTest, PacketDroppedWhenTooOld) {
// Fill the FEC decoder and force the last packet to be dropped.
const size_t kNumMediaPacketsBatch2 = 192;
- std::list<AugmentedPacket*> augmented_media_packets_batch2;
+ std::list<RtpPacketReceived> augmented_media_packets_batch2;
ForwardErrorCorrection::PacketList media_packets_batch2;
for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) {
PacketizeFrame(1, i, &augmented_media_packets_batch2,
@@ -462,10 +463,10 @@ TEST_F(UlpfecReceiverTest, OldFecPacketDropped) {
// 49 frames with 2 media packets and one FEC packet. All media packets
// missing.
const size_t kNumMediaPackets = 49 * 2;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
for (size_t i = 0; i < kNumMediaPackets / 2; ++i) {
- std::list<AugmentedPacket*> frame_augmented_media_packets;
+ std::list<RtpPacketReceived> frame_augmented_media_packets;
ForwardErrorCorrection::PacketList frame_media_packets;
std::list<ForwardErrorCorrection::Packet*> fec_packets;
PacketizeFrame(2, 0, &frame_augmented_media_packets, &frame_media_packets);
@@ -520,15 +521,12 @@ TEST_F(UlpfecReceiverTest, TruncatedPacketWithoutDataPastFirstBlock) {
TEST_F(UlpfecReceiverTest, MediaWithPadding) {
const size_t kNumFecPackets = 1;
- std::list<AugmentedPacket*> augmented_media_packets;
+ std::list<RtpPacketReceived> augmented_media_packets;
ForwardErrorCorrection::PacketList media_packets;
PacketizeFrame(2, 0, &augmented_media_packets, &media_packets);
- // Append four bytes of padding to the first media packet.
- const uint8_t kPadding[] = {0, 0, 0, 4};
- augmented_media_packets.front()->data.AppendData(kPadding);
- augmented_media_packets.front()->data.MutableData()[0] |= 1 << 5; // P bit.
- augmented_media_packets.front()->header.paddingLength = 4;
+ augmented_media_packets.front().SetPadding(/*padding_bytes=*/4);
+ media_packets.front()->data = augmented_media_packets.front().Buffer();
std::list<ForwardErrorCorrection::Packet*> fec_packets;
EncodeFec(media_packets, kNumFecPackets, &fec_packets);
@@ -536,12 +534,12 @@ TEST_F(UlpfecReceiverTest, MediaWithPadding) {
auto it = augmented_media_packets.begin();
BuildAndAddRedMediaPacket(augmented_media_packets.front());
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
BuildAndAddRedFecPacket(fec_packets.front());
++it;
- VerifyReconstructedMediaPacket(**it, 1);
+ VerifyReconstructedMediaPacket(*it, 1);
receiver_fec_.ProcessReceivedFec();
}
