Add pcap support to bwe tools. Allow filtering on SSRCs.

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.
  */
 
@@ skipping 51 matching lines @@
     uint8_t tmp;
     if (fread(&tmp, 1, sizeof(uint8_t), file) != sizeof(uint8_t))
       return false;
     *out |= tmp;
   }
   return true;
 }
 
 class RtpFileReaderImpl : public RtpFileReader {
  public:
-  virtual bool Init(const std::string& filename) = 0;
+  virtual bool Init(const std::string& filename,
+                    const std::set<uint32_t>& ssrc_filter) = 0;
 };
 
 class InterleavedRtpFileReader : public RtpFileReaderImpl {
  public:
   virtual ~InterleavedRtpFileReader() {
     if (file_ != NULL) {
       fclose(file_);
       file_ = NULL;
     }
   }
 
-  virtual bool Init(const std::string& filename) {
+  virtual bool Init(const std::string& filename,
+                    const std::set<uint32_t>& ssrc_filter) {
     file_ = fopen(filename.c_str(), "rb");
     if (file_ == NULL) {
       printf("ERROR: Can't open file: %s\n", filename.c_str());
       return false;
     }
     return true;
   }
   virtual bool NextPacket(RtpPacket* packet) {
     assert(file_ != NULL);
     packet->length = RtpPacket::kMaxPacketBufferSize;
@@ skipping 25 matching lines @@
 class RtpDumpReader : public RtpFileReaderImpl {
  public:
   RtpDumpReader() : file_(NULL) {}
   virtual ~RtpDumpReader() {
     if (file_ != NULL) {
       fclose(file_);
       file_ = NULL;
     }
   }
 
-  bool Init(const std::string& filename) {
+  bool Init(const std::string& filename,
+            const std::set<uint32_t>& ssrc_filter) {
     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");
       return false;
@@ skipping 117 matching lines @@
       next_packet_it_() {
   }
 
   virtual ~PcapReader() {
     if (file_ != NULL) {
       fclose(file_);
       file_ = NULL;
     }
   }
 
-  bool Init(const std::string& filename) override {
-    return Initialize(filename) == kResultSuccess;
+  bool Init(const std::string& filename,
+            const std::set<uint32_t>& ssrc_filter) override {
+    return Initialize(filename, ssrc_filter) == kResultSuccess;
   }
 
-  int Initialize(const std::string& filename) {
+  int Initialize(const std::string& filename,
+                 const std::set<uint32_t>& ssrc_filter) {
     file_ = fopen(filename.c_str(), "rb");
     if (file_ == NULL) {
       printf("ERROR: Can't open file: %s\n", filename.c_str());
       return kResultFail;
     }
 
     if (ReadGlobalHeader() < 0) {
       return kResultFail;
     }
 
     int total_packet_count = 0;
     uint32_t stream_start_ms = 0;
     int32_t next_packet_pos = ftell(file_);
     for (;;) {
       TRY_PCAP(fseek(file_, next_packet_pos, SEEK_SET));
       int result = ReadPacket(&next_packet_pos, stream_start_ms,
-                              ++total_packet_count);
+                              ++total_packet_count, ssrc_filter);
       if (result == kResultFail) {
         break;
       } else if (result == kResultSuccess && packets_.size() == 1) {
         assert(stream_start_ms == 0);
         PacketIterator it = packets_.begin();
         stream_start_ms = it->time_offset_ms;
         it->time_offset_ms = 0;
       }
     }
 
     if (feof(file_) == 0) {
       printf("Failed reading file!\n");
       return kResultFail;
     }
 
     printf("Total packets in file: %d\n", total_packet_count);
     printf("Total RTP/RTCP packets: %" PRIuS "\n", packets_.size());
 
     for (SsrcMapIterator mit = packets_by_ssrc_.begin();
         mit != packets_by_ssrc_.end(); ++mit) {
       uint32_t ssrc = mit->first;
-      const std::vector<uint32_t>& packet_numbers = mit->second;
-      uint8_t pt = packets_[packet_numbers[0]].rtp_header.payloadType;
+      const std::vector<uint32_t>& packet_indices = mit->second;
+      uint8_t pt = packets_[packet_indices[0]].rtp_header.payloadType;
       printf("SSRC: %08x, %" PRIuS " packets, pt=%d\n", ssrc,
-             packet_numbers.size(), pt);
+             packet_indices.size(), pt);
     }
 
     // TODO(solenberg): Better validation of identified SSRC streams.
     //
     // Since we're dealing with raw network data here, we will wrongly identify
     // some packets as RTP. When these packets are consumed by RtpPlayer, they
     // are unlikely to cause issues as they will ultimately be filtered out by
     // the RtpRtcp module. However, we should really do better filtering here,
     // which we can accomplish in a number of ways, e.g.:
     //
@@ skipping 87 matching lines @@
 
     // Accept only LINKTYPE_NULL and LINKTYPE_ETHERNET.
     // See: http://www.tcpdump.org/linktypes.html
     if (network != kLinktypeNull && network != kLinktypeEthernet) {
       return kResultFail;
     }
 
     return kResultSuccess;
   }
 
-  int ReadPacket(int32_t* next_packet_pos, uint32_t stream_start_ms,
-                 uint32_t number) {
+  int ReadPacket(int32_t* next_packet_pos,
+                 uint32_t stream_start_ms,
+                 uint32_t number,
+                 const std::set<uint32_t>& ssrc_filter) {
     assert(next_packet_pos);
 
     uint32_t ts_sec;    // Timestamp seconds.
     uint32_t ts_usec;   // Timestamp microseconds.
     uint32_t incl_len;  // Number of octets of packet saved in file.
     uint32_t orig_len;  // Actual length of packet.
     TRY_PCAP(Read(&ts_sec, false));
     TRY_PCAP(Read(&ts_usec, false));
     TRY_PCAP(Read(&incl_len, false));
     TRY_PCAP(Read(&orig_len, false));
@@ skipping 16 matching lines @@
     if (rtp_parser.RTCP()) {
       rtp_parser.ParseRtcp(&marker.rtp_header);
       packets_.push_back(marker);
     } else {
       if (!rtp_parser.Parse(marker.rtp_header, NULL)) {
         DEBUG_LOG("Not recognized as RTP/RTCP");
         return kResultSkip;
       }
 
       uint32_t ssrc = marker.rtp_header.ssrc;
-      packets_by_ssrc_[ssrc].push_back(marker.packet_number);
-      packets_.push_back(marker);
+      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
@@ skipping 153 matching lines @@
   uint8_t read_buffer_[kMaxReadBufferSize];
 
   SsrcMap packets_by_ssrc_;
   std::vector<RtpPacketMarker> packets_;
   PacketIterator next_packet_it_;
 
   DISALLOW_COPY_AND_ASSIGN(PcapReader);
 };
 
 RtpFileReader* RtpFileReader::Create(FileFormat format,
-                                     const std::string& filename) {
+                                     const std::string& filename,
+                                     const std::set<uint32_t>& ssrc_filter) {
   RtpFileReaderImpl* reader = NULL;
   switch (format) {
     case kPcap:
       reader = new PcapReader();
       break;
     case kRtpDump:
       reader = new RtpDumpReader();
       break;
     case kLengthPacketInterleaved:
       reader = new InterleavedRtpFileReader();
       break;
   }
-  if (!reader->Init(filename)) {
+  if (!reader->Init(filename, ssrc_filter)) {
     delete reader;
     return NULL;
   }
   return reader;
 }
 
+RtpFileReader* RtpFileReader::Create(FileFormat format,
+                                     const std::string& filename) {
+  return RtpFileReader::Create(format, filename, std::set<uint32_t>());
+}
+
 }  // namespace test
 }  // namespace webrtc