Split LoggedBweProbeResult into -Success and -Failure.
Also change ParsedEventLog::EventType to enum class.
Bug: webrtc:8111
Change-Id: I4747fb9cbcbdb963fa032770078218e5b416b3da
Reviewed-on: https://webrtc-review.googlesource.com/79280
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Reviewed-by: Minyue Li <minyue@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23432}diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
index 35244d7..1bda6c9 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
@@ -140,7 +140,7 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::AUDIO_NETWORK_ADAPTATION_EVENT);
+ ParsedRtcEventLogNew::EventType::AUDIO_NETWORK_ADAPTATION_EVENT);
LoggedAudioNetworkAdaptationEvent parsed_event =
parsed_log_.GetAudioNetworkAdaptation(0);
@@ -232,7 +232,7 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::AUDIO_PLAYOUT_EVENT);
+ ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT);
LoggedAudioPlayoutEvent playout_event = parsed_log_.GetAudioPlayout(0);
@@ -261,7 +261,7 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::AUDIO_RECEIVER_CONFIG_EVENT);
+ ParsedRtcEventLogNew::EventType::AUDIO_RECEIVER_CONFIG_EVENT);
auto parsed_event = parsed_log_.GetAudioReceiveConfig(0);
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
@@ -286,7 +286,7 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::AUDIO_SENDER_CONFIG_EVENT);
+ ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT);
auto parsed_event = parsed_log_.GetAudioSendConfig(0);
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
@@ -306,7 +306,7 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::DELAY_BASED_BWE_UPDATE);
+ ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE);
auto parsed_event = parsed_log_.GetDelayBasedBweUpdate(0);
@@ -330,7 +330,7 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::LOSS_BASED_BWE_UPDATE);
+ ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE);
LoggedBweLossBasedUpdate bwe_update = parsed_log_.GetLossBasedBweUpdate(0);
@@ -345,7 +345,8 @@
ASSERT_TRUE(parsed_log_.ParseString(encoder_->EncodeLogStart(timestamp_us)));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
- ASSERT_EQ(parsed_log_.GetEventType(0), ParsedRtcEventLogNew::LOG_START);
+ ASSERT_EQ(parsed_log_.GetEventType(0),
+ ParsedRtcEventLogNew::EventType::LOG_START);
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
}
@@ -355,16 +356,17 @@
ASSERT_TRUE(parsed_log_.ParseString(encoder_->EncodeLogEnd(timestamp_us)));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
- ASSERT_EQ(parsed_log_.GetEventType(0), ParsedRtcEventLogNew::LOG_END);
+ ASSERT_EQ(parsed_log_.GetEventType(0),
+ ParsedRtcEventLogNew::EventType::LOG_END);
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
}
TEST_P(RtcEventLogEncoderTest, RtcEventProbeClusterCreated) {
- const int id = RandomPositiveInt();
- const int bitrate_bps = RandomBitrate();
- const int min_probes = RandomPositiveInt();
- const int min_bytes = RandomPositiveInt();
+ const int32_t id = RandomPositiveInt();
+ const int32_t bitrate_bps = RandomBitrate();
+ const uint32_t min_probes = RandomPositiveInt();
+ const uint32_t min_bytes = RandomPositiveInt();
auto event = rtc::MakeUnique<RtcEventProbeClusterCreated>(
id, bitrate_bps, min_probes, min_bytes);
@@ -375,15 +377,15 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::BWE_PROBE_CLUSTER_CREATED_EVENT);
+ ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT);
auto parsed_event = parsed_log_.GetBweProbeClusterCreated(0);
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
- EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.id), id);
- EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.bitrate_bps), bitrate_bps);
- EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.min_packets), min_probes);
- EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.min_bytes), min_bytes);
+ EXPECT_EQ(parsed_event.id, id);
+ EXPECT_EQ(parsed_event.bitrate_bps, bitrate_bps);
+ EXPECT_EQ(parsed_event.min_packets, min_probes);
+ EXPECT_EQ(parsed_event.min_bytes, min_bytes);
}
TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) {
@@ -399,20 +401,18 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::BWE_PROBE_RESULT_EVENT);
+ ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT);
- auto parsed_event = parsed_log_.GetBweProbeResult(0);
+ auto parsed_event = parsed_log_.GetBweProbeFailure(0);
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
- EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.id), id);
- ASSERT_FALSE(parsed_event.bitrate_bps);
- ASSERT_TRUE(parsed_event.failure_reason);
+ EXPECT_EQ(parsed_event.id, id);
EXPECT_EQ(parsed_event.failure_reason, failure_reason);
}
TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) {
- const int id = RandomPositiveInt();
- const uint64_t bitrate_bps = rtc::checked_cast<uint64_t>(RandomBitrate());
+ const int32_t id = RandomPositiveInt();
+ const int32_t bitrate_bps = RandomBitrate();
auto event = rtc::MakeUnique<RtcEventProbeResultSuccess>(id, bitrate_bps);
const int64_t timestamp_us = event->timestamp_us_;
@@ -422,14 +422,13 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::BWE_PROBE_RESULT_EVENT);
+ ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT);
- auto parsed_event = parsed_log_.GetBweProbeResult(0);
+ auto parsed_event = parsed_log_.GetBweProbeSuccess(0);
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
- EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.id), id);
+ EXPECT_EQ(parsed_event.id, id);
EXPECT_EQ(parsed_event.bitrate_bps, bitrate_bps);
- ASSERT_FALSE(parsed_event.failure_reason);
}
void RtcEventLogEncoderTest::TestRtcEventRtcpPacket(PacketDirection direction) {
@@ -449,7 +448,8 @@
std::string encoded = encoder_->EncodeBatch(history_.begin(), history_.end());
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
- ASSERT_EQ(parsed_log_.GetEventType(0), ParsedRtcEventLogNew::RTCP_EVENT);
+ ASSERT_EQ(parsed_log_.GetEventType(0),
+ ParsedRtcEventLogNew::EventType::RTCP_EVENT);
PacketDirection parsed_direction;
uint8_t parsed_packet[IP_PACKET_SIZE]; // "Parsed" = after event-encoding.
@@ -503,7 +503,8 @@
std::string encoded = encoder_->EncodeBatch(history_.begin(), history_.end());
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
- ASSERT_EQ(parsed_log_.GetEventType(0), ParsedRtcEventLogNew::RTP_EVENT);
+ ASSERT_EQ(parsed_log_.GetEventType(0),
+ ParsedRtcEventLogNew::EventType::RTP_EVENT);
PacketDirection parsed_direction;
uint8_t parsed_rtp_header[IP_PACKET_SIZE];
@@ -554,7 +555,7 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::VIDEO_RECEIVER_CONFIG_EVENT);
+ ParsedRtcEventLogNew::EventType::VIDEO_RECEIVER_CONFIG_EVENT);
auto parsed_event = parsed_log_.GetVideoReceiveConfig(0);
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
@@ -580,7 +581,7 @@
ASSERT_TRUE(parsed_log_.ParseString(encoded));
ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
ASSERT_EQ(parsed_log_.GetEventType(0),
- ParsedRtcEventLogNew::VIDEO_SENDER_CONFIG_EVENT);
+ ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT);
auto parsed_event = parsed_log_.GetVideoSendConfig(0)[0];
EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
diff --git a/logging/rtc_event_log/rtc_event_log2rtp_dump.cc b/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
index 3990363..bdb560a 100644
--- a/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
+++ b/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
@@ -128,7 +128,7 @@
// a softer failure option, but it does not seem useful to generate
// RTP dumps based on broken event logs.
if (FLAG_rtp && parsed_stream.GetEventType(i) ==
- webrtc::ParsedRtcEventLogNew::RTP_EVENT) {
+ webrtc::ParsedRtcEventLogNew::EventType::RTP_EVENT) {
webrtc::test::RtpPacket packet;
webrtc::PacketDirection direction;
parsed_stream.GetRtpHeader(i, &direction, packet.data, &packet.length,
@@ -166,7 +166,7 @@
rtp_counter++;
}
if (FLAG_rtcp && parsed_stream.GetEventType(i) ==
- webrtc::ParsedRtcEventLogNew::RTCP_EVENT) {
+ webrtc::ParsedRtcEventLogNew::EventType::RTCP_EVENT) {
webrtc::test::RtpPacket packet;
webrtc::PacketDirection direction;
parsed_stream.GetRtcpPacket(i, &direction, packet.data, &packet.length);
diff --git a/logging/rtc_event_log/rtc_event_log2text.cc b/logging/rtc_event_log/rtc_event_log2text.cc
index cc41525..00092a9 100644
--- a/logging/rtc_event_log/rtc_event_log2text.cc
+++ b/logging/rtc_event_log/rtc_event_log2text.cc
@@ -409,7 +409,7 @@
for (size_t i = 0; i < parsed_stream.GetNumberOfEvents(); i++) {
bool event_recognized = false;
switch (parsed_stream.GetEventType(i)) {
- case webrtc::ParsedRtcEventLogNew::UNKNOWN_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT: {
if (FLAG_unknown) {
std::cout << parsed_stream.GetTimestamp(i) << "\tUNKNOWN_EVENT"
<< std::endl;
@@ -418,7 +418,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::LOG_START: {
+ case webrtc::ParsedRtcEventLogNew::EventType::LOG_START: {
if (FLAG_startstop) {
std::cout << parsed_stream.GetTimestamp(i) << "\tLOG_START"
<< std::endl;
@@ -427,7 +427,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::LOG_END: {
+ case webrtc::ParsedRtcEventLogNew::EventType::LOG_END: {
if (FLAG_startstop) {
std::cout << parsed_stream.GetTimestamp(i) << "\tLOG_END"
<< std::endl;
@@ -436,7 +436,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::RTP_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::RTP_EVENT: {
if (FLAG_rtp) {
size_t header_length;
size_t total_length;
@@ -513,7 +513,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::RTCP_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::RTCP_EVENT: {
if (FLAG_rtcp) {
size_t length;
uint8_t packet[IP_PACKET_SIZE];
@@ -580,7 +580,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::AUDIO_PLAYOUT_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT: {
if (FLAG_playout) {
auto audio_playout = parsed_stream.GetAudioPlayout(i);
std::cout << audio_playout.log_time_us() << "\tAUDIO_PLAYOUT"
@@ -590,7 +590,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::LOSS_BASED_BWE_UPDATE: {
+ case webrtc::ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE: {
if (FLAG_bwe) {
auto bwe_update = parsed_stream.GetLossBasedBweUpdate(i);
std::cout << bwe_update.log_time_us() << "\tBWE(LOSS_BASED)"
@@ -604,7 +604,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::DELAY_BASED_BWE_UPDATE: {
+ case webrtc::ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE: {
if (FLAG_bwe) {
auto bwe_update = parsed_stream.GetDelayBasedBweUpdate(i);
std::cout << bwe_update.log_time_us() << "\tBWE(DELAY_BASED)"
@@ -616,7 +616,8 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::VIDEO_RECEIVER_CONFIG_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::
+ VIDEO_RECEIVER_CONFIG_EVENT: {
if (FLAG_config && FLAG_video && FLAG_incoming) {
webrtc::rtclog::StreamConfig config =
parsed_stream.GetVideoReceiveConfig(i);
@@ -641,7 +642,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::VIDEO_SENDER_CONFIG_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT: {
if (FLAG_config && FLAG_video && FLAG_outgoing) {
std::vector<webrtc::rtclog::StreamConfig> configs =
parsed_stream.GetVideoSendConfig(i);
@@ -668,7 +669,8 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::AUDIO_RECEIVER_CONFIG_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::
+ AUDIO_RECEIVER_CONFIG_EVENT: {
if (FLAG_config && FLAG_audio && FLAG_incoming) {
webrtc::rtclog::StreamConfig config =
parsed_stream.GetAudioReceiveConfig(i);
@@ -693,7 +695,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::AUDIO_SENDER_CONFIG_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT: {
if (FLAG_config && FLAG_audio && FLAG_outgoing) {
webrtc::rtclog::StreamConfig config =
parsed_stream.GetAudioSendConfig(i);
@@ -717,7 +719,8 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::AUDIO_NETWORK_ADAPTATION_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::
+ AUDIO_NETWORK_ADAPTATION_EVENT: {
if (FLAG_ana) {
auto ana_event = parsed_stream.GetAudioNetworkAdaptation(i);
char buffer[300];
@@ -749,7 +752,8 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::BWE_PROBE_CLUSTER_CREATED_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::
+ BWE_PROBE_CLUSTER_CREATED_EVENT: {
if (FLAG_probe) {
auto probe_event = parsed_stream.GetBweProbeClusterCreated(i);
std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_CREATED("
@@ -762,28 +766,34 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::BWE_PROBE_RESULT_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT: {
if (FLAG_probe) {
- webrtc::LoggedBweProbeResultEvent probe_result =
- parsed_stream.GetBweProbeResult(i);
- if (probe_result.failure_reason) {
- std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_SUCCESS("
- << probe_result.id << ")"
- << "\tfailure_reason="
- << static_cast<int>(*probe_result.failure_reason)
- << std::endl;
- } else {
- std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_SUCCESS("
- << probe_result.id << ")"
- << "\tbitrate_bps=" << *probe_result.bitrate_bps
- << std::endl;
- }
+ webrtc::LoggedBweProbeFailureEvent probe_result =
+ parsed_stream.GetBweProbeFailure(i);
+ std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_FAILURE("
+ << probe_result.id << ")"
+ << "\tfailure_reason="
+ << static_cast<int>(probe_result.failure_reason)
+ << std::endl;
}
event_recognized = true;
break;
}
- case webrtc::ParsedRtcEventLogNew::ALR_STATE_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT: {
+ if (FLAG_probe) {
+ webrtc::LoggedBweProbeSuccessEvent probe_result =
+ parsed_stream.GetBweProbeSuccess(i);
+ std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_SUCCESS("
+ << probe_result.id << ")"
+ << "\tbitrate_bps=" << probe_result.bitrate_bps
+ << std::endl;
+ }
+ event_recognized = true;
+ break;
+ }
+
+ case webrtc::ParsedRtcEventLogNew::EventType::ALR_STATE_EVENT: {
if (FLAG_bwe) {
webrtc::LoggedAlrStateEvent alr_state = parsed_stream.GetAlrState(i);
std::cout << parsed_stream.GetTimestamp(i) << "\tALR_STATE"
@@ -793,7 +803,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::ICE_CANDIDATE_PAIR_CONFIG: {
+ case webrtc::ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_CONFIG: {
if (FLAG_ice) {
webrtc::LoggedIceCandidatePairConfig ice_cp_config =
parsed_stream.GetIceCandidatePairConfig(i);
@@ -807,7 +817,7 @@
break;
}
- case webrtc::ParsedRtcEventLogNew::ICE_CANDIDATE_PAIR_EVENT: {
+ case webrtc::ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_EVENT: {
if (FLAG_ice) {
webrtc::LoggedIceCandidatePairEvent ice_cp_event =
parsed_stream.GetIceCandidatePairEvent(i);
@@ -823,8 +833,9 @@
}
if (!event_recognized) {
- std::cout << "Unrecognized event (" << parsed_stream.GetEventType(i)
- << ")" << std::endl;
+ std::cout << "Unrecognized event ("
+ << static_cast<int>(parsed_stream.GetEventType(i)) << ")"
+ << std::endl;
}
}
return 0;
diff --git a/logging/rtc_event_log/rtc_event_log_parser_new.cc b/logging/rtc_event_log/rtc_event_log_parser_new.cc
index 810279e..2d6c4cd 100644
--- a/logging/rtc_event_log/rtc_event_log_parser_new.cc
+++ b/logging/rtc_event_log/rtc_event_log_parser_new.cc
@@ -80,7 +80,10 @@
case rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT:
return ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT;
case rtclog::Event::BWE_PROBE_RESULT_EVENT:
- return ParsedRtcEventLogNew::EventType::BWE_PROBE_RESULT_EVENT;
+ // Probe successes and failures are currently stored in the same proto
+ // message, we are moving towards separate messages. Probe results
+ // therefore need special treatment in the parser.
+ return ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT;
case rtclog::Event::ALR_STATE_EVENT:
return ParsedRtcEventLogNew::EventType::ALR_STATE_EVENT;
case rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG:
@@ -313,7 +316,8 @@
audio_playout_events_.clear();
audio_network_adaptation_events_.clear();
bwe_probe_cluster_created_events_.clear();
- bwe_probe_result_events_.clear();
+ bwe_probe_failure_events_.clear();
+ bwe_probe_success_events_.clear();
bwe_delay_updates_.clear();
bwe_loss_updates_.clear();
alr_state_events_.clear();
@@ -467,8 +471,8 @@
last_timestamp_ = std::max(last_timestamp_, timestamp);
}
- switch (event.type()) {
- case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT: {
+ switch (GetEventType(event)) {
+ case ParsedRtcEventLogNew::EventType::VIDEO_RECEIVER_CONFIG_EVENT: {
rtclog::StreamConfig config = GetVideoReceiveConfig(event);
video_recv_configs_.emplace_back(GetTimestamp(event), config);
incoming_rtp_extensions_maps_[config.remote_ssrc] =
@@ -483,7 +487,7 @@
incoming_rtx_ssrcs_.insert(config.rtx_ssrc);
break;
}
- case rtclog::Event::VIDEO_SENDER_CONFIG_EVENT: {
+ case ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT: {
std::vector<rtclog::StreamConfig> configs = GetVideoSendConfig(event);
video_send_configs_.emplace_back(GetTimestamp(event), configs);
for (const auto& config : configs) {
@@ -497,7 +501,7 @@
}
break;
}
- case rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT: {
+ case ParsedRtcEventLogNew::EventType::AUDIO_RECEIVER_CONFIG_EVENT: {
rtclog::StreamConfig config = GetAudioReceiveConfig(event);
audio_recv_configs_.emplace_back(GetTimestamp(event), config);
incoming_rtp_extensions_maps_[config.remote_ssrc] =
@@ -507,7 +511,7 @@
incoming_audio_ssrcs_.insert(config.remote_ssrc);
break;
}
- case rtclog::Event::AUDIO_SENDER_CONFIG_EVENT: {
+ case ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT: {
rtclog::StreamConfig config = GetAudioSendConfig(event);
audio_send_configs_.emplace_back(GetTimestamp(event), config);
outgoing_rtp_extensions_maps_[config.local_ssrc] =
@@ -515,7 +519,7 @@
outgoing_audio_ssrcs_.insert(config.local_ssrc);
break;
}
- case rtclog::Event::RTP_EVENT: {
+ case ParsedRtcEventLogNew::EventType::RTP_EVENT: {
PacketDirection direction;
uint8_t header[IP_PACKET_SIZE];
size_t header_length;
@@ -546,7 +550,7 @@
}
break;
}
- case rtclog::Event::RTCP_EVENT: {
+ case ParsedRtcEventLogNew::EventType::RTCP_EVENT: {
PacketDirection direction;
uint8_t packet[IP_PACKET_SIZE];
size_t total_length;
@@ -632,55 +636,59 @@
}
break;
}
- case rtclog::Event::LOG_START: {
+ case ParsedRtcEventLogNew::EventType::LOG_START: {
start_log_events_.push_back(LoggedStartEvent(GetTimestamp(event)));
break;
}
- case rtclog::Event::LOG_END: {
+ case ParsedRtcEventLogNew::EventType::LOG_END: {
stop_log_events_.push_back(LoggedStopEvent(GetTimestamp(event)));
break;
}
- case rtclog::Event::AUDIO_PLAYOUT_EVENT: {
+ case ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT: {
LoggedAudioPlayoutEvent playout_event = GetAudioPlayout(event);
audio_playout_events_[playout_event.ssrc].push_back(playout_event);
break;
}
- case rtclog::Event::LOSS_BASED_BWE_UPDATE: {
+ case ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE: {
bwe_loss_updates_.push_back(GetLossBasedBweUpdate(event));
break;
}
- case rtclog::Event::DELAY_BASED_BWE_UPDATE: {
+ case ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE: {
bwe_delay_updates_.push_back(GetDelayBasedBweUpdate(event));
break;
}
- case rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT: {
+ case ParsedRtcEventLogNew::EventType::AUDIO_NETWORK_ADAPTATION_EVENT: {
LoggedAudioNetworkAdaptationEvent ana_event =
GetAudioNetworkAdaptation(event);
audio_network_adaptation_events_.push_back(ana_event);
break;
}
- case rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT: {
+ case ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT: {
bwe_probe_cluster_created_events_.push_back(
GetBweProbeClusterCreated(event));
break;
}
- case rtclog::Event::BWE_PROBE_RESULT_EVENT: {
- bwe_probe_result_events_.push_back(GetBweProbeResult(event));
+ case ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT: {
+ bwe_probe_failure_events_.push_back(GetBweProbeFailure(event));
break;
}
- case rtclog::Event::ALR_STATE_EVENT: {
+ case ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT: {
+ bwe_probe_success_events_.push_back(GetBweProbeSuccess(event));
+ break;
+ }
+ case ParsedRtcEventLogNew::EventType::ALR_STATE_EVENT: {
alr_state_events_.push_back(GetAlrState(event));
break;
}
- case rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG: {
+ case ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_CONFIG: {
ice_candidate_pair_configs_.push_back(GetIceCandidatePairConfig(event));
break;
}
- case rtclog::Event::ICE_CANDIDATE_PAIR_EVENT: {
+ case ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_EVENT: {
ice_candidate_pair_events_.push_back(GetIceCandidatePairEvent(event));
break;
}
- case rtclog::Event::UNKNOWN_EVENT: {
+ case ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT: {
break;
}
}
@@ -705,7 +713,19 @@
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
+ return GetEventType(event);
+}
+
+ParsedRtcEventLogNew::EventType ParsedRtcEventLogNew::GetEventType(
+ const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
+ if (event.type() == rtclog::Event::BWE_PROBE_RESULT_EVENT) {
+ RTC_CHECK(event.has_probe_result());
+ RTC_CHECK(event.probe_result().has_result());
+ if (event.probe_result().result() == rtclog::BweProbeResult::SUCCESS)
+ return ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT;
+ return ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT;
+ }
return GetRuntimeEventType(event.type());
}
@@ -1108,30 +1128,29 @@
return res;
}
-LoggedBweProbeResultEvent ParsedRtcEventLogNew::GetBweProbeResult(
+LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
- return GetBweProbeResult(event);
+ return GetBweProbeFailure(event);
}
-LoggedBweProbeResultEvent ParsedRtcEventLogNew::GetBweProbeResult(
+LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
RTC_CHECK(event.has_probe_result());
const rtclog::BweProbeResult& pr_event = event.probe_result();
- LoggedBweProbeResultEvent res;
+ RTC_CHECK(pr_event.has_result());
+ RTC_CHECK_NE(pr_event.result(), rtclog::BweProbeResult::SUCCESS);
+
+ LoggedBweProbeFailureEvent res;
res.timestamp_us = GetTimestamp(event);
RTC_CHECK(pr_event.has_id());
res.id = pr_event.id();
-
RTC_CHECK(pr_event.has_result());
- if (pr_event.result() == rtclog::BweProbeResult::SUCCESS) {
- RTC_CHECK(pr_event.has_bitrate_bps());
- res.bitrate_bps = pr_event.bitrate_bps();
- } else if (pr_event.result() ==
- rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL) {
+ if (pr_event.result() ==
+ rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL) {
res.failure_reason = ProbeFailureReason::kInvalidSendReceiveInterval;
} else if (pr_event.result() ==
rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO) {
@@ -1141,6 +1160,33 @@
} else {
RTC_NOTREACHED();
}
+ RTC_CHECK(!pr_event.has_bitrate_bps());
+
+ return res;
+}
+
+LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
+ size_t index) const {
+ RTC_CHECK_LT(index, GetNumberOfEvents());
+ const rtclog::Event& event = events_[index];
+ return GetBweProbeSuccess(event);
+}
+
+LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
+ const rtclog::Event& event) const {
+ RTC_CHECK(event.has_type());
+ RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
+ RTC_CHECK(event.has_probe_result());
+ const rtclog::BweProbeResult& pr_event = event.probe_result();
+ RTC_CHECK(pr_event.has_result());
+ RTC_CHECK_EQ(pr_event.result(), rtclog::BweProbeResult::SUCCESS);
+
+ LoggedBweProbeSuccessEvent res;
+ res.timestamp_us = GetTimestamp(event);
+ RTC_CHECK(pr_event.has_id());
+ res.id = pr_event.id();
+ RTC_CHECK(pr_event.has_bitrate_bps());
+ res.bitrate_bps = pr_event.bitrate_bps();
return res;
}
diff --git a/logging/rtc_event_log/rtc_event_log_parser_new.h b/logging/rtc_event_log/rtc_event_log_parser_new.h
index c7cbc4b..23c1aee 100644
--- a/logging/rtc_event_log/rtc_event_log_parser_new.h
+++ b/logging/rtc_event_log/rtc_event_log_parser_new.h
@@ -96,11 +96,18 @@
int64_t log_time_ms() const { return timestamp_us / 1000; }
};
-struct LoggedBweProbeResultEvent {
+struct LoggedBweProbeSuccessEvent {
int64_t timestamp_us;
int32_t id;
- rtc::Optional<int32_t> bitrate_bps;
- rtc::Optional<ProbeFailureReason> failure_reason;
+ int32_t bitrate_bps;
+ int64_t log_time_us() const { return timestamp_us; }
+ int64_t log_time_ms() const { return timestamp_us / 1000; }
+};
+
+struct LoggedBweProbeFailureEvent {
+ int64_t timestamp_us;
+ int32_t id;
+ ProbeFailureReason failure_reason;
int64_t log_time_us() const { return timestamp_us; }
int64_t log_time_ms() const { return timestamp_us / 1000; }
};
@@ -463,7 +470,7 @@
friend class RtcEventLogTestHelper;
public:
- enum EventType {
+ enum class EventType {
UNKNOWN_EVENT = 0,
LOG_START = 1,
LOG_END = 2,
@@ -478,10 +485,11 @@
AUDIO_SENDER_CONFIG_EVENT = 11,
AUDIO_NETWORK_ADAPTATION_EVENT = 16,
BWE_PROBE_CLUSTER_CREATED_EVENT = 17,
- BWE_PROBE_RESULT_EVENT = 18,
- ALR_STATE_EVENT = 19,
- ICE_CANDIDATE_PAIR_CONFIG = 20,
- ICE_CANDIDATE_PAIR_EVENT = 21,
+ BWE_PROBE_FAILURE_EVENT = 18,
+ BWE_PROBE_SUCCESS_EVENT = 19,
+ ALR_STATE_EVENT = 20,
+ ICE_CANDIDATE_PAIR_CONFIG = 21,
+ ICE_CANDIDATE_PAIR_EVENT = 22,
};
enum class MediaType { ANY, AUDIO, VIDEO, DATA };
@@ -490,6 +498,37 @@
kAttemptWebrtcDefaultConfig
};
+ struct LoggedRtpStreamIncoming {
+ uint32_t ssrc;
+ std::vector<LoggedRtpPacketIncoming> incoming_packets;
+ };
+
+ struct LoggedRtpStreamOutgoing {
+ uint32_t ssrc;
+ std::vector<LoggedRtpPacketOutgoing> outgoing_packets;
+ };
+
+ struct LoggedRtpStreamView {
+ LoggedRtpStreamView(uint32_t ssrc,
+ const LoggedRtpPacketIncoming* ptr,
+ size_t num_elements)
+ : ssrc(ssrc),
+ packet_view(PacketView<const LoggedRtpPacket>::Create(
+ ptr,
+ num_elements,
+ offsetof(LoggedRtpPacketIncoming, rtp))) {}
+ LoggedRtpStreamView(uint32_t ssrc,
+ const LoggedRtpPacketOutgoing* ptr,
+ size_t num_elements)
+ : ssrc(ssrc),
+ packet_view(PacketView<const LoggedRtpPacket>::Create(
+ ptr,
+ num_elements,
+ offsetof(LoggedRtpPacketOutgoing, rtp))) {}
+ uint32_t ssrc;
+ PacketView<const LoggedRtpPacket> packet_view;
+ };
+
explicit ParsedRtcEventLogNew(
UnconfiguredHeaderExtensions parse_unconfigured_header_extensions =
UnconfiguredHeaderExtensions::kDontParse);
@@ -517,6 +556,7 @@
// Reads the event type of the rtclog::Event at |index|.
EventType GetEventType(size_t index) const;
+ EventType GetEventType(const rtclog::Event& event) const;
// Reads the header, direction, header length and packet length from the RTP
// event at |index|, and stores the values in the corresponding output
@@ -601,7 +641,8 @@
LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated(
size_t index) const;
- LoggedBweProbeResultEvent GetBweProbeResult(size_t index) const;
+ LoggedBweProbeFailureEvent GetBweProbeFailure(size_t index) const;
+ LoggedBweProbeSuccessEvent GetBweProbeSuccess(size_t index) const;
MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const;
@@ -611,96 +652,91 @@
LoggedIceCandidatePairEvent GetIceCandidatePairEvent(size_t index) const;
+ // Configured SSRCs.
const std::set<uint32_t>& incoming_rtx_ssrcs() const {
return incoming_rtx_ssrcs_;
}
+
const std::set<uint32_t>& incoming_video_ssrcs() const {
return incoming_video_ssrcs_;
}
+
const std::set<uint32_t>& incoming_audio_ssrcs() const {
return incoming_audio_ssrcs_;
}
+
const std::set<uint32_t>& outgoing_rtx_ssrcs() const {
return outgoing_rtx_ssrcs_;
}
+
const std::set<uint32_t>& outgoing_video_ssrcs() const {
return outgoing_video_ssrcs_;
}
+
const std::set<uint32_t>& outgoing_audio_ssrcs() const {
return outgoing_audio_ssrcs_;
}
+ // Beginning and end of log segments.
const std::vector<LoggedStartEvent>& start_log_events() const {
return start_log_events_;
}
+
const std::vector<LoggedStopEvent>& stop_log_events() const {
return stop_log_events_;
}
+
+ // Audio
const std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>&
audio_playout_events() const {
return audio_playout_events_;
}
+
const std::vector<LoggedAudioNetworkAdaptationEvent>&
audio_network_adaptation_events() const {
return audio_network_adaptation_events_;
}
+
+ // Bandwidth estimation
const std::vector<LoggedBweProbeClusterCreatedEvent>&
bwe_probe_cluster_created_events() const {
return bwe_probe_cluster_created_events_;
}
- const std::vector<LoggedBweProbeResultEvent>& bwe_probe_result_events()
+
+ const std::vector<LoggedBweProbeFailureEvent>& bwe_probe_failure_events()
const {
- return bwe_probe_result_events_;
+ return bwe_probe_failure_events_;
}
+
+ const std::vector<LoggedBweProbeSuccessEvent>& bwe_probe_success_events()
+ const {
+ return bwe_probe_success_events_;
+ }
+
const std::vector<LoggedBweDelayBasedUpdate>& bwe_delay_updates() const {
return bwe_delay_updates_;
}
+
const std::vector<LoggedBweLossBasedUpdate>& bwe_loss_updates() const {
return bwe_loss_updates_;
}
+
const std::vector<LoggedAlrStateEvent>& alr_state_events() const {
return alr_state_events_;
}
+
+ // ICE events
const std::vector<LoggedIceCandidatePairConfig>& ice_candidate_pair_configs()
const {
return ice_candidate_pair_configs_;
}
+
const std::vector<LoggedIceCandidatePairEvent>& ice_candidate_pair_events()
const {
return ice_candidate_pair_events_;
}
- struct LoggedRtpStreamIncoming {
- uint32_t ssrc;
- std::vector<LoggedRtpPacketIncoming> incoming_packets;
- };
-
- struct LoggedRtpStreamOutgoing {
- uint32_t ssrc;
- std::vector<LoggedRtpPacketOutgoing> outgoing_packets;
- };
-
- struct LoggedRtpStreamView {
- LoggedRtpStreamView(uint32_t ssrc,
- const LoggedRtpPacketIncoming* ptr,
- size_t num_elements)
- : ssrc(ssrc),
- packet_view(PacketView<const LoggedRtpPacket>::Create(
- ptr,
- num_elements,
- offsetof(LoggedRtpPacketIncoming, rtp))) {}
- LoggedRtpStreamView(uint32_t ssrc,
- const LoggedRtpPacketOutgoing* ptr,
- size_t num_elements)
- : ssrc(ssrc),
- packet_view(PacketView<const LoggedRtpPacket>::Create(
- ptr,
- num_elements,
- offsetof(LoggedRtpPacketOutgoing, rtp))) {}
- uint32_t ssrc;
- PacketView<const LoggedRtpPacket> packet_view;
- };
-
+ // RTP
const std::vector<LoggedRtpStreamIncoming>& incoming_rtp_packets_by_ssrc()
const {
return incoming_rtp_packets_by_ssrc_;
@@ -711,14 +747,6 @@
return outgoing_rtp_packets_by_ssrc_;
}
- const std::vector<LoggedRtcpPacketIncoming>& incoming_rtcp_packets() const {
- return incoming_rtcp_packets_;
- }
-
- const std::vector<LoggedRtcpPacketOutgoing>& outgoing_rtcp_packets() const {
- return outgoing_rtcp_packets_;
- }
-
const std::vector<LoggedRtpStreamView>& rtp_packets_by_ssrc(
PacketDirection direction) const {
if (direction == kIncomingPacket)
@@ -727,6 +755,15 @@
return outgoing_rtp_packet_views_by_ssrc_;
}
+ // RTCP
+ const std::vector<LoggedRtcpPacketIncoming>& incoming_rtcp_packets() const {
+ return incoming_rtcp_packets_;
+ }
+
+ const std::vector<LoggedRtcpPacketOutgoing>& outgoing_rtcp_packets() const {
+ return outgoing_rtcp_packets_;
+ }
+
const std::vector<LoggedRtcpPacketReceiverReport>& receiver_reports(
PacketDirection direction) const {
if (direction == kIncomingPacket) {
@@ -799,7 +836,10 @@
LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated(
const rtclog::Event& event) const;
- LoggedBweProbeResultEvent GetBweProbeResult(const rtclog::Event& event) const;
+ LoggedBweProbeFailureEvent GetBweProbeFailure(
+ const rtclog::Event& event) const;
+ LoggedBweProbeSuccessEvent GetBweProbeSuccess(
+ const rtclog::Event& event) const;
LoggedAlrStateEvent GetAlrState(const rtclog::Event& event) const;
@@ -887,7 +927,8 @@
std::vector<LoggedBweProbeClusterCreatedEvent>
bwe_probe_cluster_created_events_;
- std::vector<LoggedBweProbeResultEvent> bwe_probe_result_events_;
+ std::vector<LoggedBweProbeFailureEvent> bwe_probe_failure_events_;
+ std::vector<LoggedBweProbeSuccessEvent> bwe_probe_success_events_;
std::vector<LoggedBweDelayBasedUpdate> bwe_delay_updates_;
diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc
index 4ce2f3e..486a744 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -145,8 +145,10 @@
"AUDIO_NETWORK_ADAPTATION"},
{ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT,
"BWE_PROBE_CREATED"},
- {ParsedRtcEventLogNew::EventType::BWE_PROBE_RESULT_EVENT,
- "BWE_PROBE_RESULT"}});
+ {ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT,
+ "BWE_PROBE_SUCCESS"},
+ {ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT,
+ "BWE_PROBE_FAILURE"}});
} // namespace
void PrintActualEvents(const ParsedRtcEventLogNew& parsed_log,
diff --git a/modules/audio_coding/neteq/tools/rtc_event_log_source.cc b/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
index cf12891..7c97824 100644
--- a/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
+++ b/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
@@ -40,7 +40,7 @@
for (; rtp_packet_index_ < parsed_stream_.GetNumberOfEvents();
rtp_packet_index_++) {
if (parsed_stream_.GetEventType(rtp_packet_index_) ==
- ParsedRtcEventLogNew::RTP_EVENT) {
+ ParsedRtcEventLogNew::EventType::RTP_EVENT) {
PacketDirection direction;
size_t header_length;
size_t packet_length;
@@ -84,7 +84,7 @@
int64_t RtcEventLogSource::NextAudioOutputEventMs() {
while (audio_output_index_ < parsed_stream_.GetNumberOfEvents()) {
if (parsed_stream_.GetEventType(audio_output_index_) ==
- ParsedRtcEventLogNew::AUDIO_PLAYOUT_EVENT) {
+ ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT) {
LoggedAudioPlayoutEvent playout_event =
parsed_stream_.GetAudioPlayout(audio_output_index_);
if (!(use_ssrc_filter_ && playout_event.ssrc != ssrc_)) {
diff --git a/rtc_tools/event_log_visualizer/analyzer.cc b/rtc_tools/event_log_visualizer/analyzer.cc
index 71707a9..3bed18b 100644
--- a/rtc_tools/event_log_visualizer/analyzer.cc
+++ b/rtc_tools/event_log_visualizer/analyzer.cc
@@ -977,12 +977,10 @@
TimeSeries result_series("Probing results.", LineStyle::kNone,
PointStyle::kHighlight);
- for (auto& result : parsed_log_.bwe_probe_result_events()) {
- if (result.bitrate_bps) {
- float x = ToCallTimeSec(result.log_time_us());
- float y = static_cast<float>(*result.bitrate_bps) / 1000;
- result_series.points.emplace_back(x, y);
- }
+ for (auto& result : parsed_log_.bwe_probe_success_events()) {
+ float x = ToCallTimeSec(result.log_time_us());
+ float y = static_cast<float>(result.bitrate_bps) / 1000;
+ result_series.points.emplace_back(x, y);
}
IntervalSeries alr_state("ALR", "#555555", IntervalSeries::kHorizontal);
