1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <algorithm>
6 #include <string>
7
8 #include "base/bind.h"
9 #include "base/bind_helpers.h"
10 #include "base/logging.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/time/time.h"
13 #include "media/base/audio_decoder_config.h"
14 #include "media/base/decoder_buffer.h"
15 #include "media/base/stream_parser_buffer.h"
16 #include "media/base/test_data_util.h"
17 #include "media/base/text_track_config.h"
18 #include "media/base/video_decoder_config.h"
19 #include "media/mp2t/mp2t_stream_parser.h"
20 #include "testing/gtest/include/gtest/gtest.h"
21
22 namespace media {
23 namespace mp2t {
24
25 class Mp2tStreamParserTest : public testing::Test {
26 public:
Mp2tStreamParserTest()27 Mp2tStreamParserTest()
28 : audio_frame_count_(0),
29 video_frame_count_(0),
30 video_min_dts_(kNoTimestamp()),
31 video_max_dts_(kNoTimestamp()) {
32 bool has_sbr = false;
33 parser_.reset(new Mp2tStreamParser(has_sbr));
34 }
35
36 protected:
37 scoped_ptr<Mp2tStreamParser> parser_;
38 int audio_frame_count_;
39 int video_frame_count_;
40 base::TimeDelta video_min_dts_;
41 base::TimeDelta video_max_dts_;
42
AppendData(const uint8 * data,size_t length)43 bool AppendData(const uint8* data, size_t length) {
44 return parser_->Parse(data, length);
45 }
46
AppendDataInPieces(const uint8 * data,size_t length,size_t piece_size)47 bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
48 const uint8* start = data;
49 const uint8* end = data + length;
50 while (start < end) {
51 size_t append_size = std::min(piece_size,
52 static_cast<size_t>(end - start));
53 if (!AppendData(start, append_size))
54 return false;
55 start += append_size;
56 }
57 return true;
58 }
59
OnInit(bool init_ok,base::TimeDelta duration)60 void OnInit(bool init_ok, base::TimeDelta duration) {
61 DVLOG(1) << "OnInit: ok=" << init_ok
62 << ", dur=" << duration.InMilliseconds();
63 }
64
OnNewConfig(const AudioDecoderConfig & ac,const VideoDecoderConfig & vc,const StreamParser::TextTrackConfigMap & tc)65 bool OnNewConfig(const AudioDecoderConfig& ac,
66 const VideoDecoderConfig& vc,
67 const StreamParser::TextTrackConfigMap& tc) {
68 DVLOG(1) << "OnNewConfig: audio=" << ac.IsValidConfig()
69 << ", video=" << vc.IsValidConfig();
70 return true;
71 }
72
73
DumpBuffers(const std::string & label,const StreamParser::BufferQueue & buffers)74 void DumpBuffers(const std::string& label,
75 const StreamParser::BufferQueue& buffers) {
76 DVLOG(2) << "DumpBuffers: " << label << " size " << buffers.size();
77 for (StreamParser::BufferQueue::const_iterator buf = buffers.begin();
78 buf != buffers.end(); buf++) {
79 DVLOG(3) << " n=" << buf - buffers.begin()
80 << ", size=" << (*buf)->data_size()
81 << ", dur=" << (*buf)->duration().InMilliseconds();
82 }
83 }
84
OnNewBuffers(const StreamParser::BufferQueue & audio_buffers,const StreamParser::BufferQueue & video_buffers)85 bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
86 const StreamParser::BufferQueue& video_buffers) {
87 DumpBuffers("audio_buffers", audio_buffers);
88 DumpBuffers("video_buffers", video_buffers);
89 audio_frame_count_ += audio_buffers.size();
90 video_frame_count_ += video_buffers.size();
91
92 if (video_min_dts_ == kNoTimestamp() && !video_buffers.empty())
93 video_min_dts_ = video_buffers.front()->GetDecodeTimestamp();
94 if (!video_buffers.empty()) {
95 video_max_dts_ = video_buffers.back()->GetDecodeTimestamp();
96 // Verify monotonicity.
97 StreamParser::BufferQueue::const_iterator it1 = video_buffers.begin();
98 StreamParser::BufferQueue::const_iterator it2 = ++it1;
99 for ( ; it2 != video_buffers.end(); ++it1, ++it2) {
100 if ((*it2)->GetDecodeTimestamp() < (*it1)->GetDecodeTimestamp())
101 return false;
102 }
103 }
104
105 return true;
106 }
107
OnKeyNeeded(const std::string & type,const std::vector<uint8> & init_data)108 void OnKeyNeeded(const std::string& type,
109 const std::vector<uint8>& init_data) {
110 DVLOG(1) << "OnKeyNeeded: " << init_data.size();
111 }
112
OnNewSegment()113 void OnNewSegment() {
114 DVLOG(1) << "OnNewSegment";
115 }
116
OnEndOfSegment()117 void OnEndOfSegment() {
118 DVLOG(1) << "OnEndOfSegment()";
119 }
120
InitializeParser()121 void InitializeParser() {
122 parser_->Init(
123 base::Bind(&Mp2tStreamParserTest::OnInit,
124 base::Unretained(this)),
125 base::Bind(&Mp2tStreamParserTest::OnNewConfig,
126 base::Unretained(this)),
127 base::Bind(&Mp2tStreamParserTest::OnNewBuffers,
128 base::Unretained(this)),
129 StreamParser::NewTextBuffersCB(),
130 base::Bind(&Mp2tStreamParserTest::OnKeyNeeded,
131 base::Unretained(this)),
132 base::Bind(&Mp2tStreamParserTest::OnNewSegment,
133 base::Unretained(this)),
134 base::Bind(&Mp2tStreamParserTest::OnEndOfSegment,
135 base::Unretained(this)),
136 LogCB());
137 }
138
ParseMpeg2TsFile(const std::string & filename,int append_bytes)139 bool ParseMpeg2TsFile(const std::string& filename, int append_bytes) {
140 InitializeParser();
141
142 scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
143 EXPECT_TRUE(AppendDataInPieces(buffer->data(),
144 buffer->data_size(),
145 append_bytes));
146 return true;
147 }
148 };
149
TEST_F(Mp2tStreamParserTest,UnalignedAppend17)150 TEST_F(Mp2tStreamParserTest, UnalignedAppend17) {
151 // Test small, non-segment-aligned appends.
152 ParseMpeg2TsFile("bear-1280x720.ts", 17);
153 EXPECT_EQ(video_frame_count_, 81);
154 parser_->Flush();
155 EXPECT_EQ(video_frame_count_, 82);
156 }
157
TEST_F(Mp2tStreamParserTest,UnalignedAppend512)158 TEST_F(Mp2tStreamParserTest, UnalignedAppend512) {
159 // Test small, non-segment-aligned appends.
160 ParseMpeg2TsFile("bear-1280x720.ts", 512);
161 EXPECT_EQ(video_frame_count_, 81);
162 parser_->Flush();
163 EXPECT_EQ(video_frame_count_, 82);
164 }
165
TEST_F(Mp2tStreamParserTest,TimestampWrapAround)166 TEST_F(Mp2tStreamParserTest, TimestampWrapAround) {
167 // "bear-1280x720_ptswraparound.ts" has been transcoded
168 // from bear-1280x720.mp4 by applying a time offset of 95442s
169 // (close to 2^33 / 90000) which results in timestamps wrap around
170 // in the Mpeg2 TS stream.
171 ParseMpeg2TsFile("bear-1280x720_ptswraparound.ts", 512);
172 EXPECT_EQ(video_frame_count_, 81);
173 EXPECT_GE(video_min_dts_, base::TimeDelta::FromSeconds(95443 - 10));
174 EXPECT_LE(video_max_dts_, base::TimeDelta::FromSeconds(95443 + 10));
175 }
176
177 } // namespace mp2t
178 } // namespace media
179