Renames RtcEventLogParseNew to RtcEventLogParser
Bug: webrtc:10170
Change-Id: I9232c276229a64fa4d8321b6c996387fe130f68b
Reviewed-on: https://webrtc-review.googlesource.com/c/116064
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Minyue Li <minyue@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26128}diff --git a/logging/BUILD.gn b/logging/BUILD.gn
index 3eda875..edb1b86 100644
--- a/logging/BUILD.gn
+++ b/logging/BUILD.gn
@@ -291,7 +291,8 @@
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 @@
"../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 7054365..2225d87 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 @@
template <typename ParsedType>
const std::vector<ParsedType>* GetRtpPacketsBySsrc(
- const ParsedRtcEventLogNew* parsed_log,
+ const ParsedRtcEventLog* parsed_log,
uint32_t ssrc);
template <typename EventType, typename ParsedType>
@@ -82,7 +82,7 @@
std::deque<std::unique_ptr<RtcEvent>> history_;
std::unique_ptr<RtcEventLogEncoder> encoder_;
- ParsedRtcEventLogNew parsed_log_;
+ ParsedRtcEventLog parsed_log_;
const uint64_t seed_;
Random prng_;
const bool new_encoding_;
@@ -128,9 +128,8 @@
template <>
const std::vector<LoggedRtpPacketIncoming>*
-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 @@
template <>
const std::vector<LoggedRtpPacketOutgoing>*
-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 e6608e2..c446212 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 @@
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 @@
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 79747b0..d0f9f2b 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 <stdint.h>
#include <string.h>
@@ -788,23 +788,21 @@
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 @@
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 @@
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 @@
// 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<AudioLevel>(webrtc::RtpExtension::kAudioLevelDefaultId);
default_map.Register<TransmissionOffset>(
@@ -853,14 +851,14 @@
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 @@
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 @@
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 @@
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<char> buffer(0xFFFF);
@@ -1128,14 +1126,14 @@
}
template <typename T>
-void ParsedRtcEventLogNew::StoreFirstAndLastTimestamp(const std::vector<T>& v) {
+void ParsedRtcEventLog::StoreFirstAndLastTimestamp(const std::vector<T>& 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 @@
}
}
-
-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 @@
}
// 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 @@
}
}
-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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
}
const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
- const ParsedRtcEventLogNew& parsed_log) {
+ const ParsedRtcEventLog& parsed_log) {
using RtpPacketType = LoggedRtpPacketOutgoing;
using TransportFeedbackType = LoggedRtcpPacketTransportFeedback;
@@ -1856,7 +1851,7 @@
}
// 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::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 @@
// 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::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 @@
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::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::StoreBweProbeClusterCreated(
+void ParsedRtcEventLog::StoreBweProbeClusterCreated(
const rtclog2::BweProbeCluster& proto) {
LoggedBweProbeClusterCreatedEvent probe_cluster;
RTC_CHECK(proto.has_timestamp_ms());
@@ -2167,7 +2161,7 @@
// 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 @@
// 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 @@
// 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::StoreDtlsTransportState(
+void ParsedRtcEventLog::StoreDtlsTransportState(
const rtclog2::DtlsTransportStateEvent& proto) {
LoggedDtlsTransportState dtls_state;
RTC_CHECK(proto.has_timestamp_ms());
@@ -2363,7 +2357,7 @@
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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 0000000..f7e896d
--- /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 <iterator>
+#include <map>
+#include <set>
+#include <sstream> // no-presubmit-check TODO(webrtc:8982)
+#include <string>
+#include <utility> // pair
+#include <vector>
+
+#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 <typename T>
+class PacketView;
+
+template <typename T>
+class PacketIterator {
+ friend class PacketView<T>;
+
+ 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<T>& other) const {
+ RTC_DCHECK_EQ(element_size_, other.element_size_);
+ return ptr_ == other.ptr_;
+ }
+ bool operator!=(const PacketIterator<T>& 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<T*>(ptr_); }
+ const T& operator*() const { return *reinterpret_cast<const T*>(ptr_); }
+
+ private:
+ PacketIterator(typename std::conditional<std::is_const<T>::value,
+ const void*,
+ void*>::type p,
+ size_t s)
+ : ptr_(reinterpret_cast<decltype(ptr_)>(p)), element_size_(s) {}
+
+ typename std::conditional<std::is_const<T>::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<A> view1 = PacketView<A>::Create<B>(array1, len, offsetof(B, a));
+// PacketView<A> view2 = PacketView<A>::Create<C>(array2, len, offsetof(C, a));
+//
+// The following code works with either view1 or view2.
+// void f(PacketView<A> view)
+// for (A& a : view) {
+// DoSomething(a);
+// }
+template <typename T>
+class PacketView {
+ public:
+ template <typename U>
+ static PacketView Create(U* ptr, size_t num_elements, size_t offset) {
+ static_assert(std::is_standard_layout<U>::value,
+ "PacketView can only be created for standard layout types.");
+ static_assert(std::is_standard_layout<T>::value,
+ "PacketView can only be created for standard layout types.");
+ return PacketView(ptr, num_elements, offset, sizeof(U));
+ }
+
+ using iterator = PacketIterator<T>;
+ using const_iterator = PacketIterator<const T>;
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_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<T*>(elem_ptr);
+ }
+
+ const T& operator[](size_t i) const {
+ auto elem_ptr = data_ + i * element_size_;
+ return *reinterpret_cast<const T*>(elem_ptr);
+ }
+
+ private:
+ PacketView(typename std::conditional<std::is_const<T>::value,
+ const void*,
+ void*>::type data,
+ size_t num_elements,
+ size_t offset,
+ size_t element_size)
+ : data_(reinterpret_cast<decltype(data_)>(data) + offset),
+ num_elements_(num_elements),
+ element_size_(element_size) {}
+
+ typename std::conditional<std::is_const<T>::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<LoggedRtpPacketIncoming> incoming_packets;
+ };
+
+ struct LoggedRtpStreamOutgoing {
+ LoggedRtpStreamOutgoing();
+ LoggedRtpStreamOutgoing(const LoggedRtpStreamOutgoing&);
+ ~LoggedRtpStreamOutgoing();
+ uint32_t ssrc;
+ std::vector<LoggedRtpPacketOutgoing> 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<const LoggedRtpPacket> 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<uint32_t>& incoming_rtx_ssrcs() const {
+ return incoming_rtx_ssrcs_;
+ }
+
+ const std::set<uint32_t>& incoming_video_ssrcs() const {
+ return incoming_video_ssrcs_;
+ }
+
+ const std::set<uint32_t>& incoming_audio_ssrcs() const {
+ return incoming_audio_ssrcs_;
+ }
+
+ const std::set<uint32_t>& outgoing_rtx_ssrcs() const {
+ return outgoing_rtx_ssrcs_;
+ }
+
+ const std::set<uint32_t>& outgoing_video_ssrcs() const {
+ return outgoing_video_ssrcs_;
+ }
+
+ const std::set<uint32_t>& outgoing_audio_ssrcs() const {
+ return outgoing_audio_ssrcs_;
+ }
+
+ // Stream configurations.
+ const std::vector<LoggedAudioRecvConfig>& audio_recv_configs() const {
+ return audio_recv_configs_;
+ }
+
+ const std::vector<LoggedAudioSendConfig>& audio_send_configs() const {
+ return audio_send_configs_;
+ }
+
+ const std::vector<LoggedVideoRecvConfig>& video_recv_configs() const {
+ return video_recv_configs_;
+ }
+
+ const std::vector<LoggedVideoSendConfig>& video_send_configs() const {
+ return video_send_configs_;
+ }
+
+ // Beginning and end of log segments.
+ const std::vector<LoggedStartEvent>& start_log_events() const {
+ return start_log_events_;
+ }
+
+ const std::vector<LoggedStopEvent>& stop_log_events() const {
+ return stop_log_events_;
+ }
+
+ const std::vector<LoggedAlrStateEvent>& alr_state_events() const {
+ return alr_state_events_;
+ }
+
+ // Audio
+ const std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>&
+ audio_playout_events() const {
+ return audio_playout_events_;
+ }
+
+ const std::vector<LoggedAudioNetworkAdaptationEvent>&
+ audio_network_adaptation_events() const {
+ return audio_network_adaptation_events_;
+ }
+
+ // Bandwidth estimation
+ const std::vector<LoggedBweProbeClusterCreatedEvent>&
+ bwe_probe_cluster_created_events() const {
+ return bwe_probe_cluster_created_events_;
+ }
+
+ const std::vector<LoggedBweProbeFailureEvent>& bwe_probe_failure_events()
+ const {
+ return bwe_probe_failure_events_;
+ }
+
+ const std::vector<LoggedBweProbeSuccessEvent>& bwe_probe_success_events()
+ const {
+ return bwe_probe_success_events_;
+ }
+
+ const std::vector<LoggedBweDelayBasedUpdate>& bwe_delay_updates() const {
+ return bwe_delay_updates_;
+ }
+
+ const std::vector<LoggedBweLossBasedUpdate>& bwe_loss_updates() const {
+ return bwe_loss_updates_;
+ }
+
+ // DTLS
+ const std::vector<LoggedDtlsTransportState>& dtls_transport_states() const {
+ return dtls_transport_states_;
+ }
+
+ const std::vector<LoggedDtlsWritableState>& dtls_writable_states() const {
+ return dtls_writable_states_;
+ }
+
+ // ICE events
+ const std::vector<LoggedIceCandidatePairConfig>& ice_candidate_pair_configs()
+ const {
+ return ice_candidate_pair_configs_;
+ }
+
+ const std::vector<LoggedIceCandidatePairEvent>& ice_candidate_pair_events()
+ const {
+ return ice_candidate_pair_events_;
+ }
+
+ // RTP
+ const std::vector<LoggedRtpStreamIncoming>& incoming_rtp_packets_by_ssrc()
+ const {
+ return incoming_rtp_packets_by_ssrc_;
+ }
+
+ const std::vector<LoggedRtpStreamOutgoing>& outgoing_rtp_packets_by_ssrc()
+ const {
+ return outgoing_rtp_packets_by_ssrc_;
+ }
+
+ const std::vector<LoggedRtpStreamView>& 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<LoggedRtcpPacketIncoming>& incoming_rtcp_packets() const {
+ return incoming_rtcp_packets_;
+ }
+
+ const std::vector<LoggedRtcpPacketOutgoing>& outgoing_rtcp_packets() const {
+ return outgoing_rtcp_packets_;
+ }
+
+ const std::vector<LoggedRtcpPacketReceiverReport>& receiver_reports(
+ PacketDirection direction) const {
+ if (direction == kIncomingPacket) {
+ return incoming_rr_;
+ } else {
+ return outgoing_rr_;
+ }
+ }
+
+ const std::vector<LoggedRtcpPacketSenderReport>& sender_reports(
+ PacketDirection direction) const {
+ if (direction == kIncomingPacket) {
+ return incoming_sr_;
+ } else {
+ return outgoing_sr_;
+ }
+ }
+
+ const std::vector<LoggedRtcpPacketNack>& nacks(
+ PacketDirection direction) const {
+ if (direction == kIncomingPacket) {
+ return incoming_nack_;
+ } else {
+ return outgoing_nack_;
+ }
+ }
+
+ const std::vector<LoggedRtcpPacketRemb>& rembs(
+ PacketDirection direction) const {
+ if (direction == kIncomingPacket) {
+ return incoming_remb_;
+ } else {
+ return outgoing_remb_;
+ }
+ }
+
+ const std::vector<LoggedRtcpPacketTransportFeedback>& 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 <typename T>
+ void StoreFirstAndLastTimestamp(const std::vector<T>& 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<uint32_t> incoming_rtx_ssrcs_;
+ std::set<uint32_t> incoming_video_ssrcs_;
+ std::set<uint32_t> incoming_audio_ssrcs_;
+ std::set<uint32_t> outgoing_rtx_ssrcs_;
+ std::set<uint32_t> outgoing_video_ssrcs_;
+ std::set<uint32_t> 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<uint32_t, std::vector<LoggedRtpPacketIncoming>>
+ incoming_rtp_packets_map_;
+ std::map<uint32_t, std::vector<LoggedRtpPacketOutgoing>>
+ outgoing_rtp_packets_map_;
+
+ // RTP headers.
+ std::vector<LoggedRtpStreamIncoming> incoming_rtp_packets_by_ssrc_;
+ std::vector<LoggedRtpStreamOutgoing> outgoing_rtp_packets_by_ssrc_;
+ std::vector<LoggedRtpStreamView> incoming_rtp_packet_views_by_ssrc_;
+ std::vector<LoggedRtpStreamView> outgoing_rtp_packet_views_by_ssrc_;
+
+ // Raw RTCP packets.
+ std::vector<LoggedRtcpPacketIncoming> incoming_rtcp_packets_;
+ std::vector<LoggedRtcpPacketOutgoing> outgoing_rtcp_packets_;
+
+ // Parsed RTCP messages. Currently not separated based on SSRC.
+ std::vector<LoggedRtcpPacketReceiverReport> incoming_rr_;
+ std::vector<LoggedRtcpPacketReceiverReport> outgoing_rr_;
+ std::vector<LoggedRtcpPacketSenderReport> incoming_sr_;
+ std::vector<LoggedRtcpPacketSenderReport> outgoing_sr_;
+ std::vector<LoggedRtcpPacketNack> incoming_nack_;
+ std::vector<LoggedRtcpPacketNack> outgoing_nack_;
+ std::vector<LoggedRtcpPacketRemb> incoming_remb_;
+ std::vector<LoggedRtcpPacketRemb> outgoing_remb_;
+ std::vector<LoggedRtcpPacketTransportFeedback> incoming_transport_feedback_;
+ std::vector<LoggedRtcpPacketTransportFeedback> outgoing_transport_feedback_;
+
+ std::vector<LoggedStartEvent> start_log_events_;
+ std::vector<LoggedStopEvent> stop_log_events_;
+
+ std::vector<LoggedAlrStateEvent> alr_state_events_;
+
+ std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>
+ audio_playout_events_;
+
+ std::vector<LoggedAudioNetworkAdaptationEvent>
+ audio_network_adaptation_events_;
+
+ std::vector<LoggedBweProbeClusterCreatedEvent>
+ bwe_probe_cluster_created_events_;
+
+ std::vector<LoggedBweProbeFailureEvent> bwe_probe_failure_events_;
+ std::vector<LoggedBweProbeSuccessEvent> bwe_probe_success_events_;
+
+ std::vector<LoggedBweDelayBasedUpdate> bwe_delay_updates_;
+ std::vector<LoggedBweLossBasedUpdate> bwe_loss_updates_;
+
+ std::vector<LoggedDtlsTransportState> dtls_transport_states_;
+ std::vector<LoggedDtlsWritableState> dtls_writable_states_;
+
+ std::vector<LoggedIceCandidatePairConfig> ice_candidate_pair_configs_;
+ std::vector<LoggedIceCandidatePairEvent> ice_candidate_pair_events_;
+
+ std::vector<LoggedAudioRecvConfig> audio_recv_configs_;
+ std::vector<LoggedAudioSendConfig> audio_send_configs_;
+ std::vector<LoggedVideoRecvConfig> video_recv_configs_;
+ std::vector<LoggedVideoSendConfig> 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<uint32_t, webrtc::RtpHeaderExtensionMap>
+ incoming_rtp_extensions_maps_;
+ mutable std::map<uint32_t, webrtc::RtpHeaderExtensionMap>
+ 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<MatchedSendArrivalTimes> 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 0ee70a5..158a1d8 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 <iterator>
-#include <map>
-#include <set>
-#include <sstream> // no-presubmit-check TODO(webrtc:8982)
-#include <string>
-#include <utility> // pair
-#include <vector>
-
-#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 <typename T>
-class PacketView;
-
-template <typename T>
-class PacketIterator {
- friend class PacketView<T>;
-
- 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<T>& other) const {
- RTC_DCHECK_EQ(element_size_, other.element_size_);
- return ptr_ == other.ptr_;
- }
- bool operator!=(const PacketIterator<T>& 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<T*>(ptr_); }
- const T& operator*() const { return *reinterpret_cast<const T*>(ptr_); }
-
- private:
- PacketIterator(typename std::conditional<std::is_const<T>::value,
- const void*,
- void*>::type p,
- size_t s)
- : ptr_(reinterpret_cast<decltype(ptr_)>(p)), element_size_(s) {}
-
- typename std::conditional<std::is_const<T>::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<A> view1 = PacketView<A>::Create<B>(array1, len, offsetof(B, a));
-// PacketView<A> view2 = PacketView<A>::Create<C>(array2, len, offsetof(C, a));
-//
-// The following code works with either view1 or view2.
-// void f(PacketView<A> view)
-// for (A& a : view) {
-// DoSomething(a);
-// }
-template <typename T>
-class PacketView {
- public:
- template <typename U>
- static PacketView Create(U* ptr, size_t num_elements, size_t offset) {
- static_assert(std::is_standard_layout<U>::value,
- "PacketView can only be created for standard layout types.");
- static_assert(std::is_standard_layout<T>::value,
- "PacketView can only be created for standard layout types.");
- return PacketView(ptr, num_elements, offset, sizeof(U));
- }
-
- using iterator = PacketIterator<T>;
- using const_iterator = PacketIterator<const T>;
- using reverse_iterator = std::reverse_iterator<iterator>;
- using const_reverse_iterator = std::reverse_iterator<const_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<T*>(elem_ptr);
- }
-
- const T& operator[](size_t i) const {
- auto elem_ptr = data_ + i * element_size_;
- return *reinterpret_cast<const T*>(elem_ptr);
- }
-
- private:
- PacketView(typename std::conditional<std::is_const<T>::value,
- const void*,
- void*>::type data,
- size_t num_elements,
- size_t offset,
- size_t element_size)
- : data_(reinterpret_cast<decltype(data_)>(data) + offset),
- num_elements_(num_elements),
- element_size_(element_size) {}
-
- typename std::conditional<std::is_const<T>::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<LoggedRtpPacketIncoming> incoming_packets;
- };
-
- struct LoggedRtpStreamOutgoing {
- LoggedRtpStreamOutgoing();
- LoggedRtpStreamOutgoing(const LoggedRtpStreamOutgoing&);
- ~LoggedRtpStreamOutgoing();
- uint32_t ssrc;
- std::vector<LoggedRtpPacketOutgoing> 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<const LoggedRtpPacket> 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<uint32_t>& incoming_rtx_ssrcs() const {
- return incoming_rtx_ssrcs_;
- }
-
- const std::set<uint32_t>& incoming_video_ssrcs() const {
- return incoming_video_ssrcs_;
- }
-
- const std::set<uint32_t>& incoming_audio_ssrcs() const {
- return incoming_audio_ssrcs_;
- }
-
- const std::set<uint32_t>& outgoing_rtx_ssrcs() const {
- return outgoing_rtx_ssrcs_;
- }
-
- const std::set<uint32_t>& outgoing_video_ssrcs() const {
- return outgoing_video_ssrcs_;
- }
-
- const std::set<uint32_t>& outgoing_audio_ssrcs() const {
- return outgoing_audio_ssrcs_;
- }
-
- // Stream configurations.
- const std::vector<LoggedAudioRecvConfig>& audio_recv_configs() const {
- return audio_recv_configs_;
- }
-
- const std::vector<LoggedAudioSendConfig>& audio_send_configs() const {
- return audio_send_configs_;
- }
-
- const std::vector<LoggedVideoRecvConfig>& video_recv_configs() const {
- return video_recv_configs_;
- }
-
- const std::vector<LoggedVideoSendConfig>& video_send_configs() const {
- return video_send_configs_;
- }
-
- // Beginning and end of log segments.
- const std::vector<LoggedStartEvent>& start_log_events() const {
- return start_log_events_;
- }
-
- const std::vector<LoggedStopEvent>& stop_log_events() const {
- return stop_log_events_;
- }
-
- const std::vector<LoggedAlrStateEvent>& alr_state_events() const {
- return alr_state_events_;
- }
-
- // Audio
- const std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>&
- audio_playout_events() const {
- return audio_playout_events_;
- }
-
- const std::vector<LoggedAudioNetworkAdaptationEvent>&
- audio_network_adaptation_events() const {
- return audio_network_adaptation_events_;
- }
-
- // Bandwidth estimation
- const std::vector<LoggedBweProbeClusterCreatedEvent>&
- bwe_probe_cluster_created_events() const {
- return bwe_probe_cluster_created_events_;
- }
-
- const std::vector<LoggedBweProbeFailureEvent>& bwe_probe_failure_events()
- const {
- return bwe_probe_failure_events_;
- }
-
- const std::vector<LoggedBweProbeSuccessEvent>& bwe_probe_success_events()
- const {
- return bwe_probe_success_events_;
- }
-
- const std::vector<LoggedBweDelayBasedUpdate>& bwe_delay_updates() const {
- return bwe_delay_updates_;
- }
-
- const std::vector<LoggedBweLossBasedUpdate>& bwe_loss_updates() const {
- return bwe_loss_updates_;
- }
-
- // DTLS
- const std::vector<LoggedDtlsTransportState>& dtls_transport_states() const {
- return dtls_transport_states_;
- }
-
- const std::vector<LoggedDtlsWritableState>& dtls_writable_states() const {
- return dtls_writable_states_;
- }
-
- // ICE events
- const std::vector<LoggedIceCandidatePairConfig>& ice_candidate_pair_configs()
- const {
- return ice_candidate_pair_configs_;
- }
-
- const std::vector<LoggedIceCandidatePairEvent>& ice_candidate_pair_events()
- const {
- return ice_candidate_pair_events_;
- }
-
- // RTP
- const std::vector<LoggedRtpStreamIncoming>& incoming_rtp_packets_by_ssrc()
- const {
- return incoming_rtp_packets_by_ssrc_;
- }
-
- const std::vector<LoggedRtpStreamOutgoing>& outgoing_rtp_packets_by_ssrc()
- const {
- return outgoing_rtp_packets_by_ssrc_;
- }
-
- const std::vector<LoggedRtpStreamView>& 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<LoggedRtcpPacketIncoming>& incoming_rtcp_packets() const {
- return incoming_rtcp_packets_;
- }
-
- const std::vector<LoggedRtcpPacketOutgoing>& outgoing_rtcp_packets() const {
- return outgoing_rtcp_packets_;
- }
-
- const std::vector<LoggedRtcpPacketReceiverReport>& receiver_reports(
- PacketDirection direction) const {
- if (direction == kIncomingPacket) {
- return incoming_rr_;
- } else {
- return outgoing_rr_;
- }
- }
-
- const std::vector<LoggedRtcpPacketSenderReport>& sender_reports(
- PacketDirection direction) const {
- if (direction == kIncomingPacket) {
- return incoming_sr_;
- } else {
- return outgoing_sr_;
- }
- }
-
- const std::vector<LoggedRtcpPacketNack>& nacks(
- PacketDirection direction) const {
- if (direction == kIncomingPacket) {
- return incoming_nack_;
- } else {
- return outgoing_nack_;
- }
- }
-
- const std::vector<LoggedRtcpPacketRemb>& rembs(
- PacketDirection direction) const {
- if (direction == kIncomingPacket) {
- return incoming_remb_;
- } else {
- return outgoing_remb_;
- }
- }
-
- const std::vector<LoggedRtcpPacketTransportFeedback>& 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 <typename T>
- void StoreFirstAndLastTimestamp(const std::vector<T>& 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<uint32_t> incoming_rtx_ssrcs_;
- std::set<uint32_t> incoming_video_ssrcs_;
- std::set<uint32_t> incoming_audio_ssrcs_;
- std::set<uint32_t> outgoing_rtx_ssrcs_;
- std::set<uint32_t> outgoing_video_ssrcs_;
- std::set<uint32_t> 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<uint32_t, std::vector<LoggedRtpPacketIncoming>>
- incoming_rtp_packets_map_;
- std::map<uint32_t, std::vector<LoggedRtpPacketOutgoing>>
- outgoing_rtp_packets_map_;
-
- // RTP headers.
- std::vector<LoggedRtpStreamIncoming> incoming_rtp_packets_by_ssrc_;
- std::vector<LoggedRtpStreamOutgoing> outgoing_rtp_packets_by_ssrc_;
- std::vector<LoggedRtpStreamView> incoming_rtp_packet_views_by_ssrc_;
- std::vector<LoggedRtpStreamView> outgoing_rtp_packet_views_by_ssrc_;
-
- // Raw RTCP packets.
- std::vector<LoggedRtcpPacketIncoming> incoming_rtcp_packets_;
- std::vector<LoggedRtcpPacketOutgoing> outgoing_rtcp_packets_;
-
- // Parsed RTCP messages. Currently not separated based on SSRC.
- std::vector<LoggedRtcpPacketReceiverReport> incoming_rr_;
- std::vector<LoggedRtcpPacketReceiverReport> outgoing_rr_;
- std::vector<LoggedRtcpPacketSenderReport> incoming_sr_;
- std::vector<LoggedRtcpPacketSenderReport> outgoing_sr_;
- std::vector<LoggedRtcpPacketNack> incoming_nack_;
- std::vector<LoggedRtcpPacketNack> outgoing_nack_;
- std::vector<LoggedRtcpPacketRemb> incoming_remb_;
- std::vector<LoggedRtcpPacketRemb> outgoing_remb_;
- std::vector<LoggedRtcpPacketTransportFeedback> incoming_transport_feedback_;
- std::vector<LoggedRtcpPacketTransportFeedback> outgoing_transport_feedback_;
-
- std::vector<LoggedStartEvent> start_log_events_;
- std::vector<LoggedStopEvent> stop_log_events_;
-
- std::vector<LoggedAlrStateEvent> alr_state_events_;
-
- std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>
- audio_playout_events_;
-
- std::vector<LoggedAudioNetworkAdaptationEvent>
- audio_network_adaptation_events_;
-
- std::vector<LoggedBweProbeClusterCreatedEvent>
- bwe_probe_cluster_created_events_;
-
- std::vector<LoggedBweProbeFailureEvent> bwe_probe_failure_events_;
- std::vector<LoggedBweProbeSuccessEvent> bwe_probe_success_events_;
-
- std::vector<LoggedBweDelayBasedUpdate> bwe_delay_updates_;
- std::vector<LoggedBweLossBasedUpdate> bwe_loss_updates_;
-
- std::vector<LoggedDtlsTransportState> dtls_transport_states_;
- std::vector<LoggedDtlsWritableState> dtls_writable_states_;
-
- std::vector<LoggedIceCandidatePairConfig> ice_candidate_pair_configs_;
- std::vector<LoggedIceCandidatePairEvent> ice_candidate_pair_events_;
-
- std::vector<LoggedAudioRecvConfig> audio_recv_configs_;
- std::vector<LoggedAudioSendConfig> audio_send_configs_;
- std::vector<LoggedVideoRecvConfig> video_recv_configs_;
- std::vector<LoggedVideoSendConfig> 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<uint32_t, webrtc::RtpHeaderExtensionMap>
- incoming_rtp_extensions_maps_;
- mutable std::map<uint32_t, webrtc::RtpHeaderExtensionMap>
- 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<MatchedSendArrivalTimes> 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 a89de54..842687e 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 @@
// 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 @@
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 a840371..61b202c 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 8409adf..dac3bb6 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 <numeric>
#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 0110b8c..446a1a9 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 test {
namespace {
-bool ShouldSkipStream(ParsedRtcEventLogNew::MediaType media_type,
+bool ShouldSkipStream(ParsedRtcEventLog::MediaType media_type,
uint32_t ssrc,
absl::optional<uint32_t> 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 @@
bool RtcEventLogSource::OpenFile(const std::string& file_name,
absl::optional<uint32_t> ssrc_filter) {
- ParsedRtcEventLogNew parsed_log;
+ ParsedRtcEventLog parsed_log;
if (!parsed_log.ParseFile(file_name))
return false;
@@ -104,7 +104,7 @@
// 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 6b761f7..ea620da 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 <vector>
#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 cae810c..2d1e908 100644
--- a/rtc_tools/event_log_visualizer/analyzer.cc
+++ b/rtc_tools/event_log_visualizer/analyzer.cc
@@ -445,7 +445,7 @@
} // 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 35a44b9..976598b 100644
--- a/rtc_tools/event_log_visualizer/analyzer.h
+++ b/rtc_tools/event_log_visualizer/analyzer.h
@@ -18,7 +18,7 @@
#include <utility>
#include <vector>
-#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 @@
// 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 @@
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 4808f9d..8c92be5 100644
--- a/rtc_tools/event_log_visualizer/main.cc
+++ b/rtc_tools/event_log_visualizer/main.cc
@@ -17,7 +17,7 @@
#include <utility>
#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 @@
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;