| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "C2EncoderTest" |
| |
| #include <fstream> |
| #include <iostream> |
| #include <limits> |
| |
| #include "BenchmarkTestEnvironment.h" |
| #include "C2Encoder.h" |
| #include "Decoder.h" |
| |
| static BenchmarkTestEnvironment *gEnv = nullptr; |
| |
| class C2EncoderTest : public ::testing::TestWithParam<pair<string, string>> { |
| public: |
| C2EncoderTest() : mEncoder(nullptr) {} |
| |
| ~C2EncoderTest() { |
| if (!mCodecList.empty()) { |
| mCodecList.clear(); |
| } |
| if (mEncoder) { |
| delete mEncoder; |
| mEncoder = nullptr; |
| } |
| } |
| |
| virtual void SetUp() override { setupC2EncoderTest(); } |
| |
| void setupC2EncoderTest(); |
| |
| vector<string> mCodecList; |
| C2Encoder *mEncoder; |
| }; |
| |
| void C2EncoderTest::setupC2EncoderTest() { |
| mEncoder = new C2Encoder(); |
| ASSERT_NE(mEncoder, nullptr) << "C2Encoder creation failed"; |
| |
| int32_t status = mEncoder->setupCodec2(); |
| ASSERT_EQ(status, 0) << "Codec2 setup failed"; |
| |
| mCodecList = mEncoder->getSupportedComponentList(true /* isEncoder*/); |
| ASSERT_GT(mCodecList.size(), 0) << "Codec2 client didn't recognise any component"; |
| } |
| |
| TEST_P(C2EncoderTest, Codec2Encode) { |
| ALOGV("Encodes the input using codec2 framework"); |
| string inputFile = gEnv->getRes() + GetParam().first; |
| FILE *inputFp = fopen(inputFile.c_str(), "rb"); |
| ASSERT_NE(inputFp, nullptr) << "Unable to open input file for reading"; |
| |
| Decoder *decoder = new Decoder(); |
| ASSERT_NE(decoder, nullptr) << "Decoder creation failed"; |
| |
| Extractor *extractor = decoder->getExtractor(); |
| ASSERT_NE(extractor, nullptr) << "Extractor creation failed"; |
| |
| // Read file properties |
| struct stat buf; |
| stat(inputFile.c_str(), &buf); |
| size_t fileSize = buf.st_size; |
| int32_t fd = fileno(inputFp); |
| |
| ASSERT_LE(fileSize, kMaxBufferSize) |
| << "Input file size is greater than the threshold memory dedicated to the test"; |
| |
| int32_t trackCount = extractor->initExtractor(fd, fileSize); |
| ASSERT_GT(trackCount, 0) << "initExtractor failed"; |
| |
| for (int curTrack = 0; curTrack < trackCount; curTrack++) { |
| int32_t status = extractor->setupTrackFormat(curTrack); |
| ASSERT_EQ(status, 0) << "Track Format invalid"; |
| |
| uint8_t *inputBuffer = (uint8_t *)malloc(fileSize); |
| ASSERT_NE(inputBuffer, nullptr) << "Insufficient memory"; |
| |
| vector<AMediaCodecBufferInfo> frameInfo; |
| AMediaCodecBufferInfo info; |
| uint32_t inputBufferOffset = 0; |
| |
| // Get frame data |
| while (1) { |
| status = extractor->getFrameSample(info); |
| if (status || !info.size) break; |
| // copy the meta data and buffer to be passed to decoder |
| ASSERT_LE(inputBufferOffset + info.size, fileSize) << "Memory allocated not sufficient"; |
| |
| memcpy(inputBuffer + inputBufferOffset, extractor->getFrameBuf(), info.size); |
| frameInfo.push_back(info); |
| inputBufferOffset += info.size; |
| } |
| |
| string decName = ""; |
| string outputFileName = "decode.out"; |
| FILE *outFp = fopen(outputFileName.c_str(), "wb"); |
| 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); |
| ASSERT_EQ(status, AMEDIA_OK) << "Decode returned error : " << status; |
| |
| // Encode the given input stream for all C2 codecs supported by device |
| AMediaFormat *format = extractor->getFormat(); |
| ifstream eleStream; |
| eleStream.open(outputFileName.c_str(), ifstream::binary | ifstream::ate); |
| ASSERT_EQ(eleStream.is_open(), true) << outputFileName.c_str() << " - file not found"; |
| size_t eleSize = eleStream.tellg(); |
| |
| for (string codecName : mCodecList) { |
| if (codecName.find(GetParam().second) != string::npos) { |
| status = mEncoder->createCodec2Component(codecName, format); |
| ASSERT_EQ(status, 0) << "Create component failed for " << codecName; |
| |
| // Send the inputs to C2 Encoder and wait till all buffers are returned. |
| eleStream.seekg(0, ifstream::beg); |
| status = mEncoder->encodeFrames(eleStream, eleSize); |
| ASSERT_EQ(status, 0) << "Encoder failed for " << codecName; |
| |
| mEncoder->waitOnInputConsumption(); |
| ASSERT_TRUE(mEncoder->mEos) << "Test Failed. Didn't receive EOS \n"; |
| |
| mEncoder->deInitCodec(); |
| int64_t durationUs = extractor->getClipDuration(); |
| ALOGV("codec : %s", codecName.c_str()); |
| mEncoder->dumpStatistics(GetParam().first, durationUs); |
| mEncoder->resetEncoder(); |
| } |
| } |
| |
| // Destroy the decoder for the given input |
| decoder->deInitCodec(); |
| decoder->resetDecoder(); |
| free(inputBuffer); |
| } |
| fclose(inputFp); |
| 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"))); |
| |
| 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"))); |
| |
| int main(int argc, char **argv) { |
| gEnv = new BenchmarkTestEnvironment(); |
| ::testing::AddGlobalTestEnvironment(gEnv); |
| ::testing::InitGoogleTest(&argc, argv); |
| int status = gEnv->initFromOptions(argc, argv); |
| if (status == 0) { |
| status = RUN_ALL_TESTS(); |
| ALOGV("C2 Encoder Test result = %d\n", status); |
| } |
| return status; |
| } |