blob: 2e2b12e1246435071e72c6bf8b872a823cefa2d7 [file] [log] [blame]
// 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 "base/bind.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/mp3/mp3_stream_parser.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace media {
class MP3StreamParserTest : public testing::Test {
public:
MP3StreamParserTest() {}
protected:
MP3StreamParser parser_;
std::stringstream results_stream_;
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 OnInitDone(bool success, base::TimeDelta duration) {
DVLOG(1) << __FUNCTION__ << "(" << success << ", "
<< duration.InMilliseconds() << ")";
}
bool OnNewConfig(const AudioDecoderConfig& audio_config,
const VideoDecoderConfig& video_config) {
DVLOG(1) << __FUNCTION__ << "(" << audio_config.IsValidConfig() << ", "
<< video_config.IsValidConfig() << ")";
EXPECT_TRUE(audio_config.IsValidConfig());
EXPECT_FALSE(video_config.IsValidConfig());
return true;
}
std::string BufferQueueToString(const StreamParser::BufferQueue& buffers) {
std::stringstream ss;
ss << "{";
for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
itr != buffers.end();
++itr) {
ss << " " << (*itr)->timestamp().InMilliseconds();
if ((*itr)->IsKeyframe())
ss << "K";
}
ss << " }";
return ss.str();
}
bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
const StreamParser::BufferQueue& video_buffers) {
EXPECT_FALSE(audio_buffers.empty());
EXPECT_TRUE(video_buffers.empty());
std::string buffers_str = BufferQueueToString(audio_buffers);
DVLOG(1) << __FUNCTION__ << " : " << buffers_str;
results_stream_ << buffers_str;
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) << __FUNCTION__ << "(" << type << ", " << 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) << __FUNCTION__;
results_stream_ << "NewSegment";
}
void OnEndOfSegment() {
DVLOG(1) << __FUNCTION__;
results_stream_ << "EndOfSegment";
}
void InitializeParser() {
parser_.Init(
base::Bind(&MP3StreamParserTest::OnInitDone, base::Unretained(this)),
base::Bind(&MP3StreamParserTest::OnNewConfig, base::Unretained(this)),
base::Bind(&MP3StreamParserTest::OnNewBuffers, base::Unretained(this)),
base::Bind(&MP3StreamParserTest::OnNewTextBuffers,
base::Unretained(this)),
base::Bind(&MP3StreamParserTest::OnKeyNeeded, base::Unretained(this)),
base::Bind(&MP3StreamParserTest::OnAddTextTrack,
base::Unretained(this)),
base::Bind(&MP3StreamParserTest::OnNewSegment, base::Unretained(this)),
base::Bind(&MP3StreamParserTest::OnEndOfSegment,
base::Unretained(this)),
LogCB());
}
std::string ParseFile(const std::string& filename, int append_bytes) {
results_stream_.clear();
InitializeParser();
scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
EXPECT_TRUE(
AppendDataInPieces(buffer->data(), buffer->data_size(), append_bytes));
return results_stream_.str();
}
};
// Test parsing with small prime sized chunks to smoke out "power of
// 2" field size assumptions.
TEST_F(MP3StreamParserTest, UnalignedAppend) {
std::string expected =
"NewSegment"
"{ 0K }"
"{ 26K }"
"{ 52K }"
"{ 78K }"
"{ 104K }"
"{ 130K }"
"{ 156K }"
"{ 182K }"
"EndOfSegment"
"NewSegment"
"{ 208K }"
"{ 235K }"
"{ 261K }"
"EndOfSegment"
"NewSegment"
"{ 287K }"
"{ 313K }"
"EndOfSegment";
EXPECT_EQ(expected, ParseFile("sfx.mp3", 17));
}
// Test parsing with a larger piece size to verify that multiple buffers
// are passed to |new_buffer_cb_|.
TEST_F(MP3StreamParserTest, UnalignedAppend512) {
std::string expected =
"NewSegment"
"{ 0K }"
"{ 26K 52K 78K 104K }"
"EndOfSegment"
"NewSegment"
"{ 130K 156K 182K }"
"{ 208K 235K 261K 287K }"
"{ 313K }"
"EndOfSegment";
EXPECT_EQ(expected, ParseFile("sfx.mp3", 512));
}
} // namespace media