rtc_tools/rtc_event_log_visualizer/analyze_rtp_rtcp.cc

/*
 *  Copyright (c) 2026 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "rtc_tools/rtc_event_log_visualizer/analyze_rtp_rtcp.h"

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <deque>
#include <map>
#include <optional>
#include <string>
#include <tuple>
#include <unordered_set>
#include <utility>
#include <vector>

#include "api/function_view.h"
#include "api/rtp_headers.h"
#include "api/transport/ecn_marking.h"
#include "api/units/data_rate.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "logging/rtc_event_log/events/logged_rtp_rtcp.h"
#include "logging/rtc_event_log/rtc_event_log_parser.h"
#include "logging/rtc_event_log/rtc_event_processor.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtcp_packet/congestion_control_feedback.h"
#include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.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/rtcp_packet/target_bitrate.h"
#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/sequence_number_unwrapper.h"
#include "rtc_tools/rtc_event_log_visualizer/analyzer_common.h"
#include "rtc_tools/rtc_event_log_visualizer/plot_base.h"

namespace webrtc {

namespace {

template <typename T>
TimeSeries CreateRtcpTypeTimeSeries(const std::vector<T>& rtcp_list,
                                    AnalyzerConfig config,
                                    std::string rtcp_name,
                                    int category_id) {
  TimeSeries time_series(rtcp_name, LineStyle::kNone, PointStyle::kHighlight);
  for (const auto& rtcp : rtcp_list) {
    float x = config.GetCallTimeSec(rtcp.timestamp);
    float y = category_id;
    time_series.points.emplace_back(x, y);
  }
  return time_series;
}

struct PacketLossSummary {
  size_t num_packets = 0;
  size_t num_lost_packets = 0;
  Timestamp base_time = Timestamp::MinusInfinity();
};

}  // namespace

float GetHighestSeqNumber(const rtcp::ReportBlock& block) {
  return block.extended_high_seq_num();
}

float GetFractionLost(const rtcp::ReportBlock& block) {
  return static_cast<double>(block.fraction_lost()) / 256 * 100;
}

float GetCumulativeLost(const rtcp::ReportBlock& block) {
  return block.cumulative_lost();
}

float DelaySinceLastSr(const rtcp::ReportBlock& block) {
  return static_cast<double>(block.delay_since_last_sr()) / 65536;
}

void CreatePacketGraph(PacketDirection direction,
                       const ParsedRtcEventLog& parsed_log,
                       const AnalyzerConfig& config,
                       Plot* plot) {
  for (const auto& stream : parsed_log.rtp_packets_by_ssrc(direction)) {
    // Filter on SSRC.
    if (!MatchingSsrc(stream.ssrc, config.desired_ssrc_)) {
      continue;
    }

    TimeSeries time_series(GetStreamName(parsed_log, direction, stream.ssrc),
                           LineStyle::kBar);
    auto GetPacketSize = [](const LoggedRtpPacket& packet) {
      return std::optional<float>(packet.total_length);
    };
    auto ToCallTime = [&config](const LoggedRtpPacket& packet) {
      return config.GetCallTimeSec(packet.timestamp);
    };
    ProcessPoints<LoggedRtpPacket>(ToCallTime, GetPacketSize,
                                   stream.packet_view, &time_series);
    plot->AppendTimeSeries(std::move(time_series));
  }

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "Packet size (bytes)", kBottomMargin,
                          kTopMargin);
  plot->SetTitle(GetDirectionAsString(direction) + " RTP packets");
}

void CreateRtcpTypeGraph(PacketDirection direction,
                         const ParsedRtcEventLog& parsed_log,
                         const AnalyzerConfig& config,
                         Plot* plot) {
  plot->AppendTimeSeries(CreateRtcpTypeTimeSeries(
      parsed_log.transport_feedbacks(direction), config, "TWCC", 1));
  plot->AppendTimeSeries(CreateRtcpTypeTimeSeries(
      parsed_log.congestion_feedback(direction), config, "CCFB", 2));
  plot->AppendTimeSeries(CreateRtcpTypeTimeSeries(
      parsed_log.receiver_reports(direction), config, "RR", 3));
  plot->AppendTimeSeries(CreateRtcpTypeTimeSeries(
      parsed_log.sender_reports(direction), config, "SR", 4));
  plot->AppendTimeSeries(CreateRtcpTypeTimeSeries(
      parsed_log.extended_reports(direction), config, "XR", 5));
  plot->AppendTimeSeries(
      CreateRtcpTypeTimeSeries(parsed_log.nacks(direction), config, "NACK", 6));
  plot->AppendTimeSeries(
      CreateRtcpTypeTimeSeries(parsed_log.rembs(direction), config, "REMB", 7));
  plot->AppendTimeSeries(
      CreateRtcpTypeTimeSeries(parsed_log.firs(direction), config, "FIR", 8));
  plot->AppendTimeSeries(
      CreateRtcpTypeTimeSeries(parsed_log.plis(direction), config, "PLI", 9));
  plot->AppendTimeSeries(
      CreateRtcpTypeTimeSeries(parsed_log.byes(direction), config, "BYE", 10));
  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "RTCP type", kBottomMargin, kTopMargin);
  plot->SetTitle(GetDirectionAsString(direction) + " RTCP packets");
  plot->SetYAxisTickLabels({{1, "TWCC"},
                            {2, "CCFB"},
                            {3, "RR"},
                            {4, "SR"},
                            {5, "XR"},
                            {6, "NACK"},
                            {7, "REMB"},
                            {8, "FIR"},
                            {9, "PLI"},
                            {10, "BYE"}});
}

template <typename IterableType>
void CreateAccumulatedPacketsTimeSeries(Plot* plot,
                                        const AnalyzerConfig& config,
                                        const IterableType& packets,
                                        const std::string& label) {
  TimeSeries time_series(label, LineStyle::kStep);
  for (size_t i = 0; i < packets.size(); i++) {
    float x = config.GetCallTimeSec(packets[i].log_time());
    time_series.points.emplace_back(x, i + 1);
  }
  plot->AppendTimeSeries(std::move(time_series));
}

void CreateAccumulatedPacketsGraph(PacketDirection direction,
                                   const ParsedRtcEventLog& parsed_log,
                                   const AnalyzerConfig& config,
                                   Plot* plot) {
  for (const auto& stream : parsed_log.rtp_packets_by_ssrc(direction)) {
    if (!MatchingSsrc(stream.ssrc, config.desired_ssrc_))
      continue;
    std::string label =
        std::string("RTP ") + GetStreamName(parsed_log, direction, stream.ssrc);
    CreateAccumulatedPacketsTimeSeries(plot, config, stream.packet_view, label);
  }
  std::string label =
      std::string("RTCP ") + "(" + GetDirectionAsShortString(direction) + ")";
  if (direction == kIncomingPacket) {
    CreateAccumulatedPacketsTimeSeries(
        plot, config, parsed_log.incoming_rtcp_packets(), label);
  } else {
    CreateAccumulatedPacketsTimeSeries(
        plot, config, parsed_log.outgoing_rtcp_packets(), label);
  }

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "Received Packets", kBottomMargin, kTopMargin);
  plot->SetTitle(std::string("Accumulated ") + GetDirectionAsString(direction) +
                 " RTP/RTCP packets");
}

void CreatePacketRateGraph(PacketDirection direction,
                           const ParsedRtcEventLog& parsed_log,
                           const AnalyzerConfig& config,
                           Plot* plot) {
  auto CountPackets = [](auto packet) { return 1.0; };
  for (const auto& stream : parsed_log.rtp_packets_by_ssrc(direction)) {
    // Filter on SSRC.
    if (!MatchingSsrc(stream.ssrc, config.desired_ssrc_)) {
      continue;
    }
    TimeSeries time_series(
        std::string("RTP ") + GetStreamName(parsed_log, direction, stream.ssrc),
        LineStyle::kLine);
    MovingAverage<LoggedRtpPacket, double>(CountPackets, stream.packet_view,
                                           config, &time_series);
    plot->AppendTimeSeries(std::move(time_series));
  }
  TimeSeries time_series(
      std::string("RTCP ") + "(" + GetDirectionAsShortString(direction) + ")",
      LineStyle::kLine);
  if (direction == kIncomingPacket) {
    MovingAverage<LoggedRtcpPacketIncoming, double>(
        CountPackets, parsed_log.incoming_rtcp_packets(), config, &time_series);
  } else {
    MovingAverage<LoggedRtcpPacketOutgoing, double>(
        CountPackets, parsed_log.outgoing_rtcp_packets(), config, &time_series);
  }
  plot->AppendTimeSeries(std::move(time_series));

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "Packet Rate (packets/s)", kBottomMargin,
                          kTopMargin);
  plot->SetTitle("Rate of " + GetDirectionAsString(direction) +
                 " RTP/RTCP packets");
}

void CreateTotalPacketRateGraph(PacketDirection direction,
                                const ParsedRtcEventLog& parsed_log,
                                const AnalyzerConfig& config,
                                Plot* plot) {
  // Contains a log timestamp to enable counting logged events of different
  // types using MovingAverage().
  class LogTime {
   public:
    explicit LogTime(Timestamp log_time) : log_time_(log_time) {}
    Timestamp log_time() const { return log_time_; }

   private:
    Timestamp log_time_;
  };
  std::vector<LogTime> packet_times;
  auto handle_rtp = [&packet_times](const LoggedRtpPacket& packet) {
    packet_times.emplace_back(packet.log_time());
  };
  RtcEventProcessor process;
  for (const auto& stream : parsed_log.rtp_packets_by_ssrc(direction)) {
    process.AddEvents(stream.packet_view, handle_rtp, direction);
  }
  if (direction == kIncomingPacket) {
    auto handle_incoming_rtcp =
        [&packet_times](const LoggedRtcpPacketIncoming& packet) {
          packet_times.emplace_back(packet.log_time());
        };
    process.AddEvents(parsed_log.incoming_rtcp_packets(), handle_incoming_rtcp);
  } else {
    auto handle_outgoing_rtcp =
        [&packet_times](const LoggedRtcpPacketOutgoing& packet) {
          packet_times.emplace_back(packet.log_time());
        };
    process.AddEvents(parsed_log.outgoing_rtcp_packets(), handle_outgoing_rtcp);
  }
  process.ProcessEventsInOrder();
  TimeSeries time_series(std::string("Total ") + "(" +
                             GetDirectionAsShortString(direction) + ") packets",
                         LineStyle::kLine);
  MovingAverage<LogTime, uint64_t>([](auto packet) { return 1; }, packet_times,
                                   config, &time_series);
  plot->AppendTimeSeries(std::move(time_series));

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "Packet Rate (packets/s)", kBottomMargin,
                          kTopMargin);
  plot->SetTitle("Rate of all " + GetDirectionAsString(direction) +
                 " RTP/RTCP packets");
}

// For each SSRC, plot the sequence number difference between consecutive
// incoming packets.
void CreateSequenceNumberGraph(const ParsedRtcEventLog& parsed_log,
                               const AnalyzerConfig& config,
                               Plot* plot) {
  for (const auto& stream : parsed_log.incoming_rtp_packets_by_ssrc()) {
    // Filter on SSRC.
    if (!MatchingSsrc(stream.ssrc, config.desired_ssrc_)) {
      continue;
    }

    TimeSeries time_series(
        GetStreamName(parsed_log, kIncomingPacket, stream.ssrc),
        LineStyle::kBar);
    auto GetSequenceNumberDiff = [](const LoggedRtpPacketIncoming& old_packet,
                                    const LoggedRtpPacketIncoming& new_packet) {
      int64_t diff =
          WrappingDifference(new_packet.rtp.header.sequenceNumber,
                             old_packet.rtp.header.sequenceNumber, 1ul << 16);
      return diff;
    };
    auto ToCallTime = [&config](const LoggedRtpPacketIncoming& packet) {
      return config.GetCallTimeSec(packet.log_time());
    };
    ProcessPairs<LoggedRtpPacketIncoming, float>(
        ToCallTime, GetSequenceNumberDiff, stream.incoming_packets,
        &time_series);
    plot->AppendTimeSeries(std::move(time_series));
  }

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "Difference since last packet", kBottomMargin,
                          kTopMargin);
  plot->SetTitle("Incoming sequence number delta");
}

void CreateIncomingPacketLossGraph(const ParsedRtcEventLog& parsed_log,
                                   const AnalyzerConfig& config,
                                   Plot* plot) {
  for (const auto& stream : parsed_log.incoming_rtp_packets_by_ssrc()) {
    const std::vector<LoggedRtpPacketIncoming>& packets =
        stream.incoming_packets;
    // Filter on SSRC.
    if (!MatchingSsrc(stream.ssrc, config.desired_ssrc_) || packets.empty()) {
      continue;
    }

    TimeSeries time_series(
        GetStreamName(parsed_log, kIncomingPacket, stream.ssrc),
        LineStyle::kLine, PointStyle::kHighlight);
    // TODO(terelius): Should the window and step size be read from the class
    // instead?
    const TimeDelta kWindow = TimeDelta::Millis(1000);
    const TimeDelta kStep = TimeDelta::Millis(1000);
    SeqNumUnwrapper<uint16_t> unwrapper_;
    SeqNumUnwrapper<uint16_t> prior_unwrapper_;
    size_t window_index_begin = 0;
    size_t window_index_end = 0;
    uint64_t highest_seq_number =
        unwrapper_.Unwrap(packets[0].rtp.header.sequenceNumber) - 1;
    uint64_t highest_prior_seq_number =
        prior_unwrapper_.Unwrap(packets[0].rtp.header.sequenceNumber) - 1;

    for (Timestamp t = config.begin_time_; t < config.end_time_ + kStep;
         t += kStep) {
      while (window_index_end < packets.size() &&
             packets[window_index_end].rtp.log_time() < t) {
        uint64_t sequence_number = unwrapper_.Unwrap(
            packets[window_index_end].rtp.header.sequenceNumber);
        highest_seq_number = std::max(highest_seq_number, sequence_number);
        ++window_index_end;
      }
      while (window_index_begin < packets.size() &&
             packets[window_index_begin].rtp.log_time() < t - kWindow) {
        uint64_t sequence_number = prior_unwrapper_.Unwrap(
            packets[window_index_begin].rtp.header.sequenceNumber);
        highest_prior_seq_number =
            std::max(highest_prior_seq_number, sequence_number);
        ++window_index_begin;
      }
      float x = config.GetCallTimeSec(t);
      uint64_t expected_packets = highest_seq_number - highest_prior_seq_number;
      if (expected_packets > 0) {
        int64_t received_packets = window_index_end - window_index_begin;
        int64_t lost_packets = expected_packets - received_packets;
        float y = static_cast<float>(lost_packets) / expected_packets * 100;
        time_series.points.emplace_back(x, y);
      }
    }
    plot->AppendTimeSeries(std::move(time_series));
  }

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "Loss rate (in %)", kBottomMargin, kTopMargin);
  plot->SetTitle("Incoming packet loss (derived from incoming packets)");
}

// For each SSRC, plot the bandwidth used by that stream.
void CreateStreamBitrateGraph(PacketDirection direction,
                              const ParsedRtcEventLog& parsed_log,
                              const AnalyzerConfig& config,
                              Plot* plot) {
  for (const auto& stream : parsed_log.rtp_packets_by_ssrc(direction)) {
    // Filter on SSRC.
    if (!MatchingSsrc(stream.ssrc, config.desired_ssrc_)) {
      continue;
    }

    TimeSeries time_series(GetStreamName(parsed_log, direction, stream.ssrc),
                           LineStyle::kLine);
    auto GetPacketSizeKilobits = [](const LoggedRtpPacket& packet) {
      return packet.total_length * 8.0 / 1000.0;
    };
    MovingAverage<LoggedRtpPacket, double>(
        GetPacketSizeKilobits, stream.packet_view, config, &time_series);
    plot->AppendTimeSeries(std::move(time_series));
  }

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
  plot->SetTitle(GetDirectionAsString(direction) + " bitrate per stream");
}

// Plot the bitrate allocation for each temporal and spatial layer.
// Computed from RTCP XR target bitrate block, so the graph is only populated if
// those are sent.
void CreateBitrateAllocationGraph(PacketDirection direction,
                                  const ParsedRtcEventLog& parsed_log,
                                  const AnalyzerConfig& config,
                                  Plot* plot) {
  std::map<LayerDescription, TimeSeries> time_series;
  const auto& xr_list = parsed_log.extended_reports(direction);
  for (const auto& rtcp : xr_list) {
    const std::optional<rtcp::TargetBitrate>& target_bitrate =
        rtcp.xr.target_bitrate();
    if (!target_bitrate.has_value())
      continue;
    for (const auto& bitrate_item : target_bitrate->GetTargetBitrates()) {
      LayerDescription layer(rtcp.xr.sender_ssrc(), bitrate_item.spatial_layer,
                             bitrate_item.temporal_layer);
      auto time_series_it = time_series.find(layer);
      if (time_series_it == time_series.end()) {
        std::string layer_name = GetLayerName(layer);
        bool inserted;
        std::tie(time_series_it, inserted) = time_series.insert(
            std::make_pair(layer, TimeSeries(layer_name, LineStyle::kStep)));
        RTC_DCHECK(inserted);
      }
      float x = config.GetCallTimeSec(rtcp.log_time());
      float y = bitrate_item.target_bitrate_kbps;
      time_series_it->second.points.emplace_back(x, y);
    }
  }
  for (auto& layer : time_series) {
    plot->AppendTimeSeries(std::move(layer.second));
  }
  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
  if (direction == kIncomingPacket)
    plot->SetTitle("Target bitrate per incoming layer");
  else
    plot->SetTitle("Target bitrate per outgoing layer");
}

void CreateEcnFeedbackGraph(Plot* plot,
                            PacketDirection direction,
                            const ParsedRtcEventLog& parsed_log,
                            const AnalyzerConfig& config) {
  TimeSeries not_ect("Not ECN capable", LineStyle::kBar,
                     PointStyle::kHighlight);
  TimeSeries ect_1("ECN capable", LineStyle::kBar, PointStyle::kHighlight);
  TimeSeries ce("Congestion experienced", LineStyle::kBar,
                PointStyle::kHighlight);

  for (const LoggedRtcpCongestionControlFeedback& feedback :
       parsed_log.congestion_feedback(direction)) {
    int ect_1_count = 0;
    int not_ect_count = 0;
    int ce_count = 0;

    for (const rtcp::CongestionControlFeedback::PacketInfo& info :
         feedback.congestion_feedback.packets()) {
      switch (info.ecn) {
        case EcnMarking::kNotEct:
          ++not_ect_count;
          break;
        case EcnMarking::kEct1:
          ++ect_1_count;
          break;
        case EcnMarking::kEct0:
          RTC_LOG(LS_ERROR) << "unexpected ect(0)";
          break;
        case EcnMarking::kCe:
          ++ce_count;
          break;
      }
    }
    ect_1.points.emplace_back(config.GetCallTimeSec(feedback.timestamp),
                              ect_1_count);
    not_ect.points.emplace_back(config.GetCallTimeSec(feedback.timestamp),
                                not_ect_count);
    ce.points.emplace_back(config.GetCallTimeSec(feedback.timestamp), ce_count);
  }

  plot->AppendTimeSeriesIfNotEmpty(std::move(ect_1));
  plot->AppendTimeSeriesIfNotEmpty(std::move(not_ect));
  plot->AppendTimeSeriesIfNotEmpty(std::move(ce));

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 10, "Count per feedback", kBottomMargin,
                          kTopMargin);
}

void CreateOutgoingEcnFeedbackGraph(const ParsedRtcEventLog& parsed_log,
                                    const AnalyzerConfig& config,
                                    Plot* plot) {
  CreateEcnFeedbackGraph(plot, kOutgoingPacket, parsed_log, config);
  plot->SetTitle("Outgoing ECN count per feedback");
}

void CreateIncomingEcnFeedbackGraph(const ParsedRtcEventLog& parsed_log,
                                    const AnalyzerConfig& config,
                                    Plot* plot) {
  CreateEcnFeedbackGraph(plot, kIncomingPacket, parsed_log, config);
  plot->SetTitle("Incoming ECN count per feedback");
}

void CreateOutgoingLossRateGraph(const ParsedRtcEventLog& parsed_log,
                                 const AnalyzerConfig& config,
                                 Plot* plot) {
  struct PacketLossPerFeedback {
    Timestamp timestamp;              // Time when this feedback was received.
    int num_packets_in_feedback = 0;  // Includes lost packets.
    int num_lost_packets = 0;         // In this specific feedback.
    int num_reordered_packets = 0;    // Packets received in this feedback, but
                                      // was previously reported as lost.
    int num_missing_feedback =
        0;  // Packets missing feedback between this report and the previous.
  };

  class LossFeedbackBuilder {
   public:
    void AddPacket(uint16_t sequence_number, TimeDelta arrival_time_delta) {
      last_unwrapped_sequence_number_ =
          sequence_number_unwrapper_.Unwrap(sequence_number);
      if (!first_sequence_number_.has_value()) {
        first_sequence_number_ = last_unwrapped_sequence_number_;
      }
      ++num_packets_;
      if (arrival_time_delta.IsInfinite()) {
        lost_sequence_numbers_.insert(last_unwrapped_sequence_number_);
      } else {
        num_reordered_packets_ += previous_lost_sequence_numbers_.count(
            last_unwrapped_sequence_number_);
      }
    }

    void Update(PacketLossPerFeedback& feedback) {
      feedback.num_packets_in_feedback += num_packets_;
      feedback.num_lost_packets += lost_sequence_numbers_.size();
      feedback.num_reordered_packets += num_reordered_packets_;
      if (first_sequence_number_.has_value() &&
          previous_feedback_highest_seq_number_.has_value()) {
        feedback.num_missing_feedback +=
            *first_sequence_number_ - *previous_feedback_highest_seq_number_ -
            1;
      }

      // Prepare for next feedback.
      first_sequence_number_ = std::nullopt;
      previous_lost_sequence_numbers_.insert(lost_sequence_numbers_.begin(),
                                             lost_sequence_numbers_.end());
      previous_feedback_highest_seq_number_ = last_unwrapped_sequence_number_;
      lost_sequence_numbers_.clear();
      num_reordered_packets_ = 0;
      num_packets_ = 0;
    }

   private:
    int64_t last_unwrapped_sequence_number_ = 0;
    int num_reordered_packets_ = 0;
    int num_packets_ = 0;
    std::optional<int64_t> first_sequence_number_;

    std::unordered_set<int64_t> lost_sequence_numbers_;
    std::unordered_set<int64_t> previous_lost_sequence_numbers_;
    std::optional<int64_t> previous_feedback_highest_seq_number_;

    RtpSequenceNumberUnwrapper sequence_number_unwrapper_;
  };

  TimeSeries loss_rate_series("Loss rate (from packet feedback)",
                              LineStyle::kLine, PointStyle::kHighlight);
  TimeSeries reordered_packets_between_feedback(
      "Ratio of reordered packets from last feedback", LineStyle::kLine,
      PointStyle::kHighlight);
  TimeSeries average_loss_rate_series("Average loss rate last 5s",
                                      LineStyle::kLine, PointStyle::kHighlight);
  TimeSeries missing_feedback_series("Missing feedback", LineStyle::kNone,
                                     PointStyle::kHighlight);

  std::vector<PacketLossPerFeedback> loss_per_feedback;

  if (!parsed_log.congestion_feedback(kIncomingPacket).empty()) {
    plot->SetTitle("Outgoing loss rate (from CCFB)");

    std::map</*ssrc*/ uint32_t, LossFeedbackBuilder> per_ssrc_builder;
    for (const LoggedRtcpCongestionControlFeedback& feedback :
         parsed_log.congestion_feedback(kIncomingPacket)) {
      const rtcp::CongestionControlFeedback& transport_feedback =
          feedback.congestion_feedback;

      PacketLossPerFeedback packet_loss_per_feedback = {
          .timestamp = feedback.log_time()};
      for (const rtcp::CongestionControlFeedback::PacketInfo& packet :
           transport_feedback.packets()) {
        per_ssrc_builder[packet.ssrc].AddPacket(packet.sequence_number,
                                                packet.arrival_time_offset);
      }
      for (auto& [ssrc, builder] : per_ssrc_builder) {
        builder.Update(packet_loss_per_feedback);
      }
      loss_per_feedback.push_back(packet_loss_per_feedback);
    }
  } else if (!parsed_log.transport_feedbacks(kIncomingPacket).empty()) {
    plot->SetTitle("Outgoing loss rate (from TWCC)");

    LossFeedbackBuilder builder;
    for (const LoggedRtcpPacketTransportFeedback& feedback :
         parsed_log.transport_feedbacks(kIncomingPacket)) {
      feedback.transport_feedback.ForAllPackets(
          [&](uint16_t sequence_number, TimeDelta receive_time_delta) {
            builder.AddPacket(sequence_number, receive_time_delta);
          });
      PacketLossPerFeedback packet_loss_per_feedback = {
          .timestamp = feedback.log_time()};
      builder.Update(packet_loss_per_feedback);
      loss_per_feedback.push_back(packet_loss_per_feedback);
    }
  }

  PacketLossSummary window_summary;
  Timestamp last_observation_receive_time = Timestamp::Zero();

  // Use loss based bwe 2 observation duration and observation window size.
  constexpr TimeDelta kObservationDuration = TimeDelta::Millis(250);
  constexpr uint32_t kObservationWindowSize = 20;
  std::deque<PacketLossSummary> observations;
  int previous_feedback_size = 0;
  for (const PacketLossPerFeedback& feedback : loss_per_feedback) {
    for (int64_t num = 0; num < feedback.num_missing_feedback; ++num) {
      missing_feedback_series.points.emplace_back(
          config.GetCallTimeSec(feedback.timestamp), 100 + num);
    }

    // Compute loss rate from the transport feedback.
    float loss_rate = static_cast<float>(feedback.num_lost_packets * 100.0 /
                                         feedback.num_packets_in_feedback);

    loss_rate_series.points.emplace_back(
        config.GetCallTimeSec(feedback.timestamp), loss_rate);
    float reordered_rate =
        previous_feedback_size == 0
            ? 0
            : static_cast<float>(feedback.num_reordered_packets * 100.0 /
                                 previous_feedback_size);
    previous_feedback_size = feedback.num_packets_in_feedback;
    reordered_packets_between_feedback.points.emplace_back(
        config.GetCallTimeSec(feedback.timestamp), reordered_rate);

    // Compute loss rate in a window of kObservationWindowSize.
    if (window_summary.num_packets == 0) {
      window_summary.base_time = feedback.timestamp;
    }
    window_summary.num_packets += feedback.num_packets_in_feedback;
    window_summary.num_lost_packets +=
        feedback.num_lost_packets - feedback.num_reordered_packets;

    const Timestamp last_received_time = feedback.timestamp;
    const TimeDelta observation_duration =
        window_summary.base_time == Timestamp::Zero()
            ? TimeDelta::Zero()
            : last_received_time - window_summary.base_time;
    if (observation_duration > kObservationDuration) {
      last_observation_receive_time = last_received_time;
      observations.push_back(window_summary);
      if (observations.size() > kObservationWindowSize) {
        observations.pop_front();
      }

      // Compute average loss rate in a number of windows.
      int total_packets = 0;
      int total_loss = 0;
      for (const auto& observation : observations) {
        total_loss += observation.num_lost_packets;
        total_packets += observation.num_packets;
      }
      if (total_packets > 0) {
        float average_loss_rate = total_loss * 100.0 / total_packets;
        average_loss_rate_series.points.emplace_back(
            config.GetCallTimeSec(feedback.timestamp), average_loss_rate);
      } else {
        average_loss_rate_series.points.emplace_back(
            config.GetCallTimeSec(feedback.timestamp), 0);
      }
      window_summary = PacketLossSummary();
    }
  }
  // Add the data set to the plot.
  plot->AppendTimeSeriesIfNotEmpty(std::move(loss_rate_series));
  plot->AppendTimeSeriesIfNotEmpty(
      std::move(reordered_packets_between_feedback));
  plot->AppendTimeSeriesIfNotEmpty(std::move(average_loss_rate_series));
  plot->AppendTimeSeriesIfNotEmpty(std::move(missing_feedback_series));

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 100, "Loss rate (percent)", kBottomMargin,
                          kTopMargin);
}

void CreateTimestampGraph(PacketDirection direction,
                          const ParsedRtcEventLog& parsed_log,
                          const AnalyzerConfig& config,
                          Plot* plot) {
  for (const auto& stream : parsed_log.rtp_packets_by_ssrc(direction)) {
    TimeSeries rtp_timestamps(
        GetStreamName(parsed_log, direction, stream.ssrc) + " capture-time",
        LineStyle::kLine, PointStyle::kHighlight);
    for (const auto& packet : stream.packet_view) {
      float x = config.GetCallTimeSec(packet.log_time());
      float y = packet.header.timestamp;
      rtp_timestamps.points.emplace_back(x, y);
    }
    plot->AppendTimeSeries(std::move(rtp_timestamps));

    TimeSeries rtcp_timestamps(
        GetStreamName(parsed_log, direction, stream.ssrc) +
            " rtcp capture-time",
        LineStyle::kLine, PointStyle::kHighlight);
    // TODO(terelius): Why only sender reports?
    const auto& sender_reports = parsed_log.sender_reports(direction);
    for (const auto& rtcp : sender_reports) {
      if (rtcp.sr.sender_ssrc() != stream.ssrc)
        continue;
      float x = config.GetCallTimeSec(rtcp.log_time());
      float y = rtcp.sr.rtp_timestamp();
      rtcp_timestamps.points.emplace_back(x, y);
    }
    plot->AppendTimeSeriesIfNotEmpty(std::move(rtcp_timestamps));
  }

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, "RTP timestamp", kBottomMargin, kTopMargin);
  plot->SetTitle(GetDirectionAsString(direction) + " timestamps");
}

void CreateSenderAndReceiverReportPlot(
    PacketDirection direction,
    FunctionView<float(const rtcp::ReportBlock&)> fy,
    std::string title,
    std::string yaxis_label,
    const ParsedRtcEventLog& parsed_log,
    const AnalyzerConfig& config,
    Plot* plot) {
  std::map<uint32_t, TimeSeries> sr_reports_by_ssrc;
  const auto& sender_reports = parsed_log.sender_reports(direction);
  for (const auto& rtcp : sender_reports) {
    float x = config.GetCallTimeSec(rtcp.log_time());
    uint32_t ssrc = rtcp.sr.sender_ssrc();
    for (const auto& block : rtcp.sr.report_blocks()) {
      float y = fy(block);
      auto sr_report_it = sr_reports_by_ssrc.find(ssrc);
      bool inserted;
      if (sr_report_it == sr_reports_by_ssrc.end()) {
        std::tie(sr_report_it, inserted) = sr_reports_by_ssrc.emplace(
            ssrc, TimeSeries(GetStreamName(parsed_log, direction, ssrc) +
                                 " Sender Reports",
                             LineStyle::kLine, PointStyle::kHighlight));
      }
      sr_report_it->second.points.emplace_back(x, y);
    }
  }
  for (auto& kv : sr_reports_by_ssrc) {
    plot->AppendTimeSeries(std::move(kv.second));
  }

  std::map<uint32_t, TimeSeries> rr_reports_by_ssrc;
  const auto& receiver_reports = parsed_log.receiver_reports(direction);
  for (const auto& rtcp : receiver_reports) {
    float x = config.GetCallTimeSec(rtcp.log_time());
    uint32_t ssrc = rtcp.rr.sender_ssrc();
    for (const auto& block : rtcp.rr.report_blocks()) {
      float y = fy(block);
      auto rr_report_it = rr_reports_by_ssrc.find(ssrc);
      bool inserted;
      if (rr_report_it == rr_reports_by_ssrc.end()) {
        std::tie(rr_report_it, inserted) = rr_reports_by_ssrc.emplace(
            ssrc, TimeSeries(GetStreamName(parsed_log, direction, ssrc) +
                                 " Receiver Reports",
                             LineStyle::kLine, PointStyle::kHighlight));
      }
      rr_report_it->second.points.emplace_back(x, y);
    }
  }
  for (auto& kv : rr_reports_by_ssrc) {
    plot->AppendTimeSeries(std::move(kv.second));
  }

  plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
                 kLeftMargin, kRightMargin);
  plot->SetSuggestedYAxis(0, 1, yaxis_label, kBottomMargin, kTopMargin);
  plot->SetTitle(title);
}

}  // namespace webrtc