Revert "Create new API for RtcEventLogParser."
This reverts commit 9e336ec0b8a77c3461d13677cff3563c11c88daa.
Reason for revert: Code can accidentally include the deprecated parser but link with the new one, or vice versa. Reverting to fix naming.
Original change's description:
> Create new API for RtcEventLogParser.
>
> The new API stores events gathered by event type. For example, it is
> possible to ask fo a list of all incoming RTCP messages or all audio
> playout events.
>
> The new API is experimental and may change over next few weeks. Once
> it has stabilized and all unit tests and existing tools have been
> ported to the new API, the old one will be removed.
>
> This CL also updates the event_log_visualizer tool to use the new
> parser API. This is not a funcional change except for:
> - Incoming and outgoing audio level are now drawn in two separate plots.
> - Incoming and outgoing timstamps are now drawn in two separate plots.
> - RTCP count is no longer split into Video and Audio. It also counts
> all RTCP packets rather than only specific message types.
> - Slight timing difference in sendside BWE simulation due to only
> iterating over transport feedbacks and not over all RTCP packets.
> This timing changes are not visible in the plots.
>
>
> Media type for RTCP messages might not be identified correctly by
> rtc_event_log2text anymore. On the other hand, assigning a specific
> media type to an RTCP packet was a bit hacky to begin with.
>
> Bug: webrtc:8111
> Change-Id: I8e7168302beb69b2e163a097a2a142b86dd4a26b
> Reviewed-on: https://webrtc-review.googlesource.com/60865
> Reviewed-by: Minyue Li <minyue@webrtc.org>
> Reviewed-by: Sebastian Jansson <srte@webrtc.org>
> Commit-Queue: Björn Terelius <terelius@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#23015}
TBR=terelius@webrtc.org,srte@webrtc.org,minyue@webrtc.org
Change-Id: Ib4bbcf0563423675a3cc1dce59ebf665e0c5dae9
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:8111
Reviewed-on: https://webrtc-review.googlesource.com/72500
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23026}diff --git a/rtc_tools/event_log_visualizer/analyzer.h b/rtc_tools/event_log_visualizer/analyzer.h
index b37de21..a8fedb8 100644
--- a/rtc_tools/event_log_visualizer/analyzer.h
+++ b/rtc_tools/event_log_visualizer/analyzer.h
@@ -18,12 +18,54 @@
#include <utility>
#include <vector>
-#include "logging/rtc_event_log/rtc_event_log_parser2.h"
-#include "rtc_base/strings/string_builder.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
+#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "modules/rtp_rtcp/source/rtcp_packet.h"
+#include "rtc_base/function_view.h"
#include "rtc_tools/event_log_visualizer/plot_base.h"
#include "rtc_tools/event_log_visualizer/triage_notifications.h"
namespace webrtc {
+namespace plotting {
+
+struct LoggedRtpPacket {
+ LoggedRtpPacket(uint64_t timestamp,
+ RTPHeader header,
+ size_t header_length,
+ size_t total_length)
+ : timestamp(timestamp),
+ header(header),
+ header_length(header_length),
+ total_length(total_length) {}
+ uint64_t timestamp;
+ // TODO(terelius): This allocates space for 15 CSRCs even if none are used.
+ RTPHeader header;
+ size_t header_length;
+ size_t total_length;
+};
+
+struct LoggedRtcpPacket {
+ LoggedRtcpPacket(uint64_t timestamp,
+ RTCPPacketType rtcp_type,
+ std::unique_ptr<rtcp::RtcpPacket> rtcp_packet)
+ : timestamp(timestamp), type(rtcp_type), packet(std::move(rtcp_packet)) {}
+ uint64_t timestamp;
+ RTCPPacketType type;
+ std::unique_ptr<rtcp::RtcpPacket> packet;
+};
+
+struct LossBasedBweUpdate {
+ uint64_t timestamp;
+ int32_t new_bitrate;
+ uint8_t fraction_loss;
+ int32_t expected_packets;
+};
+
+struct AudioNetworkAdaptationEvent {
+ uint64_t timestamp;
+ AudioEncoderRuntimeConfig config;
+};
class EventLogAnalyzer {
public:
@@ -32,13 +74,14 @@
// modified while the EventLogAnalyzer is being used.
explicit EventLogAnalyzer(const ParsedRtcEventLog& log);
- void CreatePacketGraph(PacketDirection direction, Plot* plot);
+ void CreatePacketGraph(PacketDirection desired_direction, Plot* plot);
- void CreateAccumulatedPacketsGraph(PacketDirection direction, Plot* plot);
+ void CreateAccumulatedPacketsGraph(PacketDirection desired_direction,
+ Plot* plot);
void CreatePlayoutGraph(Plot* plot);
- void CreateAudioLevelGraph(PacketDirection direction, Plot* plot);
+ void CreateAudioLevelGraph(Plot* plot);
void CreateSequenceNumberGraph(Plot* plot);
@@ -49,20 +92,19 @@
void CreateFractionLossGraph(Plot* plot);
- void CreateTotalIncomingBitrateGraph(Plot* plot);
- void CreateTotalOutgoingBitrateGraph(Plot* plot,
- bool show_detector_state = false,
- bool show_alr_state = false);
+ void CreateTotalBitrateGraph(PacketDirection desired_direction,
+ Plot* plot,
+ bool show_detector_state = false,
+ bool show_alr_state = false);
- void CreateStreamBitrateGraph(PacketDirection direction, Plot* plot);
+ void CreateStreamBitrateGraph(PacketDirection desired_direction, Plot* plot);
void CreateSendSideBweSimulationGraph(Plot* plot);
void CreateReceiveSideBweSimulationGraph(Plot* plot);
void CreateNetworkDelayFeedbackGraph(Plot* plot);
void CreatePacerDelayGraph(Plot* plot);
-
- void CreateTimestampGraph(PacketDirection direction, Plot* plot);
+ void CreateTimestampGraph(Plot* plot);
void CreateAudioEncoderTargetBitrateGraph(Plot* plot);
void CreateAudioEncoderFrameLengthGraph(Plot* plot);
@@ -77,114 +119,55 @@
void CreateIceCandidatePairConfigGraph(Plot* plot);
void CreateIceConnectivityCheckGraph(Plot* plot);
+ // Returns a vector of capture and arrival timestamps for the video frames
+ // of the stream with the most number of frames.
+ std::vector<std::pair<int64_t, int64_t>> GetFrameTimestamps() const;
+
void CreateTriageNotifications();
void PrintNotifications(FILE* file);
private:
- bool IsRtxSsrc(PacketDirection direction, uint32_t ssrc) const {
- if (direction == kIncomingPacket) {
- return parsed_log_.incoming_rtx_ssrcs().find(ssrc) !=
- parsed_log_.incoming_rtx_ssrcs().end();
- } else {
- return parsed_log_.outgoing_rtx_ssrcs().find(ssrc) !=
- parsed_log_.outgoing_rtx_ssrcs().end();
+ class StreamId {
+ public:
+ StreamId(uint32_t ssrc, webrtc::PacketDirection direction)
+ : ssrc_(ssrc), direction_(direction) {}
+ bool operator<(const StreamId& other) const {
+ return std::tie(ssrc_, direction_) <
+ std::tie(other.ssrc_, other.direction_);
}
- }
-
- bool IsVideoSsrc(PacketDirection direction, uint32_t ssrc) const {
- if (direction == kIncomingPacket) {
- return parsed_log_.incoming_video_ssrcs().find(ssrc) !=
- parsed_log_.incoming_video_ssrcs().end();
- } else {
- return parsed_log_.outgoing_video_ssrcs().find(ssrc) !=
- parsed_log_.outgoing_video_ssrcs().end();
+ bool operator==(const StreamId& other) const {
+ return std::tie(ssrc_, direction_) ==
+ std::tie(other.ssrc_, other.direction_);
}
- }
+ uint32_t GetSsrc() const { return ssrc_; }
+ webrtc::PacketDirection GetDirection() const { return direction_; }
- bool IsAudioSsrc(PacketDirection direction, uint32_t ssrc) const {
- if (direction == kIncomingPacket) {
- return parsed_log_.incoming_audio_ssrcs().find(ssrc) !=
- parsed_log_.incoming_audio_ssrcs().end();
- } else {
- return parsed_log_.outgoing_audio_ssrcs().find(ssrc) !=
- parsed_log_.outgoing_audio_ssrcs().end();
- }
- }
+ private:
+ uint32_t ssrc_;
+ webrtc::PacketDirection direction_;
+ };
- template <typename IterableType>
- void CreateAccumulatedPacketsTimeSeries(Plot* plot,
- const IterableType& packets,
- const std::string& label);
+ template <typename T>
+ void CreateAccumulatedPacketsTimeSeries(
+ PacketDirection desired_direction,
+ Plot* plot,
+ const std::map<StreamId, std::vector<T>>& packets,
+ const std::string& label_prefix);
- void CreateStreamGapAlerts(PacketDirection direction);
- void CreateTransmissionGapAlerts(PacketDirection direction);
+ bool IsRtxSsrc(StreamId stream_id) const;
- std::string GetStreamName(PacketDirection direction, uint32_t ssrc) const {
- char buffer[200];
- rtc::SimpleStringBuilder name(buffer);
- if (IsAudioSsrc(direction, ssrc)) {
- name << "Audio ";
- } else if (IsVideoSsrc(direction, ssrc)) {
- name << "Video ";
- } else {
- name << "Unknown ";
- }
- if (IsRtxSsrc(direction, ssrc)) {
- name << "RTX ";
- }
- if (direction == kIncomingPacket)
- name << "(In) ";
- else
- name << "(Out) ";
- name << "SSRC " << ssrc;
- return name.str();
- }
+ bool IsVideoSsrc(StreamId stream_id) const;
+
+ bool IsAudioSsrc(StreamId stream_id) const;
+
+ std::string GetStreamName(StreamId stream_id) const;
+
+ rtc::Optional<uint32_t> EstimateRtpClockFrequency(
+ const std::vector<LoggedRtpPacket>& packets) const;
float ToCallTime(int64_t timestamp) const;
- void Alert_RtpLogTimeGap(PacketDirection direction,
- float time_seconds,
- int64_t duration) {
- if (direction == kIncomingPacket) {
- incoming_rtp_recv_time_gaps_.emplace_back(time_seconds, duration);
- } else {
- outgoing_rtp_send_time_gaps_.emplace_back(time_seconds, duration);
- }
- }
-
- void Alert_RtcpLogTimeGap(PacketDirection direction,
- float time_seconds,
- int64_t duration) {
- if (direction == kIncomingPacket) {
- incoming_rtcp_recv_time_gaps_.emplace_back(time_seconds, duration);
- } else {
- outgoing_rtcp_send_time_gaps_.emplace_back(time_seconds, duration);
- }
- }
-
- void Alert_SeqNumJump(PacketDirection direction,
- float time_seconds,
- uint32_t ssrc) {
- if (direction == kIncomingPacket) {
- incoming_seq_num_jumps_.emplace_back(time_seconds, ssrc);
- } else {
- outgoing_seq_num_jumps_.emplace_back(time_seconds, ssrc);
- }
- }
-
- void Alert_CaptureTimeJump(PacketDirection direction,
- float time_seconds,
- uint32_t ssrc) {
- if (direction == kIncomingPacket) {
- incoming_capture_time_jumps_.emplace_back(time_seconds, ssrc);
- } else {
- outgoing_capture_time_jumps_.emplace_back(time_seconds, ssrc);
- }
- }
-
- void Alert_OutgoingHighLoss(double avg_loss_fraction) {
- outgoing_high_loss_alerts_.emplace_back(avg_loss_fraction);
- }
+ void Notification(std::unique_ptr<TriageNotification> notification);
std::string GetCandidatePairLogDescriptionFromId(uint32_t candidate_pair_id);
@@ -194,19 +177,50 @@
// If left empty, all SSRCs will be considered relevant.
std::vector<uint32_t> desired_ssrc_;
+ // Tracks what each stream is configured for. Note that a single SSRC can be
+ // in several sets. For example, the SSRC used for sending video over RTX
+ // will appear in both video_ssrcs_ and rtx_ssrcs_. In the unlikely case that
+ // an SSRC is reconfigured to a different media type mid-call, it will also
+ // appear in multiple sets.
+ std::set<StreamId> rtx_ssrcs_;
+ std::set<StreamId> video_ssrcs_;
+ std::set<StreamId> audio_ssrcs_;
+
+ // Maps a stream identifier consisting of ssrc and direction to the parsed
+ // RTP headers in that stream. Header extensions are parsed if the stream
+ // has been configured.
+ std::map<StreamId, std::vector<LoggedRtpPacket>> rtp_packets_;
+
+ std::map<StreamId, std::vector<LoggedRtcpPacket>> rtcp_packets_;
+
+ // Maps an SSRC to the timestamps of parsed audio playout events.
+ std::map<uint32_t, std::vector<uint64_t>> audio_playout_events_;
+
// Stores the timestamps for all log segments, in the form of associated start
// and end events.
- std::vector<std::pair<int64_t, int64_t>> log_segments_;
+ std::vector<std::pair<uint64_t, uint64_t>> log_segments_;
- std::vector<IncomingRtpReceiveTimeGap> incoming_rtp_recv_time_gaps_;
- std::vector<IncomingRtcpReceiveTimeGap> incoming_rtcp_recv_time_gaps_;
- std::vector<OutgoingRtpSendTimeGap> outgoing_rtp_send_time_gaps_;
- std::vector<OutgoingRtcpSendTimeGap> outgoing_rtcp_send_time_gaps_;
- std::vector<IncomingSeqNumJump> incoming_seq_num_jumps_;
- std::vector<IncomingCaptureTimeJump> incoming_capture_time_jumps_;
- std::vector<OutgoingSeqNoJump> outgoing_seq_num_jumps_;
- std::vector<OutgoingCaptureTimeJump> outgoing_capture_time_jumps_;
- std::vector<OutgoingHighLoss> outgoing_high_loss_alerts_;
+ // A list of all updates from the send-side loss-based bandwidth estimator.
+ std::vector<LossBasedBweUpdate> bwe_loss_updates_;
+
+ std::vector<AudioNetworkAdaptationEvent> audio_network_adaptation_events_;
+
+ std::vector<ParsedRtcEventLog::BweProbeClusterCreatedEvent>
+ bwe_probe_cluster_created_events_;
+
+ std::vector<ParsedRtcEventLog::BweProbeResultEvent> bwe_probe_result_events_;
+
+ std::vector<ParsedRtcEventLog::BweDelayBasedUpdate> bwe_delay_updates_;
+
+ std::vector<std::unique_ptr<TriageNotification>> notifications_;
+
+ std::vector<ParsedRtcEventLog::AlrStateEvent> alr_state_events_;
+
+ std::vector<ParsedRtcEventLog::IceCandidatePairConfig>
+ ice_candidate_pair_configs_;
+
+ std::vector<ParsedRtcEventLog::IceCandidatePairEvent>
+ ice_candidate_pair_events_;
std::map<uint32_t, std::string> candidate_pair_desc_by_id_;
@@ -214,17 +228,18 @@
// The generated data points will be |step_| microseconds apart.
// Only events occuring at most |window_duration_| microseconds before the
// current data point will be part of the average.
- int64_t window_duration_;
- int64_t step_;
+ uint64_t window_duration_;
+ uint64_t step_;
// First and last events of the log.
- int64_t begin_time_;
- int64_t end_time_;
+ uint64_t begin_time_;
+ uint64_t end_time_;
// Duration (in seconds) of log file.
float call_duration_s_;
};
+} // namespace plotting
} // namespace webrtc
#endif // RTC_TOOLS_EVENT_LOG_VISUALIZER_ANALYZER_H_