This cl removes RtcEventLog deps to call:call_interfaces. The purpose is to be able to use the event log from the upcoming RtpTransport.
Biggest change is to Remove MediaType as argument to RtcEventLog::LogRtpHeader and RtcEventLog::LogRtcpHeader.
Since the type is used by tools, these tools are rewritten to figure out the media type from the configurations instead.
BUG=webrtc:7538
TBR=solenberg@webrtc.org // For call.cc and voiceengine.cc
Review-Url: https://codereview.webrtc.org/2855143002
Cr-Commit-Position: refs/heads/master@{#18324}
diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc
index a1aa1de..6a8cd14 100644
--- a/webrtc/call/call.cc
+++ b/webrtc/call/call.cc
@@ -1214,7 +1214,7 @@
}
if (rtcp_delivered)
- event_log_->LogRtcpPacket(kIncomingPacket, media_type, packet, length);
+ event_log_->LogRtcpPacket(kIncomingPacket, packet, length);
return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
}
@@ -1242,14 +1242,14 @@
if (audio_rtp_demuxer_.OnRtpPacket(*parsed_packet)) {
received_bytes_per_second_counter_.Add(static_cast<int>(length));
received_audio_bytes_per_second_counter_.Add(static_cast<int>(length));
- event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
+ event_log_->LogRtpHeader(kIncomingPacket, packet, length);
return DELIVERY_OK;
}
} else if (media_type == MediaType::VIDEO) {
if (video_rtp_demuxer_.OnRtpPacket(*parsed_packet)) {
received_bytes_per_second_counter_.Add(static_cast<int>(length));
received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
- event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
+ event_log_->LogRtpHeader(kIncomingPacket, packet, length);
return DELIVERY_OK;
}
}
diff --git a/webrtc/logging/BUILD.gn b/webrtc/logging/BUILD.gn
index ffc64a3..8bb6c26 100644
--- a/webrtc/logging/BUILD.gn
+++ b/webrtc/logging/BUILD.gn
@@ -28,8 +28,8 @@
]
deps = [
"..:video_stream_api",
+ "..:webrtc_common",
"../base:rtc_base_approved",
- "../call:call_interfaces",
]
}
@@ -48,7 +48,6 @@
"..:webrtc_common",
"../base:protobuf_utils",
"../base:rtc_base_approved",
- "../call:call_interfaces",
"../modules/audio_coding:audio_network_adaptor",
"../modules/remote_bitrate_estimator:remote_bitrate_estimator",
"../modules/rtp_rtcp",
@@ -83,7 +82,6 @@
":rtc_event_log_api",
":rtc_event_log_proto",
"..:webrtc_common",
- "../call:call_interfaces",
"../modules/audio_coding:audio_network_adaptor",
"../modules/remote_bitrate_estimator:remote_bitrate_estimator",
"../modules/rtp_rtcp:rtp_rtcp",
@@ -138,7 +136,6 @@
":rtc_event_log_impl",
":rtc_event_log_parser",
"../base:rtc_base_approved",
- "../call:call_interfaces",
"../modules/rtp_rtcp:rtp_rtcp",
"../system_wrappers:field_trial_default",
"../system_wrappers:metrics_default",
@@ -162,7 +159,6 @@
":rtc_event_log_impl",
":rtc_event_log_parser",
"../base:rtc_base_approved",
- "../call:call_interfaces",
# TODO(kwiberg): Remove this dependency.
"../api/audio_codecs:audio_codecs_api",
diff --git a/webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h b/webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h
index cedc309..cb31d8f 100644
--- a/webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h
+++ b/webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h
@@ -41,22 +41,19 @@
MOCK_METHOD1(LogAudioSendStreamConfig,
void(const rtclog::StreamConfig& config));
- MOCK_METHOD4(LogRtpHeader,
+ MOCK_METHOD3(LogRtpHeader,
void(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length));
- MOCK_METHOD5(LogRtpHeader,
+ MOCK_METHOD4(LogRtpHeader,
void(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length,
int probe_cluster_id));
- MOCK_METHOD4(LogRtcpPacket,
+ MOCK_METHOD3(LogRtcpPacket,
void(PacketDirection direction,
- MediaType media_type,
const uint8_t* packet,
size_t length));
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log.cc b/webrtc/logging/rtc_event_log/rtc_event_log.cc
index 7469cf7..d139c4d 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log.cc
+++ b/webrtc/logging/rtc_event_log/rtc_event_log.cc
@@ -21,7 +21,6 @@
#include "webrtc/base/swap_queue.h"
#include "webrtc/base/thread_checker.h"
#include "webrtc/base/timeutils.h"
-#include "webrtc/call/call.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log_helper_thread.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
@@ -67,16 +66,13 @@
void LogAudioReceiveStreamConfig(const rtclog::StreamConfig& config) override;
void LogAudioSendStreamConfig(const rtclog::StreamConfig& config) override;
void LogRtpHeader(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length) override;
void LogRtpHeader(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length,
int probe_cluster_id) override;
void LogRtcpPacket(PacketDirection direction,
- MediaType media_type,
const uint8_t* packet,
size_t length) override;
void LogAudioPlayout(uint32_t ssrc) override;
@@ -132,21 +128,6 @@
return rtclog::VideoReceiveConfig::RTCP_COMPOUND;
}
-rtclog::MediaType ConvertMediaType(MediaType media_type) {
- switch (media_type) {
- case MediaType::ANY:
- return rtclog::MediaType::ANY;
- case MediaType::AUDIO:
- return rtclog::MediaType::AUDIO;
- case MediaType::VIDEO:
- return rtclog::MediaType::VIDEO;
- case MediaType::DATA:
- return rtclog::MediaType::DATA;
- }
- RTC_NOTREACHED();
- return rtclog::ANY;
-}
-
rtclog::DelayBasedBweUpdate::DetectorState ConvertDetectorState(
BandwidthUsage state) {
switch (state) {
@@ -390,15 +371,12 @@
}
void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length) {
- LogRtpHeader(direction, media_type, header, packet_length,
- PacedPacketInfo::kNotAProbe);
+ LogRtpHeader(direction, header, packet_length, PacedPacketInfo::kNotAProbe);
}
void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length,
int probe_cluster_id) {
@@ -422,7 +400,6 @@
rtp_event->set_timestamp_us(rtc::TimeMicros());
rtp_event->set_type(rtclog::Event::RTP_EVENT);
rtp_event->mutable_rtp_packet()->set_incoming(direction == kIncomingPacket);
- rtp_event->mutable_rtp_packet()->set_type(ConvertMediaType(media_type));
rtp_event->mutable_rtp_packet()->set_packet_length(packet_length);
rtp_event->mutable_rtp_packet()->set_header(header, header_length);
if (probe_cluster_id != PacedPacketInfo::kNotAProbe)
@@ -431,14 +408,12 @@
}
void RtcEventLogImpl::LogRtcpPacket(PacketDirection direction,
- MediaType media_type,
const uint8_t* packet,
size_t length) {
std::unique_ptr<rtclog::Event> rtcp_event(new rtclog::Event());
rtcp_event->set_timestamp_us(rtc::TimeMicros());
rtcp_event->set_type(rtclog::Event::RTCP_EVENT);
rtcp_event->mutable_rtcp_packet()->set_incoming(direction == kIncomingPacket);
- rtcp_event->mutable_rtcp_packet()->set_type(ConvertMediaType(media_type));
rtcp::CommonHeader header;
const uint8_t* block_begin = packet;
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log.h b/webrtc/logging/rtc_event_log/rtc_event_log.h
index 45e8bf0..bb4cc2e 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log.h
+++ b/webrtc/logging/rtc_event_log/rtc_event_log.h
@@ -16,10 +16,7 @@
#include <vector>
#include "webrtc/base/platform_file.h"
-#include "webrtc/call/audio_receive_stream.h"
-#include "webrtc/call/audio_send_stream.h"
-#include "webrtc/video_receive_stream.h"
-#include "webrtc/video_send_stream.h"
+#include "webrtc/config.h"
namespace webrtc {
@@ -129,21 +126,18 @@
// Logs the header of an incoming or outgoing RTP packet. packet_length
// is the total length of the packet, including both header and payload.
virtual void LogRtpHeader(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length) = 0;
// Same as above but used on the sender side to log packets that are part of
// a probe cluster.
virtual void LogRtpHeader(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length,
int probe_cluster_id) = 0;
// Logs an incoming or outgoing RTCP packet.
virtual void LogRtcpPacket(PacketDirection direction,
- MediaType media_type,
const uint8_t* packet,
size_t length) = 0;
@@ -204,16 +198,13 @@
const rtclog::StreamConfig& config) override {}
void LogAudioSendStreamConfig(const rtclog::StreamConfig& config) override {}
void LogRtpHeader(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length) override {}
void LogRtpHeader(PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t packet_length,
int probe_cluster_id) override {}
void LogRtcpPacket(PacketDirection direction,
- MediaType media_type,
const uint8_t* packet,
size_t length) override {}
void LogAudioPlayout(uint32_t ssrc) override {}
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log.proto b/webrtc/logging/rtc_event_log/rtc_event_log.proto
index 26d55a7..17a7c11 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log.proto
+++ b/webrtc/logging/rtc_event_log/rtc_event_log.proto
@@ -86,8 +86,7 @@
// required - True if the packet is incoming w.r.t. the user logging the data
optional bool incoming = 1;
- // required
- optional MediaType type = 2;
+ optional MediaType type = 2 [deprecated = true];
// required - The size of the packet including both payload and header.
optional uint32 packet_length = 3;
@@ -105,8 +104,7 @@
// required - True if the packet is incoming w.r.t. the user logging the data
optional bool incoming = 1;
- // required
- optional MediaType type = 2;
+ optional MediaType type = 2 [deprecated = true];
// required - The whole packet including both payload and header.
optional bytes packet_data = 3;
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log2rtp_dump.cc b/webrtc/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
index 2336caa..e22f1f3 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
+++ b/webrtc/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
@@ -15,14 +15,16 @@
#include "gflags/gflags.h"
#include "webrtc/base/checks.h"
-#include "webrtc/call/call.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
#include "webrtc/test/rtp_file_writer.h"
namespace {
+using MediaType = webrtc::ParsedRtcEventLog::MediaType;
+
DEFINE_bool(noaudio,
false,
"Excludes audio packets from the converted RTPdump file.");
@@ -118,21 +120,28 @@
parsed_stream.GetEventType(i) == webrtc::ParsedRtcEventLog::RTP_EVENT) {
webrtc::test::RtpPacket packet;
webrtc::PacketDirection direction;
- webrtc::MediaType media_type;
- parsed_stream.GetRtpHeader(i, &direction, &media_type, packet.data,
- &packet.length, &packet.original_length);
+ parsed_stream.GetRtpHeader(i, &direction, packet.data, &packet.length,
+ &packet.original_length);
if (packet.original_length > packet.length)
header_only = true;
packet.time_ms = parsed_stream.GetTimestamp(i) / 1000;
+ webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet.data,
+ packet.length);
+
// TODO(terelius): Maybe add a flag to dump outgoing traffic instead?
if (direction == webrtc::kOutgoingPacket)
continue;
- if (FLAGS_noaudio && media_type == webrtc::MediaType::AUDIO)
+
+ webrtc::RTPHeader parsed_header;
+ rtp_parser.Parse(&parsed_header);
+ MediaType media_type =
+ parsed_stream.GetMediaType(parsed_header.ssrc, direction);
+ if (FLAGS_noaudio && media_type == MediaType::AUDIO)
continue;
- if (FLAGS_novideo && media_type == webrtc::MediaType::VIDEO)
+ if (FLAGS_novideo && media_type == MediaType::VIDEO)
continue;
- if (FLAGS_nodata && media_type == webrtc::MediaType::DATA)
+ if (FLAGS_nodata && media_type == MediaType::DATA)
continue;
if (!FLAGS_ssrc.empty()) {
const uint32_t packet_ssrc =
@@ -150,9 +159,7 @@
webrtc::ParsedRtcEventLog::RTCP_EVENT) {
webrtc::test::RtpPacket packet;
webrtc::PacketDirection direction;
- webrtc::MediaType media_type;
- parsed_stream.GetRtcpPacket(i, &direction, &media_type, packet.data,
- &packet.length);
+ parsed_stream.GetRtcpPacket(i, &direction, packet.data, &packet.length);
// For RTCP packets the original_length should be set to 0 in the
// RTPdump format.
packet.original_length = 0;
@@ -161,16 +168,20 @@
// TODO(terelius): Maybe add a flag to dump outgoing traffic instead?
if (direction == webrtc::kOutgoingPacket)
continue;
- if (FLAGS_noaudio && media_type == webrtc::MediaType::AUDIO)
+
+ // Note that |packet_ssrc| is the sender SSRC. An RTCP message may contain
+ // report blocks for many streams, thus several SSRCs and they doen't
+ // necessarily have to be of the same media type.
+ const uint32_t packet_ssrc = webrtc::ByteReader<uint32_t>::ReadBigEndian(
+ reinterpret_cast<const uint8_t*>(packet.data + 4));
+ MediaType media_type = parsed_stream.GetMediaType(packet_ssrc, direction);
+ if (FLAGS_noaudio && media_type == MediaType::AUDIO)
continue;
- if (FLAGS_novideo && media_type == webrtc::MediaType::VIDEO)
+ if (FLAGS_novideo && media_type == MediaType::VIDEO)
continue;
- if (FLAGS_nodata && media_type == webrtc::MediaType::DATA)
+ if (FLAGS_nodata && media_type == MediaType::DATA)
continue;
if (!FLAGS_ssrc.empty()) {
- const uint32_t packet_ssrc =
- webrtc::ByteReader<uint32_t>::ReadBigEndian(
- reinterpret_cast<const uint8_t*>(packet.data + 4));
if (packet_ssrc != ssrc_filter)
continue;
}
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log2text.cc b/webrtc/logging/rtc_event_log/rtc_event_log2text.cc
index fab04c9..ec66810 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log2text.cc
+++ b/webrtc/logging/rtc_event_log/rtc_event_log2text.cc
@@ -14,7 +14,6 @@
#include "gflags/gflags.h"
#include "webrtc/base/checks.h"
-#include "webrtc/call/call.h"
#include "webrtc/common_types.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
@@ -52,6 +51,8 @@
"Print only packets with this SSRC (decimal or hex, the latter "
"starting with 0x).");
+using MediaType = webrtc::ParsedRtcEventLog::MediaType;
+
static uint32_t filtered_ssrc = 0;
// Parses the input string for a valid SSRC. If a valid SSRC is found, it is
@@ -73,44 +74,18 @@
return str.empty() || (!ss.fail() && ss.eof());
}
-// Struct used for storing SSRCs used in a Stream.
-struct Stream {
- Stream(uint32_t ssrc,
- webrtc::MediaType media_type,
- webrtc::PacketDirection direction)
- : ssrc(ssrc), media_type(media_type), direction(direction) {}
- uint32_t ssrc;
- webrtc::MediaType media_type;
- webrtc::PacketDirection direction;
-};
-
-// All configured streams found in the event log.
-std::vector<Stream> global_streams;
-
-// Returns the MediaType for registered SSRCs. Search from the end to use last
-// registered types first.
-webrtc::MediaType GetMediaType(uint32_t ssrc,
- webrtc::PacketDirection direction) {
- for (auto rit = global_streams.rbegin(); rit != global_streams.rend();
- ++rit) {
- if (rit->ssrc == ssrc && rit->direction == direction)
- return rit->media_type;
- }
- return webrtc::MediaType::ANY;
-}
-
bool ExcludePacket(webrtc::PacketDirection direction,
- webrtc::MediaType media_type,
+ MediaType media_type,
uint32_t packet_ssrc) {
if (FLAGS_nooutgoing && direction == webrtc::kOutgoingPacket)
return true;
if (FLAGS_noincoming && direction == webrtc::kIncomingPacket)
return true;
- if (FLAGS_noaudio && media_type == webrtc::MediaType::AUDIO)
+ if (FLAGS_noaudio && media_type == MediaType::AUDIO)
return true;
- if (FLAGS_novideo && media_type == webrtc::MediaType::VIDEO)
+ if (FLAGS_novideo && media_type == MediaType::VIDEO)
return true;
- if (FLAGS_nodata && media_type == webrtc::MediaType::DATA)
+ if (FLAGS_nodata && media_type == MediaType::DATA)
return true;
if (!FLAGS_ssrc.empty() && packet_ssrc != filtered_ssrc)
return true;
@@ -118,23 +93,23 @@
}
const char* StreamInfo(webrtc::PacketDirection direction,
- webrtc::MediaType media_type) {
+ MediaType media_type) {
if (direction == webrtc::kOutgoingPacket) {
- if (media_type == webrtc::MediaType::AUDIO)
+ if (media_type == MediaType::AUDIO)
return "(out,audio)";
- else if (media_type == webrtc::MediaType::VIDEO)
+ else if (media_type == MediaType::VIDEO)
return "(out,video)";
- else if (media_type == webrtc::MediaType::DATA)
+ else if (media_type == MediaType::DATA)
return "(out,data)";
else
return "(out)";
}
if (direction == webrtc::kIncomingPacket) {
- if (media_type == webrtc::MediaType::AUDIO)
+ if (media_type == MediaType::AUDIO)
return "(in,audio)";
- else if (media_type == webrtc::MediaType::VIDEO)
+ else if (media_type == MediaType::VIDEO)
return "(in,video)";
- else if (media_type == webrtc::MediaType::DATA)
+ else if (media_type == MediaType::DATA)
return "(in,data)";
else
return "(in)";
@@ -142,13 +117,15 @@
return "(unknown)";
}
-void PrintSenderReport(const webrtc::rtcp::CommonHeader& rtcp_block,
+void PrintSenderReport(const webrtc::ParsedRtcEventLog& 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;
- webrtc::MediaType media_type = GetMediaType(sr.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(sr.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, sr.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -157,13 +134,15 @@
<< "\ttimestamp=" << sr.rtp_timestamp() << std::endl;
}
-void PrintReceiverReport(const webrtc::rtcp::CommonHeader& rtcp_block,
+void PrintReceiverReport(const webrtc::ParsedRtcEventLog& 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;
- webrtc::MediaType media_type = GetMediaType(rr.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(rr.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, rr.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -171,13 +150,15 @@
<< "\tssrc=" << rr.sender_ssrc() << std::endl;
}
-void PrintXr(const webrtc::rtcp::CommonHeader& rtcp_block,
+void PrintXr(const webrtc::ParsedRtcEventLog& 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;
- webrtc::MediaType media_type = GetMediaType(xr.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(xr.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, xr.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -189,18 +170,20 @@
uint64_t log_timestamp,
webrtc::PacketDirection direction) {
std::cout << log_timestamp << "\t"
- << "RTCP_SDES" << StreamInfo(direction, webrtc::MediaType::ANY)
+ << "RTCP_SDES" << StreamInfo(direction, MediaType::ANY)
<< std::endl;
RTC_NOTREACHED() << "SDES should have been redacted when writing the log";
}
-void PrintBye(const webrtc::rtcp::CommonHeader& rtcp_block,
+void PrintBye(const webrtc::ParsedRtcEventLog& 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;
- webrtc::MediaType media_type = GetMediaType(bye.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(bye.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, bye.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -208,7 +191,8 @@
<< "\tssrc=" << bye.sender_ssrc() << std::endl;
}
-void PrintRtpFeedback(const webrtc::rtcp::CommonHeader& rtcp_block,
+void PrintRtpFeedback(const webrtc::ParsedRtcEventLog& parsed_stream,
+ const webrtc::rtcp::CommonHeader& rtcp_block,
uint64_t log_timestamp,
webrtc::PacketDirection direction) {
switch (rtcp_block.fmt()) {
@@ -216,8 +200,8 @@
webrtc::rtcp::Nack nack;
if (!nack.Parse(rtcp_block))
return;
- webrtc::MediaType media_type =
- GetMediaType(nack.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(nack.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, nack.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -229,8 +213,8 @@
webrtc::rtcp::Tmmbr tmmbr;
if (!tmmbr.Parse(rtcp_block))
return;
- webrtc::MediaType media_type =
- GetMediaType(tmmbr.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(tmmbr.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, tmmbr.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -242,8 +226,8 @@
webrtc::rtcp::Tmmbn tmmbn;
if (!tmmbn.Parse(rtcp_block))
return;
- webrtc::MediaType media_type =
- GetMediaType(tmmbn.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(tmmbn.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, tmmbn.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -255,8 +239,8 @@
webrtc::rtcp::RapidResyncRequest sr_req;
if (!sr_req.Parse(rtcp_block))
return;
- webrtc::MediaType media_type =
- GetMediaType(sr_req.sender_ssrc(), direction);
+ 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"
@@ -268,8 +252,8 @@
webrtc::rtcp::TransportFeedback transport_feedback;
if (!transport_feedback.Parse(rtcp_block))
return;
- webrtc::MediaType media_type =
- GetMediaType(transport_feedback.sender_ssrc(), direction);
+ MediaType media_type = parsed_stream.GetMediaType(
+ transport_feedback.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type,
transport_feedback.sender_ssrc()))
return;
@@ -283,7 +267,8 @@
}
}
-void PrintPsFeedback(const webrtc::rtcp::CommonHeader& rtcp_block,
+void PrintPsFeedback(const webrtc::ParsedRtcEventLog& parsed_stream,
+ const webrtc::rtcp::CommonHeader& rtcp_block,
uint64_t log_timestamp,
webrtc::PacketDirection direction) {
switch (rtcp_block.fmt()) {
@@ -291,7 +276,8 @@
webrtc::rtcp::Pli pli;
if (!pli.Parse(rtcp_block))
return;
- webrtc::MediaType media_type = GetMediaType(pli.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(pli.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, pli.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -303,7 +289,8 @@
webrtc::rtcp::Fir fir;
if (!fir.Parse(rtcp_block))
return;
- webrtc::MediaType media_type = GetMediaType(fir.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(fir.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, fir.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -315,8 +302,8 @@
webrtc::rtcp::Remb remb;
if (!remb.Parse(rtcp_block))
return;
- webrtc::MediaType media_type =
- GetMediaType(remb.sender_ssrc(), direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(remb.sender_ssrc(), direction);
if (ExcludePacket(direction, media_type, remb.sender_ssrc()))
return;
std::cout << log_timestamp << "\t"
@@ -362,67 +349,41 @@
}
for (size_t i = 0; i < parsed_stream.GetNumberOfEvents(); i++) {
- if (parsed_stream.GetEventType(i) ==
- webrtc::ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT) {
+ if (!FLAGS_noconfig && !FLAGS_novideo && !FLAGS_noincoming &&
+ parsed_stream.GetEventType(i) ==
+ webrtc::ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT) {
webrtc::rtclog::StreamConfig config;
parsed_stream.GetVideoReceiveConfig(i, &config);
-
- global_streams.emplace_back(config.remote_ssrc,
- webrtc::MediaType::VIDEO,
- webrtc::kIncomingPacket);
- global_streams.emplace_back(config.local_ssrc,
- webrtc::MediaType::VIDEO,
- webrtc::kOutgoingPacket);
-
- if (!FLAGS_noconfig && !FLAGS_novideo && !FLAGS_noincoming) {
- std::cout << parsed_stream.GetTimestamp(i) << "\tVIDEO_RECV_CONFIG"
+ std::cout << parsed_stream.GetTimestamp(i) << "\tVIDEO_RECV_CONFIG"
<< "\tssrc=" << config.remote_ssrc
<< "\tfeedback_ssrc=" << config.local_ssrc << std::endl;
- }
}
- if (parsed_stream.GetEventType(i) ==
- webrtc::ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT) {
+ if (!FLAGS_noconfig && !FLAGS_novideo && !FLAGS_nooutgoing &&
+ parsed_stream.GetEventType(i) ==
+ webrtc::ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT) {
webrtc::rtclog::StreamConfig config;
parsed_stream.GetVideoSendConfig(i, &config);
- global_streams.emplace_back(config.local_ssrc, webrtc::MediaType::VIDEO,
- webrtc::kOutgoingPacket);
-
- global_streams.emplace_back(config.rtx_ssrc, webrtc::MediaType::VIDEO,
- webrtc::kOutgoingPacket);
-
- if (!FLAGS_noconfig && !FLAGS_novideo && !FLAGS_nooutgoing) {
std::cout << parsed_stream.GetTimestamp(i) << "\tVIDEO_SEND_CONFIG";
std::cout << "\tssrcs=" << config.local_ssrc;
std::cout << "\trtx_ssrcs=" << config.rtx_ssrc;
std::cout << std::endl;
- }
}
- if (parsed_stream.GetEventType(i) ==
- webrtc::ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT) {
+ if (!FLAGS_noconfig && !FLAGS_noaudio && !FLAGS_noincoming &&
+ parsed_stream.GetEventType(i) ==
+ webrtc::ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT) {
webrtc::rtclog::StreamConfig config;
parsed_stream.GetAudioReceiveConfig(i, &config);
- global_streams.emplace_back(config.remote_ssrc,
- webrtc::MediaType::AUDIO,
- webrtc::kIncomingPacket);
- global_streams.emplace_back(config.local_ssrc,
- webrtc::MediaType::AUDIO,
- webrtc::kOutgoingPacket);
- if (!FLAGS_noconfig && !FLAGS_noaudio && !FLAGS_noincoming) {
- std::cout << parsed_stream.GetTimestamp(i) << "\tAUDIO_RECV_CONFIG"
- << "\tssrc=" << config.remote_ssrc
- << "\tfeedback_ssrc=" << config.local_ssrc << std::endl;
- }
+ std::cout << parsed_stream.GetTimestamp(i) << "\tAUDIO_RECV_CONFIG"
+ << "\tssrc=" << config.remote_ssrc
+ << "\tfeedback_ssrc=" << config.local_ssrc << std::endl;
}
- if (parsed_stream.GetEventType(i) ==
- webrtc::ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT) {
+ if (!FLAGS_noconfig && !FLAGS_noaudio && !FLAGS_nooutgoing &&
+ parsed_stream.GetEventType(i) ==
+ webrtc::ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT) {
webrtc::rtclog::StreamConfig config;
parsed_stream.GetAudioSendConfig(i, &config);
- global_streams.emplace_back(config.local_ssrc, webrtc::MediaType::AUDIO,
- webrtc::kOutgoingPacket);
- if (!FLAGS_noconfig && !FLAGS_noaudio && !FLAGS_nooutgoing) {
- std::cout << parsed_stream.GetTimestamp(i) << "\tAUDIO_SEND_CONFIG"
- << "\tssrc=" << config.local_ssrc << std::endl;
- }
+ std::cout << parsed_stream.GetTimestamp(i) << "\tAUDIO_SEND_CONFIG"
+ << "\tssrc=" << config.local_ssrc << std::endl;
}
if (!FLAGS_nortp &&
parsed_stream.GetEventType(i) == webrtc::ParsedRtcEventLog::RTP_EVENT) {
@@ -430,15 +391,16 @@
size_t total_length;
uint8_t header[IP_PACKET_SIZE];
webrtc::PacketDirection direction;
- webrtc::MediaType media_type;
- parsed_stream.GetRtpHeader(i, &direction, &media_type, header,
- &header_length, &total_length);
+
+ parsed_stream.GetRtpHeader(i, &direction, header, &header_length,
+ &total_length);
// 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);
- media_type = GetMediaType(parsed_header.ssrc, direction);
+ MediaType media_type =
+ parsed_stream.GetMediaType(parsed_header.ssrc, direction);
if (ExcludePacket(direction, media_type, parsed_header.ssrc))
continue;
@@ -454,8 +416,7 @@
size_t length;
uint8_t packet[IP_PACKET_SIZE];
webrtc::PacketDirection direction;
- webrtc::MediaType media_type;
- parsed_stream.GetRtcpPacket(i, &direction, &media_type, packet, &length);
+ parsed_stream.GetRtcpPacket(i, &direction, packet, &length);
webrtc::rtcp::CommonHeader rtcp_block;
const uint8_t* packet_end = packet + length;
@@ -470,25 +431,29 @@
uint64_t log_timestamp = parsed_stream.GetTimestamp(i);
switch (rtcp_block.type()) {
case webrtc::rtcp::SenderReport::kPacketType:
- PrintSenderReport(rtcp_block, log_timestamp, direction);
+ PrintSenderReport(parsed_stream, rtcp_block, log_timestamp,
+ direction);
break;
case webrtc::rtcp::ReceiverReport::kPacketType:
- PrintReceiverReport(rtcp_block, log_timestamp, direction);
+ 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(rtcp_block, log_timestamp, direction);
+ PrintXr(parsed_stream, rtcp_block, log_timestamp, direction);
break;
case webrtc::rtcp::Bye::kPacketType:
- PrintBye(rtcp_block, log_timestamp, direction);
+ PrintBye(parsed_stream, rtcp_block, log_timestamp, direction);
break;
case webrtc::rtcp::Rtpfb::kPacketType:
- PrintRtpFeedback(rtcp_block, log_timestamp, direction);
+ PrintRtpFeedback(parsed_stream, rtcp_block, log_timestamp,
+ direction);
break;
case webrtc::rtcp::Psfb::kPacketType:
- PrintPsFeedback(rtcp_block, log_timestamp, direction);
+ PrintPsFeedback(parsed_stream, rtcp_block, log_timestamp,
+ direction);
break;
default:
break;
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_parser.cc b/webrtc/logging/rtc_event_log/rtc_event_log_parser.cc
index 6194d3a..f01895a 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log_parser.cc
+++ b/webrtc/logging/rtc_event_log/rtc_event_log_parser.cc
@@ -22,7 +22,6 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/protobuf_utils.h"
-#include "webrtc/call/call.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
@@ -31,21 +30,6 @@
namespace webrtc {
namespace {
-MediaType GetRuntimeMediaType(rtclog::MediaType media_type) {
- switch (media_type) {
- case rtclog::MediaType::ANY:
- return MediaType::ANY;
- case rtclog::MediaType::AUDIO:
- return MediaType::AUDIO;
- case rtclog::MediaType::VIDEO:
- return MediaType::VIDEO;
- case rtclog::MediaType::DATA:
- return MediaType::DATA;
- }
- RTC_NOTREACHED();
- return MediaType::ANY;
-}
-
RtcpMode GetRuntimeRtcpMode(rtclog::VideoReceiveConfig::RtcpMode rtcp_mode) {
switch (rtcp_mode) {
case rtclog::VideoReceiveConfig::RTCP_COMPOUND:
@@ -179,7 +163,8 @@
// Read the next message tag. The tag number is defined as
// (fieldnumber << 3) | wire_type. In our case, the field number is
- // supposed to be 1 and the wire type for an length-delimited field is 2.
+ // supposed to be 1 and the wire type for an
+ // length-delimited field is 2.
const uint64_t kExpectedTag = (1 << 3) | 2;
std::tie(tag, success) = ParseVarInt(stream);
if (!success) {
@@ -213,6 +198,48 @@
LOG(LS_WARNING) << "Failed to parse protobuf message.";
return false;
}
+
+ EventType type = GetRuntimeEventType(event.type());
+ switch (type) {
+ case VIDEO_RECEIVER_CONFIG_EVENT: {
+ rtclog::StreamConfig config;
+ GetVideoReceiveConfig(event, &config);
+ streams_.emplace_back(config.remote_ssrc, MediaType::VIDEO,
+ kIncomingPacket);
+ streams_.emplace_back(config.local_ssrc, MediaType::VIDEO,
+ kOutgoingPacket);
+ break;
+ }
+ case VIDEO_SENDER_CONFIG_EVENT: {
+ rtclog::StreamConfig config;
+ GetVideoSendConfig(event, &config);
+ streams_.emplace_back(config.local_ssrc, MediaType::VIDEO,
+ kOutgoingPacket);
+
+ streams_.emplace_back(config.rtx_ssrc, MediaType::VIDEO,
+ kOutgoingPacket);
+ break;
+ }
+ case AUDIO_RECEIVER_CONFIG_EVENT: {
+ rtclog::StreamConfig config;
+ GetAudioReceiveConfig(event, &config);
+ streams_.emplace_back(config.remote_ssrc, MediaType::AUDIO,
+ kIncomingPacket);
+ streams_.emplace_back(config.local_ssrc, MediaType::AUDIO,
+ kOutgoingPacket);
+ break;
+ }
+ case AUDIO_SENDER_CONFIG_EVENT: {
+ rtclog::StreamConfig config;
+ GetAudioSendConfig(event, &config);
+ streams_.emplace_back(config.local_ssrc, MediaType::AUDIO,
+ kOutgoingPacket);
+ break;
+ }
+ default:
+ break;
+ }
+
events_.push_back(event);
}
}
@@ -239,7 +266,6 @@
// The header must have space for at least IP_PACKET_SIZE bytes.
void ParsedRtcEventLog::GetRtpHeader(size_t index,
PacketDirection* incoming,
- MediaType* media_type,
uint8_t* header,
size_t* header_length,
size_t* total_length) const {
@@ -254,11 +280,6 @@
if (incoming != nullptr) {
*incoming = rtp_packet.incoming() ? kIncomingPacket : kOutgoingPacket;
}
- // Get media type.
- RTC_CHECK(rtp_packet.has_type());
- if (media_type != nullptr) {
- *media_type = GetRuntimeMediaType(rtp_packet.type());
- }
// Get packet length.
RTC_CHECK(rtp_packet.has_packet_length());
if (total_length != nullptr) {
@@ -282,7 +303,6 @@
// The packet must have space for at least IP_PACKET_SIZE bytes.
void ParsedRtcEventLog::GetRtcpPacket(size_t index,
PacketDirection* incoming,
- MediaType* media_type,
uint8_t* packet,
size_t* length) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
@@ -296,11 +316,6 @@
if (incoming != nullptr) {
*incoming = rtcp_packet.incoming() ? kIncomingPacket : kOutgoingPacket;
}
- // Get media type.
- RTC_CHECK(rtcp_packet.has_type());
- if (media_type != nullptr) {
- *media_type = GetRuntimeMediaType(rtcp_packet.type());
- }
// Get packet length.
RTC_CHECK(rtcp_packet.has_packet_data());
if (length != nullptr) {
@@ -319,7 +334,12 @@
size_t index,
rtclog::StreamConfig* config) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
+ GetVideoReceiveConfig(events_[index], config);
+}
+
+void ParsedRtcEventLog::GetVideoReceiveConfig(
+ const rtclog::Event& event,
+ rtclog::StreamConfig* config) const {
RTC_CHECK(config != nullptr);
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
@@ -381,7 +401,10 @@
void ParsedRtcEventLog::GetVideoSendConfig(size_t index,
rtclog::StreamConfig* config) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
+ GetVideoSendConfig(events_[index], config);
+}
+void ParsedRtcEventLog::GetVideoSendConfig(const rtclog::Event& event,
+ rtclog::StreamConfig* config) const {
RTC_CHECK(config != nullptr);
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
@@ -419,7 +442,12 @@
size_t index,
rtclog::StreamConfig* config) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
+ GetAudioReceiveConfig(events_[index], config);
+}
+
+void ParsedRtcEventLog::GetAudioReceiveConfig(
+ const rtclog::Event& event,
+ rtclog::StreamConfig* config) const {
RTC_CHECK(config != nullptr);
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
@@ -439,7 +467,11 @@
void ParsedRtcEventLog::GetAudioSendConfig(size_t index,
rtclog::StreamConfig* config) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
- const rtclog::Event& event = events_[index];
+ GetAudioSendConfig(events_[index], config);
+}
+
+void ParsedRtcEventLog::GetAudioSendConfig(const rtclog::Event& event,
+ rtclog::StreamConfig* config) const {
RTC_CHECK(config != nullptr);
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_SENDER_CONFIG_EVENT);
@@ -588,4 +620,16 @@
return res;
}
+
+// Returns the MediaType for registered SSRCs. Search from the end to use last
+// registered types first.
+ParsedRtcEventLog::MediaType ParsedRtcEventLog::GetMediaType(
+ uint32_t ssrc,
+ PacketDirection direction) const {
+ for (auto rit = streams_.rbegin(); rit != streams_.rend(); ++rit) {
+ if (rit->ssrc == ssrc && rit->direction == direction)
+ return rit->media_type;
+ }
+ return MediaType::ANY;
+}
} // namespace webrtc
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_parser.h b/webrtc/logging/rtc_event_log/rtc_event_log_parser.h
index 966f00d..9e273ff 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log_parser.h
+++ b/webrtc/logging/rtc_event_log/rtc_event_log_parser.h
@@ -74,6 +74,8 @@
BWE_PROBE_RESULT_EVENT = 18
};
+ enum class MediaType { ANY, AUDIO, VIDEO, DATA };
+
// Reads an RtcEventLog file and returns true if parsing was successful.
bool ParseFile(const std::string& file_name);
@@ -92,25 +94,23 @@
// Reads the event type of the rtclog::Event at |index|.
EventType GetEventType(size_t index) const;
- // Reads the header, direction, media type, 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.
+ // 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.
void GetRtpHeader(size_t index,
PacketDirection* incoming,
- MediaType* media_type,
uint8_t* header,
size_t* header_length,
size_t* total_length) const;
- // Reads packet, direction, media type and packet length from the RTCP event
- // at |index|, and stores the values in the corresponding output parameters.
+ // Reads packet, direction and packet length from the RTCP event at |index|,
+ // and stores the values in the corresponding output parameters.
// Each output parameter can be set to nullptr if that value isn't needed.
// NB: The packet must have space for at least IP_PACKET_SIZE bytes.
void GetRtcpPacket(size_t index,
PacketDirection* incoming,
- MediaType* media_type,
uint8_t* packet,
size_t* length) const;
@@ -158,13 +158,36 @@
void GetAudioNetworkAdaptation(size_t index,
AudioEncoderRuntimeConfig* config) const;
- ParsedRtcEventLog::BweProbeClusterCreatedEvent GetBweProbeClusterCreated(
- size_t index) const;
+ BweProbeClusterCreatedEvent GetBweProbeClusterCreated(size_t index) const;
- ParsedRtcEventLog::BweProbeResultEvent GetBweProbeResult(size_t index) const;
+ BweProbeResultEvent GetBweProbeResult(size_t index) const;
+
+ MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const;
private:
+ void GetVideoReceiveConfig(const rtclog::Event& event,
+ rtclog::StreamConfig* config) const;
+ void GetVideoSendConfig(const rtclog::Event& event,
+ rtclog::StreamConfig* config) const;
+ void GetAudioReceiveConfig(const rtclog::Event& event,
+ rtclog::StreamConfig* config) const;
+ void GetAudioSendConfig(const rtclog::Event& event,
+ rtclog::StreamConfig* config) const;
+
std::vector<rtclog::Event> events_;
+
+ struct Stream {
+ Stream(uint32_t ssrc,
+ MediaType media_type,
+ webrtc::PacketDirection direction)
+ : ssrc(ssrc), media_type(media_type), direction(direction) {}
+ uint32_t ssrc;
+ MediaType media_type;
+ webrtc::PacketDirection direction;
+ };
+
+ // All configured streams found in the event log.
+ std::vector<Stream> streams_;
};
} // namespace webrtc
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc b/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
index e655b4b..b5c91fa 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -306,13 +306,11 @@
for (size_t i = 1; i <= rtp_count; i++) {
log_dumper->LogRtpHeader(
(i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
- (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
rtp_packets[i - 1].data(), rtp_packets[i - 1].size());
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
if (i * rtcp_count >= rtcp_index * rtp_count) {
log_dumper->LogRtcpPacket(
(rtcp_index % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
- rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
rtcp_packets[rtcp_index - 1].data(),
rtcp_packets[rtcp_index - 1].size());
rtcp_index++;
@@ -368,7 +366,6 @@
RtcEventLogTestHelper::VerifyRtpEvent(
parsed_log, event_index,
(i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
- (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
rtp_packets[i - 1].data(), rtp_packets[i - 1].headers_size(),
rtp_packets[i - 1].size());
event_index++;
@@ -376,7 +373,6 @@
RtcEventLogTestHelper::VerifyRtcpEvent(
parsed_log, event_index,
rtcp_index % 2 == 0 ? kIncomingPacket : kOutgoingPacket,
- rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
rtcp_packets[rtcp_index - 1].data(),
rtcp_packets[rtcp_index - 1].size());
event_index++;
@@ -454,15 +450,15 @@
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
- log_dumper->LogRtpHeader(kIncomingPacket, MediaType::VIDEO, rtp_packet.data(),
+ log_dumper->LogRtpHeader(kIncomingPacket, rtp_packet.data(),
rtp_packet.size());
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->StartLogging(temp_filename, 10000000);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- log_dumper->LogRtcpPacket(kOutgoingPacket, MediaType::VIDEO,
- rtcp_packet.data(), rtcp_packet.size());
+ log_dumper->LogRtcpPacket(kOutgoingPacket, rtcp_packet.data(),
+ rtcp_packet.size());
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->StopLogging();
@@ -478,12 +474,11 @@
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
RtcEventLogTestHelper::VerifyRtpEvent(
- parsed_log, 1, kIncomingPacket, MediaType::VIDEO, rtp_packet.data(),
+ parsed_log, 1, kIncomingPacket, rtp_packet.data(),
rtp_packet.headers_size(), rtp_packet.size());
- RtcEventLogTestHelper::VerifyRtcpEvent(parsed_log, 2, kOutgoingPacket,
- MediaType::VIDEO, rtcp_packet.data(),
- rtcp_packet.size());
+ RtcEventLogTestHelper::VerifyRtcpEvent(
+ parsed_log, 2, kOutgoingPacket, rtcp_packet.data(), rtcp_packet.size());
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 3);
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc b/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
index 8b4ea6b..4147721 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
+++ b/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
@@ -30,20 +30,6 @@
namespace webrtc {
namespace {
-MediaType GetRuntimeMediaType(rtclog::MediaType media_type) {
- switch (media_type) {
- case rtclog::MediaType::ANY:
- return MediaType::ANY;
- case rtclog::MediaType::AUDIO:
- return MediaType::AUDIO;
- case rtclog::MediaType::VIDEO:
- return MediaType::VIDEO;
- case rtclog::MediaType::DATA:
- return MediaType::DATA;
- }
- RTC_NOTREACHED();
- return MediaType::ANY;
-}
BandwidthUsage GetRuntimeDetectorState(
rtclog::DelayBasedBweUpdate::DetectorState detector_state) {
@@ -367,7 +353,6 @@
void RtcEventLogTestHelper::VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
size_t index,
PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t header_size,
size_t total_size) {
@@ -377,8 +362,6 @@
const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
ASSERT_TRUE(rtp_packet.has_incoming());
EXPECT_EQ(direction == kIncomingPacket, rtp_packet.incoming());
- ASSERT_TRUE(rtp_packet.has_type());
- EXPECT_EQ(media_type, GetRuntimeMediaType(rtp_packet.type()));
ASSERT_TRUE(rtp_packet.has_packet_length());
EXPECT_EQ(total_size, rtp_packet.packet_length());
ASSERT_TRUE(rtp_packet.has_header());
@@ -389,14 +372,11 @@
// Check consistency of the parser.
PacketDirection parsed_direction;
- MediaType parsed_media_type;
uint8_t parsed_header[1500];
size_t parsed_header_size, parsed_total_size;
- parsed_log.GetRtpHeader(index, &parsed_direction, &parsed_media_type,
- parsed_header, &parsed_header_size,
- &parsed_total_size);
+ parsed_log.GetRtpHeader(index, &parsed_direction, parsed_header,
+ &parsed_header_size, &parsed_total_size);
EXPECT_EQ(direction, parsed_direction);
- EXPECT_EQ(media_type, parsed_media_type);
ASSERT_EQ(header_size, parsed_header_size);
EXPECT_EQ(0, std::memcmp(header, parsed_header, header_size));
EXPECT_EQ(total_size, parsed_total_size);
@@ -405,7 +385,6 @@
void RtcEventLogTestHelper::VerifyRtcpEvent(const ParsedRtcEventLog& parsed_log,
size_t index,
PacketDirection direction,
- MediaType media_type,
const uint8_t* packet,
size_t total_size) {
const rtclog::Event& event = parsed_log.events_[index];
@@ -414,8 +393,6 @@
const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet();
ASSERT_TRUE(rtcp_packet.has_incoming());
EXPECT_EQ(direction == kIncomingPacket, rtcp_packet.incoming());
- ASSERT_TRUE(rtcp_packet.has_type());
- EXPECT_EQ(media_type, GetRuntimeMediaType(rtcp_packet.type()));
ASSERT_TRUE(rtcp_packet.has_packet_data());
ASSERT_EQ(total_size, rtcp_packet.packet_data().size());
for (size_t i = 0; i < total_size; i++) {
@@ -424,13 +401,11 @@
// Check consistency of the parser.
PacketDirection parsed_direction;
- MediaType parsed_media_type;
uint8_t parsed_packet[1500];
size_t parsed_total_size;
- parsed_log.GetRtcpPacket(index, &parsed_direction, &parsed_media_type,
- parsed_packet, &parsed_total_size);
+ parsed_log.GetRtcpPacket(index, &parsed_direction, parsed_packet,
+ &parsed_total_size);
EXPECT_EQ(direction, parsed_direction);
- EXPECT_EQ(media_type, parsed_media_type);
ASSERT_EQ(total_size, parsed_total_size);
EXPECT_EQ(0, std::memcmp(packet, parsed_packet, total_size));
}
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h b/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h
index c0fc493..04aa6bf 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h
+++ b/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h
@@ -35,14 +35,12 @@
static void VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
size_t index,
PacketDirection direction,
- MediaType media_type,
const uint8_t* header,
size_t header_size,
size_t total_size);
static void VerifyRtcpEvent(const ParsedRtcEventLog& parsed_log,
size_t index,
PacketDirection direction,
- MediaType media_type,
const uint8_t* packet,
size_t total_size);
static void VerifyPlayoutEvent(const ParsedRtcEventLog& parsed_log,
diff --git a/webrtc/modules/audio_coding/neteq/tools/rtc_event_log_source.cc b/webrtc/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
index fd3c130..e0b54cb 100644
--- a/webrtc/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
+++ b/webrtc/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
@@ -39,38 +39,45 @@
}
std::unique_ptr<Packet> RtcEventLogSource::NextPacket() {
- while (rtp_packet_index_ < parsed_stream_.GetNumberOfEvents()) {
+ for (; rtp_packet_index_ < parsed_stream_.GetNumberOfEvents();
+ rtp_packet_index_++) {
if (parsed_stream_.GetEventType(rtp_packet_index_) ==
ParsedRtcEventLog::RTP_EVENT) {
PacketDirection direction;
- MediaType media_type;
size_t header_length;
size_t packet_length;
uint64_t timestamp_us = parsed_stream_.GetTimestamp(rtp_packet_index_);
- parsed_stream_.GetRtpHeader(rtp_packet_index_, &direction, &media_type,
- nullptr, &header_length, &packet_length);
- if (direction == kIncomingPacket && media_type == MediaType::AUDIO) {
- uint8_t* packet_header = new uint8_t[header_length];
- parsed_stream_.GetRtpHeader(rtp_packet_index_, nullptr, nullptr,
- packet_header, nullptr, nullptr);
- std::unique_ptr<Packet> packet(new Packet(
- packet_header, header_length, packet_length,
- static_cast<double>(timestamp_us) / 1000, *parser_.get()));
- if (packet->valid_header()) {
- // Check if the packet should not be filtered out.
- if (!filter_.test(packet->header().payloadType) &&
- !(use_ssrc_filter_ && packet->header().ssrc != ssrc_)) {
- rtp_packet_index_++;
- return packet;
- }
- } else {
- std::cout << "Warning: Packet with index " << rtp_packet_index_
- << " has an invalid header and will be ignored."
- << std::endl;
- }
+ parsed_stream_.GetRtpHeader(rtp_packet_index_, &direction, nullptr,
+ &header_length, &packet_length);
+
+ if (direction != kIncomingPacket) {
+ continue;
+ }
+
+ uint8_t* packet_header = new uint8_t[header_length];
+ parsed_stream_.GetRtpHeader(rtp_packet_index_, nullptr, packet_header,
+ nullptr, nullptr);
+ std::unique_ptr<Packet> packet(
+ new Packet(packet_header, header_length, packet_length,
+ static_cast<double>(timestamp_us) / 1000, *parser_.get()));
+
+ if (!packet->valid_header()) {
+ std::cout << "Warning: Packet with index " << rtp_packet_index_
+ << " has an invalid header and will be ignored." << std::endl;
+ continue;
+ }
+
+ if (parsed_stream_.GetMediaType(packet->header().ssrc, direction) !=
+ webrtc::ParsedRtcEventLog::MediaType::AUDIO) {
+ continue;
+ }
+
+ // Check if the packet should not be filtered out.
+ if (!filter_.test(packet->header().payloadType) &&
+ !(use_ssrc_filter_ && packet->header().ssrc != ssrc_)) {
+ return packet;
}
}
- rtp_packet_index_++;
}
return nullptr;
}
diff --git a/webrtc/modules/congestion_controller/BUILD.gn b/webrtc/modules/congestion_controller/BUILD.gn
index 352d410..f32b7b6 100644
--- a/webrtc/modules/congestion_controller/BUILD.gn
+++ b/webrtc/modules/congestion_controller/BUILD.gn
@@ -86,6 +86,7 @@
deps = [
":congestion_controller",
":mock_congestion_controller",
+ "../../base:rtc_base",
"../../base:rtc_base_approved",
"../../system_wrappers:system_wrappers",
"../../test:field_trial",
diff --git a/webrtc/modules/congestion_controller/congestion_controller_unittest.cc b/webrtc/modules/congestion_controller/congestion_controller_unittest.cc
index 3f14068..46a1bd5 100644
--- a/webrtc/modules/congestion_controller/congestion_controller_unittest.cc
+++ b/webrtc/modules/congestion_controller/congestion_controller_unittest.cc
@@ -9,6 +9,7 @@
*/
#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
+#include "webrtc/base/socket.h"
#include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h"
#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
#include "webrtc/modules/congestion_controller/congestion_controller_unittests_helper.h"
@@ -16,6 +17,7 @@
#include "webrtc/modules/pacing/mock/mock_paced_sender.h"
#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
#include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/test/gmock.h"
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
index 97cf8ca..cab55d3 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -100,8 +100,7 @@
if (transport_->SendRtcp(data, length)) {
bytes_sent_ += length;
if (event_log_) {
- event_log_->LogRtcpPacket(kOutgoingPacket, MediaType::ANY, data,
- length);
+ event_log_->LogRtcpPacket(kOutgoingPacket, data, length);
}
}
}
@@ -987,8 +986,7 @@
void OnPacketReady(uint8_t* data, size_t length) override {
if (transport_->SendRtcp(data, length)) {
if (event_log_) {
- event_log_->LogRtcpPacket(kOutgoingPacket, MediaType::ANY, data,
- length);
+ event_log_->LogRtcpPacket(kOutgoingPacket, data, length);
}
} else {
send_failure_ = true;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index d1de668..e0c10e9 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -631,8 +631,8 @@
? static_cast<int>(packet.size())
: -1;
if (event_log_ && bytes_sent > 0) {
- event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet.data(),
- packet.size(), pacing_info.probe_cluster_id);
+ event_log_->LogRtpHeader(kOutgoingPacket, packet.data(), packet.size(),
+ pacing_info.probe_cluster_id);
}
}
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index a3ddb6e..235dd31 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -464,7 +464,7 @@
EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
kSsrc, kSeqNum, _, _, _));
EXPECT_CALL(mock_rtc_event_log_,
- LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _, _));
+ LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _));
rtp_sender_->SetStorePacketsStatus(true, 10);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -509,7 +509,7 @@
EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
kSsrc, kSeqNum, _, _, _));
EXPECT_CALL(mock_rtc_event_log_,
- LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _, _));
+ LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _));
rtp_sender_->SetStorePacketsStatus(true, 10);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -563,7 +563,7 @@
EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
kSsrc, kSeqNum, _, _, _));
EXPECT_CALL(mock_rtc_event_log_,
- LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _, _))
+ LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
.Times(1 + 4 + 1);
uint16_t seq_num = kSeqNum;
@@ -764,7 +764,7 @@
InsertPacket(RtpPacketSender::kNormalPriority, kSsrc, _, _, _, _))
.Times(kNumPayloadSizes);
EXPECT_CALL(mock_rtc_event_log_,
- LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _, _))
+ LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
.Times(kNumPayloadSizes);
// Send 10 packets of increasing size.
@@ -778,7 +778,7 @@
}
EXPECT_CALL(mock_rtc_event_log_,
- LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _, _))
+ LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
.Times(::testing::AtLeast(4));
// The amount of padding to send it too small to send a payload packet.
@@ -875,7 +875,7 @@
.WillOnce(testing::SaveArg<2>(&flexfec_seq_num));
SendGenericPayload();
EXPECT_CALL(mock_rtc_event_log_,
- LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _, _))
+ LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
.Times(2);
EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(),
@@ -923,7 +923,7 @@
rtp_sender_->SetFecParameters(params, params);
EXPECT_CALL(mock_rtc_event_log_,
- LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _, _))
+ LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
.Times(2);
SendGenericPayload();
ASSERT_EQ(2, transport_.packets_sent());
diff --git a/webrtc/tools/event_log_visualizer/analyzer.cc b/webrtc/tools/event_log_visualizer/analyzer.cc
index a34d855..f42855f 100644
--- a/webrtc/tools/event_log_visualizer/analyzer.cc
+++ b/webrtc/tools/event_log_visualizer/analyzer.cc
@@ -373,9 +373,8 @@
break;
}
case ParsedRtcEventLog::RTP_EVENT: {
- MediaType media_type;
- parsed_log_.GetRtpHeader(i, &direction, &media_type, header,
- &header_length, &total_length);
+ parsed_log_.GetRtpHeader(i, &direction, header, &header_length,
+ &total_length);
// Parse header to get SSRC.
RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
RTPHeader parsed_header;
@@ -399,9 +398,7 @@
}
case ParsedRtcEventLog::RTCP_EVENT: {
uint8_t packet[IP_PACKET_SIZE];
- MediaType media_type;
- parsed_log_.GetRtcpPacket(i, &direction, &media_type, packet,
- &total_length);
+ parsed_log_.GetRtcpPacket(i, &direction, packet, &total_length);
// Currently incoming RTCP packets are logged twice, both for audio and
// video. Only act on one of them. Compare against the previous parsed
// incoming RTCP packet.
@@ -905,8 +902,7 @@
for (size_t i = 0; i < parsed_log_.GetNumberOfEvents(); i++) {
ParsedRtcEventLog::EventType event_type = parsed_log_.GetEventType(i);
if (event_type == ParsedRtcEventLog::RTP_EVENT) {
- parsed_log_.GetRtpHeader(i, &direction, nullptr, nullptr, nullptr,
- &total_length);
+ parsed_log_.GetRtpHeader(i, &direction, nullptr, nullptr, &total_length);
if (direction == desired_direction) {
uint64_t timestamp = parsed_log_.GetTimestamp(i);
packets.push_back(TimestampSize(timestamp, total_length));
diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc
index bf7d30c..b0bae4e 100644
--- a/webrtc/voice_engine/channel.cc
+++ b/webrtc/voice_engine/channel.cc
@@ -101,32 +101,28 @@
}
void LogRtpHeader(webrtc::PacketDirection direction,
- webrtc::MediaType media_type,
const uint8_t* header,
size_t packet_length) override {
- LogRtpHeader(direction, media_type, header, packet_length,
- PacedPacketInfo::kNotAProbe);
+ LogRtpHeader(direction, header, packet_length, PacedPacketInfo::kNotAProbe);
}
void LogRtpHeader(webrtc::PacketDirection direction,
- webrtc::MediaType media_type,
const uint8_t* header,
size_t packet_length,
int probe_cluster_id) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
- event_log_->LogRtpHeader(direction, media_type, header, packet_length,
+ event_log_->LogRtpHeader(direction, header, packet_length,
probe_cluster_id);
}
}
void LogRtcpPacket(webrtc::PacketDirection direction,
- webrtc::MediaType media_type,
const uint8_t* packet,
size_t length) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
- event_log_->LogRtcpPacket(direction, media_type, packet, length);
+ event_log_->LogRtcpPacket(direction, packet, length);
}
}
