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

Renames RtcEventLogParseNew to RtcEventLogParser

Browse Source 
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}
This commit is contained in:
Sebastian Jansson
2019-01-03 14:46:23 +01:00
committed by Commit Bot
parent a29b3a6f34
commit b290a6d767
14 changed files with 788 additions and 777 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
logging/BUILD.gn
View File

@ -291,7 +291,8 @@ if (rtc_enable_protobuf) {
visibility = [ "*" ]
sources = [
"rtc_event_log/logged_events.h",
"rtc_event_log/rtc_event_log_parser_new.cc",
"rtc_event_log/rtc_event_log_parser.cc",
"rtc_event_log/rtc_event_log_parser.h",
"rtc_event_log/rtc_event_log_parser_new.h",
"rtc_event_log/rtc_event_processor.h",
]
@ -312,6 +313,7 @@ if (rtc_enable_protobuf) {
"../modules/rtp_rtcp",
"../modules/rtp_rtcp:rtp_rtcp_format",
"../rtc_base:checks",
"../rtc_base:deprecation",
"../rtc_base:protobuf_utils",
"../rtc_base:rtc_base_approved",
"//third_party/abseil-cpp/absl/memory",

16
logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
View File

@ -32,7 +32,7 @@
#include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
#include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h"
#include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
#include "logging/rtc_event_log/rtc_event_log_parser.h"
#include "logging/rtc_event_log/rtc_event_log_unittest_helper.h"
#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
@ -74,7 +74,7 @@ class RtcEventLogEncoderTest
template <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 @@ class RtcEventLogEncoderTest
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 @@ std::unique_ptr<RtcEventRtpPacketOutgoing> RtcEventLogEncoderTest::NewRtpPacket(
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 @@ RtcEventLogEncoderTest::GetRtpPacketsBySsrc(
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) {

8
logging/rtc_event_log/rtc_event_log2rtp_dump.cc
View File

@ -21,7 +21,7 @@
#include "api/array_view.h"
#include "api/rtp_headers.h"
#include "logging/rtc_event_log/rtc_event_log.h"
#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
#include "logging/rtc_event_log/rtc_event_log_parser.h"
#include "logging/rtc_event_log/rtc_event_processor.h"
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
@ -33,7 +33,7 @@
namespace {
using MediaType = webrtc::ParsedRtcEventLogNew::MediaType;
using MediaType = webrtc::ParsedRtcEventLog::MediaType;
WEBRTC_DEFINE_bool(
audio,
@ -185,7 +185,7 @@ int main(int argc, char* argv[]) {
RTC_CHECK(ssrc_filter.has_value()) << "Failed to read SSRC filter flag.";
}
webrtc::ParsedRtcEventLogNew parsed_stream;
webrtc::ParsedRtcEventLog parsed_stream;
if (!parsed_stream.ParseFile(input_file)) {
std::cerr << "Error while parsing input file: " << input_file << std::endl;
return -1;
@ -205,7 +205,7 @@ int main(int argc, char* argv[]) {
bool header_only = false;
webrtc::RtpHeaderExtensionMap default_extension_map =
webrtc::ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap();
webrtc::ParsedRtcEventLog::GetDefaultHeaderExtensionMap();
auto handle_rtp = [&default_extension_map, &rtp_writer, &rtp_counter](
const webrtc::LoggedRtpPacketIncoming& incoming) {
webrtc::test::RtpPacket packet;

136
logging/rtc_event_log/rtc_event_log_parser_new.cc → logging/rtc_event_log/rtc_event_log_parser.cc
View File

@ -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(uint64_t timestamp_us,
LoggedRtcpPacket::LoggedRtcpPacket(const LoggedRtcpPacket& rhs) = default;
LoggedRtcpPacket::~LoggedRtcpPacket() = default;
ParsedRtcEventLogNew::~ParsedRtcEventLogNew() = default;
ParsedRtcEventLog::~ParsedRtcEventLog() = default;
ParsedRtcEventLogNew::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming() =
default;
ParsedRtcEventLogNew::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming(
ParsedRtcEventLog::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming() = default;
ParsedRtcEventLog::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming(
const LoggedRtpStreamIncoming& rhs) = default;
ParsedRtcEventLogNew::LoggedRtpStreamIncoming::~LoggedRtpStreamIncoming() =
ParsedRtcEventLog::LoggedRtpStreamIncoming::~LoggedRtpStreamIncoming() =
default;
ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing() =
default;
ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing(
ParsedRtcEventLog::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing() = default;
ParsedRtcEventLog::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing(
const LoggedRtpStreamOutgoing& rhs) = default;
ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::~LoggedRtpStreamOutgoing() =
ParsedRtcEventLog::LoggedRtpStreamOutgoing::~LoggedRtpStreamOutgoing() =
default;
ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView(
uint32_t ssrc,
const LoggedRtpPacketIncoming* ptr,
size_t num_elements)
@ -814,7 +812,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
num_elements,
offsetof(LoggedRtpPacketIncoming, rtp))) {}
ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView(
uint32_t ssrc,
const LoggedRtpPacketOutgoing* ptr,
size_t num_elements)
@ -824,7 +822,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
num_elements,
offsetof(LoggedRtpPacketOutgoing, rtp))) {}
ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView(
const LoggedRtpStreamView&) = default;
// Return default values for header extensions, to use on streams without stored
@ -833,7 +831,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
// TODO(ivoc): Remove this once this mapping is stored in the event log for
// audio streams. Tracking bug: webrtc:6399
webrtc::RtpHeaderExtensionMap
ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap() {
ParsedRtcEventLog::GetDefaultHeaderExtensionMap() {
webrtc::RtpHeaderExtensionMap default_map;
default_map.Register<AudioLevel>(webrtc::RtpExtension::kAudioLevelDefaultId);
default_map.Register<TransmissionOffset>(
@ -853,14 +851,14 @@ ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap() {
return default_map;
}
ParsedRtcEventLogNew::ParsedRtcEventLogNew(
ParsedRtcEventLog::ParsedRtcEventLog(
UnconfiguredHeaderExtensions parse_unconfigured_header_extensions)
: parse_unconfigured_header_extensions_(
parse_unconfigured_header_extensions) {
Clear();
}
void ParsedRtcEventLogNew::Clear() {
void ParsedRtcEventLog::Clear() {
default_extension_map_ = GetDefaultHeaderExtensionMap();
incoming_rtx_ssrcs_.clear();
@ -920,7 +918,7 @@ void ParsedRtcEventLogNew::Clear() {
outgoing_rtp_extensions_maps_.clear();
}
bool ParsedRtcEventLogNew::ParseFile(const std::string& filename) {
bool ParsedRtcEventLog::ParseFile(const std::string& filename) {
std::ifstream file( // no-presubmit-check TODO(webrtc:8982)
filename, std::ios_base::in | std::ios_base::binary);
if (!file.good() || !file.is_open()) {
@ -931,13 +929,13 @@ bool ParsedRtcEventLogNew::ParseFile(const std::string& filename) {
return ParseStream(file);
}
bool ParsedRtcEventLogNew::ParseString(const std::string& s) {
bool ParsedRtcEventLog::ParseString(const std::string& s) {
std::istringstream stream( // no-presubmit-check TODO(webrtc:8982)
s, std::ios_base::in | std::ios_base::binary);
return ParseStream(stream);
}
bool ParsedRtcEventLogNew::ParseStream(
bool ParsedRtcEventLog::ParseStream(
std::istream& stream) { // no-presubmit-check TODO(webrtc:8982)
Clear();
bool success = ParseStreamInternal(stream);
@ -1045,7 +1043,7 @@ bool ParsedRtcEventLogNew::ParseStream(
return success;
}
bool ParsedRtcEventLogNew::ParseStreamInternal(
bool ParsedRtcEventLog::ParseStreamInternal(
std::istream& stream) { // no-presubmit-check TODO(webrtc:8982)
constexpr uint64_t kMaxEventSize = 10000000; // Sanity check.
std::vector<char> buffer(0xFFFF);
@ -1128,14 +1126,14 @@ bool ParsedRtcEventLogNew::ParseStreamInternal(
}
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 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
}
}
int64_t ParsedRtcEventLogNew::GetTimestamp(const rtclog::Event& event) const {
int64_t ParsedRtcEventLog::GetTimestamp(const rtclog::Event& event) const {
RTC_CHECK(event.has_timestamp_us());
return event.timestamp_us();
}
// The header must have space for at least IP_PACKET_SIZE bytes.
const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader(
const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLog::GetRtpHeader(
const rtclog::Event& event,
PacketDirection* incoming,
uint8_t* header,
@ -1376,10 +1373,10 @@ const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader(
}
// The packet must have space for at least IP_PACKET_SIZE bytes.
void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event,
PacketDirection* incoming,
uint8_t* packet,
size_t* length) const {
void ParsedRtcEventLog::GetRtcpPacket(const rtclog::Event& event,
PacketDirection* incoming,
uint8_t* packet,
size_t* length) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::RTCP_EVENT);
RTC_CHECK(event.has_rtcp_packet());
@ -1403,7 +1400,7 @@ void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event,
}
}
rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig(
rtclog::StreamConfig ParsedRtcEventLog::GetVideoReceiveConfig(
const rtclog::Event& event) const {
rtclog::StreamConfig config;
RTC_CHECK(event.has_type());
@ -1464,7 +1461,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig(
return config;
}
rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoSendConfig(
rtclog::StreamConfig ParsedRtcEventLog::GetVideoSendConfig(
const rtclog::Event& event) const {
rtclog::StreamConfig config;
RTC_CHECK(event.has_type());
@ -1500,7 +1497,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoSendConfig(
return config;
}
rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig(
rtclog::StreamConfig ParsedRtcEventLog::GetAudioReceiveConfig(
const rtclog::Event& event) const {
rtclog::StreamConfig config;
RTC_CHECK(event.has_type());
@ -1519,7 +1516,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig(
return config;
}
rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig(
rtclog::StreamConfig ParsedRtcEventLog::GetAudioSendConfig(
const rtclog::Event& event) const {
rtclog::StreamConfig config;
RTC_CHECK(event.has_type());
@ -1535,7 +1532,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig(
return config;
}
LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout(
LoggedAudioPlayoutEvent ParsedRtcEventLog::GetAudioPlayout(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_PLAYOUT_EVENT);
@ -1548,7 +1545,7 @@ LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout(
return res;
}
LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate(
LoggedBweLossBasedUpdate ParsedRtcEventLog::GetLossBasedBweUpdate(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::LOSS_BASED_BWE_UPDATE);
@ -1566,7 +1563,7 @@ LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate(
return bwe_update;
}
LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate(
LoggedBweDelayBasedUpdate ParsedRtcEventLog::GetDelayBasedBweUpdate(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::DELAY_BASED_BWE_UPDATE);
@ -1583,8 +1580,7 @@ LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate(
return res;
}
LoggedAudioNetworkAdaptationEvent
ParsedRtcEventLogNew::GetAudioNetworkAdaptation(
LoggedAudioNetworkAdaptationEvent ParsedRtcEventLog::GetAudioNetworkAdaptation(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);
@ -1610,8 +1606,7 @@ ParsedRtcEventLogNew::GetAudioNetworkAdaptation(
return res;
}
LoggedBweProbeClusterCreatedEvent
ParsedRtcEventLogNew::GetBweProbeClusterCreated(
LoggedBweProbeClusterCreatedEvent ParsedRtcEventLog::GetBweProbeClusterCreated(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT);
@ -1630,7 +1625,7 @@ ParsedRtcEventLogNew::GetBweProbeClusterCreated(
return res;
}
LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
LoggedBweProbeFailureEvent ParsedRtcEventLog::GetBweProbeFailure(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
@ -1660,7 +1655,7 @@ LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
return res;
}
LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
LoggedBweProbeSuccessEvent ParsedRtcEventLog::GetBweProbeSuccess(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
@ -1679,7 +1674,7 @@ LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
return res;
}
LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState(
LoggedAlrStateEvent ParsedRtcEventLog::GetAlrState(
const rtclog::Event& event) const {
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::ALR_STATE_EVENT);
@ -1693,7 +1688,7 @@ LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState(
return res;
}
LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig(
LoggedIceCandidatePairConfig ParsedRtcEventLog::GetIceCandidatePairConfig(
const rtclog::Event& rtc_event) const {
RTC_CHECK(rtc_event.has_type());
RTC_CHECK_EQ(rtc_event.type(), rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG);
@ -1729,7 +1724,7 @@ LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig(
return res;
}
LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent(
LoggedIceCandidatePairEvent ParsedRtcEventLog::GetIceCandidatePairEvent(
const rtclog::Event& rtc_event) const {
RTC_CHECK(rtc_event.has_type());
RTC_CHECK_EQ(rtc_event.type(), rtclog::Event::ICE_CANDIDATE_PAIR_EVENT);
@ -1748,7 +1743,7 @@ LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent(
// Returns the MediaType for registered SSRCs. Search from the end to use last
// registered types first.
ParsedRtcEventLogNew::MediaType ParsedRtcEventLogNew::GetMediaType(
ParsedRtcEventLog::MediaType ParsedRtcEventLog::GetMediaType(
uint32_t ssrc,
PacketDirection direction) const {
if (direction == kIncomingPacket) {
@ -1774,7 +1769,7 @@ ParsedRtcEventLogNew::MediaType ParsedRtcEventLogNew::GetMediaType(
}
const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
const ParsedRtcEventLogNew& parsed_log) {
const ParsedRtcEventLog& parsed_log) {
using RtpPacketType = LoggedRtpPacketOutgoing;
using TransportFeedbackType = LoggedRtcpPacketTransportFeedback;
@ -1856,7 +1851,7 @@ const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
}
// Helper functions for new format start here
void ParsedRtcEventLogNew::StoreParsedNewFormatEvent(
void ParsedRtcEventLog::StoreParsedNewFormatEvent(
const rtclog2::EventStream& stream) {
RTC_DCHECK_EQ(stream.stream_size(), 0);
@ -1929,7 +1924,7 @@ void ParsedRtcEventLogNew::StoreParsedNewFormatEvent(
}
}
void ParsedRtcEventLogNew::StoreAlrStateEvent(const rtclog2::AlrState& proto) {
void ParsedRtcEventLog::StoreAlrStateEvent(const rtclog2::AlrState& proto) {
RTC_CHECK(proto.has_timestamp_ms());
RTC_CHECK(proto.has_in_alr());
LoggedAlrStateEvent alr_event;
@ -1940,7 +1935,7 @@ void ParsedRtcEventLogNew::StoreAlrStateEvent(const rtclog2::AlrState& proto) {
// TODO(terelius): Should we delta encode this event type?
}
void ParsedRtcEventLogNew::StoreAudioPlayoutEvent(
void ParsedRtcEventLog::StoreAudioPlayoutEvent(
const rtclog2::AudioPlayoutEvents& proto) {
RTC_CHECK(proto.has_timestamp_ms());
RTC_CHECK(proto.has_local_ssrc());
@ -1984,28 +1979,27 @@ void ParsedRtcEventLogNew::StoreAudioPlayoutEvent(
}
}
void ParsedRtcEventLogNew::StoreIncomingRtpPackets(
void ParsedRtcEventLog::StoreIncomingRtpPackets(
const rtclog2::IncomingRtpPackets& proto) {
StoreRtpPackets(proto, &incoming_rtp_packets_map_);
}
void ParsedRtcEventLogNew::StoreOutgoingRtpPackets(
void ParsedRtcEventLog::StoreOutgoingRtpPackets(
const rtclog2::OutgoingRtpPackets& proto) {
StoreRtpPackets(proto, &outgoing_rtp_packets_map_);
}
void ParsedRtcEventLogNew::StoreIncomingRtcpPackets(
void ParsedRtcEventLog::StoreIncomingRtcpPackets(
const rtclog2::IncomingRtcpPackets& proto) {
StoreRtcpPackets(proto, &incoming_rtcp_packets_);
}
void ParsedRtcEventLogNew::StoreOutgoingRtcpPackets(
void ParsedRtcEventLog::StoreOutgoingRtcpPackets(
const rtclog2::OutgoingRtcpPackets& proto) {
StoreRtcpPackets(proto, &outgoing_rtcp_packets_);
}
void ParsedRtcEventLogNew::StoreStartEvent(
const rtclog2::BeginLogEvent& proto) {
void ParsedRtcEventLog::StoreStartEvent(const rtclog2::BeginLogEvent& proto) {
RTC_CHECK(proto.has_timestamp_ms());
RTC_CHECK(proto.has_version());
RTC_CHECK(proto.has_utc_time_ms());
@ -2016,14 +2010,14 @@ void ParsedRtcEventLogNew::StoreStartEvent(
start_log_events_.push_back(start_event);
}
void ParsedRtcEventLogNew::StoreStopEvent(const rtclog2::EndLogEvent& proto) {
void ParsedRtcEventLog::StoreStopEvent(const rtclog2::EndLogEvent& proto) {
RTC_CHECK(proto.has_timestamp_ms());
LoggedStopEvent stop_event(proto.timestamp_ms() * 1000);
stop_log_events_.push_back(stop_event);
}
void ParsedRtcEventLogNew::StoreBweLossBasedUpdate(
void ParsedRtcEventLog::StoreBweLossBasedUpdate(
const rtclog2::LossBasedBweUpdates& proto) {
RTC_CHECK(proto.has_timestamp_ms());
RTC_CHECK(proto.has_bitrate_bps());
@ -2091,7 +2085,7 @@ void ParsedRtcEventLogNew::StoreBweLossBasedUpdate(
}
}
void ParsedRtcEventLogNew::StoreBweDelayBasedUpdate(
void ParsedRtcEventLog::StoreBweDelayBasedUpdate(
const rtclog2::DelayBasedBweUpdates& proto) {
RTC_CHECK(proto.has_timestamp_ms());
RTC_CHECK(proto.has_bitrate_bps());
@ -2148,7 +2142,7 @@ void ParsedRtcEventLogNew::StoreBweDelayBasedUpdate(
}
}
void ParsedRtcEventLogNew::StoreBweProbeClusterCreated(
void ParsedRtcEventLog::StoreBweProbeClusterCreated(
const rtclog2::BweProbeCluster& proto) {
LoggedBweProbeClusterCreatedEvent probe_cluster;
RTC_CHECK(proto.has_timestamp_ms());
@ -2167,7 +2161,7 @@ void ParsedRtcEventLogNew::StoreBweProbeClusterCreated(
// TODO(terelius): Should we delta encode this event type?
}
void ParsedRtcEventLogNew::StoreBweProbeSuccessEvent(
void ParsedRtcEventLog::StoreBweProbeSuccessEvent(
const rtclog2::BweProbeResultSuccess& proto) {
LoggedBweProbeSuccessEvent probe_result;
RTC_CHECK(proto.has_timestamp_ms());
@ -2182,7 +2176,7 @@ void ParsedRtcEventLogNew::StoreBweProbeSuccessEvent(
// TODO(terelius): Should we delta encode this event type?
}
void ParsedRtcEventLogNew::StoreBweProbeFailureEvent(
void ParsedRtcEventLog::StoreBweProbeFailureEvent(
const rtclog2::BweProbeResultFailure& proto) {
LoggedBweProbeFailureEvent probe_result;
RTC_CHECK(proto.has_timestamp_ms());
@ -2197,7 +2191,7 @@ void ParsedRtcEventLogNew::StoreBweProbeFailureEvent(
// TODO(terelius): Should we delta encode this event type?
}
void ParsedRtcEventLogNew::StoreAudioNetworkAdaptationEvent(
void ParsedRtcEventLog::StoreAudioNetworkAdaptationEvent(
const rtclog2::AudioNetworkAdaptations& proto) {
RTC_CHECK(proto.has_timestamp_ms());
@ -2350,7 +2344,7 @@ void ParsedRtcEventLogNew::StoreAudioNetworkAdaptationEvent(
}
}
void ParsedRtcEventLogNew::StoreDtlsTransportState(
void ParsedRtcEventLog::StoreDtlsTransportState(
const rtclog2::DtlsTransportStateEvent& proto) {
LoggedDtlsTransportState dtls_state;
RTC_CHECK(proto.has_timestamp_ms());
@ -2363,7 +2357,7 @@ void ParsedRtcEventLogNew::StoreDtlsTransportState(
dtls_transport_states_.push_back(dtls_state);
}
void ParsedRtcEventLogNew::StoreDtlsWritableState(
void ParsedRtcEventLog::StoreDtlsWritableState(
const rtclog2::DtlsWritableState& proto) {
LoggedDtlsWritableState dtls_writable_state;
RTC_CHECK(proto.has_timestamp_ms());
@ -2374,7 +2368,7 @@ void ParsedRtcEventLogNew::StoreDtlsWritableState(
dtls_writable_states_.push_back(dtls_writable_state);
}
void ParsedRtcEventLogNew::StoreIceCandidatePairConfig(
void ParsedRtcEventLog::StoreIceCandidatePairConfig(
const rtclog2::IceCandidatePairConfig& proto) {
LoggedIceCandidatePairConfig ice_config;
RTC_CHECK(proto.has_timestamp_ms());
@ -2411,7 +2405,7 @@ void ParsedRtcEventLogNew::StoreIceCandidatePairConfig(
// TODO(terelius): Should we delta encode this event type?
}
void ParsedRtcEventLogNew::StoreIceCandidateEvent(
void ParsedRtcEventLog::StoreIceCandidateEvent(
const rtclog2::IceCandidatePairEvent& proto) {
LoggedIceCandidatePairEvent ice_event;
RTC_CHECK(proto.has_timestamp_ms());
@ -2430,7 +2424,7 @@ void ParsedRtcEventLogNew::StoreIceCandidateEvent(
// TODO(terelius): Should we delta encode this event type?
}
void ParsedRtcEventLogNew::StoreVideoRecvConfig(
void ParsedRtcEventLog::StoreVideoRecvConfig(
const rtclog2::VideoRecvStreamConfig& proto) {
LoggedVideoRecvConfig stream;
RTC_CHECK(proto.has_timestamp_ms());
@ -2449,7 +2443,7 @@ void ParsedRtcEventLogNew::StoreVideoRecvConfig(
video_recv_configs_.push_back(stream);
}
void ParsedRtcEventLogNew::StoreVideoSendConfig(
void ParsedRtcEventLog::StoreVideoSendConfig(
const rtclog2::VideoSendStreamConfig& proto) {
LoggedVideoSendConfig stream;
RTC_CHECK(proto.has_timestamp_ms());
@ -2466,7 +2460,7 @@ void ParsedRtcEventLogNew::StoreVideoSendConfig(
video_send_configs_.push_back(stream);
}
void ParsedRtcEventLogNew::StoreAudioRecvConfig(
void ParsedRtcEventLog::StoreAudioRecvConfig(
const rtclog2::AudioRecvStreamConfig& proto) {
LoggedAudioRecvConfig stream;
RTC_CHECK(proto.has_timestamp_ms());
@ -2482,7 +2476,7 @@ void ParsedRtcEventLogNew::StoreAudioRecvConfig(
audio_recv_configs_.push_back(stream);
}
void ParsedRtcEventLogNew::StoreAudioSendConfig(
void ParsedRtcEventLog::StoreAudioSendConfig(
const rtclog2::AudioSendStreamConfig& proto) {
LoggedAudioSendConfig stream;
RTC_CHECK(proto.has_timestamp_ms());

686
logging/rtc_event_log/rtc_event_log_parser.h Normal file
View File

@ -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_

677
logging/rtc_event_log/rtc_event_log_parser_new.h
View File

@ -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_

6
logging/rtc_event_log/rtc_event_log_unittest.cc
View File

@ -37,7 +37,7 @@
#include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
#include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
#include "logging/rtc_event_log/rtc_event_log.h"
#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
#include "logging/rtc_event_log/rtc_event_log_parser.h"
#include "logging/rtc_event_log/rtc_event_log_unittest_helper.h"
#include "logging/rtc_event_log/rtc_stream_config.h"
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
@ -498,7 +498,7 @@ void RtcEventLogSession::WriteLog(EventCounts count,
// same as what we wrote down.
void RtcEventLogSession::ReadAndVerifyLog() {
// Read the generated file from disk.
ParsedRtcEventLogNew parsed_log;
ParsedRtcEventLog parsed_log;
ASSERT_TRUE(parsed_log.ParseFile(temp_filename_));
// Start and stop events.
@ -785,7 +785,7 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) {
log_dumper->StopLogging();
// Read the generated file from disk.
ParsedRtcEventLogNew parsed_log;
ParsedRtcEventLog parsed_log;
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
const auto& start_log_events = parsed_log.start_log_events();

2
logging/rtc_event_log/rtc_event_log_unittest_helper.h
View File

@ -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"

2
logging/rtc_event_log/rtc_event_processor_unittest.cc
View File

@ -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"

8
modules/audio_coding/neteq/tools/rtc_event_log_source.cc
View File

@ -24,10 +24,10 @@ namespace webrtc {
namespace test {
namespace {
bool ShouldSkipStream(ParsedRtcEventLogNew::MediaType media_type,
bool ShouldSkipStream(ParsedRtcEventLog::MediaType media_type,
uint32_t ssrc,
absl::optional<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 @@ RtcEventLogSource::RtcEventLogSource() : PacketSource() {}
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 @@ bool RtcEventLogSource::OpenFile(const std::string& file_name,
// This wouldn't be needed if we knew that there was at most one audio stream.
webrtc::RtcEventProcessor event_processor;
for (const auto& rtp_packets : parsed_log.incoming_rtp_packets_by_ssrc()) {
ParsedRtcEventLogNew::MediaType media_type =
ParsedRtcEventLog::MediaType media_type =
parsed_log.GetMediaType(rtp_packets.ssrc, webrtc::kIncomingPacket);
if (ShouldSkipStream(media_type, rtp_packets.ssrc, ssrc_filter)) {
continue;

2
modules/audio_coding/neteq/tools/rtc_event_log_source.h
View File

@ -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"

2
rtc_tools/event_log_visualizer/analyzer.cc
View File

@ -445,7 +445,7 @@ std::string GetDirectionAsShortString(PacketDirection direction) {
} // namespace
EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLogNew& log,
EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log,
bool normalize_time)
: parsed_log_(log),
window_duration_(250000),

6
rtc_tools/event_log_visualizer/analyzer.h
View File

@ -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 @@ class EventLogAnalyzer {
// The EventLogAnalyzer keeps a reference to the ParsedRtcEventLogNew for the
// duration of its lifetime. The ParsedRtcEventLogNew must not be destroyed or
// modified while the EventLogAnalyzer is being used.
EventLogAnalyzer(const ParsedRtcEventLogNew& log, bool normalize_time);
EventLogAnalyzer(const ParsedRtcEventLog& log, bool normalize_time);
void CreatePacketGraph(PacketDirection direction, Plot* plot);
@ -223,7 +223,7 @@ class EventLogAnalyzer {
std::string GetCandidatePairLogDescriptionFromId(uint32_t candidate_pair_id);
const ParsedRtcEventLogNew& parsed_log_;
const ParsedRtcEventLog& parsed_log_;
// A list of SSRCs we are interested in analysing.
// If left empty, all SSRCs will be considered relevant.

10
rtc_tools/event_log_visualizer/main.cc
View File

@ -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 @@ int main(int argc, char* argv[]) {
std::string filename = argv[1];
webrtc::ParsedRtcEventLogNew::UnconfiguredHeaderExtensions header_extensions =
webrtc::ParsedRtcEventLogNew::UnconfiguredHeaderExtensions::kDontParse;
webrtc::ParsedRtcEventLog::UnconfiguredHeaderExtensions header_extensions =
webrtc::ParsedRtcEventLog::UnconfiguredHeaderExtensions::kDontParse;
if (FLAG_parse_unconfigured_header_extensions) {
header_extensions = webrtc::ParsedRtcEventLogNew::
header_extensions = webrtc::ParsedRtcEventLog::
UnconfiguredHeaderExtensions::kAttemptWebrtcDefaultConfig;
}
webrtc::ParsedRtcEventLogNew parsed_log(header_extensions);
webrtc::ParsedRtcEventLog parsed_log(header_extensions);
if (!parsed_log.ParseFile(filename)) {
std::cerr << "Could not parse the entire log file." << std::endl;