Add back video_replay. Disappeared in the gn conversion.

webrtc/test/rtp_file_reader.cc

 /*
  *  Copyright (c) 2014 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/test/rtp_file_reader.h"
 
 #include <stdio.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/format_macros.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 
 namespace webrtc {
 namespace test {
 
 static const size_t kFirstLineLength = 40;
 static uint16_t kPacketHeaderSize = 8;
 
-#if 1
-# define DEBUG_LOG(text)
-# define DEBUG_LOG1(text, arg)
-#else
-# define DEBUG_LOG(text) (printf(text "\n"))
-# define DEBUG_LOG1(text, arg) (printf(text "\n", arg))
-#endif
-
 #define TRY(expr)                                      \
   do {                                                 \
     if (!(expr)) {                                     \
-      DEBUG_LOG1("FAIL at " __FILE__ ":%d", __LINE__); \
+      LOG(LS_INFO) << "Failed to read";                \
       return false;                                    \
     }                                                  \
   } while (0)
 
 bool ReadUint32(uint32_t* out, FILE* file) {
   *out = 0;
   for (size_t i = 0; i < 4; ++i) {
     *out <<= 8;
     uint8_t tmp;
     if (fread(&tmp, 1, sizeof(uint8_t), file) != sizeof(uint8_t))
@@ skipping 80 matching lines @@
   bool Init(const std::string& filename,
             const std::set<uint32_t>& ssrc_filter) override {
     file_ = fopen(filename.c_str(), "rb");
     if (file_ == NULL) {
       printf("ERROR: Can't open file: %s\n", filename.c_str());
       return false;
     }
 
     char firstline[kFirstLineLength + 1] = {0};
     if (fgets(firstline, kFirstLineLength, file_) == NULL) {
-      DEBUG_LOG("ERROR: Can't read from file\n");
+      LOG(LS_INFO) << "Can't read from file";
       return false;
     }
     if (strncmp(firstline, "#!rtpplay", 9) == 0) {
       if (strncmp(firstline, "#!rtpplay1.0", 12) != 0) {
-        DEBUG_LOG("ERROR: wrong rtpplay version, must be 1.0\n");
+        LOG(LS_INFO) <<  "Wrong rtpplay version, must be 1.0";
         return false;
       }
     } else if (strncmp(firstline, "#!RTPencode", 11) == 0) {
       if (strncmp(firstline, "#!RTPencode1.0", 14) != 0) {
-        DEBUG_LOG("ERROR: wrong RTPencode version, must be 1.0\n");
+        LOG(LS_INFO) << "Wrong RTPencode version, must be 1.0";
         return false;
       }
     } else {
-      DEBUG_LOG("ERROR: wrong file format of input file\n");
+      LOG(LS_INFO) << "Wrong file format of input file";
       return false;
     }
 
     uint32_t start_sec;
     uint32_t start_usec;
     uint32_t source;
     uint16_t port;
     uint16_t padding;
     TRY(ReadUint32(&start_sec, file_));
     TRY(ReadUint32(&start_usec, file_));
@@ skipping 62 matching lines @@
   kMaxReadBufferSize = 4096
 };
 
 const uint32_t kPcapBOMSwapOrder = 0xd4c3b2a1UL;
 const uint32_t kPcapBOMNoSwapOrder = 0xa1b2c3d4UL;
 
 #define TRY_PCAP(expr)                                 \
   do {                                                 \
     int r = (expr);                                    \
     if (r == kResultFail) {                            \
-      DEBUG_LOG1("FAIL at " __FILE__ ":%d", __LINE__); \
+      LOG(LS_INFO) << "FAIL at " << __FILE__  << ":" << __LINE__; \
       return kResultFail;                              \
     } else if (r == kResultSkip) {                     \
       return kResultSkip;                              \
     }                                                  \
   } while (0)
 
 // Read RTP packets from file in tcpdump/libpcap format, as documented at:
 // http://wiki.wireshark.org/Development/LibpcapFileFormat
 class PcapReader : public RtpFileReaderImpl {
  public:
@@ skipping 202 matching lines @@
       return kResultFail;
     }
     TRY_PCAP(Read(read_buffer_, marker.payload_length));
 
     RtpUtility::RtpHeaderParser rtp_parser(read_buffer_, marker.payload_length);
     if (rtp_parser.RTCP()) {
       rtp_parser.ParseRtcp(&marker.rtp_header);
       packets_.push_back(marker);
     } else {
       if (!rtp_parser.Parse(&marker.rtp_header, nullptr)) {
-        DEBUG_LOG("Not recognized as RTP/RTCP");
+        LOG(LS_INFO) << "Not recognized as RTP/RTCP";
         return kResultSkip;
       }
 
       uint32_t ssrc = marker.rtp_header.ssrc;
       if (ssrc_filter.empty() || ssrc_filter.find(ssrc) != ssrc_filter.end()) {
         packets_by_ssrc_[ssrc].push_back(
             static_cast<uint32_t>(packets_.size()));
         packets_.push_back(marker);
       } else {
         return kResultSkip;
       }
     }
 
     return kResultSuccess;
   }
 
   int ReadPacketHeader(RtpPacketMarker* marker) {
     int32_t file_pos = ftell(file_);
 
     // Check for BSD null/loopback frame header. The header is just 4 bytes in
     // native byte order, so we check for both versions as we don't care about
     // the header as such and will likely fail reading the IP header if this is
     // something else than null/loopback.
     uint32_t protocol;
     TRY_PCAP(Read(&protocol, true));
     if (protocol == kBsdNullLoopback1 || protocol == kBsdNullLoopback2) {
       int result = ReadXxpIpHeader(marker);
-      DEBUG_LOG("Recognized loopback frame");
+      LOG(LS_INFO) << "Recognized loopback frame";
       if (result != kResultSkip) {
         return result;
       }
     }
 
     TRY_PCAP(fseek(file_, file_pos, SEEK_SET));
 
     // Check for Ethernet II, IP frame header.
     uint16_t type;
     TRY_PCAP(Skip(kEthernetIIHeaderMacSkip));  // Source+destination MAC.
     TRY_PCAP(Read(&type, true));
     if (type == kEthertypeIp) {
       int result = ReadXxpIpHeader(marker);
-      DEBUG_LOG("Recognized ethernet 2 frame");
+      LOG(LS_INFO) << "Recognized ethernet 2 frame";
       if (result != kResultSkip) {
         return result;
       }
     }
 
     return kResultSkip;
   }
 
   uint32_t CalcTimeDelta(uint32_t ts_sec, uint32_t ts_usec, uint32_t start_ms) {
     // Round to nearest ms.
@@ skipping 19 matching lines @@
     TRY_PCAP(Read(&version, true));
     TRY_PCAP(Read(&length, true));
     TRY_PCAP(Read(&id, true));
     TRY_PCAP(Read(&fragment, true));
     TRY_PCAP(Read(&protocol, true));
     TRY_PCAP(Read(&checksum, true));
     TRY_PCAP(Read(&marker->source_ip, true));
     TRY_PCAP(Read(&marker->dest_ip, true));
 
     if (((version >> 12) & 0x000f) != kIpVersion4) {
-      DEBUG_LOG("IP header is not IPv4");
+      LOG(LS_INFO) << "IP header is not IPv4";
       return kResultSkip;
     }
 
     if (fragment != kFragmentOffsetClear &&
         fragment != kFragmentOffsetDoNotFragment) {
-      DEBUG_LOG("IP fragments cannot be handled");
+      LOG(LS_INFO) << "IP fragments cannot be handled";
       return kResultSkip;
     }
 
     // Skip remaining fields of IP header.
     uint16_t header_length = (version & 0x0f00) >> (8 - 2);
     assert(header_length >= kMinIpHeaderLength);
     TRY_PCAP(Skip(header_length - kMinIpHeaderLength));
 
     protocol = protocol & 0x00ff;
     if (protocol == kProtocolTcp) {
-      DEBUG_LOG("TCP packets are not handled");
+      LOG(LS_INFO) << "TCP packets are not handled";
       return kResultSkip;
     } else if (protocol == kProtocolUdp) {
       uint16_t length;
       uint16_t checksum;
       TRY_PCAP(Read(&marker->source_port, true));
       TRY_PCAP(Read(&marker->dest_port, true));
       TRY_PCAP(Read(&length, true));
       TRY_PCAP(Read(&checksum, true));
       marker->payload_length = length - kUdpHeaderLength;
     } else {
-      DEBUG_LOG("Unknown transport (expected UDP or TCP)");
+      LOG(LS_INFO) << "Unknown transport (expected UDP or TCP)";
       return kResultSkip;
     }
 
     return kResultSuccess;
   }
 
   int Read(uint32_t* out, bool expect_network_order) {
     uint32_t tmp = 0;
     if (fread(&tmp, 1, sizeof(uint32_t), file_) != sizeof(uint32_t)) {
       return kResultFail;
@@ skipping 82 matching lines @@
   return reader;
 }
 
 RtpFileReader* RtpFileReader::Create(FileFormat format,
                                      const std::string& filename) {
   return RtpFileReader::Create(format, filename, std::set<uint32_t>());
 }
 
 }  // namespace test
 }  // namespace webrtc