Index: webrtc/call/rtc_event_log_parser.cc |
diff --git a/webrtc/call/rtc_event_log_parser.cc b/webrtc/call/rtc_event_log_parser.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..244f17c491e906050bb9dd400ac808d8483affcb |
--- /dev/null |
+++ b/webrtc/call/rtc_event_log_parser.cc |
@@ -0,0 +1,395 @@ |
+/* |
+ * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
+ * |
+ * Use of this source code is governed by a BSD-style license |
+ * that can be found in the LICENSE file in the root of the source |
+ * tree. An additional intellectual property rights grant can be found |
+ * in the file PATENTS. All contributing project authors may |
+ * be found in the AUTHORS file in the root of the source tree. |
+ */ |
+ |
+#include "webrtc/call/rtc_event_log_parser.h" |
+ |
+#include <string.h> |
+ |
+#include <fstream> |
+ |
+#include "webrtc/base/checks.h" |
+#include "webrtc/base/logging.h" |
+#include "webrtc/base/scoped_ptr.h" |
+#include "webrtc/call.h" |
+#include "webrtc/call/rtc_event_log.h" |
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
+#include "webrtc/system_wrappers/include/file_wrapper.h" |
+ |
+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: |
+ return RtcpMode::kCompound; |
+ case rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE: |
+ return RtcpMode::kReducedSize; |
+ } |
+ RTC_NOTREACHED(); |
+ return RtcpMode::kOff; |
+} |
+ |
+ParsedRtcEventLog::EventType GetRuntimeEventType( |
+ rtclog::Event::EventType event_type) { |
+ switch (event_type) { |
+ case rtclog::Event::UNKNOWN_EVENT: |
+ return ParsedRtcEventLog::EventType::UNKNOWN_EVENT; |
+ case rtclog::Event::LOG_START: |
+ return ParsedRtcEventLog::EventType::LOG_START; |
+ case rtclog::Event::LOG_END: |
+ return ParsedRtcEventLog::EventType::LOG_END; |
+ case rtclog::Event::RTP_EVENT: |
+ return ParsedRtcEventLog::EventType::RTP_EVENT; |
+ case rtclog::Event::RTCP_EVENT: |
+ return ParsedRtcEventLog::EventType::RTCP_EVENT; |
+ case rtclog::Event::AUDIO_PLAYOUT_EVENT: |
+ return ParsedRtcEventLog::EventType::AUDIO_PLAYOUT_EVENT; |
+ case rtclog::Event::BWE_PACKET_LOSS_EVENT: |
+ return ParsedRtcEventLog::EventType::BWE_PACKET_LOSS_EVENT; |
+ case rtclog::Event::BWE_PACKET_DELAY_EVENT: |
+ return ParsedRtcEventLog::EventType::BWE_PACKET_DELAY_EVENT; |
+ case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT: |
+ return ParsedRtcEventLog::EventType::VIDEO_RECEIVER_CONFIG_EVENT; |
+ case rtclog::Event::VIDEO_SENDER_CONFIG_EVENT: |
+ return ParsedRtcEventLog::EventType::VIDEO_SENDER_CONFIG_EVENT; |
+ case rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT: |
+ return ParsedRtcEventLog::EventType::AUDIO_RECEIVER_CONFIG_EVENT; |
+ case rtclog::Event::AUDIO_SENDER_CONFIG_EVENT: |
+ return ParsedRtcEventLog::EventType::AUDIO_SENDER_CONFIG_EVENT; |
+ } |
+ RTC_NOTREACHED(); |
+ return ParsedRtcEventLog::EventType::UNKNOWN_EVENT; |
+} |
+ |
+bool ParseVarInt(std::FILE* file, uint64_t* varint, size_t* bytes_read) { |
+ uint8_t byte; |
+ *varint = 0; |
+ for (*bytes_read = 0; *bytes_read < 10 && fread(&byte, 1, 1, file) == 1; |
+ ++(*bytes_read)) { |
+ // The most significant bit of each byte is 0 if it is the last byte in |
+ // the varint and 1 otherwise. Thus, we take the 7 least significant bits |
+ // of each byte and shift them 7 bits for each byte read previously to get |
+ // the (unsigned) integer. |
+ *varint |= static_cast<uint64_t>(byte & 0x7F) << (7 * *bytes_read); |
+ if ((byte & 0x80) == 0) { |
+ return true; |
+ } |
+ } |
+ return false; |
+} |
+ |
+} // namespace |
+ |
+bool ParsedRtcEventLog::ParseFile(const std::string& filename) { |
+ stream_.clear(); |
+ const size_t kMaxEventSize = (1u << 16) - 1; |
+ char tmp_buffer[kMaxEventSize]; |
+ |
+ std::FILE* file = fopen(filename.c_str(), "rb"); |
+ if (!file) { |
+ LOG(LS_WARNING) << "Could not open file for reading."; |
+ return false; |
+ } |
+ |
+ while (1) { |
+ // Peek at the next message tag. The tag number is defined as |
+ // (fieldnumber << 3) | wire_type. In our case, the field number is |
+ // supposed to be 1 and the wire type for an length-delimited field is 2. |
+ const uint64_t kExpectedTag = (1 << 3) | 2; |
+ uint64_t tag; |
+ size_t bytes_read; |
+ if (!ParseVarInt(file, &tag, &bytes_read) || tag != kExpectedTag) { |
+ fclose(file); |
+ if (bytes_read == 0) { |
+ return true; // Reached end of file. |
+ } |
+ LOG(LS_WARNING) << "Missing field tag from beginning of protobuf event."; |
+ return false; |
+ } |
+ |
+ // Peek at the length field. |
+ uint64_t message_length; |
+ if (!ParseVarInt(file, &message_length, &bytes_read)) { |
+ LOG(LS_WARNING) << "Missing message length after protobuf field tag."; |
+ fclose(file); |
+ return false; |
+ } else if (message_length > kMaxEventSize) { |
+ LOG(LS_WARNING) << "Protobuf message length is too large."; |
+ fclose(file); |
+ return false; |
+ } |
+ |
+ if (fread(tmp_buffer, 1, message_length, file) != message_length) { |
+ LOG(LS_WARNING) << "Failed to read protobuf message from file."; |
+ fclose(file); |
+ return false; |
+ } |
+ |
+ rtclog::Event event; |
+ if (!event.ParseFromArray(tmp_buffer, message_length)) { |
+ LOG(LS_WARNING) << "Failed to parse protobuf message."; |
+ fclose(file); |
+ return false; |
+ } |
+ stream_.push_back(event); |
+ } |
+} |
+ |
+size_t ParsedRtcEventLog::GetNumberOfEvents() const { |
+ return stream_.size(); |
+} |
+ |
+int64_t ParsedRtcEventLog::GetTimestamp(size_t index) const { |
+ RTC_CHECK_LT(index, GetNumberOfEvents()); |
+ const rtclog::Event& event = stream_[index]; |
+ RTC_CHECK(event.has_timestamp_us()); |
+ return event.timestamp_us(); |
+} |
+ |
+ParsedRtcEventLog::EventType ParsedRtcEventLog::GetEventType( |
+ size_t index) const { |
+ RTC_CHECK_LT(index, GetNumberOfEvents()); |
+ const rtclog::Event& event = stream_[index]; |
+ RTC_CHECK(event.has_type()); |
+ return GetRuntimeEventType(event.type()); |
+} |
+ |
+// 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 { |
+ RTC_CHECK_LT(index, GetNumberOfEvents()); |
+ const rtclog::Event& event = stream_[index]; |
+ RTC_CHECK(event.has_type()); |
+ RTC_CHECK_EQ(event.type(), rtclog::Event::RTP_EVENT); |
+ RTC_CHECK(event.has_rtp_packet()); |
+ const rtclog::RtpPacket& rtp_packet = event.rtp_packet(); |
+ // Get direction of packet. |
+ RTC_CHECK(rtp_packet.has_incoming()); |
+ if (incoming != nullptr) { |
+ *incoming = rtp_packet.incoming() ? kIncomingPacket : kOutgoingPacket; |
+ } |
+ // Get 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) { |
+ *total_length = rtp_packet.packet_length(); |
+ } |
+ // Get header length. |
+ RTC_CHECK(rtp_packet.has_header()); |
+ if (header_length != nullptr) { |
+ *header_length = rtp_packet.header().size(); |
+ } |
+ // Get header contents. |
+ if (header != nullptr) { |
+ const size_t kMinRtpHeaderSize = 12; |
+ RTC_CHECK_GE(rtp_packet.header().size(), kMinRtpHeaderSize); |
+ RTC_CHECK_LE(rtp_packet.header().size(), |
+ static_cast<size_t>(IP_PACKET_SIZE)); |
+ memcpy(header, rtp_packet.header().data(), rtp_packet.header().size()); |
+ } |
+} |
+ |
+// 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()); |
+ const rtclog::Event& event = stream_[index]; |
+ RTC_CHECK(event.has_type()); |
+ RTC_CHECK_EQ(event.type(), rtclog::Event::RTCP_EVENT); |
+ RTC_CHECK(event.has_rtcp_packet()); |
+ const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet(); |
+ // Get direction of packet. |
+ RTC_CHECK(rtcp_packet.has_incoming()); |
+ if (incoming != nullptr) { |
+ *incoming = rtcp_packet.incoming() ? kIncomingPacket : kOutgoingPacket; |
+ } |
+ // Get 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) { |
+ *length = rtcp_packet.packet_data().size(); |
+ } |
+ // Get packet contents. |
+ if (packet != nullptr) { |
+ RTC_CHECK_LE(rtcp_packet.packet_data().size(), |
+ static_cast<unsigned>(IP_PACKET_SIZE)); |
+ memcpy(packet, rtcp_packet.packet_data().data(), |
+ rtcp_packet.packet_data().size()); |
+ } |
+} |
+ |
+void ParsedRtcEventLog::GetVideoReceiveConfig( |
+ size_t index, |
+ VideoReceiveStream::Config* config) const { |
+ RTC_CHECK_LT(index, GetNumberOfEvents()); |
+ const rtclog::Event& event = stream_[index]; |
+ RTC_CHECK(config != nullptr); |
+ RTC_CHECK(event.has_type()); |
+ RTC_CHECK_EQ(event.type(), rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT); |
+ RTC_CHECK(event.has_video_receiver_config()); |
+ const rtclog::VideoReceiveConfig& receiver_config = |
+ event.video_receiver_config(); |
+ // Get SSRCs. |
+ RTC_CHECK(receiver_config.has_remote_ssrc()); |
+ config->rtp.remote_ssrc = receiver_config.remote_ssrc(); |
+ RTC_CHECK(receiver_config.has_local_ssrc()); |
+ config->rtp.local_ssrc = receiver_config.local_ssrc(); |
+ // Get RTCP settings. |
+ RTC_CHECK(receiver_config.has_rtcp_mode()); |
+ config->rtp.rtcp_mode = GetRuntimeRtcpMode(receiver_config.rtcp_mode()); |
+ RTC_CHECK(receiver_config.has_remb()); |
+ config->rtp.remb = receiver_config.remb(); |
+ // Get RTX map. |
+ config->rtp.rtx.clear(); |
+ for (int i = 0; i < receiver_config.rtx_map_size(); i++) { |
+ const rtclog::RtxMap& map = receiver_config.rtx_map(i); |
+ RTC_CHECK(map.has_payload_type()); |
+ RTC_CHECK(map.has_config()); |
+ RTC_CHECK(map.config().has_rtx_ssrc()); |
+ RTC_CHECK(map.config().has_rtx_payload_type()); |
+ webrtc::VideoReceiveStream::Config::Rtp::Rtx rtx_pair; |
+ rtx_pair.ssrc = map.config().rtx_ssrc(); |
+ rtx_pair.payload_type = map.config().rtx_payload_type(); |
+ config->rtp.rtx.insert(std::make_pair(map.payload_type(), rtx_pair)); |
+ } |
+ // Get header extensions. |
+ config->rtp.extensions.clear(); |
+ for (int i = 0; i < receiver_config.header_extensions_size(); i++) { |
+ RTC_CHECK(receiver_config.header_extensions(i).has_name()); |
+ RTC_CHECK(receiver_config.header_extensions(i).has_id()); |
+ const std::string& name = receiver_config.header_extensions(i).name(); |
+ int id = receiver_config.header_extensions(i).id(); |
+ config->rtp.extensions.push_back(RtpExtension(name, id)); |
+ } |
+ // Get decoders. |
+ config->decoders.clear(); |
+ for (int i = 0; i < receiver_config.decoders_size(); i++) { |
+ RTC_CHECK(receiver_config.decoders(i).has_name()); |
+ RTC_CHECK(receiver_config.decoders(i).has_payload_type()); |
+ VideoReceiveStream::Decoder decoder; |
+ decoder.payload_name = receiver_config.decoders(i).name(); |
+ decoder.payload_type = receiver_config.decoders(i).payload_type(); |
+ config->decoders.push_back(decoder); |
+ } |
+} |
+ |
+void ParsedRtcEventLog::GetVideoSendConfig( |
+ size_t index, |
+ VideoSendStream::Config* config) const { |
+ RTC_CHECK_LT(index, GetNumberOfEvents()); |
+ const rtclog::Event& event = stream_[index]; |
+ RTC_CHECK(config != nullptr); |
+ RTC_CHECK(event.has_type()); |
+ RTC_CHECK_EQ(event.type(), rtclog::Event::VIDEO_SENDER_CONFIG_EVENT); |
+ RTC_CHECK(event.has_video_sender_config()); |
+ const rtclog::VideoSendConfig& sender_config = event.video_sender_config(); |
+ // Get SSRCs. |
+ config->rtp.ssrcs.clear(); |
+ for (int i = 0; i < sender_config.ssrcs_size(); i++) { |
+ config->rtp.ssrcs.push_back(sender_config.ssrcs(i)); |
+ } |
+ // Get header extensions. |
+ config->rtp.extensions.clear(); |
+ for (int i = 0; i < sender_config.header_extensions_size(); i++) { |
+ RTC_CHECK(sender_config.header_extensions(i).has_name()); |
+ RTC_CHECK(sender_config.header_extensions(i).has_id()); |
+ const std::string& name = sender_config.header_extensions(i).name(); |
+ int id = sender_config.header_extensions(i).id(); |
+ config->rtp.extensions.push_back(RtpExtension(name, id)); |
+ } |
+ // Get RTX settings. |
+ config->rtp.rtx.ssrcs.clear(); |
+ for (int i = 0; i < sender_config.rtx_ssrcs_size(); i++) { |
+ config->rtp.rtx.ssrcs.push_back(sender_config.rtx_ssrcs(i)); |
+ } |
+ if (sender_config.rtx_ssrcs_size() > 0) { |
+ RTC_CHECK(sender_config.has_rtx_payload_type()); |
+ config->rtp.rtx.payload_type = sender_config.rtx_payload_type(); |
+ } else { |
+ // Reset RTX payload type default value if no RTX SSRCs are used. |
+ config->rtp.rtx.payload_type = -1; |
+ } |
+ // Get encoder. |
+ RTC_CHECK(sender_config.has_encoder()); |
+ RTC_CHECK(sender_config.encoder().has_name()); |
+ RTC_CHECK(sender_config.encoder().has_payload_type()); |
+ config->encoder_settings.payload_name = sender_config.encoder().name(); |
+ config->encoder_settings.payload_type = |
+ sender_config.encoder().payload_type(); |
+} |
+ |
+void ParsedRtcEventLog::GetAudioPlayout(size_t index, uint32_t* ssrc) const { |
+ RTC_CHECK_LT(index, GetNumberOfEvents()); |
+ const rtclog::Event& event = stream_[index]; |
+ RTC_CHECK(event.has_type()); |
+ RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_PLAYOUT_EVENT); |
+ RTC_CHECK(event.has_audio_playout_event()); |
+ const rtclog::AudioPlayoutEvent& loss_event = event.audio_playout_event(); |
+ RTC_CHECK(loss_event.has_local_ssrc()); |
+ if (ssrc != nullptr) { |
+ *ssrc = loss_event.local_ssrc(); |
+ } |
+} |
+ |
+void ParsedRtcEventLog::GetBwePacketLossEvent(size_t index, |
+ int32_t* bitrate, |
+ uint8_t* fraction_loss, |
+ int32_t* total_packets) const { |
+ RTC_CHECK_LT(index, GetNumberOfEvents()); |
+ const rtclog::Event& event = stream_[index]; |
+ RTC_CHECK(event.has_type()); |
+ RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PACKET_LOSS_EVENT); |
+ RTC_CHECK(event.has_bwe_packet_loss_event()); |
+ const rtclog::BwePacketLossEvent& loss_event = event.bwe_packet_loss_event(); |
+ RTC_CHECK(loss_event.has_bitrate()); |
+ if (bitrate != nullptr) { |
+ *bitrate = loss_event.bitrate(); |
+ } |
+ RTC_CHECK(loss_event.has_fraction_loss()); |
+ if (fraction_loss != nullptr) { |
+ *fraction_loss = loss_event.fraction_loss(); |
+ } |
+ RTC_CHECK(loss_event.has_total_packets()); |
+ if (total_packets != nullptr) { |
+ *total_packets = loss_event.total_packets(); |
+ } |
+} |
+ |
+} // namespace webrtc |