commit fc66d8c07b29a0647dd126bce027980eb7c3bddf parent c797b290fa2d3da3d72e3e6f16a7730a2d418155 Author: Dan Baker <dbaker@mozilla.com> Date: Thu, 23 Oct 2025 14:37:31 -0600 Bug 1995393 - Vendor libwebrtc from 65b75ab230 Upstream commit: https://webrtc.googlesource.com/src/+/65b75ab2303ed24bc98940c1ff609577df9571a6 Replace test packet NetEqInput::PacketData with RtpPacketReceived Reducing number of representation of an RTP packet. Bug: webrtc:42225366 Change-Id: I829567d652c895c012056469945c1b72c409dca8 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/404140 Reviewed-by: Jakob Ivarsson‎ <jakobi@webrtc.org> Commit-Queue: Danil Chapovalov <danilchap@webrtc.org> Cr-Commit-Position: refs/heads/main@{#45322} Diffstat:
21 files changed, 164 insertions(+), 161 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 /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc --commit mozpatches libwebrtc -libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-10-23T20:34:54.025863+00:00. +libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-10-23T20:37:12.022156+00:00. # base of lastest vendoring -53beafc5f7 +65b75ab230 diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/neteq_decoder_plc_unittest.cc b/third_party/libwebrtc/modules/audio_coding/neteq/neteq_decoder_plc_unittest.cc @@ -30,6 +30,7 @@ #include "modules/audio_coding/neteq/tools/input_audio_file.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" #include "modules/audio_coding/neteq/tools/neteq_test.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/buffer.h" #include "rtc_base/checks.h" #include "rtc_base/numerics/safe_conversions.h" @@ -141,7 +142,7 @@ class LossyInput : public NetEqInput { return input_->NextSetMinimumDelayInfo(); } - std::unique_ptr<PacketData> PopPacket() override { + std::unique_ptr<RtpPacketReceived> PopPacket() override { if (loss_cadence_ != 0 && (++count_ % loss_cadence_) == 0) { // Pop `burst_length_` packets to create the loss. auto packet_to_return = input_->PopPacket(); diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/encode_neteq_input.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/encode_neteq_input.cc @@ -18,7 +18,9 @@ #include "api/audio_codecs/audio_encoder.h" #include "api/rtp_headers.h" -#include "modules/audio_coding/neteq/tools/neteq_input.h" +#include "api/units/timestamp.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" +#include "rtc_base/buffer.h" #include "rtc_base/checks.h" #include "rtc_base/numerics/safe_conversions.h" @@ -38,17 +40,17 @@ EncodeNetEqInput::~EncodeNetEqInput() = default; std::optional<int64_t> EncodeNetEqInput::NextPacketTime() const { RTC_DCHECK(packet_data_); - return static_cast<int64_t>(packet_data_->time_ms); + return packet_data_->arrival_time().ms(); } std::optional<int64_t> EncodeNetEqInput::NextOutputEventTime() const { return next_output_event_ms_; } -std::unique_ptr<NetEqInput::PacketData> EncodeNetEqInput::PopPacket() { +std::unique_ptr<RtpPacketReceived> EncodeNetEqInput::PopPacket() { RTC_DCHECK(packet_data_); // Grab the packet to return... - std::unique_ptr<PacketData> packet_to_return = std::move(packet_data_); + std::unique_ptr<RtpPacketReceived> packet_to_return = std::move(packet_data_); // ... and line up the next packet for future use. CreatePacket(); @@ -65,35 +67,38 @@ bool EncodeNetEqInput::ended() const { std::optional<RTPHeader> EncodeNetEqInput::NextHeader() const { RTC_DCHECK(packet_data_); - return packet_data_->header; + std::optional<RTPHeader> rtp_header(std::in_place); + packet_data_->GetHeader(&*rtp_header); + return rtp_header; } void EncodeNetEqInput::CreatePacket() { // Create a new PacketData object. RTC_DCHECK(!packet_data_); - packet_data_.reset(new NetEqInput::PacketData); - RTC_DCHECK_EQ(packet_data_->payload.size(), 0); + packet_data_ = std::make_unique<RtpPacketReceived>(); // Loop until we get a packet. AudioEncoder::EncodedInfo info; RTC_DCHECK(!info.send_even_if_empty); int num_blocks = 0; - while (packet_data_->payload.empty() && !info.send_even_if_empty) { + Buffer payload; + while (payload.empty() && !info.send_even_if_empty) { const size_t num_samples = CheckedDivExact( static_cast<int>(encoder_->SampleRateHz() * kOutputPeriodMs), 1000); info = encoder_->Encode(rtp_timestamp_, generator_->Generate(num_samples), - &packet_data_->payload); + &payload); rtp_timestamp_ += dchecked_cast<uint32_t>(num_samples * encoder_->RtpTimestampRateHz() / encoder_->SampleRateHz()); ++num_blocks; } - packet_data_->header.timestamp = info.encoded_timestamp; - packet_data_->header.payloadType = info.payload_type; - packet_data_->header.sequenceNumber = sequence_number_++; - packet_data_->time_ms = next_packet_time_ms_; + packet_data_->SetPayload(payload); + packet_data_->SetTimestamp(info.encoded_timestamp); + packet_data_->SetPayloadType(info.payload_type); + packet_data_->SetSequenceNumber(sequence_number_++); + packet_data_->set_arrival_time(Timestamp::Millis(next_packet_time_ms_)); next_packet_time_ms_ += num_blocks * kOutputPeriodMs; } diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/encode_neteq_input.h b/third_party/libwebrtc/modules/audio_coding/neteq/tools/encode_neteq_input.h @@ -20,6 +20,7 @@ #include "api/audio_codecs/audio_encoder.h" #include "api/rtp_headers.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" namespace webrtc { namespace test { @@ -50,7 +51,7 @@ class EncodeNetEqInput : public NetEqInput { return std::nullopt; } - std::unique_ptr<PacketData> PopPacket() override; + std::unique_ptr<RtpPacketReceived> PopPacket() override; void AdvanceOutputEvent() override; @@ -67,7 +68,7 @@ class EncodeNetEqInput : public NetEqInput { std::unique_ptr<Generator> generator_; std::unique_ptr<AudioEncoder> encoder_; - std::unique_ptr<PacketData> packet_data_; + std::unique_ptr<RtpPacketReceived> packet_data_; uint32_t rtp_timestamp_ = 0; int16_t sequence_number_ = 0; int64_t next_packet_time_ms_ = 0; diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.cc @@ -17,7 +17,7 @@ #include "api/rtp_headers.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" -#include "rtc_base/buffer.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/checks.h" namespace webrtc { @@ -45,7 +45,7 @@ InitialPacketInserterNetEqInput::NextSetMinimumDelayInfo() const { return source_->NextSetMinimumDelayInfo(); } -std::unique_ptr<InitialPacketInserterNetEqInput::PacketData> +std::unique_ptr<RtpPacketReceived> InitialPacketInserterNetEqInput::PopPacket() { if (!first_packet_) { first_packet_ = source_->PopPacket(); @@ -56,15 +56,13 @@ InitialPacketInserterNetEqInput::PopPacket() { } if (packets_to_insert_ > 0) { RTC_CHECK(first_packet_); - auto dummy_packet = std::unique_ptr<PacketData>(new PacketData()); - dummy_packet->header = first_packet_->header; - dummy_packet->payload = - Buffer(first_packet_->payload.data(), first_packet_->payload.size()); - dummy_packet->time_ms = first_packet_->time_ms; - dummy_packet->header.sequenceNumber -= packets_to_insert_; + auto dummy_packet = std::make_unique<RtpPacketReceived>(*first_packet_); + dummy_packet->SetSequenceNumber(first_packet_->SequenceNumber() - + packets_to_insert_); // This assumes 20ms per packet. - dummy_packet->header.timestamp -= - 20 * sample_rate_hz_ * packets_to_insert_ / 1000; + dummy_packet->SetTimestamp(first_packet_->Timestamp() - + 20 * sample_rate_hz_ * packets_to_insert_ / + 1000); packets_to_insert_--; return dummy_packet; } diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.h b/third_party/libwebrtc/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.h @@ -17,6 +17,7 @@ #include "api/rtp_headers.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" namespace webrtc { namespace test { @@ -31,7 +32,7 @@ class InitialPacketInserterNetEqInput final : public NetEqInput { std::optional<int64_t> NextPacketTime() const override; std::optional<int64_t> NextOutputEventTime() const override; std::optional<SetMinimumDelayInfo> NextSetMinimumDelayInfo() const override; - std::unique_ptr<PacketData> PopPacket() override; + std::unique_ptr<RtpPacketReceived> PopPacket() override; void AdvanceOutputEvent() override; void AdvanceSetMinimumDelay() override; bool ended() const override; @@ -41,7 +42,7 @@ class InitialPacketInserterNetEqInput final : public NetEqInput { const std::unique_ptr<NetEqInput> source_; int packets_to_insert_; const int sample_rate_hz_; - std::unique_ptr<PacketData> first_packet_; + std::unique_ptr<RtpPacketReceived> first_packet_; }; } // namespace test diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc @@ -25,7 +25,7 @@ #include "api/audio/audio_frame.h" #include "api/neteq/neteq.h" #include "api/rtp_packet_info.h" -#include "modules/audio_coding/neteq/tools/neteq_input.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/checks.h" #include "rtc_base/numerics/sequence_number_unwrapper.h" @@ -92,13 +92,12 @@ void PrintDelays(const NetEqDelayAnalyzer::Delays& delays, } // namespace -void NetEqDelayAnalyzer::AfterInsertPacket( - const test::NetEqInput::PacketData& packet, - NetEq* /* neteq */) { - data_.insert( - std::make_pair(packet.header.timestamp, TimingData(packet.time_ms))); - ssrcs_.insert(packet.header.ssrc); - payload_types_.insert(packet.header.payloadType); +void NetEqDelayAnalyzer::AfterInsertPacket(const RtpPacketReceived& packet, + NetEq* /* neteq */) { + data_.insert(std::make_pair(packet.Timestamp(), + TimingData(packet.arrival_time().ms()))); + ssrcs_.insert(packet.Ssrc()); + payload_types_.insert(packet.PayloadType()); } void NetEqDelayAnalyzer::BeforeGetAudio(NetEq* neteq) { diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h @@ -22,8 +22,8 @@ #include "absl/strings/string_view.h" #include "api/audio/audio_frame.h" #include "api/neteq/neteq.h" -#include "modules/audio_coding/neteq/tools/neteq_input.h" #include "modules/audio_coding/neteq/tools/neteq_test.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" namespace webrtc { namespace test { @@ -31,7 +31,7 @@ namespace test { class NetEqDelayAnalyzer : public test::NetEqPostInsertPacket, public test::NetEqGetAudioCallback { public: - void AfterInsertPacket(const test::NetEqInput::PacketData& packet, + void AfterInsertPacket(const RtpPacketReceived& packet, NetEq* neteq) override; void BeforeGetAudio(NetEq* neteq) override; diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_event_log_input.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_event_log_input.cc @@ -11,17 +11,20 @@ #include "modules/audio_coding/neteq/tools/neteq_event_log_input.h" #include <algorithm> +#include <cstddef> #include <cstdint> #include <memory> #include <optional> #include <vector> +#include "api/array_view.h" #include "api/rtp_headers.h" #include "logging/rtc_event_log/events/logged_rtp_rtcp.h" #include "logging/rtc_event_log/events/rtc_event_audio_playout.h" #include "logging/rtc_event_log/events/rtc_event_neteq_set_minimum_delay.h" #include "logging/rtc_event_log/rtc_event_log_parser.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" namespace webrtc { namespace test { @@ -84,19 +87,25 @@ class NetEqEventLogInput : public NetEqInput { neteq_set_minimum_delay_events_it_->minimum_delay_ms); } - std::unique_ptr<PacketData> PopPacket() override { + std::unique_ptr<RtpPacketReceived> PopPacket() override { if (packet_stream_it_ == packet_stream_.end()) { return nullptr; } - auto packet_data = std::make_unique<PacketData>(); - packet_data->header = packet_stream_it_->rtp.header; - packet_data->time_ms = packet_stream_it_->rtp.log_time_ms(); + const LoggedRtpPacket& logged = packet_stream_it_->rtp; + auto packet_data = std::make_unique<RtpPacketReceived>(); + packet_data->SetPayloadType(logged.header.payloadType); + packet_data->SetMarker(logged.header.markerBit); + packet_data->SetSequenceNumber(logged.header.sequenceNumber); + packet_data->SetTimestamp(logged.header.timestamp); + packet_data->SetSsrc(logged.header.ssrc); + packet_data->SetCsrcs( + MakeArrayView(logged.header.arrOfCSRCs, logged.header.numCSRCs)); + packet_data->set_arrival_time(logged.log_time()); // This is a header-only "dummy" packet. Set the payload to all zeros, with // length according to the virtual length. - packet_data->payload.SetSize(packet_stream_it_->rtp.total_length - - packet_stream_it_->rtp.header_length); - std::fill_n(packet_data->payload.data(), packet_data->payload.size(), 0); + size_t payload_size = logged.total_length - logged.header_length; + std::fill_n(packet_data->AllocatePayload(payload_size), payload_size, 0); ++packet_stream_it_; return packet_data; diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_input.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_input.cc @@ -17,35 +17,33 @@ #include <utility> #include "api/rtp_headers.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/strings/string_builder.h" namespace webrtc { namespace test { -NetEqInput::PacketData::PacketData() = default; -NetEqInput::PacketData::~PacketData() = default; - -std::string NetEqInput::PacketData::ToString() const { +std::string NetEqInput::ToString(const RtpPacketReceived& packet) { StringBuilder ss; ss << "{" "time_ms: " - << static_cast<int64_t>(time_ms) + << packet.arrival_time().ms() << ", " "header: {" "pt: " - << static_cast<int>(header.payloadType) + << static_cast<int>(packet.PayloadType()) << ", " "sn: " - << header.sequenceNumber + << packet.SequenceNumber() << ", " "ts: " - << header.timestamp + << packet.Timestamp() << ", " "ssrc: " - << header.ssrc + << packet.Ssrc() << "}, " "payload bytes: " - << payload.size() << "}"; + << packet.payload_size() << "}"; return ss.Release(); } @@ -70,9 +68,9 @@ TimeLimitedNetEqInput::NextSetMinimumDelayInfo() const { return ended_ ? std::nullopt : input_->NextSetMinimumDelayInfo(); } -std::unique_ptr<NetEqInput::PacketData> TimeLimitedNetEqInput::PopPacket() { +std::unique_ptr<RtpPacketReceived> TimeLimitedNetEqInput::PopPacket() { if (ended_) { - return std::unique_ptr<PacketData>(); + return nullptr; } auto packet = input_->PopPacket(); MaybeSetEnded(); diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_input.h b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_input.h @@ -18,7 +18,7 @@ #include <string> #include "api/rtp_headers.h" -#include "rtc_base/buffer.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" namespace webrtc { namespace test { @@ -26,16 +26,6 @@ namespace test { // Interface class for input to the NetEqTest class. class NetEqInput { public: - struct PacketData { - PacketData(); - ~PacketData(); - std::string ToString() const; - - RTPHeader header; - Buffer payload; - int64_t time_ms; - }; - struct SetMinimumDelayInfo { SetMinimumDelayInfo(int64_t timestamp_ms_in, int delay_ms_in) : timestamp_ms(timestamp_ms_in), delay_ms(delay_ms_in) {} @@ -43,6 +33,8 @@ class NetEqInput { int delay_ms; }; + static std::string ToString(const RtpPacketReceived& packet); + virtual ~NetEqInput() = default; // Returns at what time (in ms) NetEq::InsertPacket should be called next, or @@ -84,7 +76,7 @@ class NetEqInput { // returned one is pre-fetched in the NetEqInput object, such that future // calls to NextPacketTime() or NextHeader() will return information from that // packet. - virtual std::unique_ptr<PacketData> PopPacket() = 0; + virtual std::unique_ptr<RtpPacketReceived> PopPacket() = 0; // Move to the next output event. This will make NextOutputEventTime() return // a new value (potentially the same if several output events share the same @@ -115,7 +107,7 @@ class TimeLimitedNetEqInput : public NetEqInput { std::optional<int64_t> NextPacketTime() const override; std::optional<int64_t> NextOutputEventTime() const override; std::optional<SetMinimumDelayInfo> NextSetMinimumDelayInfo() const override; - std::unique_ptr<PacketData> PopPacket() override; + std::unique_ptr<RtpPacketReceived> PopPacket() override; void AdvanceOutputEvent() override; void AdvanceSetMinimumDelay() override; bool ended() const override; diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_replacement_input.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_replacement_input.cc @@ -20,6 +20,7 @@ #include "api/rtp_headers.h" #include "modules/audio_coding/neteq/tools/fake_decode_from_file.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/checks.h" namespace webrtc { @@ -40,9 +41,7 @@ NetEqReplacementInput::NetEqReplacementInput( } std::optional<int64_t> NetEqReplacementInput::NextPacketTime() const { - return packet_ - ? std::optional<int64_t>(static_cast<int64_t>(packet_->time_ms)) - : std::nullopt; + return packet_ ? std::optional(packet_->arrival_time().ms()) : std::nullopt; } std::optional<int64_t> NetEqReplacementInput::NextOutputEventTime() const { @@ -54,13 +53,13 @@ NetEqReplacementInput::NextSetMinimumDelayInfo() const { return source_->NextSetMinimumDelayInfo(); } -std::unique_ptr<NetEqInput::PacketData> NetEqReplacementInput::PopPacket() { - std::unique_ptr<PacketData> to_return = std::move(packet_); +std::unique_ptr<RtpPacketReceived> NetEqReplacementInput::PopPacket() { + std::unique_ptr<RtpPacketReceived> to_return = std::move(packet_); while (true) { packet_ = source_->PopPacket(); if (!packet_) break; - if (packet_->payload.size() > packet_->header.paddingLength) { + if (!packet_->payload().empty()) { // Not padding only. Good to go. Skip this packet otherwise. break; } @@ -95,15 +94,15 @@ void NetEqReplacementInput::ReplacePacket() { RTC_DCHECK(packet_); - RTC_CHECK_EQ(forbidden_types_.count(packet_->header.payloadType), 0) - << "Payload type " << static_cast<int>(packet_->header.payloadType) + RTC_CHECK_EQ(forbidden_types_.count(packet_->PayloadType()), 0) + << "Payload type " << static_cast<int>(packet_->PayloadType()) << " is forbidden."; // Check if this packet is comfort noise. - if (comfort_noise_types_.count(packet_->header.payloadType) != 0) { + if (comfort_noise_types_.count(packet_->PayloadType()) != 0) { // If CNG, simply insert a zero-energy one-byte payload. uint8_t cng_payload[1] = {127}; // Max attenuation of CNG. - packet_->payload.SetData(cng_payload); + packet_->SetPayload(cng_payload); return; } @@ -111,14 +110,13 @@ void NetEqReplacementInput::ReplacePacket() { RTC_DCHECK(next_hdr); uint8_t payload[12]; constexpr uint32_t kMaxFrameSize = 120 * 48; - const uint32_t timestamp_diff = - next_hdr->timestamp - packet_->header.timestamp; + const uint32_t timestamp_diff = next_hdr->timestamp - packet_->Timestamp(); uint32_t frame_size = last_frame_size_timestamps_; if (timestamp_diff > 0) { frame_size = std::min(frame_size, timestamp_diff); } - const bool opus_dtx = packet_->payload.size() <= 2; - if (next_hdr->sequenceNumber == packet_->header.sequenceNumber + 1 && + const bool opus_dtx = packet_->payload_size() <= 2; + if (next_hdr->sequenceNumber == packet_->SequenceNumber() + 1 && timestamp_diff <= kMaxFrameSize && timestamp_diff > 0 && !opus_dtx) { // Packets are in order and the timestamp diff is valid. frame_size = timestamp_diff; @@ -126,10 +124,10 @@ void NetEqReplacementInput::ReplacePacket() { } RTC_DCHECK_LE(frame_size, kMaxFrameSize); RTC_DCHECK_GT(frame_size, 0); - FakeDecodeFromFile::PrepareEncoded(packet_->header.timestamp, frame_size, - packet_->payload.size(), payload); - packet_->payload.SetData(payload); - packet_->header.payloadType = replacement_payload_type_; + FakeDecodeFromFile::PrepareEncoded(packet_->Timestamp(), frame_size, + packet_->payload_size(), payload); + packet_->SetPayload(payload); + packet_->SetPayloadType(replacement_payload_type_); return; } diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_replacement_input.h b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_replacement_input.h @@ -18,6 +18,7 @@ #include "api/rtp_headers.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" namespace webrtc { namespace test { @@ -34,7 +35,7 @@ class NetEqReplacementInput : public NetEqInput { std::optional<int64_t> NextPacketTime() const override; std::optional<int64_t> NextOutputEventTime() const override; std::optional<SetMinimumDelayInfo> NextSetMinimumDelayInfo() const override; - std::unique_ptr<PacketData> PopPacket() override; + std::unique_ptr<RtpPacketReceived> PopPacket() override; void AdvanceOutputEvent() override; void AdvanceSetMinimumDelay() override; bool ended() const override; @@ -47,7 +48,7 @@ class NetEqReplacementInput : public NetEqInput { const uint8_t replacement_payload_type_; const std::set<uint8_t> comfort_noise_types_; const std::set<uint8_t> forbidden_types_; - std::unique_ptr<PacketData> packet_; // The next packet to deliver. + std::unique_ptr<RtpPacketReceived> packet_; // The next packet to deliver. uint32_t last_frame_size_timestamps_ = 960; // Initial guess: 20 ms @ 48 kHz. }; diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_rtp_dump_input.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_rtp_dump_input.cc @@ -14,6 +14,7 @@ #include <map> #include <memory> #include <optional> +#include <utility> #include "absl/strings/string_view.h" #include "api/rtp_headers.h" @@ -36,7 +37,7 @@ class NetEqRtpDumpInput : public NetEqInput { for (const auto& ext_pair : hdr_ext_map) { source_->RegisterRtpHeaderExtension(ext_pair.second, ext_pair.first); } - LoadNextPacket(); + packet_ = source_->NextPacket(); } std::optional<int64_t> NextOutputEventTime() const override { @@ -62,18 +63,11 @@ class NetEqRtpDumpInput : public NetEqInput { return packet_ ? std::optional(packet_->arrival_time().ms()) : std::nullopt; } - std::unique_ptr<PacketData> PopPacket() override { + std::unique_ptr<RtpPacketReceived> PopPacket() override { if (!packet_) { - return std::unique_ptr<PacketData>(); + return nullptr; } - auto packet_data = std::make_unique<PacketData>(); - packet_->GetHeader(&packet_data->header); - packet_data->payload.SetData(packet_->payload()); - packet_data->time_ms = packet_->arrival_time().ms(); - - LoadNextPacket(); - - return packet_data; + return std::exchange(packet_, source_->NextPacket()); } std::optional<RTPHeader> NextHeader() const override { @@ -88,8 +82,6 @@ class NetEqRtpDumpInput : public NetEqInput { bool ended() const override { return !next_output_event_ms_; } private: - void LoadNextPacket() { packet_ = source_->NextPacket(); } - std::optional<int64_t> next_output_event_ms_ = 0; static constexpr int64_t kOutputPeriodMs = 10; diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_test.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_test.cc @@ -30,12 +30,14 @@ #include "api/neteq/default_neteq_factory.h" #include "api/neteq/neteq.h" #include "api/neteq/neteq_factory.h" +#include "api/rtp_headers.h" #include "api/scoped_refptr.h" #include "api/test/neteq_simulator.h" #include "api/units/timestamp.h" #include "modules/audio_coding/neteq/tools/audio_sink.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" #include "modules/rtp_rtcp/source/byte_io.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/checks.h" #include "system_wrappers/include/clock.h" @@ -70,9 +72,9 @@ std::unique_ptr<NetEq> CreateNetEq( } // namespace void DefaultNetEqTestErrorCallback::OnInsertPacketError( - const NetEqInput::PacketData& packet) { + const RtpPacketReceived& packet) { std::cerr << "InsertPacket returned an error." << std::endl; - std::cerr << "Packet data: " << packet.ToString() << std::endl; + std::cerr << "Packet data: " << NetEqInput::ToString(packet) << std::endl; RTC_FATAL(); } @@ -133,14 +135,14 @@ NetEqTest::SimulationStepResult NetEqTest::RunToNextGetAudio() { time_now_ms = *input_->NextEventTime(); // Check if it is time to insert packet. if (input_->NextPacketTime() && time_now_ms >= *input_->NextPacketTime()) { - std::unique_ptr<NetEqInput::PacketData> packet_data = input_->PopPacket(); + std::unique_ptr<RtpPacketReceived> packet_data = input_->PopPacket(); RTC_CHECK(packet_data); - const size_t payload_data_length = - packet_data->payload.size() - packet_data->header.paddingLength; + const size_t payload_data_length = packet_data->payload_size(); + RTPHeader rtp_header; + packet_data->GetHeader(&rtp_header); if (payload_data_length != 0) { - int error = neteq_->InsertPacket( - packet_data->header, ArrayView<const uint8_t>(packet_data->payload), - Timestamp::Millis(time_now_ms)); + int error = neteq_->InsertPacket(rtp_header, packet_data->payload(), + Timestamp::Millis(time_now_ms)); if (error != NetEq::kOK && callbacks_.error_callback) { callbacks_.error_callback->OnInsertPacketError(*packet_data); } @@ -149,7 +151,7 @@ NetEqTest::SimulationStepResult NetEqTest::RunToNextGetAudio() { neteq_.get()); } } else { - neteq_->InsertEmptyPacket(packet_data->header); + neteq_->InsertEmptyPacket(rtp_header); } if (last_packet_time_ms_) { current_state_.packet_iat_ms.push_back(time_now_ms - @@ -161,30 +163,29 @@ NetEqTest::SimulationStepResult NetEqTest::RunToNextGetAudio() { last_packet_time_ms_ ? (time_now_ms - *last_packet_time_ms_) : -1; const auto delta_timestamp = last_packet_timestamp_ - ? (static_cast<int64_t>(packet_data->header.timestamp) - + ? (static_cast<int64_t>(packet_data->Timestamp()) - *last_packet_timestamp_) * 1000 / sample_rate_hz_ : -1; const auto packet_size_bytes = - packet_data->payload.size() == 12 + packet_data->payload_size() == 12 ? ByteReader<uint32_t>::ReadLittleEndian( - &packet_data->payload[8]) + &packet_data->payload()[8]) : -1; *text_log_ << "Packet - wallclock: " << std::setw(5) << time_now_ms << ", delta wc: " << std::setw(4) << delta_wallclock - << ", seq_no: " << packet_data->header.sequenceNumber + << ", seq_no: " << packet_data->SequenceNumber() << ", timestamp: " << std::setw(10) - << packet_data->header.timestamp - << ", delta ts: " << std::setw(4) << delta_timestamp - << ", size: " << std::setw(5) << packet_size_bytes + << packet_data->Timestamp() // + << ", delta ts: " << std::setw(4) << delta_timestamp // + << ", size: " << std::setw(5) << packet_size_bytes // << ", frame size: " << std::setw(3) << ops_state.current_frame_size_ms << ", buffer size: " << std::setw(4) << ops_state.current_buffer_size_ms << std::endl; } - last_packet_time_ms_ = std::make_optional<int>(time_now_ms); - last_packet_timestamp_ = - std::make_optional<uint32_t>(packet_data->header.timestamp); + last_packet_time_ms_ = time_now_ms; + last_packet_timestamp_ = packet_data->Timestamp(); } if (input_->NextSetMinimumDelayInfo().has_value() && diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_test.h b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_test.h @@ -27,6 +27,7 @@ #include "api/test/neteq_simulator.h" #include "modules/audio_coding/neteq/tools/audio_sink.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "system_wrappers/include/clock.h" namespace webrtc { @@ -35,20 +36,19 @@ namespace test { class NetEqTestErrorCallback { public: virtual ~NetEqTestErrorCallback() = default; - virtual void OnInsertPacketError(const NetEqInput::PacketData& /* packet */) { - } + virtual void OnInsertPacketError(const RtpPacketReceived& /* packet */) {} virtual void OnGetAudioError() {} }; class DefaultNetEqTestErrorCallback : public NetEqTestErrorCallback { - void OnInsertPacketError(const NetEqInput::PacketData& packet) override; + void OnInsertPacketError(const RtpPacketReceived& packet) override; void OnGetAudioError() override; }; class NetEqPostInsertPacket { public: virtual ~NetEqPostInsertPacket() = default; - virtual void AfterInsertPacket(const NetEqInput::PacketData& packet, + virtual void AfterInsertPacket(const RtpPacketReceived& packet, NetEq* neteq) = 0; }; diff --git a/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_test_factory.cc b/third_party/libwebrtc/modules/audio_coding/neteq/tools/neteq_test_factory.cc @@ -90,16 +90,15 @@ class SsrcSwitchDetector : public NetEqPostInsertPacket { explicit SsrcSwitchDetector(NetEqPostInsertPacket* other_callback) : other_callback_(other_callback) {} - void AfterInsertPacket(const NetEqInput::PacketData& packet, + void AfterInsertPacket(const RtpPacketReceived& packet, NetEq* neteq) override { - if (last_ssrc_ && packet.header.ssrc != *last_ssrc_) { + if (last_ssrc_ && packet.Ssrc() != *last_ssrc_) { std::cout << "Changing streams from 0x" << std::hex << *last_ssrc_ - << " to 0x" << std::hex << packet.header.ssrc << std::dec - << " (payload type " - << static_cast<int>(packet.header.payloadType) << ")" + << " to 0x" << std::hex << packet.Ssrc() << std::dec + << " (payload type " << int{packet.PayloadType()} << ")" << std::endl; } - last_ssrc_ = packet.header.ssrc; + last_ssrc_ = packet.Ssrc(); if (other_callback_) { other_callback_->AfterInsertPacket(packet, neteq); } diff --git a/third_party/libwebrtc/moz-patch-stack/s0102.patch b/third_party/libwebrtc/moz-patch-stack/s0102.patch @@ -782,7 +782,7 @@ index f5039000f6..27fbece69e 100644 deps = [ ":google_test_runner_delegate" ] } diff --git a/test/fuzzers/BUILD.gn b/test/fuzzers/BUILD.gn -index 9d61ce653a..8d61065eab 100644 +index ae891d22bd..4f2e3cc266 100644 --- a/test/fuzzers/BUILD.gn +++ b/test/fuzzers/BUILD.gn @@ -6,7 +6,7 @@ diff --git a/third_party/libwebrtc/test/fuzzers/BUILD.gn b/third_party/libwebrtc/test/fuzzers/BUILD.gn @@ -451,10 +451,12 @@ webrtc_fuzzer_test("neteq_signal_fuzzer") { "../../api/audio_codecs:audio_codecs_api", "../../api/audio_codecs:builtin_audio_decoder_factory", "../../api/neteq:neteq_api", + "../../api/units:time_delta", "../../modules/audio_coding:neteq", "../../modules/audio_coding:neteq_test_tools", "../../modules/audio_coding:neteq_tools_minimal", "../../modules/audio_coding:pcm16b", + "../../modules/rtp_rtcp:rtp_rtcp_format", "../../rtc_base:checks", "../../rtc_base:random", "../../rtc_base:safe_conversions", diff --git a/third_party/libwebrtc/test/fuzzers/neteq_rtp_fuzzer.cc b/third_party/libwebrtc/test/fuzzers/neteq_rtp_fuzzer.cc @@ -8,7 +8,6 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include <algorithm> #include <cmath> #include <cstdint> #include <cstring> @@ -30,6 +29,7 @@ #include "modules/audio_coding/neteq/tools/neteq_input.h" #include "modules/audio_coding/neteq/tools/neteq_test.h" #include "modules/rtp_rtcp/source/byte_io.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/checks.h" namespace webrtc { @@ -80,7 +80,7 @@ class FuzzRtpInput : public NetEqInput { } std::optional<int64_t> NextPacketTime() const override { - return packet_->time_ms; + return packet_->arrival_time().ms(); } std::optional<int64_t> NextOutputEventTime() const override { @@ -91,9 +91,9 @@ class FuzzRtpInput : public NetEqInput { return input_->NextSetMinimumDelayInfo(); } - std::unique_ptr<PacketData> PopPacket() override { + std::unique_ptr<RtpPacketReceived> PopPacket() override { RTC_DCHECK(packet_); - std::unique_ptr<PacketData> packet_to_return = std::move(packet_); + std::unique_ptr<RtpPacketReceived> packet_to_return = std::move(packet_); packet_ = input_->PopPacket(); FuzzHeader(); MaybeFuzzPayload(); @@ -110,7 +110,9 @@ class FuzzRtpInput : public NetEqInput { std::optional<RTPHeader> NextHeader() const override { RTC_DCHECK(packet_); - return packet_->header; + std::optional<RTPHeader> rtp_header(std::in_place); + packet_->GetHeader(&*rtp_header); + return rtp_header; } private: @@ -122,18 +124,16 @@ class FuzzRtpInput : public NetEqInput { } RTC_DCHECK(packet_); const size_t start_ix = data_ix_; - packet_->header.payloadType = - ByteReader<uint8_t>::ReadLittleEndian(&data_[data_ix_]); - packet_->header.payloadType &= 0x7F; + packet_->SetPayloadType( + ByteReader<uint8_t>::ReadLittleEndian(&data_[data_ix_]) & 0x7F); data_ix_ += sizeof(uint8_t); - packet_->header.sequenceNumber = - ByteReader<uint16_t>::ReadLittleEndian(&data_[data_ix_]); + packet_->SetSequenceNumber( + ByteReader<uint16_t>::ReadLittleEndian(&data_[data_ix_])); data_ix_ += sizeof(uint16_t); - packet_->header.timestamp = - ByteReader<uint32_t>::ReadLittleEndian(&data_[data_ix_]); + packet_->SetTimestamp( + ByteReader<uint32_t>::ReadLittleEndian(&data_[data_ix_])); data_ix_ += sizeof(uint32_t); - packet_->header.ssrc = - ByteReader<uint32_t>::ReadLittleEndian(&data_[data_ix_]); + packet_->SetSsrc(ByteReader<uint32_t>::ReadLittleEndian(&data_[data_ix_])); data_ix_ += sizeof(uint32_t); RTC_CHECK_EQ(data_ix_ - start_ix, kNumBytesToFuzz); } @@ -147,8 +147,8 @@ class FuzzRtpInput : public NetEqInput { size_t bytes_to_fuzz = data_[data_ix_++]; // Restrict number of bytes to fuzz to 16; a reasonably low number enough to - // cover a few RED headers. Also don't write outside the payload length. - bytes_to_fuzz = std::min(bytes_to_fuzz % 16, packet_->payload.size()); + // cover a few RED headers. + bytes_to_fuzz = bytes_to_fuzz % 16; if (bytes_to_fuzz == 0) return; @@ -158,7 +158,7 @@ class FuzzRtpInput : public NetEqInput { return; } - std::memcpy(packet_->payload.data(), &data_[data_ix_], bytes_to_fuzz); + packet_->SetPayload(MakeArrayView(&data_[data_ix_], bytes_to_fuzz)); data_ix_ += bytes_to_fuzz; } @@ -166,7 +166,7 @@ class FuzzRtpInput : public NetEqInput { webrtc::ArrayView<const uint8_t> data_; size_t data_ix_ = 0; std::unique_ptr<EncodeNetEqInput> input_; - std::unique_ptr<PacketData> packet_; + std::unique_ptr<RtpPacketReceived> packet_; }; } // namespace diff --git a/third_party/libwebrtc/test/fuzzers/neteq_signal_fuzzer.cc b/third_party/libwebrtc/test/fuzzers/neteq_signal_fuzzer.cc @@ -25,11 +25,13 @@ #include "api/audio_codecs/builtin_audio_decoder_factory.h" #include "api/neteq/neteq.h" #include "api/rtp_headers.h" +#include "api/units/time_delta.h" #include "modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h" #include "modules/audio_coding/neteq/tools/audio_checksum.h" #include "modules/audio_coding/neteq/tools/encode_neteq_input.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" #include "modules/audio_coding/neteq/tools/neteq_test.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "rtc_base/checks.h" #include "rtc_base/numerics/safe_conversions.h" #include "rtc_base/random.h" @@ -103,7 +105,7 @@ class FuzzSignalInput : public NetEqInput { } std::optional<int64_t> NextPacketTime() const override { - return packet_->time_ms; + return packet_->arrival_time().ms(); } std::optional<int64_t> NextOutputEventTime() const override { @@ -114,9 +116,9 @@ class FuzzSignalInput : public NetEqInput { return input_->NextSetMinimumDelayInfo(); } - std::unique_ptr<PacketData> PopPacket() override { + std::unique_ptr<RtpPacketReceived> PopPacket() override { RTC_DCHECK(packet_); - std::unique_ptr<PacketData> packet_to_return = std::move(packet_); + std::unique_ptr<RtpPacketReceived> packet_to_return = std::move(packet_); do { packet_ = input_->PopPacket(); // If the next value from the fuzzer input is 0, the packet is discarded @@ -124,10 +126,12 @@ class FuzzSignalInput : public NetEqInput { } while (fuzz_data_.CanReadBytes(1) && fuzz_data_.Read<uint8_t>() == 0); if (fuzz_data_.CanReadBytes(1)) { // Generate jitter by setting an offset for the arrival time. - const int8_t arrival_time_offset_ms = fuzz_data_.Read<int8_t>(); + const TimeDelta arrival_time_offset = + TimeDelta::Millis(fuzz_data_.Read<int8_t>()); // The arrival time can not be before the previous packets. - packet_->time_ms = std::max(packet_to_return->time_ms, - packet_->time_ms + arrival_time_offset_ms); + packet_->set_arrival_time( + std::max(packet_to_return->arrival_time(), + packet_->arrival_time() + arrival_time_offset)); } else { // Mark that we are at the end of the test. However, the current packet is // still valid (but it may not have been fuzzed as expected). @@ -148,14 +152,16 @@ class FuzzSignalInput : public NetEqInput { std::optional<RTPHeader> NextHeader() const override { RTC_DCHECK(packet_); - return packet_->header; + std::optional<RTPHeader> rtp_header(std::in_place); + packet_->GetHeader(&*rtp_header); + return rtp_header; } private: bool ended_ = false; FuzzDataHelper& fuzz_data_; std::unique_ptr<EncodeNetEqInput> input_; - std::unique_ptr<PacketData> packet_; + std::unique_ptr<RtpPacketReceived> packet_; int64_t next_output_event_ms_ = 0; int64_t output_event_period_ms_ = 10; };