zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Break out parameters from EventLogAnalyzer to AnalyzerConfig struct.

Browse Source 
This is not a functional change. I've verified that the event_log_visualizer outputs the same bytes before and after the CL.

Bug: webrtc:10102, webrtc:10312
Change-Id: I49c4c847926078cefc9b72fe57fbdaebf76423e9
Reviewed-on: https://webrtc-review.googlesource.com/c/122844
Reviewed-by: Mirta Dvornicic <mirtad@webrtc.org>
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26685}
This commit is contained in:
Bjorn Terelius
2019-02-13 22:38:25 +01:00
committed by Commit Bot
parent f0c366b461
commit 068fc359e5
2 changed files with 167 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

295
rtc_tools/event_log_visualizer/analyzer.cc
View File

@ -288,19 +288,16 @@ void AccumulatePairs(
// during the preceeding |window_duration_us| microseconds. // during the preceeding |window_duration_us| microseconds.
template <typename DataType, typename ResultType, typename IterableType> template <typename DataType, typename ResultType, typename IterableType>
void MovingAverage( void MovingAverage(
rtc::FunctionView<float(int64_t)> fx,
rtc::FunctionView<absl::optional<ResultType>(const DataType&)> fy, rtc::FunctionView<absl::optional<ResultType>(const DataType&)> fy,
const IterableType& data_view, const IterableType& data_view,
int64_t begin_time, AnalyzerConfig config,
int64_t end_time,
int64_t window_duration_us,
int64_t step,
TimeSeries* result) { TimeSeries* result) {
size_t window_index_begin = 0; size_t window_index_begin = 0;
size_t window_index_end = 0; size_t window_index_end = 0;
ResultType sum_in_window = 0; ResultType sum_in_window = 0;
for (int64_t t = begin_time; t < end_time + step; t += step) { for (int64_t t = config.begin_time_; t < config.end_time_ + config.step_;
t += config.step_) {
while (window_index_end < data_view.size() && while (window_index_end < data_view.size() &&
data_view[window_index_end].log_time_us() < t) { data_view[window_index_end].log_time_us() < t) {
absl::optional<ResultType> value = fy(data_view[window_index_end]); absl::optional<ResultType> value = fy(data_view[window_index_end]);
@ -310,15 +307,15 @@ void MovingAverage(
} }
while (window_index_begin < data_view.size() && while (window_index_begin < data_view.size() &&
data_view[window_index_begin].log_time_us() < data_view[window_index_begin].log_time_us() <
t - window_duration_us) { t - config.window_duration_) {
absl::optional<ResultType> value = fy(data_view[window_index_begin]); absl::optional<ResultType> value = fy(data_view[window_index_begin]);
if (value) if (value)
sum_in_window -= *value; sum_in_window -= *value;
++window_index_begin; ++window_index_begin;
} }
float window_duration_s = float window_duration_s =
static_cast<float>(window_duration_us) / kNumMicrosecsPerSec; static_cast<float>(config.window_duration_) / kNumMicrosecsPerSec;
float x = fx(t); float x = config.GetCallTimeSec(t);
float y = sum_in_window / window_duration_s; float y = sum_in_window / window_duration_s;
result->points.emplace_back(x, y); result->points.emplace_back(x, y);
} }
@ -448,17 +445,16 @@ std::string GetDirectionAsShortString(PacketDirection direction) {
EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log, EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log,
bool normalize_time) bool normalize_time)
: parsed_log_(log), : parsed_log_(log) {
window_duration_(250000), config_.window_duration_ = 250000;
step_(10000), config_.step_ = 10000;
normalize_time_(normalize_time) { config_.normalize_time_ = normalize_time;
begin_time_ = parsed_log_.first_timestamp(); config_.begin_time_ = parsed_log_.first_timestamp();
end_time_ = parsed_log_.last_timestamp(); config_.end_time_ = parsed_log_.last_timestamp();
if (end_time_ < begin_time_) { if (config_.end_time_ < config_.begin_time_) {
RTC_LOG(LS_WARNING) << "No useful events in the log."; RTC_LOG(LS_WARNING) << "No useful events in the log.";
begin_time_ = end_time_ = 0; config_.begin_time_ = config_.end_time_ = 0;
} }
call_duration_s_ = ToCallTimeSec(end_time_);
const auto& log_start_events = parsed_log_.start_log_events(); const auto& log_start_events = parsed_log_.start_log_events();
const auto& log_end_events = parsed_log_.stop_log_events(); const auto& log_end_events = parsed_log_.stop_log_events();
@ -481,7 +477,7 @@ EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log,
// we're missing an end event. Assume that it occurred just before the // we're missing an end event. Assume that it occurred just before the
// next start. // next start.
log_segments_.push_back( log_segments_.push_back(
std::make_pair(start, next_start.value_or(end_time_))); std::make_pair(start, next_start.value_or(config_.end_time_)));
} }
} }
RTC_LOG(LS_INFO) << "Found " << log_segments_.size() RTC_LOG(LS_INFO) << "Found " << log_segments_.size()
@ -514,18 +510,6 @@ class BitrateObserver : public RemoteBitrateObserver {
bool bitrate_updated_; bool bitrate_updated_;
}; };
int64_t EventLogAnalyzer::ToCallTimeUs(int64_t timestamp) const {
int64_t begin_time = 0;
if (normalize_time_) {
begin_time = begin_time_;
}
return timestamp - begin_time;
}
float EventLogAnalyzer::ToCallTimeSec(int64_t timestamp) const {
return static_cast<float>(ToCallTimeUs(timestamp)) / kNumMicrosecsPerSec;
}
void EventLogAnalyzer::CreatePacketGraph(PacketDirection direction, void EventLogAnalyzer::CreatePacketGraph(PacketDirection direction,
Plot* plot) { Plot* plot) {
for (const auto& stream : parsed_log_.rtp_packets_by_ssrc(direction)) { for (const auto& stream : parsed_log_.rtp_packets_by_ssrc(direction)) {
@ -540,15 +524,15 @@ void EventLogAnalyzer::CreatePacketGraph(PacketDirection direction,
return absl::optional<float>(packet.total_length); return absl::optional<float>(packet.total_length);
}; };
auto ToCallTime = [this](const LoggedRtpPacket& packet) { auto ToCallTime = [this](const LoggedRtpPacket& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
ProcessPoints<LoggedRtpPacket>(ToCallTime, GetPacketSize, ProcessPoints<LoggedRtpPacket>(ToCallTime, GetPacketSize,
stream.packet_view, &time_series); stream.packet_view, &time_series);
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Packet size (bytes)", kBottomMargin, plot->SetSuggestedYAxis(0, 1, "Packet size (bytes)", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle(GetDirectionAsString(direction) + " RTP packets"); plot->SetTitle(GetDirectionAsString(direction) + " RTP packets");
@ -561,7 +545,7 @@ void EventLogAnalyzer::CreateAccumulatedPacketsTimeSeries(
const std::string& label) { const std::string& label) {
TimeSeries time_series(label, LineStyle::kStep); TimeSeries time_series(label, LineStyle::kStep);
for (size_t i = 0; i < packets.size(); i++) { for (size_t i = 0; i < packets.size(); i++) {
float x = ToCallTimeSec(packets[i].log_time_us()); float x = config_.GetCallTimeSec(packets[i].log_time_us());
time_series.points.emplace_back(x, i + 1); time_series.points.emplace_back(x, i + 1);
} }
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
@ -586,8 +570,8 @@ void EventLogAnalyzer::CreateAccumulatedPacketsGraph(PacketDirection direction,
plot, parsed_log_.outgoing_rtcp_packets(), label); plot, parsed_log_.outgoing_rtcp_packets(), label);
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Received Packets", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "Received Packets", kBottomMargin, kTopMargin);
plot->SetTitle(std::string("Accumulated ") + GetDirectionAsString(direction) + plot->SetTitle(std::string("Accumulated ") + GetDirectionAsString(direction) +
" RTP/RTCP packets"); " RTP/RTCP packets");
@ -602,7 +586,7 @@ void EventLogAnalyzer::CreatePlayoutGraph(Plot* plot) {
absl::optional<int64_t> last_playout_ms; absl::optional<int64_t> last_playout_ms;
TimeSeries time_series(SsrcToString(ssrc), LineStyle::kBar); TimeSeries time_series(SsrcToString(ssrc), LineStyle::kBar);
for (const auto& playout_event : playout_stream.second) { for (const auto& playout_event : playout_stream.second) {
float x = ToCallTimeSec(playout_event.log_time_us()); float x = config_.GetCallTimeSec(playout_event.log_time_us());
int64_t playout_time_ms = playout_event.log_time_ms(); int64_t playout_time_ms = playout_event.log_time_ms();
// If there were no previous playouts, place the point on the x-axis. // If there were no previous playouts, place the point on the x-axis.
float y = playout_time_ms - last_playout_ms.value_or(playout_time_ms); float y = playout_time_ms - last_playout_ms.value_or(playout_time_ms);
@ -612,8 +596,8 @@ void EventLogAnalyzer::CreatePlayoutGraph(Plot* plot) {
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Time since last playout (ms)", kBottomMargin, plot->SetSuggestedYAxis(0, 1, "Time since last playout (ms)", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle("Audio playout"); plot->SetTitle("Audio playout");
@ -629,7 +613,7 @@ void EventLogAnalyzer::CreateAudioLevelGraph(PacketDirection direction,
LineStyle::kLine); LineStyle::kLine);
for (auto& packet : stream.packet_view) { for (auto& packet : stream.packet_view) {
if (packet.header.extension.hasAudioLevel) { if (packet.header.extension.hasAudioLevel) {
float x = ToCallTimeSec(packet.log_time_us()); float x = config_.GetCallTimeSec(packet.log_time_us());
// The audio level is stored in -dBov (so e.g. -10 dBov is stored as 10) // The audio level is stored in -dBov (so e.g. -10 dBov is stored as 10)
// Here we convert it to dBov. // Here we convert it to dBov.
float y = static_cast<float>(-packet.header.extension.audioLevel); float y = static_cast<float>(-packet.header.extension.audioLevel);
@ -639,8 +623,8 @@ void EventLogAnalyzer::CreateAudioLevelGraph(PacketDirection direction,
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetYAxis(-127, 0, "Audio level (dBov)", kBottomMargin, kTopMargin); plot->SetYAxis(-127, 0, "Audio level (dBov)", kBottomMargin, kTopMargin);
plot->SetTitle(GetDirectionAsString(direction) + " audio level"); plot->SetTitle(GetDirectionAsString(direction) + " audio level");
} }
@ -663,7 +647,7 @@ void EventLogAnalyzer::CreateSequenceNumberGraph(Plot* plot) {
return diff; return diff;
}; };
auto ToCallTime = [this](const LoggedRtpPacketIncoming& packet) { auto ToCallTime = [this](const LoggedRtpPacketIncoming& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
ProcessPairs<LoggedRtpPacketIncoming, float>( ProcessPairs<LoggedRtpPacketIncoming, float>(
ToCallTime, GetSequenceNumberDiff, stream.incoming_packets, ToCallTime, GetSequenceNumberDiff, stream.incoming_packets,
@ -671,8 +655,8 @@ void EventLogAnalyzer::CreateSequenceNumberGraph(Plot* plot) {
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Difference since last packet", kBottomMargin, plot->SetSuggestedYAxis(0, 1, "Difference since last packet", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle("Sequence number"); plot->SetTitle("Sequence number");
@ -702,7 +686,8 @@ void EventLogAnalyzer::CreateIncomingPacketLossGraph(Plot* plot) {
uint64_t highest_prior_seq_number = uint64_t highest_prior_seq_number =
prior_unwrapper_.Unwrap(packets[0].rtp.header.sequenceNumber) - 1; prior_unwrapper_.Unwrap(packets[0].rtp.header.sequenceNumber) - 1;
for (int64_t t = begin_time_; t < end_time_ + kStep; t += kStep) { for (int64_t t = config_.begin_time_; t < config_.end_time_ + kStep;
t += kStep) {
while (window_index_end < packets.size() && while (window_index_end < packets.size() &&
packets[window_index_end].rtp.log_time_us() < t) { packets[window_index_end].rtp.log_time_us() < t) {
uint64_t sequence_number = unwrapper_.Unwrap( uint64_t sequence_number = unwrapper_.Unwrap(
@ -718,7 +703,7 @@ void EventLogAnalyzer::CreateIncomingPacketLossGraph(Plot* plot) {
std::max(highest_prior_seq_number, sequence_number); std::max(highest_prior_seq_number, sequence_number);
++window_index_begin; ++window_index_begin;
} }
float x = ToCallTimeSec(t); float x = config_.GetCallTimeSec(t);
uint64_t expected_packets = highest_seq_number - highest_prior_seq_number; uint64_t expected_packets = highest_seq_number - highest_prior_seq_number;
if (expected_packets > 0) { if (expected_packets > 0) {
int64_t received_packets = window_index_end - window_index_begin; int64_t received_packets = window_index_end - window_index_begin;
@ -730,8 +715,8 @@ void EventLogAnalyzer::CreateIncomingPacketLossGraph(Plot* plot) {
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Estimated loss rate (%)", kBottomMargin, plot->SetSuggestedYAxis(0, 1, "Estimated loss rate (%)", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle("Estimated incoming loss rate"); plot->SetTitle("Estimated incoming loss rate");
@ -768,7 +753,7 @@ void EventLogAnalyzer::CreateIncomingDelayGraph(Plot* plot) {
} }
auto ToCallTime = [this](const LoggedRtpPacketIncoming& packet) { auto ToCallTime = [this](const LoggedRtpPacketIncoming& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
auto ToNetworkDelay = [frequency_hz]( auto ToNetworkDelay = [frequency_hz](
const LoggedRtpPacketIncoming& old_packet, const LoggedRtpPacketIncoming& old_packet,
@ -791,8 +776,8 @@ void EventLogAnalyzer::CreateIncomingDelayGraph(Plot* plot) {
plot->AppendTimeSeriesIfNotEmpty(std::move(send_time_data)); plot->AppendTimeSeriesIfNotEmpty(std::move(send_time_data));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Delay (ms)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "Delay (ms)", kBottomMargin, kTopMargin);
plot->SetTitle("Incoming network delay (relative to first packet)"); plot->SetTitle("Incoming network delay (relative to first packet)");
} }
@ -802,14 +787,14 @@ void EventLogAnalyzer::CreateFractionLossGraph(Plot* plot) {
TimeSeries time_series("Fraction lost", LineStyle::kLine, TimeSeries time_series("Fraction lost", LineStyle::kLine,
PointStyle::kHighlight); PointStyle::kHighlight);
for (auto& bwe_update : parsed_log_.bwe_loss_updates()) { for (auto& bwe_update : parsed_log_.bwe_loss_updates()) {
float x = ToCallTimeSec(bwe_update.log_time_us()); float x = config_.GetCallTimeSec(bwe_update.log_time_us());
float y = static_cast<float>(bwe_update.fraction_lost) / 255 * 100; float y = static_cast<float>(bwe_update.fraction_lost) / 255 * 100;
time_series.points.emplace_back(x, y); time_series.points.emplace_back(x, y);
} }
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin, plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle("Reported packet loss"); plot->SetTitle("Reported packet loss");
@ -831,20 +816,21 @@ void EventLogAnalyzer::CreateTotalIncomingBitrateGraph(Plot* plot) {
// Calculate a moving average of the bitrate and store in a TimeSeries. // Calculate a moving average of the bitrate and store in a TimeSeries.
TimeSeries bitrate_series("Bitrate", LineStyle::kLine); TimeSeries bitrate_series("Bitrate", LineStyle::kLine);
for (int64_t time = begin_time_; time < end_time_ + step_; time += step_) { for (int64_t time = config_.begin_time_;
time < config_.end_time_ + config_.step_; time += config_.step_) {
while (window_end != packets_in_order.end() && window_end->first < time) { while (window_end != packets_in_order.end() && window_end->first < time) {
bytes_in_window += window_end->second; bytes_in_window += window_end->second;
++window_end; ++window_end;
} }
while (window_begin != packets_in_order.end() && while (window_begin != packets_in_order.end() &&
window_begin->first < time - window_duration_) { window_begin->first < time - config_.window_duration_) {
RTC_DCHECK_LE(window_begin->second, bytes_in_window); RTC_DCHECK_LE(window_begin->second, bytes_in_window);
bytes_in_window -= window_begin->second; bytes_in_window -= window_begin->second;
++window_begin; ++window_begin;
} }
float window_duration_in_seconds = float window_duration_in_seconds =
static_cast<float>(window_duration_) / kNumMicrosecsPerSec; static_cast<float>(config_.window_duration_) / kNumMicrosecsPerSec;
float x = ToCallTimeSec(time); float x = config_.GetCallTimeSec(time);
float y = bytes_in_window * 8 / window_duration_in_seconds / 1000; float y = bytes_in_window * 8 / window_duration_in_seconds / 1000;
bitrate_series.points.emplace_back(x, y); bitrate_series.points.emplace_back(x, y);
} }
@ -853,14 +839,14 @@ void EventLogAnalyzer::CreateTotalIncomingBitrateGraph(Plot* plot) {
// Overlay the outgoing REMB over incoming bitrate. // Overlay the outgoing REMB over incoming bitrate.
TimeSeries remb_series("Remb", LineStyle::kStep); TimeSeries remb_series("Remb", LineStyle::kStep);
for (const auto& rtcp : parsed_log_.rembs(kOutgoingPacket)) { for (const auto& rtcp : parsed_log_.rembs(kOutgoingPacket)) {
float x = ToCallTimeSec(rtcp.log_time_us()); float x = config_.GetCallTimeSec(rtcp.log_time_us());
float y = static_cast<float>(rtcp.remb.bitrate_bps()) / 1000; float y = static_cast<float>(rtcp.remb.bitrate_bps()) / 1000;
remb_series.points.emplace_back(x, y); remb_series.points.emplace_back(x, y);
} }
plot->AppendTimeSeriesIfNotEmpty(std::move(remb_series)); plot->AppendTimeSeriesIfNotEmpty(std::move(remb_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
plot->SetTitle("Incoming RTP bitrate"); plot->SetTitle("Incoming RTP bitrate");
} }
@ -883,20 +869,21 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
// Calculate a moving average of the bitrate and store in a TimeSeries. // Calculate a moving average of the bitrate and store in a TimeSeries.
TimeSeries bitrate_series("Bitrate", LineStyle::kLine); TimeSeries bitrate_series("Bitrate", LineStyle::kLine);
for (int64_t time = begin_time_; time < end_time_ + step_; time += step_) { for (int64_t time = config_.begin_time_;
time < config_.end_time_ + config_.step_; time += config_.step_) {
while (window_end != packets_in_order.end() && window_end->first < time) { while (window_end != packets_in_order.end() && window_end->first < time) {
bytes_in_window += window_end->second; bytes_in_window += window_end->second;
++window_end; ++window_end;
} }
while (window_begin != packets_in_order.end() && while (window_begin != packets_in_order.end() &&
window_begin->first < time - window_duration_) { window_begin->first < time - config_.window_duration_) {
RTC_DCHECK_LE(window_begin->second, bytes_in_window); RTC_DCHECK_LE(window_begin->second, bytes_in_window);
bytes_in_window -= window_begin->second; bytes_in_window -= window_begin->second;
++window_begin; ++window_begin;
} }
float window_duration_in_seconds = float window_duration_in_seconds =
static_cast<float>(window_duration_) / kNumMicrosecsPerSec; static_cast<float>(config_.window_duration_) / kNumMicrosecsPerSec;
float x = ToCallTimeSec(time); float x = config_.GetCallTimeSec(time);
float y = bytes_in_window * 8 / window_duration_in_seconds / 1000; float y = bytes_in_window * 8 / window_duration_in_seconds / 1000;
bitrate_series.points.emplace_back(x, y); bitrate_series.points.emplace_back(x, y);
} }
@ -905,7 +892,7 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
// Overlay the send-side bandwidth estimate over the outgoing bitrate. // Overlay the send-side bandwidth estimate over the outgoing bitrate.
TimeSeries loss_series("Loss-based estimate", LineStyle::kStep); TimeSeries loss_series("Loss-based estimate", LineStyle::kStep);
for (auto& loss_update : parsed_log_.bwe_loss_updates()) { for (auto& loss_update : parsed_log_.bwe_loss_updates()) {
float x = ToCallTimeSec(loss_update.log_time_us()); float x = config_.GetCallTimeSec(loss_update.log_time_us());
float y = static_cast<float>(loss_update.bitrate_bps) / 1000; float y = static_cast<float>(loss_update.bitrate_bps) / 1000;
loss_series.points.emplace_back(x, y); loss_series.points.emplace_back(x, y);
} }
@ -923,7 +910,7 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
BandwidthUsage last_detector_state = BandwidthUsage::kBwNormal; BandwidthUsage last_detector_state = BandwidthUsage::kBwNormal;
for (auto& delay_update : parsed_log_.bwe_delay_updates()) { for (auto& delay_update : parsed_log_.bwe_delay_updates()) {
float x = ToCallTimeSec(delay_update.log_time_us()); float x = config_.GetCallTimeSec(delay_update.log_time_us());
float y = static_cast<float>(delay_update.bitrate_bps) / 1000; float y = static_cast<float>(delay_update.bitrate_bps) / 1000;
if (last_detector_state != delay_update.detector_state) { if (last_detector_state != delay_update.detector_state) {
@ -950,12 +937,12 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
} }
RTC_CHECK(last_series); RTC_CHECK(last_series);
last_series->intervals.emplace_back(last_detector_switch, end_time_); last_series->intervals.emplace_back(last_detector_switch, config_.end_time_);
TimeSeries created_series("Probe cluster created.", LineStyle::kNone, TimeSeries created_series("Probe cluster created.", LineStyle::kNone,
PointStyle::kHighlight); PointStyle::kHighlight);
for (auto& cluster : parsed_log_.bwe_probe_cluster_created_events()) { for (auto& cluster : parsed_log_.bwe_probe_cluster_created_events()) {
float x = ToCallTimeSec(cluster.log_time_us()); float x = config_.GetCallTimeSec(cluster.log_time_us());
float y = static_cast<float>(cluster.bitrate_bps) / 1000; float y = static_cast<float>(cluster.bitrate_bps) / 1000;
created_series.points.emplace_back(x, y); created_series.points.emplace_back(x, y);
} }
@ -963,7 +950,7 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
TimeSeries result_series("Probing results.", LineStyle::kNone, TimeSeries result_series("Probing results.", LineStyle::kNone,
PointStyle::kHighlight); PointStyle::kHighlight);
for (auto& result : parsed_log_.bwe_probe_success_events()) { for (auto& result : parsed_log_.bwe_probe_success_events()) {
float x = ToCallTimeSec(result.log_time_us()); float x = config_.GetCallTimeSec(result.log_time_us());
float y = static_cast<float>(result.bitrate_bps) / 1000; float y = static_cast<float>(result.bitrate_bps) / 1000;
result_series.points.emplace_back(x, y); result_series.points.emplace_back(x, y);
} }
@ -971,7 +958,7 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
TimeSeries probe_failures_series("Probe failed", LineStyle::kNone, TimeSeries probe_failures_series("Probe failed", LineStyle::kNone,
PointStyle::kHighlight); PointStyle::kHighlight);
for (auto& failure : parsed_log_.bwe_probe_failure_events()) { for (auto& failure : parsed_log_.bwe_probe_failure_events()) {
float x = ToCallTimeSec(failure.log_time_us()); float x = config_.GetCallTimeSec(failure.log_time_us());
probe_failures_series.points.emplace_back(x, 0); probe_failures_series.points.emplace_back(x, 0);
} }
@ -979,20 +966,20 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
bool previously_in_alr = false; bool previously_in_alr = false;
int64_t alr_start = 0; int64_t alr_start = 0;
for (auto& alr : parsed_log_.alr_state_events()) { for (auto& alr : parsed_log_.alr_state_events()) {
float y = ToCallTimeSec(alr.log_time_us()); float y = config_.GetCallTimeSec(alr.log_time_us());
if (!previously_in_alr && alr.in_alr) { if (!previously_in_alr && alr.in_alr) {
alr_start = alr.log_time_us(); alr_start = alr.log_time_us();
previously_in_alr = true; previously_in_alr = true;
} else if (previously_in_alr && !alr.in_alr) { } else if (previously_in_alr && !alr.in_alr) {
float x = ToCallTimeSec(alr_start); float x = config_.GetCallTimeSec(alr_start);
alr_state.intervals.emplace_back(x, y); alr_state.intervals.emplace_back(x, y);
previously_in_alr = false; previously_in_alr = false;
} }
} }
if (previously_in_alr) { if (previously_in_alr) {
float x = ToCallTimeSec(alr_start); float x = config_.GetCallTimeSec(alr_start);
float y = ToCallTimeSec(end_time_); float y = config_.GetCallTimeSec(config_.end_time_);
alr_state.intervals.emplace_back(x, y); alr_state.intervals.emplace_back(x, y);
} }
@ -1014,14 +1001,14 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
// Overlay the incoming REMB over the outgoing bitrate. // Overlay the incoming REMB over the outgoing bitrate.
TimeSeries remb_series("Remb", LineStyle::kStep); TimeSeries remb_series("Remb", LineStyle::kStep);
for (const auto& rtcp : parsed_log_.rembs(kIncomingPacket)) { for (const auto& rtcp : parsed_log_.rembs(kIncomingPacket)) {
float x = ToCallTimeSec(rtcp.log_time_us()); float x = config_.GetCallTimeSec(rtcp.log_time_us());
float y = static_cast<float>(rtcp.remb.bitrate_bps()) / 1000; float y = static_cast<float>(rtcp.remb.bitrate_bps()) / 1000;
remb_series.points.emplace_back(x, y); remb_series.points.emplace_back(x, y);
} }
plot->AppendTimeSeriesIfNotEmpty(std::move(remb_series)); plot->AppendTimeSeriesIfNotEmpty(std::move(remb_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
plot->SetTitle("Outgoing RTP bitrate"); plot->SetTitle("Outgoing RTP bitrate");
} }
@ -1040,17 +1027,13 @@ void EventLogAnalyzer::CreateStreamBitrateGraph(PacketDirection direction,
auto GetPacketSizeKilobits = [](const LoggedRtpPacket& packet) { auto GetPacketSizeKilobits = [](const LoggedRtpPacket& packet) {
return packet.total_length * 8.0 / 1000.0; return packet.total_length * 8.0 / 1000.0;
}; };
auto ToCallTime = [this](int64_t time) {
return this->ToCallTimeSec(time);
};
MovingAverage<LoggedRtpPacket, double>( MovingAverage<LoggedRtpPacket, double>(
ToCallTime, GetPacketSizeKilobits, stream.packet_view, begin_time_, GetPacketSizeKilobits, stream.packet_view, config_, &time_series);
end_time_, window_duration_, step_, &time_series);
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
plot->SetTitle(GetDirectionAsString(direction) + " bitrate per stream"); plot->SetTitle(GetDirectionAsString(direction) + " bitrate per stream");
} }
@ -1176,7 +1159,7 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
} }
} }
float x = ToCallTimeSec(clock.TimeInMicroseconds()); float x = config_.GetCallTimeSec(clock.TimeInMicroseconds());
float y = bitrate_bps.value_or(0) / 1000; float y = bitrate_bps.value_or(0) / 1000;
acked_time_series.points.emplace_back(x, y); acked_time_series.points.emplace_back(x, y);
#if !(BWE_TEST_LOGGING_COMPILE_TIME_ENABLE) #if !(BWE_TEST_LOGGING_COMPILE_TIME_ENABLE)
@ -1195,7 +1178,7 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
if (observer.GetAndResetBitrateUpdated() || if (observer.GetAndResetBitrateUpdated() ||
time_us - last_update_us >= 1e6) { time_us - last_update_us >= 1e6) {
uint32_t y = observer.last_bitrate_bps() / 1000; uint32_t y = observer.last_bitrate_bps() / 1000;
float x = ToCallTimeSec(clock.TimeInMicroseconds()); float x = config_.GetCallTimeSec(clock.TimeInMicroseconds());
time_series.points.emplace_back(x, y); time_series.points.emplace_back(x, y);
last_update_us = time_us; last_update_us = time_us;
} }
@ -1206,8 +1189,8 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
plot->AppendTimeSeries(std::move(acked_time_series)); plot->AppendTimeSeries(std::move(acked_time_series));
plot->AppendTimeSeriesIfNotEmpty(std::move(acked_estimate_time_series)); plot->AppendTimeSeriesIfNotEmpty(std::move(acked_estimate_time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 10, "Bitrate (kbps)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 10, "Bitrate (kbps)", kBottomMargin, kTopMargin);
plot->SetTitle("Simulated send-side BWE behavior"); plot->SetTitle("Simulated send-side BWE behavior");
} }
@ -1270,13 +1253,13 @@ void EventLogAnalyzer::CreateReceiveSideBweSimulationGraph(Plot* plot) {
absl::optional<uint32_t> bitrate_bps = acked_bitrate.Rate(arrival_time_ms); absl::optional<uint32_t> bitrate_bps = acked_bitrate.Rate(arrival_time_ms);
if (bitrate_bps) { if (bitrate_bps) {
uint32_t y = *bitrate_bps / 1000; uint32_t y = *bitrate_bps / 1000;
float x = ToCallTimeSec(clock.TimeInMicroseconds()); float x = config_.GetCallTimeSec(clock.TimeInMicroseconds());
acked_time_series.points.emplace_back(x, y); acked_time_series.points.emplace_back(x, y);
} }
if (packet_router.GetAndResetBitrateUpdated() || if (packet_router.GetAndResetBitrateUpdated() ||
clock.TimeInMicroseconds() - last_update_us >= 1e6) { clock.TimeInMicroseconds() - last_update_us >= 1e6) {
uint32_t y = packet_router.last_bitrate_bps() / 1000; uint32_t y = packet_router.last_bitrate_bps() / 1000;
float x = ToCallTimeSec(clock.TimeInMicroseconds()); float x = config_.GetCallTimeSec(clock.TimeInMicroseconds());
time_series.points.emplace_back(x, y); time_series.points.emplace_back(x, y);
last_update_us = clock.TimeInMicroseconds(); last_update_us = clock.TimeInMicroseconds();
} }
@ -1285,8 +1268,8 @@ void EventLogAnalyzer::CreateReceiveSideBweSimulationGraph(Plot* plot) {
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
plot->AppendTimeSeries(std::move(acked_time_series)); plot->AppendTimeSeries(std::move(acked_time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 10, "Bitrate (kbps)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 10, "Bitrate (kbps)", kBottomMargin, kTopMargin);
plot->SetTitle("Simulated receive-side BWE behavior"); plot->SetTitle("Simulated receive-side BWE behavior");
} }
@ -1303,7 +1286,7 @@ void EventLogAnalyzer::CreateNetworkDelayFeedbackGraph(Plot* plot) {
for (auto packet : GetNetworkTrace(parsed_log_)) { for (auto packet : GetNetworkTrace(parsed_log_)) {
if (packet.arrival_time_ms == PacketFeedback::kNotReceived) if (packet.arrival_time_ms == PacketFeedback::kNotReceived)
continue; continue;
float x = ToCallTimeSec(1000 * packet.feedback_arrival_time_ms); float x = config_.GetCallTimeSec(1000 * packet.feedback_arrival_time_ms);
if (packet.send_time_ms == PacketFeedback::kNoSendTime) { if (packet.send_time_ms == PacketFeedback::kNoSendTime) {
late_feedback_series.points.emplace_back(x, prev_y); late_feedback_series.points.emplace_back(x, prev_y);
continue; continue;
@ -1330,8 +1313,8 @@ void EventLogAnalyzer::CreateNetworkDelayFeedbackGraph(Plot* plot) {
plot->AppendTimeSeriesIfNotEmpty(std::move(time_series)); plot->AppendTimeSeriesIfNotEmpty(std::move(time_series));
plot->AppendTimeSeriesIfNotEmpty(std::move(late_feedback_series)); plot->AppendTimeSeriesIfNotEmpty(std::move(late_feedback_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 10, "Delay (ms)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 10, "Delay (ms)", kBottomMargin, kTopMargin);
plot->SetTitle("Outgoing network delay (based on per-packet feedback)"); plot->SetTitle("Outgoing network delay (based on per-packet feedback)");
} }
@ -1378,15 +1361,15 @@ void EventLogAnalyzer::CreatePacerDelayGraph(Plot* plot) {
double send_time_ms = double send_time_ms =
static_cast<double>(packet.rtp.log_time_us() - first_send_timestamp) / static_cast<double>(packet.rtp.log_time_us() - first_send_timestamp) /
1000; 1000;
float x = ToCallTimeSec(packet.rtp.log_time_us()); float x = config_.GetCallTimeSec(packet.rtp.log_time_us());
float y = send_time_ms - capture_time_ms; float y = send_time_ms - capture_time_ms;
pacer_delay_series.points.emplace_back(x, y); pacer_delay_series.points.emplace_back(x, y);
} }
plot->AppendTimeSeries(std::move(pacer_delay_series)); plot->AppendTimeSeries(std::move(pacer_delay_series));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 10, "Pacer delay (ms)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 10, "Pacer delay (ms)", kBottomMargin, kTopMargin);
plot->SetTitle( plot->SetTitle(
"Delay from capture to send time. (First packet normalized to 0.)"); "Delay from capture to send time. (First packet normalized to 0.)");
@ -1399,7 +1382,7 @@ void EventLogAnalyzer::CreateTimestampGraph(PacketDirection direction,
GetStreamName(direction, stream.ssrc) + " capture-time", GetStreamName(direction, stream.ssrc) + " capture-time",
LineStyle::kLine, PointStyle::kHighlight); LineStyle::kLine, PointStyle::kHighlight);
for (const auto& packet : stream.packet_view) { for (const auto& packet : stream.packet_view) {
float x = ToCallTimeSec(packet.log_time_us()); float x = config_.GetCallTimeSec(packet.log_time_us());
float y = packet.header.timestamp; float y = packet.header.timestamp;
rtp_timestamps.points.emplace_back(x, y); rtp_timestamps.points.emplace_back(x, y);
} }
@ -1413,15 +1396,15 @@ void EventLogAnalyzer::CreateTimestampGraph(PacketDirection direction,
for (const auto& rtcp : sender_reports) { for (const auto& rtcp : sender_reports) {
if (rtcp.sr.sender_ssrc() != stream.ssrc) if (rtcp.sr.sender_ssrc() != stream.ssrc)
continue; continue;
float x = ToCallTimeSec(rtcp.log_time_us()); float x = config_.GetCallTimeSec(rtcp.log_time_us());
float y = rtcp.sr.rtp_timestamp(); float y = rtcp.sr.rtp_timestamp();
rtcp_timestamps.points.emplace_back(x, y); rtcp_timestamps.points.emplace_back(x, y);
} }
plot->AppendTimeSeriesIfNotEmpty(std::move(rtcp_timestamps)); plot->AppendTimeSeriesIfNotEmpty(std::move(rtcp_timestamps));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "RTP timestamp", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "RTP timestamp", kBottomMargin, kTopMargin);
plot->SetTitle(GetDirectionAsString(direction) + " timestamps"); plot->SetTitle(GetDirectionAsString(direction) + " timestamps");
} }
@ -1435,7 +1418,7 @@ void EventLogAnalyzer::CreateSenderAndReceiverReportPlot(
std::map<uint32_t, TimeSeries> sr_reports_by_ssrc; std::map<uint32_t, TimeSeries> sr_reports_by_ssrc;
const auto& sender_reports = parsed_log_.sender_reports(direction); const auto& sender_reports = parsed_log_.sender_reports(direction);
for (const auto& rtcp : sender_reports) { for (const auto& rtcp : sender_reports) {
float x = ToCallTimeSec(rtcp.log_time_us()); float x = config_.GetCallTimeSec(rtcp.log_time_us());
uint32_t ssrc = rtcp.sr.sender_ssrc(); uint32_t ssrc = rtcp.sr.sender_ssrc();
for (const auto& block : rtcp.sr.report_blocks()) { for (const auto& block : rtcp.sr.report_blocks()) {
float y = fy(block); float y = fy(block);
@ -1456,7 +1439,7 @@ void EventLogAnalyzer::CreateSenderAndReceiverReportPlot(
std::map<uint32_t, TimeSeries> rr_reports_by_ssrc; std::map<uint32_t, TimeSeries> rr_reports_by_ssrc;
const auto& receiver_reports = parsed_log_.receiver_reports(direction); const auto& receiver_reports = parsed_log_.receiver_reports(direction);
for (const auto& rtcp : receiver_reports) { for (const auto& rtcp : receiver_reports) {
float x = ToCallTimeSec(rtcp.log_time_us()); float x = config_.GetCallTimeSec(rtcp.log_time_us());
uint32_t ssrc = rtcp.rr.sender_ssrc(); uint32_t ssrc = rtcp.rr.sender_ssrc();
for (const auto& block : rtcp.rr.report_blocks()) { for (const auto& block : rtcp.rr.report_blocks()) {
float y = fy(block); float y = fy(block);
@ -1475,8 +1458,8 @@ void EventLogAnalyzer::CreateSenderAndReceiverReportPlot(
plot->AppendTimeSeries(std::move(kv.second)); plot->AppendTimeSeries(std::move(kv.second));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, yaxis_label, kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, yaxis_label, kBottomMargin, kTopMargin);
plot->SetTitle(title); plot->SetTitle(title);
} }
@ -1492,14 +1475,14 @@ void EventLogAnalyzer::CreateAudioEncoderTargetBitrateGraph(Plot* plot) {
return absl::nullopt; return absl::nullopt;
}; };
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) { auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
ProcessPoints<LoggedAudioNetworkAdaptationEvent>( ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
ToCallTime, GetAnaBitrateBps, ToCallTime, GetAnaBitrateBps,
parsed_log_.audio_network_adaptation_events(), &time_series); parsed_log_.audio_network_adaptation_events(), &time_series);
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Bitrate (bps)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "Bitrate (bps)", kBottomMargin, kTopMargin);
plot->SetTitle("Reported audio encoder target bitrate"); plot->SetTitle("Reported audio encoder target bitrate");
} }
@ -1515,14 +1498,14 @@ void EventLogAnalyzer::CreateAudioEncoderFrameLengthGraph(Plot* plot) {
return absl::optional<float>(); return absl::optional<float>();
}; };
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) { auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
ProcessPoints<LoggedAudioNetworkAdaptationEvent>( ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
ToCallTime, GetAnaFrameLengthMs, ToCallTime, GetAnaFrameLengthMs,
parsed_log_.audio_network_adaptation_events(), &time_series); parsed_log_.audio_network_adaptation_events(), &time_series);
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Frame length (ms)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "Frame length (ms)", kBottomMargin, kTopMargin);
plot->SetTitle("Reported audio encoder frame length"); plot->SetTitle("Reported audio encoder frame length");
} }
@ -1538,14 +1521,14 @@ void EventLogAnalyzer::CreateAudioEncoderPacketLossGraph(Plot* plot) {
return absl::optional<float>(); return absl::optional<float>();
}; };
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) { auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
ProcessPoints<LoggedAudioNetworkAdaptationEvent>( ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
ToCallTime, GetAnaPacketLoss, ToCallTime, GetAnaPacketLoss,
parsed_log_.audio_network_adaptation_events(), &time_series); parsed_log_.audio_network_adaptation_events(), &time_series);
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin, plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle("Reported audio encoder lost packets"); plot->SetTitle("Reported audio encoder lost packets");
@ -1562,14 +1545,14 @@ void EventLogAnalyzer::CreateAudioEncoderEnableFecGraph(Plot* plot) {
return absl::optional<float>(); return absl::optional<float>();
}; };
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) { auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
ProcessPoints<LoggedAudioNetworkAdaptationEvent>( ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
ToCallTime, GetAnaFecEnabled, ToCallTime, GetAnaFecEnabled,
parsed_log_.audio_network_adaptation_events(), &time_series); parsed_log_.audio_network_adaptation_events(), &time_series);
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "FEC (false/true)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "FEC (false/true)", kBottomMargin, kTopMargin);
plot->SetTitle("Reported audio encoder FEC"); plot->SetTitle("Reported audio encoder FEC");
} }
@ -1585,14 +1568,14 @@ void EventLogAnalyzer::CreateAudioEncoderEnableDtxGraph(Plot* plot) {
return absl::optional<float>(); return absl::optional<float>();
}; };
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) { auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
ProcessPoints<LoggedAudioNetworkAdaptationEvent>( ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
ToCallTime, GetAnaDtxEnabled, ToCallTime, GetAnaDtxEnabled,
parsed_log_.audio_network_adaptation_events(), &time_series); parsed_log_.audio_network_adaptation_events(), &time_series);
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "DTX (false/true)", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "DTX (false/true)", kBottomMargin, kTopMargin);
plot->SetTitle("Reported audio encoder DTX"); plot->SetTitle("Reported audio encoder DTX");
} }
@ -1608,14 +1591,14 @@ void EventLogAnalyzer::CreateAudioEncoderNumChannelsGraph(Plot* plot) {
return absl::optional<float>(); return absl::optional<float>();
}; };
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) { auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
return this->ToCallTimeSec(packet.log_time_us()); return this->config_.GetCallTimeSec(packet.log_time_us());
}; };
ProcessPoints<LoggedAudioNetworkAdaptationEvent>( ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
ToCallTime, GetAnaNumChannels, ToCallTime, GetAnaNumChannels,
parsed_log_.audio_network_adaptation_events(), &time_series); parsed_log_.audio_network_adaptation_events(), &time_series);
plot->AppendTimeSeries(std::move(time_series)); plot->AppendTimeSeries(std::move(time_series));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Number of channels (1 (mono)/2 (stereo))", plot->SetSuggestedYAxis(0, 1, "Number of channels (1 (mono)/2 (stereo))",
kBottomMargin, kTopMargin); kBottomMargin, kTopMargin);
plot->SetTitle("Reported audio encoder number of channels"); plot->SetTitle("Reported audio encoder number of channels");
@ -1844,23 +1827,23 @@ void EventLogAnalyzer::CreateAudioJitterBufferGraph(
PointStyle::kHighlight); PointStyle::kHighlight);
for (const auto& data : arrival_delay_ms) { for (const auto& data : arrival_delay_ms) {
const float x = ToCallTimeSec(data.first * 1000); // ms to us. const float x = config_.GetCallTimeSec(data.first * 1000); // ms to us.
const float y = data.second; const float y = data.second;
time_series_packet_arrival.points.emplace_back(TimeSeriesPoint(x, y)); time_series_packet_arrival.points.emplace_back(TimeSeriesPoint(x, y));
} }
for (const auto& data : corrected_arrival_delay_ms) { for (const auto& data : corrected_arrival_delay_ms) {
const float x = ToCallTimeSec(data.first * 1000); // ms to us. const float x = config_.GetCallTimeSec(data.first * 1000); // ms to us.
const float y = data.second; const float y = data.second;
time_series_relative_packet_arrival.points.emplace_back( time_series_relative_packet_arrival.points.emplace_back(
TimeSeriesPoint(x, y)); TimeSeriesPoint(x, y));
} }
for (const auto& data : playout_delay_ms) { for (const auto& data : playout_delay_ms) {
const float x = ToCallTimeSec(data.first * 1000); // ms to us. const float x = config_.GetCallTimeSec(data.first * 1000); // ms to us.
const float y = data.second; const float y = data.second;
time_series_play_time.points.emplace_back(TimeSeriesPoint(x, y)); time_series_play_time.points.emplace_back(TimeSeriesPoint(x, y));
} }
for (const auto& data : target_delay_ms) { for (const auto& data : target_delay_ms) {
const float x = ToCallTimeSec(data.first * 1000); // ms to us. const float x = config_.GetCallTimeSec(data.first * 1000); // ms to us.
const float y = data.second; const float y = data.second;
time_series_target_time.points.emplace_back(TimeSeriesPoint(x, y)); time_series_target_time.points.emplace_back(TimeSeriesPoint(x, y));
} }
@ -1870,8 +1853,8 @@ void EventLogAnalyzer::CreateAudioJitterBufferGraph(
plot->AppendTimeSeries(std::move(time_series_play_time)); plot->AppendTimeSeries(std::move(time_series_play_time));
plot->AppendTimeSeries(std::move(time_series_target_time)); plot->AppendTimeSeries(std::move(time_series_target_time));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Relative delay (ms)", kBottomMargin, plot->SetSuggestedYAxis(0, 1, "Relative delay (ms)", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle("NetEq timing for " + GetStreamName(kIncomingPacket, ssrc)); plot->SetTitle("NetEq timing for " + GetStreamName(kIncomingPacket, ssrc));
@ -1892,7 +1875,8 @@ void EventLogAnalyzer::CreateNetEqStatsGraphInternal(
const std::vector<std::pair<int64_t, NetEqStatsType>>* data_vector = const std::vector<std::pair<int64_t, NetEqStatsType>>* data_vector =
data_extractor(st.second.get()); data_extractor(st.second.get());
for (const auto& data : *data_vector) { for (const auto& data : *data_vector) {
const float time = ToCallTimeSec(data.first * 1000); // ms to us. const float time =
config_.GetCallTimeSec(data.first * 1000); // ms to us.
const float value = stats_extractor(data.second); const float value = stats_extractor(data.second);
time_series[ssrc].points.emplace_back(TimeSeriesPoint(time, value)); time_series[ssrc].points.emplace_back(TimeSeriesPoint(time, value));
} }
@ -1904,8 +1888,8 @@ void EventLogAnalyzer::CreateNetEqStatsGraphInternal(
plot->AppendTimeSeries(std::move(series.second)); plot->AppendTimeSeries(std::move(series.second));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, plot_name, kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, plot_name, kBottomMargin, kTopMargin);
plot->SetTitle(plot_name); plot->SetTitle(plot_name);
} }
@ -1950,7 +1934,7 @@ void EventLogAnalyzer::CreateIceCandidatePairConfigGraph(Plot* plot) {
candidate_pair_desc_by_id_[config.candidate_pair_id] = candidate_pair_desc_by_id_[config.candidate_pair_id] =
candidate_pair_desc; candidate_pair_desc;
} }
float x = ToCallTimeSec(config.log_time_us()); float x = config_.GetCallTimeSec(config.log_time_us());
float y = static_cast<float>(config.type); float y = static_cast<float>(config.type);
configs_by_cp_id[config.candidate_pair_id].points.emplace_back(x, y); configs_by_cp_id[config.candidate_pair_id].points.emplace_back(x, y);
} }
@ -1962,8 +1946,8 @@ void EventLogAnalyzer::CreateIceCandidatePairConfigGraph(Plot* plot) {
plot->AppendTimeSeries(std::move(kv.second)); plot->AppendTimeSeries(std::move(kv.second));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 3, "Numeric Config Type", kBottomMargin, plot->SetSuggestedYAxis(0, 3, "Numeric Config Type", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle("[IceEventLog] ICE candidate pair configs"); plot->SetTitle("[IceEventLog] ICE candidate pair configs");
@ -1999,7 +1983,7 @@ void EventLogAnalyzer::CreateIceConnectivityCheckGraph(Plot* plot) {
GetCandidatePairLogDescriptionFromId(event.candidate_pair_id), GetCandidatePairLogDescriptionFromId(event.candidate_pair_id),
LineStyle::kNone, PointStyle::kHighlight); LineStyle::kNone, PointStyle::kHighlight);
} }
float x = ToCallTimeSec(event.log_time_us()); float x = config_.GetCallTimeSec(event.log_time_us());
constexpr int kIceCandidatePairEventTypeOffset = constexpr int kIceCandidatePairEventTypeOffset =
static_cast<int>(IceCandidatePairConfigType::kNumValues); static_cast<int>(IceCandidatePairConfigType::kNumValues);
float y = static_cast<float>(event.type) + kIceCandidatePairEventTypeOffset; float y = static_cast<float>(event.type) + kIceCandidatePairEventTypeOffset;
@ -2011,8 +1995,8 @@ void EventLogAnalyzer::CreateIceConnectivityCheckGraph(Plot* plot) {
plot->AppendTimeSeries(std::move(kv.second)); plot->AppendTimeSeries(std::move(kv.second));
} }
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 4, "Numeric Connectivity State", kBottomMargin, plot->SetSuggestedYAxis(0, 4, "Numeric Connectivity State", kBottomMargin,
kTopMargin); kTopMargin);
plot->SetTitle("[IceEventLog] ICE connectivity checks"); plot->SetTitle("[IceEventLog] ICE connectivity checks");
@ -2022,13 +2006,13 @@ void EventLogAnalyzer::CreateDtlsTransportStateGraph(Plot* plot) {
TimeSeries states("DTLS Transport State", LineStyle::kNone, TimeSeries states("DTLS Transport State", LineStyle::kNone,
PointStyle::kHighlight); PointStyle::kHighlight);
for (const auto& event : parsed_log_.dtls_transport_states()) { for (const auto& event : parsed_log_.dtls_transport_states()) {
float x = ToCallTimeSec(event.log_time_us()); float x = config_.GetCallTimeSec(event.log_time_us());
float y = static_cast<float>(event.dtls_transport_state); float y = static_cast<float>(event.dtls_transport_state);
states.points.emplace_back(x, y); states.points.emplace_back(x, y);
} }
plot->AppendTimeSeries(std::move(states)); plot->AppendTimeSeries(std::move(states));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, static_cast<float>(DtlsTransportState::kNumValues), plot->SetSuggestedYAxis(0, static_cast<float>(DtlsTransportState::kNumValues),
"Numeric Transport State", kBottomMargin, kTopMargin); "Numeric Transport State", kBottomMargin, kTopMargin);
plot->SetTitle("DTLS Transport State"); plot->SetTitle("DTLS Transport State");
@ -2038,13 +2022,13 @@ void EventLogAnalyzer::CreateDtlsWritableStateGraph(Plot* plot) {
TimeSeries writable("DTLS Writable", LineStyle::kNone, TimeSeries writable("DTLS Writable", LineStyle::kNone,
PointStyle::kHighlight); PointStyle::kHighlight);
for (const auto& event : parsed_log_.dtls_writable_states()) { for (const auto& event : parsed_log_.dtls_writable_states()) {
float x = ToCallTimeSec(event.log_time_us()); float x = config_.GetCallTimeSec(event.log_time_us());
float y = static_cast<float>(event.writable); float y = static_cast<float>(event.writable);
writable.points.emplace_back(x, y); writable.points.emplace_back(x, y);
} }
plot->AppendTimeSeries(std::move(writable)); plot->AppendTimeSeries(std::move(writable));
plot->SetXAxis(ToCallTimeSec(begin_time_), call_duration_s_, "Time (s)", plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
kLeftMargin, kRightMargin); "Time (s)", kLeftMargin, kRightMargin);
plot->SetSuggestedYAxis(0, 1, "Writable", kBottomMargin, kTopMargin); plot->SetSuggestedYAxis(0, 1, "Writable", kBottomMargin, kTopMargin);
plot->SetTitle("DTLS Writable State"); plot->SetTitle("DTLS Writable State");
} }
@ -2107,7 +2091,8 @@ void EventLogAnalyzer::CreateStreamGapAlerts(PacketDirection direction) {
int64_t seq_num = seq_num_unwrapper.Unwrap(packet.header.sequenceNumber); int64_t seq_num = seq_num_unwrapper.Unwrap(packet.header.sequenceNumber);
if (last_seq_num.has_value() && if (last_seq_num.has_value() &&
std::abs(seq_num - last_seq_num.value()) > kMaxSeqNumJump) { std::abs(seq_num - last_seq_num.value()) > kMaxSeqNumJump) {
Alert_SeqNumJump(direction, ToCallTimeSec(packet.log_time_us()), Alert_SeqNumJump(direction,
config_.GetCallTimeSec(packet.log_time_us()),
packet.header.ssrc); packet.header.ssrc);
} }
last_seq_num.emplace(seq_num); last_seq_num.emplace(seq_num);
@ -2117,7 +2102,8 @@ void EventLogAnalyzer::CreateStreamGapAlerts(PacketDirection direction) {
if (last_capture_time.has_value() && if (last_capture_time.has_value() &&
std::abs(capture_time - last_capture_time.value()) > std::abs(capture_time - last_capture_time.value()) >
kMaxCaptureTimeJump) { kMaxCaptureTimeJump) {
Alert_CaptureTimeJump(direction, ToCallTimeSec(packet.log_time_us()), Alert_CaptureTimeJump(direction,
config_.GetCallTimeSec(packet.log_time_us()),
packet.header.ssrc); packet.header.ssrc);
} }
last_capture_time.emplace(capture_time); last_capture_time.emplace(capture_time);
@ -2149,7 +2135,8 @@ void EventLogAnalyzer::CreateTransmissionGapAlerts(PacketDirection direction) {
int64_t duration = timestamp - last_rtp_time.value_or(0); int64_t duration = timestamp - last_rtp_time.value_or(0);
if (last_rtp_time.has_value() && duration > kMaxRtpTransmissionGap) { if (last_rtp_time.has_value() && duration > kMaxRtpTransmissionGap) {
// No packet sent/received for more than 500 ms. // No packet sent/received for more than 500 ms.
Alert_RtpLogTimeGap(direction, ToCallTimeSec(timestamp), duration / 1000); Alert_RtpLogTimeGap(direction, config_.GetCallTimeSec(timestamp),
duration / 1000);
} }
last_rtp_time.emplace(timestamp); last_rtp_time.emplace(timestamp);
} }
@ -2164,7 +2151,8 @@ void EventLogAnalyzer::CreateTransmissionGapAlerts(PacketDirection direction) {
int64_t duration = rtcp.log_time_us() - last_rtcp_time.value_or(0); int64_t duration = rtcp.log_time_us() - last_rtcp_time.value_or(0);
if (last_rtcp_time.has_value() && duration > kMaxRtcpTransmissionGap) { if (last_rtcp_time.has_value() && duration > kMaxRtcpTransmissionGap) {
// No feedback sent/received for more than 2000 ms. // No feedback sent/received for more than 2000 ms.
Alert_RtcpLogTimeGap(direction, ToCallTimeSec(rtcp.log_time_us()), Alert_RtcpLogTimeGap(direction,
config_.GetCallTimeSec(rtcp.log_time_us()),
duration / 1000); duration / 1000);
} }
last_rtcp_time.emplace(rtcp.log_time_us()); last_rtcp_time.emplace(rtcp.log_time_us());
@ -2178,7 +2166,8 @@ void EventLogAnalyzer::CreateTransmissionGapAlerts(PacketDirection direction) {
int64_t duration = rtcp.log_time_us() - last_rtcp_time.value_or(0); int64_t duration = rtcp.log_time_us() - last_rtcp_time.value_or(0);
if (last_rtcp_time.has_value() && duration > kMaxRtcpTransmissionGap) { if (last_rtcp_time.has_value() && duration > kMaxRtcpTransmissionGap) {
// No feedback sent/received for more than 2000 ms. // No feedback sent/received for more than 2000 ms.
Alert_RtcpLogTimeGap(direction, ToCallTimeSec(rtcp.log_time_us()), Alert_RtcpLogTimeGap(direction,
config_.GetCallTimeSec(rtcp.log_time_us()),
duration / 1000); duration / 1000);
} }
last_rtcp_time.emplace(rtcp.log_time_us()); last_rtcp_time.emplace(rtcp.log_time_us());

42
rtc_tools/event_log_visualizer/analyzer.h
View File

@ -26,6 +26,30 @@
namespace webrtc { namespace webrtc {
class AnalyzerConfig {
public:
float GetCallTimeSec(int64_t timestamp_us) const {
int64_t offset = normalize_time_ ? begin_time_ : 0;
return static_cast<float>(timestamp_us - offset) / 1000000;
}
float CallBeginTimeSec() const { return GetCallTimeSec(begin_time_); }
float CallEndTimeSec() const { return GetCallTimeSec(end_time_); }
// Window and step size used for calculating moving averages, e.g. bitrate.
// 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_;
// First and last events of the log.
int64_t begin_time_;
int64_t end_time_;
bool normalize_time_;
};
class EventLogAnalyzer { class EventLogAnalyzer {
public: public:
// The EventLogAnalyzer keeps a reference to the ParsedRtcEventLogNew for the // The EventLogAnalyzer keeps a reference to the ParsedRtcEventLogNew for the
@ -174,9 +198,6 @@ class EventLogAnalyzer {
return name.str(); return name.str();
} }
int64_t ToCallTimeUs(int64_t timestamp) const;
float ToCallTimeSec(int64_t timestamp) const;
void Alert_RtpLogTimeGap(PacketDirection direction, void Alert_RtpLogTimeGap(PacketDirection direction,
float time_seconds, float time_seconds,
int64_t duration) { int64_t duration) {
@ -245,20 +266,7 @@ class EventLogAnalyzer {
std::map<uint32_t, std::string> candidate_pair_desc_by_id_; std::map<uint32_t, std::string> candidate_pair_desc_by_id_;
// Window and step size used for calculating moving averages, e.g. bitrate. AnalyzerConfig config_;
// 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_;
// First and last events of the log.
int64_t begin_time_;
int64_t end_time_;
const bool normalize_time_;
// Duration (in seconds) of log file.
float call_duration_s_;
}; };
} // namespace webrtc } // namespace webrtc