gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Benchmark: add asserts for common failures in native tests"

Browse Source 
am: d860d68f3d

Change-Id: I186d74daf92ef3657deef2f14c589b8bfa005aa9
gugelfrei
Manisha Jajoo 5 years ago committed by android-build-merger
parent 1bd0d9ec00 d860d68f3d
commit 7e8edd390d
8 changed files with 170 additions and 252 deletions
Show Stats Download Patch File Download Diff File

1
media/tests/benchmark/src/native/common/BenchmarkCommon.h
Unescape View File

@ -17,6 +17,7 @@
#ifndef __BENCHMARK_COMMON_H__ #ifndef __BENCHMARK_COMMON_H__
#define __BENCHMARK_COMMON_H__ #define __BENCHMARK_COMMON_H__
#include <sys/stat.h>
#include <inttypes.h> #include <inttypes.h>
#include <mutex> #include <mutex>
#include <queue> #include <queue>

4
media/tests/benchmark/src/native/muxer/Muxer.cpp
Unescape View File

@ -29,7 +29,7 @@ int32_t Muxer::initMuxer(int32_t fd, MUXER_OUTPUT_T outputFormat) {
int64_t sTime = mStats->getCurTime(); int64_t sTime = mStats->getCurTime();
mMuxer = AMediaMuxer_new(fd, (OutputFormat)outputFormat); mMuxer = AMediaMuxer_new(fd, (OutputFormat)outputFormat);
if (!mMuxer) { if (!mMuxer) {
cout << "[ WARN ] Test Skipped. Unable to create muxer \n"; ALOGV("Unable to create muxer");
return AMEDIA_ERROR_INVALID_OBJECT; return AMEDIA_ERROR_INVALID_OBJECT;
} }
/* /*
@ -38,7 +38,7 @@ int32_t Muxer::initMuxer(int32_t fd, MUXER_OUTPUT_T outputFormat) {
*/ */
ssize_t index = AMediaMuxer_addTrack(mMuxer, mFormat); ssize_t index = AMediaMuxer_addTrack(mMuxer, mFormat);
if (index < 0) { if (index < 0) {
cout << "[ WARN ] Test Skipped. Format not supported \n"; ALOGV("Format not supported");
return index; return index;
} }
AMediaMuxer_start(mMuxer); AMediaMuxer_start(mMuxer);

140
media/tests/benchmark/tests/C2DecoderTest.cpp
Unescape View File

@ -29,82 +29,64 @@ static BenchmarkTestEnvironment *gEnv = nullptr;
class C2DecoderTest : public ::testing::TestWithParam<pair<string, string>> { class C2DecoderTest : public ::testing::TestWithParam<pair<string, string>> {
public: public:
C2DecoderTest() : mDecoder(nullptr), disableTest(false) { setupC2DecoderTest(); } C2DecoderTest() : mDecoder(nullptr) {}
~C2DecoderTest() {
if (!mCodecList.empty()) {
mCodecList.clear();
}
if (mDecoder) {
delete mDecoder;
mDecoder = nullptr;
}
}
virtual void SetUp() override { setupC2DecoderTest(); }
void setupC2DecoderTest(); void setupC2DecoderTest();
vector<string> mCodecList; vector<string> mCodecList;
C2Decoder *mDecoder; C2Decoder *mDecoder;
bool disableTest;
}; };
void C2DecoderTest::setupC2DecoderTest() { void C2DecoderTest::setupC2DecoderTest() {
mDecoder = new C2Decoder(); mDecoder = new C2Decoder();
if (!mDecoder) { ASSERT_NE(mDecoder, nullptr) << "C2Decoder creation failed";
cout << "[ WARN ] Test Skipped. C2Decoder creation failed\n";
disableTest = true;
return;
}
int32_t status = mDecoder->setupCodec2(); int32_t status = mDecoder->setupCodec2();
if (status != 0) { ASSERT_EQ(status, 0) << "Codec2 setup failed";
cout << "[ WARN ] Test Skipped. Codec2 setup failed \n";
disableTest = true;
return;
}
mCodecList = mDecoder->getSupportedComponentList(false /* isEncoder*/); mCodecList = mDecoder->getSupportedComponentList(false /* isEncoder*/);
if (!mCodecList.size()) { ASSERT_GT(mCodecList.size(), 0) << "Codec2 client didn't recognise any component";
cout << "[ WARN ] Test Skipped. Codec2 client didn't recognise any component \n";
disableTest = true;
return;
}
} }
TEST_P(C2DecoderTest, Codec2Decode) { TEST_P(C2DecoderTest, Codec2Decode) {
if (disableTest) return;
ALOGV("Decode the samples given by extractor using codec2"); ALOGV("Decode the samples given by extractor using codec2");
string inputFile = gEnv->getRes() + GetParam().first; string inputFile = gEnv->getRes() + GetParam().first;
FILE *inputFp = fopen(inputFile.c_str(), "rb"); FILE *inputFp = fopen(inputFile.c_str(), "rb");
if (!inputFp) { ASSERT_NE(inputFp, nullptr) << "Unable to open " << inputFile << " file for reading";
cout << "[ WARN ] Test Skipped. Unable to open input file" << inputFile
<< " for reading \n";
return;
}
Extractor *extractor = new Extractor(); Extractor *extractor = new Extractor();
if (!extractor) { ASSERT_NE(extractor, nullptr) << "Extractor creation failed";
cout << "[ WARN ] Test Skipped. Extractor creation failed \n";
return;
}
// Read file properties // Read file properties
fseek(inputFp, 0, SEEK_END); struct stat buf;
size_t fileSize = ftell(inputFp); stat(inputFile.c_str(), &buf);
fseek(inputFp, 0, SEEK_SET); size_t fileSize = buf.st_size;
int32_t fd = fileno(inputFp); int32_t fd = fileno(inputFp);
if (fileSize > kMaxBufferSize) { ASSERT_LE(fileSize, kMaxBufferSize)
cout << "[ WARN ] Test Skipped. Input file size is greater than the threshold memory " << "Input file size is greater than the threshold memory dedicated to the test";
"dedicated to the test \n";
}
int32_t trackCount = extractor->initExtractor(fd, fileSize); int32_t trackCount = extractor->initExtractor(fd, fileSize);
if (trackCount <= 0) { ASSERT_GT(trackCount, 0) << "initExtractor failed";
cout << "[ WARN ] Test Skipped. initExtractor failed\n";
return;
}
for (int32_t curTrack = 0; curTrack < trackCount; curTrack++) { for (int32_t curTrack = 0; curTrack < trackCount; curTrack++) {
int32_t status = extractor->setupTrackFormat(curTrack); int32_t status = extractor->setupTrackFormat(curTrack);
if (status != 0) { ASSERT_EQ(status, 0) << "Track Format invalid";
cout << "[ WARN ] Test Skipped. Track Format invalid \n";
return;
}
uint8_t *inputBuffer = (uint8_t *)malloc(fileSize); uint8_t *inputBuffer = (uint8_t *)malloc(fileSize);
if (!inputBuffer) { ASSERT_NE(inputBuffer, nullptr) << "Insufficient memory";
cout << "[ WARN ] Test Skipped. Insufficient memory \n";
return;
}
vector<AMediaCodecBufferInfo> frameInfo; vector<AMediaCodecBufferInfo> frameInfo;
AMediaCodecBufferInfo info; AMediaCodecBufferInfo info;
@ -116,11 +98,8 @@ TEST_P(C2DecoderTest, Codec2Decode) {
void *csdBuffer = extractor->getCSDSample(info, idx); void *csdBuffer = extractor->getCSDSample(info, idx);
if (!csdBuffer || !info.size) break; if (!csdBuffer || !info.size) break;
// copy the meta data and buffer to be passed to decoder // copy the meta data and buffer to be passed to decoder
if (inputBufferOffset + info.size > fileSize) { ASSERT_LE(inputBufferOffset + info.size, fileSize) << "Memory allocated not sufficient";
cout << "[ WARN ] Test Skipped. Memory allocated not sufficient\n";
free(inputBuffer);
return;
}
memcpy(inputBuffer + inputBufferOffset, csdBuffer, info.size); memcpy(inputBuffer + inputBufferOffset, csdBuffer, info.size);
frameInfo.push_back(info); frameInfo.push_back(info);
inputBufferOffset += info.size; inputBufferOffset += info.size;
@ -132,11 +111,8 @@ TEST_P(C2DecoderTest, Codec2Decode) {
status = extractor->getFrameSample(info); status = extractor->getFrameSample(info);
if (status || !info.size) break; if (status || !info.size) break;
// copy the meta data and buffer to be passed to decoder // copy the meta data and buffer to be passed to decoder
if (inputBufferOffset + info.size > fileSize) { ASSERT_LE(inputBufferOffset + info.size, fileSize) << "Memory allocated not sufficient";
cout << "[ WARN ] Test Skipped. Memory allocated not sufficient\n";
free(inputBuffer);
return;
}
memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size); memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size);
frameInfo.push_back(info); frameInfo.push_back(info);
inputBufferOffset += info.size; inputBufferOffset += info.size;
@ -148,21 +124,18 @@ TEST_P(C2DecoderTest, Codec2Decode) {
if (codecName.find(GetParam().second) != string::npos && if (codecName.find(GetParam().second) != string::npos &&
codecName.find("secure") == string::npos) { codecName.find("secure") == string::npos) {
status = mDecoder->createCodec2Component(codecName, format); status = mDecoder->createCodec2Component(codecName, format);
if (status != 0) { ASSERT_EQ(status, 0) << "Create component failed for " << codecName;
cout << "[ WARN ] Test Skipped. Create component failed for " << codecName
<< "\n";
continue;
}
// Send the inputs to C2 Decoder and wait till all buffers are returned. // Send the inputs to C2 Decoder and wait till all buffers are returned.
mDecoder->decodeFrames(inputBuffer, frameInfo); status = mDecoder->decodeFrames(inputBuffer, frameInfo);
ASSERT_EQ(status, 0) << "Decoder failed for " << codecName;
mDecoder->waitOnInputConsumption(); mDecoder->waitOnInputConsumption();
if (!mDecoder->mEos) { ASSERT_TRUE(mDecoder->mEos) << "Test Failed. Didn't receive EOS \n";
cout << "[ WARN ] Test Failed. Didn't receive EOS \n";
}
mDecoder->deInitCodec(); mDecoder->deInitCodec();
int64_t durationUs = extractor->getClipDuration(); int64_t durationUs = extractor->getClipDuration();
cout << "codec: " << codecName << endl; ALOGV("codec : %s", codecName.c_str());
mDecoder->dumpStatistics(GetParam().first, durationUs); mDecoder->dumpStatistics(GetParam().first, durationUs);
mDecoder->resetDecoder(); mDecoder->resetDecoder();
} }
@ -172,6 +145,7 @@ TEST_P(C2DecoderTest, Codec2Decode) {
extractor->deInitExtractor(); extractor->deInitExtractor();
delete extractor; delete extractor;
delete mDecoder; delete mDecoder;
mDecoder = nullptr;
} }
} }
@ -179,26 +153,24 @@ TEST_P(C2DecoderTest, Codec2Decode) {
// Add wav files // Add wav files
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
AudioDecoderTest, C2DecoderTest, AudioDecoderTest, C2DecoderTest,
::testing::Values( ::testing::Values(make_pair("bbb_44100hz_2ch_128kbps_aac_30sec.mp4", "aac"),
make_pair("bbb_44100hz_2ch_128kbps_aac_30sec.mp4", "aac"), make_pair("bbb_44100hz_2ch_128kbps_mp3_30sec.mp3", "mp3"),
make_pair("bbb_44100hz_2ch_128kbps_mp3_30sec.mp3", "mp3"), make_pair("bbb_8000hz_1ch_8kbps_amrnb_30sec.3gp", "amrnb"),
make_pair("bbb_8000hz_1ch_8kbps_amrnb_30sec.3gp", "amrnb"), make_pair("bbb_16000hz_1ch_9kbps_amrwb_30sec.3gp", "amrnb"),
make_pair("bbb_16000hz_1ch_9kbps_amrwb_30sec.3gp", "amrnb"), make_pair("bbb_44100hz_2ch_80kbps_vorbis_30sec.mp4", "vorbis"),
make_pair("bbb_44100hz_2ch_80kbps_vorbis_30sec.mp4", "vorbis"), make_pair("bbb_44100hz_2ch_600kbps_flac_30sec.mp4", "flac"),
make_pair("bbb_44100hz_2ch_600kbps_flac_30sec.mp4", "flac"), make_pair("bbb_48000hz_2ch_100kbps_opus_30sec.webm", "opus")));
make_pair("bbb_48000hz_2ch_100kbps_opus_30sec.webm", "opus")));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
VideoDecoderTest, C2DecoderTest, VideoDecoderTest, C2DecoderTest,
::testing::Values( ::testing::Values(make_pair("crowd_1920x1080_25fps_4000kbps_vp9.webm", "vp9"),
make_pair("crowd_1920x1080_25fps_4000kbps_vp9.webm", "vp9"), make_pair("crowd_1920x1080_25fps_4000kbps_vp8.webm", "vp8"),
make_pair("crowd_1920x1080_25fps_4000kbps_vp8.webm", "vp8"), make_pair("crowd_1920x1080_25fps_4000kbps_av1.webm", "av1"),
make_pair("crowd_1920x1080_25fps_4000kbps_av1.webm", "av1"), make_pair("crowd_1920x1080_25fps_7300kbps_mpeg2.mp4", "mpeg2"),
make_pair("crowd_1920x1080_25fps_7300kbps_mpeg2.mp4", "mpeg2"), make_pair("crowd_1920x1080_25fps_6000kbps_mpeg4.mp4", "mpeg4"),
make_pair("crowd_1920x1080_25fps_6000kbps_mpeg4.mp4", "mpeg4"), make_pair("crowd_352x288_25fps_6000kbps_h263.3gp", "h263"),
make_pair("crowd_352x288_25fps_6000kbps_h263.3gp", "h263"), make_pair("crowd_1920x1080_25fps_6700kbps_h264.ts", "avc"),
make_pair("crowd_1920x1080_25fps_6700kbps_h264.ts", "avc"), make_pair("crowd_1920x1080_25fps_4000kbps_h265.mkv", "hevc")));
make_pair("crowd_1920x1080_25fps_4000kbps_h265.mkv", "hevc")));
int main(int argc, char **argv) { int main(int argc, char **argv) {
gEnv = new BenchmarkTestEnvironment(); gEnv = new BenchmarkTestEnvironment();

42
media/tests/benchmark/tests/C2EncoderTest.cpp
Unescape View File

@ -17,7 +17,6 @@
//#define LOG_NDEBUG 0 //#define LOG_NDEBUG 0
#define LOG_TAG "C2EncoderTest" #define LOG_TAG "C2EncoderTest"
#include <sys/stat.h>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <limits> #include <limits>
@ -30,7 +29,19 @@ static BenchmarkTestEnvironment *gEnv = nullptr;
class C2EncoderTest : public ::testing::TestWithParam<pair<string, string>> { class C2EncoderTest : public ::testing::TestWithParam<pair<string, string>> {
public: public:
C2EncoderTest() : mEncoder(nullptr) { setupC2EncoderTest(); } C2EncoderTest() : mEncoder(nullptr) {}
~C2EncoderTest() {
if (!mCodecList.empty()) {
mCodecList.clear();
}
if (mEncoder) {
delete mEncoder;
mEncoder = nullptr;
}
}
virtual void SetUp() override { setupC2EncoderTest(); }
void setupC2EncoderTest(); void setupC2EncoderTest();
@ -128,7 +139,7 @@ TEST_P(C2EncoderTest, Codec2Encode) {
mEncoder->deInitCodec(); mEncoder->deInitCodec();
int64_t durationUs = extractor->getClipDuration(); int64_t durationUs = extractor->getClipDuration();
cout << "codec: " << codecName << endl; ALOGV("codec : %s", codecName.c_str());
mEncoder->dumpStatistics(GetParam().first, durationUs); mEncoder->dumpStatistics(GetParam().first, durationUs);
mEncoder->resetEncoder(); mEncoder->resetEncoder();
} }
@ -143,26 +154,25 @@ TEST_P(C2EncoderTest, Codec2Encode) {
extractor->deInitExtractor(); extractor->deInitExtractor();
delete decoder; delete decoder;
delete mEncoder; delete mEncoder;
mEncoder = nullptr;
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
AudioEncoderTest, C2EncoderTest, AudioEncoderTest, C2EncoderTest,
::testing::Values( ::testing::Values(make_pair("bbb_44100hz_2ch_128kbps_aac_30sec.mp4", "aac"),
make_pair("bbb_44100hz_2ch_128kbps_aac_30sec.mp4", "aac"), make_pair("bbb_8000hz_1ch_8kbps_amrnb_30sec.3gp", "amrnb"),
make_pair("bbb_8000hz_1ch_8kbps_amrnb_30sec.3gp", "amrnb"), make_pair("bbb_16000hz_1ch_9kbps_amrwb_30sec.3gp", "amrwb"),
make_pair("bbb_16000hz_1ch_9kbps_amrwb_30sec.3gp", "amrwb"), make_pair("bbb_44100hz_2ch_600kbps_flac_30sec.mp4", "flac"),
make_pair("bbb_44100hz_2ch_600kbps_flac_30sec.mp4", "flac"), make_pair("bbb_48000hz_2ch_100kbps_opus_30sec.webm", "opus")));
make_pair("bbb_48000hz_2ch_100kbps_opus_30sec.webm", "opus")));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
VideoEncoderTest, C2EncoderTest, VideoEncoderTest, C2EncoderTest,
::testing::Values( ::testing::Values(make_pair("crowd_1920x1080_25fps_4000kbps_vp9.webm", "vp9"),
make_pair("crowd_1920x1080_25fps_4000kbps_vp9.webm", "vp9"), make_pair("crowd_1920x1080_25fps_4000kbps_vp8.webm", "vp8"),
make_pair("crowd_1920x1080_25fps_4000kbps_vp8.webm", "vp8"), make_pair("crowd_176x144_25fps_6000kbps_mpeg4.mp4", "mpeg4"),
make_pair("crowd_176x144_25fps_6000kbps_mpeg4.mp4", "mpeg4"), make_pair("crowd_176x144_25fps_6000kbps_h263.3gp", "h263"),
make_pair("crowd_176x144_25fps_6000kbps_h263.3gp", "h263"), make_pair("crowd_1920x1080_25fps_6700kbps_h264.ts", "avc"),
make_pair("crowd_1920x1080_25fps_6700kbps_h264.ts", "avc"), make_pair("crowd_1920x1080_25fps_4000kbps_h265.mkv", "hevc")));
make_pair("crowd_1920x1080_25fps_4000kbps_h265.mkv", "hevc")));
int main(int argc, char **argv) { int main(int argc, char **argv) {
gEnv = new BenchmarkTestEnvironment(); gEnv = new BenchmarkTestEnvironment();

54
media/tests/benchmark/tests/DecoderTest.cpp
Unescape View File

@ -21,8 +21,8 @@
#include <iostream> #include <iostream>
#include <limits> #include <limits>
#include "Decoder.h"
#include "BenchmarkTestEnvironment.h" #include "BenchmarkTestEnvironment.h"
#include "Decoder.h"
static BenchmarkTestEnvironment *gEnv = nullptr; static BenchmarkTestEnvironment *gEnv = nullptr;
@ -34,41 +34,30 @@ TEST_P(DecoderTest, Decode) {
string inputFile = gEnv->getRes() + get<0>(params); string inputFile = gEnv->getRes() + get<0>(params);
FILE *inputFp = fopen(inputFile.c_str(), "rb"); FILE *inputFp = fopen(inputFile.c_str(), "rb");
if (!inputFp) { ASSERT_NE(inputFp, nullptr) << "Unable to open " << inputFile << " file for reading";
cout << "[ WARN ] Test Skipped. Unable to open input file for reading \n";
return;
}
Decoder *decoder = new Decoder(); Decoder *decoder = new Decoder();
ASSERT_NE(decoder, nullptr) << "Decoder creation failed";
Extractor *extractor = decoder->getExtractor(); Extractor *extractor = decoder->getExtractor();
if (!extractor) { ASSERT_NE(extractor, nullptr) << "Extractor creation failed";
cout << "[ WARN ] Test Skipped. Extractor creation failed \n";
return;
}
// Read file properties // Read file properties
fseek(inputFp, 0, SEEK_END); struct stat buf;
size_t fileSize = ftell(inputFp); stat(inputFile.c_str(), &buf);
fseek(inputFp, 0, SEEK_SET); size_t fileSize = buf.st_size;
int32_t fd = fileno(inputFp); int32_t fd = fileno(inputFp);
int32_t trackCount = extractor->initExtractor(fd, fileSize); int32_t trackCount = extractor->initExtractor(fd, fileSize);
if (trackCount <= 0) { ASSERT_GT(trackCount, 0) << "initExtractor failed";
cout << "[ WARN ] Test Skipped. initExtractor failed\n";
return;
}
for (int curTrack = 0; curTrack < trackCount; curTrack++) { for (int curTrack = 0; curTrack < trackCount; curTrack++) {
int32_t status = extractor->setupTrackFormat(curTrack); int32_t status = extractor->setupTrackFormat(curTrack);
if (status != 0) { ASSERT_EQ(status, 0) << "Track Format invalid";
cout << "[ WARN ] Test Skipped. Track Format invalid \n";
return;
}
uint8_t *inputBuffer = (uint8_t *)malloc(kMaxBufferSize); uint8_t *inputBuffer = (uint8_t *)malloc(kMaxBufferSize);
if (!inputBuffer) { ASSERT_NE(inputBuffer, nullptr) << "Insufficient memory";
cout << "[ WARN ] Test Skipped. Insufficient memory \n";
return;
}
vector<AMediaCodecBufferInfo> frameInfo; vector<AMediaCodecBufferInfo> frameInfo;
AMediaCodecBufferInfo info; AMediaCodecBufferInfo info;
uint32_t inputBufferOffset = 0; uint32_t inputBufferOffset = 0;
@ -78,11 +67,9 @@ TEST_P(DecoderTest, Decode) {
status = extractor->getFrameSample(info); status = extractor->getFrameSample(info);
if (status || !info.size) break; if (status || !info.size) break;
// copy the meta data and buffer to be passed to decoder // copy the meta data and buffer to be passed to decoder
if (inputBufferOffset + info.size > kMaxBufferSize) { ASSERT_LE(inputBufferOffset + info.size, kMaxBufferSize)
cout << "[ WARN ] Test Skipped. Memory allocated not sufficient\n"; << "Memory allocated not sufficient";
free(inputBuffer);
return;
}
memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size); memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size);
frameInfo.push_back(info); frameInfo.push_back(info);
inputBufferOffset += info.size; inputBufferOffset += info.size;
@ -92,13 +79,10 @@ TEST_P(DecoderTest, Decode) {
bool asyncMode = get<2>(params); bool asyncMode = get<2>(params);
decoder->setupDecoder(); decoder->setupDecoder();
status = decoder->decode(inputBuffer, frameInfo, codecName, asyncMode); status = decoder->decode(inputBuffer, frameInfo, codecName, asyncMode);
if (status != AMEDIA_OK) { ASSERT_EQ(status, AMEDIA_OK) << "Decoder failed for " << codecName;
cout << "[ WARN ] Test Failed. Decode returned error " << status << endl;
free(inputBuffer);
return;
}
decoder->deInitCodec(); decoder->deInitCodec();
cout << "codec : " << codecName << endl; ALOGV("codec : %s", codecName.c_str());
string inputReference = get<0>(params); string inputReference = get<0>(params);
decoder->dumpStatistics(inputReference); decoder->dumpStatistics(inputReference);
free(inputBuffer); free(inputBuffer);

84
media/tests/benchmark/tests/EncoderTest.cpp
Unescape View File

@ -20,8 +20,8 @@
#include <fstream> #include <fstream>
#include "BenchmarkTestEnvironment.h" #include "BenchmarkTestEnvironment.h"
#include "Encoder.h"
#include "Decoder.h" #include "Decoder.h"
#include "Encoder.h"
static BenchmarkTestEnvironment *gEnv = nullptr; static BenchmarkTestEnvironment *gEnv = nullptr;
@ -33,42 +33,33 @@ TEST_P(EncoderTest, Encode) {
string inputFile = gEnv->getRes() + get<0>(params); string inputFile = gEnv->getRes() + get<0>(params);
FILE *inputFp = fopen(inputFile.c_str(), "rb"); FILE *inputFp = fopen(inputFile.c_str(), "rb");
if (!inputFp) { ASSERT_NE(inputFp, nullptr) << "Unable to open " << inputFile << " file for reading";
cout << "[ WARN ] Test Skipped. Unable to open input file for reading \n";
return;
}
Decoder *decoder = new Decoder(); Decoder *decoder = new Decoder();
ASSERT_NE(decoder, nullptr) << "Decoder creation failed";
Extractor *extractor = decoder->getExtractor(); Extractor *extractor = decoder->getExtractor();
if (!extractor) { ASSERT_NE(extractor, nullptr) << "Extractor creation failed";
cout << "[ WARN ] Test Skipped. Extractor creation failed \n";
return;
}
// Read file properties // Read file properties
fseek(inputFp, 0, SEEK_END); struct stat buf;
size_t fileSize = ftell(inputFp); stat(inputFile.c_str(), &buf);
fseek(inputFp, 0, SEEK_SET); size_t fileSize = buf.st_size;
int32_t fd = fileno(inputFp); int32_t fd = fileno(inputFp);
int32_t trackCount = extractor->initExtractor(fd, fileSize); int32_t trackCount = extractor->initExtractor(fd, fileSize);
if (trackCount <= 0) { ASSERT_GT(trackCount, 0) << "initExtractor failed";
cout << "[ WARN ] Test Skipped. initExtractor failed\n";
return;
}
Encoder *encoder = new Encoder(); Encoder *encoder = new Encoder();
ASSERT_NE(encoder, nullptr) << "Decoder creation failed";
for (int curTrack = 0; curTrack < trackCount; curTrack++) { for (int curTrack = 0; curTrack < trackCount; curTrack++) {
int32_t status = extractor->setupTrackFormat(curTrack); int32_t status = extractor->setupTrackFormat(curTrack);
if (status != 0) { ASSERT_EQ(status, 0) << "Track Format invalid";
cout << "[ WARN ] Test Skipped. Track Format invalid \n";
return;
}
uint8_t *inputBuffer = (uint8_t *)malloc(kMaxBufferSize); uint8_t *inputBuffer = (uint8_t *)malloc(kMaxBufferSize);
if (!inputBuffer) { ASSERT_NE(inputBuffer, nullptr) << "Insufficient memory";
cout << "[ WARN ] Test Skipped. Insufficient memory \n";
return;
}
vector<AMediaCodecBufferInfo> frameInfo; vector<AMediaCodecBufferInfo> frameInfo;
AMediaCodecBufferInfo info; AMediaCodecBufferInfo info;
uint32_t inputBufferOffset = 0; uint32_t inputBufferOffset = 0;
@ -78,11 +69,9 @@ TEST_P(EncoderTest, Encode) {
status = extractor->getFrameSample(info); status = extractor->getFrameSample(info);
if (status || !info.size) break; if (status || !info.size) break;
// copy the meta data and buffer to be passed to decoder // copy the meta data and buffer to be passed to decoder
if (inputBufferOffset + info.size > kMaxBufferSize) { ASSERT_LE(inputBufferOffset + info.size, kMaxBufferSize)
cout << "[ WARN ] Test Skipped. Memory allocated not sufficient\n"; << "Memory allocated not sufficient";
free(inputBuffer);
return;
}
memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size); memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size);
frameInfo.push_back(info); frameInfo.push_back(info);
inputBufferOffset += info.size; inputBufferOffset += info.size;
@ -91,16 +80,12 @@ TEST_P(EncoderTest, Encode) {
string decName = ""; string decName = "";
string outputFileName = "decode.out"; string outputFileName = "decode.out";
FILE *outFp = fopen(outputFileName.c_str(), "wb"); FILE *outFp = fopen(outputFileName.c_str(), "wb");
if (outFp == nullptr) { ASSERT_NE(outFp, nullptr) << "Unable to open output file" << outputFileName
ALOGE("Unable to open output file for writing"); << " for dumping decoder's output";
return;
}
decoder->setupDecoder(); decoder->setupDecoder();
status = decoder->decode(inputBuffer, frameInfo, decName, false /*asyncMode */, outFp); status = decoder->decode(inputBuffer, frameInfo, decName, false /*asyncMode */, outFp);
if (status != AMEDIA_OK) { ASSERT_EQ(status, AMEDIA_OK) << "Decode returned error : " << status;
cout << "[ WARN ] Test Skipped. Decode returned error \n";
return;
}
ifstream eleStream; ifstream eleStream;
eleStream.open(outputFileName.c_str(), ifstream::binary | ifstream::ate); eleStream.open(outputFileName.c_str(), ifstream::binary | ifstream::ate);
@ -111,15 +96,13 @@ TEST_P(EncoderTest, Encode) {
AMediaFormat *format = extractor->getFormat(); AMediaFormat *format = extractor->getFormat();
const char *mime = nullptr; const char *mime = nullptr;
AMediaFormat_getString(format, AMEDIAFORMAT_KEY_MIME, &mime); AMediaFormat_getString(format, AMEDIAFORMAT_KEY_MIME, &mime);
if (!mime) { ASSERT_NE(mime, nullptr) << "Invalid mime type";
ALOGE("Error in AMediaFormat_getString");
return;
}
// Get encoder params // Get encoder params
encParameter encParams; encParameter encParams;
if (!strncmp(mime, "video/", 6)) { if (!strncmp(mime, "video/", 6)) {
AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &encParams.width); ASSERT_TRUE(AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &encParams.width));
AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &encParams.height); ASSERT_TRUE(AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &encParams.height));
AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_FRAME_RATE, &encParams.frameRate); AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_FRAME_RATE, &encParams.frameRate);
AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, &encParams.bitrate); AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, &encParams.bitrate);
if (encParams.bitrate <= 0 || encParams.frameRate <= 0) { if (encParams.bitrate <= 0 || encParams.frameRate <= 0) {
@ -133,8 +116,10 @@ TEST_P(EncoderTest, Encode) {
AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_PROFILE, &encParams.profile); AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_PROFILE, &encParams.profile);
AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_LEVEL, &encParams.level); AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_LEVEL, &encParams.level);
} else { } else {
AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &encParams.sampleRate); ASSERT_TRUE(AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE,
AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &encParams.numChannels); &encParams.sampleRate));
ASSERT_TRUE(AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT,
&encParams.numChannels));
encParams.bitrate = encParams.bitrate =
encParams.sampleRate * encParams.numChannels * 16 /* bitsPerSample */; encParams.sampleRate * encParams.numChannels * 16 /* bitsPerSample */;
} }
@ -143,13 +128,10 @@ TEST_P(EncoderTest, Encode) {
string codecName = get<1>(params); string codecName = get<1>(params);
bool asyncMode = get<2>(params); bool asyncMode = get<2>(params);
status = encoder->encode(codecName, eleStream, eleSize, asyncMode, encParams, (char *)mime); status = encoder->encode(codecName, eleStream, eleSize, asyncMode, encParams, (char *)mime);
if (status != AMEDIA_OK) { ASSERT_EQ(status, 0) << "Encoder failed for " << codecName;
cout << "[ WARN ] Test Failed. Encode returned error " << status << endl;
free(inputBuffer);
return;
}
encoder->deInitCodec(); encoder->deInitCodec();
cout << "codec : " << codecName << endl; ALOGV("codec : %s", codecName.c_str());
string inputReference = get<0>(params); string inputReference = get<0>(params);
encoder->dumpStatistics(inputReference, extractor->getClipDuration()); encoder->dumpStatistics(inputReference, extractor->getClipDuration());
eleStream.close(); eleStream.close();

28
media/tests/benchmark/tests/ExtractorTest.cpp
Unescape View File

@ -19,8 +19,8 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "Extractor.h"
#include "BenchmarkTestEnvironment.h" #include "BenchmarkTestEnvironment.h"
#include "Extractor.h"
static BenchmarkTestEnvironment *gEnv = nullptr; static BenchmarkTestEnvironment *gEnv = nullptr;
@ -28,33 +28,24 @@ class ExtractorTest : public ::testing::TestWithParam<pair<string, int32_t>> {};
TEST_P(ExtractorTest, Extract) { TEST_P(ExtractorTest, Extract) {
Extractor *extractObj = new Extractor(); Extractor *extractObj = new Extractor();
ASSERT_NE(extractObj, nullptr) << "Extractor creation failed";
string inputFile = gEnv->getRes() + GetParam().first; string inputFile = gEnv->getRes() + GetParam().first;
FILE *inputFp = fopen(inputFile.c_str(), "rb"); FILE *inputFp = fopen(inputFile.c_str(), "rb");
if (!inputFp) { ASSERT_NE(inputFp, nullptr) << "Unable to open " << inputFile << " file for reading";
cout << "[ WARN ] Test Skipped. Unable to open input file for reading \n";
return;
}
// Read file properties // Read file properties
size_t fileSize = 0; struct stat buf;
fseek(inputFp, 0, SEEK_END); stat(inputFile.c_str(), &buf);
fileSize = ftell(inputFp); size_t fileSize = buf.st_size;
fseek(inputFp, 0, SEEK_SET);
int32_t fd = fileno(inputFp); int32_t fd = fileno(inputFp);
int32_t trackCount = extractObj->initExtractor(fd, fileSize); int32_t trackCount = extractObj->initExtractor(fd, fileSize);
if (trackCount <= 0) { ASSERT_GT(trackCount, 0) << "initExtractor failed";
cout << "[ WARN ] Test Skipped. initExtractor failed\n";
return;
}
int32_t trackID = GetParam().second; int32_t trackID = GetParam().second;
int32_t status = extractObj->extract(trackID); int32_t status = extractObj->extract(trackID);
if (status != AMEDIA_OK) { ASSERT_EQ(status, AMEDIA_OK) << "Extraction failed \n";
cout << "[ WARN ] Test Skipped. Extraction failed \n";
return;
}
extractObj->deInitExtractor(); extractObj->deInitExtractor();
@ -79,7 +70,8 @@ INSTANTIATE_TEST_SUITE_P(ExtractorTestAll, ExtractorTest,
make_pair("bbb_8000hz_1ch_8kbps_amrnb_5mins.3gp", 0), make_pair("bbb_8000hz_1ch_8kbps_amrnb_5mins.3gp", 0),
make_pair("bbb_16000hz_1ch_9kbps_amrwb_5mins.3gp", 0), make_pair("bbb_16000hz_1ch_9kbps_amrwb_5mins.3gp", 0),
make_pair("bbb_44100hz_2ch_80kbps_vorbis_5mins.mp4", 0), make_pair("bbb_44100hz_2ch_80kbps_vorbis_5mins.mp4", 0),
make_pair("bbb_48000hz_2ch_100kbps_opus_5mins.webm", 0))); make_pair("bbb_48000hz_2ch_100kbps_opus_5mins.webm",
0)));
int main(int argc, char **argv) { int main(int argc, char **argv) {
gEnv = new BenchmarkTestEnvironment(); gEnv = new BenchmarkTestEnvironment();

69
media/tests/benchmark/tests/MuxerTest.cpp
Unescape View File

@ -21,8 +21,8 @@
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include "Muxer.h"
#include "BenchmarkTestEnvironment.h" #include "BenchmarkTestEnvironment.h"
#include "Muxer.h"
#define OUTPUT_FILE_NAME "/data/local/tmp/mux.out" #define OUTPUT_FILE_NAME "/data/local/tmp/mux.out"
@ -53,49 +53,34 @@ TEST_P(MuxerTest, Mux) {
ALOGV("Mux the samples given by extractor"); ALOGV("Mux the samples given by extractor");
string inputFile = gEnv->getRes() + GetParam().first; string inputFile = gEnv->getRes() + GetParam().first;
FILE *inputFp = fopen(inputFile.c_str(), "rb"); FILE *inputFp = fopen(inputFile.c_str(), "rb");
if (!inputFp) { ASSERT_NE(inputFp, nullptr) << "Unable to open " << inputFile << " file for reading";
cout << "[ WARN ] Test Skipped. Unable to open input file for reading \n";
return;
}
string fmt = GetParam().second; string fmt = GetParam().second;
MUXER_OUTPUT_T outputFormat = getMuxerOutFormat(fmt); MUXER_OUTPUT_T outputFormat = getMuxerOutFormat(fmt);
if (outputFormat == MUXER_OUTPUT_FORMAT_INVALID) { ASSERT_NE(outputFormat, MUXER_OUTPUT_FORMAT_INVALID) << "Invalid muxer output format";
ALOGE("output format is MUXER_OUTPUT_FORMAT_INVALID");
return;
}
Muxer *muxerObj = new Muxer(); Muxer *muxerObj = new Muxer();
ASSERT_NE(muxerObj, nullptr) << "Muxer creation failed";
Extractor *extractor = muxerObj->getExtractor(); Extractor *extractor = muxerObj->getExtractor();
if (!extractor) { ASSERT_NE(extractor, nullptr) << "Extractor creation failed";
cout << "[ WARN ] Test Skipped. Extractor creation failed \n";
return;
}
// Read file properties // Read file properties
size_t fileSize = 0; struct stat buf;
fseek(inputFp, 0, SEEK_END); stat(inputFile.c_str(), &buf);
fileSize = ftell(inputFp); size_t fileSize = buf.st_size;
fseek(inputFp, 0, SEEK_SET);
int32_t fd = fileno(inputFp); int32_t fd = fileno(inputFp);
int32_t trackCount = extractor->initExtractor(fd, fileSize); int32_t trackCount = extractor->initExtractor(fd, fileSize);
if (trackCount <= 0) { ASSERT_GT(trackCount, 0) << "initExtractor failed";
cout << "[ WARN ] Test Skipped. initExtractor failed\n";
return;
}
for (int curTrack = 0; curTrack < trackCount; curTrack++) { for (int curTrack = 0; curTrack < trackCount; curTrack++) {
int32_t status = extractor->setupTrackFormat(curTrack); int32_t status = extractor->setupTrackFormat(curTrack);
if (status != 0) { ASSERT_EQ(status, 0) << "Track Format invalid";
cout << "[ WARN ] Test Skipped. Track Format invalid \n";
return;
}
uint8_t *inputBuffer = (uint8_t *)malloc(kMaxBufferSize); uint8_t *inputBuffer = (uint8_t *)malloc(kMaxBufferSize);
if (!inputBuffer) { ASSERT_NE(inputBuffer, nullptr) << "Insufficient memory";
std::cout << "[ WARN ] Test Skipped. Insufficient memory \n";
return;
}
// AMediaCodecBufferInfo : <size of frame> <flags> <presentationTimeUs> <offset> // AMediaCodecBufferInfo : <size of frame> <flags> <presentationTimeUs> <offset>
vector<AMediaCodecBufferInfo> frameInfos; vector<AMediaCodecBufferInfo> frameInfos;
AMediaCodecBufferInfo info; AMediaCodecBufferInfo info;
@ -106,11 +91,9 @@ TEST_P(MuxerTest, Mux) {
status = extractor->getFrameSample(info); status = extractor->getFrameSample(info);
if (status || !info.size) break; if (status || !info.size) break;
// copy the meta data and buffer to be passed to muxer // copy the meta data and buffer to be passed to muxer
if (inputBufferOffset + info.size > kMaxBufferSize) { ASSERT_LE(inputBufferOffset + info.size, kMaxBufferSize)
cout << "[ WARN ] Test Skipped. Memory allocated not sufficient\n"; << "Memory allocated not sufficient";
free(inputBuffer);
return;
}
memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size); memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size);
info.offset = inputBufferOffset; info.offset = inputBufferOffset;
frameInfos.push_back(info); frameInfos.push_back(info);
@ -119,22 +102,16 @@ TEST_P(MuxerTest, Mux) {
string outputFileName = OUTPUT_FILE_NAME; string outputFileName = OUTPUT_FILE_NAME;
FILE *outputFp = fopen(outputFileName.c_str(), "w+b"); FILE *outputFp = fopen(outputFileName.c_str(), "w+b");
if (!outputFp) { ASSERT_NE(outputFp, nullptr)
cout << "[ WARN ] Test Skipped. Unable to open output file for writing \n"; << "Unable to open output file" << outputFileName << " for writing";
return;
}
int32_t fd = fileno(outputFp); int32_t fd = fileno(outputFp);
status = muxerObj->initMuxer(fd, outputFormat); status = muxerObj->initMuxer(fd, outputFormat);
if (status != 0) { ASSERT_EQ(status, 0) << "initMuxer failed";
cout << "[ WARN ] Test Skipped. initMuxer failed\n";
return;
}
status = muxerObj->mux(inputBuffer, frameInfos); status = muxerObj->mux(inputBuffer, frameInfos);
if (status != 0) { ASSERT_EQ(status, 0) << "Mux failed";
cout << "[ WARN ] Test Skipped. Mux failed \n";
return;
}
muxerObj->deInitMuxer(); muxerObj->deInitMuxer();
muxerObj->dumpStatistics(GetParam().first + "." + fmt.c_str()); muxerObj->dumpStatistics(GetParam().first + "." + fmt.c_str());
free(inputBuffer); free(inputBuffer);

Write Preview
Loading…
Cancel
Save