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

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

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

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

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

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

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

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

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

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

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

Write Preview
Loading…
Cancel
Save