Remove the old RTC event log parser.
The new parser provides the same functionality (with a slightly
different API) and is backwards compatible with the legacy wire format.
Downstream projects seem to have transitioned to the new parser API.
Bug: webrtc:8111
Change-Id: Icb458f0d55e0a4566c4b7b4a53cab48f0b9d6fd8
Reviewed-on: https://webrtc-review.googlesource.com/c/110782
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25635}diff --git a/logging/BUILD.gn b/logging/BUILD.gn
index 90cf08a..4cd1d04 100644
--- a/logging/BUILD.gn
+++ b/logging/BUILD.gn
@@ -286,8 +286,6 @@
rtc_static_library("rtc_event_log_parser") {
visibility = [ "*" ]
sources = [
- "rtc_event_log/rtc_event_log_parser.cc",
- "rtc_event_log/rtc_event_log_parser.h",
"rtc_event_log/rtc_event_log_parser_new.cc",
"rtc_event_log/rtc_event_log_parser_new.h",
"rtc_event_log/rtc_event_processor.h",
diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc
deleted file mode 100644
index 802af18..0000000
--- a/logging/rtc_event_log/rtc_event_log_parser.cc
+++ /dev/null
@@ -1,851 +0,0 @@
-/*
- * Copyright (c) 2016 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.
- */
-
-#include "logging/rtc_event_log/rtc_event_log_parser.h"
-
-#include <stdint.h>
-#include <string.h>
-
-#include <algorithm>
-#include <fstream>
-#include <istream>
-#include <map>
-#include <utility>
-
-#include "logging/rtc_event_log/rtc_event_log.h"
-#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
-#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/protobuf_utils.h"
-
-namespace webrtc {
-
-namespace {
-RtcpMode GetRuntimeRtcpMode(rtclog::VideoReceiveConfig::RtcpMode rtcp_mode) {
- switch (rtcp_mode) {
- case rtclog::VideoReceiveConfig::RTCP_COMPOUND:
- return RtcpMode::kCompound;
- case rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE:
- return RtcpMode::kReducedSize;
- }
- RTC_NOTREACHED();
- return RtcpMode::kOff;
-}
-
-ParsedRtcEventLog::EventType GetRuntimeEventType(
- rtclog::Event::EventType event_type) {
- switch (event_type) {
- case rtclog::Event::UNKNOWN_EVENT:
- return ParsedRtcEventLog::EventType::UNKNOWN_EVENT;
- case rtclog::Event::LOG_START:
- return ParsedRtcEventLog::EventType::LOG_START;
- case rtclog::Event::LOG_END:
- return ParsedRtcEventLog::EventType::LOG_END;
- case rtclog::Event::RTP_EVENT:
- return ParsedRtcEventLog::EventType::RTP_EVENT;
- case rtclog::Event::RTCP_EVENT:
- return ParsedRtcEventLog::EventType::RTCP_EVENT;
- case rtclog::Event::AUDIO_PLAYOUT_EVENT:
- return ParsedRtcEventLog::EventType::AUDIO_PLAYOUT_EVENT;
- case rtclog::Event::LOSS_BASED_BWE_UPDATE:
- return ParsedRtcEventLog::EventType::LOSS_BASED_BWE_UPDATE;
- case rtclog::Event::DELAY_BASED_BWE_UPDATE:
- return ParsedRtcEventLog::EventType::DELAY_BASED_BWE_UPDATE;
- case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT:
- return ParsedRtcEventLog::EventType::VIDEO_RECEIVER_CONFIG_EVENT;
- case rtclog::Event::VIDEO_SENDER_CONFIG_EVENT:
- return ParsedRtcEventLog::EventType::VIDEO_SENDER_CONFIG_EVENT;
- case rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT:
- return ParsedRtcEventLog::EventType::AUDIO_RECEIVER_CONFIG_EVENT;
- case rtclog::Event::AUDIO_SENDER_CONFIG_EVENT:
- return ParsedRtcEventLog::EventType::AUDIO_SENDER_CONFIG_EVENT;
- case rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT:
- return ParsedRtcEventLog::EventType::AUDIO_NETWORK_ADAPTATION_EVENT;
- case rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT:
- return ParsedRtcEventLog::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT;
- case rtclog::Event::BWE_PROBE_RESULT_EVENT:
- return ParsedRtcEventLog::EventType::BWE_PROBE_RESULT_EVENT;
- case rtclog::Event::ALR_STATE_EVENT:
- return ParsedRtcEventLog::EventType::ALR_STATE_EVENT;
- case rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG:
- return ParsedRtcEventLog::EventType::ICE_CANDIDATE_PAIR_CONFIG;
- case rtclog::Event::ICE_CANDIDATE_PAIR_EVENT:
- return ParsedRtcEventLog::EventType::ICE_CANDIDATE_PAIR_EVENT;
- }
- return ParsedRtcEventLog::EventType::UNKNOWN_EVENT;
-}
-
-BandwidthUsage GetRuntimeDetectorState(
- rtclog::DelayBasedBweUpdate::DetectorState detector_state) {
- switch (detector_state) {
- case rtclog::DelayBasedBweUpdate::BWE_NORMAL:
- return BandwidthUsage::kBwNormal;
- case rtclog::DelayBasedBweUpdate::BWE_UNDERUSING:
- return BandwidthUsage::kBwUnderusing;
- case rtclog::DelayBasedBweUpdate::BWE_OVERUSING:
- return BandwidthUsage::kBwOverusing;
- }
- RTC_NOTREACHED();
- return BandwidthUsage::kBwNormal;
-}
-
-IceCandidatePairConfigType GetRuntimeIceCandidatePairConfigType(
- rtclog::IceCandidatePairConfig::IceCandidatePairConfigType type) {
- switch (type) {
- case rtclog::IceCandidatePairConfig::ADDED:
- return IceCandidatePairConfigType::kAdded;
- case rtclog::IceCandidatePairConfig::UPDATED:
- return IceCandidatePairConfigType::kUpdated;
- case rtclog::IceCandidatePairConfig::DESTROYED:
- return IceCandidatePairConfigType::kDestroyed;
- case rtclog::IceCandidatePairConfig::SELECTED:
- return IceCandidatePairConfigType::kSelected;
- }
- RTC_NOTREACHED();
- return IceCandidatePairConfigType::kAdded;
-}
-
-IceCandidateType GetRuntimeIceCandidateType(
- rtclog::IceCandidatePairConfig::IceCandidateType type) {
- switch (type) {
- case rtclog::IceCandidatePairConfig::LOCAL:
- return IceCandidateType::kLocal;
- case rtclog::IceCandidatePairConfig::STUN:
- return IceCandidateType::kStun;
- case rtclog::IceCandidatePairConfig::PRFLX:
- return IceCandidateType::kPrflx;
- case rtclog::IceCandidatePairConfig::RELAY:
- return IceCandidateType::kRelay;
- case rtclog::IceCandidatePairConfig::UNKNOWN_CANDIDATE_TYPE:
- return IceCandidateType::kUnknown;
- }
- RTC_NOTREACHED();
- return IceCandidateType::kUnknown;
-}
-
-IceCandidatePairProtocol GetRuntimeIceCandidatePairProtocol(
- rtclog::IceCandidatePairConfig::Protocol protocol) {
- switch (protocol) {
- case rtclog::IceCandidatePairConfig::UDP:
- return IceCandidatePairProtocol::kUdp;
- case rtclog::IceCandidatePairConfig::TCP:
- return IceCandidatePairProtocol::kTcp;
- case rtclog::IceCandidatePairConfig::SSLTCP:
- return IceCandidatePairProtocol::kSsltcp;
- case rtclog::IceCandidatePairConfig::TLS:
- return IceCandidatePairProtocol::kTls;
- case rtclog::IceCandidatePairConfig::UNKNOWN_PROTOCOL:
- return IceCandidatePairProtocol::kUnknown;
- }
- RTC_NOTREACHED();
- return IceCandidatePairProtocol::kUnknown;
-}
-
-IceCandidatePairAddressFamily GetRuntimeIceCandidatePairAddressFamily(
- rtclog::IceCandidatePairConfig::AddressFamily address_family) {
- switch (address_family) {
- case rtclog::IceCandidatePairConfig::IPV4:
- return IceCandidatePairAddressFamily::kIpv4;
- case rtclog::IceCandidatePairConfig::IPV6:
- return IceCandidatePairAddressFamily::kIpv6;
- case rtclog::IceCandidatePairConfig::UNKNOWN_ADDRESS_FAMILY:
- return IceCandidatePairAddressFamily::kUnknown;
- }
- RTC_NOTREACHED();
- return IceCandidatePairAddressFamily::kUnknown;
-}
-
-IceCandidateNetworkType GetRuntimeIceCandidateNetworkType(
- rtclog::IceCandidatePairConfig::NetworkType network_type) {
- switch (network_type) {
- case rtclog::IceCandidatePairConfig::ETHERNET:
- return IceCandidateNetworkType::kEthernet;
- case rtclog::IceCandidatePairConfig::LOOPBACK:
- return IceCandidateNetworkType::kLoopback;
- case rtclog::IceCandidatePairConfig::WIFI:
- return IceCandidateNetworkType::kWifi;
- case rtclog::IceCandidatePairConfig::VPN:
- return IceCandidateNetworkType::kVpn;
- case rtclog::IceCandidatePairConfig::CELLULAR:
- return IceCandidateNetworkType::kCellular;
- case rtclog::IceCandidatePairConfig::UNKNOWN_NETWORK_TYPE:
- return IceCandidateNetworkType::kUnknown;
- }
- RTC_NOTREACHED();
- return IceCandidateNetworkType::kUnknown;
-}
-
-IceCandidatePairEventType GetRuntimeIceCandidatePairEventType(
- rtclog::IceCandidatePairEvent::IceCandidatePairEventType type) {
- switch (type) {
- case rtclog::IceCandidatePairEvent::CHECK_SENT:
- return IceCandidatePairEventType::kCheckSent;
- case rtclog::IceCandidatePairEvent::CHECK_RECEIVED:
- return IceCandidatePairEventType::kCheckReceived;
- case rtclog::IceCandidatePairEvent::CHECK_RESPONSE_SENT:
- return IceCandidatePairEventType::kCheckResponseSent;
- case rtclog::IceCandidatePairEvent::CHECK_RESPONSE_RECEIVED:
- return IceCandidatePairEventType::kCheckResponseReceived;
- }
- RTC_NOTREACHED();
- return IceCandidatePairEventType::kCheckSent;
-}
-
-std::pair<uint64_t, bool> ParseVarInt(std::istream& stream) {
- uint64_t varint = 0;
- for (size_t bytes_read = 0; bytes_read < 10; ++bytes_read) {
- // The most significant bit of each byte is 0 if it is the last byte in
- // the varint and 1 otherwise. Thus, we take the 7 least significant bits
- // of each byte and shift them 7 bits for each byte read previously to get
- // the (unsigned) integer.
- int byte = stream.get();
- if (stream.eof()) {
- return std::make_pair(varint, false);
- }
- RTC_DCHECK_GE(byte, 0);
- RTC_DCHECK_LE(byte, 255);
- varint |= static_cast<uint64_t>(byte & 0x7F) << (7 * bytes_read);
- if ((byte & 0x80) == 0) {
- return std::make_pair(varint, true);
- }
- }
- return std::make_pair(varint, false);
-}
-
-void GetHeaderExtensions(std::vector<RtpExtension>* header_extensions,
- const RepeatedPtrField<rtclog::RtpHeaderExtension>&
- proto_header_extensions) {
- header_extensions->clear();
- for (auto& p : proto_header_extensions) {
- RTC_CHECK(p.has_name());
- RTC_CHECK(p.has_id());
- const std::string& name = p.name();
- int id = p.id();
- header_extensions->push_back(RtpExtension(name, id));
- }
-}
-
-} // namespace
-
-ParsedRtcEventLog::ParsedRtcEventLog() = default;
-ParsedRtcEventLog::~ParsedRtcEventLog() = default;
-
-ParsedRtcEventLog::BweProbeResultEvent::BweProbeResultEvent() = default;
-ParsedRtcEventLog::BweProbeResultEvent::BweProbeResultEvent(
- const BweProbeResultEvent&) = default;
-
-bool ParsedRtcEventLog::ParseFile(const std::string& filename) {
- std::ifstream file(filename, std::ios_base::in | std::ios_base::binary);
- if (!file.good() || !file.is_open()) {
- RTC_LOG(LS_WARNING) << "Could not open file for reading.";
- return false;
- }
-
- return ParseStream(file);
-}
-
-bool ParsedRtcEventLog::ParseString(const std::string& s) {
- std::istringstream stream(s, std::ios_base::in | std::ios_base::binary);
- return ParseStream(stream);
-}
-
-bool ParsedRtcEventLog::ParseStream(std::istream& stream) {
- events_.clear();
- const size_t kMaxEventSize = (1u << 16) - 1;
- std::vector<char> tmp_buffer(kMaxEventSize);
- uint64_t tag;
- uint64_t message_length;
- bool success;
-
- RTC_DCHECK(stream.good());
-
- while (1) {
- // Check whether we have reached end of file.
- stream.peek();
- if (stream.eof()) {
- // Process all extensions maps for faster look-up later.
- for (auto& event_stream : streams_) {
- rtp_extensions_maps_[StreamId(event_stream.ssrc,
- event_stream.direction)] =
- &event_stream.rtp_extensions_map;
- }
- return true;
- }
-
- // Read the next message tag. The tag number is defined as
- // (fieldnumber << 3) | wire_type. In our case, the field number is
- // supposed to be 1 and the wire type for an
- // length-delimited field is 2.
- const uint64_t kExpectedTag = (1 << 3) | 2;
- std::tie(tag, success) = ParseVarInt(stream);
- if (!success) {
- RTC_LOG(LS_WARNING)
- << "Missing field tag from beginning of protobuf event.";
- return false;
- } else if (tag != kExpectedTag) {
- RTC_LOG(LS_WARNING)
- << "Unexpected field tag at beginning of protobuf event.";
- return false;
- }
-
- // Read the length field.
- std::tie(message_length, success) = ParseVarInt(stream);
- if (!success) {
- RTC_LOG(LS_WARNING) << "Missing message length after protobuf field tag.";
- return false;
- } else if (message_length > kMaxEventSize) {
- RTC_LOG(LS_WARNING) << "Protobuf message length is too large.";
- return false;
- }
-
- // Read the next protobuf event to a temporary char buffer.
- stream.read(tmp_buffer.data(), message_length);
- if (stream.gcount() != static_cast<int>(message_length)) {
- RTC_LOG(LS_WARNING) << "Failed to read protobuf message from file.";
- return false;
- }
-
- // Parse the protobuf event from the buffer.
- rtclog::Event event;
- if (!event.ParseFromArray(tmp_buffer.data(), message_length)) {
- RTC_LOG(LS_WARNING) << "Failed to parse protobuf message.";
- return false;
- }
-
- EventType type = GetRuntimeEventType(event.type());
- switch (type) {
- case VIDEO_RECEIVER_CONFIG_EVENT: {
- rtclog::StreamConfig config = GetVideoReceiveConfig(event);
- streams_.emplace_back(config.remote_ssrc, MediaType::VIDEO,
- kIncomingPacket,
- RtpHeaderExtensionMap(config.rtp_extensions));
- streams_.emplace_back(config.local_ssrc, MediaType::VIDEO,
- kOutgoingPacket,
- RtpHeaderExtensionMap(config.rtp_extensions));
- break;
- }
- case VIDEO_SENDER_CONFIG_EVENT: {
- std::vector<rtclog::StreamConfig> configs = GetVideoSendConfig(event);
- for (size_t i = 0; i < configs.size(); i++) {
- streams_.emplace_back(
- configs[i].local_ssrc, MediaType::VIDEO, kOutgoingPacket,
- RtpHeaderExtensionMap(configs[i].rtp_extensions));
-
- streams_.emplace_back(
- configs[i].rtx_ssrc, MediaType::VIDEO, kOutgoingPacket,
- RtpHeaderExtensionMap(configs[i].rtp_extensions));
- }
- break;
- }
- case AUDIO_RECEIVER_CONFIG_EVENT: {
- rtclog::StreamConfig config = GetAudioReceiveConfig(event);
- streams_.emplace_back(config.remote_ssrc, MediaType::AUDIO,
- kIncomingPacket,
- RtpHeaderExtensionMap(config.rtp_extensions));
- streams_.emplace_back(config.local_ssrc, MediaType::AUDIO,
- kOutgoingPacket,
- RtpHeaderExtensionMap(config.rtp_extensions));
- break;
- }
- case AUDIO_SENDER_CONFIG_EVENT: {
- rtclog::StreamConfig config = GetAudioSendConfig(event);
- streams_.emplace_back(config.local_ssrc, MediaType::AUDIO,
- kOutgoingPacket,
- RtpHeaderExtensionMap(config.rtp_extensions));
- break;
- }
- default:
- break;
- }
-
- events_.push_back(event);
- }
-}
-
-size_t ParsedRtcEventLog::GetNumberOfEvents() const {
- return events_.size();
-}
-
-int64_t ParsedRtcEventLog::GetTimestamp(size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_timestamp_us());
- return event.timestamp_us();
-}
-
-ParsedRtcEventLog::EventType ParsedRtcEventLog::GetEventType(
- size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- return GetRuntimeEventType(event.type());
-}
-
-// The header must have space for at least IP_PACKET_SIZE bytes.
-webrtc::RtpHeaderExtensionMap* ParsedRtcEventLog::GetRtpHeader(
- size_t index,
- PacketDirection* incoming,
- uint8_t* header,
- size_t* header_length,
- size_t* total_length,
- int* probe_cluster_id) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::RTP_EVENT);
- RTC_CHECK(event.has_rtp_packet());
- const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
- // Get direction of packet.
- RTC_CHECK(rtp_packet.has_incoming());
- if (incoming != nullptr) {
- *incoming = rtp_packet.incoming() ? kIncomingPacket : kOutgoingPacket;
- }
- // Get packet length.
- RTC_CHECK(rtp_packet.has_packet_length());
- if (total_length != nullptr) {
- *total_length = rtp_packet.packet_length();
- }
- // Get header length.
- RTC_CHECK(rtp_packet.has_header());
- if (header_length != nullptr) {
- *header_length = rtp_packet.header().size();
- }
- // Get header contents.
- if (header != nullptr) {
- const size_t kMinRtpHeaderSize = 12;
- RTC_CHECK_GE(rtp_packet.header().size(), kMinRtpHeaderSize);
- RTC_CHECK_LE(rtp_packet.header().size(),
- static_cast<size_t>(IP_PACKET_SIZE));
- memcpy(header, rtp_packet.header().data(), rtp_packet.header().size());
- uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(header + 8);
- StreamId stream_id(
- ssrc, rtp_packet.incoming() ? kIncomingPacket : kOutgoingPacket);
- auto it = rtp_extensions_maps_.find(stream_id);
- if (it != rtp_extensions_maps_.end()) {
- return it->second;
- }
- }
- if (probe_cluster_id != nullptr) {
- if (rtp_packet.has_probe_cluster_id()) {
- *probe_cluster_id = rtp_packet.probe_cluster_id();
- RTC_CHECK_NE(*probe_cluster_id, PacedPacketInfo::kNotAProbe);
- } else {
- *probe_cluster_id = PacedPacketInfo::kNotAProbe;
- }
- }
- return nullptr;
-}
-
-// The packet must have space for at least IP_PACKET_SIZE bytes.
-void ParsedRtcEventLog::GetRtcpPacket(size_t index,
- PacketDirection* incoming,
- uint8_t* packet,
- size_t* length) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::RTCP_EVENT);
- RTC_CHECK(event.has_rtcp_packet());
- const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet();
- // Get direction of packet.
- RTC_CHECK(rtcp_packet.has_incoming());
- if (incoming != nullptr) {
- *incoming = rtcp_packet.incoming() ? kIncomingPacket : kOutgoingPacket;
- }
- // Get packet length.
- RTC_CHECK(rtcp_packet.has_packet_data());
- if (length != nullptr) {
- *length = rtcp_packet.packet_data().size();
- }
- // Get packet contents.
- if (packet != nullptr) {
- RTC_CHECK_LE(rtcp_packet.packet_data().size(),
- static_cast<unsigned>(IP_PACKET_SIZE));
- memcpy(packet, rtcp_packet.packet_data().data(),
- rtcp_packet.packet_data().size());
- }
-}
-
-rtclog::StreamConfig ParsedRtcEventLog::GetVideoReceiveConfig(
- size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- return GetVideoReceiveConfig(events_[index]);
-}
-
-rtclog::StreamConfig ParsedRtcEventLog::GetVideoReceiveConfig(
- const rtclog::Event& event) const {
- rtclog::StreamConfig config;
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
- RTC_CHECK(event.has_video_receiver_config());
- const rtclog::VideoReceiveConfig& receiver_config =
- event.video_receiver_config();
- // Get SSRCs.
- RTC_CHECK(receiver_config.has_remote_ssrc());
- config.remote_ssrc = receiver_config.remote_ssrc();
- RTC_CHECK(receiver_config.has_local_ssrc());
- config.local_ssrc = receiver_config.local_ssrc();
- config.rtx_ssrc = 0;
- // Get RTCP settings.
- RTC_CHECK(receiver_config.has_rtcp_mode());
- config.rtcp_mode = GetRuntimeRtcpMode(receiver_config.rtcp_mode());
- RTC_CHECK(receiver_config.has_remb());
- config.remb = receiver_config.remb();
-
- // Get RTX map.
- std::map<uint32_t, const rtclog::RtxConfig> rtx_map;
- for (int i = 0; i < receiver_config.rtx_map_size(); i++) {
- const rtclog::RtxMap& map = receiver_config.rtx_map(i);
- RTC_CHECK(map.has_payload_type());
- RTC_CHECK(map.has_config());
- RTC_CHECK(map.config().has_rtx_ssrc());
- RTC_CHECK(map.config().has_rtx_payload_type());
- rtx_map.insert(std::make_pair(map.payload_type(), map.config()));
- }
-
- // Get header extensions.
- GetHeaderExtensions(&config.rtp_extensions,
- receiver_config.header_extensions());
- // Get decoders.
- config.codecs.clear();
- for (int i = 0; i < receiver_config.decoders_size(); i++) {
- RTC_CHECK(receiver_config.decoders(i).has_name());
- RTC_CHECK(receiver_config.decoders(i).has_payload_type());
- int rtx_payload_type = 0;
- auto rtx_it = rtx_map.find(receiver_config.decoders(i).payload_type());
- if (rtx_it != rtx_map.end()) {
- rtx_payload_type = rtx_it->second.rtx_payload_type();
- if (config.rtx_ssrc != 0 &&
- config.rtx_ssrc != rtx_it->second.rtx_ssrc()) {
- RTC_LOG(LS_WARNING)
- << "RtcEventLog protobuf contained different SSRCs for "
- "different received RTX payload types. Will only use "
- "rtx_ssrc = "
- << config.rtx_ssrc << ".";
- } else {
- config.rtx_ssrc = rtx_it->second.rtx_ssrc();
- }
- }
- config.codecs.emplace_back(receiver_config.decoders(i).name(),
- receiver_config.decoders(i).payload_type(),
- rtx_payload_type);
- }
- return config;
-}
-
-std::vector<rtclog::StreamConfig> ParsedRtcEventLog::GetVideoSendConfig(
- size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- return GetVideoSendConfig(events_[index]);
-}
-
-std::vector<rtclog::StreamConfig> ParsedRtcEventLog::GetVideoSendConfig(
- const rtclog::Event& event) const {
- std::vector<rtclog::StreamConfig> configs;
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
- RTC_CHECK(event.has_video_sender_config());
- const rtclog::VideoSendConfig& sender_config = event.video_sender_config();
- if (sender_config.rtx_ssrcs_size() > 0 &&
- sender_config.ssrcs_size() != sender_config.rtx_ssrcs_size()) {
- RTC_LOG(WARNING)
- << "VideoSendConfig is configured for RTX but the number of "
- "SSRCs doesn't match the number of RTX SSRCs.";
- }
- configs.resize(sender_config.ssrcs_size());
- for (int i = 0; i < sender_config.ssrcs_size(); i++) {
- // Get SSRCs.
- configs[i].local_ssrc = sender_config.ssrcs(i);
- if (sender_config.rtx_ssrcs_size() > 0 &&
- i < sender_config.rtx_ssrcs_size()) {
- RTC_CHECK(sender_config.has_rtx_payload_type());
- configs[i].rtx_ssrc = sender_config.rtx_ssrcs(i);
- }
- // Get header extensions.
- GetHeaderExtensions(&configs[i].rtp_extensions,
- sender_config.header_extensions());
-
- // Get the codec.
- RTC_CHECK(sender_config.has_encoder());
- RTC_CHECK(sender_config.encoder().has_name());
- RTC_CHECK(sender_config.encoder().has_payload_type());
- configs[i].codecs.emplace_back(
- sender_config.encoder().name(), sender_config.encoder().payload_type(),
- sender_config.has_rtx_payload_type() ? sender_config.rtx_payload_type()
- : 0);
- }
- return configs;
-}
-
-rtclog::StreamConfig ParsedRtcEventLog::GetAudioReceiveConfig(
- size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- return GetAudioReceiveConfig(events_[index]);
-}
-
-rtclog::StreamConfig ParsedRtcEventLog::GetAudioReceiveConfig(
- const rtclog::Event& event) const {
- rtclog::StreamConfig config;
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
- RTC_CHECK(event.has_audio_receiver_config());
- const rtclog::AudioReceiveConfig& receiver_config =
- event.audio_receiver_config();
- // Get SSRCs.
- RTC_CHECK(receiver_config.has_remote_ssrc());
- config.remote_ssrc = receiver_config.remote_ssrc();
- RTC_CHECK(receiver_config.has_local_ssrc());
- config.local_ssrc = receiver_config.local_ssrc();
- // Get header extensions.
- GetHeaderExtensions(&config.rtp_extensions,
- receiver_config.header_extensions());
- return config;
-}
-
-rtclog::StreamConfig ParsedRtcEventLog::GetAudioSendConfig(size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- return GetAudioSendConfig(events_[index]);
-}
-
-rtclog::StreamConfig ParsedRtcEventLog::GetAudioSendConfig(
- const rtclog::Event& event) const {
- rtclog::StreamConfig config;
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_SENDER_CONFIG_EVENT);
- RTC_CHECK(event.has_audio_sender_config());
- const rtclog::AudioSendConfig& sender_config = event.audio_sender_config();
- // Get SSRCs.
- RTC_CHECK(sender_config.has_ssrc());
- config.local_ssrc = sender_config.ssrc();
- // Get header extensions.
- GetHeaderExtensions(&config.rtp_extensions,
- sender_config.header_extensions());
- return config;
-}
-
-void ParsedRtcEventLog::GetAudioPlayout(size_t index, uint32_t* ssrc) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_PLAYOUT_EVENT);
- RTC_CHECK(event.has_audio_playout_event());
- const rtclog::AudioPlayoutEvent& loss_event = event.audio_playout_event();
- RTC_CHECK(loss_event.has_local_ssrc());
- if (ssrc != nullptr) {
- *ssrc = loss_event.local_ssrc();
- }
-}
-
-void ParsedRtcEventLog::GetLossBasedBweUpdate(size_t index,
- int32_t* bitrate_bps,
- uint8_t* fraction_loss,
- int32_t* total_packets) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::LOSS_BASED_BWE_UPDATE);
- RTC_CHECK(event.has_loss_based_bwe_update());
- const rtclog::LossBasedBweUpdate& loss_event = event.loss_based_bwe_update();
- RTC_CHECK(loss_event.has_bitrate_bps());
- if (bitrate_bps != nullptr) {
- *bitrate_bps = loss_event.bitrate_bps();
- }
- RTC_CHECK(loss_event.has_fraction_loss());
- if (fraction_loss != nullptr) {
- *fraction_loss = loss_event.fraction_loss();
- }
- RTC_CHECK(loss_event.has_total_packets());
- if (total_packets != nullptr) {
- *total_packets = loss_event.total_packets();
- }
-}
-
-ParsedRtcEventLog::BweDelayBasedUpdate
-ParsedRtcEventLog::GetDelayBasedBweUpdate(size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::DELAY_BASED_BWE_UPDATE);
- RTC_CHECK(event.has_delay_based_bwe_update());
- const rtclog::DelayBasedBweUpdate& delay_event =
- event.delay_based_bwe_update();
-
- BweDelayBasedUpdate res;
- res.timestamp = GetTimestamp(index);
- RTC_CHECK(delay_event.has_bitrate_bps());
- res.bitrate_bps = delay_event.bitrate_bps();
- RTC_CHECK(delay_event.has_detector_state());
- res.detector_state = GetRuntimeDetectorState(delay_event.detector_state());
- return res;
-}
-
-void ParsedRtcEventLog::GetAudioNetworkAdaptation(
- size_t index,
- AudioEncoderRuntimeConfig* config) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);
- RTC_CHECK(event.has_audio_network_adaptation());
- const rtclog::AudioNetworkAdaptation& ana_event =
- event.audio_network_adaptation();
- if (ana_event.has_bitrate_bps())
- config->bitrate_bps = ana_event.bitrate_bps();
- if (ana_event.has_enable_fec())
- config->enable_fec = ana_event.enable_fec();
- if (ana_event.has_enable_dtx())
- config->enable_dtx = ana_event.enable_dtx();
- if (ana_event.has_frame_length_ms())
- config->frame_length_ms = ana_event.frame_length_ms();
- if (ana_event.has_num_channels())
- config->num_channels = ana_event.num_channels();
- if (ana_event.has_uplink_packet_loss_fraction())
- config->uplink_packet_loss_fraction =
- ana_event.uplink_packet_loss_fraction();
-}
-
-ParsedRtcEventLog::BweProbeClusterCreatedEvent
-ParsedRtcEventLog::GetBweProbeClusterCreated(size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT);
- RTC_CHECK(event.has_probe_cluster());
- const rtclog::BweProbeCluster& pcc_event = event.probe_cluster();
- BweProbeClusterCreatedEvent res;
- res.timestamp = GetTimestamp(index);
- RTC_CHECK(pcc_event.has_id());
- res.id = pcc_event.id();
- RTC_CHECK(pcc_event.has_bitrate_bps());
- res.bitrate_bps = pcc_event.bitrate_bps();
- RTC_CHECK(pcc_event.has_min_packets());
- res.min_packets = pcc_event.min_packets();
- RTC_CHECK(pcc_event.has_min_bytes());
- res.min_bytes = pcc_event.min_bytes();
- return res;
-}
-
-ParsedRtcEventLog::BweProbeResultEvent ParsedRtcEventLog::GetBweProbeResult(
- size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
- RTC_CHECK(event.has_probe_result());
- const rtclog::BweProbeResult& pr_event = event.probe_result();
- BweProbeResultEvent res;
- res.timestamp = GetTimestamp(index);
- RTC_CHECK(pr_event.has_id());
- res.id = pr_event.id();
-
- RTC_CHECK(pr_event.has_result());
- if (pr_event.result() == rtclog::BweProbeResult::SUCCESS) {
- RTC_CHECK(pr_event.has_bitrate_bps());
- res.bitrate_bps = pr_event.bitrate_bps();
- } else if (pr_event.result() ==
- rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL) {
- res.failure_reason = ProbeFailureReason::kInvalidSendReceiveInterval;
- } else if (pr_event.result() ==
- rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO) {
- res.failure_reason = ProbeFailureReason::kInvalidSendReceiveRatio;
- } else if (pr_event.result() == rtclog::BweProbeResult::TIMEOUT) {
- res.failure_reason = ProbeFailureReason::kTimeout;
- } else {
- RTC_NOTREACHED();
- }
-
- return res;
-}
-
-ParsedRtcEventLog::AlrStateEvent ParsedRtcEventLog::GetAlrState(
- size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
- RTC_CHECK(event.has_type());
- RTC_CHECK_EQ(event.type(), rtclog::Event::ALR_STATE_EVENT);
- RTC_CHECK(event.has_alr_state());
- const rtclog::AlrState& alr_event = event.alr_state();
- AlrStateEvent res;
- res.timestamp = GetTimestamp(index);
- RTC_CHECK(alr_event.has_in_alr());
- res.in_alr = alr_event.in_alr();
-
- return res;
-}
-
-ParsedRtcEventLog::IceCandidatePairConfig
-ParsedRtcEventLog::GetIceCandidatePairConfig(size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& rtc_event = events_[index];
- RTC_CHECK(rtc_event.has_type());
- RTC_CHECK_EQ(rtc_event.type(), rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG);
- IceCandidatePairConfig res;
- const rtclog::IceCandidatePairConfig& config =
- rtc_event.ice_candidate_pair_config();
- res.timestamp = GetTimestamp(index);
- RTC_CHECK(config.has_config_type());
- res.type = GetRuntimeIceCandidatePairConfigType(config.config_type());
- RTC_CHECK(config.has_candidate_pair_id());
- res.candidate_pair_id = config.candidate_pair_id();
- RTC_CHECK(config.has_local_candidate_type());
- res.local_candidate_type =
- GetRuntimeIceCandidateType(config.local_candidate_type());
- RTC_CHECK(config.has_local_relay_protocol());
- res.local_relay_protocol =
- GetRuntimeIceCandidatePairProtocol(config.local_relay_protocol());
- RTC_CHECK(config.has_local_network_type());
- res.local_network_type =
- GetRuntimeIceCandidateNetworkType(config.local_network_type());
- RTC_CHECK(config.has_local_address_family());
- res.local_address_family =
- GetRuntimeIceCandidatePairAddressFamily(config.local_address_family());
- RTC_CHECK(config.has_remote_candidate_type());
- res.remote_candidate_type =
- GetRuntimeIceCandidateType(config.remote_candidate_type());
- RTC_CHECK(config.has_remote_address_family());
- res.remote_address_family =
- GetRuntimeIceCandidatePairAddressFamily(config.remote_address_family());
- RTC_CHECK(config.has_candidate_pair_protocol());
- res.candidate_pair_protocol =
- GetRuntimeIceCandidatePairProtocol(config.candidate_pair_protocol());
- return res;
-}
-
-ParsedRtcEventLog::IceCandidatePairEvent
-ParsedRtcEventLog::GetIceCandidatePairEvent(size_t index) const {
- RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& rtc_event = events_[index];
- RTC_CHECK(rtc_event.has_type());
- RTC_CHECK_EQ(rtc_event.type(), rtclog::Event::ICE_CANDIDATE_PAIR_EVENT);
- IceCandidatePairEvent res;
- const rtclog::IceCandidatePairEvent& event =
- rtc_event.ice_candidate_pair_event();
- res.timestamp = GetTimestamp(index);
- RTC_CHECK(event.has_event_type());
- res.type = GetRuntimeIceCandidatePairEventType(event.event_type());
- RTC_CHECK(event.has_candidate_pair_id());
- res.candidate_pair_id = event.candidate_pair_id();
- return res;
-}
-
-// Returns the MediaType for registered SSRCs. Search from the end to use last
-// registered types first.
-ParsedRtcEventLog::MediaType ParsedRtcEventLog::GetMediaType(
- uint32_t ssrc,
- PacketDirection direction) const {
- for (auto rit = streams_.rbegin(); rit != streams_.rend(); ++rit) {
- if (rit->ssrc == ssrc && rit->direction == direction)
- return rit->media_type;
- }
- return MediaType::ANY;
-}
-} // namespace webrtc
diff --git a/logging/rtc_event_log/rtc_event_log_parser.h b/logging/rtc_event_log/rtc_event_log_parser.h
deleted file mode 100644
index c93ec6d..0000000
--- a/logging/rtc_event_log/rtc_event_log_parser.h
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
- * Copyright (c) 2016 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 <map>
-#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/events/rtc_event_ice_candidate_pair.h"
-#include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h"
-#include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
-#include "logging/rtc_event_log/rtc_event_log.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/byte_io.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"
-#else
-#include "logging/rtc_event_log/rtc_event_log.pb.h"
-#endif
-RTC_POP_IGNORING_WUNDEF()
-
-namespace webrtc {
-
-enum class BandwidthUsage;
-enum class MediaType;
-
-struct AudioEncoderRuntimeConfig;
-
-class ParsedRtcEventLog {
- friend class RtcEventLogTestHelper;
-
- public:
- ParsedRtcEventLog();
- ~ParsedRtcEventLog();
-
- struct BweProbeClusterCreatedEvent {
- uint64_t timestamp;
- uint32_t id;
- uint64_t bitrate_bps;
- uint32_t min_packets;
- uint32_t min_bytes;
- };
-
- struct BweProbeResultEvent {
- BweProbeResultEvent();
- BweProbeResultEvent(const BweProbeResultEvent&);
-
- uint64_t timestamp;
- uint32_t id;
- absl::optional<uint64_t> bitrate_bps;
- absl::optional<ProbeFailureReason> failure_reason;
- };
-
- struct BweDelayBasedUpdate {
- uint64_t timestamp;
- int32_t bitrate_bps;
- BandwidthUsage detector_state;
- };
-
- struct AlrStateEvent {
- uint64_t timestamp;
- bool in_alr;
- };
-
- struct IceCandidatePairConfig {
- uint64_t timestamp;
- IceCandidatePairConfigType type;
- uint32_t candidate_pair_id;
- IceCandidateType local_candidate_type;
- IceCandidatePairProtocol local_relay_protocol;
- IceCandidateNetworkType local_network_type;
- IceCandidatePairAddressFamily local_address_family;
- IceCandidateType remote_candidate_type;
- IceCandidatePairAddressFamily remote_address_family;
- IceCandidatePairProtocol candidate_pair_protocol;
- };
-
- struct IceCandidatePairEvent {
- uint64_t timestamp;
- IceCandidatePairEventType type;
- uint32_t candidate_pair_id;
- };
-
- enum EventType {
- UNKNOWN_EVENT = 0,
- LOG_START = 1,
- LOG_END = 2,
- RTP_EVENT = 3,
- RTCP_EVENT = 4,
- AUDIO_PLAYOUT_EVENT = 5,
- LOSS_BASED_BWE_UPDATE = 6,
- DELAY_BASED_BWE_UPDATE = 7,
- VIDEO_RECEIVER_CONFIG_EVENT = 8,
- VIDEO_SENDER_CONFIG_EVENT = 9,
- AUDIO_RECEIVER_CONFIG_EVENT = 10,
- AUDIO_SENDER_CONFIG_EVENT = 11,
- AUDIO_NETWORK_ADAPTATION_EVENT = 16,
- BWE_PROBE_CLUSTER_CREATED_EVENT = 17,
- BWE_PROBE_RESULT_EVENT = 18,
- ALR_STATE_EVENT = 19,
- ICE_CANDIDATE_PAIR_CONFIG = 20,
- ICE_CANDIDATE_PAIR_EVENT = 21,
- };
-
- enum class MediaType { ANY, AUDIO, VIDEO, DATA };
-
- // 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);
-
- // Returns the number of events in an EventStream.
- size_t GetNumberOfEvents() const;
-
- // Reads the arrival timestamp (in microseconds) from a rtclog::Event.
- int64_t GetTimestamp(size_t index) const;
-
- // Reads the event type of the rtclog::Event at |index|.
- EventType GetEventType(size_t index) 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).
- webrtc::RtpHeaderExtensionMap* GetRtpHeader(size_t index,
- PacketDirection* incoming,
- uint8_t* header,
- size_t* header_length,
- size_t* total_length,
- int* probe_cluster_id) const;
-
- // Reads packet, direction and packet length from the RTCP event at |index|,
- // and stores the values in the corresponding output parameters.
- // Each output parameter can be set to nullptr if that value isn't needed.
- // NB: The packet must have space for at least IP_PACKET_SIZE bytes.
- void GetRtcpPacket(size_t index,
- PacketDirection* incoming,
- uint8_t* packet,
- size_t* length) const;
-
- // Reads a video receive config event to a StreamConfig struct.
- // Only the fields that are stored in the protobuf will be written.
- rtclog::StreamConfig GetVideoReceiveConfig(size_t index) const;
-
- // Reads a video send config event to a StreamConfig struct. If the proto
- // contains multiple SSRCs and RTX SSRCs (this used to be the case for
- // simulcast streams) then we return one StreamConfig per SSRC,RTX_SSRC pair.
- // Only the fields that are stored in the protobuf will be written.
- std::vector<rtclog::StreamConfig> GetVideoSendConfig(size_t index) const;
-
- // Reads a audio receive config event to a StreamConfig struct.
- // Only the fields that are stored in the protobuf will be written.
- rtclog::StreamConfig GetAudioReceiveConfig(size_t index) const;
-
- // Reads a config event to a StreamConfig struct.
- // Only the fields that are stored in the protobuf will be written.
- rtclog::StreamConfig GetAudioSendConfig(size_t index) const;
-
- // Reads the SSRC from the audio playout event at |index|. The SSRC is stored
- // in the output parameter ssrc. The output parameter can be set to nullptr
- // and in that case the function only asserts that the event is well formed.
- void GetAudioPlayout(size_t index, uint32_t* ssrc) const;
-
- // Reads bitrate, fraction loss (as defined in RFC 1889) and total number of
- // expected packets from the loss based BWE event at |index| and stores the
- // values in
- // the corresponding output parameters. Each output parameter can be set to
- // nullptr if that
- // value isn't needed.
- void GetLossBasedBweUpdate(size_t index,
- int32_t* bitrate_bps,
- uint8_t* fraction_loss,
- int32_t* total_packets) const;
-
- // Reads bitrate and detector_state from the delay based BWE event at |index|
- // and stores the values in the corresponding output parameters. Each output
- // parameter can be set to nullptr if that
- // value isn't needed.
- BweDelayBasedUpdate GetDelayBasedBweUpdate(size_t index) const;
-
- // Reads a audio network adaptation event to a (non-NULL)
- // AudioEncoderRuntimeConfig struct. Only the fields that are
- // stored in the protobuf will be written.
- void GetAudioNetworkAdaptation(size_t index,
- AudioEncoderRuntimeConfig* config) const;
-
- BweProbeClusterCreatedEvent GetBweProbeClusterCreated(size_t index) const;
-
- BweProbeResultEvent GetBweProbeResult(size_t index) const;
-
- MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const;
-
- AlrStateEvent GetAlrState(size_t index) const;
-
- IceCandidatePairConfig GetIceCandidatePairConfig(size_t index) const;
- IceCandidatePairEvent GetIceCandidatePairEvent(size_t index) const;
-
- private:
- rtclog::StreamConfig GetVideoReceiveConfig(const rtclog::Event& event) const;
- std::vector<rtclog::StreamConfig> GetVideoSendConfig(
- const rtclog::Event& event) const;
- rtclog::StreamConfig GetAudioReceiveConfig(const rtclog::Event& event) const;
- rtclog::StreamConfig GetAudioSendConfig(const rtclog::Event& event) const;
-
- std::vector<rtclog::Event> events_;
-
- struct Stream {
- Stream(uint32_t ssrc,
- MediaType media_type,
- webrtc::PacketDirection direction,
- webrtc::RtpHeaderExtensionMap map)
- : ssrc(ssrc),
- media_type(media_type),
- direction(direction),
- rtp_extensions_map(map) {}
- uint32_t ssrc;
- MediaType media_type;
- webrtc::PacketDirection direction;
- webrtc::RtpHeaderExtensionMap rtp_extensions_map;
- };
-
- // All configured streams found in the event log.
- std::vector<Stream> streams_;
-
- // To find configured extensions map for given stream, what are needed to
- // parse a header.
- typedef std::pair<uint32_t, webrtc::PacketDirection> StreamId;
- std::map<StreamId, webrtc::RtpHeaderExtensionMap*> rtp_extensions_maps_;
-};
-
-} // namespace webrtc
-
-#endif // LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_
