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

Remove deprecated APIs from RTC event log parser.

Browse Source 
Bug: webrtc:8111
Change-Id: Ic64f8754c35c2de16d1f74e5d470a501d0a1af52
Reviewed-on: https://webrtc-review.googlesource.com/c/110900
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25637}
This commit is contained in:
Bjorn Terelius
2018-11-14 13:40:13 +01:00
committed by Commit Bot
parent 3bc696fe48
commit fdc635d2a8
4 changed files with 62 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
logging/rtc_event_log/rtc_event_log2rtp_dump.cc
View File

@ -198,8 +198,6 @@ int main(int argc, char* argv[]) {
return -1; return -1;
} }
std::cout << "Found " << parsed_stream.GetNumberOfEvents()
<< " events in the input file." << std::endl;
int rtp_counter = 0, rtcp_counter = 0; int rtp_counter = 0, rtcp_counter = 0;
bool header_only = false; bool header_only = false;

244
logging/rtc_event_log/rtc_event_log_parser_new.cc
View File

@ -59,52 +59,6 @@ RtcpMode GetRuntimeRtcpMode(rtclog::VideoReceiveConfig::RtcpMode rtcp_mode) {
return RtcpMode::kOff; return RtcpMode::kOff;
} }
ParsedRtcEventLogNew::EventType GetRuntimeEventType(
rtclog::Event::EventType event_type) {
switch (event_type) {
case rtclog::Event::UNKNOWN_EVENT:
return ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT;
case rtclog::Event::LOG_START:
return ParsedRtcEventLogNew::EventType::LOG_START;
case rtclog::Event::LOG_END:
return ParsedRtcEventLogNew::EventType::LOG_END;
case rtclog::Event::RTP_EVENT:
return ParsedRtcEventLogNew::EventType::RTP_EVENT;
case rtclog::Event::RTCP_EVENT:
return ParsedRtcEventLogNew::EventType::RTCP_EVENT;
case rtclog::Event::AUDIO_PLAYOUT_EVENT:
return ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT;
case rtclog::Event::LOSS_BASED_BWE_UPDATE:
return ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE;
case rtclog::Event::DELAY_BASED_BWE_UPDATE:
return ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE;
case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT:
return ParsedRtcEventLogNew::EventType::VIDEO_RECEIVER_CONFIG_EVENT;
case rtclog::Event::VIDEO_SENDER_CONFIG_EVENT:
return ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT;
case rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT:
return ParsedRtcEventLogNew::EventType::AUDIO_RECEIVER_CONFIG_EVENT;
case rtclog::Event::AUDIO_SENDER_CONFIG_EVENT:
return ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT;
case rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT:
return ParsedRtcEventLogNew::EventType::AUDIO_NETWORK_ADAPTATION_EVENT;
case rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT:
return ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT;
case rtclog::Event::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:
return ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_CONFIG;
case rtclog::Event::ICE_CANDIDATE_PAIR_EVENT:
return ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_EVENT;
}
return ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT;
}
BandwidthUsage GetRuntimeDetectorState( BandwidthUsage GetRuntimeDetectorState(
rtclog::DelayBasedBweUpdate::DetectorState detector_state) { rtclog::DelayBasedBweUpdate::DetectorState detector_state) {
switch (detector_state) { switch (detector_state) {
@ -846,7 +800,6 @@ ParsedRtcEventLogNew::ParsedRtcEventLogNew(
} }
void ParsedRtcEventLogNew::Clear() { void ParsedRtcEventLogNew::Clear() {
events_.clear();
default_extension_map_ = GetDefaultHeaderExtensionMap(); default_extension_map_ = GetDefaultHeaderExtensionMap();
incoming_rtx_ssrcs_.clear(); incoming_rtx_ssrcs_.clear();
@ -1030,7 +983,6 @@ bool ParsedRtcEventLogNew::ParseStreamInternal(
RTC_CHECK_EQ(event_stream.stream_size(), 1); RTC_CHECK_EQ(event_stream.stream_size(), 1);
StoreParsedLegacyEvent(event_stream.stream(0)); StoreParsedLegacyEvent(event_stream.stream(0));
events_.push_back(event_stream.stream(0));
} else { } else {
// Parse the protobuf event from the buffer. // Parse the protobuf event from the buffer.
rtclog2::EventStream event_stream; rtclog2::EventStream event_stream;
@ -1045,6 +997,7 @@ bool ParsedRtcEventLogNew::ParseStreamInternal(
} }
void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) { void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
RTC_CHECK(event.has_type());
if (event.type() != rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT && if (event.type() != rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT &&
event.type() != rtclog::Event::VIDEO_SENDER_CONFIG_EVENT && event.type() != rtclog::Event::VIDEO_SENDER_CONFIG_EVENT &&
event.type() != rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT && event.type() != rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT &&
@ -1057,8 +1010,8 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
last_timestamp_ = std::max(last_timestamp_, timestamp); last_timestamp_ = std::max(last_timestamp_, timestamp);
} }
switch (GetEventType(event)) { switch (event.type()) {
case ParsedRtcEventLogNew::EventType::VIDEO_RECEIVER_CONFIG_EVENT: { case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT: {
rtclog::StreamConfig config = GetVideoReceiveConfig(event); rtclog::StreamConfig config = GetVideoReceiveConfig(event);
video_recv_configs_.emplace_back(GetTimestamp(event), config); video_recv_configs_.emplace_back(GetTimestamp(event), config);
incoming_rtp_extensions_maps_[config.remote_ssrc] = incoming_rtp_extensions_maps_[config.remote_ssrc] =
@ -1073,7 +1026,7 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
incoming_rtx_ssrcs_.insert(config.rtx_ssrc); incoming_rtx_ssrcs_.insert(config.rtx_ssrc);
break; break;
} }
case ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT: { case rtclog::Event::VIDEO_SENDER_CONFIG_EVENT: {
std::vector<rtclog::StreamConfig> configs = GetVideoSendConfig(event); std::vector<rtclog::StreamConfig> configs = GetVideoSendConfig(event);
video_send_configs_.emplace_back(GetTimestamp(event), configs); video_send_configs_.emplace_back(GetTimestamp(event), configs);
for (const auto& config : configs) { for (const auto& config : configs) {
@ -1087,7 +1040,7 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
} }
break; break;
} }
case ParsedRtcEventLogNew::EventType::AUDIO_RECEIVER_CONFIG_EVENT: { case rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT: {
rtclog::StreamConfig config = GetAudioReceiveConfig(event); rtclog::StreamConfig config = GetAudioReceiveConfig(event);
audio_recv_configs_.emplace_back(GetTimestamp(event), config); audio_recv_configs_.emplace_back(GetTimestamp(event), config);
incoming_rtp_extensions_maps_[config.remote_ssrc] = incoming_rtp_extensions_maps_[config.remote_ssrc] =
@ -1097,7 +1050,7 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
incoming_audio_ssrcs_.insert(config.remote_ssrc); incoming_audio_ssrcs_.insert(config.remote_ssrc);
break; break;
} }
case ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT: { case rtclog::Event::AUDIO_SENDER_CONFIG_EVENT: {
rtclog::StreamConfig config = GetAudioSendConfig(event); rtclog::StreamConfig config = GetAudioSendConfig(event);
audio_send_configs_.emplace_back(GetTimestamp(event), config); audio_send_configs_.emplace_back(GetTimestamp(event), config);
outgoing_rtp_extensions_maps_[config.local_ssrc] = outgoing_rtp_extensions_maps_[config.local_ssrc] =
@ -1105,7 +1058,7 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
outgoing_audio_ssrcs_.insert(config.local_ssrc); outgoing_audio_ssrcs_.insert(config.local_ssrc);
break; break;
} }
case ParsedRtcEventLogNew::EventType::RTP_EVENT: { case rtclog::Event::RTP_EVENT: {
PacketDirection direction; PacketDirection direction;
uint8_t header[IP_PACKET_SIZE]; uint8_t header[IP_PACKET_SIZE];
size_t header_length; size_t header_length;
@ -1148,7 +1101,7 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
} }
break; break;
} }
case ParsedRtcEventLogNew::EventType::RTCP_EVENT: { case rtclog::Event::RTCP_EVENT: {
PacketDirection direction; PacketDirection direction;
uint8_t packet[IP_PACKET_SIZE]; uint8_t packet[IP_PACKET_SIZE];
size_t total_length; size_t total_length;
@ -1234,113 +1187,76 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
} }
break; break;
} }
case ParsedRtcEventLogNew::EventType::LOG_START: { case rtclog::Event::LOG_START: {
start_log_events_.push_back(LoggedStartEvent(GetTimestamp(event))); start_log_events_.push_back(LoggedStartEvent(GetTimestamp(event)));
break; break;
} }
case ParsedRtcEventLogNew::EventType::LOG_END: { case rtclog::Event::LOG_END: {
stop_log_events_.push_back(LoggedStopEvent(GetTimestamp(event))); stop_log_events_.push_back(LoggedStopEvent(GetTimestamp(event)));
break; break;
} }
case ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT: { case rtclog::Event::AUDIO_PLAYOUT_EVENT: {
LoggedAudioPlayoutEvent playout_event = GetAudioPlayout(event); LoggedAudioPlayoutEvent playout_event = GetAudioPlayout(event);
audio_playout_events_[playout_event.ssrc].push_back(playout_event); audio_playout_events_[playout_event.ssrc].push_back(playout_event);
break; break;
} }
case ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE: { case rtclog::Event::LOSS_BASED_BWE_UPDATE: {
bwe_loss_updates_.push_back(GetLossBasedBweUpdate(event)); bwe_loss_updates_.push_back(GetLossBasedBweUpdate(event));
break; break;
} }
case ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE: { case rtclog::Event::DELAY_BASED_BWE_UPDATE: {
bwe_delay_updates_.push_back(GetDelayBasedBweUpdate(event)); bwe_delay_updates_.push_back(GetDelayBasedBweUpdate(event));
break; break;
} }
case ParsedRtcEventLogNew::EventType::AUDIO_NETWORK_ADAPTATION_EVENT: { case rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT: {
LoggedAudioNetworkAdaptationEvent ana_event = LoggedAudioNetworkAdaptationEvent ana_event =
GetAudioNetworkAdaptation(event); GetAudioNetworkAdaptation(event);
audio_network_adaptation_events_.push_back(ana_event); audio_network_adaptation_events_.push_back(ana_event);
break; break;
} }
case ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT: { case rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT: {
bwe_probe_cluster_created_events_.push_back( bwe_probe_cluster_created_events_.push_back(
GetBweProbeClusterCreated(event)); GetBweProbeClusterCreated(event));
break; break;
} }
case ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT: { case rtclog::Event::BWE_PROBE_RESULT_EVENT: {
bwe_probe_failure_events_.push_back(GetBweProbeFailure(event)); // Probe successes and failures are currently stored in the same proto
break; // message, we are moving towards separate messages. Probe results
} // therefore need special treatment in the parser.
case ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT: { RTC_CHECK(event.has_probe_result());
RTC_CHECK(event.probe_result().has_result());
if (event.probe_result().result() == rtclog::BweProbeResult::SUCCESS) {
bwe_probe_success_events_.push_back(GetBweProbeSuccess(event)); bwe_probe_success_events_.push_back(GetBweProbeSuccess(event));
} else {
bwe_probe_failure_events_.push_back(GetBweProbeFailure(event));
}
break; break;
} }
case ParsedRtcEventLogNew::EventType::ALR_STATE_EVENT: { case rtclog::Event::ALR_STATE_EVENT: {
alr_state_events_.push_back(GetAlrState(event)); alr_state_events_.push_back(GetAlrState(event));
break; break;
} }
case ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_CONFIG: { case rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG: {
ice_candidate_pair_configs_.push_back(GetIceCandidatePairConfig(event)); ice_candidate_pair_configs_.push_back(GetIceCandidatePairConfig(event));
break; break;
} }
case ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_EVENT: { case rtclog::Event::ICE_CANDIDATE_PAIR_EVENT: {
ice_candidate_pair_events_.push_back(GetIceCandidatePairEvent(event)); ice_candidate_pair_events_.push_back(GetIceCandidatePairEvent(event));
break; break;
} }
case ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT: { case rtclog::Event::UNKNOWN_EVENT: {
break; break;
} }
} }
} }
size_t ParsedRtcEventLogNew::GetNumberOfEvents() const {
return events_.size();
}
int64_t ParsedRtcEventLogNew::GetTimestamp(size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetTimestamp(event);
}
int64_t ParsedRtcEventLogNew::GetTimestamp(const rtclog::Event& event) const { int64_t ParsedRtcEventLogNew::GetTimestamp(const rtclog::Event& event) const {
RTC_CHECK(event.has_timestamp_us()); RTC_CHECK(event.has_timestamp_us());
return event.timestamp_us(); return event.timestamp_us();
} }
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());
}
// The header must have space for at least IP_PACKET_SIZE bytes. // The header must have space for at least IP_PACKET_SIZE bytes.
const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader(
size_t index,
PacketDirection* incoming,
uint8_t* header,
size_t* header_length,
size_t* total_length,
int* probe_cluster_id) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetRtpHeader(event, incoming, header, header_length, total_length,
probe_cluster_id);
}
const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader( const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader(
const rtclog::Event& event, const rtclog::Event& event,
PacketDirection* incoming, PacketDirection* incoming,
@ -1402,15 +1318,6 @@ const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader(
} }
// The packet must have space for at least IP_PACKET_SIZE bytes. // The packet must have space for at least IP_PACKET_SIZE bytes.
void ParsedRtcEventLogNew::GetRtcpPacket(size_t index,
PacketDirection* incoming,
uint8_t* packet,
size_t* length) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
GetRtcpPacket(event, incoming, packet, length);
}
void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event, void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event,
PacketDirection* incoming, PacketDirection* incoming,
uint8_t* packet, uint8_t* packet,
@ -1438,12 +1345,6 @@ void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event,
} }
} }
rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
return GetVideoReceiveConfig(events_[index]);
}
rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig( rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig(
const rtclog::Event& event) const { const rtclog::Event& event) const {
rtclog::StreamConfig config; rtclog::StreamConfig config;
@ -1505,12 +1406,6 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig(
return config; return config;
} }
std::vector<rtclog::StreamConfig> ParsedRtcEventLogNew::GetVideoSendConfig(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
return GetVideoSendConfig(events_[index]);
}
std::vector<rtclog::StreamConfig> ParsedRtcEventLogNew::GetVideoSendConfig( std::vector<rtclog::StreamConfig> ParsedRtcEventLogNew::GetVideoSendConfig(
const rtclog::Event& event) const { const rtclog::Event& event) const {
std::vector<rtclog::StreamConfig> configs; std::vector<rtclog::StreamConfig> configs;
@ -1549,12 +1444,6 @@ std::vector<rtclog::StreamConfig> ParsedRtcEventLogNew::GetVideoSendConfig(
return configs; return configs;
} }
rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
return GetAudioReceiveConfig(events_[index]);
}
rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig( rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig(
const rtclog::Event& event) const { const rtclog::Event& event) const {
rtclog::StreamConfig config; rtclog::StreamConfig config;
@ -1574,12 +1463,6 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig(
return config; return config;
} }
rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
return GetAudioSendConfig(events_[index]);
}
rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig( rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig(
const rtclog::Event& event) const { const rtclog::Event& event) const {
rtclog::StreamConfig config; rtclog::StreamConfig config;
@ -1596,13 +1479,6 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig(
return config; return config;
} }
LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetAudioPlayout(event);
}
LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout( LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout(
const rtclog::Event& event) const { const rtclog::Event& event) const {
RTC_CHECK(event.has_type()); RTC_CHECK(event.has_type());
@ -1616,13 +1492,6 @@ LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout(
return res; return res;
} }
LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetLossBasedBweUpdate(event);
}
LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate( LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate(
const rtclog::Event& event) const { const rtclog::Event& event) const {
RTC_CHECK(event.has_type()); RTC_CHECK(event.has_type());
@ -1641,13 +1510,6 @@ LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate(
return bwe_update; return bwe_update;
} }
LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetDelayBasedBweUpdate(event);
}
LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate( LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate(
const rtclog::Event& event) const { const rtclog::Event& event) const {
RTC_CHECK(event.has_type()); RTC_CHECK(event.has_type());
@ -1665,13 +1527,6 @@ LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate(
return res; return res;
} }
LoggedAudioNetworkAdaptationEvent
ParsedRtcEventLogNew::GetAudioNetworkAdaptation(size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetAudioNetworkAdaptation(event);
}
LoggedAudioNetworkAdaptationEvent LoggedAudioNetworkAdaptationEvent
ParsedRtcEventLogNew::GetAudioNetworkAdaptation( ParsedRtcEventLogNew::GetAudioNetworkAdaptation(
const rtclog::Event& event) const { const rtclog::Event& event) const {
@ -1699,13 +1554,6 @@ ParsedRtcEventLogNew::GetAudioNetworkAdaptation(
return res; return res;
} }
LoggedBweProbeClusterCreatedEvent
ParsedRtcEventLogNew::GetBweProbeClusterCreated(size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetBweProbeClusterCreated(event);
}
LoggedBweProbeClusterCreatedEvent LoggedBweProbeClusterCreatedEvent
ParsedRtcEventLogNew::GetBweProbeClusterCreated( ParsedRtcEventLogNew::GetBweProbeClusterCreated(
const rtclog::Event& event) const { const rtclog::Event& event) const {
@ -1726,13 +1574,6 @@ ParsedRtcEventLogNew::GetBweProbeClusterCreated(
return res; return res;
} }
LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetBweProbeFailure(event);
}
LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure( LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
const rtclog::Event& event) const { const rtclog::Event& event) const {
RTC_CHECK(event.has_type()); RTC_CHECK(event.has_type());
@ -1763,13 +1604,6 @@ LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
return res; 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( LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
const rtclog::Event& event) const { const rtclog::Event& event) const {
RTC_CHECK(event.has_type()); RTC_CHECK(event.has_type());
@ -1789,12 +1623,6 @@ LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
return res; return res;
} }
LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState(size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
return GetAlrState(event);
}
LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState( LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState(
const rtclog::Event& event) const { const rtclog::Event& event) const {
RTC_CHECK(event.has_type()); RTC_CHECK(event.has_type());
@ -1809,13 +1637,6 @@ LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState(
return res; return res;
} }
LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& rtc_event = events_[index];
return GetIceCandidatePairConfig(rtc_event);
}
LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig( LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig(
const rtclog::Event& rtc_event) const { const rtclog::Event& rtc_event) const {
RTC_CHECK(rtc_event.has_type()); RTC_CHECK(rtc_event.has_type());
@ -1852,13 +1673,6 @@ LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig(
return res; return res;
} }
LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent(
size_t index) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& rtc_event = events_[index];
return GetIceCandidatePairEvent(rtc_event);
}
LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent( LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent(
const rtclog::Event& rtc_event) const { const rtclog::Event& rtc_event) const {
RTC_CHECK(rtc_event.has_type()); RTC_CHECK(rtc_event.has_type());

161
logging/rtc_event_log/rtc_event_log_parser_new.h
View File

@ -612,30 +612,6 @@ class ParsedRtcEventLogNew {
friend class RtcEventLogTestHelper; friend class RtcEventLogTestHelper;
public: public:
~ParsedRtcEventLogNew();
enum class EventType {
UNKNOWN_EVENT = 0,
LOG_START = 1,
LOG_END = 2,
RTP_EVENT = 3,
RTCP_EVENT = 4,
AUDIO_PLAYOUT_EVENT = 5,
LOSS_BASED_BWE_UPDATE = 6,
DELAY_BASED_BWE_UPDATE = 7,
VIDEO_RECEIVER_CONFIG_EVENT = 8,
VIDEO_SENDER_CONFIG_EVENT = 9,
AUDIO_RECEIVER_CONFIG_EVENT = 10,
AUDIO_SENDER_CONFIG_EVENT = 11,
AUDIO_NETWORK_ADAPTATION_EVENT = 16,
BWE_PROBE_CLUSTER_CREATED_EVENT = 17,
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 }; enum class MediaType { ANY, AUDIO, VIDEO, DATA };
enum class UnconfiguredHeaderExtensions { enum class UnconfiguredHeaderExtensions {
kDontParse, kDontParse,
@ -676,6 +652,8 @@ class ParsedRtcEventLogNew {
UnconfiguredHeaderExtensions parse_unconfigured_header_extensions = UnconfiguredHeaderExtensions parse_unconfigured_header_extensions =
UnconfiguredHeaderExtensions::kDontParse); UnconfiguredHeaderExtensions::kDontParse);
~ParsedRtcEventLogNew();
// Clears previously parsed events and resets the ParsedRtcEventLogNew to an // Clears previously parsed events and resets the ParsedRtcEventLogNew to an
// empty state. // empty state.
void Clear(); void Clear();
@ -690,111 +668,8 @@ class ParsedRtcEventLogNew {
bool ParseStream( bool ParseStream(
std::istream& stream); // no-presubmit-check TODO(webrtc:8982) std::istream& stream); // no-presubmit-check TODO(webrtc:8982)
// Returns the number of events in an EventStream.
size_t GetNumberOfEvents() const;
// Reads the arrival timestamp (in microseconds) from a rtclog::Event.
int64_t GetTimestamp(size_t index) const;
int64_t GetTimestamp(const rtclog::Event& event) const;
// 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
// parameters. Each output parameter can be set to nullptr if that value
// isn't needed.
// NB: The header must have space for at least IP_PACKET_SIZE bytes.
// Returns: a pointer to a header extensions map acquired from parsing
// corresponding Audio/Video Sender/Receiver config events.
// Warning: if the same SSRC is reused by both video and audio streams during
// call, extensions maps may be incorrect (the last one would be returned).
const webrtc::RtpHeaderExtensionMap* GetRtpHeader(
size_t index,
PacketDirection* incoming,
uint8_t* header,
size_t* header_length,
size_t* total_length,
int* probe_cluster_id) const;
const webrtc::RtpHeaderExtensionMap* GetRtpHeader(
const rtclog::Event& event,
PacketDirection* incoming,
uint8_t* header,
size_t* header_length,
size_t* total_length,
int* probe_cluster_id) const;
// Reads packet, direction and packet length from the RTCP event at |index|,
// and stores the values in the corresponding output parameters.
// Each output parameter can be set to nullptr if that value isn't needed.
// NB: The packet must have space for at least IP_PACKET_SIZE bytes.
void GetRtcpPacket(size_t index,
PacketDirection* incoming,
uint8_t* packet,
size_t* length) const;
void GetRtcpPacket(const rtclog::Event& event,
PacketDirection* incoming,
uint8_t* packet,
size_t* length) const;
// Reads a video receive config event to a StreamConfig struct.
// Only the fields that are stored in the protobuf will be written.
rtclog::StreamConfig GetVideoReceiveConfig(size_t index) const;
// Reads a video send config event to a StreamConfig struct. If the proto
// contains multiple SSRCs and RTX SSRCs (this used to be the case for
// simulcast streams) then we return one StreamConfig per SSRC,RTX_SSRC pair.
// Only the fields that are stored in the protobuf will be written.
std::vector<rtclog::StreamConfig> GetVideoSendConfig(size_t index) const;
// Reads a audio receive config event to a StreamConfig struct.
// Only the fields that are stored in the protobuf will be written.
rtclog::StreamConfig GetAudioReceiveConfig(size_t index) const;
// Reads a config event to a StreamConfig struct.
// Only the fields that are stored in the protobuf will be written.
rtclog::StreamConfig GetAudioSendConfig(size_t index) const;
// Reads the SSRC from the audio playout event at |index|. The SSRC is stored
// in the output parameter ssrc. The output parameter can be set to nullptr
// and in that case the function only asserts that the event is well formed.
LoggedAudioPlayoutEvent GetAudioPlayout(size_t index) const;
// Reads bitrate, fraction loss (as defined in RFC 1889) and total number of
// expected packets from the loss based BWE event at |index| and stores the
// values in
// the corresponding output parameters. Each output parameter can be set to
// nullptr if that
// value isn't needed.
LoggedBweLossBasedUpdate GetLossBasedBweUpdate(size_t index) const;
// Reads bitrate and detector_state from the delay based BWE event at |index|
// and stores the values in the corresponding output parameters. Each output
// parameter can be set to nullptr if that
// value isn't needed.
LoggedBweDelayBasedUpdate GetDelayBasedBweUpdate(size_t index) const;
// Reads a audio network adaptation event to a (non-NULL)
// AudioEncoderRuntimeConfig struct. Only the fields that are
// stored in the protobuf will be written.
LoggedAudioNetworkAdaptationEvent GetAudioNetworkAdaptation(
size_t index) const;
LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated(
size_t index) const;
LoggedBweProbeFailureEvent GetBweProbeFailure(size_t index) const;
LoggedBweProbeSuccessEvent GetBweProbeSuccess(size_t index) const;
MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const; MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const;
LoggedAlrStateEvent GetAlrState(size_t index) const;
LoggedIceCandidatePairConfig GetIceCandidatePairConfig(size_t index) const;
LoggedIceCandidatePairEvent GetIceCandidatePairEvent(size_t index) const;
// Configured SSRCs. // Configured SSRCs.
const std::set<uint32_t>& incoming_rtx_ssrcs() const { const std::set<uint32_t>& incoming_rtx_ssrcs() const {
return incoming_rtx_ssrcs_; return incoming_rtx_ssrcs_;
@ -978,6 +853,35 @@ class ParsedRtcEventLogNew {
void StoreParsedLegacyEvent(const rtclog::Event& event); void StoreParsedLegacyEvent(const rtclog::Event& event);
// Reads the arrival timestamp (in microseconds) from a rtclog::Event.
int64_t GetTimestamp(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
// parameters. Each output parameter can be set to nullptr if that value
// isn't needed.
// NB: The header must have space for at least IP_PACKET_SIZE bytes.
// Returns: a pointer to a header extensions map acquired from parsing
// corresponding Audio/Video Sender/Receiver config events.
// Warning: if the same SSRC is reused by both video and audio streams during
// call, extensions maps may be incorrect (the last one would be returned).
const webrtc::RtpHeaderExtensionMap* GetRtpHeader(
const rtclog::Event& event,
PacketDirection* incoming,
uint8_t* header,
size_t* header_length,
size_t* total_length,
int* probe_cluster_id) const;
// Reads packet, direction and packet length from the RTCP event at |index|,
// and stores the values in the corresponding output parameters.
// Each output parameter can be set to nullptr if that value isn't needed.
// NB: The packet must have space for at least IP_PACKET_SIZE bytes.
void GetRtcpPacket(const rtclog::Event& event,
PacketDirection* incoming,
uint8_t* packet,
size_t* length) const;
rtclog::StreamConfig GetVideoReceiveConfig(const rtclog::Event& event) const; rtclog::StreamConfig GetVideoReceiveConfig(const rtclog::Event& event) const;
std::vector<rtclog::StreamConfig> GetVideoSendConfig( std::vector<rtclog::StreamConfig> GetVideoSendConfig(
const rtclog::Event& event) const; const rtclog::Event& event) const;
@ -1008,9 +912,6 @@ class ParsedRtcEventLogNew {
LoggedIceCandidatePairEvent GetIceCandidatePairEvent( LoggedIceCandidatePairEvent GetIceCandidatePairEvent(
const rtclog::Event& event) const; const rtclog::Event& event) const;
// TODO(terelius): Remove
std::vector<rtclog::Event> events_;
// Parsing functions for new format. // Parsing functions for new format.
void StoreParsedNewFormatEvent(const rtclog2::EventStream& event); void StoreParsedNewFormatEvent(const rtclog2::EventStream& event);
void StoreIncomingRtpPackets(const rtclog2::IncomingRtpPackets& proto); void StoreIncomingRtpPackets(const rtclog2::IncomingRtpPackets& proto);

4
rtc_tools/event_log_visualizer/main.cc
View File

@ -252,9 +252,7 @@ int main(int argc, char* argv[]) {
if (!parsed_log.ParseFile(filename)) { if (!parsed_log.ParseFile(filename)) {
std::cerr << "Could not parse the entire log file." << std::endl; std::cerr << "Could not parse the entire log file." << std::endl;
std::cerr << "Proceeding to analyze the first " std::cerr << "Only the parsable events will be analyzed." << std::endl;
<< parsed_log.GetNumberOfEvents() << " events in the file."
<< std::endl;
} }
webrtc::EventLogAnalyzer analyzer(parsed_log, FLAG_normalize_time); webrtc::EventLogAnalyzer analyzer(parsed_log, FLAG_normalize_time);