terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #ifndef RTC_TOOLS_EVENT_LOG_VISUALIZER_ANALYZER_H_ |
| 12 | #define RTC_TOOLS_EVENT_LOG_VISUALIZER_ANALYZER_H_ |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 13 | |
terelius | 88e64e5 | 2016-07-19 01:51:06 -0700 | [diff] [blame] | 14 | #include <map> |
Stefan Holmer | 1318103 | 2016-07-29 14:48:54 +0200 | [diff] [blame] | 15 | #include <memory> |
terelius | 0740a20 | 2016-08-08 10:21:04 -0700 | [diff] [blame] | 16 | #include <set> |
philipel | ccd7489 | 2016-09-05 02:46:25 -0700 | [diff] [blame] | 17 | #include <string> |
Stefan Holmer | 1318103 | 2016-07-29 14:48:54 +0200 | [diff] [blame] | 18 | #include <utility> |
philipel | ccd7489 | 2016-09-05 02:46:25 -0700 | [diff] [blame] | 19 | #include <vector> |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 20 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 21 | #include "logging/rtc_event_log/rtc_event_log_parser_new.h" |
Minyue Li | c6ff757 | 2018-05-04 09:46:44 +0200 | [diff] [blame] | 22 | #include "modules/audio_coding/neteq/tools/neteq_stats_getter.h" |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 23 | #include "rtc_base/strings/string_builder.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "rtc_tools/event_log_visualizer/plot_base.h" |
Bjorn Terelius | 2eb3188 | 2017-11-30 15:15:25 +0100 | [diff] [blame] | 25 | #include "rtc_tools/event_log_visualizer/triage_notifications.h" |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 26 | |
| 27 | namespace webrtc { |
michaelt | 6e5b219 | 2017-02-22 07:33:27 -0800 | [diff] [blame] | 28 | |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 29 | class EventLogAnalyzer { |
| 30 | public: |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 31 | // The EventLogAnalyzer keeps a reference to the ParsedRtcEventLogNew for the |
| 32 | // duration of its lifetime. The ParsedRtcEventLogNew must not be destroyed or |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 33 | // modified while the EventLogAnalyzer is being used. |
Stefan Holmer | 1d4a227 | 2018-05-24 13:48:09 +0200 | [diff] [blame^] | 34 | EventLogAnalyzer(const ParsedRtcEventLogNew& log, bool normalize_time); |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 35 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 36 | void CreatePacketGraph(PacketDirection direction, Plot* plot); |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 37 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 38 | void CreateAccumulatedPacketsGraph(PacketDirection direction, Plot* plot); |
philipel | ccd7489 | 2016-09-05 02:46:25 -0700 | [diff] [blame] | 39 | |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 40 | void CreatePlayoutGraph(Plot* plot); |
| 41 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 42 | void CreateAudioLevelGraph(PacketDirection direction, Plot* plot); |
ivoc | aac9d6f | 2016-09-22 07:01:47 -0700 | [diff] [blame] | 43 | |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 44 | void CreateSequenceNumberGraph(Plot* plot); |
| 45 | |
Stefan Holmer | 99f8e08 | 2016-09-09 13:37:50 +0200 | [diff] [blame] | 46 | void CreateIncomingPacketLossGraph(Plot* plot); |
| 47 | |
terelius | 2ee076d | 2017-08-15 02:04:02 -0700 | [diff] [blame] | 48 | void CreateIncomingDelayDeltaGraph(Plot* plot); |
| 49 | void CreateIncomingDelayGraph(Plot* plot); |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 50 | |
terelius | f736d23 | 2016-08-04 10:00:11 -0700 | [diff] [blame] | 51 | void CreateFractionLossGraph(Plot* plot); |
| 52 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 53 | void CreateTotalIncomingBitrateGraph(Plot* plot); |
| 54 | void CreateTotalOutgoingBitrateGraph(Plot* plot, |
| 55 | bool show_detector_state = false, |
| 56 | bool show_alr_state = false); |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 57 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 58 | void CreateStreamBitrateGraph(PacketDirection direction, Plot* plot); |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 59 | |
Bjorn Terelius | 28db266 | 2017-10-04 14:22:43 +0200 | [diff] [blame] | 60 | void CreateSendSideBweSimulationGraph(Plot* plot); |
| 61 | void CreateReceiveSideBweSimulationGraph(Plot* plot); |
Stefan Holmer | 1318103 | 2016-07-29 14:48:54 +0200 | [diff] [blame] | 62 | |
terelius | e34c19c | 2016-08-15 08:47:14 -0700 | [diff] [blame] | 63 | void CreateNetworkDelayFeedbackGraph(Plot* plot); |
Bjorn Terelius | 0295a96 | 2017-10-25 17:42:41 +0200 | [diff] [blame] | 64 | void CreatePacerDelayGraph(Plot* plot); |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 65 | |
| 66 | void CreateTimestampGraph(PacketDirection direction, Plot* plot); |
stefan | c3de033 | 2016-08-02 07:22:17 -0700 | [diff] [blame] | 67 | |
michaelt | 6e5b219 | 2017-02-22 07:33:27 -0800 | [diff] [blame] | 68 | void CreateAudioEncoderTargetBitrateGraph(Plot* plot); |
| 69 | void CreateAudioEncoderFrameLengthGraph(Plot* plot); |
terelius | 2ee076d | 2017-08-15 02:04:02 -0700 | [diff] [blame] | 70 | void CreateAudioEncoderPacketLossGraph(Plot* plot); |
michaelt | 6e5b219 | 2017-02-22 07:33:27 -0800 | [diff] [blame] | 71 | void CreateAudioEncoderEnableFecGraph(Plot* plot); |
| 72 | void CreateAudioEncoderEnableDtxGraph(Plot* plot); |
| 73 | void CreateAudioEncoderNumChannelsGraph(Plot* plot); |
Minyue Li | c6ff757 | 2018-05-04 09:46:44 +0200 | [diff] [blame] | 74 | |
| 75 | using NetEqStatsGetterMap = |
| 76 | std::map<uint32_t, std::unique_ptr<test::NetEqStatsGetter>>; |
| 77 | NetEqStatsGetterMap SimulateNetEq(const std::string& replacement_file_name, |
| 78 | int file_sample_rate_hz) const; |
| 79 | void CreateAudioJitterBufferGraph( |
| 80 | const NetEqStatsGetterMap& neteq_stats_getters, |
| 81 | Plot* plot) const; |
Minyue Li | 27e2b7d | 2018-05-07 15:20:24 +0200 | [diff] [blame] | 82 | void CreateNetEqStatsGraph( |
| 83 | const NetEqStatsGetterMap& neteq_stats_getters, |
| 84 | rtc::FunctionView<float(const NetEqNetworkStatistics&)> stats_extractor, |
| 85 | const std::string& plot_name, |
| 86 | Plot* plot) const; |
michaelt | 6e5b219 | 2017-02-22 07:33:27 -0800 | [diff] [blame] | 87 | |
Qingsi Wang | 8eca1ff | 2018-02-02 11:49:44 -0800 | [diff] [blame] | 88 | void CreateIceCandidatePairConfigGraph(Plot* plot); |
| 89 | void CreateIceConnectivityCheckGraph(Plot* plot); |
| 90 | |
Bjorn Terelius | 2eb3188 | 2017-11-30 15:15:25 +0100 | [diff] [blame] | 91 | void CreateTriageNotifications(); |
| 92 | void PrintNotifications(FILE* file); |
| 93 | |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 94 | private: |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 95 | bool IsRtxSsrc(PacketDirection direction, uint32_t ssrc) const { |
| 96 | if (direction == kIncomingPacket) { |
| 97 | return parsed_log_.incoming_rtx_ssrcs().find(ssrc) != |
| 98 | parsed_log_.incoming_rtx_ssrcs().end(); |
| 99 | } else { |
| 100 | return parsed_log_.outgoing_rtx_ssrcs().find(ssrc) != |
| 101 | parsed_log_.outgoing_rtx_ssrcs().end(); |
terelius | 0740a20 | 2016-08-08 10:21:04 -0700 | [diff] [blame] | 102 | } |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 103 | } |
| 104 | |
| 105 | bool IsVideoSsrc(PacketDirection direction, uint32_t ssrc) const { |
| 106 | if (direction == kIncomingPacket) { |
| 107 | return parsed_log_.incoming_video_ssrcs().find(ssrc) != |
| 108 | parsed_log_.incoming_video_ssrcs().end(); |
| 109 | } else { |
| 110 | return parsed_log_.outgoing_video_ssrcs().find(ssrc) != |
| 111 | parsed_log_.outgoing_video_ssrcs().end(); |
terelius | 0740a20 | 2016-08-08 10:21:04 -0700 | [diff] [blame] | 112 | } |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 113 | } |
terelius | 88e64e5 | 2016-07-19 01:51:06 -0700 | [diff] [blame] | 114 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 115 | bool IsAudioSsrc(PacketDirection direction, uint32_t ssrc) const { |
| 116 | if (direction == kIncomingPacket) { |
| 117 | return parsed_log_.incoming_audio_ssrcs().find(ssrc) != |
| 118 | parsed_log_.incoming_audio_ssrcs().end(); |
| 119 | } else { |
| 120 | return parsed_log_.outgoing_audio_ssrcs().find(ssrc) != |
| 121 | parsed_log_.outgoing_audio_ssrcs().end(); |
| 122 | } |
| 123 | } |
terelius | 88e64e5 | 2016-07-19 01:51:06 -0700 | [diff] [blame] | 124 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 125 | template <typename IterableType> |
| 126 | void CreateAccumulatedPacketsTimeSeries(Plot* plot, |
| 127 | const IterableType& packets, |
| 128 | const std::string& label); |
philipel | ccd7489 | 2016-09-05 02:46:25 -0700 | [diff] [blame] | 129 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 130 | void CreateStreamGapAlerts(PacketDirection direction); |
| 131 | void CreateTransmissionGapAlerts(PacketDirection direction); |
terelius | 0740a20 | 2016-08-08 10:21:04 -0700 | [diff] [blame] | 132 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 133 | std::string GetStreamName(PacketDirection direction, uint32_t ssrc) const { |
| 134 | char buffer[200]; |
| 135 | rtc::SimpleStringBuilder name(buffer); |
| 136 | if (IsAudioSsrc(direction, ssrc)) { |
| 137 | name << "Audio "; |
| 138 | } else if (IsVideoSsrc(direction, ssrc)) { |
| 139 | name << "Video "; |
| 140 | } else { |
| 141 | name << "Unknown "; |
| 142 | } |
| 143 | if (IsRtxSsrc(direction, ssrc)) { |
| 144 | name << "RTX "; |
| 145 | } |
| 146 | if (direction == kIncomingPacket) |
| 147 | name << "(In) "; |
| 148 | else |
| 149 | name << "(Out) "; |
| 150 | name << "SSRC " << ssrc; |
| 151 | return name.str(); |
| 152 | } |
terelius | 0740a20 | 2016-08-08 10:21:04 -0700 | [diff] [blame] | 153 | |
Stefan Holmer | 1d4a227 | 2018-05-24 13:48:09 +0200 | [diff] [blame^] | 154 | int64_t ToCallTimeUs(int64_t timestamp) const; |
| 155 | float ToCallTimeSec(int64_t timestamp) const; |
Bjorn Terelius | 2eb3188 | 2017-11-30 15:15:25 +0100 | [diff] [blame] | 156 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 157 | void Alert_RtpLogTimeGap(PacketDirection direction, |
| 158 | float time_seconds, |
| 159 | int64_t duration) { |
| 160 | if (direction == kIncomingPacket) { |
| 161 | incoming_rtp_recv_time_gaps_.emplace_back(time_seconds, duration); |
| 162 | } else { |
| 163 | outgoing_rtp_send_time_gaps_.emplace_back(time_seconds, duration); |
| 164 | } |
| 165 | } |
| 166 | |
| 167 | void Alert_RtcpLogTimeGap(PacketDirection direction, |
| 168 | float time_seconds, |
| 169 | int64_t duration) { |
| 170 | if (direction == kIncomingPacket) { |
| 171 | incoming_rtcp_recv_time_gaps_.emplace_back(time_seconds, duration); |
| 172 | } else { |
| 173 | outgoing_rtcp_send_time_gaps_.emplace_back(time_seconds, duration); |
| 174 | } |
| 175 | } |
| 176 | |
| 177 | void Alert_SeqNumJump(PacketDirection direction, |
| 178 | float time_seconds, |
| 179 | uint32_t ssrc) { |
| 180 | if (direction == kIncomingPacket) { |
| 181 | incoming_seq_num_jumps_.emplace_back(time_seconds, ssrc); |
| 182 | } else { |
| 183 | outgoing_seq_num_jumps_.emplace_back(time_seconds, ssrc); |
| 184 | } |
| 185 | } |
| 186 | |
| 187 | void Alert_CaptureTimeJump(PacketDirection direction, |
| 188 | float time_seconds, |
| 189 | uint32_t ssrc) { |
| 190 | if (direction == kIncomingPacket) { |
| 191 | incoming_capture_time_jumps_.emplace_back(time_seconds, ssrc); |
| 192 | } else { |
| 193 | outgoing_capture_time_jumps_.emplace_back(time_seconds, ssrc); |
| 194 | } |
| 195 | } |
| 196 | |
| 197 | void Alert_OutgoingHighLoss(double avg_loss_fraction) { |
| 198 | outgoing_high_loss_alerts_.emplace_back(avg_loss_fraction); |
| 199 | } |
Bjorn Terelius | 2eb3188 | 2017-11-30 15:15:25 +0100 | [diff] [blame] | 200 | |
Qingsi Wang | 8eca1ff | 2018-02-02 11:49:44 -0800 | [diff] [blame] | 201 | std::string GetCandidatePairLogDescriptionFromId(uint32_t candidate_pair_id); |
| 202 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 203 | const ParsedRtcEventLogNew& parsed_log_; |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 204 | |
| 205 | // A list of SSRCs we are interested in analysing. |
| 206 | // If left empty, all SSRCs will be considered relevant. |
| 207 | std::vector<uint32_t> desired_ssrc_; |
| 208 | |
henrik.lundin | 3c938fc | 2017-06-14 06:09:58 -0700 | [diff] [blame] | 209 | // Stores the timestamps for all log segments, in the form of associated start |
| 210 | // and end events. |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 211 | std::vector<std::pair<int64_t, int64_t>> log_segments_; |
henrik.lundin | 3c938fc | 2017-06-14 06:09:58 -0700 | [diff] [blame] | 212 | |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 213 | std::vector<IncomingRtpReceiveTimeGap> incoming_rtp_recv_time_gaps_; |
| 214 | std::vector<IncomingRtcpReceiveTimeGap> incoming_rtcp_recv_time_gaps_; |
| 215 | std::vector<OutgoingRtpSendTimeGap> outgoing_rtp_send_time_gaps_; |
| 216 | std::vector<OutgoingRtcpSendTimeGap> outgoing_rtcp_send_time_gaps_; |
| 217 | std::vector<IncomingSeqNumJump> incoming_seq_num_jumps_; |
| 218 | std::vector<IncomingCaptureTimeJump> incoming_capture_time_jumps_; |
| 219 | std::vector<OutgoingSeqNoJump> outgoing_seq_num_jumps_; |
| 220 | std::vector<OutgoingCaptureTimeJump> outgoing_capture_time_jumps_; |
| 221 | std::vector<OutgoingHighLoss> outgoing_high_loss_alerts_; |
Qingsi Wang | 8eca1ff | 2018-02-02 11:49:44 -0800 | [diff] [blame] | 222 | |
| 223 | std::map<uint32_t, std::string> candidate_pair_desc_by_id_; |
| 224 | |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 225 | // Window and step size used for calculating moving averages, e.g. bitrate. |
| 226 | // The generated data points will be |step_| microseconds apart. |
| 227 | // Only events occuring at most |window_duration_| microseconds before the |
| 228 | // current data point will be part of the average. |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 229 | int64_t window_duration_; |
| 230 | int64_t step_; |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 231 | |
| 232 | // First and last events of the log. |
Bjorn Terelius | c4ca1d3 | 2018-04-27 14:33:34 +0200 | [diff] [blame] | 233 | int64_t begin_time_; |
| 234 | int64_t end_time_; |
Stefan Holmer | 1d4a227 | 2018-05-24 13:48:09 +0200 | [diff] [blame^] | 235 | const bool normalize_time_; |
terelius | dc35dcd | 2016-08-01 12:03:27 -0700 | [diff] [blame] | 236 | |
| 237 | // Duration (in seconds) of log file. |
| 238 | float call_duration_s_; |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 239 | }; |
| 240 | |
terelius | 54ce680 | 2016-07-13 06:44:41 -0700 | [diff] [blame] | 241 | } // namespace webrtc |
| 242 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 243 | #endif // RTC_TOOLS_EVENT_LOG_VISUALIZER_ANALYZER_H_ |