Mpeg2 TS stream parser for media source.

media/mp2t/mp2t_stream_parser_unittest.cc

Index: media/mp2t/mp2t_stream_parser_unittest.cc
diff --git a/media/mp2t/mp2t_stream_parser_unittest.cc b/media/mp2t/mp2t_stream_parser_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a50f43d1f469af78979c2777da2bc3524c753a15
--- /dev/null
+++ b/media/mp2t/mp2t_stream_parser_unittest.cc
@@ -0,0 +1,189 @@
+// Copyright (c) 2013 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 <string>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/time/time.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/decoder_buffer.h"
+#include "media/base/stream_parser_buffer.h"
+#include "media/base/test_data_util.h"
+#include "media/base/video_decoder_config.h"
+#include "media/mp2t/mp2t_stream_parser.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+namespace mp2t {
+
+class Mp2tStreamParserTest : public testing::Test {
+ public:
+  Mp2tStreamParserTest()
+      : audio_frame_count_(0),
+        video_frame_count_(0),
+        video_min_dts_(kNoTimestamp()),
+        video_max_dts_(kNoTimestamp()) {
+    parser_.reset(new Mp2tStreamParser());
+  }
+
+ protected:
+  scoped_ptr<Mp2tStreamParser> parser_;
+  int audio_frame_count_;
+  int video_frame_count_;
+  base::TimeDelta video_min_dts_;
+  base::TimeDelta video_max_dts_;
+
+  bool AppendData(const uint8* data, size_t length) {
+    return parser_->Parse(data, length);
+  }
+
+  bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
+    const uint8* start = data;
+    const uint8* end = data + length;
+    while (start < end) {
+      size_t append_size = std::min(piece_size,
+                                    static_cast<size_t>(end - start));
+      if (!AppendData(start, append_size))
+        return false;
+      start += append_size;
+    }
+    return true;
+  }
+
+  void OnInit(bool init_ok, base::TimeDelta duration) {
+    DVLOG(1) << "OnInit: ok=" << init_ok
+             << ", dur=" << duration.InMilliseconds();
+  }
+
+  bool OnNewConfig(const AudioDecoderConfig& ac, const VideoDecoderConfig& vc) {
+    DVLOG(1) << "OnNewConfig: audio=" << ac.IsValidConfig()
+             << ", video=" << vc.IsValidConfig();
+    return true;
+  }
+
+
+  void DumpBuffers(const std::string& label,
+                   const StreamParser::BufferQueue& buffers) {
+    DVLOG(2) << "DumpBuffers: " << label << " size " << buffers.size();
+    for (StreamParser::BufferQueue::const_iterator buf = buffers.begin();
+         buf != buffers.end(); buf++) {
+      DVLOG(3) << "  n=" << buf - buffers.begin()
+               << ", size=" << (*buf)->data_size()
+               << ", dur=" << (*buf)->duration().InMilliseconds();
+    }
+  }
+
+  bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
+                    const StreamParser::BufferQueue& video_buffers) {
+    DumpBuffers("audio_buffers", audio_buffers);
+    DumpBuffers("video_buffers", video_buffers);
+    audio_frame_count_ += audio_buffers.size();
+    video_frame_count_ += video_buffers.size();
+
+    if (video_min_dts_ == kNoTimestamp() && !video_buffers.empty())
+      video_min_dts_ = video_buffers.front()->GetDecodeTimestamp();
+    if (!video_buffers.empty()) {
+      video_max_dts_ = video_buffers.back()->GetDecodeTimestamp();
+      // Verify monotonicity.
+      StreamParser::BufferQueue::const_iterator it1 = video_buffers.begin();
+      StreamParser::BufferQueue::const_iterator it2 = ++it1;
+      for ( ; it2 != video_buffers.end(); ++it1, ++it2) {
+        if ((*it2)->GetDecodeTimestamp() < (*it1)->GetDecodeTimestamp())
+          return false;
+      }
+    }
+
+    return true;
+  }
+
+  bool OnNewTextBuffers(TextTrack* text_track,
+                        const StreamParser::BufferQueue& buffers) {
+    return true;
+  }
+
+  void OnKeyNeeded(const std::string& type,
+                   const std::vector<uint8>& init_data) {
+    DVLOG(1) << "OnKeyNeeded: " << init_data.size();
+  }
+
+  scoped_ptr<TextTrack> OnAddTextTrack(
+      TextKind kind,
+      const std::string& label,
+      const std::string& language) {
+    return scoped_ptr<TextTrack>();
+  }
+
+  void OnNewSegment() {
+    DVLOG(1) << "OnNewSegment";
+  }
+
+  void OnEndOfSegment() {
+    DVLOG(1) << "OnEndOfSegment()";
+  }
+
+  void InitializeParser() {
+    parser_->Init(
+        base::Bind(&Mp2tStreamParserTest::OnInit,
+                   base::Unretained(this)),
+        base::Bind(&Mp2tStreamParserTest::OnNewConfig,
+                   base::Unretained(this)),
+        base::Bind(&Mp2tStreamParserTest::OnNewBuffers,
+                   base::Unretained(this)),
+        base::Bind(&Mp2tStreamParserTest::OnNewTextBuffers,
+                   base::Unretained(this)),
+        base::Bind(&Mp2tStreamParserTest::OnKeyNeeded,
+                   base::Unretained(this)),
+        base::Bind(&Mp2tStreamParserTest::OnAddTextTrack,
+                   base::Unretained(this)),
+        base::Bind(&Mp2tStreamParserTest::OnNewSegment,
+                   base::Unretained(this)),
+        base::Bind(&Mp2tStreamParserTest::OnEndOfSegment,
+                   base::Unretained(this)),
+        LogCB());
+  }
+
+  bool ParseMpeg2TsFile(const std::string& filename, int append_bytes) {
+    InitializeParser();
+
+    scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
+    EXPECT_TRUE(AppendDataInPieces(buffer->data(),
+                                   buffer->data_size(),
+                                   append_bytes));
+    return true;
+  }
+};
+
+TEST_F(Mp2tStreamParserTest, UnalignedAppend17) {
+  // Test small, non-segment-aligned appends.
+  ParseMpeg2TsFile("bear-1280x720.ts", 17);
+  EXPECT_EQ(video_frame_count_, 81);
+  parser_->Flush();
+  EXPECT_EQ(video_frame_count_, 82);
+}
+
+TEST_F(Mp2tStreamParserTest, UnalignedAppend512) {
+  // Test small, non-segment-aligned appends.
+  ParseMpeg2TsFile("bear-1280x720.ts", 512);
+  EXPECT_EQ(video_frame_count_, 81);
+  parser_->Flush();
+  EXPECT_EQ(video_frame_count_, 82);
+}
+
+TEST_F(Mp2tStreamParserTest, TimestampWrapAround) {
+  // "bear-1280x720_ptswraparound.ts" has been transcoded
+  // from bear-1280x720.mp4 by applying a time offset of 95442s
+  // (close to 2^33 / 90000) which results in timestamps wrap around
+  // in the Mpeg2 TS stream.
+  ParseMpeg2TsFile("bear-1280x720_ptswraparound.ts", 512);
+  EXPECT_EQ(video_frame_count_, 81);
+  EXPECT_GE(video_min_dts_, base::TimeDelta::FromSeconds(95443 - 10));
+  EXPECT_LE(video_max_dts_, base::TimeDelta::FromSeconds(95443 + 10));
+}
+
+}  // namespace mp2t
+}  // namespace media