Revert of Tool to convert RtcEventLog files to RtpDump format.

webrtc/video/rtc_event_log2rtp_dump.cc

Index: webrtc/video/rtc_event_log2rtp_dump.cc
diff --git a/webrtc/video/rtc_event_log2rtp_dump.cc b/webrtc/video/rtc_event_log2rtp_dump.cc
deleted file mode 100644
index 4f1d93bbe46ce55997d42a2fdf7d8786a75c8a08..0000000000000000000000000000000000000000
--- a/webrtc/video/rtc_event_log2rtp_dump.cc
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- *  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 <iostream>
-#include <sstream>
-#include <string>
-
-#include "gflags/gflags.h"
-#include "webrtc/base/checks.h"
-#include "webrtc/base/scoped_ptr.h"
-#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
-#include "webrtc/test/rtp_file_writer.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 {
-
-DEFINE_bool(noaudio,
-            false,
-            "Excludes audio packets from the converted RTPdump file.");
-DEFINE_bool(novideo,
-            false,
-            "Excludes video packets from the converted RTPdump file.");
-DEFINE_bool(nodata,
-            false,
-            "Excludes data packets from the converted RTPdump file.");
-DEFINE_bool(nortp,
-            false,
-            "Excludes RTP packets from the converted RTPdump file.");
-DEFINE_bool(nortcp,
-            false,
-            "Excludes RTCP packets from the converted RTPdump file.");
-DEFINE_string(ssrc,
-              "",
-              "Store only packets with this SSRC (decimal or hex, the latter "
-              "starting with 0x).");
-
-// Parses the input string for a valid SSRC. If a valid SSRC is found, it is
-// written to the output variable |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, uint32_t* ssrc) {
-  // 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 >> *ssrc;
-  return str.empty() || (!ss.fail() && ss.eof());
-}
-
-}  // namespace
-
-// This utility will convert a stored event log to the rtpdump format.
-int main(int argc, char* argv[]) {
-  std::string program_name = argv[0];
-  std::string usage =
-      "Tool for converting an RtcEventLog file to an RTP dump file.\n"
-      "Run " +
-      program_name +
-      " --helpshort for usage.\n"
-      "Example usage:\n" +
-      program_name + " input.rel output.rtp\n";
-  google::SetUsageMessage(usage);
-  google::ParseCommandLineFlags(&argc, &argv, true);
-
-  if (argc != 3) {
-    std::cout << google::ProgramUsage();
-    return 0;
-  }
-  std::string input_file = argv[1];
-  std::string output_file = argv[2];
-
-  uint32_t ssrc_filter = 0;
-  if (!FLAGS_ssrc.empty())
-    RTC_CHECK(ParseSsrc(FLAGS_ssrc, &ssrc_filter))
-        << "Flag verification has failed.";
-
-  webrtc::rtclog::EventStream event_stream;
-  if (!webrtc::RtcEventLog::ParseRtcEventLog(input_file, &event_stream)) {
-    std::cerr << "Error while parsing input file: " << input_file << std::endl;
-    return -1;
-  }
-
-  rtc::scoped_ptr<webrtc::test::RtpFileWriter> rtp_writer(
-      webrtc::test::RtpFileWriter::Create(
-          webrtc::test::RtpFileWriter::FileFormat::kRtpDump, output_file));
-
-  if (!rtp_writer.get()) {
-    std::cerr << "Error while opening output file: " << output_file
-              << std::endl;
-    return -1;
-  }
-
-  std::cout << "Found " << event_stream.stream_size()
-            << " events in the input file." << std::endl;
-  int rtp_counter = 0, rtcp_counter = 0;
-  bool header_only = false;
-  // TODO(ivoc): This can be refactored once the packet interpretation
-  //             functions are finished.
-  for (int i = 0; i < event_stream.stream_size(); i++) {
-    const webrtc::rtclog::Event& event = event_stream.stream(i);
-    if (!FLAGS_nortp && event.has_type() && event.type() == event.RTP_EVENT) {
-      if (event.has_timestamp_us() && event.has_rtp_packet() &&
-          event.rtp_packet().has_header() &&
-          event.rtp_packet().header().size() >= 12 &&
-          event.rtp_packet().has_packet_length() &&
-          event.rtp_packet().has_type()) {
-        const webrtc::rtclog::RtpPacket& rtp_packet = event.rtp_packet();
-        if (FLAGS_noaudio && rtp_packet.type() == webrtc::rtclog::AUDIO)
-          continue;
-        if (FLAGS_novideo && rtp_packet.type() == webrtc::rtclog::VIDEO)
-          continue;
-        if (FLAGS_nodata && rtp_packet.type() == webrtc::rtclog::DATA)
-          continue;
-        if (!FLAGS_ssrc.empty()) {
-          const uint32_t packet_ssrc =
-              webrtc::ByteReader<uint32_t>::ReadBigEndian(
-                  reinterpret_cast<const uint8_t*>(rtp_packet.header().data() +
-                                                   8));
-          if (packet_ssrc != ssrc_filter)
-            continue;
-        }
-
-        webrtc::test::RtpPacket packet;
-        packet.length = rtp_packet.header().size();
-        if (packet.length > packet.kMaxPacketBufferSize) {
-          std::cout << "Skipping packet with size " << packet.length
-                    << ", the maximum supported size is "
-                    << packet.kMaxPacketBufferSize << std::endl;
-          continue;
-        }
-        packet.original_length = rtp_packet.packet_length();
-        if (packet.original_length > packet.length)
-          header_only = true;
-        packet.time_ms = event.timestamp_us() / 1000;
-        memcpy(packet.data, rtp_packet.header().data(), packet.length);
-        rtp_writer->WritePacket(&packet);
-        rtp_counter++;
-      } else {
-        std::cout << "Skipping malformed event." << std::endl;
-      }
-    }
-    if (!FLAGS_nortcp && event.has_type() && event.type() == event.RTCP_EVENT) {
-      if (event.has_timestamp_us() && event.has_rtcp_packet() &&
-          event.rtcp_packet().has_type() &&
-          event.rtcp_packet().has_packet_data() &&
-          event.rtcp_packet().packet_data().size() > 0) {
-        const webrtc::rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet();
-        if (FLAGS_noaudio && rtcp_packet.type() == webrtc::rtclog::AUDIO)
-          continue;
-        if (FLAGS_novideo && rtcp_packet.type() == webrtc::rtclog::VIDEO)
-          continue;
-        if (FLAGS_nodata && rtcp_packet.type() == webrtc::rtclog::DATA)
-          continue;
-        if (!FLAGS_ssrc.empty()) {
-          const uint32_t packet_ssrc =
-              webrtc::ByteReader<uint32_t>::ReadBigEndian(
-                  reinterpret_cast<const uint8_t*>(
-                      rtcp_packet.packet_data().data() + 4));
-          if (packet_ssrc != ssrc_filter)
-            continue;
-        }
-
-        webrtc::test::RtpPacket packet;
-        packet.length = rtcp_packet.packet_data().size();
-        if (packet.length > packet.kMaxPacketBufferSize) {
-          std::cout << "Skipping packet with size " << packet.length
-                    << ", the maximum supported size is "
-                    << packet.kMaxPacketBufferSize << std::endl;
-          continue;
-        }
-        // For RTCP packets the original_length should be set to 0 in the
-        // RTPdump format.
-        packet.original_length = 0;
-        packet.time_ms = event.timestamp_us() / 1000;
-        memcpy(packet.data, rtcp_packet.packet_data().data(), packet.length);
-        rtp_writer->WritePacket(&packet);
-        rtcp_counter++;
-      } else {
-        std::cout << "Skipping malformed event." << std::endl;
-      }
-    }
-  }
-  std::cout << "Wrote " << rtp_counter << (header_only ? " header-only" : "")
-            << " RTP packets and " << rtcp_counter << " RTCP packets to the "
-            << "output file." << std::endl;
-  return 0;
-}