Convenience functions to convert RtcEvents to webrtc types.

webrtc/video/rtc_event_log_parser.cc

Index: webrtc/video/rtc_event_log_parser.cc
diff --git a/webrtc/video/rtc_event_log_parser.cc b/webrtc/video/rtc_event_log_parser.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9353c038a05320cbd6e010bc912e7d3512d81a89
--- /dev/null
+++ b/webrtc/video/rtc_event_log_parser.cc
@@ -0,0 +1,249 @@
+/*
+ *  Copyright (c) 2015 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/video/rtc_event_log_parser.h"
+
+#include <string.h>
+#include <string>
+
+#include "webrtc/base/checks.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/call.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
+#include "webrtc/system_wrappers/interface/file_wrapper.h"
+#include "webrtc/video/rtc_event_log.h"
+
+// Files generated at build-time by the protobuf compiler.
+#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
+#include "external/webrtc/webrtc/video/rtc_event_log.pb.h"
+#else
+#include "webrtc/video/rtc_event_log.pb.h"
+#endif
+
+namespace webrtc {
+
+MediaType RtcEventLogParser::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;
+}
+
+bool RtcEventLogParser::ParseRtcEventLog(const std::string& file_name,
+                                         rtclog::EventStream* result) {
+  char tmp_buffer[1024];
+  int bytes_read = 0;
+  rtc::scoped_ptr<FileWrapper> dump_file(FileWrapper::Create());
+  if (dump_file->OpenFile(file_name.c_str(), true) != 0) {
+    return false;
+  }
+  std::string dump_buffer;
+  while ((bytes_read = dump_file->Read(tmp_buffer, sizeof(tmp_buffer))) > 0) {
+    dump_buffer.append(tmp_buffer, bytes_read);
+  }
+  dump_file->CloseFile();
+  return result->ParseFromString(dump_buffer);
+}
+
+int64_t RtcEventLogParser::GetTimestamp(const rtclog::Event& event) {
+  CHECK(event.has_timestamp_us());
+  return event.timestamp_us();
+}
+
+rtclog::Event_EventType RtcEventLogParser::GetEventType(
+    const rtclog::Event& event) {
+  CHECK(event.has_type());
+  return event.type();
+}
+
+// The header must have space for at least IP_PACKET_SIZE bytes.
+void RtcEventLogParser::GetRtpHeader(const rtclog::Event& event,
+                                     bool* incoming,
+                                     MediaType* media_type,
+                                     uint8_t* header,
+                                     size_t* header_length,
+                                     size_t* total_length) {
+  CHECK(event.has_type());
+  CHECK(event.type() == rtclog::Event::RTP_EVENT);
+  CHECK(event.has_rtp_packet());
+  const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
+  // Get direction of packet.
+  CHECK(rtp_packet.has_incoming());
+  if (incoming != nullptr)
+    *incoming = rtp_packet.incoming();
+  // Get media type.
+  CHECK(rtp_packet.has_type());
+  if (media_type != nullptr) {
+    *media_type = GetRuntimeMediaType(rtp_packet.type());
+  }
+  // Get packet length.
+  CHECK(rtp_packet.has_packet_length());
+  if (total_length != nullptr)
+    *total_length = rtp_packet.packet_length();
+  // Get header length.
+  CHECK(rtp_packet.has_header());
+  if (header_length != nullptr)
+    *header_length = rtp_packet.header().size();
+  // Get header contents.
+  if (header != nullptr) {
+    CHECK_LE(rtp_packet.header().size(), static_cast<unsigned>(IP_PACKET_SIZE));
+    memcpy(header, rtp_packet.header().data(), rtp_packet.header().size());

[ivoc, 2015/08/25 15:25:55]

Another option here would be to allocate the data here, and pass ownership to
the caller. You could do this by changing the header argument to uint8_t** type,
if it's set to nullptr, don't allocate a header, otherwise, allocate from here
and fill the buffer. 

[terelius, 2015/09/23 11:41:17]

The problem is that doing that would force a new allocation for each packet,
even if the application only want to check the header for an absolute send time.
I prefer doing it this way since ownership is more explicit and the same buffer
can be reused for multiple headers.

[ivoc, 2015/09/25 14:16:34]

Acknowledged.

+  }
+}
+
+// The packet must have space for at least IP_PACKET_SIZE bytes.
+void RtcEventLogParser::GetRtcpPacket(const rtclog::Event& event,
+                                      bool* incoming,
+                                      MediaType* media_type,
+                                      uint8_t* packet,
+                                      size_t* length) {
+  CHECK(event.has_type());
+  CHECK(event.type() == rtclog::Event::RTCP_EVENT);
+  CHECK(event.has_rtcp_packet());
+  const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet();
+  // Get direction of packet.
+  CHECK(rtcp_packet.has_incoming());
+  if (incoming != nullptr)
+    *incoming = rtcp_packet.incoming();
+  // Get media type.
+  CHECK(rtcp_packet.has_type());
+  if (media_type != nullptr) {
+    *media_type = GetRuntimeMediaType(rtcp_packet.type());
+  }
+  // Get packet length.
+  CHECK(rtcp_packet.has_packet_data());
+  if (length != nullptr)
+    *length = rtcp_packet.packet_data().size();
+  // Get packet contents.
+  if (packet != nullptr) {
+    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());

[ivoc, 2015/08/25 15:25:55]

Same here.

[terelius, 2015/09/23 11:41:17]

See above.

+  }
+}
+
+void RtcEventLogParser::GetVideoReceiveConfig(
+    const rtclog::Event& event,
+    VideoReceiveStream::Config* config) {
+  CHECK(config != nullptr);
+  CHECK(event.has_type());
+  CHECK(event.type() == rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
+  CHECK(event.has_video_receiver_config());
+  const rtclog::VideoReceiveConfig& receiver_config =
+      event.video_receiver_config();
+  // Get SSRCs.
+  CHECK(receiver_config.has_remote_ssrc());
+  config->rtp.remote_ssrc = receiver_config.remote_ssrc();
+  CHECK(receiver_config.has_local_ssrc());
+  config->rtp.local_ssrc = receiver_config.local_ssrc();
+  // Get RTCP settings.
+  CHECK(receiver_config.has_rtcp_mode());
+  switch (receiver_config.rtcp_mode()) {

[ivoc, 2015/08/25 15:25:55]

Would be nice to refactor this into a seperate conversion function, like the
other enum conversion function.

[terelius, 2015/09/23 11:41:17]

Done.

+    case rtclog::VideoReceiveConfig::RTCP_COMPOUND:
+      config->rtp.rtcp_mode = newapi::kRtcpCompound;
+      break;
+    case rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE:
+      config->rtp.rtcp_mode = newapi::kRtcpReducedSize;
+      break;
+  }
+  CHECK(receiver_config.has_receiver_reference_time_report());
+  config->rtp.rtcp_xr.receiver_reference_time_report =
+      receiver_config.receiver_reference_time_report();
+  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);
+    CHECK(map.has_payload_type());
+    CHECK(map.has_config());
+    CHECK(map.config().has_rtx_ssrc());
+    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++) {
+    CHECK(receiver_config.header_extensions(i).has_name());
+    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++) {
+    CHECK(receiver_config.decoders(i).has_name());
+    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 RtcEventLogParser::GetVideoSendConfig(const rtclog::Event& event,
+                                           VideoSendStream::Config* config) {
+  CHECK(config != nullptr);
+  CHECK(event.has_type());
+  CHECK(event.type() == rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
+  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++) {
+    CHECK(sender_config.header_extensions(i).has_name());
+    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));
+  }
+  // Check 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) {
+    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;
+  }
+  // Check CNAME.
+  CHECK(sender_config.has_c_name());
+  config->rtp.c_name = sender_config.c_name();
+  // Check encoder.
+  CHECK(sender_config.has_encoder());
+  CHECK(sender_config.encoder().has_name());
+  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();
+}
+
+}  // namespace webrtc