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}
diff --git a/modules/audio_coding/neteq/neteq_decoder_plc_unittest.cc b/modules/audio_coding/neteq/neteq_decoder_plc_unittest.cc
index edd57a0..df858f9 100644
--- a/modules/audio_coding/neteq/neteq_decoder_plc_unittest.cc
+++ b/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 @@
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/modules/audio_coding/neteq/tools/encode_neteq_input.cc b/modules/audio_coding/neteq/tools/encode_neteq_input.cc
index e763d78..c9a842b 100644
--- a/modules/audio_coding/neteq/tools/encode_neteq_input.cc
+++ b/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 @@
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 @@
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/modules/audio_coding/neteq/tools/encode_neteq_input.h b/modules/audio_coding/neteq/tools/encode_neteq_input.h
index eb8fea7..1fe42d3 100644
--- a/modules/audio_coding/neteq/tools/encode_neteq_input.h
+++ b/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 @@
return std::nullopt;
}
- std::unique_ptr<PacketData> PopPacket() override;
+ std::unique_ptr<RtpPacketReceived> PopPacket() override;
void AdvanceOutputEvent() override;
@@ -67,7 +68,7 @@
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/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.cc b/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.cc
index b2bb4f1..a658552 100644
--- a/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.cc
+++ b/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 @@
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 @@
}
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/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.h b/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.h
index 47939de..a6fa513 100644
--- a/modules/audio_coding/neteq/tools/initial_packet_inserter_neteq_input.h
+++ b/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 @@
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 @@
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/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc b/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc
index 894eef9..76ba747 100644
--- a/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc
+++ b/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 @@
} // 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/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h b/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h
index caa3302..e19920b 100644
--- a/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h
+++ b/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 @@
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/modules/audio_coding/neteq/tools/neteq_event_log_input.cc b/modules/audio_coding/neteq/tools/neteq_event_log_input.cc
index 9066bd6..64bcc34 100644
--- a/modules/audio_coding/neteq/tools/neteq_event_log_input.cc
+++ b/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 @@
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/modules/audio_coding/neteq/tools/neteq_input.cc b/modules/audio_coding/neteq/tools/neteq_input.cc
index 8c27b8e..d335917 100644
--- a/modules/audio_coding/neteq/tools/neteq_input.cc
+++ b/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 @@
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/modules/audio_coding/neteq/tools/neteq_input.h b/modules/audio_coding/neteq/tools/neteq_input.h
index 269d7b6..49560a6 100644
--- a/modules/audio_coding/neteq/tools/neteq_input.h
+++ b/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 @@
// 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 @@
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 @@
// 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 @@
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/modules/audio_coding/neteq/tools/neteq_replacement_input.cc b/modules/audio_coding/neteq/tools/neteq_replacement_input.cc
index 374279f..9b8268f 100644
--- a/modules/audio_coding/neteq/tools/neteq_replacement_input.cc
+++ b/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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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/modules/audio_coding/neteq/tools/neteq_replacement_input.h b/modules/audio_coding/neteq/tools/neteq_replacement_input.h
index a7efbc1..53ccde8 100644
--- a/modules/audio_coding/neteq/tools/neteq_replacement_input.h
+++ b/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 @@
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 @@
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/modules/audio_coding/neteq/tools/neteq_rtp_dump_input.cc b/modules/audio_coding/neteq/tools/neteq_rtp_dump_input.cc
index d438900..a3e0e2d 100644
--- a/modules/audio_coding/neteq/tools/neteq_rtp_dump_input.cc
+++ b/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 @@
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 @@
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 @@
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/modules/audio_coding/neteq/tools/neteq_test.cc b/modules/audio_coding/neteq/tools/neteq_test.cc
index cfeccfd..ed8c10a 100644
--- a/modules/audio_coding/neteq/tools/neteq_test.cc
+++ b/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 @@
} // 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 @@
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 @@
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 @@
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/modules/audio_coding/neteq/tools/neteq_test.h b/modules/audio_coding/neteq/tools/neteq_test.h
index 8717cd0..e0cf777 100644
--- a/modules/audio_coding/neteq/tools/neteq_test.h
+++ b/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 @@
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/modules/audio_coding/neteq/tools/neteq_test_factory.cc b/modules/audio_coding/neteq/tools/neteq_test_factory.cc
index ca4fb49..0901e09 100644
--- a/modules/audio_coding/neteq/tools/neteq_test_factory.cc
+++ b/modules/audio_coding/neteq/tools/neteq_test_factory.cc
@@ -90,16 +90,15 @@
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/test/fuzzers/BUILD.gn b/test/fuzzers/BUILD.gn
index 9d61ce6..ae891d2 100644
--- a/test/fuzzers/BUILD.gn
+++ b/test/fuzzers/BUILD.gn
@@ -451,10 +451,12 @@
"../../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/test/fuzzers/neteq_rtp_fuzzer.cc b/test/fuzzers/neteq_rtp_fuzzer.cc
index 734e734..cdfa59c 100644
--- a/test/fuzzers/neteq_rtp_fuzzer.cc
+++ b/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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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/test/fuzzers/neteq_signal_fuzzer.cc b/test/fuzzers/neteq_signal_fuzzer.cc
index 1ba6d81..be64df5 100644
--- a/test/fuzzers/neteq_signal_fuzzer.cc
+++ b/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 @@
}
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 @@
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 @@
} 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 @@
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;
};
