// Copyright 2017 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.
//#define LOG_NDEBUG 0
#define LOG_TAG "C2VDAComponent_test"
#include <C2VDAComponent.h>
#include <C2Buffer.h>
#include <C2BufferPriv.h>
#include <C2Component.h>
#include <C2PlatformSupport.h>
#include <C2Work.h>
#include <SimpleC2Interface.h>
#include <base/files/file.h>
#include <base/files/file_path.h>
#include <base/md5.h>
#include <base/strings/string_piece.h>
#include <base/strings/string_split.h>
#include <gtest/gtest.h>
#include <media/DataSource.h>
#include <media/IMediaHTTPService.h>
#include <media/MediaExtractor.h>
#include <media/MediaSource.h>
#include <media/stagefright/DataSourceFactory.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MediaExtractorFactory.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ALooper.h>
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/foundation/AUtils.h>
#include <utils/Log.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <algorithm>
#include <chrono>
#include <thread>
using namespace std::chrono_literals;
namespace {
const int kMD5StringLength = 32;
// Read in golden MD5s for the sanity play-through check of this video
void readGoldenMD5s(const std::string& videoFile, std::vector<std::string>* md5Strings) {
base::FilePath filepath(videoFile + ".md5");
std::string allMD5s;
base::ReadFileToString(filepath, &allMD5s);
*md5Strings = base::SplitString(allMD5s, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
// Check these are legitimate MD5s.
for (const std::string& md5String : *md5Strings) {
// Ignore the empty string added by SplitString. Ignore comments.
if (!md5String.length() || md5String.at(0) == '#') {
continue;
}
if (static_cast<int>(md5String.length()) != kMD5StringLength) {
fprintf(stderr, "MD5 length error: %s\n", md5String.c_str());
}
if (std::count_if(md5String.begin(), md5String.end(), isxdigit) != kMD5StringLength) {
fprintf(stderr, "MD5 includes non-hex char: %s\n", md5String.c_str());
}
}
if (md5Strings->empty()) {
fprintf(stderr, "MD5 checksum file (%s) missing or empty.\n",
filepath.MaybeAsASCII().c_str());
}
}
// Get file path name of recording raw YUV
base::FilePath getRecordOutputPath(const std::string& videoFile, int width, int height) {
base::FilePath filepath(videoFile);
filepath = filepath.RemoveExtension();
std::string suffix = "_output_" + std::to_string(width) + "x" + std::to_string(height) + ".yuv";
return base::FilePath(filepath.value() + suffix);
}
} // namespace
namespace android {
// Input video data parameters. This could be overwritten by user argument [-i].
// The syntax of each column is:
// filename:componentName:width:height:numFrames:numFragments
// - |filename| is the file path to mp4 (h264) or webm (VP8/9) video.
// - |componentName| specifies the name of decoder component.
// - |width| and |height| are for video size (in pixels).
// - |numFrames| is the number of picture frames.
// - |numFragments| is the NALU (h264) or frame (VP8/9) count by MediaExtractor.
const char* gTestVideoData = "bear.mp4:c2.vda.avc.decoder:640:360:82:84";
//const char* gTestVideoData = "bear-vp8.webm:c2.vda.vp8.decoder:640:360:82:82";
//const char* gTestVideoData = "bear-vp9.webm:c2.vda.vp9.decoder:320:240:82:82";
// Record decoded output frames as raw YUV format.
// The recorded file will be named as "<video_name>_output_<width>x<height>.yuv" under the same
// folder of input video file.
bool gRecordOutputYUV = false;
const std::string kH264DecoderName = "c2.vda.avc.decoder";
const std::string kVP8DecoderName = "c2.vda.vp8.decoder";
const std::string kVP9DecoderName = "c2.vda.vp9.decoder";
// Magic constants for indicating the timing of flush being called.
enum FlushPoint : int { END_OF_STREAM_FLUSH = -3, MID_STREAM_FLUSH = -2, NO_FLUSH = -1 };
struct TestVideoFile {
enum class CodecType { UNKNOWN, H264, VP8, VP9 };
std::string mFilename;
std::string mComponentName;
CodecType mCodec = CodecType::UNKNOWN;
int mWidth = -1;
int mHeight = -1;
int mNumFrames = -1;
int mNumFragments = -1;
sp<IMediaSource> mData;
};
class C2VDALinearBuffer : public C2Buffer {
public:
explicit C2VDALinearBuffer(const std::shared_ptr<C2LinearBlock>& block)
: C2Buffer({block->share(block->offset(), block->size(), C2Fence())}) {}
};
class C2VDADummyLinearBuffer : public C2Buffer {
public:
explicit C2VDADummyLinearBuffer(const std::shared_ptr<C2LinearBlock>& block)
: C2Buffer({block->share(0, 0, C2Fence())}) {}
};
class Listener;
class C2VDAComponentTest : public ::testing::Test {
public:
void onWorkDone(std::weak_ptr<C2Component> component,
std::list<std::unique_ptr<C2Work>> workItems);
void onTripped(std::weak_ptr<C2Component> component,
std::vector<std::shared_ptr<C2SettingResult>> settingResult);
void onError(std::weak_ptr<C2Component> component, uint32_t errorCode);
protected:
C2VDAComponentTest();
void SetUp() override;
void parseTestVideoData(const char* testVideoData);
protected:
using ULock = std::unique_lock<std::mutex>;
enum {
kWorkCount = 16,
};
std::shared_ptr<Listener> mListener;
// Allocators
std::shared_ptr<C2Allocator> mLinearAlloc;
std::shared_ptr<C2BlockPool> mLinearBlockPool;
// The array of output video frame counters which will be counted in listenerThread. The array
// length equals to iteration time of stream play.
std::vector<int> mOutputFrameCounts;
// The array of work counters returned from component which will be counted in listenerThread.
// The array length equals to iteration time of stream play.
std::vector<int> mFinishedWorkCounts;
// The array of output frame MD5Sum which will be computed in listenerThread. The array length
// equals to iteration time of stream play.
std::vector<std::string> mMD5Strings;
// Mutex for |mWorkQueue| among main and listenerThread.
std::mutex mQueueLock;
std::condition_variable mQueueCondition;
std::list<std::unique_ptr<C2Work>> mWorkQueue;
// Mutex for |mProcessedWork| among main and listenerThread.
std::mutex mProcessedLock;
std::condition_variable mProcessedCondition;
std::list<std::unique_ptr<C2Work>> mProcessedWork;
// Mutex for |mFlushDone| among main and listenerThread.
std::mutex mFlushDoneLock;
std::condition_variable mFlushDoneCondition;
bool mFlushDone;
std::unique_ptr<TestVideoFile> mTestVideoFile;
};
class Listener : public C2Component::Listener {
public:
explicit Listener(C2VDAComponentTest* thiz) : mThis(thiz) {}
virtual ~Listener() = default;
virtual void onWorkDone_nb(std::weak_ptr<C2Component> component,
std::list<std::unique_ptr<C2Work>> workItems) override {
mThis->onWorkDone(component, std::move(workItems));
}
virtual void onTripped_nb(
std::weak_ptr<C2Component> component,
std::vector<std::shared_ptr<C2SettingResult>> settingResult) override {
mThis->onTripped(component, settingResult);
}
virtual void onError_nb(std::weak_ptr<C2Component> component, uint32_t errorCode) override {
mThis->onError(component, errorCode);
}
private:
C2VDAComponentTest* const mThis;
};
C2VDAComponentTest::C2VDAComponentTest() : mListener(new Listener(this)) {
std::shared_ptr<C2AllocatorStore> store = GetCodec2PlatformAllocatorStore();
CHECK_EQ(store->fetchAllocator(C2AllocatorStore::DEFAULT_LINEAR, &mLinearAlloc), C2_OK);
mLinearBlockPool = std::make_shared<C2BasicLinearBlockPool>(mLinearAlloc);
}
void C2VDAComponentTest::onWorkDone(std::weak_ptr<C2Component> component,
std::list<std::unique_ptr<C2Work>> workItems) {
(void)component;
ULock l(mProcessedLock);
for (auto& item : workItems) {
mProcessedWork.emplace_back(std::move(item));
}
mProcessedCondition.notify_all();
}
void C2VDAComponentTest::onTripped(std::weak_ptr<C2Component> component,
std::vector<std::shared_ptr<C2SettingResult>> settingResult) {
(void)component;
(void)settingResult;
// no-ops
}
void C2VDAComponentTest::onError(std::weak_ptr<C2Component> component, uint32_t errorCode) {
(void)component;
// fail the test
FAIL() << "Get error code from component: " << errorCode;
}
void C2VDAComponentTest::SetUp() {
parseTestVideoData(gTestVideoData);
mWorkQueue.clear();
for (int i = 0; i < kWorkCount; ++i) {
mWorkQueue.emplace_back(new C2Work);
}
mProcessedWork.clear();
mFlushDone = false;
}
static bool getMediaSourceFromFile(const std::string& filename,
const TestVideoFile::CodecType codec, sp<IMediaSource>* source) {
source->clear();
sp<DataSource> dataSource =
DataSourceFactory::CreateFromURI(nullptr /* httpService */, filename.c_str());
if (dataSource == nullptr) {
fprintf(stderr, "Unable to create data source.\n");
return false;
}
sp<IMediaExtractor> extractor = MediaExtractorFactory::Create(dataSource);
if (extractor == nullptr) {
fprintf(stderr, "could not create extractor.\n");
return false;
}
std::string expectedMime;
if (codec == TestVideoFile::CodecType::H264) {
expectedMime = "video/avc";
} else if (codec == TestVideoFile::CodecType::VP8) {
expectedMime = "video/x-vnd.on2.vp8";
} else if (codec == TestVideoFile::CodecType::VP9) {
expectedMime = "video/x-vnd.on2.vp9";
} else {
fprintf(stderr, "unsupported codec type.\n");
return false;
}
for (size_t i = 0, numTracks = extractor->countTracks(); i < numTracks; ++i) {
sp<MetaData> meta =
extractor->getTrackMetaData(i, MediaExtractor::kIncludeExtensiveMetaData);
if (meta == nullptr) {
continue;
}
const char* mime;
meta->findCString(kKeyMIMEType, &mime);
if (!strcasecmp(mime, expectedMime.c_str())) {
*source = extractor->getTrack(i);
if (*source == nullptr) {
fprintf(stderr, "It's NULL track for track %zu.\n", i);
return false;
}
return true;
}
}
fprintf(stderr, "No track found.\n");
return false;
}
void C2VDAComponentTest::parseTestVideoData(const char* testVideoData) {
ALOGV("videoDataStr: %s", testVideoData);
mTestVideoFile = std::make_unique<TestVideoFile>();
auto splitString = [](const std::string& input, const char delim) {
std::vector<std::string> splits;
auto beg = input.begin();
while (beg != input.end()) {
auto pos = std::find(beg, input.end(), delim);
splits.emplace_back(beg, pos);
beg = pos != input.end() ? pos + 1 : pos;
}
return splits;
};
auto tokens = splitString(testVideoData, ':');
ASSERT_EQ(tokens.size(), 6u);
mTestVideoFile->mFilename = tokens[0];
ASSERT_GT(mTestVideoFile->mFilename.length(), 0u);
mTestVideoFile->mComponentName = tokens[1];
if (mTestVideoFile->mComponentName == kH264DecoderName) {
mTestVideoFile->mCodec = TestVideoFile::CodecType::H264;
} else if (mTestVideoFile->mComponentName == kVP8DecoderName) {
mTestVideoFile->mCodec = TestVideoFile::CodecType::VP8;
} else if (mTestVideoFile->mComponentName == kVP9DecoderName) {
mTestVideoFile->mCodec = TestVideoFile::CodecType::VP9;
}
ASSERT_NE(mTestVideoFile->mCodec, TestVideoFile::CodecType::UNKNOWN);
mTestVideoFile->mWidth = std::stoi(tokens[2]);
mTestVideoFile->mHeight = std::stoi(tokens[3]);
mTestVideoFile->mNumFrames = std::stoi(tokens[4]);
mTestVideoFile->mNumFragments = std::stoi(tokens[5]);
ALOGV("mTestVideoFile: %s, %s, %d, %d, %d, %d", mTestVideoFile->mFilename.c_str(),
mTestVideoFile->mComponentName.c_str(), mTestVideoFile->mWidth, mTestVideoFile->mHeight,
mTestVideoFile->mNumFrames, mTestVideoFile->mNumFragments);
}
static void getFrameStringPieces(const C2GraphicView& constGraphicView,
std::vector<::base::StringPiece>* framePieces) {
const uint8_t* const* constData = constGraphicView.data();
ASSERT_NE(constData, nullptr);
const C2PlanarLayout& layout = constGraphicView.layout();
ASSERT_EQ(layout.type, C2PlanarLayout::TYPE_YUV) << "Only support YUV plane format";
framePieces->clear();
framePieces->push_back(
::base::StringPiece(reinterpret_cast<const char*>(constData[C2PlanarLayout::PLANE_Y]),
constGraphicView.width() * constGraphicView.height()));
if (layout.planes[C2PlanarLayout::PLANE_U].colInc == 2) { // semi-planar mode
framePieces->push_back(::base::StringPiece(
reinterpret_cast<const char*>(std::min(constData[C2PlanarLayout::PLANE_U],
constData[C2PlanarLayout::PLANE_V])),
constGraphicView.width() * constGraphicView.height() / 2));
} else {
framePieces->push_back(::base::StringPiece(
reinterpret_cast<const char*>(constData[C2PlanarLayout::PLANE_U]),
constGraphicView.width() * constGraphicView.height() / 4));
framePieces->push_back(::base::StringPiece(
reinterpret_cast<const char*>(constData[C2PlanarLayout::PLANE_V]),
constGraphicView.width() * constGraphicView.height() / 4));
}
}
// Test parameters:
// - Flush after work index. If this value is not negative, test will signal flush to component
// after queueing the work frame index equals to this value in the first iteration. Negative
// values may be magic constants, please refer to FlushPoint enum.
// - Number of play through. This value specifies the iteration time for playing entire video. If
// |mFlushAfterWorkIndex| is not negative, the first iteration will perform flush, then repeat
// times as this value for playing entire video.
// - Sanity check. If this is true, decoded content sanity check is enabled. Test will compute the
// MD5Sum for output frame data for a play-though iteration (not flushed), and compare to golden
// MD5Sums which should be stored in the file |video_filename|.md5
// - Use dummy EOS work. If this is true, test will queue a dummy work with end-of-stream flag in
// the end of all input works. On the contrary, test will call drain_nb() to component.
class C2VDAComponentParamTest
: public C2VDAComponentTest,
public ::testing::WithParamInterface<std::tuple<int, uint32_t, bool, bool>> {
protected:
int mFlushAfterWorkIndex;
uint32_t mNumberOfPlaythrough;
bool mSanityCheck;
bool mUseDummyEOSWork;
};
TEST_P(C2VDAComponentParamTest, SimpleDecodeTest) {
mFlushAfterWorkIndex = std::get<0>(GetParam());
if (mFlushAfterWorkIndex == FlushPoint::MID_STREAM_FLUSH) {
mFlushAfterWorkIndex = mTestVideoFile->mNumFragments / 2;
} else if (mFlushAfterWorkIndex == FlushPoint::END_OF_STREAM_FLUSH) {
mFlushAfterWorkIndex = mTestVideoFile->mNumFragments - 1;
}
ASSERT_LT(mFlushAfterWorkIndex, mTestVideoFile->mNumFragments);
mNumberOfPlaythrough = std::get<1>(GetParam());
if (mFlushAfterWorkIndex >= 0) {
mNumberOfPlaythrough++; // add the first iteration for perform mid-stream flushing.
}
mSanityCheck = std::get<2>(GetParam());
mUseDummyEOSWork = std::get<3>(GetParam());
// Reset counters and determine the expected answers for all iterations.
mOutputFrameCounts.resize(mNumberOfPlaythrough, 0);
mFinishedWorkCounts.resize(mNumberOfPlaythrough, 0);
mMD5Strings.resize(mNumberOfPlaythrough);
std::vector<int> expectedOutputFrameCounts(mNumberOfPlaythrough, mTestVideoFile->mNumFrames);
auto expectedWorkCount = mTestVideoFile->mNumFragments;
if (mUseDummyEOSWork) {
expectedWorkCount += 1; // plus one dummy EOS work
}
std::vector<int> expectedFinishedWorkCounts(mNumberOfPlaythrough, expectedWorkCount);
if (mFlushAfterWorkIndex >= 0) {
// First iteration performs the mid-stream flushing.
expectedOutputFrameCounts[0] = mFlushAfterWorkIndex + 1;
expectedFinishedWorkCounts[0] = mFlushAfterWorkIndex + 1;
}
std::shared_ptr<C2Component> component(std::make_shared<C2VDAComponent>(
mTestVideoFile->mComponentName, 0, std::make_shared<C2ReflectorHelper>()));
ASSERT_EQ(component->setListener_vb(mListener, C2_DONT_BLOCK), C2_OK);
ASSERT_EQ(component->start(), C2_OK);
std::atomic_bool running(true);
std::thread listenerThread([this, &running]() {
uint32_t iteration = 0;
::base::MD5Context md5Ctx;
::base::MD5Init(&md5Ctx);
::base::File recordFile;
if (gRecordOutputYUV) {
auto recordFilePath = getRecordOutputPath(
mTestVideoFile->mFilename, mTestVideoFile->mWidth, mTestVideoFile->mHeight);
fprintf(stdout, "record output file: %s\n", recordFilePath.value().c_str());
recordFile = ::base::File(recordFilePath,
::base::File::FLAG_OPEN_ALWAYS | ::base::File::FLAG_WRITE);
ASSERT_TRUE(recordFile.IsValid());
}
while (running) {
std::unique_ptr<C2Work> work;
{
ULock l(mProcessedLock);
if (mProcessedWork.empty()) {
mProcessedCondition.wait_for(l, 100ms);
if (mProcessedWork.empty()) {
continue;
}
}
work = std::move(mProcessedWork.front());
mProcessedWork.pop_front();
}
mFinishedWorkCounts[iteration]++;
ALOGV("Output: frame index: %llu result: %d flags: 0x%x buffers: %zu",
work->input.ordinal.frameIndex.peekull(), work->result,
work->worklets.front()->output.flags,
work->worklets.front()->output.buffers.size());
ASSERT_EQ(work->worklets.size(), 1u);
if (work->worklets.front()->output.buffers.size() == 1u) {
std::shared_ptr<C2Buffer> output = work->worklets.front()->output.buffers[0];
C2ConstGraphicBlock graphicBlock = output->data().graphicBlocks().front();
// check graphic buffer size (coded size) is not less than given video size.
ASSERT_LE(mTestVideoFile->mWidth, static_cast<int>(graphicBlock.width()));
ASSERT_LE(mTestVideoFile->mHeight, static_cast<int>(graphicBlock.height()));
// check visible rect equals to given video size.
ASSERT_EQ(mTestVideoFile->mWidth, static_cast<int>(graphicBlock.crop().width));
ASSERT_EQ(mTestVideoFile->mHeight, static_cast<int>(graphicBlock.crop().height));
ASSERT_EQ(0u, graphicBlock.crop().left);
ASSERT_EQ(0u, graphicBlock.crop().top);
// Intended behavior for Intel libva driver (crbug.com/148546):
// The 5ms latency is laid here to make sure surface content is finished processed
// processed by libva.
std::this_thread::sleep_for(std::chrono::milliseconds(5));
const C2GraphicView& constGraphicView = graphicBlock.map().get();
ASSERT_EQ(C2_OK, constGraphicView.error());
std::vector<::base::StringPiece> framePieces;
getFrameStringPieces(constGraphicView, &framePieces);
ASSERT_FALSE(framePieces.empty());
if (mSanityCheck) {
for (const auto& piece : framePieces) {
::base::MD5Update(&md5Ctx, piece);
}
}
if (gRecordOutputYUV) {
for (const auto& piece : framePieces) {
ASSERT_EQ(static_cast<int>(piece.length()),
recordFile.WriteAtCurrentPos(piece.data(), piece.length()))
<< "Failed to write file for yuv recording...";
}
}
work->worklets.front()->output.buffers.clear();
mOutputFrameCounts[iteration]++;
}
bool iteration_end =
work->worklets.front()->output.flags & C2FrameData::FLAG_END_OF_STREAM;
// input buffer should be reset in component side.
ASSERT_EQ(work->input.buffers.size(), 1u);
ASSERT_TRUE(work->input.buffers.front() == nullptr);
work->worklets.clear();
work->workletsProcessed = 0;
if (iteration == 0 && work->input.ordinal.frameIndex.peeku() ==
static_cast<uint64_t>(mFlushAfterWorkIndex)) {
ULock l(mFlushDoneLock);
mFlushDone = true;
mFlushDoneCondition.notify_all();
iteration_end = true;
}
ULock l(mQueueLock);
mWorkQueue.emplace_back(std::move(work));
mQueueCondition.notify_all();
if (iteration_end) {
// record md5sum
::base::MD5Digest digest;
::base::MD5Final(&digest, &md5Ctx);
mMD5Strings[iteration] = ::base::MD5DigestToBase16(digest);
::base::MD5Init(&md5Ctx);
iteration++;
if (iteration == mNumberOfPlaythrough) {
running.store(false); // stop the thread
}
}
}
});
for (uint32_t iteration = 0; iteration < mNumberOfPlaythrough; ++iteration) {
ASSERT_TRUE(getMediaSourceFromFile(mTestVideoFile->mFilename, mTestVideoFile->mCodec,
&mTestVideoFile->mData));
std::deque<sp<ABuffer>> csds;
if (mTestVideoFile->mCodec == TestVideoFile::CodecType::H264) {
// Get csd buffers for h264.
sp<AMessage> format;
(void)convertMetaDataToMessage(mTestVideoFile->mData->getFormat(), &format);
csds.resize(2);
format->findBuffer("csd-0", &csds[0]);
format->findBuffer("csd-1", &csds[1]);
ASSERT_TRUE(csds[0] != nullptr && csds[1] != nullptr);
}
ASSERT_EQ(mTestVideoFile->mData->start(), OK);
int numWorks = 0;
while (true) {
size_t size = 0u;
void* data = nullptr;
int64_t timestamp = 0u;
MediaBufferBase* buffer = nullptr;
sp<ABuffer> csd;
bool queueDummyEOSWork = false;
if (!csds.empty()) {
csd = std::move(csds.front());
csds.pop_front();
size = csd->size();
data = csd->data();
} else {
if (mTestVideoFile->mData->read(&buffer) != OK) {
ASSERT_TRUE(buffer == nullptr);
if (mUseDummyEOSWork) {
ALOGV("Meet end of stream. Put a dummy EOS work.");
queueDummyEOSWork = true;
} else {
ALOGV("Meet end of stream. Now drain the component.");
ASSERT_EQ(component->drain_nb(C2Component::DRAIN_COMPONENT_WITH_EOS),
C2_OK);
break;
}
// TODO(johnylin): add test with drain with DRAIN_COMPONENT_NO_EOS when we know
// the actual use case of it.
} else {
MetaDataBase& meta = buffer->meta_data();
ASSERT_TRUE(meta.findInt64(kKeyTime, ×tamp));
size = buffer->size();
data = buffer->data();
}
}
std::unique_ptr<C2Work> work;
while (!work) {
ULock l(mQueueLock);
if (!mWorkQueue.empty()) {
work = std::move(mWorkQueue.front());
mWorkQueue.pop_front();
} else {
mQueueCondition.wait_for(l, 100ms);
}
}
work->input.ordinal.frameIndex = static_cast<uint64_t>(numWorks);
work->input.buffers.clear();
std::shared_ptr<C2LinearBlock> block;
if (queueDummyEOSWork) {
work->input.flags = C2FrameData::FLAG_END_OF_STREAM;
work->input.ordinal.timestamp = 0; // timestamp is invalid for dummy EOS work
// Create a dummy input buffer by allocating minimal size of buffer from block pool.
mLinearBlockPool->fetchLinearBlock(
1, {C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE}, &block);
work->input.buffers.emplace_back(new C2VDADummyLinearBuffer(std::move(block)));
ALOGV("Input: (Dummy EOS) id: %llu", work->input.ordinal.frameIndex.peekull());
} else {
work->input.flags = static_cast<C2FrameData::flags_t>(0);
work->input.ordinal.timestamp = static_cast<uint64_t>(timestamp);
// Allocate an input buffer with data size.
mLinearBlockPool->fetchLinearBlock(
size, {C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE}, &block);
C2WriteView view = block->map().get();
ASSERT_EQ(view.error(), C2_OK);
memcpy(view.base(), data, size);
work->input.buffers.emplace_back(new C2VDALinearBuffer(std::move(block)));
ALOGV("Input: bitstream id: %llu timestamp: %llu size: %zu",
work->input.ordinal.frameIndex.peekull(),
work->input.ordinal.timestamp.peekull(), size);
}
work->worklets.clear();
work->worklets.emplace_back(new C2Worklet);
std::list<std::unique_ptr<C2Work>> items;
items.push_back(std::move(work));
// Queue the work.
ASSERT_EQ(component->queue_nb(&items), C2_OK);
numWorks++;
if (buffer) {
buffer->release();
}
if (iteration == 0 && numWorks == mFlushAfterWorkIndex + 1) {
// Perform flush.
// Note: C2VDAComponent does not return work via |flushedWork|.
ASSERT_EQ(component->flush_sm(C2Component::FLUSH_COMPONENT,
nullptr /* flushedWork */),
C2_OK);
break;
}
if (queueDummyEOSWork) {
break;
}
}
if (iteration == 0 && mFlushAfterWorkIndex >= 0) {
// Wait here until client get all flushed works.
while (true) {
ULock l(mFlushDoneLock);
if (mFlushDone) {
break;
}
mFlushDoneCondition.wait_for(l, 100ms);
}
ALOGV("Got flush done signal");
EXPECT_EQ(numWorks, mFlushAfterWorkIndex + 1);
} else {
EXPECT_EQ(numWorks, expectedWorkCount);
}
ASSERT_EQ(mTestVideoFile->mData->stop(), OK);
}
listenerThread.join();
ASSERT_EQ(running, false);
ASSERT_EQ(component->stop(), C2_OK);
// Finally check the decoding want as expected.
for (uint32_t i = 0; i < mNumberOfPlaythrough; ++i) {
if (mFlushAfterWorkIndex >= 0 && i == 0) {
EXPECT_LE(mOutputFrameCounts[i], expectedOutputFrameCounts[i]) << "At iteration: " << i;
} else {
EXPECT_EQ(mOutputFrameCounts[i], expectedOutputFrameCounts[i]) << "At iteration: " << i;
}
EXPECT_EQ(mFinishedWorkCounts[i], expectedFinishedWorkCounts[i]) << "At iteration: " << i;
}
if (mSanityCheck) {
std::vector<std::string> goldenMD5s;
readGoldenMD5s(mTestVideoFile->mFilename, &goldenMD5s);
for (uint32_t i = 0; i < mNumberOfPlaythrough; ++i) {
if (mFlushAfterWorkIndex >= 0 && i == 0) {
continue; // do not compare the iteration with flushing
}
bool matched = std::find(goldenMD5s.begin(), goldenMD5s.end(), mMD5Strings[i]) !=
goldenMD5s.end();
EXPECT_TRUE(matched) << "Unknown MD5: " << mMD5Strings[i] << " at iter: " << i;
}
}
}
// Play input video once, end by draining.
INSTANTIATE_TEST_CASE_P(SinglePlaythroughTest, C2VDAComponentParamTest,
::testing::Values(std::make_tuple(static_cast<int>(FlushPoint::NO_FLUSH),
1u, false, false)));
// Play input video once, end by dummy EOS work.
INSTANTIATE_TEST_CASE_P(DummyEOSWorkTest, C2VDAComponentParamTest,
::testing::Values(std::make_tuple(static_cast<int>(FlushPoint::NO_FLUSH),
1u, false, true)));
// Play 5 times of input video, and check sanity by MD5Sum.
INSTANTIATE_TEST_CASE_P(MultiplePlaythroughSanityTest, C2VDAComponentParamTest,
::testing::Values(std::make_tuple(static_cast<int>(FlushPoint::NO_FLUSH),
5u, true, false)));
// Test mid-stream flush then play once entirely.
INSTANTIATE_TEST_CASE_P(FlushPlaythroughTest, C2VDAComponentParamTest,
::testing::Values(std::make_tuple(40, 1u, true, false)));
// Test mid-stream flush then stop.
INSTANTIATE_TEST_CASE_P(FlushStopTest, C2VDAComponentParamTest,
::testing::Values(std::make_tuple(
static_cast<int>(FlushPoint::MID_STREAM_FLUSH), 0u, false, false)));
// Test early flush (after a few works) then stop.
INSTANTIATE_TEST_CASE_P(EarlyFlushStopTest, C2VDAComponentParamTest,
::testing::Values(std::make_tuple(0, 0u, false, false),
std::make_tuple(1, 0u, false, false),
std::make_tuple(2, 0u, false, false),
std::make_tuple(3, 0u, false, false)));
// Test end-of-stream flush then stop.
INSTANTIATE_TEST_CASE_P(
EndOfStreamFlushStopTest, C2VDAComponentParamTest,
::testing::Values(std::make_tuple(static_cast<int>(FlushPoint::END_OF_STREAM_FLUSH), 0u,
false, false)));
} // namespace android
static void usage(const char* me) {
fprintf(stderr, "usage: %s [-i test_video_data] [-r(ecord YUV)] [gtest options]\n", me);
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
int res;
while ((res = getopt(argc, argv, "i:r")) >= 0) {
switch (res) {
case 'i': {
android::gTestVideoData = optarg;
break;
}
case 'r': {
android::gRecordOutputYUV = true;
break;
}
default: {
usage(argv[0]);
exit(1);
break;
}
}
}
return RUN_ALL_TESTS();
}