Parse XR, FIR and PLI in rtc_event_log_parser.cc

Bug: webrtc:10312
Change-Id: I1b24e23f8002feef8a2ef928130ac6da19c3cd81
Reviewed-on: https://webrtc-review.googlesource.com/c/122580
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Mirta Dvornicic <mirtad@webrtc.org>
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26670}

logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc

@@ -813,6 +813,121 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpSenderReport) {
   }
 }
 
+TEST_P(RtcEventLogEncoderTest, RtcEventRtcpExtendedReports) {
+  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::ExtendedReports> 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_.NewExtendedReports();
+      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& extended_reports = parsed_log_.extended_reports(direction);
+    ASSERT_EQ(extended_reports.size(), event_count_);
+
+    for (size_t i = 0; i < event_count_; ++i) {
+      verifier_.VerifyLoggedExtendedReports(timestamps_us[i], events[i],
+                                            extended_reports[i]);
+    }
+  }
+}
+
+TEST_P(RtcEventLogEncoderTest, RtcEventRtcpFir) {
+  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::Fir> 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_.NewFir();
+      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& firs = parsed_log_.firs(direction);
+    ASSERT_EQ(firs.size(), event_count_);
+
+    for (size_t i = 0; i < event_count_; ++i) {
+      verifier_.VerifyLoggedFir(timestamps_us[i], events[i], firs[i]);
+    }
+  }
+}
+
+TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPli) {
+  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::Pli> 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_.NewPli();
+      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& plis = parsed_log_.plis(direction);
+    ASSERT_EQ(plis.size(), event_count_);
+
+    for (size_t i = 0; i < event_count_; ++i) {
+      verifier_.VerifyLoggedPli(timestamps_us[i], events[i], plis[i]);
+    }
+  }
+}
+
 TEST_P(RtcEventLogEncoderTest, RtcEventRtcpNack) {
   if (force_repeated_fields_) {
     return;

logging/rtc_event_log/logged_events.h

@@ -25,8 +25,11 @@
 #include "logging/rtc_event_log/rtc_stream_config.h"
 #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/rtcp_packet/extended_reports.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/loss_notification.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/pli.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
@@ -334,6 +337,16 @@ struct LoggedRtcpPacketSenderReport {
   rtcp::SenderReport sr;
 };
 
+struct LoggedRtcpPacketExtendedReports {
+  LoggedRtcpPacketExtendedReports() = default;
+
+  int64_t log_time_us() const { return timestamp_us; }
+  int64_t log_time_ms() const { return timestamp_us / 1000; }
+
+  int64_t timestamp_us;
+  rtcp::ExtendedReports xr;
+};
+
 struct LoggedRtcpPacketRemb {
   LoggedRtcpPacketRemb() = default;
   LoggedRtcpPacketRemb(int64_t timestamp_us, const rtcp::Remb& remb)
@@ -358,6 +371,26 @@ struct LoggedRtcpPacketNack {
   rtcp::Nack nack;
 };
 
+struct LoggedRtcpPacketFir {
+  LoggedRtcpPacketFir() = default;
+
+  int64_t log_time_us() const { return timestamp_us; }
+  int64_t log_time_ms() const { return timestamp_us / 1000; }
+
+  int64_t timestamp_us;
+  rtcp::Fir fir;
+};
+
+struct LoggedRtcpPacketPli {
+  LoggedRtcpPacketPli() = default;
+
+  int64_t log_time_us() const { return timestamp_us; }
+  int64_t log_time_ms() const { return timestamp_us / 1000; }
+
+  int64_t timestamp_us;
+  rtcp::Pli pli;
+};
+
 struct LoggedRtcpPacketTransportFeedback {
   LoggedRtcpPacketTransportFeedback() = default;
   LoggedRtcpPacketTransportFeedback(

logging/rtc_event_log/rtc_event_log_parser.cc

@@ -803,11 +803,14 @@ 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<LoggedRtcpPacketExtendedReports>* xr_list,
     std::vector<LoggedRtcpPacketRemb>* remb_list,
     std::vector<LoggedRtcpPacketNack>* nack_list,
+    std::vector<LoggedRtcpPacketFir>* fir_list,
+    std::vector<LoggedRtcpPacketPli>* pli_list,
+    std::vector<LoggedRtcpPacketTransportFeedback>* transport_feedback_list,
     std::vector<LoggedRtcpPacketLossNotification>* loss_notification_list) {
   rtcp::CommonHeader header;
   for (const uint8_t* block = packet_begin; block < packet_end;
@@ -831,6 +834,26 @@ void StoreRtcpBlocks(
       if (parsed_block.rr.Parse(header)) {
         rr_list->push_back(std::move(parsed_block));
       }
+    } else if (header.type() == rtcp::ExtendedReports::kPacketType) {
+      LoggedRtcpPacketExtendedReports parsed_block;
+      parsed_block.timestamp_us = timestamp_us;
+      if (parsed_block.xr.Parse(header)) {
+        xr_list->push_back(std::move(parsed_block));
+      }
+    } else if (header.type() == rtcp::Fir::kPacketType &&
+               header.fmt() == rtcp::Fir::kFeedbackMessageType) {
+      LoggedRtcpPacketFir parsed_block;
+      parsed_block.timestamp_us = timestamp_us;
+      if (parsed_block.fir.Parse(header)) {
+        fir_list->push_back(std::move(parsed_block));
+      }
+    } else if (header.type() == rtcp::Pli::kPacketType &&
+               header.fmt() == rtcp::Pli::kFeedbackMessageType) {
+      LoggedRtcpPacketPli parsed_block;
+      parsed_block.timestamp_us = timestamp_us;
+      if (parsed_block.pli.Parse(header)) {
+        pli_list->push_back(std::move(parsed_block));
+      }
     } else if (header.type() == rtcp::Remb::kPacketType &&
                header.fmt() == rtcp::Remb::kFeedbackMessageType) {
       bool type_found = false;
@@ -1088,9 +1111,10 @@ bool ParsedRtcEventLog::ParseStream(
     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_,
+    StoreRtcpBlocks(timestamp_us, packet_begin, packet_end, &incoming_sr_,
+                    &incoming_rr_, &incoming_xr_, &incoming_remb_,
+                    &incoming_nack_, &incoming_fir_, &incoming_pli_,
+                    &incoming_transport_feedback_,
                     &incoming_loss_notification_);
   }
 
@@ -1098,9 +1122,10 @@ bool ParsedRtcEventLog::ParseStream(
     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_,
+    StoreRtcpBlocks(timestamp_us, packet_begin, packet_end, &outgoing_sr_,
+                    &outgoing_rr_, &outgoing_xr_, &outgoing_remb_,
+                    &outgoing_nack_, &outgoing_fir_, &outgoing_pli_,
+                    &outgoing_transport_feedback_,
                     &outgoing_loss_notification_);
   }
 

logging/rtc_event_log/rtc_event_log_parser.h

@@ -434,6 +434,15 @@ class ParsedRtcEventLog {
     }
   }
 
+  const std::vector<LoggedRtcpPacketExtendedReports>& extended_reports(
+      PacketDirection direction) const {
+    if (direction == kIncomingPacket) {
+      return incoming_xr_;
+    } else {
+      return outgoing_xr_;
+    }
+  }
+
   const std::vector<LoggedRtcpPacketNack>& nacks(
       PacketDirection direction) const {
     if (direction == kIncomingPacket) {
@@ -452,6 +461,24 @@ class ParsedRtcEventLog {
     }
   }
 
+  const std::vector<LoggedRtcpPacketFir>& firs(
+      PacketDirection direction) const {
+    if (direction == kIncomingPacket) {
+      return incoming_fir_;
+    } else {
+      return outgoing_fir_;
+    }
+  }
+
+  const std::vector<LoggedRtcpPacketPli>& plis(
+      PacketDirection direction) const {
+    if (direction == kIncomingPacket) {
+      return incoming_pli_;
+    } else {
+      return outgoing_pli_;
+    }
+  }
+
   const std::vector<LoggedRtcpPacketTransportFeedback>& transport_feedbacks(
       PacketDirection direction) const {
     if (direction == kIncomingPacket) {
@@ -653,10 +680,16 @@ class ParsedRtcEventLog {
   std::vector<LoggedRtcpPacketReceiverReport> outgoing_rr_;
   std::vector<LoggedRtcpPacketSenderReport> incoming_sr_;
   std::vector<LoggedRtcpPacketSenderReport> outgoing_sr_;
+  std::vector<LoggedRtcpPacketExtendedReports> incoming_xr_;
+  std::vector<LoggedRtcpPacketExtendedReports> outgoing_xr_;
   std::vector<LoggedRtcpPacketNack> incoming_nack_;
   std::vector<LoggedRtcpPacketNack> outgoing_nack_;
   std::vector<LoggedRtcpPacketRemb> incoming_remb_;
   std::vector<LoggedRtcpPacketRemb> outgoing_remb_;
+  std::vector<LoggedRtcpPacketFir> incoming_fir_;
+  std::vector<LoggedRtcpPacketFir> outgoing_fir_;
+  std::vector<LoggedRtcpPacketPli> incoming_pli_;
+  std::vector<LoggedRtcpPacketPli> outgoing_pli_;
   std::vector<LoggedRtcpPacketTransportFeedback> incoming_transport_feedback_;
   std::vector<LoggedRtcpPacketTransportFeedback> outgoing_transport_feedback_;
   std::vector<LoggedRtcpPacketLossNotification> incoming_loss_notification_;

logging/rtc_event_log/rtc_event_log_unittest_helper.cc

@@ -29,6 +29,9 @@
 #include "modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "modules/rtp_rtcp/include/rtp_cvo.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/rrtr.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
@@ -258,6 +261,29 @@ rtcp::ReceiverReport EventGenerator::NewReceiverReport() {
   return receiver_report;
 }
 
+rtcp::ExtendedReports EventGenerator::NewExtendedReports() {
+  rtcp::ExtendedReports extended_report;
+  extended_report.SetSenderSsrc(prng_.Rand<uint32_t>());
+
+  rtcp::Rrtr rrtr;
+  rrtr.SetNtp(NtpTime(prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>()));
+  extended_report.SetRrtr(rrtr);
+
+  rtcp::ReceiveTimeInfo time_info(
+      prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>());
+  extended_report.AddDlrrItem(time_info);
+
+  rtcp::TargetBitrate target_bitrate;
+  target_bitrate.AddTargetBitrate(/*spatial layer*/ prng_.Rand(0, 3),
+                                  /*temporal layer*/ prng_.Rand(0, 3),
+                                  /*bitrate kbps*/ prng_.Rand(0, 50000));
+  target_bitrate.AddTargetBitrate(/*spatial layer*/ prng_.Rand(4, 7),
+                                  /*temporal layer*/ prng_.Rand(4, 7),
+                                  /*bitrate kbps*/ prng_.Rand(0, 50000));
+  extended_report.SetTargetBitrate(target_bitrate);
+  return extended_report;
+}
+
 rtcp::Nack EventGenerator::NewNack() {
   rtcp::Nack nack;
   uint16_t base_seq_no = prng_.Rand<uint16_t>();
@@ -271,6 +297,23 @@ rtcp::Nack EventGenerator::NewNack() {
   return nack;
 }
 
+rtcp::Fir EventGenerator::NewFir() {
+  rtcp::Fir fir;
+  fir.SetSenderSsrc(prng_.Rand<uint32_t>());
+  fir.AddRequestTo(/*ssrc*/ prng_.Rand<uint32_t>(),
+                   /*seq num*/ prng_.Rand<uint8_t>());
+  fir.AddRequestTo(/*ssrc*/ prng_.Rand<uint32_t>(),
+                   /*seq num*/ prng_.Rand<uint8_t>());
+  return fir;
+}
+
+rtcp::Pli EventGenerator::NewPli() {
+  rtcp::Pli pli;
+  pli.SetSenderSsrc(prng_.Rand<uint32_t>());
+  pli.SetMediaSsrc(prng_.Rand<uint32_t>());
+  return pli;
+}
+
 rtcp::TransportFeedback EventGenerator::NewTransportFeedback() {
   rtcp::TransportFeedback transport_feedback;
   uint16_t base_seq_no = prng_.Rand<uint16_t>();
@@ -312,6 +355,9 @@ EventGenerator::NewRtcpPacketIncoming() {
   enum class SupportedRtcpTypes {
     kSenderReport = 0,
     kReceiverReport,
+    kExtendedReports,
+    kFir,
+    kPli,
     kNack,
     kRemb,
     kTransportFeedback,
@@ -330,6 +376,21 @@ EventGenerator::NewRtcpPacketIncoming() {
       rtc::Buffer buffer = receiver_report.Build();
       return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
     }
+    case SupportedRtcpTypes::kExtendedReports: {
+      rtcp::ExtendedReports extended_report = NewExtendedReports();
+      rtc::Buffer buffer = extended_report.Build();
+      return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
+    }
+    case SupportedRtcpTypes::kFir: {
+      rtcp::Fir fir = NewFir();
+      rtc::Buffer buffer = fir.Build();
+      return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
+    }
+    case SupportedRtcpTypes::kPli: {
+      rtcp::Pli pli = NewPli();
+      rtc::Buffer buffer = pli.Build();
+      return absl::make_unique<RtcEventRtcpPacketIncoming>(buffer);
+    }
     case SupportedRtcpTypes::kNack: {
       rtcp::Nack nack = NewNack();
       rtc::Buffer buffer = nack.Build();
@@ -357,6 +418,9 @@ EventGenerator::NewRtcpPacketOutgoing() {
   enum class SupportedRtcpTypes {
     kSenderReport = 0,
     kReceiverReport,
+    kExtendedReports,
+    kFir,
+    kPli,
     kNack,
     kRemb,
     kTransportFeedback,
@@ -375,6 +439,21 @@ EventGenerator::NewRtcpPacketOutgoing() {
       rtc::Buffer buffer = receiver_report.Build();
       return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
     }
+    case SupportedRtcpTypes::kExtendedReports: {
+      rtcp::ExtendedReports extended_report = NewExtendedReports();
+      rtc::Buffer buffer = extended_report.Build();
+      return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
+    }
+    case SupportedRtcpTypes::kFir: {
+      rtcp::Fir fir = NewFir();
+      rtc::Buffer buffer = fir.Build();
+      return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
+    }
+    case SupportedRtcpTypes::kPli: {
+      rtcp::Pli pli = NewPli();
+      rtc::Buffer buffer = pli.Build();
+      return absl::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
+    }
     case SupportedRtcpTypes::kNack: {
       rtcp::Nack nack = NewNack();
       rtc::Buffer buffer = nack.Build();
@@ -984,6 +1063,68 @@ void EventVerifier::VerifyLoggedReceiverReport(
   }
 }
 
+void EventVerifier::VerifyLoggedExtendedReports(
+    int64_t log_time_us,
+    const rtcp::ExtendedReports& original_xr,
+    const LoggedRtcpPacketExtendedReports& logged_xr) {
+  EXPECT_EQ(original_xr.sender_ssrc(), logged_xr.xr.sender_ssrc());
+
+  EXPECT_EQ(original_xr.rrtr().has_value(), logged_xr.xr.rrtr().has_value());
+  if (original_xr.rrtr().has_value() && logged_xr.xr.rrtr().has_value()) {
+    EXPECT_EQ(original_xr.rrtr()->ntp(), logged_xr.xr.rrtr()->ntp());
+  }
+
+  const auto& original_subblocks = original_xr.dlrr().sub_blocks();
+  const auto& logged_subblocks = logged_xr.xr.dlrr().sub_blocks();
+  ASSERT_EQ(original_subblocks.size(), logged_subblocks.size());
+  for (size_t i = 0; i < original_subblocks.size(); i++) {
+    EXPECT_EQ(original_subblocks[i].ssrc, logged_subblocks[i].ssrc);
+    EXPECT_EQ(original_subblocks[i].last_rr, logged_subblocks[i].last_rr);
+    EXPECT_EQ(original_subblocks[i].delay_since_last_rr,
+              logged_subblocks[i].delay_since_last_rr);
+  }
+
+  EXPECT_EQ(original_xr.target_bitrate().has_value(),
+            logged_xr.xr.target_bitrate().has_value());
+  if (original_xr.target_bitrate().has_value() &&
+      logged_xr.xr.target_bitrate().has_value()) {
+    const auto& original_bitrates =
+        original_xr.target_bitrate()->GetTargetBitrates();
+    const auto& logged_bitrates =
+        logged_xr.xr.target_bitrate()->GetTargetBitrates();
+    ASSERT_EQ(original_bitrates.size(), logged_bitrates.size());
+    for (size_t i = 0; i < original_bitrates.size(); i++) {
+      EXPECT_EQ(original_bitrates[i].spatial_layer,
+                logged_bitrates[i].spatial_layer);
+      EXPECT_EQ(original_bitrates[i].temporal_layer,
+                logged_bitrates[i].temporal_layer);
+      EXPECT_EQ(original_bitrates[i].target_bitrate_kbps,
+                logged_bitrates[i].target_bitrate_kbps);
+    }
+  }
+}
+
+void EventVerifier::VerifyLoggedFir(int64_t log_time_us,
+                                    const rtcp::Fir& original_fir,
+                                    const LoggedRtcpPacketFir& logged_fir) {
+  EXPECT_EQ(original_fir.sender_ssrc(), logged_fir.fir.sender_ssrc());
+
+  const auto& original_requests = original_fir.requests();
+  const auto& logged_requests = logged_fir.fir.requests();
+  ASSERT_EQ(original_requests.size(), logged_requests.size());
+  for (size_t i = 0; i < original_requests.size(); i++) {
+    EXPECT_EQ(original_requests[i].ssrc, logged_requests[i].ssrc);
+    EXPECT_EQ(original_requests[i].seq_nr, logged_requests[i].seq_nr);
+  }
+}
+
+void EventVerifier::VerifyLoggedPli(int64_t log_time_us,
+                                    const rtcp::Pli& original_pli,
+                                    const LoggedRtcpPacketPli& logged_pli) {
+  EXPECT_EQ(original_pli.sender_ssrc(), logged_pli.pli.sender_ssrc());
+  EXPECT_EQ(original_pli.media_ssrc(), logged_pli.pli.media_ssrc());
+}
+
 void EventVerifier::VerifyLoggedNack(int64_t log_time_us,
                                      const rtcp::Nack& original_nack,
                                      const LoggedRtcpPacketNack& logged_nack) {

logging/rtc_event_log/rtc_event_log_unittest_helper.h

@@ -41,8 +41,13 @@
 #include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "logging/rtc_event_log/rtc_stream_config.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/loss_notification.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/pli.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
 #include "modules/rtp_rtcp/source/rtp_packet.h"
@@ -57,31 +62,18 @@ class EventGenerator {
   explicit EventGenerator(uint64_t seed) : prng_(seed) {}
 
   std::unique_ptr<RtcEventAlrState> NewAlrState();
-
   std::unique_ptr<RtcEventAudioPlayout> NewAudioPlayout(uint32_t ssrc);
-
   std::unique_ptr<RtcEventAudioNetworkAdaptation> NewAudioNetworkAdaptation();
-
   std::unique_ptr<RtcEventBweUpdateDelayBased> NewBweUpdateDelayBased();
-
   std::unique_ptr<RtcEventBweUpdateLossBased> NewBweUpdateLossBased();
-
   std::unique_ptr<RtcEventDtlsTransportState> NewDtlsTransportState();
-
   std::unique_ptr<RtcEventDtlsWritableState> NewDtlsWritableState();
-
   std::unique_ptr<RtcEventProbeClusterCreated> NewProbeClusterCreated();
-
   std::unique_ptr<RtcEventProbeResultFailure> NewProbeResultFailure();
-
   std::unique_ptr<RtcEventProbeResultSuccess> NewProbeResultSuccess();
-
   std::unique_ptr<RtcEventIceCandidatePairConfig> NewIceCandidatePairConfig();
-
   std::unique_ptr<RtcEventIceCandidatePair> NewIceCandidatePair();
-
   std::unique_ptr<RtcEventRtcpPacketIncoming> NewRtcpPacketIncoming();
-
   std::unique_ptr<RtcEventRtcpPacketOutgoing> NewRtcpPacketOutgoing();
 
   std::unique_ptr<RtcEventGenericPacketSent> NewGenericPacketSent();
@@ -90,9 +82,12 @@ class EventGenerator {
 
   rtcp::SenderReport NewSenderReport();
   rtcp::ReceiverReport NewReceiverReport();
+  rtcp::ExtendedReports NewExtendedReports();
   rtcp::Nack NewNack();
-  rtcp::TransportFeedback NewTransportFeedback();
   rtcp::Remb NewRemb();
+  rtcp::Fir NewFir();
+  rtcp::Pli NewPli();
+  rtcp::TransportFeedback NewTransportFeedback();
   rtcp::LossNotification NewLossNotification();
 
   // |all_configured_exts| determines whether the RTP packet exhibits all
@@ -253,6 +248,16 @@ class EventVerifier {
       int64_t log_time_us,
       const rtcp::ReceiverReport& original_rr,
       const LoggedRtcpPacketReceiverReport& logged_rr);
+  void VerifyLoggedExtendedReports(
+      int64_t log_time_us,
+      const rtcp::ExtendedReports& original_xr,
+      const LoggedRtcpPacketExtendedReports& logged_xr);
+  void VerifyLoggedFir(int64_t log_time_us,
+                       const rtcp::Fir& original_fir,
+                       const LoggedRtcpPacketFir& logged_fir);
+  void VerifyLoggedPli(int64_t log_time_us,
+                       const rtcp::Pli& original_pli,
+                       const LoggedRtcpPacketPli& logged_pli);
   void VerifyLoggedNack(int64_t log_time_us,
                         const rtcp::Nack& original_nack,
                         const LoggedRtcpPacketNack& logged_nack);

modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc

@@ -44,7 +44,8 @@ constexpr size_t ExtendedReports::kMaxNumberOfDlrrItems;
 //  :             type-specific block contents                      :
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ExtendedReports::ExtendedReports() : sender_ssrc_(0) {}
-ExtendedReports::~ExtendedReports() {}
+ExtendedReports::ExtendedReports(const ExtendedReports& xr) = default;
+ExtendedReports::~ExtendedReports() = default;
 
 bool ExtendedReports::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);

modules/rtp_rtcp/source/rtcp_packet/extended_reports.h

@@ -30,6 +30,7 @@ class ExtendedReports : public RtcpPacket {
   static constexpr size_t kMaxNumberOfDlrrItems = 50;
 
   ExtendedReports();
+  ExtendedReports(const ExtendedReports& xr);
   ~ExtendedReports() override;
 
   // Parse assumes header is already parsed and validated.

modules/rtp_rtcp/source/rtcp_packet/fir.cc

@@ -46,6 +46,8 @@ constexpr uint8_t Fir::kFeedbackMessageType;
 
 Fir::Fir() = default;
 
+Fir::Fir(const Fir& fir) = default;
+
 Fir::~Fir() = default;
 
 bool Fir::Parse(const CommonHeader& packet) {

modules/rtp_rtcp/source/rtcp_packet/fir.h

@@ -30,6 +30,7 @@ class Fir : public Psfb {
   };
 
   Fir();
+  Fir(const Fir& fir);
   ~Fir() override;
 
   // Parse assumes header is already parsed and validated.

modules/rtp_rtcp/source/rtcp_packet/pli.cc

@@ -33,6 +33,12 @@ constexpr uint8_t Pli::kFeedbackMessageType;
 //  :            Feedback Control Information (FCI)                 :
 //  :                                                               :
 
+Pli::Pli() = default;
+
+Pli::Pli(const Pli& pli) = default;
+
+Pli::~Pli() = default;
+
 //
 // Picture loss indication (PLI) (RFC 4585).
 // FCI: no feedback control information.

modules/rtp_rtcp/source/rtcp_packet/pli.h

@@ -20,8 +20,9 @@ class Pli : public Psfb {
  public:
   static constexpr uint8_t kFeedbackMessageType = 1;
 
-  Pli() {}
-  ~Pli() override {}
+  Pli();
+  Pli(const Pli& pli);
+  ~Pli() override;
 
   bool Parse(const CommonHeader& packet);