Mpeg2 TS stream parser for media source.

media/mpeg2/mpeg2ts_stream_parser_unittest.cc

+// 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/mpeg2/mpeg2ts_stream_parser.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+namespace mpeg2ts {
+
+class Mpeg2TsStreamParserTest : public testing::Test {
+ public:
+  Mpeg2TsStreamParserTest()
+      : configs_received_(false),
+        audio_frame_count_(0),
+        video_frame_count_(0),
+        video_min_dts_(kNoTimestamp()),
+        video_max_dts_(kNoTimestamp()) {
+    parser_.reset(new Mpeg2TsStreamParser());
+  }
+
+ protected:
+  scoped_ptr<Mpeg2TsStreamParser> parser_;
+  bool configs_received_;
+  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 InitF(bool init_ok, base::TimeDelta duration) {
+    DVLOG(1) << "InitF: ok=" << init_ok
+             << ", dur=" << duration.InMilliseconds();
+  }
+
+  bool NewConfigF(const AudioDecoderConfig& ac, const VideoDecoderConfig& vc) {
+    DVLOG(1) << "NewConfigF: audio=" << ac.IsValidConfig()
+             << ", video=" << vc.IsValidConfig();
+    configs_received_ = true;
+    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 NewBuffersF(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();
+    for (StreamParser::BufferQueue::const_iterator it = video_buffers.begin();
+         it != video_buffers.end(); ++it) {
+      base::TimeDelta dts = (*it)->GetDecodeTimestamp();
+      if (video_min_dts_ == kNoTimestamp() ||
+          dts < video_min_dts_)
+        video_min_dts_ = dts;
+      if (video_max_dts_ == kNoTimestamp() ||
+          dts > video_max_dts_)
+        video_max_dts_ = dts;
+    }
+    return true;
+  }
+
+  bool NewTextBuffersF(TextTrack* text_track,
+                       const StreamParser::BufferQueue& buffers) {
+    return true;
+  }
+
+  void KeyNeededF(const std::string& type,
+                  scoped_ptr<uint8[]> init_data, int init_data_size) {
+    DVLOG(1) << "KeyNeededF: " << init_data_size;
+  }
+
+  scoped_ptr<TextTrack> AddTextTrackF(
+      TextKind kind,
+      const std::string& label,
+      const std::string& language) {
+    return scoped_ptr<TextTrack>();
+  }
+
+  void NewSegmentF() {
+    DVLOG(1) << "NewSegmentF";
+  }
+
+  void EndOfSegmentF() {
+    DVLOG(1) << "EndOfSegmentF()";
+  }
+
+  void InitializeParser() {
+    parser_->Init(
+        base::Bind(&Mpeg2TsStreamParserTest::InitF,
+                   base::Unretained(this)),
+        base::Bind(&Mpeg2TsStreamParserTest::NewConfigF,
+                   base::Unretained(this)),
+        base::Bind(&Mpeg2TsStreamParserTest::NewBuffersF,
+                   base::Unretained(this)),
+        base::Bind(&Mpeg2TsStreamParserTest::NewTextBuffersF,
+                   base::Unretained(this)),
+        base::Bind(&Mpeg2TsStreamParserTest::KeyNeededF,
+                   base::Unretained(this)),
+        base::Bind(&Mpeg2TsStreamParserTest::AddTextTrackF,
+                   base::Unretained(this)),
+        base::Bind(&Mpeg2TsStreamParserTest::NewSegmentF,
+                   base::Unretained(this)),
+        base::Bind(&Mpeg2TsStreamParserTest::EndOfSegmentF,
+                   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(Mpeg2TsStreamParserTest, UnalignedAppend) {
+  // 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(Mpeg2TsStreamParserTest, 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 mpeg2ts
+}  // namespace media