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}
This commit is contained in:
Bjorn Terelius
committed by
Commit Bot
Commit Bot
parent
9545e1c9e5
commit
7a0bb00422
@ -140,7 +140,7 @@ void RtcEventLogEncoderTest::TestRtcEventAudioNetworkAdaptation(
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioPlayout) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioSendStreamConfig) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateDelayBased) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateLossBased) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStarted) {
|
||||
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStopped) {
|
||||
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeClusterCreated) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) {
|
||||
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 @@ void RtcEventLogEncoderTest::TestRtcEventRtcpPacket(PacketDirection direction) {
|
||||
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 @@ void RtcEventLogEncoderTest::TestRtcEventRtpPacket(PacketDirection direction) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) {
|
||||
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 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) {
|
||||
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);
|
||||
|
||||
@ -128,7 +128,7 @@ int main(int argc, char* argv[]) {
|
||||
// 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 @@ int main(int argc, char* argv[]) {
|
||||
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);
|
||||
|
||||
@ -409,7 +409,7 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
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 @@ int main(int argc, char* argv[]) {
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
@ -80,7 +80,10 @@ ParsedRtcEventLogNew::EventType GetRuntimeEventType(
|
||||
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 @@ void ParsedRtcEventLogNew::Clear() {
|
||||
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 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
|
||||
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 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
|
||||
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 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
|
||||
}
|
||||
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 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
|
||||
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 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
|
||||
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 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
|
||||
}
|
||||
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 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
|
||||
}
|
||||
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 @@ ParsedRtcEventLogNew::EventType ParsedRtcEventLogNew::GetEventType(
|
||||
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 @@ ParsedRtcEventLogNew::GetBweProbeClusterCreated(
|
||||
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 @@ LoggedBweProbeResultEvent ParsedRtcEventLogNew::GetBweProbeResult(
|
||||
} 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;
|
||||
}
|
||||
|
||||
@ -96,11 +96,18 @@ struct LoggedBweProbeClusterCreatedEvent {
|
||||
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 @@ class ParsedRtcEventLogNew {
|
||||
friend class RtcEventLogTestHelper;
|
||||
|
||||
public:
|
||||
enum EventType {
|
||||
enum class EventType {
|
||||
UNKNOWN_EVENT = 0,
|
||||
LOG_START = 1,
|
||||
LOG_END = 2,
|
||||
@ -478,10 +485,11 @@ class ParsedRtcEventLogNew {
|
||||
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 @@ class ParsedRtcEventLogNew {
|
||||
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 @@ class ParsedRtcEventLogNew {
|
||||
|
||||
// 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 @@ class ParsedRtcEventLogNew {
|
||||
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 @@ class ParsedRtcEventLogNew {
|
||||
|
||||
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 @@ class ParsedRtcEventLogNew {
|
||||
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 @@ class ParsedRtcEventLogNew {
|
||||
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 @@ class ParsedRtcEventLogNew {
|
||||
|
||||
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 @@ class ParsedRtcEventLogNew {
|
||||
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_;
|
||||
|
||||
|
||||
@ -145,8 +145,10 @@ const std::map<ParsedRtcEventLogNew::EventType, std::string>
|
||||
"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,
|
||||
|
||||
@ -40,7 +40,7 @@ std::unique_ptr<Packet> RtcEventLogSource::NextPacket() {
|
||||
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 @@ std::unique_ptr<Packet> RtcEventLogSource::NextPacket() {
|
||||
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_)) {
|
||||
|
||||
@ -977,12 +977,10 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
|
||||
|
||||
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);
|
||||
|
||||
Reference in New Issue
Block a user