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

BUG=None

Review URL: https://codereview.chromium.org/399433003

Cr-Commit-Position: refs/heads/master@{#289944}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@289944 0039d316-1c4b-4281-b951-d872f2087c98

media/BUILD.gn

@@ -512,7 +512,10 @@ test("media_unittests") {
       "formats/common/stream_parser_test_base.cc",
       "formats/common/stream_parser_test_base.h",
       "formats/mp2t/es_adapter_video_unittest.cc",
+      "formats/mp2t/es_parser_adts_unittest.cc",
       "formats/mp2t/es_parser_h264_unittest.cc",
+      "formats/mp2t/es_parser_test_base.cc",
+      "formats/mp2t/es_parser_test_base.h",
       "formats/mp2t/mp2t_stream_parser_unittest.cc",
       "formats/mp4/aac_unittest.cc",
       "formats/mp4/avc_unittest.cc",

media/formats/mp2t/es_parser_adts.cc

@@ -151,6 +151,10 @@ bool EsParserAdts::Parse(const uint8* buf, int size,
       pts_list_.pop_front();
     }
 
+    if (audio_timestamp_helper_->base_timestamp() == kNoTimestamp()) {
+      DVLOG(1) << "Audio frame with unknown timestamp";
+      return false;
+    }
     base::TimeDelta current_pts = audio_timestamp_helper_->GetTimestamp();
     base::TimeDelta frame_duration =
         audio_timestamp_helper_->GetFrameDuration(kSamplesPerAACFrame);
@@ -246,7 +250,8 @@ bool EsParserAdts::UpdateAudioConfiguration(const uint8* adts_header) {
     DVLOG(1) << "Channel config: " << channel_configuration;
     DVLOG(1) << "Adts profile: " << adts_profile;
     // Reset the timestamp helper to use a new time scale.
-    if (audio_timestamp_helper_) {
+    if (audio_timestamp_helper_ &&
+        audio_timestamp_helper_->base_timestamp() != kNoTimestamp()) {
       base::TimeDelta base_timestamp = audio_timestamp_helper_->GetTimestamp();
       audio_timestamp_helper_.reset(
         new AudioTimestampHelper(samples_per_second));

media/formats/mp2t/es_parser_adts.h

@@ -13,6 +13,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
+#include "media/base/media_export.h"
 #include "media/formats/mp2t/es_parser.h"
 
 namespace media {
@@ -25,7 +26,7 @@ class StreamParserBuffer;
 namespace media {
 namespace mp2t {
 
-class EsParserAdts : public EsParser {
+class MEDIA_EXPORT EsParserAdts : public EsParser {
  public:
   typedef base::Callback<void(const AudioDecoderConfig&)> NewAudioConfigCB;
 

media/formats/mp2t/es_parser_adts_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 <vector>
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/time/time.h"
+#include "media/base/buffers.h"
+#include "media/base/stream_parser_buffer.h"
+#include "media/formats/mp2t/es_parser_adts.h"
+#include "media/formats/mp2t/es_parser_test_base.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+class AudioDecoderConfig;
+
+namespace mp2t {
+
+class EsParserAdtsTest : public EsParserTestBase,
+                         public testing::Test {
+ public:
+  EsParserAdtsTest();
+  virtual ~EsParserAdtsTest() {}
+
+ protected:
+  bool Process(const std::vector<Packet>& pes_packets, bool force_timing);
+
+  std::vector<Packet> GenerateFixedSizePesPacket(size_t pes_size);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EsParserAdtsTest);
+};
+
+EsParserAdtsTest::EsParserAdtsTest() {
+}
+
+bool EsParserAdtsTest::Process(
+    const std::vector<Packet>& pes_packets,
+    bool force_timing) {
+  EsParserAdts es_parser(
+      base::Bind(&EsParserAdtsTest::NewAudioConfig, base::Unretained(this)),
+      base::Bind(&EsParserAdtsTest::EmitBuffer, base::Unretained(this)),
+      false);
+  return ProcessPesPackets(&es_parser, pes_packets, force_timing);
+}
+
+std::vector<EsParserTestBase::Packet>
+EsParserAdtsTest::GenerateFixedSizePesPacket(size_t pes_size) {
+  DCHECK_GT(stream_.size(), 0u);
+  std::vector<Packet> pes_packets;
+
+  Packet cur_pes_packet;
+  cur_pes_packet.offset = 0;
+  cur_pes_packet.pts = kNoTimestamp();
+  while (cur_pes_packet.offset < stream_.size()) {
+    pes_packets.push_back(cur_pes_packet);
+    cur_pes_packet.offset += pes_size;
+  }
+  ComputePacketSize(&pes_packets);
+
+  return pes_packets;
+}
+
+TEST_F(EsParserAdtsTest, NoInitialPts) {
+  LoadStream("bear.adts");
+  std::vector<Packet> pes_packets = GenerateFixedSizePesPacket(512);
+  EXPECT_FALSE(Process(pes_packets, false));
+  EXPECT_EQ(0u, buffer_count_);
+}
+
+TEST_F(EsParserAdtsTest, SinglePts) {
+  LoadStream("bear.adts");
+
+  std::vector<Packet> pes_packets = GenerateFixedSizePesPacket(512);
+  pes_packets.front().pts = base::TimeDelta::FromSeconds(10);
+
+  EXPECT_TRUE(Process(pes_packets, false));
+  EXPECT_EQ(1u, config_count_);
+  EXPECT_EQ(45u, buffer_count_);
+}
+
+}  // namespace mp2t
+}  // namespace media
+

media/formats/mp2t/es_parser_h264_unittest.cc

@@ -2,19 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <algorithm>
+#include <sstream>
+#include <string>
 #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/strings/string_util.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_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
@@ -22,36 +21,51 @@ class VideoDecoderConfig;
 
 namespace mp2t {
 
-namespace {
+class EsParserH264Test : public EsParserTestBase,
+                         public testing::Test {
+ public:
+  EsParserH264Test() {}
+  virtual ~EsParserH264Test() {}
+
+ protected:
+  void LoadH264Stream(const char* filename);
+  void GetPesTimestamps(std::vector<Packet>* pes_packets);
+  bool Process(const std::vector<Packet>& pes_packets, bool force_timing);
+  void CheckAccessUnits();
+
+  // Access units of the stream with AUD NALUs.
+  std::vector<Packet> access_units_;
 
-struct Packet {
-  // Offset in the stream.
-  size_t offset;
+ private:
+  // Get the offset of the start of each access unit of |stream_|.
+  // 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.
+  void GetAccessUnits();
 
-  // Size of the packet.
-  size_t size;
+  // Insert an AUD before each access unit.
+  // Update |stream_| and |access_units_| accordingly.
+  void InsertAUD();
 
-  // Timestamp of the packet.
-  base::TimeDelta pts;
+  DISALLOW_COPY_AND_ASSIGN(EsParserH264Test);
 };
 
-// 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;
+void EsParserH264Test::LoadH264Stream(const char* filename) {
+  // Load the input H264 file and segment it into access units.
+  LoadStream(filename);
+  GetAccessUnits();
+  ASSERT_GT(access_units_.size(), 0u);
+
+  // Insert AUDs into the stream.
+  InsertAUD();
+
+  // Generate some timestamps based on a 25fps stream.
+  for (size_t k = 0; k < access_units_.size(); k++)
+    access_units_[k].pts = base::TimeDelta::FromMilliseconds(k * 40u);
 }
 
-// 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;
+void EsParserH264Test::GetAccessUnits() {
+  access_units_.resize(0);
   bool start_access_unit = true;
 
   // In a first pass, retrieve the offsets of all access units.
@@ -61,7 +75,7 @@ std::vector<Packet> GetAccessUnits(const uint8* stream, size_t stream_size) {
     off_t relative_offset = 0;
     off_t start_code_size = 0;
     bool success = H264Parser::FindStartCode(
-        &stream[offset], stream_size - offset,
+        &stream_[offset], stream_.size() - offset,
         &relative_offset, &start_code_size);
     if (!success)
       break;
@@ -70,15 +84,15 @@ std::vector<Packet> GetAccessUnits(const uint8* stream, size_t stream_size) {
     if (start_access_unit) {
       Packet cur_access_unit;
       cur_access_unit.offset = offset;
-      access_units.push_back(cur_access_unit);
+      access_units_.push_back(cur_access_unit);
       start_access_unit = false;
     }
 
     // Get the NALU type.
     offset += start_code_size;
-    if (offset >= stream_size)
+    if (offset >= stream_.size())
       break;
-    int nal_unit_type = stream[offset] & 0x1f;
+    int nal_unit_type = stream_[offset] & 0x1f;
 
     // We assume there is only one slice per access unit.
     if (nal_unit_type == H264NALU::kIDRSlice ||
@@ -87,95 +101,46 @@ std::vector<Packet> GetAccessUnits(const uint8* stream, size_t stream_size) {
     }
   }
 
-  ComputePacketSize(access_units, stream_size);
-  return access_units;
+  ComputePacketSize(&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) {
+void EsParserH264Test::InsertAUD() {
   uint8 aud[] = { 0x00, 0x00, 0x01, 0x09 };
-  stream_with_aud.resize(stream_size + access_units.size() * sizeof(aud));
-  access_units_with_aud.resize(access_units.size());
+
+  std::vector<uint8> stream_with_aud(
+      stream_.size() + access_units_.size() * sizeof(aud));
+  std::vector<EsParserTestBase::Packet> access_units_with_aud(
+      access_units_.size());
 
   size_t offset = 0;
-  for (size_t k = 0; k < access_units.size(); k++) {
+  for (size_t k = 0; k < access_units_.size(); k++) {
     access_units_with_aud[k].offset = offset;
-    access_units_with_aud[k].size = access_units[k].size + sizeof(aud);
+    access_units_with_aud[k].size = access_units_[k].size + sizeof(aud);
 
     memcpy(&stream_with_aud[offset], aud, sizeof(aud));
     offset += sizeof(aud);
 
     memcpy(&stream_with_aud[offset],
-           &stream[access_units[k].offset], access_units[k].size);
-    offset += access_units[k].size;
-  }
-}
-
-}  // namespace
-
-class EsParserH264Test : public testing::Test {
- public:
-  EsParserH264Test() : buffer_count_(0) {
+           &stream_[access_units_[k].offset], access_units_[k].size);
+    offset += access_units_[k].size;
   }
-  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);
 
-  // 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_;
-
- private:
-  void EmitBuffer(scoped_refptr<StreamParserBuffer> buffer);
-
-  void NewVideoConfig(const VideoDecoderConfig& config) {
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(EsParserH264Test);
-};
-
-void EsParserH264Test::LoadStream(const char* filename) {
-  base::FilePath file_path = GetTestDataFilePath(filename);
-
-  base::MemoryMappedFile stream_without_aud;
-  ASSERT_TRUE(stream_without_aud.Initialize(file_path))
-      << "Couldn't open stream file: " << file_path.MaybeAsASCII();
-
-  // The input file does not have AUDs.
-  std::vector<Packet> access_units_without_aud = GetAccessUnits(
-      stream_without_aud.data(), stream_without_aud.length());
-  ASSERT_GT(access_units_without_aud.size(), 0u);
-  AppendAUD(stream_without_aud.data(), stream_without_aud.length(),
-            access_units_without_aud,
-            stream_, access_units_);
-
-  // Generate some timestamps based on a 25fps stream.
-  for (size_t k = 0; k < access_units_.size(); k++)
-    access_units_[k].pts = base::TimeDelta::FromMilliseconds(k * 40u);
+  // Update the stream and access units used for the test.
+  stream_ = stream_with_aud;
+  access_units_ = access_units_with_aud;
 }
 
-void EsParserH264Test::GetPesTimestamps(std::vector<Packet>& pes_packets) {
+void EsParserH264Test::GetPesTimestamps(std::vector<Packet>* pes_packets_ptr) {
+  DCHECK(pes_packets_ptr);
+  const std::vector<Packet>& pes_packets = *pes_packets_ptr;
+
   // Default: set to a negative timestamp to be able to differentiate from
   // real timestamps.
   // Note: we don't use kNoTimestamp() here since this one has already
   // a special meaning in EsParserH264. The negative timestamps should be
   // ultimately discarded by the H264 parser since not relevant.
   for (size_t k = 0; k < pes_packets.size(); k++) {
-    pes_packets[k].pts = base::TimeDelta::FromMilliseconds(-1);
+    (*pes_packets_ptr)[k].pts = base::TimeDelta::FromMilliseconds(-1);
   }
 
   // Set a valid timestamp for PES packets which include the start
@@ -187,55 +152,51 @@ void EsParserH264Test::GetPesTimestamps(std::vector<Packet>& pes_packets) {
       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;
+        (*pes_packets_ptr)[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)));
+  return ProcessPesPackets(&es_parser, pes_packets, force_timing);
+}
 
-  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();
-    DecodeTimestamp dts = kNoDecodeTimestamp();
-    if (pes_packets[k].pts >= base::TimeDelta() || force_timing)
-      pts = pes_packets[k].pts;
+void EsParserH264Test::CheckAccessUnits() {
+  EXPECT_EQ(buffer_count_, access_units_.size());
 
-    ASSERT_TRUE(
-        es_parser.Parse(&stream_[cur_pes_offset], cur_pes_size, pts, dts));
+  std::stringstream buffer_timestamps_stream;
+  for (size_t k = 0; k < access_units_.size(); k++) {
+    buffer_timestamps_stream << "("
+                             << access_units_[k].pts.InMilliseconds()
+                             << ") ";
   }
-  es_parser.Flush();
-}
-
-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_++;
+  std::string buffer_timestamps = buffer_timestamps_stream.str();
+  base::TrimWhitespaceASCII(
+      buffer_timestamps, base::TRIM_ALL, &buffer_timestamps);
+  EXPECT_EQ(buffer_timestamps_, buffer_timestamps);
 }
 
 TEST_F(EsParserH264Test, OneAccessUnitPerPes) {
-  LoadStream("bear.h264");
+  LoadH264Stream("bear.h264");
 
   // One to one equivalence between PES packets and access units.
   std::vector<Packet> pes_packets(access_units_);
-  GetPesTimestamps(pes_packets);
+  GetPesTimestamps(&pes_packets);
 
   // Process each PES packet.
-  ProcessPesPackets(pes_packets, false);
-  EXPECT_EQ(buffer_count_, access_units_.size());
+  EXPECT_TRUE(Process(pes_packets, false));
+  CheckAccessUnits();
 }
 
 TEST_F(EsParserH264Test, NonAlignedPesPacket) {
-  LoadStream("bear.h264");
+  LoadH264Stream("bear.h264");
 
   // Generate the PES packets.
   std::vector<Packet> pes_packets;
@@ -251,16 +212,16 @@ TEST_F(EsParserH264Test, NonAlignedPesPacket) {
     cur_pes_packet.offset = access_units_[k].offset +
         std::min<size_t>(487u, access_units_[k].size);
   }
-  ComputePacketSize(pes_packets, stream_.size());
-  GetPesTimestamps(pes_packets);
+  ComputePacketSize(&pes_packets);
+  GetPesTimestamps(&pes_packets);
 
   // Process each PES packet.
-  ProcessPesPackets(pes_packets, false);
-  EXPECT_EQ(buffer_count_, access_units_.size());
+  EXPECT_TRUE(Process(pes_packets, false));
+  CheckAccessUnits();
 }
 
 TEST_F(EsParserH264Test, SeveralPesPerAccessUnit) {
-  LoadStream("bear.h264");
+  LoadH264Stream("bear.h264");
 
   // Get the minimum size of an access unit.
   size_t min_access_unit_size = stream_.size();
@@ -282,17 +243,16 @@ TEST_F(EsParserH264Test, SeveralPesPerAccessUnit) {
     pes_packets.push_back(cur_pes_packet);
     cur_pes_packet.offset += pes_size;
   }
-  ComputePacketSize(pes_packets, stream_.size());
-  GetPesTimestamps(pes_packets);
+  ComputePacketSize(&pes_packets);
+  GetPesTimestamps(&pes_packets);
 
   // Process each PES packet.
-  ProcessPesPackets(pes_packets, false);
-  EXPECT_EQ(buffer_count_, access_units_.size());
+  EXPECT_TRUE(Process(pes_packets, false));
+  CheckAccessUnits();
 
   // Process PES packets forcing timings for each PES packet.
-  buffer_count_ = 0;
-  ProcessPesPackets(pes_packets, true);
-  EXPECT_EQ(buffer_count_, access_units_.size());
+  EXPECT_TRUE(Process(pes_packets, true));
+  CheckAccessUnits();
 }
 
 }  // namespace mp2t

media/formats/mp2t/es_parser_test_base.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 "media/formats/mp2t/es_parser_test_base.h"
+
+#include "base/files/memory_mapped_file.h"
+#include "base/logging.h"
+#include "base/path_service.h"
+#include "base/strings/string_util.h"
+#include "media/base/buffers.h"
+#include "media/base/stream_parser_buffer.h"
+#include "media/base/test_data_util.h"
+#include "media/formats/mp2t/es_parser.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+namespace mp2t {
+
+EsParserTestBase::Packet::Packet()
+    : offset(0u),
+      size(0u),
+      pts(kNoTimestamp()) {
+}
+
+EsParserTestBase::EsParserTestBase()
+    : config_count_(0u),
+      buffer_count_(0u) {
+}
+
+EsParserTestBase::~EsParserTestBase() {
+}
+
+void EsParserTestBase::LoadStream(const char* filename) {
+  base::FilePath file_path = GetTestDataFilePath(filename);
+
+  base::MemoryMappedFile stream;
+  ASSERT_TRUE(stream.Initialize(file_path))
+      << "Couldn't open stream file: " << file_path.MaybeAsASCII();
+
+  stream_.resize(stream.length());
+  memcpy(&stream_[0], stream.data(), stream_.size());
+}
+
+void EsParserTestBase::NewAudioConfig(const AudioDecoderConfig& config) {
+  config_count_++;
+}
+
+void EsParserTestBase::NewVideoConfig(const VideoDecoderConfig& config) {
+  config_count_++;
+}
+
+void EsParserTestBase::EmitBuffer(scoped_refptr<StreamParserBuffer> buffer) {
+  buffer_timestamps_stream_ << "("
+                            << buffer->timestamp().InMilliseconds()
+                            << ") ";
+  buffer_count_++;
+}
+
+bool EsParserTestBase::ProcessPesPackets(
+    EsParser* es_parser,
+    const std::vector<Packet>& pes_packets,
+    bool force_timing) {
+  DCHECK(es_parser);
+
+  buffer_count_ = 0;
+  config_count_ = 0;
+  buffer_timestamps_stream_.str(std::string());
+
+  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();
+    DecodeTimestamp dts = kNoDecodeTimestamp();
+    if (pes_packets[k].pts >= base::TimeDelta() || force_timing)
+      pts = pes_packets[k].pts;
+
+    DCHECK_LT(cur_pes_offset, stream_.size());
+    if (!es_parser->Parse(&stream_[cur_pes_offset], cur_pes_size, pts, dts))
+      return false;
+  }
+  es_parser->Flush();
+
+  buffer_timestamps_ = buffer_timestamps_stream_.str();
+  base::TrimWhitespaceASCII(
+      buffer_timestamps_, base::TRIM_ALL, &buffer_timestamps_);
+  return true;
+}
+
+void EsParserTestBase::ComputePacketSize(std::vector<Packet>* packets) {
+  DCHECK(packets);
+  if (packets->size() == 0u)
+    return;
+
+  Packet* cur = &(*packets)[0];
+  for (size_t k = 0; k < packets->size() - 1; k++) {
+    Packet* next = &(*packets)[k + 1];
+    DCHECK_GE(next->offset, cur->offset);
+    cur->size = next->offset - cur->offset;
+    cur = next;
+  }
+  DCHECK_GE(stream_.size(), cur->offset);
+  cur->size = stream_.size() - cur->offset;
+}
+
+}  // namespace mp2t
+}  // namespace media

media/formats/mp2t/es_parser_test_base.h

+// 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.
+
+#ifndef MEDIA_FORMATS_MP2T_ES_PARSER_TEST_BASE_H_
+#define MEDIA_FORMATS_MP2T_ES_PARSER_TEST_BASE_H_
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/time/time.h"
+
+namespace media {
+class AudioDecoderConfig;
+class StreamParserBuffer;
+class VideoDecoderConfig;
+
+namespace mp2t {
+class EsParser;
+
+class EsParserTestBase {
+ public:
+  struct Packet {
+    Packet();
+
+    // Offset in the stream.
+    size_t offset;
+
+    // Size of the packet.
+    size_t size;
+
+    // Timestamp of the packet.
+    base::TimeDelta pts;
+  };
+
+  EsParserTestBase();
+  virtual ~EsParserTestBase();
+
+ protected:
+  void LoadStream(const char* filename);
+
+  // ES parser callbacks.
+  void NewAudioConfig(const AudioDecoderConfig& config);
+  void NewVideoConfig(const VideoDecoderConfig& config);
+  void EmitBuffer(scoped_refptr<StreamParserBuffer> buffer);
+
+  // Process the PES packets using the given ES parser.
+  // When |force_timing| is true, even the invalid negative timestamps will be
+  // given to the ES parser.
+  // Return true if successful, false otherwise.
+  bool ProcessPesPackets(EsParser* es_parser,
+                         const std::vector<Packet>& pes_packets,
+                         bool force_timing);
+
+  // Assume the offsets are known, compute the size of each packet.
+  // The last packet is assumed to cover the end of the stream.
+  // Packets are assumed to be in stream order.
+  void ComputePacketSize(std::vector<Packet>* packets);
+
+  // ES stream.
+  std::vector<uint8> stream_;
+
+  // Number of decoder configs received from the ES parser.
+  size_t config_count_;
+
+  // Number of buffers generated while parsing the ES stream.
+  size_t buffer_count_;
+
+  // Timestamps of buffers generated while parsing the ES stream.
+  std::string buffer_timestamps_;
+
+ private:
+  // Timestamps of buffers generated while parsing the ES stream.
+  std::stringstream buffer_timestamps_stream_;
+
+  DISALLOW_COPY_AND_ASSIGN(EsParserTestBase);
+};
+
+}  // namespace mp2t
+}  // namespace media
+
+#endif  // MEDIA_FORMATS_MP2T_ES_PARSER_TEST_BASE_H_

media/media.gyp

@@ -1253,7 +1253,10 @@
             'formats/common/stream_parser_test_base.cc',
             'formats/common/stream_parser_test_base.h',
             'formats/mp2t/es_adapter_video_unittest.cc',
+            'formats/mp2t/es_parser_adts_unittest.cc',
             'formats/mp2t/es_parser_h264_unittest.cc',
+            'formats/mp2t/es_parser_test_base.cc',
+            'formats/mp2t/es_parser_test_base.h',
             'formats/mp2t/mp2t_stream_parser_unittest.cc',
             'formats/mp4/aac_unittest.cc',
             'formats/mp4/avc_unittest.cc',