From b290a6d767fdd64664a7dde56fe58514b2cfaed8 Mon Sep 17 00:00:00 2001 From: Sebastian Jansson Date: Thu, 3 Jan 2019 14:46:23 +0100 Subject: [PATCH] Renames RtcEventLogParseNew to RtcEventLogParser MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:10170 Change-Id: I9232c276229a64fa4d8321b6c996387fe130f68b Reviewed-on: https://webrtc-review.googlesource.com/c/116064 Commit-Queue: Sebastian Jansson Reviewed-by: Björn Terelius Reviewed-by: Minyue Li Cr-Commit-Position: refs/heads/master@{#26128} --- logging/BUILD.gn | 4 +- .../encoder/rtc_event_log_encoder_unittest.cc | 16 +- .../rtc_event_log/rtc_event_log2rtp_dump.cc | 8 +- ..._parser_new.cc => rtc_event_log_parser.cc} | 136 ++-- logging/rtc_event_log/rtc_event_log_parser.h | 686 ++++++++++++++++++ .../rtc_event_log/rtc_event_log_parser_new.h | 677 +---------------- .../rtc_event_log/rtc_event_log_unittest.cc | 6 +- .../rtc_event_log_unittest_helper.h | 2 +- .../rtc_event_processor_unittest.cc | 2 +- .../neteq/tools/rtc_event_log_source.cc | 8 +- .../neteq/tools/rtc_event_log_source.h | 2 +- rtc_tools/event_log_visualizer/analyzer.cc | 2 +- rtc_tools/event_log_visualizer/analyzer.h | 6 +- rtc_tools/event_log_visualizer/main.cc | 10 +- 14 files changed, 788 insertions(+), 777 deletions(-) rename logging/rtc_event_log/{rtc_event_log_parser_new.cc => rtc_event_log_parser.cc} (95%) create mode 100644 logging/rtc_event_log/rtc_event_log_parser.h diff --git a/logging/BUILD.gn b/logging/BUILD.gn index 3eda8754b5..edb1b8679e 100644 --- a/logging/BUILD.gn +++ b/logging/BUILD.gn @@ -291,7 +291,8 @@ if (rtc_enable_protobuf) { visibility = [ "*" ] sources = [ "rtc_event_log/logged_events.h", - "rtc_event_log/rtc_event_log_parser_new.cc", + "rtc_event_log/rtc_event_log_parser.cc", + "rtc_event_log/rtc_event_log_parser.h", "rtc_event_log/rtc_event_log_parser_new.h", "rtc_event_log/rtc_event_processor.h", ] @@ -312,6 +313,7 @@ if (rtc_enable_protobuf) { "../modules/rtp_rtcp", "../modules/rtp_rtcp:rtp_rtcp_format", "../rtc_base:checks", + "../rtc_base:deprecation", "../rtc_base:protobuf_utils", "../rtc_base:rtc_base_approved", "//third_party/abseil-cpp/absl/memory", 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 7054365e48..2225d87f0e 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 @@ -32,7 +32,7 @@ #include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h" #include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h" #include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h" -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include "logging/rtc_event_log/rtc_event_log_unittest_helper.h" #include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h" #include "modules/remote_bitrate_estimator/include/bwe_defines.h" @@ -74,7 +74,7 @@ class RtcEventLogEncoderTest template const std::vector* GetRtpPacketsBySsrc( - const ParsedRtcEventLogNew* parsed_log, + const ParsedRtcEventLog* parsed_log, uint32_t ssrc); template @@ -82,7 +82,7 @@ class RtcEventLogEncoderTest std::deque> history_; std::unique_ptr encoder_; - ParsedRtcEventLogNew parsed_log_; + ParsedRtcEventLog parsed_log_; const uint64_t seed_; Random prng_; const bool new_encoding_; @@ -128,9 +128,8 @@ std::unique_ptr RtcEventLogEncoderTest::NewRtpPacket( template <> const std::vector* -RtcEventLogEncoderTest::GetRtpPacketsBySsrc( - const ParsedRtcEventLogNew* parsed_log, - uint32_t ssrc) { +RtcEventLogEncoderTest::GetRtpPacketsBySsrc(const ParsedRtcEventLog* parsed_log, + uint32_t ssrc) { const auto& incoming_streams = parsed_log->incoming_rtp_packets_by_ssrc(); for (const auto& stream : incoming_streams) { if (stream.ssrc == ssrc) { @@ -142,9 +141,8 @@ RtcEventLogEncoderTest::GetRtpPacketsBySsrc( template <> const std::vector* -RtcEventLogEncoderTest::GetRtpPacketsBySsrc( - const ParsedRtcEventLogNew* parsed_log, - uint32_t ssrc) { +RtcEventLogEncoderTest::GetRtpPacketsBySsrc(const ParsedRtcEventLog* parsed_log, + uint32_t ssrc) { const auto& outgoing_streams = parsed_log->outgoing_rtp_packets_by_ssrc(); for (const auto& stream : outgoing_streams) { if (stream.ssrc == ssrc) { diff --git a/logging/rtc_event_log/rtc_event_log2rtp_dump.cc b/logging/rtc_event_log/rtc_event_log2rtp_dump.cc index e6608e21fc..c446212be4 100644 --- a/logging/rtc_event_log/rtc_event_log2rtp_dump.cc +++ b/logging/rtc_event_log/rtc_event_log2rtp_dump.cc @@ -21,7 +21,7 @@ #include "api/array_view.h" #include "api/rtp_headers.h" #include "logging/rtc_event_log/rtc_event_log.h" -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include "logging/rtc_event_log/rtc_event_processor.h" #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" #include "modules/rtp_rtcp/source/rtp_header_extensions.h" @@ -33,7 +33,7 @@ namespace { -using MediaType = webrtc::ParsedRtcEventLogNew::MediaType; +using MediaType = webrtc::ParsedRtcEventLog::MediaType; WEBRTC_DEFINE_bool( audio, @@ -185,7 +185,7 @@ int main(int argc, char* argv[]) { RTC_CHECK(ssrc_filter.has_value()) << "Failed to read SSRC filter flag."; } - webrtc::ParsedRtcEventLogNew parsed_stream; + webrtc::ParsedRtcEventLog parsed_stream; if (!parsed_stream.ParseFile(input_file)) { std::cerr << "Error while parsing input file: " << input_file << std::endl; return -1; @@ -205,7 +205,7 @@ int main(int argc, char* argv[]) { bool header_only = false; webrtc::RtpHeaderExtensionMap default_extension_map = - webrtc::ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap(); + webrtc::ParsedRtcEventLog::GetDefaultHeaderExtensionMap(); auto handle_rtp = [&default_extension_map, &rtp_writer, &rtp_counter]( const webrtc::LoggedRtpPacketIncoming& incoming) { webrtc::test::RtpPacket packet; diff --git a/logging/rtc_event_log/rtc_event_log_parser_new.cc b/logging/rtc_event_log/rtc_event_log_parser.cc similarity index 95% rename from logging/rtc_event_log/rtc_event_log_parser_new.cc rename to logging/rtc_event_log/rtc_event_log_parser.cc index 79747b0d3e..d0f9f2be40 100644 --- a/logging/rtc_event_log/rtc_event_log_parser_new.cc +++ b/logging/rtc_event_log/rtc_event_log_parser.cc @@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include #include @@ -788,23 +788,21 @@ LoggedRtcpPacket::LoggedRtcpPacket(uint64_t timestamp_us, LoggedRtcpPacket::LoggedRtcpPacket(const LoggedRtcpPacket& rhs) = default; LoggedRtcpPacket::~LoggedRtcpPacket() = default; -ParsedRtcEventLogNew::~ParsedRtcEventLogNew() = default; +ParsedRtcEventLog::~ParsedRtcEventLog() = default; -ParsedRtcEventLogNew::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming() = - default; -ParsedRtcEventLogNew::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming( +ParsedRtcEventLog::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming() = default; +ParsedRtcEventLog::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming( const LoggedRtpStreamIncoming& rhs) = default; -ParsedRtcEventLogNew::LoggedRtpStreamIncoming::~LoggedRtpStreamIncoming() = +ParsedRtcEventLog::LoggedRtpStreamIncoming::~LoggedRtpStreamIncoming() = default; -ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing() = - default; -ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing( +ParsedRtcEventLog::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing() = default; +ParsedRtcEventLog::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing( const LoggedRtpStreamOutgoing& rhs) = default; -ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::~LoggedRtpStreamOutgoing() = +ParsedRtcEventLog::LoggedRtpStreamOutgoing::~LoggedRtpStreamOutgoing() = default; -ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView( +ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView( uint32_t ssrc, const LoggedRtpPacketIncoming* ptr, size_t num_elements) @@ -814,7 +812,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView( num_elements, offsetof(LoggedRtpPacketIncoming, rtp))) {} -ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView( +ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView( uint32_t ssrc, const LoggedRtpPacketOutgoing* ptr, size_t num_elements) @@ -824,7 +822,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView( num_elements, offsetof(LoggedRtpPacketOutgoing, rtp))) {} -ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView( +ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView( const LoggedRtpStreamView&) = default; // Return default values for header extensions, to use on streams without stored @@ -833,7 +831,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView( // TODO(ivoc): Remove this once this mapping is stored in the event log for // audio streams. Tracking bug: webrtc:6399 webrtc::RtpHeaderExtensionMap -ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap() { +ParsedRtcEventLog::GetDefaultHeaderExtensionMap() { webrtc::RtpHeaderExtensionMap default_map; default_map.Register(webrtc::RtpExtension::kAudioLevelDefaultId); default_map.Register( @@ -853,14 +851,14 @@ ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap() { return default_map; } -ParsedRtcEventLogNew::ParsedRtcEventLogNew( +ParsedRtcEventLog::ParsedRtcEventLog( UnconfiguredHeaderExtensions parse_unconfigured_header_extensions) : parse_unconfigured_header_extensions_( parse_unconfigured_header_extensions) { Clear(); } -void ParsedRtcEventLogNew::Clear() { +void ParsedRtcEventLog::Clear() { default_extension_map_ = GetDefaultHeaderExtensionMap(); incoming_rtx_ssrcs_.clear(); @@ -920,7 +918,7 @@ void ParsedRtcEventLogNew::Clear() { outgoing_rtp_extensions_maps_.clear(); } -bool ParsedRtcEventLogNew::ParseFile(const std::string& filename) { +bool ParsedRtcEventLog::ParseFile(const std::string& filename) { std::ifstream file( // no-presubmit-check TODO(webrtc:8982) filename, std::ios_base::in | std::ios_base::binary); if (!file.good() || !file.is_open()) { @@ -931,13 +929,13 @@ bool ParsedRtcEventLogNew::ParseFile(const std::string& filename) { return ParseStream(file); } -bool ParsedRtcEventLogNew::ParseString(const std::string& s) { +bool ParsedRtcEventLog::ParseString(const std::string& s) { std::istringstream stream( // no-presubmit-check TODO(webrtc:8982) s, std::ios_base::in | std::ios_base::binary); return ParseStream(stream); } -bool ParsedRtcEventLogNew::ParseStream( +bool ParsedRtcEventLog::ParseStream( std::istream& stream) { // no-presubmit-check TODO(webrtc:8982) Clear(); bool success = ParseStreamInternal(stream); @@ -1045,7 +1043,7 @@ bool ParsedRtcEventLogNew::ParseStream( return success; } -bool ParsedRtcEventLogNew::ParseStreamInternal( +bool ParsedRtcEventLog::ParseStreamInternal( std::istream& stream) { // no-presubmit-check TODO(webrtc:8982) constexpr uint64_t kMaxEventSize = 10000000; // Sanity check. std::vector buffer(0xFFFF); @@ -1128,14 +1126,14 @@ bool ParsedRtcEventLogNew::ParseStreamInternal( } template -void ParsedRtcEventLogNew::StoreFirstAndLastTimestamp(const std::vector& v) { +void ParsedRtcEventLog::StoreFirstAndLastTimestamp(const std::vector& v) { if (v.empty()) return; first_timestamp_ = std::min(first_timestamp_, v.front().log_time_us()); last_timestamp_ = std::max(last_timestamp_, v.back().log_time_us()); } -void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) { +void ParsedRtcEventLog::StoreParsedLegacyEvent(const rtclog::Event& event) { RTC_CHECK(event.has_type()); switch (event.type()) { case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT: { @@ -1308,14 +1306,13 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) { } } - -int64_t ParsedRtcEventLogNew::GetTimestamp(const rtclog::Event& event) const { +int64_t ParsedRtcEventLog::GetTimestamp(const rtclog::Event& event) const { RTC_CHECK(event.has_timestamp_us()); return event.timestamp_us(); } // The header must have space for at least IP_PACKET_SIZE bytes. -const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader( +const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLog::GetRtpHeader( const rtclog::Event& event, PacketDirection* incoming, uint8_t* header, @@ -1376,10 +1373,10 @@ const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader( } // The packet must have space for at least IP_PACKET_SIZE bytes. -void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event, - PacketDirection* incoming, - uint8_t* packet, - size_t* length) const { +void ParsedRtcEventLog::GetRtcpPacket(const rtclog::Event& event, + PacketDirection* incoming, + uint8_t* packet, + size_t* length) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::RTCP_EVENT); RTC_CHECK(event.has_rtcp_packet()); @@ -1403,7 +1400,7 @@ void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event, } } -rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig( +rtclog::StreamConfig ParsedRtcEventLog::GetVideoReceiveConfig( const rtclog::Event& event) const { rtclog::StreamConfig config; RTC_CHECK(event.has_type()); @@ -1464,7 +1461,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig( return config; } -rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoSendConfig( +rtclog::StreamConfig ParsedRtcEventLog::GetVideoSendConfig( const rtclog::Event& event) const { rtclog::StreamConfig config; RTC_CHECK(event.has_type()); @@ -1500,7 +1497,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoSendConfig( return config; } -rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig( +rtclog::StreamConfig ParsedRtcEventLog::GetAudioReceiveConfig( const rtclog::Event& event) const { rtclog::StreamConfig config; RTC_CHECK(event.has_type()); @@ -1519,7 +1516,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig( return config; } -rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig( +rtclog::StreamConfig ParsedRtcEventLog::GetAudioSendConfig( const rtclog::Event& event) const { rtclog::StreamConfig config; RTC_CHECK(event.has_type()); @@ -1535,7 +1532,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig( return config; } -LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout( +LoggedAudioPlayoutEvent ParsedRtcEventLog::GetAudioPlayout( const rtclog::Event& event) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_PLAYOUT_EVENT); @@ -1548,7 +1545,7 @@ LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout( return res; } -LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate( +LoggedBweLossBasedUpdate ParsedRtcEventLog::GetLossBasedBweUpdate( const rtclog::Event& event) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::LOSS_BASED_BWE_UPDATE); @@ -1566,7 +1563,7 @@ LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate( return bwe_update; } -LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate( +LoggedBweDelayBasedUpdate ParsedRtcEventLog::GetDelayBasedBweUpdate( const rtclog::Event& event) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::DELAY_BASED_BWE_UPDATE); @@ -1583,8 +1580,7 @@ LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate( return res; } -LoggedAudioNetworkAdaptationEvent -ParsedRtcEventLogNew::GetAudioNetworkAdaptation( +LoggedAudioNetworkAdaptationEvent ParsedRtcEventLog::GetAudioNetworkAdaptation( const rtclog::Event& event) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT); @@ -1610,8 +1606,7 @@ ParsedRtcEventLogNew::GetAudioNetworkAdaptation( return res; } -LoggedBweProbeClusterCreatedEvent -ParsedRtcEventLogNew::GetBweProbeClusterCreated( +LoggedBweProbeClusterCreatedEvent ParsedRtcEventLog::GetBweProbeClusterCreated( const rtclog::Event& event) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT); @@ -1630,7 +1625,7 @@ ParsedRtcEventLogNew::GetBweProbeClusterCreated( return res; } -LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure( +LoggedBweProbeFailureEvent ParsedRtcEventLog::GetBweProbeFailure( const rtclog::Event& event) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT); @@ -1660,7 +1655,7 @@ LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure( return res; } -LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess( +LoggedBweProbeSuccessEvent ParsedRtcEventLog::GetBweProbeSuccess( const rtclog::Event& event) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT); @@ -1679,7 +1674,7 @@ LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess( return res; } -LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState( +LoggedAlrStateEvent ParsedRtcEventLog::GetAlrState( const rtclog::Event& event) const { RTC_CHECK(event.has_type()); RTC_CHECK_EQ(event.type(), rtclog::Event::ALR_STATE_EVENT); @@ -1693,7 +1688,7 @@ LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState( return res; } -LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig( +LoggedIceCandidatePairConfig ParsedRtcEventLog::GetIceCandidatePairConfig( const rtclog::Event& rtc_event) const { RTC_CHECK(rtc_event.has_type()); RTC_CHECK_EQ(rtc_event.type(), rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG); @@ -1729,7 +1724,7 @@ LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig( return res; } -LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent( +LoggedIceCandidatePairEvent ParsedRtcEventLog::GetIceCandidatePairEvent( const rtclog::Event& rtc_event) const { RTC_CHECK(rtc_event.has_type()); RTC_CHECK_EQ(rtc_event.type(), rtclog::Event::ICE_CANDIDATE_PAIR_EVENT); @@ -1748,7 +1743,7 @@ LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent( // Returns the MediaType for registered SSRCs. Search from the end to use last // registered types first. -ParsedRtcEventLogNew::MediaType ParsedRtcEventLogNew::GetMediaType( +ParsedRtcEventLog::MediaType ParsedRtcEventLog::GetMediaType( uint32_t ssrc, PacketDirection direction) const { if (direction == kIncomingPacket) { @@ -1774,7 +1769,7 @@ ParsedRtcEventLogNew::MediaType ParsedRtcEventLogNew::GetMediaType( } const std::vector GetNetworkTrace( - const ParsedRtcEventLogNew& parsed_log) { + const ParsedRtcEventLog& parsed_log) { using RtpPacketType = LoggedRtpPacketOutgoing; using TransportFeedbackType = LoggedRtcpPacketTransportFeedback; @@ -1856,7 +1851,7 @@ const std::vector GetNetworkTrace( } // Helper functions for new format start here -void ParsedRtcEventLogNew::StoreParsedNewFormatEvent( +void ParsedRtcEventLog::StoreParsedNewFormatEvent( const rtclog2::EventStream& stream) { RTC_DCHECK_EQ(stream.stream_size(), 0); @@ -1929,7 +1924,7 @@ void ParsedRtcEventLogNew::StoreParsedNewFormatEvent( } } -void ParsedRtcEventLogNew::StoreAlrStateEvent(const rtclog2::AlrState& proto) { +void ParsedRtcEventLog::StoreAlrStateEvent(const rtclog2::AlrState& proto) { RTC_CHECK(proto.has_timestamp_ms()); RTC_CHECK(proto.has_in_alr()); LoggedAlrStateEvent alr_event; @@ -1940,7 +1935,7 @@ void ParsedRtcEventLogNew::StoreAlrStateEvent(const rtclog2::AlrState& proto) { // TODO(terelius): Should we delta encode this event type? } -void ParsedRtcEventLogNew::StoreAudioPlayoutEvent( +void ParsedRtcEventLog::StoreAudioPlayoutEvent( const rtclog2::AudioPlayoutEvents& proto) { RTC_CHECK(proto.has_timestamp_ms()); RTC_CHECK(proto.has_local_ssrc()); @@ -1984,28 +1979,27 @@ void ParsedRtcEventLogNew::StoreAudioPlayoutEvent( } } -void ParsedRtcEventLogNew::StoreIncomingRtpPackets( +void ParsedRtcEventLog::StoreIncomingRtpPackets( const rtclog2::IncomingRtpPackets& proto) { StoreRtpPackets(proto, &incoming_rtp_packets_map_); } -void ParsedRtcEventLogNew::StoreOutgoingRtpPackets( +void ParsedRtcEventLog::StoreOutgoingRtpPackets( const rtclog2::OutgoingRtpPackets& proto) { StoreRtpPackets(proto, &outgoing_rtp_packets_map_); } -void ParsedRtcEventLogNew::StoreIncomingRtcpPackets( +void ParsedRtcEventLog::StoreIncomingRtcpPackets( const rtclog2::IncomingRtcpPackets& proto) { StoreRtcpPackets(proto, &incoming_rtcp_packets_); } -void ParsedRtcEventLogNew::StoreOutgoingRtcpPackets( +void ParsedRtcEventLog::StoreOutgoingRtcpPackets( const rtclog2::OutgoingRtcpPackets& proto) { StoreRtcpPackets(proto, &outgoing_rtcp_packets_); } -void ParsedRtcEventLogNew::StoreStartEvent( - const rtclog2::BeginLogEvent& proto) { +void ParsedRtcEventLog::StoreStartEvent(const rtclog2::BeginLogEvent& proto) { RTC_CHECK(proto.has_timestamp_ms()); RTC_CHECK(proto.has_version()); RTC_CHECK(proto.has_utc_time_ms()); @@ -2016,14 +2010,14 @@ void ParsedRtcEventLogNew::StoreStartEvent( start_log_events_.push_back(start_event); } -void ParsedRtcEventLogNew::StoreStopEvent(const rtclog2::EndLogEvent& proto) { +void ParsedRtcEventLog::StoreStopEvent(const rtclog2::EndLogEvent& proto) { RTC_CHECK(proto.has_timestamp_ms()); LoggedStopEvent stop_event(proto.timestamp_ms() * 1000); stop_log_events_.push_back(stop_event); } -void ParsedRtcEventLogNew::StoreBweLossBasedUpdate( +void ParsedRtcEventLog::StoreBweLossBasedUpdate( const rtclog2::LossBasedBweUpdates& proto) { RTC_CHECK(proto.has_timestamp_ms()); RTC_CHECK(proto.has_bitrate_bps()); @@ -2091,7 +2085,7 @@ void ParsedRtcEventLogNew::StoreBweLossBasedUpdate( } } -void ParsedRtcEventLogNew::StoreBweDelayBasedUpdate( +void ParsedRtcEventLog::StoreBweDelayBasedUpdate( const rtclog2::DelayBasedBweUpdates& proto) { RTC_CHECK(proto.has_timestamp_ms()); RTC_CHECK(proto.has_bitrate_bps()); @@ -2148,7 +2142,7 @@ void ParsedRtcEventLogNew::StoreBweDelayBasedUpdate( } } -void ParsedRtcEventLogNew::StoreBweProbeClusterCreated( +void ParsedRtcEventLog::StoreBweProbeClusterCreated( const rtclog2::BweProbeCluster& proto) { LoggedBweProbeClusterCreatedEvent probe_cluster; RTC_CHECK(proto.has_timestamp_ms()); @@ -2167,7 +2161,7 @@ void ParsedRtcEventLogNew::StoreBweProbeClusterCreated( // TODO(terelius): Should we delta encode this event type? } -void ParsedRtcEventLogNew::StoreBweProbeSuccessEvent( +void ParsedRtcEventLog::StoreBweProbeSuccessEvent( const rtclog2::BweProbeResultSuccess& proto) { LoggedBweProbeSuccessEvent probe_result; RTC_CHECK(proto.has_timestamp_ms()); @@ -2182,7 +2176,7 @@ void ParsedRtcEventLogNew::StoreBweProbeSuccessEvent( // TODO(terelius): Should we delta encode this event type? } -void ParsedRtcEventLogNew::StoreBweProbeFailureEvent( +void ParsedRtcEventLog::StoreBweProbeFailureEvent( const rtclog2::BweProbeResultFailure& proto) { LoggedBweProbeFailureEvent probe_result; RTC_CHECK(proto.has_timestamp_ms()); @@ -2197,7 +2191,7 @@ void ParsedRtcEventLogNew::StoreBweProbeFailureEvent( // TODO(terelius): Should we delta encode this event type? } -void ParsedRtcEventLogNew::StoreAudioNetworkAdaptationEvent( +void ParsedRtcEventLog::StoreAudioNetworkAdaptationEvent( const rtclog2::AudioNetworkAdaptations& proto) { RTC_CHECK(proto.has_timestamp_ms()); @@ -2350,7 +2344,7 @@ void ParsedRtcEventLogNew::StoreAudioNetworkAdaptationEvent( } } -void ParsedRtcEventLogNew::StoreDtlsTransportState( +void ParsedRtcEventLog::StoreDtlsTransportState( const rtclog2::DtlsTransportStateEvent& proto) { LoggedDtlsTransportState dtls_state; RTC_CHECK(proto.has_timestamp_ms()); @@ -2363,7 +2357,7 @@ void ParsedRtcEventLogNew::StoreDtlsTransportState( dtls_transport_states_.push_back(dtls_state); } -void ParsedRtcEventLogNew::StoreDtlsWritableState( +void ParsedRtcEventLog::StoreDtlsWritableState( const rtclog2::DtlsWritableState& proto) { LoggedDtlsWritableState dtls_writable_state; RTC_CHECK(proto.has_timestamp_ms()); @@ -2374,7 +2368,7 @@ void ParsedRtcEventLogNew::StoreDtlsWritableState( dtls_writable_states_.push_back(dtls_writable_state); } -void ParsedRtcEventLogNew::StoreIceCandidatePairConfig( +void ParsedRtcEventLog::StoreIceCandidatePairConfig( const rtclog2::IceCandidatePairConfig& proto) { LoggedIceCandidatePairConfig ice_config; RTC_CHECK(proto.has_timestamp_ms()); @@ -2411,7 +2405,7 @@ void ParsedRtcEventLogNew::StoreIceCandidatePairConfig( // TODO(terelius): Should we delta encode this event type? } -void ParsedRtcEventLogNew::StoreIceCandidateEvent( +void ParsedRtcEventLog::StoreIceCandidateEvent( const rtclog2::IceCandidatePairEvent& proto) { LoggedIceCandidatePairEvent ice_event; RTC_CHECK(proto.has_timestamp_ms()); @@ -2430,7 +2424,7 @@ void ParsedRtcEventLogNew::StoreIceCandidateEvent( // TODO(terelius): Should we delta encode this event type? } -void ParsedRtcEventLogNew::StoreVideoRecvConfig( +void ParsedRtcEventLog::StoreVideoRecvConfig( const rtclog2::VideoRecvStreamConfig& proto) { LoggedVideoRecvConfig stream; RTC_CHECK(proto.has_timestamp_ms()); @@ -2449,7 +2443,7 @@ void ParsedRtcEventLogNew::StoreVideoRecvConfig( video_recv_configs_.push_back(stream); } -void ParsedRtcEventLogNew::StoreVideoSendConfig( +void ParsedRtcEventLog::StoreVideoSendConfig( const rtclog2::VideoSendStreamConfig& proto) { LoggedVideoSendConfig stream; RTC_CHECK(proto.has_timestamp_ms()); @@ -2466,7 +2460,7 @@ void ParsedRtcEventLogNew::StoreVideoSendConfig( video_send_configs_.push_back(stream); } -void ParsedRtcEventLogNew::StoreAudioRecvConfig( +void ParsedRtcEventLog::StoreAudioRecvConfig( const rtclog2::AudioRecvStreamConfig& proto) { LoggedAudioRecvConfig stream; RTC_CHECK(proto.has_timestamp_ms()); @@ -2482,7 +2476,7 @@ void ParsedRtcEventLogNew::StoreAudioRecvConfig( audio_recv_configs_.push_back(stream); } -void ParsedRtcEventLogNew::StoreAudioSendConfig( +void ParsedRtcEventLog::StoreAudioSendConfig( const rtclog2::AudioSendStreamConfig& proto) { LoggedAudioSendConfig stream; RTC_CHECK(proto.has_timestamp_ms()); diff --git a/logging/rtc_event_log/rtc_event_log_parser.h b/logging/rtc_event_log/rtc_event_log_parser.h new file mode 100644 index 0000000000..f7e896dc11 --- /dev/null +++ b/logging/rtc_event_log/rtc_event_log_parser.h @@ -0,0 +1,686 @@ +/* + * Copyright 2019 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ +#ifndef LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_ +#define LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_ + +#include +#include +#include +#include // no-presubmit-check TODO(webrtc:8982) +#include +#include // pair +#include + +#include "call/video_receive_stream.h" +#include "call/video_send_stream.h" +#include "logging/rtc_event_log/logged_events.h" +#include "logging/rtc_event_log/rtc_event_log.h" +#include "modules/rtp_rtcp/include/rtp_header_extension_map.h" +#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h" +#include "rtc_base/ignore_wundef.h" + +// Files generated at build-time by the protobuf compiler. +RTC_PUSH_IGNORING_WUNDEF() +#ifdef WEBRTC_ANDROID_PLATFORM_BUILD +#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h" +#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log2.pb.h" +#else +#include "logging/rtc_event_log/rtc_event_log.pb.h" +#include "logging/rtc_event_log/rtc_event_log2.pb.h" +#endif +RTC_POP_IGNORING_WUNDEF() + +namespace webrtc { + +template +class PacketView; + +template +class PacketIterator { + friend class PacketView; + + public: + // Standard iterator traits. + using difference_type = std::ptrdiff_t; + using value_type = T; + using pointer = T*; + using reference = T&; + using iterator_category = std::bidirectional_iterator_tag; + + // The default-contructed iterator is meaningless, but is required by the + // ForwardIterator concept. + PacketIterator() : ptr_(nullptr), element_size_(0) {} + PacketIterator(const PacketIterator& other) + : ptr_(other.ptr_), element_size_(other.element_size_) {} + PacketIterator(const PacketIterator&& other) + : ptr_(other.ptr_), element_size_(other.element_size_) {} + ~PacketIterator() = default; + + PacketIterator& operator=(const PacketIterator& other) { + ptr_ = other.ptr_; + element_size_ = other.element_size_; + return *this; + } + PacketIterator& operator=(const PacketIterator&& other) { + ptr_ = other.ptr_; + element_size_ = other.element_size_; + return *this; + } + + bool operator==(const PacketIterator& other) const { + RTC_DCHECK_EQ(element_size_, other.element_size_); + return ptr_ == other.ptr_; + } + bool operator!=(const PacketIterator& other) const { + RTC_DCHECK_EQ(element_size_, other.element_size_); + return ptr_ != other.ptr_; + } + + PacketIterator& operator++() { + ptr_ += element_size_; + return *this; + } + PacketIterator& operator--() { + ptr_ -= element_size_; + return *this; + } + PacketIterator operator++(int) { + PacketIterator iter_copy(ptr_, element_size_); + ptr_ += element_size_; + return iter_copy; + } + PacketIterator operator--(int) { + PacketIterator iter_copy(ptr_, element_size_); + ptr_ -= element_size_; + return iter_copy; + } + + T& operator*() { return *reinterpret_cast(ptr_); } + const T& operator*() const { return *reinterpret_cast(ptr_); } + + private: + PacketIterator(typename std::conditional::value, + const void*, + void*>::type p, + size_t s) + : ptr_(reinterpret_cast(p)), element_size_(s) {} + + typename std::conditional::value, const char*, char*>::type + ptr_; + size_t element_size_; +}; + +// Suppose that we have a struct S where we are only interested in a specific +// member M. Given an array of S, PacketView can be used to treat the array +// as an array of M, without exposing the type S to surrounding code and without +// accessing the member through a virtual function. In this case, we want to +// have a common view for incoming and outgoing RtpPackets, hence the PacketView +// name. +// Note that constructing a PacketView bypasses the typesystem, so the caller +// has to take extra care when constructing these objects. The implementation +// also requires that the containing struct is standard-layout (e.g. POD). +// +// Usage example: +// struct A {...}; +// struct B { A a; ...}; +// struct C { A a; ...}; +// size_t len = 10; +// B* array1 = new B[len]; +// C* array2 = new C[len]; +// +// PacketView view1 = PacketView::Create(array1, len, offsetof(B, a)); +// PacketView view2 = PacketView::Create(array2, len, offsetof(C, a)); +// +// The following code works with either view1 or view2. +// void f(PacketView view) +// for (A& a : view) { +// DoSomething(a); +// } +template +class PacketView { + public: + template + static PacketView Create(U* ptr, size_t num_elements, size_t offset) { + static_assert(std::is_standard_layout::value, + "PacketView can only be created for standard layout types."); + static_assert(std::is_standard_layout::value, + "PacketView can only be created for standard layout types."); + return PacketView(ptr, num_elements, offset, sizeof(U)); + } + + using iterator = PacketIterator; + using const_iterator = PacketIterator; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + + iterator begin() { return iterator(data_, element_size_); } + iterator end() { + auto end_ptr = data_ + num_elements_ * element_size_; + return iterator(end_ptr, element_size_); + } + + const_iterator begin() const { return const_iterator(data_, element_size_); } + const_iterator end() const { + auto end_ptr = data_ + num_elements_ * element_size_; + return const_iterator(end_ptr, element_size_); + } + + reverse_iterator rbegin() { return reverse_iterator(end()); } + reverse_iterator rend() { return reverse_iterator(begin()); } + + const_reverse_iterator rbegin() const { + return const_reverse_iterator(end()); + } + const_reverse_iterator rend() const { + return const_reverse_iterator(begin()); + } + + size_t size() const { return num_elements_; } + + T& operator[](size_t i) { + auto elem_ptr = data_ + i * element_size_; + return *reinterpret_cast(elem_ptr); + } + + const T& operator[](size_t i) const { + auto elem_ptr = data_ + i * element_size_; + return *reinterpret_cast(elem_ptr); + } + + private: + PacketView(typename std::conditional::value, + const void*, + void*>::type data, + size_t num_elements, + size_t offset, + size_t element_size) + : data_(reinterpret_cast(data) + offset), + num_elements_(num_elements), + element_size_(element_size) {} + + typename std::conditional::value, const char*, char*>::type + data_; + size_t num_elements_; + size_t element_size_; +}; + +class ParsedRtcEventLog { + friend class RtcEventLogTestHelper; + + public: + enum class MediaType { ANY, AUDIO, VIDEO, DATA }; + enum class UnconfiguredHeaderExtensions { + kDontParse, + kAttemptWebrtcDefaultConfig + }; + + struct LoggedRtpStreamIncoming { + LoggedRtpStreamIncoming(); + LoggedRtpStreamIncoming(const LoggedRtpStreamIncoming&); + ~LoggedRtpStreamIncoming(); + uint32_t ssrc; + std::vector incoming_packets; + }; + + struct LoggedRtpStreamOutgoing { + LoggedRtpStreamOutgoing(); + LoggedRtpStreamOutgoing(const LoggedRtpStreamOutgoing&); + ~LoggedRtpStreamOutgoing(); + uint32_t ssrc; + std::vector outgoing_packets; + }; + + struct LoggedRtpStreamView { + LoggedRtpStreamView(uint32_t ssrc, + const LoggedRtpPacketIncoming* ptr, + size_t num_elements); + LoggedRtpStreamView(uint32_t ssrc, + const LoggedRtpPacketOutgoing* ptr, + size_t num_elements); + LoggedRtpStreamView(const LoggedRtpStreamView&); + uint32_t ssrc; + PacketView packet_view; + }; + + static webrtc::RtpHeaderExtensionMap GetDefaultHeaderExtensionMap(); + + explicit ParsedRtcEventLog( + UnconfiguredHeaderExtensions parse_unconfigured_header_extensions = + UnconfiguredHeaderExtensions::kDontParse); + + ~ParsedRtcEventLog(); + + // Clears previously parsed events and resets the ParsedRtcEventLogNew to an + // empty state. + void Clear(); + + // Reads an RtcEventLog file and returns true if parsing was successful. + bool ParseFile(const std::string& file_name); + + // Reads an RtcEventLog from a string and returns true if successful. + bool ParseString(const std::string& s); + + // Reads an RtcEventLog from an istream and returns true if successful. + bool ParseStream( + std::istream& stream); // no-presubmit-check TODO(webrtc:8982) + + MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const; + + // Configured SSRCs. + const std::set& incoming_rtx_ssrcs() const { + return incoming_rtx_ssrcs_; + } + + const std::set& incoming_video_ssrcs() const { + return incoming_video_ssrcs_; + } + + const std::set& incoming_audio_ssrcs() const { + return incoming_audio_ssrcs_; + } + + const std::set& outgoing_rtx_ssrcs() const { + return outgoing_rtx_ssrcs_; + } + + const std::set& outgoing_video_ssrcs() const { + return outgoing_video_ssrcs_; + } + + const std::set& outgoing_audio_ssrcs() const { + return outgoing_audio_ssrcs_; + } + + // Stream configurations. + const std::vector& audio_recv_configs() const { + return audio_recv_configs_; + } + + const std::vector& audio_send_configs() const { + return audio_send_configs_; + } + + const std::vector& video_recv_configs() const { + return video_recv_configs_; + } + + const std::vector& video_send_configs() const { + return video_send_configs_; + } + + // Beginning and end of log segments. + const std::vector& start_log_events() const { + return start_log_events_; + } + + const std::vector& stop_log_events() const { + return stop_log_events_; + } + + const std::vector& alr_state_events() const { + return alr_state_events_; + } + + // Audio + const std::map>& + audio_playout_events() const { + return audio_playout_events_; + } + + const std::vector& + audio_network_adaptation_events() const { + return audio_network_adaptation_events_; + } + + // Bandwidth estimation + const std::vector& + bwe_probe_cluster_created_events() const { + return bwe_probe_cluster_created_events_; + } + + const std::vector& bwe_probe_failure_events() + const { + return bwe_probe_failure_events_; + } + + const std::vector& bwe_probe_success_events() + const { + return bwe_probe_success_events_; + } + + const std::vector& bwe_delay_updates() const { + return bwe_delay_updates_; + } + + const std::vector& bwe_loss_updates() const { + return bwe_loss_updates_; + } + + // DTLS + const std::vector& dtls_transport_states() const { + return dtls_transport_states_; + } + + const std::vector& dtls_writable_states() const { + return dtls_writable_states_; + } + + // ICE events + const std::vector& ice_candidate_pair_configs() + const { + return ice_candidate_pair_configs_; + } + + const std::vector& ice_candidate_pair_events() + const { + return ice_candidate_pair_events_; + } + + // RTP + const std::vector& incoming_rtp_packets_by_ssrc() + const { + return incoming_rtp_packets_by_ssrc_; + } + + const std::vector& outgoing_rtp_packets_by_ssrc() + const { + return outgoing_rtp_packets_by_ssrc_; + } + + const std::vector& rtp_packets_by_ssrc( + PacketDirection direction) const { + if (direction == kIncomingPacket) + return incoming_rtp_packet_views_by_ssrc_; + else + return outgoing_rtp_packet_views_by_ssrc_; + } + + // RTCP + const std::vector& incoming_rtcp_packets() const { + return incoming_rtcp_packets_; + } + + const std::vector& outgoing_rtcp_packets() const { + return outgoing_rtcp_packets_; + } + + const std::vector& receiver_reports( + PacketDirection direction) const { + if (direction == kIncomingPacket) { + return incoming_rr_; + } else { + return outgoing_rr_; + } + } + + const std::vector& sender_reports( + PacketDirection direction) const { + if (direction == kIncomingPacket) { + return incoming_sr_; + } else { + return outgoing_sr_; + } + } + + const std::vector& nacks( + PacketDirection direction) const { + if (direction == kIncomingPacket) { + return incoming_nack_; + } else { + return outgoing_nack_; + } + } + + const std::vector& rembs( + PacketDirection direction) const { + if (direction == kIncomingPacket) { + return incoming_remb_; + } else { + return outgoing_remb_; + } + } + + const std::vector& transport_feedbacks( + PacketDirection direction) const { + if (direction == kIncomingPacket) { + return incoming_transport_feedback_; + } else { + return outgoing_transport_feedback_; + } + } + + int64_t first_timestamp() const { return first_timestamp_; } + int64_t last_timestamp() const { return last_timestamp_; } + + private: + bool ParseStreamInternal( + std::istream& stream); // no-presubmit-check TODO(webrtc:8982) + + void StoreParsedLegacyEvent(const rtclog::Event& event); + + template + void StoreFirstAndLastTimestamp(const std::vector& v); + + // 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 GetVideoSendConfig(const rtclog::Event& event) const; + rtclog::StreamConfig GetAudioReceiveConfig(const rtclog::Event& event) const; + rtclog::StreamConfig GetAudioSendConfig(const rtclog::Event& event) const; + + LoggedAudioPlayoutEvent GetAudioPlayout(const rtclog::Event& event) const; + + LoggedBweLossBasedUpdate GetLossBasedBweUpdate( + const rtclog::Event& event) const; + LoggedBweDelayBasedUpdate GetDelayBasedBweUpdate( + const rtclog::Event& event) const; + + LoggedAudioNetworkAdaptationEvent GetAudioNetworkAdaptation( + const rtclog::Event& event) const; + + LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated( + 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; + + LoggedIceCandidatePairConfig GetIceCandidatePairConfig( + const rtclog::Event& event) const; + LoggedIceCandidatePairEvent GetIceCandidatePairEvent( + const rtclog::Event& event) const; + + // Parsing functions for new format. + void StoreParsedNewFormatEvent(const rtclog2::EventStream& event); + void StoreIncomingRtpPackets(const rtclog2::IncomingRtpPackets& proto); + void StoreOutgoingRtpPackets(const rtclog2::OutgoingRtpPackets& proto); + void StoreIncomingRtcpPackets(const rtclog2::IncomingRtcpPackets& proto); + void StoreOutgoingRtcpPackets(const rtclog2::OutgoingRtcpPackets& proto); + void StoreStartEvent(const rtclog2::BeginLogEvent& proto); + void StoreStopEvent(const rtclog2::EndLogEvent& proto); + void StoreAlrStateEvent(const rtclog2::AlrState& proto); + void StoreAudioNetworkAdaptationEvent( + const rtclog2::AudioNetworkAdaptations& proto); + void StoreAudioPlayoutEvent(const rtclog2::AudioPlayoutEvents& proto); + void StoreBweLossBasedUpdate(const rtclog2::LossBasedBweUpdates& proto); + void StoreBweDelayBasedUpdate(const rtclog2::DelayBasedBweUpdates& proto); + void StoreBweProbeClusterCreated(const rtclog2::BweProbeCluster& proto); + void StoreBweProbeSuccessEvent(const rtclog2::BweProbeResultSuccess& proto); + void StoreBweProbeFailureEvent(const rtclog2::BweProbeResultFailure& proto); + void StoreDtlsTransportState(const rtclog2::DtlsTransportStateEvent& proto); + void StoreDtlsWritableState(const rtclog2::DtlsWritableState& proto); + void StoreIceCandidatePairConfig( + const rtclog2::IceCandidatePairConfig& proto); + void StoreIceCandidateEvent(const rtclog2::IceCandidatePairEvent& proto); + void StoreAudioRecvConfig(const rtclog2::AudioRecvStreamConfig& proto); + void StoreAudioSendConfig(const rtclog2::AudioSendStreamConfig& proto); + void StoreVideoRecvConfig(const rtclog2::VideoRecvStreamConfig& proto); + void StoreVideoSendConfig(const rtclog2::VideoSendStreamConfig& proto); + // End of new parsing functions. + + struct Stream { + Stream(uint32_t ssrc, + MediaType media_type, + PacketDirection direction, + webrtc::RtpHeaderExtensionMap map) + : ssrc(ssrc), + media_type(media_type), + direction(direction), + rtp_extensions_map(map) {} + uint32_t ssrc; + MediaType media_type; + PacketDirection direction; + webrtc::RtpHeaderExtensionMap rtp_extensions_map; + }; + + const UnconfiguredHeaderExtensions parse_unconfigured_header_extensions_; + + // Make a default extension map for streams without configuration information. + // TODO(ivoc): Once configuration of audio streams is stored in the event log, + // this can be removed. Tracking bug: webrtc:6399 + RtpHeaderExtensionMap default_extension_map_; + + // Tracks what each stream is configured for. Note that a single SSRC can be + // in several sets. For example, the SSRC used for sending video over RTX + // will appear in both video_ssrcs_ and rtx_ssrcs_. In the unlikely case that + // an SSRC is reconfigured to a different media type mid-call, it will also + // appear in multiple sets. + std::set incoming_rtx_ssrcs_; + std::set incoming_video_ssrcs_; + std::set incoming_audio_ssrcs_; + std::set outgoing_rtx_ssrcs_; + std::set outgoing_video_ssrcs_; + std::set outgoing_audio_ssrcs_; + + // Maps an SSRC to the parsed RTP headers in that stream. Header extensions + // are parsed if the stream has been configured. This is only used for + // grouping the events by SSRC during parsing; the events are moved to + // incoming_rtp_packets_by_ssrc_ once the parsing is done. + std::map> + incoming_rtp_packets_map_; + std::map> + outgoing_rtp_packets_map_; + + // RTP headers. + std::vector incoming_rtp_packets_by_ssrc_; + std::vector outgoing_rtp_packets_by_ssrc_; + std::vector incoming_rtp_packet_views_by_ssrc_; + std::vector outgoing_rtp_packet_views_by_ssrc_; + + // Raw RTCP packets. + std::vector incoming_rtcp_packets_; + std::vector outgoing_rtcp_packets_; + + // Parsed RTCP messages. Currently not separated based on SSRC. + std::vector incoming_rr_; + std::vector outgoing_rr_; + std::vector incoming_sr_; + std::vector outgoing_sr_; + std::vector incoming_nack_; + std::vector outgoing_nack_; + std::vector incoming_remb_; + std::vector outgoing_remb_; + std::vector incoming_transport_feedback_; + std::vector outgoing_transport_feedback_; + + std::vector start_log_events_; + std::vector stop_log_events_; + + std::vector alr_state_events_; + + std::map> + audio_playout_events_; + + std::vector + audio_network_adaptation_events_; + + std::vector + bwe_probe_cluster_created_events_; + + std::vector bwe_probe_failure_events_; + std::vector bwe_probe_success_events_; + + std::vector bwe_delay_updates_; + std::vector bwe_loss_updates_; + + std::vector dtls_transport_states_; + std::vector dtls_writable_states_; + + std::vector ice_candidate_pair_configs_; + std::vector ice_candidate_pair_events_; + + std::vector audio_recv_configs_; + std::vector audio_send_configs_; + std::vector video_recv_configs_; + std::vector video_send_configs_; + + uint8_t last_incoming_rtcp_packet_[IP_PACKET_SIZE]; + uint8_t last_incoming_rtcp_packet_length_; + + int64_t first_timestamp_; + int64_t last_timestamp_; + + // The extension maps are mutable to allow us to insert the default + // configuration when parsing an RTP header for an unconfigured stream. + // TODO(terelius): This is only used for the legacy format. Remove once we've + // fully transitioned to the new format. + mutable std::map + incoming_rtp_extensions_maps_; + mutable std::map + outgoing_rtp_extensions_maps_; +}; + +struct MatchedSendArrivalTimes { + MatchedSendArrivalTimes(int64_t fb, int64_t tx, int64_t rx, int64_t ps) + : feedback_arrival_time_ms(fb), + send_time_ms(tx), + arrival_time_ms(rx), + payload_size(ps) {} + + int64_t feedback_arrival_time_ms; + int64_t send_time_ms; // PacketFeedback::kNoSendTime for late feedback. + int64_t arrival_time_ms; // PacketFeedback::kNotReceived for lost packets. + int64_t payload_size; +}; +const std::vector GetNetworkTrace( + const ParsedRtcEventLog& parsed_log); + +} // namespace webrtc + +#endif // LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_ 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 0ee70a54ec..158a1d8167 100644 --- a/logging/rtc_event_log/rtc_event_log_parser_new.h +++ b/logging/rtc_event_log/rtc_event_log_parser_new.h @@ -9,678 +9,9 @@ */ #ifndef LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_NEW_H_ #define LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_NEW_H_ - -#include -#include -#include -#include // no-presubmit-check TODO(webrtc:8982) -#include -#include // pair -#include - -#include "call/video_receive_stream.h" -#include "call/video_send_stream.h" -#include "logging/rtc_event_log/logged_events.h" -#include "logging/rtc_event_log/rtc_event_log.h" -#include "modules/rtp_rtcp/include/rtp_header_extension_map.h" -#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h" -#include "rtc_base/ignore_wundef.h" - -// Files generated at build-time by the protobuf compiler. -RTC_PUSH_IGNORING_WUNDEF() -#ifdef WEBRTC_ANDROID_PLATFORM_BUILD -#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h" -#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log2.pb.h" -#else -#include "logging/rtc_event_log/rtc_event_log.pb.h" -#include "logging/rtc_event_log/rtc_event_log2.pb.h" -#endif -RTC_POP_IGNORING_WUNDEF() - +#include "logging/rtc_event_log/rtc_event_log_parser.h" +#include "rtc_base/deprecation.h" namespace webrtc { - -template -class PacketView; - -template -class PacketIterator { - friend class PacketView; - - public: - // Standard iterator traits. - using difference_type = std::ptrdiff_t; - using value_type = T; - using pointer = T*; - using reference = T&; - using iterator_category = std::bidirectional_iterator_tag; - - // The default-contructed iterator is meaningless, but is required by the - // ForwardIterator concept. - PacketIterator() : ptr_(nullptr), element_size_(0) {} - PacketIterator(const PacketIterator& other) - : ptr_(other.ptr_), element_size_(other.element_size_) {} - PacketIterator(const PacketIterator&& other) - : ptr_(other.ptr_), element_size_(other.element_size_) {} - ~PacketIterator() = default; - - PacketIterator& operator=(const PacketIterator& other) { - ptr_ = other.ptr_; - element_size_ = other.element_size_; - return *this; - } - PacketIterator& operator=(const PacketIterator&& other) { - ptr_ = other.ptr_; - element_size_ = other.element_size_; - return *this; - } - - bool operator==(const PacketIterator& other) const { - RTC_DCHECK_EQ(element_size_, other.element_size_); - return ptr_ == other.ptr_; - } - bool operator!=(const PacketIterator& other) const { - RTC_DCHECK_EQ(element_size_, other.element_size_); - return ptr_ != other.ptr_; - } - - PacketIterator& operator++() { - ptr_ += element_size_; - return *this; - } - PacketIterator& operator--() { - ptr_ -= element_size_; - return *this; - } - PacketIterator operator++(int) { - PacketIterator iter_copy(ptr_, element_size_); - ptr_ += element_size_; - return iter_copy; - } - PacketIterator operator--(int) { - PacketIterator iter_copy(ptr_, element_size_); - ptr_ -= element_size_; - return iter_copy; - } - - T& operator*() { return *reinterpret_cast(ptr_); } - const T& operator*() const { return *reinterpret_cast(ptr_); } - - private: - PacketIterator(typename std::conditional::value, - const void*, - void*>::type p, - size_t s) - : ptr_(reinterpret_cast(p)), element_size_(s) {} - - typename std::conditional::value, const char*, char*>::type - ptr_; - size_t element_size_; -}; - -// Suppose that we have a struct S where we are only interested in a specific -// member M. Given an array of S, PacketView can be used to treat the array -// as an array of M, without exposing the type S to surrounding code and without -// accessing the member through a virtual function. In this case, we want to -// have a common view for incoming and outgoing RtpPackets, hence the PacketView -// name. -// Note that constructing a PacketView bypasses the typesystem, so the caller -// has to take extra care when constructing these objects. The implementation -// also requires that the containing struct is standard-layout (e.g. POD). -// -// Usage example: -// struct A {...}; -// struct B { A a; ...}; -// struct C { A a; ...}; -// size_t len = 10; -// B* array1 = new B[len]; -// C* array2 = new C[len]; -// -// PacketView view1 = PacketView::Create(array1, len, offsetof(B, a)); -// PacketView view2 = PacketView::Create(array2, len, offsetof(C, a)); -// -// The following code works with either view1 or view2. -// void f(PacketView view) -// for (A& a : view) { -// DoSomething(a); -// } -template -class PacketView { - public: - template - static PacketView Create(U* ptr, size_t num_elements, size_t offset) { - static_assert(std::is_standard_layout::value, - "PacketView can only be created for standard layout types."); - static_assert(std::is_standard_layout::value, - "PacketView can only be created for standard layout types."); - return PacketView(ptr, num_elements, offset, sizeof(U)); - } - - using iterator = PacketIterator; - using const_iterator = PacketIterator; - using reverse_iterator = std::reverse_iterator; - using const_reverse_iterator = std::reverse_iterator; - - iterator begin() { return iterator(data_, element_size_); } - iterator end() { - auto end_ptr = data_ + num_elements_ * element_size_; - return iterator(end_ptr, element_size_); - } - - const_iterator begin() const { return const_iterator(data_, element_size_); } - const_iterator end() const { - auto end_ptr = data_ + num_elements_ * element_size_; - return const_iterator(end_ptr, element_size_); - } - - reverse_iterator rbegin() { return reverse_iterator(end()); } - reverse_iterator rend() { return reverse_iterator(begin()); } - - const_reverse_iterator rbegin() const { - return const_reverse_iterator(end()); - } - const_reverse_iterator rend() const { - return const_reverse_iterator(begin()); - } - - size_t size() const { return num_elements_; } - - T& operator[](size_t i) { - auto elem_ptr = data_ + i * element_size_; - return *reinterpret_cast(elem_ptr); - } - - const T& operator[](size_t i) const { - auto elem_ptr = data_ + i * element_size_; - return *reinterpret_cast(elem_ptr); - } - - private: - PacketView(typename std::conditional::value, - const void*, - void*>::type data, - size_t num_elements, - size_t offset, - size_t element_size) - : data_(reinterpret_cast(data) + offset), - num_elements_(num_elements), - element_size_(element_size) {} - - typename std::conditional::value, const char*, char*>::type - data_; - size_t num_elements_; - size_t element_size_; -}; - -class ParsedRtcEventLogNew { - friend class RtcEventLogTestHelper; - - public: - enum class MediaType { ANY, AUDIO, VIDEO, DATA }; - enum class UnconfiguredHeaderExtensions { - kDontParse, - kAttemptWebrtcDefaultConfig - }; - - struct LoggedRtpStreamIncoming { - LoggedRtpStreamIncoming(); - LoggedRtpStreamIncoming(const LoggedRtpStreamIncoming&); - ~LoggedRtpStreamIncoming(); - uint32_t ssrc; - std::vector incoming_packets; - }; - - struct LoggedRtpStreamOutgoing { - LoggedRtpStreamOutgoing(); - LoggedRtpStreamOutgoing(const LoggedRtpStreamOutgoing&); - ~LoggedRtpStreamOutgoing(); - uint32_t ssrc; - std::vector outgoing_packets; - }; - - struct LoggedRtpStreamView { - LoggedRtpStreamView(uint32_t ssrc, - const LoggedRtpPacketIncoming* ptr, - size_t num_elements); - LoggedRtpStreamView(uint32_t ssrc, - const LoggedRtpPacketOutgoing* ptr, - size_t num_elements); - LoggedRtpStreamView(const LoggedRtpStreamView&); - uint32_t ssrc; - PacketView packet_view; - }; - - static webrtc::RtpHeaderExtensionMap GetDefaultHeaderExtensionMap(); - - explicit ParsedRtcEventLogNew( - UnconfiguredHeaderExtensions parse_unconfigured_header_extensions = - UnconfiguredHeaderExtensions::kDontParse); - - ~ParsedRtcEventLogNew(); - - // Clears previously parsed events and resets the ParsedRtcEventLogNew to an - // empty state. - void Clear(); - - // Reads an RtcEventLog file and returns true if parsing was successful. - bool ParseFile(const std::string& file_name); - - // Reads an RtcEventLog from a string and returns true if successful. - bool ParseString(const std::string& s); - - // Reads an RtcEventLog from an istream and returns true if successful. - bool ParseStream( - std::istream& stream); // no-presubmit-check TODO(webrtc:8982) - - MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const; - - // Configured SSRCs. - const std::set& incoming_rtx_ssrcs() const { - return incoming_rtx_ssrcs_; - } - - const std::set& incoming_video_ssrcs() const { - return incoming_video_ssrcs_; - } - - const std::set& incoming_audio_ssrcs() const { - return incoming_audio_ssrcs_; - } - - const std::set& outgoing_rtx_ssrcs() const { - return outgoing_rtx_ssrcs_; - } - - const std::set& outgoing_video_ssrcs() const { - return outgoing_video_ssrcs_; - } - - const std::set& outgoing_audio_ssrcs() const { - return outgoing_audio_ssrcs_; - } - - // Stream configurations. - const std::vector& audio_recv_configs() const { - return audio_recv_configs_; - } - - const std::vector& audio_send_configs() const { - return audio_send_configs_; - } - - const std::vector& video_recv_configs() const { - return video_recv_configs_; - } - - const std::vector& video_send_configs() const { - return video_send_configs_; - } - - // Beginning and end of log segments. - const std::vector& start_log_events() const { - return start_log_events_; - } - - const std::vector& stop_log_events() const { - return stop_log_events_; - } - - const std::vector& alr_state_events() const { - return alr_state_events_; - } - - // Audio - const std::map>& - audio_playout_events() const { - return audio_playout_events_; - } - - const std::vector& - audio_network_adaptation_events() const { - return audio_network_adaptation_events_; - } - - // Bandwidth estimation - const std::vector& - bwe_probe_cluster_created_events() const { - return bwe_probe_cluster_created_events_; - } - - const std::vector& bwe_probe_failure_events() - const { - return bwe_probe_failure_events_; - } - - const std::vector& bwe_probe_success_events() - const { - return bwe_probe_success_events_; - } - - const std::vector& bwe_delay_updates() const { - return bwe_delay_updates_; - } - - const std::vector& bwe_loss_updates() const { - return bwe_loss_updates_; - } - - // DTLS - const std::vector& dtls_transport_states() const { - return dtls_transport_states_; - } - - const std::vector& dtls_writable_states() const { - return dtls_writable_states_; - } - - // ICE events - const std::vector& ice_candidate_pair_configs() - const { - return ice_candidate_pair_configs_; - } - - const std::vector& ice_candidate_pair_events() - const { - return ice_candidate_pair_events_; - } - - // RTP - const std::vector& incoming_rtp_packets_by_ssrc() - const { - return incoming_rtp_packets_by_ssrc_; - } - - const std::vector& outgoing_rtp_packets_by_ssrc() - const { - return outgoing_rtp_packets_by_ssrc_; - } - - const std::vector& rtp_packets_by_ssrc( - PacketDirection direction) const { - if (direction == kIncomingPacket) - return incoming_rtp_packet_views_by_ssrc_; - else - return outgoing_rtp_packet_views_by_ssrc_; - } - - // RTCP - const std::vector& incoming_rtcp_packets() const { - return incoming_rtcp_packets_; - } - - const std::vector& outgoing_rtcp_packets() const { - return outgoing_rtcp_packets_; - } - - const std::vector& receiver_reports( - PacketDirection direction) const { - if (direction == kIncomingPacket) { - return incoming_rr_; - } else { - return outgoing_rr_; - } - } - - const std::vector& sender_reports( - PacketDirection direction) const { - if (direction == kIncomingPacket) { - return incoming_sr_; - } else { - return outgoing_sr_; - } - } - - const std::vector& nacks( - PacketDirection direction) const { - if (direction == kIncomingPacket) { - return incoming_nack_; - } else { - return outgoing_nack_; - } - } - - const std::vector& rembs( - PacketDirection direction) const { - if (direction == kIncomingPacket) { - return incoming_remb_; - } else { - return outgoing_remb_; - } - } - - const std::vector& transport_feedbacks( - PacketDirection direction) const { - if (direction == kIncomingPacket) { - return incoming_transport_feedback_; - } else { - return outgoing_transport_feedback_; - } - } - - int64_t first_timestamp() const { return first_timestamp_; } - int64_t last_timestamp() const { return last_timestamp_; } - - private: - bool ParseStreamInternal( - std::istream& stream); // no-presubmit-check TODO(webrtc:8982) - - void StoreParsedLegacyEvent(const rtclog::Event& event); - - template - void StoreFirstAndLastTimestamp(const std::vector& v); - - // 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 GetVideoSendConfig(const rtclog::Event& event) const; - rtclog::StreamConfig GetAudioReceiveConfig(const rtclog::Event& event) const; - rtclog::StreamConfig GetAudioSendConfig(const rtclog::Event& event) const; - - LoggedAudioPlayoutEvent GetAudioPlayout(const rtclog::Event& event) const; - - LoggedBweLossBasedUpdate GetLossBasedBweUpdate( - const rtclog::Event& event) const; - LoggedBweDelayBasedUpdate GetDelayBasedBweUpdate( - const rtclog::Event& event) const; - - LoggedAudioNetworkAdaptationEvent GetAudioNetworkAdaptation( - const rtclog::Event& event) const; - - LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated( - 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; - - LoggedIceCandidatePairConfig GetIceCandidatePairConfig( - const rtclog::Event& event) const; - LoggedIceCandidatePairEvent GetIceCandidatePairEvent( - const rtclog::Event& event) const; - - // Parsing functions for new format. - void StoreParsedNewFormatEvent(const rtclog2::EventStream& event); - void StoreIncomingRtpPackets(const rtclog2::IncomingRtpPackets& proto); - void StoreOutgoingRtpPackets(const rtclog2::OutgoingRtpPackets& proto); - void StoreIncomingRtcpPackets(const rtclog2::IncomingRtcpPackets& proto); - void StoreOutgoingRtcpPackets(const rtclog2::OutgoingRtcpPackets& proto); - void StoreStartEvent(const rtclog2::BeginLogEvent& proto); - void StoreStopEvent(const rtclog2::EndLogEvent& proto); - void StoreAlrStateEvent(const rtclog2::AlrState& proto); - void StoreAudioNetworkAdaptationEvent( - const rtclog2::AudioNetworkAdaptations& proto); - void StoreAudioPlayoutEvent(const rtclog2::AudioPlayoutEvents& proto); - void StoreBweLossBasedUpdate(const rtclog2::LossBasedBweUpdates& proto); - void StoreBweDelayBasedUpdate(const rtclog2::DelayBasedBweUpdates& proto); - void StoreBweProbeClusterCreated(const rtclog2::BweProbeCluster& proto); - void StoreBweProbeSuccessEvent(const rtclog2::BweProbeResultSuccess& proto); - void StoreBweProbeFailureEvent(const rtclog2::BweProbeResultFailure& proto); - void StoreDtlsTransportState(const rtclog2::DtlsTransportStateEvent& proto); - void StoreDtlsWritableState(const rtclog2::DtlsWritableState& proto); - void StoreIceCandidatePairConfig( - const rtclog2::IceCandidatePairConfig& proto); - void StoreIceCandidateEvent(const rtclog2::IceCandidatePairEvent& proto); - void StoreAudioRecvConfig(const rtclog2::AudioRecvStreamConfig& proto); - void StoreAudioSendConfig(const rtclog2::AudioSendStreamConfig& proto); - void StoreVideoRecvConfig(const rtclog2::VideoRecvStreamConfig& proto); - void StoreVideoSendConfig(const rtclog2::VideoSendStreamConfig& proto); - // End of new parsing functions. - - struct Stream { - Stream(uint32_t ssrc, - MediaType media_type, - PacketDirection direction, - webrtc::RtpHeaderExtensionMap map) - : ssrc(ssrc), - media_type(media_type), - direction(direction), - rtp_extensions_map(map) {} - uint32_t ssrc; - MediaType media_type; - PacketDirection direction; - webrtc::RtpHeaderExtensionMap rtp_extensions_map; - }; - - const UnconfiguredHeaderExtensions parse_unconfigured_header_extensions_; - - // Make a default extension map for streams without configuration information. - // TODO(ivoc): Once configuration of audio streams is stored in the event log, - // this can be removed. Tracking bug: webrtc:6399 - RtpHeaderExtensionMap default_extension_map_; - - // Tracks what each stream is configured for. Note that a single SSRC can be - // in several sets. For example, the SSRC used for sending video over RTX - // will appear in both video_ssrcs_ and rtx_ssrcs_. In the unlikely case that - // an SSRC is reconfigured to a different media type mid-call, it will also - // appear in multiple sets. - std::set incoming_rtx_ssrcs_; - std::set incoming_video_ssrcs_; - std::set incoming_audio_ssrcs_; - std::set outgoing_rtx_ssrcs_; - std::set outgoing_video_ssrcs_; - std::set outgoing_audio_ssrcs_; - - // Maps an SSRC to the parsed RTP headers in that stream. Header extensions - // are parsed if the stream has been configured. This is only used for - // grouping the events by SSRC during parsing; the events are moved to - // incoming_rtp_packets_by_ssrc_ once the parsing is done. - std::map> - incoming_rtp_packets_map_; - std::map> - outgoing_rtp_packets_map_; - - // RTP headers. - std::vector incoming_rtp_packets_by_ssrc_; - std::vector outgoing_rtp_packets_by_ssrc_; - std::vector incoming_rtp_packet_views_by_ssrc_; - std::vector outgoing_rtp_packet_views_by_ssrc_; - - // Raw RTCP packets. - std::vector incoming_rtcp_packets_; - std::vector outgoing_rtcp_packets_; - - // Parsed RTCP messages. Currently not separated based on SSRC. - std::vector incoming_rr_; - std::vector outgoing_rr_; - std::vector incoming_sr_; - std::vector outgoing_sr_; - std::vector incoming_nack_; - std::vector outgoing_nack_; - std::vector incoming_remb_; - std::vector outgoing_remb_; - std::vector incoming_transport_feedback_; - std::vector outgoing_transport_feedback_; - - std::vector start_log_events_; - std::vector stop_log_events_; - - std::vector alr_state_events_; - - std::map> - audio_playout_events_; - - std::vector - audio_network_adaptation_events_; - - std::vector - bwe_probe_cluster_created_events_; - - std::vector bwe_probe_failure_events_; - std::vector bwe_probe_success_events_; - - std::vector bwe_delay_updates_; - std::vector bwe_loss_updates_; - - std::vector dtls_transport_states_; - std::vector dtls_writable_states_; - - std::vector ice_candidate_pair_configs_; - std::vector ice_candidate_pair_events_; - - std::vector audio_recv_configs_; - std::vector audio_send_configs_; - std::vector video_recv_configs_; - std::vector video_send_configs_; - - uint8_t last_incoming_rtcp_packet_[IP_PACKET_SIZE]; - uint8_t last_incoming_rtcp_packet_length_; - - int64_t first_timestamp_; - int64_t last_timestamp_; - - // The extension maps are mutable to allow us to insert the default - // configuration when parsing an RTP header for an unconfigured stream. - // TODO(terelius): This is only used for the legacy format. Remove once we've - // fully transitioned to the new format. - mutable std::map - incoming_rtp_extensions_maps_; - mutable std::map - outgoing_rtp_extensions_maps_; -}; - -struct MatchedSendArrivalTimes { - MatchedSendArrivalTimes(int64_t fb, int64_t tx, int64_t rx, int64_t ps) - : feedback_arrival_time_ms(fb), - send_time_ms(tx), - arrival_time_ms(rx), - payload_size(ps) {} - - int64_t feedback_arrival_time_ms; - int64_t send_time_ms; // PacketFeedback::kNoSendTime for late feedback. - int64_t arrival_time_ms; // PacketFeedback::kNotReceived for lost packets. - int64_t payload_size; -}; -const std::vector GetNetworkTrace( - const ParsedRtcEventLogNew& parsed_log); - -} // namespace webrtc - +using ParsedRtcEventLogNew RTC_DEPRECATED = ParsedRtcEventLog; +} #endif // LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_NEW_H_ diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc index a89de54dcf..842687ef41 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest.cc +++ b/logging/rtc_event_log/rtc_event_log_unittest.cc @@ -37,7 +37,7 @@ #include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h" #include "logging/rtc_event_log/output/rtc_event_log_output_file.h" #include "logging/rtc_event_log/rtc_event_log.h" -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include "logging/rtc_event_log/rtc_event_log_unittest_helper.h" #include "logging/rtc_event_log/rtc_stream_config.h" #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" @@ -498,7 +498,7 @@ void RtcEventLogSession::WriteLog(EventCounts count, // same as what we wrote down. void RtcEventLogSession::ReadAndVerifyLog() { // Read the generated file from disk. - ParsedRtcEventLogNew parsed_log; + ParsedRtcEventLog parsed_log; ASSERT_TRUE(parsed_log.ParseFile(temp_filename_)); // Start and stop events. @@ -785,7 +785,7 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) { log_dumper->StopLogging(); // Read the generated file from disk. - ParsedRtcEventLogNew parsed_log; + ParsedRtcEventLog parsed_log; ASSERT_TRUE(parsed_log.ParseFile(temp_filename)); const auto& start_log_events = parsed_log.start_log_events(); diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.h b/logging/rtc_event_log/rtc_event_log_unittest_helper.h index a840371e0a..61b202c26d 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.h +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.h @@ -35,7 +35,7 @@ #include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h" #include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h" #include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h" -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include "logging/rtc_event_log/rtc_stream_config.h" #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" diff --git a/logging/rtc_event_log/rtc_event_processor_unittest.cc b/logging/rtc_event_log/rtc_event_processor_unittest.cc index 8409adfe51..dac3bb61a5 100644 --- a/logging/rtc_event_log/rtc_event_processor_unittest.cc +++ b/logging/rtc_event_log/rtc_event_processor_unittest.cc @@ -16,7 +16,7 @@ #include #include "absl/memory/memory.h" -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include "rtc_base/checks.h" #include "rtc_base/random.h" #include "test/gtest.h" 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 0110b8cbd9..446a1a9ee2 100644 --- a/modules/audio_coding/neteq/tools/rtc_event_log_source.cc +++ b/modules/audio_coding/neteq/tools/rtc_event_log_source.cc @@ -24,10 +24,10 @@ namespace webrtc { namespace test { namespace { -bool ShouldSkipStream(ParsedRtcEventLogNew::MediaType media_type, +bool ShouldSkipStream(ParsedRtcEventLog::MediaType media_type, uint32_t ssrc, absl::optional ssrc_filter) { - if (media_type != ParsedRtcEventLogNew::MediaType::AUDIO) + if (media_type != ParsedRtcEventLog::MediaType::AUDIO) return true; if (ssrc_filter.has_value() && ssrc != *ssrc_filter) return true; @@ -65,7 +65,7 @@ RtcEventLogSource::RtcEventLogSource() : PacketSource() {} bool RtcEventLogSource::OpenFile(const std::string& file_name, absl::optional ssrc_filter) { - ParsedRtcEventLogNew parsed_log; + ParsedRtcEventLog parsed_log; if (!parsed_log.ParseFile(file_name)) return false; @@ -104,7 +104,7 @@ bool RtcEventLogSource::OpenFile(const std::string& file_name, // This wouldn't be needed if we knew that there was at most one audio stream. webrtc::RtcEventProcessor event_processor; for (const auto& rtp_packets : parsed_log.incoming_rtp_packets_by_ssrc()) { - ParsedRtcEventLogNew::MediaType media_type = + ParsedRtcEventLog::MediaType media_type = parsed_log.GetMediaType(rtp_packets.ssrc, webrtc::kIncomingPacket); if (ShouldSkipStream(media_type, rtp_packets.ssrc, ssrc_filter)) { continue; diff --git a/modules/audio_coding/neteq/tools/rtc_event_log_source.h b/modules/audio_coding/neteq/tools/rtc_event_log_source.h index 6b761f7dbb..ea620da959 100644 --- a/modules/audio_coding/neteq/tools/rtc_event_log_source.h +++ b/modules/audio_coding/neteq/tools/rtc_event_log_source.h @@ -16,7 +16,7 @@ #include #include "absl/types/optional.h" -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include "modules/audio_coding/neteq/tools/packet_source.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "rtc_base/constructormagic.h" diff --git a/rtc_tools/event_log_visualizer/analyzer.cc b/rtc_tools/event_log_visualizer/analyzer.cc index cae810c185..2d1e908c55 100644 --- a/rtc_tools/event_log_visualizer/analyzer.cc +++ b/rtc_tools/event_log_visualizer/analyzer.cc @@ -445,7 +445,7 @@ std::string GetDirectionAsShortString(PacketDirection direction) { } // namespace -EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLogNew& log, +EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log, bool normalize_time) : parsed_log_(log), window_duration_(250000), diff --git a/rtc_tools/event_log_visualizer/analyzer.h b/rtc_tools/event_log_visualizer/analyzer.h index 35a44b903f..976598bfba 100644 --- a/rtc_tools/event_log_visualizer/analyzer.h +++ b/rtc_tools/event_log_visualizer/analyzer.h @@ -18,7 +18,7 @@ #include #include -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include "modules/audio_coding/neteq/tools/neteq_stats_getter.h" #include "rtc_base/strings/string_builder.h" #include "rtc_tools/event_log_visualizer/plot_base.h" @@ -31,7 +31,7 @@ class EventLogAnalyzer { // The EventLogAnalyzer keeps a reference to the ParsedRtcEventLogNew for the // duration of its lifetime. The ParsedRtcEventLogNew must not be destroyed or // modified while the EventLogAnalyzer is being used. - EventLogAnalyzer(const ParsedRtcEventLogNew& log, bool normalize_time); + EventLogAnalyzer(const ParsedRtcEventLog& log, bool normalize_time); void CreatePacketGraph(PacketDirection direction, Plot* plot); @@ -223,7 +223,7 @@ class EventLogAnalyzer { std::string GetCandidatePairLogDescriptionFromId(uint32_t candidate_pair_id); - const ParsedRtcEventLogNew& parsed_log_; + const ParsedRtcEventLog& parsed_log_; // A list of SSRCs we are interested in analysing. // If left empty, all SSRCs will be considered relevant. diff --git a/rtc_tools/event_log_visualizer/main.cc b/rtc_tools/event_log_visualizer/main.cc index 4808f9dad0..8c92be5ae9 100644 --- a/rtc_tools/event_log_visualizer/main.cc +++ b/rtc_tools/event_log_visualizer/main.cc @@ -17,7 +17,7 @@ #include #include "logging/rtc_event_log/rtc_event_log.h" -#include "logging/rtc_event_log/rtc_event_log_parser_new.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" #include "modules/audio_coding/neteq/include/neteq.h" #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h" #include "rtc_base/checks.h" @@ -258,13 +258,13 @@ int main(int argc, char* argv[]) { std::string filename = argv[1]; - webrtc::ParsedRtcEventLogNew::UnconfiguredHeaderExtensions header_extensions = - webrtc::ParsedRtcEventLogNew::UnconfiguredHeaderExtensions::kDontParse; + webrtc::ParsedRtcEventLog::UnconfiguredHeaderExtensions header_extensions = + webrtc::ParsedRtcEventLog::UnconfiguredHeaderExtensions::kDontParse; if (FLAG_parse_unconfigured_header_extensions) { - header_extensions = webrtc::ParsedRtcEventLogNew:: + header_extensions = webrtc::ParsedRtcEventLog:: UnconfiguredHeaderExtensions::kAttemptWebrtcDefaultConfig; } - webrtc::ParsedRtcEventLogNew parsed_log(header_extensions); + webrtc::ParsedRtcEventLog parsed_log(header_extensions); if (!parsed_log.ParseFile(filename)) { std::cerr << "Could not parse the entire log file." << std::endl;