Mpeg2 TS - Fail when no valid timestamp in the ADTS parser.

media/formats/mp2t/es_parser_h264_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/time/time.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/h264_parser.h"
 #include "media/formats/mp2t/es_parser_h264.h"
+#include "media/formats/mp2t/es_parser_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 class VideoDecoderConfig;
 
 namespace mp2t {
 
 namespace {
 
-struct Packet {
-  // Offset in the stream.
-  size_t offset;
-
-  // Size of the packet.
-  size_t size;
-
-  // Timestamp of the packet.
-  base::TimeDelta pts;
-};
-
-// Compute the size of each packet assuming packets are given in stream order
-// and the last packet covers the end of the stream.
-void ComputePacketSize(std::vector<Packet>& packets, size_t stream_size) {
-  for (size_t k = 0; k < packets.size() - 1; k++) {
-    DCHECK_GE(packets[k + 1].offset, packets[k].offset);
-    packets[k].size = packets[k + 1].offset - packets[k].offset;
-  }
-  packets[packets.size() - 1].size =
-      stream_size - packets[packets.size() - 1].offset;
-}
-
 // Get the offset of the start of each access unit.
 // This function assumes there is only one slice per access unit.
 // This is a very simplified access unit segmenter that is good
 // enough for unit tests.
 std::vector<Packet> GetAccessUnits(const uint8* stream, size_t stream_size) {
   std::vector<Packet> access_units;
   bool start_access_unit = true;
 
   // In a first pass, retrieve the offsets of all access units.
   size_t offset = 0;
@@ skipping 21 matching lines @@
       break;
     int nal_unit_type = stream[offset] & 0x1f;
 
     // We assume there is only one slice per access unit.
     if (nal_unit_type == H264NALU::kIDRSlice ||
         nal_unit_type == H264NALU::kNonIDRSlice) {
       start_access_unit = true;
     }
   }
 
-  ComputePacketSize(access_units, stream_size);
+  ComputePacketSize(&access_units, stream_size);
   return access_units;
 }
 
 // Append an AUD NALU at the beginning of each access unit
 // needed for streams which do not already have AUD NALUs.
 void AppendAUD(
     const uint8* stream, size_t stream_size,
     const std::vector<Packet>& access_units,
     std::vector<uint8>& stream_with_aud,
     std::vector<Packet>& access_units_with_aud) {
@@ skipping 19 matching lines @@
 
 class EsParserH264Test : public testing::Test {
  public:
   EsParserH264Test() : buffer_count_(0) {
   }
   virtual ~EsParserH264Test() {}
 
  protected:
   void LoadStream(const char* filename);
   void GetPesTimestamps(std::vector<Packet>& pes_packets);
-  void ProcessPesPackets(const std::vector<Packet>& pes_packets,
-                         bool force_timing);
+  bool Process(const std::vector<Packet>& pes_packets, bool force_timing);
 
   // Stream with AUD NALUs.
   std::vector<uint8> stream_;
 
   // Access units of the stream with AUD NALUs.
   std::vector<Packet> access_units_;
 
   // Number of buffers generated while parsing the H264 stream.
   size_t buffer_count_;
 
@@ skipping 45 matching lines @@
       size_t pes_end = pes_packets[pes_idx].offset + pes_packets[pes_idx].size;
       if (pes_start <= access_units_[k].offset &&
           pes_end > access_units_[k].offset) {
         pes_packets[pes_idx].pts = access_units_[k].pts;
         break;
       }
     }
   }
 }
 
-void EsParserH264Test::ProcessPesPackets(
+bool EsParserH264Test::Process(
     const std::vector<Packet>& pes_packets,
     bool force_timing) {
   EsParserH264 es_parser(
       base::Bind(&EsParserH264Test::NewVideoConfig, base::Unretained(this)),
       base::Bind(&EsParserH264Test::EmitBuffer, base::Unretained(this)));
 
-  for (size_t k = 0; k < pes_packets.size(); k++) {
-    size_t cur_pes_offset = pes_packets[k].offset;
-    size_t cur_pes_size = pes_packets[k].size;
-
-    base::TimeDelta pts = kNoTimestamp();
-    base::TimeDelta dts = kNoTimestamp();
-    if (pes_packets[k].pts >= base::TimeDelta() || force_timing)
-      pts = pes_packets[k].pts;
-
-    ASSERT_TRUE(
-        es_parser.Parse(&stream_[cur_pes_offset], cur_pes_size, pts, dts));
-  }
-  es_parser.Flush();
+  return ProcessPesPackets(&es_parser, stream_, pes_packets, force_timing);
 }
 
 void EsParserH264Test::EmitBuffer(scoped_refptr<StreamParserBuffer> buffer) {
   ASSERT_LT(buffer_count_, access_units_.size());
   EXPECT_EQ(buffer->timestamp(), access_units_[buffer_count_].pts);
   buffer_count_++;
 }
 
 TEST_F(EsParserH264Test, OneAccessUnitPerPes) {
   LoadStream("bear.h264");
 
   // One to one equivalence between PES packets and access units.
   std::vector<Packet> pes_packets(access_units_);
   GetPesTimestamps(pes_packets);
 
   // Process each PES packet.
-  ProcessPesPackets(pes_packets, false);
+  EXPECT_TRUE(Process(pes_packets, false));
   EXPECT_EQ(buffer_count_, access_units_.size());
 }
 
 TEST_F(EsParserH264Test, NonAlignedPesPacket) {
   LoadStream("bear.h264");
 
   // Generate the PES packets.
   std::vector<Packet> pes_packets;
   Packet cur_pes_packet;
   cur_pes_packet.offset = 0;
   for (size_t k = 0; k < access_units_.size(); k++) {
     pes_packets.push_back(cur_pes_packet);
 
     // The current PES packet includes the remaining bytes of the previous
     // access unit and some bytes of the current access unit
     // (487 bytes in this unit test but no more than the current access unit
     // size).
     cur_pes_packet.offset = access_units_[k].offset +
         std::min<size_t>(487u, access_units_[k].size);
   }
-  ComputePacketSize(pes_packets, stream_.size());
+  ComputePacketSize(&pes_packets, stream_.size());
   GetPesTimestamps(pes_packets);
 
   // Process each PES packet.
-  ProcessPesPackets(pes_packets, false);
+  EXPECT_TRUE(Process(pes_packets, false));
   EXPECT_EQ(buffer_count_, access_units_.size());
 }
 
 TEST_F(EsParserH264Test, SeveralPesPerAccessUnit) {
   LoadStream("bear.h264");
 
   // Get the minimum size of an access unit.
   size_t min_access_unit_size = stream_.size();
   for (size_t k = 0; k < access_units_.size(); k++) {
     if (min_access_unit_size >= access_units_[k].size)
       min_access_unit_size = access_units_[k].size;
   }
 
   // Use a small PES packet size or the minimum access unit size
   // if it is even smaller.
   size_t pes_size = 512;
   if (min_access_unit_size < pes_size)
     pes_size = min_access_unit_size;
 
   std::vector<Packet> pes_packets;
   Packet cur_pes_packet;
   cur_pes_packet.offset = 0;
   while (cur_pes_packet.offset < stream_.size()) {
     pes_packets.push_back(cur_pes_packet);
     cur_pes_packet.offset += pes_size;
   }
-  ComputePacketSize(pes_packets, stream_.size());
+  ComputePacketSize(&pes_packets, stream_.size());
   GetPesTimestamps(pes_packets);
 
   // Process each PES packet.
-  ProcessPesPackets(pes_packets, false);
+  EXPECT_TRUE(Process(pes_packets, false));
   EXPECT_EQ(buffer_count_, access_units_.size());
 
   // Process PES packets forcing timings for each PES packet.
   buffer_count_ = 0;
-  ProcessPesPackets(pes_packets, true);
+  EXPECT_TRUE(Process(pes_packets, true));
   EXPECT_EQ(buffer_count_, access_units_.size());
 }
 
 }  // namespace mp2t
 }  // namespace media