From ebb677773a2561c54b312a9095e3ccef1ad61fca Mon Sep 17 00:00:00 2001 From: Bjorn Terelius Date: Tue, 4 Dec 2018 11:13:42 +0100 Subject: [PATCH] Allow access to specific RTCP types in new format event log parser. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:8111 Change-Id: Ia727c8fd9ddaa9f0c17fea5af8f544ad01e66367 Reviewed-on: https://webrtc-review.googlesource.com/c/112382 Commit-Queue: Björn Terelius Reviewed-by: Elad Alon Cr-Commit-Position: refs/heads/master@{#25886} --- .../encoder/rtc_event_log_encoder_unittest.cc | 196 ++++++++++++++++++ .../rtc_event_log/rtc_event_log_parser_new.cc | 132 ++++++------ .../rtc_event_log_unittest_helper.cc | 191 ++++++++++++++++- .../rtc_event_log_unittest_helper.h | 29 ++- 4 files changed, 475 insertions(+), 73 deletions(-) diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc index 865b4b09a9..7054365e48 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc @@ -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(prng_.Rand()) * 1000); + + for (auto direction : {kIncomingPacket, kOutgoingPacket}) { + std::vector events(event_count_); + std::vector 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(buffer)); + } else { + history_.push_back( + absl::make_unique(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(prng_.Rand()) * 1000); + + for (auto direction : {kIncomingPacket, kOutgoingPacket}) { + std::vector events(event_count_); + std::vector 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(buffer)); + } else { + history_.push_back( + absl::make_unique(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(prng_.Rand()) * 1000); + + for (auto direction : {kIncomingPacket, kOutgoingPacket}) { + std::vector events(event_count_); + std::vector 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(buffer)); + } else { + history_.push_back( + absl::make_unique(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(prng_.Rand()) * 1000); + + for (auto direction : {kIncomingPacket, kOutgoingPacket}) { + std::vector events(event_count_); + std::vector 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(buffer)); + } else { + history_.push_back( + absl::make_unique(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(prng_.Rand()) * 1000); + + for (auto direction : {kIncomingPacket, kOutgoingPacket}) { + std::vector events; + events.reserve(event_count_); + std::vector 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(buffer)); + } else { + history_.push_back( + absl::make_unique(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(); } diff --git a/logging/rtc_event_log/rtc_event_log_parser_new.cc b/logging/rtc_event_log/rtc_event_log_parser_new.cc index d0b20380ab..672fcc1aab 100644 --- a/logging/rtc_event_log/rtc_event_log_parser_new.cc +++ b/logging/rtc_event_log/rtc_event_log_parser_new.cc @@ -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* transport_feedback_list, + std::vector* sr_list, + std::vector* rr_list, + std::vector* remb_list, + std::vector* 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: { diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc index 249d601c3f..a92e6663a4 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc @@ -244,7 +244,9 @@ rtcp::SenderReport EventGenerator::NewSenderReport() { rtcp::SenderReport sender_report; sender_report.SetSenderSsrc(prng_.Rand()); sender_report.SetNtp(NtpTime(prng_.Rand(), prng_.Rand())); + sender_report.SetRtpTimestamp(prng_.Rand()); sender_report.SetPacketCount(prng_.Rand()); + sender_report.SetOctetCount(prng_.Rand()); 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(); + std::vector nack_list; + nack_list.push_back(base_seq_no); + for (uint16_t i = 1u; i < 10u; i++) { + if (prng_.Rand()) + 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(); + int64_t base_time_us = prng_.Rand(); + 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()) { + 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 ssrcs{prng_.Rand(), prng_.Rand()}; + remb.SetSsrcs(ssrcs); + remb.SetBitrateBps(bitrate_bps); + return remb; +} + std::unique_ptr 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( + prng_.Rand(0, static_cast(SupportedRtcpTypes::kNumValues) - 1)); + switch (type) { + case SupportedRtcpTypes::kSenderReport: { rtcp::SenderReport sender_report = NewSenderReport(); rtc::Buffer buffer = sender_report.Build(); return absl::make_unique(buffer); } - case 1: { + case SupportedRtcpTypes::kReceiverReport: { rtcp::ReceiverReport receiver_report = NewReceiverReport(); rtc::Buffer buffer = receiver_report.Build(); return absl::make_unique(buffer); } + case SupportedRtcpTypes::kNack: { + rtcp::Nack nack = NewNack(); + rtc::Buffer buffer = nack.Build(); + return absl::make_unique(buffer); + } + case SupportedRtcpTypes::kRemb: { + rtcp::Remb remb = NewRemb(); + rtc::Buffer buffer = remb.Build(); + return absl::make_unique(buffer); + } + case SupportedRtcpTypes::kTransportFeedback: { + rtcp::TransportFeedback transport_feedback = NewTransportFeedback(); + rtc::Buffer buffer = transport_feedback.Build(); + return absl::make_unique(buffer); + } default: RTC_NOTREACHED(); rtc::Buffer buffer; @@ -279,18 +343,42 @@ EventGenerator::NewRtcpPacketIncoming() { std::unique_ptr 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( + prng_.Rand(0, static_cast(SupportedRtcpTypes::kNumValues) - 1)); + switch (type) { + case SupportedRtcpTypes::kSenderReport: { rtcp::SenderReport sender_report = NewSenderReport(); rtc::Buffer buffer = sender_report.Build(); return absl::make_unique(buffer); } - case 1: { + case SupportedRtcpTypes::kReceiverReport: { rtcp::ReceiverReport receiver_report = NewReceiverReport(); rtc::Buffer buffer = receiver_report.Build(); return absl::make_unique(buffer); } + case SupportedRtcpTypes::kNack: { + rtcp::Nack nack = NewNack(); + rtc::Buffer buffer = nack.Build(); + return absl::make_unique(buffer); + } + case SupportedRtcpTypes::kRemb: { + rtcp::Remb remb = NewRemb(); + rtc::Buffer buffer = remb.Build(); + return absl::make_unique(buffer); + } + case SupportedRtcpTypes::kTransportFeedback: { + rtcp::TransportFeedback transport_feedback = NewTransportFeedback(); + rtc::Buffer buffer = transport_feedback.Build(); + return absl::make_unique(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, diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.h b/logging/rtc_event_log/rtc_event_log_unittest_helper.h index 82f20f7684..a840371e0a 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.h +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.h @@ -80,6 +80,12 @@ class EventGenerator { std::unique_ptr 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_; };