| // Copyright 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/text_track_config.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()) { |
| bool has_sbr = false; |
| parser_.reset(new Mp2tStreamParser(has_sbr)); |
| } |
| |
| 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, |
| const StreamParser::TextTrackConfigMap& tc) { |
| 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; |
| } |
| |
| void OnKeyNeeded(const std::string& type, |
| const std::vector<uint8>& init_data) { |
| DVLOG(1) << "OnKeyNeeded: " << init_data.size(); |
| } |
| |
| 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)), |
| StreamParser::NewTextBuffersCB(), |
| base::Bind(&Mp2tStreamParserTest::OnKeyNeeded, |
| 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 |