Allow access to specific RTCP types in new format event log parser.
Bug: webrtc:8111 Change-Id: Ia727c8fd9ddaa9f0c17fea5af8f544ad01e66367 Reviewed-on: https://webrtc-review.googlesource.com/c/112382 Commit-Queue: Björn Terelius <terelius@webrtc.org> Reviewed-by: Elad Alon <eladalon@webrtc.org> Cr-Commit-Position: refs/heads/master@{#25886}
This commit is contained in:
Bjorn Terelius
Commit Bot
parent
41390474fc
commit
ebb677773a
@ -37,6 +37,7 @@
|
||||
#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
|
||||
#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
|
||||
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
|
||||
#include "rtc_base/fakeclock.h"
|
||||
#include "rtc_base/random.h"
|
||||
#include "test/gtest.h"
|
||||
|
||||
@ -665,6 +666,201 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketOutgoing) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST_P(RtcEventLogEncoderTest, RtcEventRtcpReceiverReport) {
|
||||
if (force_repeated_fields_) {
|
||||
return;
|
||||
}
|
||||
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(static_cast<int64_t>(prng_.Rand<uint32_t>()) * 1000);
|
||||
|
||||
for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
|
||||
std::vector<rtcp::ReceiverReport> events(event_count_);
|
||||
std::vector<int64_t> timestamps_us(event_count_);
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
timestamps_us[i] = rtc::TimeMicros();
|
||||
events[i] = gen_.NewReceiverReport();
|
||||
rtc::Buffer buffer = events[i].Build();
|
||||
if (direction == kIncomingPacket) {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketIncoming>(buffer));
|
||||
} else {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
|
||||
}
|
||||
fake_clock.AdvanceTimeMicros(prng_.Rand(0, 1000) * 1000);
|
||||
}
|
||||
|
||||
std::string encoded =
|
||||
encoder_->EncodeBatch(history_.begin(), history_.end());
|
||||
ASSERT_TRUE(parsed_log_.ParseString(encoded));
|
||||
|
||||
const auto& receiver_reports = parsed_log_.receiver_reports(direction);
|
||||
ASSERT_EQ(receiver_reports.size(), event_count_);
|
||||
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
verifier_.VerifyLoggedReceiverReport(timestamps_us[i], events[i],
|
||||
receiver_reports[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_P(RtcEventLogEncoderTest, RtcEventRtcpSenderReport) {
|
||||
if (force_repeated_fields_) {
|
||||
return;
|
||||
}
|
||||
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(static_cast<int64_t>(prng_.Rand<uint32_t>()) * 1000);
|
||||
|
||||
for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
|
||||
std::vector<rtcp::SenderReport> events(event_count_);
|
||||
std::vector<int64_t> timestamps_us(event_count_);
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
timestamps_us[i] = rtc::TimeMicros();
|
||||
events[i] = gen_.NewSenderReport();
|
||||
rtc::Buffer buffer = events[i].Build();
|
||||
if (direction == kIncomingPacket) {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketIncoming>(buffer));
|
||||
} else {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
|
||||
}
|
||||
fake_clock.AdvanceTimeMicros(prng_.Rand(0, 1000) * 1000);
|
||||
}
|
||||
|
||||
std::string encoded =
|
||||
encoder_->EncodeBatch(history_.begin(), history_.end());
|
||||
ASSERT_TRUE(parsed_log_.ParseString(encoded));
|
||||
|
||||
const auto& sender_reports = parsed_log_.sender_reports(direction);
|
||||
ASSERT_EQ(sender_reports.size(), event_count_);
|
||||
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
verifier_.VerifyLoggedSenderReport(timestamps_us[i], events[i],
|
||||
sender_reports[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_P(RtcEventLogEncoderTest, RtcEventRtcpNack) {
|
||||
if (force_repeated_fields_) {
|
||||
return;
|
||||
}
|
||||
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(static_cast<int64_t>(prng_.Rand<uint32_t>()) * 1000);
|
||||
|
||||
for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
|
||||
std::vector<rtcp::Nack> events(event_count_);
|
||||
std::vector<int64_t> timestamps_us(event_count_);
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
timestamps_us[i] = rtc::TimeMicros();
|
||||
events[i] = gen_.NewNack();
|
||||
rtc::Buffer buffer = events[i].Build();
|
||||
if (direction == kIncomingPacket) {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketIncoming>(buffer));
|
||||
} else {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
|
||||
}
|
||||
fake_clock.AdvanceTimeMicros(prng_.Rand(0, 1000) * 1000);
|
||||
}
|
||||
|
||||
std::string encoded =
|
||||
encoder_->EncodeBatch(history_.begin(), history_.end());
|
||||
ASSERT_TRUE(parsed_log_.ParseString(encoded));
|
||||
|
||||
const auto& nacks = parsed_log_.nacks(direction);
|
||||
ASSERT_EQ(nacks.size(), event_count_);
|
||||
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
verifier_.VerifyLoggedNack(timestamps_us[i], events[i], nacks[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_P(RtcEventLogEncoderTest, RtcEventRtcpRemb) {
|
||||
if (force_repeated_fields_) {
|
||||
return;
|
||||
}
|
||||
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(static_cast<int64_t>(prng_.Rand<uint32_t>()) * 1000);
|
||||
|
||||
for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
|
||||
std::vector<rtcp::Remb> events(event_count_);
|
||||
std::vector<int64_t> timestamps_us(event_count_);
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
timestamps_us[i] = rtc::TimeMicros();
|
||||
events[i] = gen_.NewRemb();
|
||||
rtc::Buffer buffer = events[i].Build();
|
||||
if (direction == kIncomingPacket) {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketIncoming>(buffer));
|
||||
} else {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
|
||||
}
|
||||
fake_clock.AdvanceTimeMicros(prng_.Rand(0, 1000) * 1000);
|
||||
}
|
||||
|
||||
std::string encoded =
|
||||
encoder_->EncodeBatch(history_.begin(), history_.end());
|
||||
ASSERT_TRUE(parsed_log_.ParseString(encoded));
|
||||
|
||||
const auto& rembs = parsed_log_.rembs(direction);
|
||||
ASSERT_EQ(rembs.size(), event_count_);
|
||||
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
verifier_.VerifyLoggedRemb(timestamps_us[i], events[i], rembs[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_P(RtcEventLogEncoderTest, RtcEventRtcpTransportFeedback) {
|
||||
if (force_repeated_fields_) {
|
||||
return;
|
||||
}
|
||||
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(static_cast<int64_t>(prng_.Rand<uint32_t>()) * 1000);
|
||||
|
||||
for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
|
||||
std::vector<rtcp::TransportFeedback> events;
|
||||
events.reserve(event_count_);
|
||||
std::vector<int64_t> timestamps_us(event_count_);
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
timestamps_us[i] = rtc::TimeMicros();
|
||||
events.emplace_back(gen_.NewTransportFeedback());
|
||||
rtc::Buffer buffer = events[i].Build();
|
||||
if (direction == kIncomingPacket) {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketIncoming>(buffer));
|
||||
} else {
|
||||
history_.push_back(
|
||||
absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
|
||||
}
|
||||
fake_clock.AdvanceTimeMicros(prng_.Rand(0, 1000) * 1000);
|
||||
}
|
||||
|
||||
std::string encoded =
|
||||
encoder_->EncodeBatch(history_.begin(), history_.end());
|
||||
ASSERT_TRUE(parsed_log_.ParseString(encoded));
|
||||
|
||||
const auto& transport_feedbacks =
|
||||
parsed_log_.transport_feedbacks(direction);
|
||||
ASSERT_EQ(transport_feedbacks.size(), event_count_);
|
||||
|
||||
for (size_t i = 0; i < event_count_; ++i) {
|
||||
verifier_.VerifyLoggedTransportFeedback(timestamps_us[i], events[i],
|
||||
transport_feedbacks[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketIncoming) {
|
||||
TestRtpPackets<RtcEventRtpPacketIncoming, LoggedRtpPacketIncoming>();
|
||||
}
|
||||
|
||||
@ -725,6 +725,55 @@ void StoreRtcpPackets(const ProtoType& proto,
|
||||
}
|
||||
}
|
||||
|
||||
void StoreRtcpBlocks(
|
||||
int64_t timestamp_us,
|
||||
const uint8_t* packet_begin,
|
||||
const uint8_t* packet_end,
|
||||
std::vector<LoggedRtcpPacketTransportFeedback>* transport_feedback_list,
|
||||
std::vector<LoggedRtcpPacketSenderReport>* sr_list,
|
||||
std::vector<LoggedRtcpPacketReceiverReport>* rr_list,
|
||||
std::vector<LoggedRtcpPacketRemb>* remb_list,
|
||||
std::vector<LoggedRtcpPacketNack>* nack_list) {
|
||||
rtcp::CommonHeader header;
|
||||
for (const uint8_t* block = packet_begin; block < packet_end;
|
||||
block = header.NextPacket()) {
|
||||
RTC_CHECK(header.Parse(block, packet_end - block));
|
||||
if (header.type() == rtcp::TransportFeedback::kPacketType &&
|
||||
header.fmt() == rtcp::TransportFeedback::kFeedbackMessageType) {
|
||||
LoggedRtcpPacketTransportFeedback parsed_block;
|
||||
parsed_block.timestamp_us = timestamp_us;
|
||||
if (parsed_block.transport_feedback.Parse(header))
|
||||
transport_feedback_list->push_back(std::move(parsed_block));
|
||||
} else if (header.type() == rtcp::SenderReport::kPacketType) {
|
||||
LoggedRtcpPacketSenderReport parsed_block;
|
||||
parsed_block.timestamp_us = timestamp_us;
|
||||
if (parsed_block.sr.Parse(header)) {
|
||||
sr_list->push_back(std::move(parsed_block));
|
||||
}
|
||||
} else if (header.type() == rtcp::ReceiverReport::kPacketType) {
|
||||
LoggedRtcpPacketReceiverReport parsed_block;
|
||||
parsed_block.timestamp_us = timestamp_us;
|
||||
if (parsed_block.rr.Parse(header)) {
|
||||
rr_list->push_back(std::move(parsed_block));
|
||||
}
|
||||
} else if (header.type() == rtcp::Remb::kPacketType &&
|
||||
header.fmt() == rtcp::Remb::kFeedbackMessageType) {
|
||||
LoggedRtcpPacketRemb parsed_block;
|
||||
parsed_block.timestamp_us = timestamp_us;
|
||||
if (parsed_block.remb.Parse(header)) {
|
||||
remb_list->push_back(std::move(parsed_block));
|
||||
}
|
||||
} else if (header.type() == rtcp::Nack::kPacketType &&
|
||||
header.fmt() == rtcp::Nack::kFeedbackMessageType) {
|
||||
LoggedRtcpPacketNack parsed_block;
|
||||
parsed_block.timestamp_us = timestamp_us;
|
||||
if (parsed_block.nack.Parse(header)) {
|
||||
nack_list->push_back(std::move(parsed_block));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
LoggedRtcpPacket::LoggedRtcpPacket(uint64_t timestamp_us,
|
||||
@ -922,7 +971,7 @@ bool ParsedRtcEventLogNew::ParseStream(
|
||||
}
|
||||
outgoing_rtp_packets_map_.clear();
|
||||
|
||||
// Build PacketViews for easier iteration over RTP packets
|
||||
// Build PacketViews for easier iteration over RTP packets.
|
||||
for (const auto& stream : incoming_rtp_packets_by_ssrc_) {
|
||||
incoming_rtp_packet_views_by_ssrc_.emplace_back(
|
||||
LoggedRtpStreamView(stream.ssrc, stream.incoming_packets.data(),
|
||||
@ -934,6 +983,25 @@ bool ParsedRtcEventLogNew::ParseStream(
|
||||
stream.outgoing_packets.size()));
|
||||
}
|
||||
|
||||
// Set up convenience wrappers around the most commonly used RTCP types.
|
||||
for (const auto& incoming : incoming_rtcp_packets_) {
|
||||
const int64_t timestamp_us = incoming.rtcp.timestamp_us;
|
||||
const uint8_t* packet_begin = incoming.rtcp.raw_data.data();
|
||||
const uint8_t* packet_end = packet_begin + incoming.rtcp.raw_data.size();
|
||||
StoreRtcpBlocks(timestamp_us, packet_begin, packet_end,
|
||||
&incoming_transport_feedback_, &incoming_sr_, &incoming_rr_,
|
||||
&incoming_remb_, &incoming_nack_);
|
||||
}
|
||||
|
||||
for (const auto& outgoing : outgoing_rtcp_packets_) {
|
||||
const int64_t timestamp_us = outgoing.rtcp.timestamp_us;
|
||||
const uint8_t* packet_begin = outgoing.rtcp.raw_data.data();
|
||||
const uint8_t* packet_end = packet_begin + outgoing.rtcp.raw_data.size();
|
||||
StoreRtcpBlocks(timestamp_us, packet_begin, packet_end,
|
||||
&outgoing_transport_feedback_, &outgoing_sr_, &outgoing_rr_,
|
||||
&outgoing_remb_, &outgoing_nack_);
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
@ -1154,68 +1222,6 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
|
||||
outgoing_rtcp_packets_.push_back(
|
||||
LoggedRtcpPacketOutgoing(timestamp_us, packet, total_length));
|
||||
}
|
||||
rtcp::CommonHeader header;
|
||||
const uint8_t* packet_end = packet + total_length;
|
||||
for (const uint8_t* block = packet; block < packet_end;
|
||||
block = header.NextPacket()) {
|
||||
RTC_CHECK(header.Parse(block, packet_end - block));
|
||||
if (header.type() == rtcp::TransportFeedback::kPacketType &&
|
||||
header.fmt() == rtcp::TransportFeedback::kFeedbackMessageType) {
|
||||
if (direction == kIncomingPacket) {
|
||||
incoming_transport_feedback_.emplace_back();
|
||||
LoggedRtcpPacketTransportFeedback& parsed_block =
|
||||
incoming_transport_feedback_.back();
|
||||
parsed_block.timestamp_us = GetTimestamp(event);
|
||||
if (!parsed_block.transport_feedback.Parse(header))
|
||||
incoming_transport_feedback_.pop_back();
|
||||
} else {
|
||||
outgoing_transport_feedback_.emplace_back();
|
||||
LoggedRtcpPacketTransportFeedback& parsed_block =
|
||||
outgoing_transport_feedback_.back();
|
||||
parsed_block.timestamp_us = GetTimestamp(event);
|
||||
if (!parsed_block.transport_feedback.Parse(header))
|
||||
outgoing_transport_feedback_.pop_back();
|
||||
}
|
||||
} else if (header.type() == rtcp::SenderReport::kPacketType) {
|
||||
LoggedRtcpPacketSenderReport parsed_block;
|
||||
parsed_block.timestamp_us = GetTimestamp(event);
|
||||
if (parsed_block.sr.Parse(header)) {
|
||||
if (direction == kIncomingPacket)
|
||||
incoming_sr_.push_back(std::move(parsed_block));
|
||||
else
|
||||
outgoing_sr_.push_back(std::move(parsed_block));
|
||||
}
|
||||
} else if (header.type() == rtcp::ReceiverReport::kPacketType) {
|
||||
LoggedRtcpPacketReceiverReport parsed_block;
|
||||
parsed_block.timestamp_us = GetTimestamp(event);
|
||||
if (parsed_block.rr.Parse(header)) {
|
||||
if (direction == kIncomingPacket)
|
||||
incoming_rr_.push_back(std::move(parsed_block));
|
||||
else
|
||||
outgoing_rr_.push_back(std::move(parsed_block));
|
||||
}
|
||||
} else if (header.type() == rtcp::Remb::kPacketType &&
|
||||
header.fmt() == rtcp::Remb::kFeedbackMessageType) {
|
||||
LoggedRtcpPacketRemb parsed_block;
|
||||
parsed_block.timestamp_us = GetTimestamp(event);
|
||||
if (parsed_block.remb.Parse(header)) {
|
||||
if (direction == kIncomingPacket)
|
||||
incoming_remb_.push_back(std::move(parsed_block));
|
||||
else
|
||||
outgoing_remb_.push_back(std::move(parsed_block));
|
||||
}
|
||||
} else if (header.type() == rtcp::Nack::kPacketType &&
|
||||
header.fmt() == rtcp::Nack::kFeedbackMessageType) {
|
||||
LoggedRtcpPacketNack parsed_block;
|
||||
parsed_block.timestamp_us = GetTimestamp(event);
|
||||
if (parsed_block.nack.Parse(header)) {
|
||||
if (direction == kIncomingPacket)
|
||||
incoming_nack_.push_back(std::move(parsed_block));
|
||||
else
|
||||
outgoing_nack_.push_back(std::move(parsed_block));
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case rtclog::Event::LOG_START: {
|
||||
|
||||
@ -244,7 +244,9 @@ rtcp::SenderReport EventGenerator::NewSenderReport() {
|
||||
rtcp::SenderReport sender_report;
|
||||
sender_report.SetSenderSsrc(prng_.Rand<uint32_t>());
|
||||
sender_report.SetNtp(NtpTime(prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>()));
|
||||
sender_report.SetRtpTimestamp(prng_.Rand<uint32_t>());
|
||||
sender_report.SetPacketCount(prng_.Rand<uint32_t>());
|
||||
sender_report.SetOctetCount(prng_.Rand<uint32_t>());
|
||||
sender_report.AddReportBlock(NewReportBlock());
|
||||
return sender_report;
|
||||
}
|
||||
@ -256,20 +258,82 @@ rtcp::ReceiverReport EventGenerator::NewReceiverReport() {
|
||||
return receiver_report;
|
||||
}
|
||||
|
||||
rtcp::Nack EventGenerator::NewNack() {
|
||||
rtcp::Nack nack;
|
||||
uint16_t base_seq_no = prng_.Rand<uint16_t>();
|
||||
std::vector<uint16_t> nack_list;
|
||||
nack_list.push_back(base_seq_no);
|
||||
for (uint16_t i = 1u; i < 10u; i++) {
|
||||
if (prng_.Rand<bool>())
|
||||
nack_list.push_back(base_seq_no + i);
|
||||
}
|
||||
nack.SetPacketIds(nack_list);
|
||||
return nack;
|
||||
}
|
||||
|
||||
rtcp::TransportFeedback EventGenerator::NewTransportFeedback() {
|
||||
rtcp::TransportFeedback transport_feedback;
|
||||
uint16_t base_seq_no = prng_.Rand<uint16_t>();
|
||||
int64_t base_time_us = prng_.Rand<uint32_t>();
|
||||
transport_feedback.SetBase(base_seq_no, base_time_us);
|
||||
int64_t time_us = base_time_us;
|
||||
for (uint16_t i = 1u; i < 10u; i++) {
|
||||
time_us += prng_.Rand(0, 100000);
|
||||
if (prng_.Rand<bool>()) {
|
||||
transport_feedback.AddReceivedPacket(base_seq_no + i, time_us);
|
||||
}
|
||||
}
|
||||
return transport_feedback;
|
||||
}
|
||||
|
||||
rtcp::Remb EventGenerator::NewRemb() {
|
||||
rtcp::Remb remb;
|
||||
// The remb bitrate is transported as a 16-bit mantissa and an 8-bit exponent.
|
||||
uint64_t bitrate_bps = prng_.Rand(0, (1 << 16) - 1) << prng_.Rand(7);
|
||||
std::vector<uint32_t> ssrcs{prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>()};
|
||||
remb.SetSsrcs(ssrcs);
|
||||
remb.SetBitrateBps(bitrate_bps);
|
||||
return remb;
|
||||
}
|
||||
|
||||
std::unique_ptr<RtcEventRtcpPacketIncoming>
|
||||
EventGenerator::NewRtcpPacketIncoming() {
|
||||
// TODO(terelius): Test the other RTCP types too.
|
||||
switch (prng_.Rand(0, 1)) {
|
||||
case 0: {
|
||||
enum class SupportedRtcpTypes {
|
||||
kSenderReport = 0,
|
||||
kReceiverReport,
|
||||
kNack,
|
||||
kRemb,
|
||||
kTransportFeedback,
|
||||
kNumValues
|
||||
};
|
||||
SupportedRtcpTypes type = static_cast<SupportedRtcpTypes>(
|
||||
prng_.Rand(0, static_cast<int>(SupportedRtcpTypes::kNumValues) - 1));
|
||||
switch (type) {
|
||||
case SupportedRtcpTypes::kSenderReport: {
|
||||
rtcp::SenderReport sender_report = NewSenderReport();
|
||||
rtc::Buffer buffer = sender_report.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
|
||||
}
|
||||
case 1: {
|
||||
case SupportedRtcpTypes::kReceiverReport: {
|
||||
rtcp::ReceiverReport receiver_report = NewReceiverReport();
|
||||
rtc::Buffer buffer = receiver_report.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
|
||||
}
|
||||
case SupportedRtcpTypes::kNack: {
|
||||
rtcp::Nack nack = NewNack();
|
||||
rtc::Buffer buffer = nack.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
|
||||
}
|
||||
case SupportedRtcpTypes::kRemb: {
|
||||
rtcp::Remb remb = NewRemb();
|
||||
rtc::Buffer buffer = remb.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
|
||||
}
|
||||
case SupportedRtcpTypes::kTransportFeedback: {
|
||||
rtcp::TransportFeedback transport_feedback = NewTransportFeedback();
|
||||
rtc::Buffer buffer = transport_feedback.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
|
||||
}
|
||||
default:
|
||||
RTC_NOTREACHED();
|
||||
rtc::Buffer buffer;
|
||||
@ -279,18 +343,42 @@ EventGenerator::NewRtcpPacketIncoming() {
|
||||
|
||||
std::unique_ptr<RtcEventRtcpPacketOutgoing>
|
||||
EventGenerator::NewRtcpPacketOutgoing() {
|
||||
// TODO(terelius): Test the other RTCP types too.
|
||||
switch (prng_.Rand(0, 1)) {
|
||||
case 0: {
|
||||
enum class SupportedRtcpTypes {
|
||||
kSenderReport = 0,
|
||||
kReceiverReport,
|
||||
kNack,
|
||||
kRemb,
|
||||
kTransportFeedback,
|
||||
kNumValues
|
||||
};
|
||||
SupportedRtcpTypes type = static_cast<SupportedRtcpTypes>(
|
||||
prng_.Rand(0, static_cast<int>(SupportedRtcpTypes::kNumValues) - 1));
|
||||
switch (type) {
|
||||
case SupportedRtcpTypes::kSenderReport: {
|
||||
rtcp::SenderReport sender_report = NewSenderReport();
|
||||
rtc::Buffer buffer = sender_report.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
|
||||
}
|
||||
case 1: {
|
||||
case SupportedRtcpTypes::kReceiverReport: {
|
||||
rtcp::ReceiverReport receiver_report = NewReceiverReport();
|
||||
rtc::Buffer buffer = receiver_report.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
|
||||
}
|
||||
case SupportedRtcpTypes::kNack: {
|
||||
rtcp::Nack nack = NewNack();
|
||||
rtc::Buffer buffer = nack.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
|
||||
}
|
||||
case SupportedRtcpTypes::kRemb: {
|
||||
rtcp::Remb remb = NewRemb();
|
||||
rtc::Buffer buffer = remb.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
|
||||
}
|
||||
case SupportedRtcpTypes::kTransportFeedback: {
|
||||
rtcp::TransportFeedback transport_feedback = NewTransportFeedback();
|
||||
rtc::Buffer buffer = transport_feedback.Build();
|
||||
return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
|
||||
}
|
||||
default:
|
||||
RTC_NOTREACHED();
|
||||
rtc::Buffer buffer;
|
||||
@ -782,6 +870,93 @@ void EventVerifier::VerifyLoggedRtcpPacketOutgoing(
|
||||
0);
|
||||
}
|
||||
|
||||
void EventVerifier::VerifyReportBlock(
|
||||
const rtcp::ReportBlock& original_report_block,
|
||||
const rtcp::ReportBlock& logged_report_block) {
|
||||
EXPECT_EQ(original_report_block.source_ssrc(),
|
||||
logged_report_block.source_ssrc());
|
||||
EXPECT_EQ(original_report_block.fraction_lost(),
|
||||
logged_report_block.fraction_lost());
|
||||
EXPECT_EQ(original_report_block.cumulative_lost_signed(),
|
||||
logged_report_block.cumulative_lost_signed());
|
||||
EXPECT_EQ(original_report_block.extended_high_seq_num(),
|
||||
logged_report_block.extended_high_seq_num());
|
||||
EXPECT_EQ(original_report_block.jitter(), logged_report_block.jitter());
|
||||
EXPECT_EQ(original_report_block.last_sr(), logged_report_block.last_sr());
|
||||
EXPECT_EQ(original_report_block.delay_since_last_sr(),
|
||||
logged_report_block.delay_since_last_sr());
|
||||
}
|
||||
|
||||
void EventVerifier::VerifyLoggedSenderReport(
|
||||
int64_t log_time_us,
|
||||
const rtcp::SenderReport& original_sr,
|
||||
const LoggedRtcpPacketSenderReport& logged_sr) {
|
||||
EXPECT_EQ(log_time_us, logged_sr.log_time_us());
|
||||
EXPECT_EQ(original_sr.sender_ssrc(), logged_sr.sr.sender_ssrc());
|
||||
EXPECT_EQ(original_sr.ntp(), logged_sr.sr.ntp());
|
||||
EXPECT_EQ(original_sr.rtp_timestamp(), logged_sr.sr.rtp_timestamp());
|
||||
EXPECT_EQ(original_sr.sender_packet_count(),
|
||||
logged_sr.sr.sender_packet_count());
|
||||
EXPECT_EQ(original_sr.sender_octet_count(),
|
||||
logged_sr.sr.sender_octet_count());
|
||||
ASSERT_EQ(original_sr.report_blocks().size(),
|
||||
logged_sr.sr.report_blocks().size());
|
||||
for (size_t i = 0; i < original_sr.report_blocks().size(); i++) {
|
||||
VerifyReportBlock(original_sr.report_blocks()[i],
|
||||
logged_sr.sr.report_blocks()[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void EventVerifier::VerifyLoggedReceiverReport(
|
||||
int64_t log_time_us,
|
||||
const rtcp::ReceiverReport& original_rr,
|
||||
const LoggedRtcpPacketReceiverReport& logged_rr) {
|
||||
EXPECT_EQ(log_time_us, logged_rr.log_time_us());
|
||||
EXPECT_EQ(original_rr.sender_ssrc(), logged_rr.rr.sender_ssrc());
|
||||
ASSERT_EQ(original_rr.report_blocks().size(),
|
||||
logged_rr.rr.report_blocks().size());
|
||||
for (size_t i = 0; i < original_rr.report_blocks().size(); i++) {
|
||||
VerifyReportBlock(original_rr.report_blocks()[i],
|
||||
logged_rr.rr.report_blocks()[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void EventVerifier::VerifyLoggedNack(int64_t log_time_us,
|
||||
const rtcp::Nack& original_nack,
|
||||
const LoggedRtcpPacketNack& logged_nack) {
|
||||
EXPECT_EQ(log_time_us, logged_nack.log_time_us());
|
||||
EXPECT_EQ(original_nack.packet_ids(), logged_nack.nack.packet_ids());
|
||||
}
|
||||
|
||||
void EventVerifier::VerifyLoggedTransportFeedback(
|
||||
int64_t log_time_us,
|
||||
const rtcp::TransportFeedback& original_transport_feedback,
|
||||
const LoggedRtcpPacketTransportFeedback& logged_transport_feedback) {
|
||||
EXPECT_EQ(log_time_us, logged_transport_feedback.log_time_us());
|
||||
ASSERT_EQ(
|
||||
original_transport_feedback.GetReceivedPackets().size(),
|
||||
logged_transport_feedback.transport_feedback.GetReceivedPackets().size());
|
||||
for (size_t i = 0;
|
||||
i < original_transport_feedback.GetReceivedPackets().size(); i++) {
|
||||
EXPECT_EQ(
|
||||
original_transport_feedback.GetReceivedPackets()[i].sequence_number(),
|
||||
logged_transport_feedback.transport_feedback.GetReceivedPackets()[i]
|
||||
.sequence_number());
|
||||
EXPECT_EQ(
|
||||
original_transport_feedback.GetReceivedPackets()[i].delta_us(),
|
||||
logged_transport_feedback.transport_feedback.GetReceivedPackets()[i]
|
||||
.delta_us());
|
||||
}
|
||||
}
|
||||
|
||||
void EventVerifier::VerifyLoggedRemb(int64_t log_time_us,
|
||||
const rtcp::Remb& original_remb,
|
||||
const LoggedRtcpPacketRemb& logged_remb) {
|
||||
EXPECT_EQ(log_time_us, logged_remb.log_time_us());
|
||||
EXPECT_EQ(original_remb.ssrcs(), logged_remb.remb.ssrcs());
|
||||
EXPECT_EQ(original_remb.bitrate_bps(), logged_remb.remb.bitrate_bps());
|
||||
}
|
||||
|
||||
void EventVerifier::VerifyLoggedStartEvent(
|
||||
int64_t start_time_us,
|
||||
int64_t utc_start_time_us,
|
||||
|
||||
@ -80,6 +80,12 @@ class EventGenerator {
|
||||
|
||||
std::unique_ptr<RtcEventRtcpPacketOutgoing> NewRtcpPacketOutgoing();
|
||||
|
||||
rtcp::SenderReport NewSenderReport();
|
||||
rtcp::ReceiverReport NewReceiverReport();
|
||||
rtcp::Nack NewNack();
|
||||
rtcp::TransportFeedback NewTransportFeedback();
|
||||
rtcp::Remb NewRemb();
|
||||
|
||||
// |all_configured_exts| determines whether the RTP packet exhibits all
|
||||
// configured extensions, or a random subset thereof.
|
||||
void RandomizeRtpPacket(size_t payload_size,
|
||||
@ -125,8 +131,6 @@ class EventGenerator {
|
||||
|
||||
private:
|
||||
rtcp::ReportBlock NewReportBlock();
|
||||
rtcp::SenderReport NewSenderReport();
|
||||
rtcp::ReceiverReport NewReceiverReport();
|
||||
|
||||
Random prng_;
|
||||
};
|
||||
@ -219,6 +223,24 @@ class EventVerifier {
|
||||
const RtcEventRtcpPacketOutgoing& original_event,
|
||||
const LoggedRtcpPacketOutgoing& logged_event) const;
|
||||
|
||||
void VerifyLoggedSenderReport(int64_t log_time_us,
|
||||
const rtcp::SenderReport& original_sr,
|
||||
const LoggedRtcpPacketSenderReport& logged_sr);
|
||||
void VerifyLoggedReceiverReport(
|
||||
int64_t log_time_us,
|
||||
const rtcp::ReceiverReport& original_rr,
|
||||
const LoggedRtcpPacketReceiverReport& logged_rr);
|
||||
void VerifyLoggedNack(int64_t log_time_us,
|
||||
const rtcp::Nack& original_nack,
|
||||
const LoggedRtcpPacketNack& logged_nack);
|
||||
void VerifyLoggedTransportFeedback(
|
||||
int64_t log_time_us,
|
||||
const rtcp::TransportFeedback& original_transport_feedback,
|
||||
const LoggedRtcpPacketTransportFeedback& logged_transport_feedback);
|
||||
void VerifyLoggedRemb(int64_t log_time_us,
|
||||
const rtcp::Remb& original_remb,
|
||||
const LoggedRtcpPacketRemb& logged_remb);
|
||||
|
||||
void VerifyLoggedStartEvent(int64_t start_time_us,
|
||||
int64_t utc_start_time_us,
|
||||
const LoggedStartEvent& logged_event) const;
|
||||
@ -242,6 +264,9 @@ class EventVerifier {
|
||||
const LoggedVideoSendConfig& logged_event) const;
|
||||
|
||||
private:
|
||||
void VerifyReportBlock(const rtcp::ReportBlock& original_report_block,
|
||||
const rtcp::ReportBlock& logged_report_block);
|
||||
|
||||
RtcEventLog::EncodingType encoding_type_;
|
||||
};
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user