Remove rtc_event_log2text
out/Default/protoc --decode=webrtc.rtclog.EventStream logging/rtc_event_log/rtc_event_log.proto < event_log_filename
performs a similar function.
Bug: webrtc:8111
Change-Id: I4aed302857651ec418dbc1bb05c97daf582bc83e
Reviewed-on: https://webrtc-review.googlesource.com/c/110725
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25627}diff --git a/logging/BUILD.gn b/logging/BUILD.gn
index ef9d589..90cf08a 100644
--- a/logging/BUILD.gn
+++ b/logging/BUILD.gn
@@ -392,35 +392,6 @@
}
}
}
-
- if (rtc_include_tests) {
- rtc_executable("rtc_event_log2text") {
- testonly = true
- sources = [
- "rtc_event_log/rtc_event_log2text.cc",
- ]
- deps = [
- ":rtc_event_log_api",
- ":rtc_event_log_parser",
- "../:webrtc_common",
- "../call:video_stream_api",
- "../modules/rtp_rtcp:rtp_rtcp_format",
- "../rtc_base:checks",
- "../rtc_base:protobuf_utils",
- "../rtc_base:rtc_base_approved",
- "../rtc_base:stringutils",
-
- # TODO(kwiberg): Remove this dependency.
- "../api/audio_codecs:audio_codecs_api",
- "../modules/audio_coding:audio_network_adaptor_config",
- "../modules/rtp_rtcp",
- ]
- if (!build_with_chromium && is_clang) {
- # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
- suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
- }
- }
- }
}
rtc_source_set("ice_log") {
diff --git a/logging/rtc_event_log/rtc_event_log2text.cc b/logging/rtc_event_log/rtc_event_log2text.cc
deleted file mode 100644
index 4cdde7d..0000000
--- a/logging/rtc_event_log/rtc_event_log2text.cc
+++ /dev/null
@@ -1,890 +0,0 @@
-/*
- * Copyright (c) 2017 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 <string.h>
-
-#include <iomanip> // setfill, setw
-#include <iostream>
-#include <map>
-#include <string>
-#include <utility> // pair
-
-#include "common_types.h" // NOLINT(build/include)
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
-#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/pli.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
-#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
-#include "modules/rtp_rtcp/source/rtp_utility.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/flags.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/strings/string_builder.h"
-
-namespace {
-
-WEBRTC_DEFINE_bool(unknown, true, "Use --nounknown to exclude unknown events.");
-WEBRTC_DEFINE_bool(startstop,
- true,
- "Use --nostartstop to exclude start/stop events.");
-WEBRTC_DEFINE_bool(config,
- true,
- "Use --noconfig to exclude stream configurations.");
-WEBRTC_DEFINE_bool(bwe, true, "Use --nobwe to exclude BWE events.");
-WEBRTC_DEFINE_bool(incoming,
- true,
- "Use --noincoming to exclude incoming packets.");
-WEBRTC_DEFINE_bool(outgoing, true, "Use --nooutgoing to exclude packets.");
-// TODO(terelius): Note that the media type doesn't work with outgoing packets.
-WEBRTC_DEFINE_bool(audio, true, "Use --noaudio to exclude audio packets.");
-// TODO(terelius): Note that the media type doesn't work with outgoing packets.
-WEBRTC_DEFINE_bool(video, true, "Use --novideo to exclude video packets.");
-// TODO(terelius): Note that the media type doesn't work with outgoing packets.
-WEBRTC_DEFINE_bool(data, true, "Use --nodata to exclude data packets.");
-WEBRTC_DEFINE_bool(rtp, true, "Use --nortp to exclude RTP packets.");
-WEBRTC_DEFINE_bool(rtcp, true, "Use --nortcp to exclude RTCP packets.");
-WEBRTC_DEFINE_bool(playout,
- true,
- "Use --noplayout to exclude audio playout events.");
-WEBRTC_DEFINE_bool(ana, true, "Use --noana to exclude ANA events.");
-WEBRTC_DEFINE_bool(probe, true, "Use --noprobe to exclude probe events.");
-WEBRTC_DEFINE_bool(ice, true, "Use --noice to exclude ICE events.");
-
-WEBRTC_DEFINE_bool(print_full_packets,
- false,
- "Print the full RTP headers and RTCP packets in hex.");
-
-// TODO(terelius): Allow a list of SSRCs.
-WEBRTC_DEFINE_string(
- ssrc,
- "",
- "Print only packets with this SSRC (decimal or hex, the latter "
- "starting with 0x).");
-WEBRTC_DEFINE_bool(help, false, "Prints this message.");
-
-using MediaType = webrtc::ParsedRtcEventLogNew::MediaType;
-
-static uint32_t filtered_ssrc = 0;
-
-// Parses the input string for a valid SSRC. If a valid SSRC is found, it is
-// written to the static global variable |filtered_ssrc|, and true is returned.
-// Otherwise, false is returned.
-// The empty string must be validated as true, because it is the default value
-// of the command-line flag. In this case, no value is written to the output
-// variable.
-bool ParseSsrc(std::string str) {
- // If the input string starts with 0x or 0X it indicates a hexadecimal number.
- auto read_mode = std::dec;
- if (str.size() > 2 &&
- (str.substr(0, 2) == "0x" || str.substr(0, 2) == "0X")) {
- read_mode = std::hex;
- str = str.substr(2);
- }
- std::stringstream ss(str);
- ss >> read_mode >> filtered_ssrc;
- return str.empty() || (!ss.fail() && ss.eof());
-}
-
-bool ExcludePacket(webrtc::PacketDirection direction,
- MediaType media_type,
- uint32_t packet_ssrc) {
- if (!FLAG_outgoing && direction == webrtc::kOutgoingPacket)
- return true;
- if (!FLAG_incoming && direction == webrtc::kIncomingPacket)
- return true;
- if (!FLAG_audio && media_type == MediaType::AUDIO)
- return true;
- if (!FLAG_video && media_type == MediaType::VIDEO)
- return true;
- if (!FLAG_data && media_type == MediaType::DATA)
- return true;
- if (strlen(FLAG_ssrc) > 0 && packet_ssrc != filtered_ssrc)
- return true;
- return false;
-}
-
-const char* StreamInfo(webrtc::PacketDirection direction,
- MediaType media_type) {
- if (direction == webrtc::kOutgoingPacket) {
- if (media_type == MediaType::AUDIO)
- return "(out,audio)";
- else if (media_type == MediaType::VIDEO)
- return "(out,video)";
- else if (media_type == MediaType::DATA)
- return "(out,data)";
- else
- return "(out)";
- }
- if (direction == webrtc::kIncomingPacket) {
- if (media_type == MediaType::AUDIO)
- return "(in,audio)";
- else if (media_type == MediaType::VIDEO)
- return "(in,video)";
- else if (media_type == MediaType::DATA)
- return "(in,data)";
- else
- return "(in)";
- }
- return "(unknown)";
-}
-
-// Return default values for header extensions, to use on streams without stored
-// mapping data. Currently this only applies to audio streams, since the mapping
-// is not stored in the event log.
-// TODO(ivoc): Remove this once this mapping is stored in the event log for
-// audio streams. Tracking bug: webrtc:6399
-webrtc::RtpHeaderExtensionMap GetDefaultHeaderExtensionMap() {
- webrtc::RtpHeaderExtensionMap default_map;
- default_map.Register<webrtc::AudioLevel>(
- webrtc::RtpExtension::kAudioLevelDefaultId);
- default_map.Register<webrtc::TransmissionOffset>(
- webrtc::RtpExtension::kTimestampOffsetDefaultId);
- default_map.Register<webrtc::AbsoluteSendTime>(
- webrtc::RtpExtension::kAbsSendTimeDefaultId);
- default_map.Register<webrtc::VideoOrientation>(
- webrtc::RtpExtension::kVideoRotationDefaultId);
- default_map.Register<webrtc::VideoContentTypeExtension>(
- webrtc::RtpExtension::kVideoContentTypeDefaultId);
- default_map.Register<webrtc::VideoTimingExtension>(
- webrtc::RtpExtension::kVideoTimingDefaultId);
- default_map.Register<webrtc::FrameMarkingExtension>(
- webrtc::RtpExtension::kFrameMarkingDefaultId);
- default_map.Register<webrtc::TransportSequenceNumber>(
- webrtc::RtpExtension::kTransportSequenceNumberDefaultId);
- default_map.Register<webrtc::PlayoutDelayLimits>(
- webrtc::RtpExtension::kPlayoutDelayDefaultId);
- return default_map;
-}
-
-void PrintSenderReport(const webrtc::ParsedRtcEventLogNew& parsed_stream,
- const webrtc::rtcp::CommonHeader& rtcp_block,
- uint64_t log_timestamp,
- webrtc::PacketDirection direction) {
- webrtc::rtcp::SenderReport sr;
- if (!sr.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(sr.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, sr.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_SR" << StreamInfo(direction, media_type)
- << "\tssrc=" << sr.sender_ssrc()
- << "\ttimestamp=" << sr.rtp_timestamp() << std::endl;
-}
-
-void PrintReceiverReport(const webrtc::ParsedRtcEventLogNew& parsed_stream,
- const webrtc::rtcp::CommonHeader& rtcp_block,
- uint64_t log_timestamp,
- webrtc::PacketDirection direction) {
- webrtc::rtcp::ReceiverReport rr;
- if (!rr.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(rr.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, rr.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_RR" << StreamInfo(direction, media_type)
- << "\tssrc=" << rr.sender_ssrc() << std::endl;
-}
-
-void PrintXr(const webrtc::ParsedRtcEventLogNew& parsed_stream,
- const webrtc::rtcp::CommonHeader& rtcp_block,
- uint64_t log_timestamp,
- webrtc::PacketDirection direction) {
- webrtc::rtcp::ExtendedReports xr;
- if (!xr.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(xr.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, xr.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_XR" << StreamInfo(direction, media_type)
- << "\tssrc=" << xr.sender_ssrc() << std::endl;
-}
-
-void PrintSdes(const webrtc::rtcp::CommonHeader& rtcp_block,
- uint64_t log_timestamp,
- webrtc::PacketDirection direction) {
- std::cout << log_timestamp << "\t"
- << "RTCP_SDES" << StreamInfo(direction, MediaType::ANY)
- << std::endl;
- RTC_NOTREACHED() << "SDES should have been redacted when writing the log";
-}
-
-void PrintBye(const webrtc::ParsedRtcEventLogNew& parsed_stream,
- const webrtc::rtcp::CommonHeader& rtcp_block,
- uint64_t log_timestamp,
- webrtc::PacketDirection direction) {
- webrtc::rtcp::Bye bye;
- if (!bye.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(bye.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, bye.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_BYE" << StreamInfo(direction, media_type)
- << "\tssrc=" << bye.sender_ssrc() << std::endl;
-}
-
-void PrintRtpFeedback(const webrtc::ParsedRtcEventLogNew& parsed_stream,
- const webrtc::rtcp::CommonHeader& rtcp_block,
- uint64_t log_timestamp,
- webrtc::PacketDirection direction) {
- switch (rtcp_block.fmt()) {
- case webrtc::rtcp::Nack::kFeedbackMessageType: {
- webrtc::rtcp::Nack nack;
- if (!nack.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(nack.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, nack.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_NACK" << StreamInfo(direction, media_type)
- << "\tssrc=" << nack.sender_ssrc() << std::endl;
- break;
- }
- case webrtc::rtcp::Tmmbr::kFeedbackMessageType: {
- webrtc::rtcp::Tmmbr tmmbr;
- if (!tmmbr.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(tmmbr.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, tmmbr.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_TMMBR" << StreamInfo(direction, media_type)
- << "\tssrc=" << tmmbr.sender_ssrc() << std::endl;
- break;
- }
- case webrtc::rtcp::Tmmbn::kFeedbackMessageType: {
- webrtc::rtcp::Tmmbn tmmbn;
- if (!tmmbn.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(tmmbn.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, tmmbn.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_TMMBN" << StreamInfo(direction, media_type)
- << "\tssrc=" << tmmbn.sender_ssrc() << std::endl;
- break;
- }
- case webrtc::rtcp::RapidResyncRequest::kFeedbackMessageType: {
- webrtc::rtcp::RapidResyncRequest sr_req;
- if (!sr_req.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(sr_req.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, sr_req.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_SRREQ" << StreamInfo(direction, media_type)
- << "\tssrc=" << sr_req.sender_ssrc() << std::endl;
- break;
- }
- case webrtc::rtcp::TransportFeedback::kFeedbackMessageType: {
- webrtc::rtcp::TransportFeedback transport_feedback;
- if (!transport_feedback.Parse(rtcp_block))
- return;
- MediaType media_type = parsed_stream.GetMediaType(
- transport_feedback.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type,
- transport_feedback.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_NEWFB" << StreamInfo(direction, media_type)
- << "\tsender_ssrc=" << transport_feedback.sender_ssrc()
- << "\tmedia_ssrc=" << transport_feedback.media_ssrc()
- << std::endl;
- break;
- }
- default:
- std::cout << log_timestamp << "\t"
- << "RTCP_RTPFB(UNKNOWN)" << std::endl;
- break;
- }
-}
-
-void PrintPsFeedback(const webrtc::ParsedRtcEventLogNew& parsed_stream,
- const webrtc::rtcp::CommonHeader& rtcp_block,
- uint64_t log_timestamp,
- webrtc::PacketDirection direction) {
- switch (rtcp_block.fmt()) {
- case webrtc::rtcp::Pli::kFeedbackMessageType: {
- webrtc::rtcp::Pli pli;
- if (!pli.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(pli.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, pli.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_PLI" << StreamInfo(direction, media_type)
- << "\tssrc=" << pli.sender_ssrc() << std::endl;
- break;
- }
- case webrtc::rtcp::Fir::kFeedbackMessageType: {
- webrtc::rtcp::Fir fir;
- if (!fir.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(fir.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, fir.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_FIR" << StreamInfo(direction, media_type)
- << "\tssrc=" << fir.sender_ssrc() << std::endl;
- break;
- }
- case webrtc::rtcp::Remb::kFeedbackMessageType: {
- webrtc::rtcp::Remb remb;
- if (!remb.Parse(rtcp_block))
- return;
- MediaType media_type =
- parsed_stream.GetMediaType(remb.sender_ssrc(), direction);
- if (ExcludePacket(direction, media_type, remb.sender_ssrc()))
- return;
- std::cout << log_timestamp << "\t"
- << "RTCP_REMB" << StreamInfo(direction, media_type)
- << "\tssrc=" << remb.sender_ssrc() << std::endl;
- break;
- }
- default:
- std::cout << log_timestamp << "\t"
- << "RTCP_PSFB(UNKNOWN)" << std::endl;
- break;
- }
-}
-
-enum class InputSource {
- STDIN,
- FILE,
-};
-
-void PrintUsageGuide(const std::string& program_name) {
- std::cout
- << "Tool for printing packet information from an RtcEventLog as text.\n"
- << "* Run " + program_name + " --help for usage.\n"
- << "* Example usage for parsing a file:\n"
- << " " << program_name + " input.rel\n"
- << "* Example usage for parsing the stdin:\n"
- << " " << program_name + "\n";
-}
-
-// TODO(eladalon): Return a stream or file descriptor instead.
-InputSource ParseCommandLineFlags(int argc, char* argv[]) {
- if (rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true) != 0) {
- PrintUsageGuide(argv[0]);
- exit(-1);
- }
-
- if (FLAG_help) {
- PrintUsageGuide(argv[0]);
- std::cout << std::endl;
- rtc::FlagList::Print(nullptr, false);
- exit(0);
- }
-
- switch (argc) {
- case 1:
- return InputSource::STDIN;
- case 2:
- return InputSource::FILE;
- default:
- PrintUsageGuide(argv[0]);
- exit(-1);
- }
-}
-
-} // namespace
-
-// This utility will print basic information about each packet to stdout.
-// Note that parser will assert if the protobuf event is missing some required
-// fields and we attempt to access them. We don't handle this at the moment.
-int main(int argc, char* argv[]) {
- InputSource input_source = ParseCommandLineFlags(argc, argv);
-
- if (strlen(FLAG_ssrc) > 0)
- RTC_CHECK(ParseSsrc(FLAG_ssrc)) << "Flag verification has failed.";
-
- webrtc::RtpHeaderExtensionMap default_map = GetDefaultHeaderExtensionMap();
- bool default_map_used = false;
-
- webrtc::ParsedRtcEventLogNew parsed_stream;
-
- switch (input_source) {
- case InputSource::STDIN: {
- if (!parsed_stream.ParseStream(std::cin)) {
- std::cerr << "Error while parsing input stream." << std::endl;
- return -1;
- }
- break;
- }
- case InputSource::FILE: {
- if (!parsed_stream.ParseFile(argv[1])) {
- std::cerr << "Error while parsing input file: " << argv[1] << std::endl;
- return -1;
- }
- break;
- }
- default: { RTC_NOTREACHED() << "Unsupported input source."; }
- }
-
- for (size_t i = 0; i < parsed_stream.GetNumberOfEvents(); i++) {
- bool event_recognized = false;
- switch (parsed_stream.GetEventType(i)) {
- case webrtc::ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT: {
- if (FLAG_unknown) {
- std::cout << parsed_stream.GetTimestamp(i) << "\tUNKNOWN_EVENT"
- << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::LOG_START: {
- if (FLAG_startstop) {
- std::cout << parsed_stream.GetTimestamp(i) << "\tLOG_START"
- << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::LOG_END: {
- if (FLAG_startstop) {
- std::cout << parsed_stream.GetTimestamp(i) << "\tLOG_END"
- << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::RTP_EVENT: {
- if (FLAG_rtp) {
- size_t header_length;
- size_t total_length;
- uint8_t header[IP_PACKET_SIZE];
- webrtc::PacketDirection direction;
- const webrtc::RtpHeaderExtensionMap* extension_map =
- parsed_stream.GetRtpHeader(i, &direction, header, &header_length,
- &total_length, nullptr);
-
- if (extension_map == nullptr) {
- extension_map = &default_map;
- if (!default_map_used)
- RTC_LOG(LS_WARNING) << "Using default header extension map";
- default_map_used = true;
- }
-
- // Parse header to get SSRC and RTP time.
- webrtc::RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
- webrtc::RTPHeader parsed_header;
- rtp_parser.Parse(&parsed_header, extension_map);
- MediaType media_type =
- parsed_stream.GetMediaType(parsed_header.ssrc, direction);
-
- if (ExcludePacket(direction, media_type, parsed_header.ssrc)) {
- event_recognized = true;
- break;
- }
-
- std::cout << parsed_stream.GetTimestamp(i) << "\tRTP"
- << StreamInfo(direction, media_type)
- << "\tssrc=" << parsed_header.ssrc
- << "\ttimestamp=" << parsed_header.timestamp;
- if (parsed_header.extension.hasAbsoluteSendTime) {
- std::cout << "\tAbsSendTime="
- << parsed_header.extension.absoluteSendTime;
- }
- if (parsed_header.extension.hasVideoContentType) {
- std::cout << "\tContentType="
- << static_cast<int>(
- parsed_header.extension.videoContentType);
- }
- if (parsed_header.extension.hasVideoRotation) {
- std::cout << "\tRotation="
- << static_cast<int>(
- parsed_header.extension.videoRotation);
- }
- if (parsed_header.extension.hasTransportSequenceNumber) {
- std::cout << "\tTransportSeq="
- << parsed_header.extension.transportSequenceNumber;
- }
- if (parsed_header.extension.hasTransmissionTimeOffset) {
- std::cout << "\tTransmTimeOffset="
- << parsed_header.extension.transmissionTimeOffset;
- }
- if (parsed_header.extension.hasAudioLevel) {
- std::cout << "\tAudioLevel="
- << static_cast<int>(parsed_header.extension.audioLevel);
- }
- std::cout << std::endl;
- if (FLAG_print_full_packets) {
- // TODO(terelius): Rewrite this file to use printf instead of cout.
- std::cout << "\t\t" << std::hex;
- char prev_fill = std::cout.fill('0');
- for (size_t i = 0; i < header_length; i++) {
- std::cout << std::setw(2) << static_cast<unsigned>(header[i]);
- if (i % 4 == 3)
- std::cout << " "; // Separator between 32-bit words.
- }
- std::cout.fill(prev_fill);
- std::cout << std::dec << std::endl;
- }
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::RTCP_EVENT: {
- if (FLAG_rtcp) {
- size_t length;
- uint8_t packet[IP_PACKET_SIZE];
- webrtc::PacketDirection direction;
- parsed_stream.GetRtcpPacket(i, &direction, packet, &length);
-
- webrtc::rtcp::CommonHeader rtcp_block;
- const uint8_t* packet_end = packet + length;
- for (const uint8_t* next_block = packet; next_block != packet_end;
- next_block = rtcp_block.NextPacket()) {
- ptrdiff_t remaining_blocks_size = packet_end - next_block;
- RTC_DCHECK_GT(remaining_blocks_size, 0);
- if (!rtcp_block.Parse(next_block, remaining_blocks_size)) {
- RTC_LOG(LS_WARNING) << "Failed to parse RTCP";
- break;
- }
-
- uint64_t log_timestamp = parsed_stream.GetTimestamp(i);
- switch (rtcp_block.type()) {
- case webrtc::rtcp::SenderReport::kPacketType:
- PrintSenderReport(parsed_stream, rtcp_block, log_timestamp,
- direction);
- break;
- case webrtc::rtcp::ReceiverReport::kPacketType:
- PrintReceiverReport(parsed_stream, rtcp_block, log_timestamp,
- direction);
- break;
- case webrtc::rtcp::Sdes::kPacketType:
- PrintSdes(rtcp_block, log_timestamp, direction);
- break;
- case webrtc::rtcp::ExtendedReports::kPacketType:
- PrintXr(parsed_stream, rtcp_block, log_timestamp, direction);
- break;
- case webrtc::rtcp::Bye::kPacketType:
- PrintBye(parsed_stream, rtcp_block, log_timestamp, direction);
- break;
- case webrtc::rtcp::Rtpfb::kPacketType:
- PrintRtpFeedback(parsed_stream, rtcp_block, log_timestamp,
- direction);
- break;
- case webrtc::rtcp::Psfb::kPacketType:
- PrintPsFeedback(parsed_stream, rtcp_block, log_timestamp,
- direction);
- break;
- default:
- break;
- }
- if (FLAG_print_full_packets) {
- std::cout << "\t\t" << std::hex;
- char prev_fill = std::cout.fill('0');
- for (const uint8_t* p = next_block; p < rtcp_block.NextPacket();
- p++) {
- std::cout << std::setw(2) << static_cast<unsigned>(*p);
- ptrdiff_t chars_printed = p - next_block;
- if (chars_printed % 4 == 3)
- std::cout << " "; // Separator between 32-bit words.
- }
- std::cout.fill(prev_fill);
- std::cout << std::dec << std::endl;
- }
- }
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT: {
- if (FLAG_playout) {
- auto audio_playout = parsed_stream.GetAudioPlayout(i);
- std::cout << audio_playout.log_time_us() << "\tAUDIO_PLAYOUT"
- << "\tssrc=" << audio_playout.ssrc << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE: {
- if (FLAG_bwe) {
- auto bwe_update = parsed_stream.GetLossBasedBweUpdate(i);
- std::cout << bwe_update.log_time_us() << "\tBWE(LOSS_BASED)"
- << "\tbitrate_bps=" << bwe_update.bitrate_bps
- << "\tfraction_lost="
- << static_cast<unsigned>(bwe_update.fraction_lost)
- << "\texpected_packets=" << bwe_update.expected_packets
- << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE: {
- if (FLAG_bwe) {
- auto bwe_update = parsed_stream.GetDelayBasedBweUpdate(i);
- std::cout << bwe_update.log_time_us() << "\tBWE(DELAY_BASED)"
- << "\tbitrate_bps=" << bwe_update.bitrate_bps
- << "\tdetector_state="
- << static_cast<int>(bwe_update.detector_state) << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::
- VIDEO_RECEIVER_CONFIG_EVENT: {
- if (FLAG_config && FLAG_video && FLAG_incoming) {
- webrtc::rtclog::StreamConfig config =
- parsed_stream.GetVideoReceiveConfig(i);
- std::cout << parsed_stream.GetTimestamp(i) << "\tVIDEO_RECV_CONFIG"
- << "\tssrc=" << config.remote_ssrc
- << "\tfeedback_ssrc=" << config.local_ssrc;
- std::cout << "\textensions={";
- for (const auto& extension : config.rtp_extensions) {
- std::cout << extension.ToString() << ",";
- }
- std::cout << "}";
- std::cout << "\tcodecs={";
- for (const auto& codec : config.codecs) {
- std::cout << "{name: " << codec.payload_name
- << ", payload_type: " << codec.payload_type
- << ", rtx_payload_type: " << codec.rtx_payload_type
- << "}";
- }
- std::cout << "}" << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT: {
- if (FLAG_config && FLAG_video && FLAG_outgoing) {
- std::vector<webrtc::rtclog::StreamConfig> configs =
- parsed_stream.GetVideoSendConfig(i);
- for (const auto& config : configs) {
- std::cout << parsed_stream.GetTimestamp(i) << "\tVIDEO_SEND_CONFIG";
- std::cout << "\tssrcs=" << config.local_ssrc;
- std::cout << "\trtx_ssrcs=" << config.rtx_ssrc;
- std::cout << "\textensions={";
- for (const auto& extension : config.rtp_extensions) {
- std::cout << extension.ToString() << ",";
- }
- std::cout << "}";
- std::cout << "\tcodecs={";
- for (const auto& codec : config.codecs) {
- std::cout << "{name: " << codec.payload_name
- << ", payload_type: " << codec.payload_type
- << ", rtx_payload_type: " << codec.rtx_payload_type
- << "}";
- }
- std::cout << "}" << std::endl;
- }
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::
- AUDIO_RECEIVER_CONFIG_EVENT: {
- if (FLAG_config && FLAG_audio && FLAG_incoming) {
- webrtc::rtclog::StreamConfig config =
- parsed_stream.GetAudioReceiveConfig(i);
- std::cout << parsed_stream.GetTimestamp(i) << "\tAUDIO_RECV_CONFIG"
- << "\tssrc=" << config.remote_ssrc
- << "\tfeedback_ssrc=" << config.local_ssrc;
- std::cout << "\textensions={";
- for (const auto& extension : config.rtp_extensions) {
- std::cout << extension.ToString() << ",";
- }
- std::cout << "}";
- std::cout << "\tcodecs={";
- for (const auto& codec : config.codecs) {
- std::cout << "{name: " << codec.payload_name
- << ", payload_type: " << codec.payload_type
- << ", rtx_payload_type: " << codec.rtx_payload_type
- << "}";
- }
- std::cout << "}" << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT: {
- if (FLAG_config && FLAG_audio && FLAG_outgoing) {
- webrtc::rtclog::StreamConfig config =
- parsed_stream.GetAudioSendConfig(i);
- std::cout << parsed_stream.GetTimestamp(i) << "\tAUDIO_SEND_CONFIG"
- << "\tssrc=" << config.local_ssrc;
- std::cout << "\textensions={";
- for (const auto& extension : config.rtp_extensions) {
- std::cout << extension.ToString() << ",";
- }
- std::cout << "}";
- std::cout << "\tcodecs={";
- for (const auto& codec : config.codecs) {
- std::cout << "{name: " << codec.payload_name
- << ", payload_type: " << codec.payload_type
- << ", rtx_payload_type: " << codec.rtx_payload_type
- << "}";
- }
- std::cout << "}" << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::
- AUDIO_NETWORK_ADAPTATION_EVENT: {
- if (FLAG_ana) {
- auto ana_event = parsed_stream.GetAudioNetworkAdaptation(i);
- char buffer[300];
- rtc::SimpleStringBuilder builder(buffer);
- builder << parsed_stream.GetTimestamp(i) << "\tANA_UPDATE";
- if (ana_event.config.bitrate_bps) {
- builder << "\tbitrate_bps=" << *ana_event.config.bitrate_bps;
- }
- if (ana_event.config.frame_length_ms) {
- builder << "\tframe_length_ms="
- << *ana_event.config.frame_length_ms;
- }
- if (ana_event.config.uplink_packet_loss_fraction) {
- builder << "\tuplink_packet_loss_fraction="
- << *ana_event.config.uplink_packet_loss_fraction;
- }
- if (ana_event.config.enable_fec) {
- builder << "\tenable_fec=" << *ana_event.config.enable_fec;
- }
- if (ana_event.config.enable_dtx) {
- builder << "\tenable_dtx=" << *ana_event.config.enable_dtx;
- }
- if (ana_event.config.num_channels) {
- builder << "\tnum_channels=" << *ana_event.config.num_channels;
- }
- std::cout << builder.str() << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::
- BWE_PROBE_CLUSTER_CREATED_EVENT: {
- if (FLAG_probe) {
- auto probe_event = parsed_stream.GetBweProbeClusterCreated(i);
- std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_CREATED("
- << probe_event.id << ")"
- << "\tbitrate_bps=" << probe_event.bitrate_bps
- << "\tmin_packets=" << probe_event.min_packets
- << "\tmin_bytes=" << probe_event.min_bytes << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT: {
- if (FLAG_probe) {
- webrtc::LoggedBweProbeFailureEvent probe_result =
- parsed_stream.GetBweProbeFailure(i);
- std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_FAILURE("
- << probe_result.id << ")"
- << "\tfailure_reason="
- << static_cast<int>(probe_result.failure_reason)
- << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT: {
- if (FLAG_probe) {
- webrtc::LoggedBweProbeSuccessEvent probe_result =
- parsed_stream.GetBweProbeSuccess(i);
- std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_SUCCESS("
- << probe_result.id << ")"
- << "\tbitrate_bps=" << probe_result.bitrate_bps
- << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::ALR_STATE_EVENT: {
- if (FLAG_bwe) {
- webrtc::LoggedAlrStateEvent alr_state = parsed_stream.GetAlrState(i);
- std::cout << parsed_stream.GetTimestamp(i) << "\tALR_STATE"
- << "\tin_alr=" << alr_state.in_alr << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_CONFIG: {
- if (FLAG_ice) {
- webrtc::LoggedIceCandidatePairConfig ice_cp_config =
- parsed_stream.GetIceCandidatePairConfig(i);
- // TODO(qingsi): convert the numeric representation of states to text
- std::cout << parsed_stream.GetTimestamp(i)
- << "\tICE_CANDIDATE_PAIR_CONFIG"
- << "\ttype=" << static_cast<int>(ice_cp_config.type)
- << std::endl;
- }
- event_recognized = true;
- break;
- }
-
- case webrtc::ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_EVENT: {
- if (FLAG_ice) {
- webrtc::LoggedIceCandidatePairEvent ice_cp_event =
- parsed_stream.GetIceCandidatePairEvent(i);
- // TODO(qingsi): convert the numeric representation of states to text
- std::cout << parsed_stream.GetTimestamp(i)
- << "\tICE_CANDIDATE_PAIR_EVENT"
- << "\ttype=" << static_cast<int>(ice_cp_event.type)
- << std::endl;
- }
- event_recognized = true;
- break;
- }
- }
-
- if (!event_recognized) {
- std::cout << "Unrecognized event ("
- << static_cast<int>(parsed_stream.GetEventType(i)) << ")"
- << std::endl;
- }
- }
- return 0;
-}
