| /* |
| * Copyright (C) 2020 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 "NativeCodecEncoderTest" |
| #include <log/log.h> |
| |
| #include <jni.h> |
| #include <sys/stat.h> |
| |
| #include "NativeCodecTestBase.h" |
| #include "NativeMediaConstants.h" |
| |
| class CodecEncoderTest final : CodecTestBase { |
| private: |
| uint8_t* mInputData; |
| size_t mInputLength; |
| int mNumBytesSubmitted; |
| int64_t mInputOffsetPts; |
| std::vector<AMediaFormat*> mFormats; |
| int mNumSyncFramesReceived; |
| std::vector<int> mSyncFramesPos; |
| |
| int32_t* mBitRates; |
| int mLen0; |
| int32_t* mEncParamList1; |
| int mLen1; |
| int32_t* mEncParamList2; |
| int mLen2; |
| |
| int mWidth, mHeight; |
| int mChannels; |
| int mSampleRate; |
| int mColorFormat; |
| int mMaxBFrames; |
| int mDefFrameRate; |
| const int kInpFrmWidth = 352; |
| const int kInpFrmHeight = 288; |
| |
| void convertyuv420ptoyuv420sp(); |
| void setUpSource(const char* srcPath); |
| void deleteSource(); |
| void setUpParams(int limit); |
| void deleteParams(); |
| bool flushCodec() override; |
| void resetContext(bool isAsync, bool signalEOSWithLastFrame) override; |
| bool enqueueInput(size_t bufferIndex) override; |
| bool dequeueOutput(size_t bufferIndex, AMediaCodecBufferInfo* bufferInfo) override; |
| void initFormat(AMediaFormat* format); |
| bool encodeToMemory(const char* file, const char* encoder, int frameLimit, AMediaFormat* format, |
| OutputManager* ref); |
| void fillByteBuffer(uint8_t* inputBuffer); |
| void forceSyncFrame(AMediaFormat* format); |
| void updateBitrate(AMediaFormat* format, int bitrate); |
| |
| public: |
| CodecEncoderTest(const char* mime, int32_t* list0, int len0, int32_t* list1, int len1, |
| int32_t* list2, int len2, int colorFormat); |
| ~CodecEncoderTest(); |
| |
| bool testSimpleEncode(const char* encoder, const char* srcPath); |
| bool testFlush(const char* encoder, const char* srcPath); |
| bool testReconfigure(const char* encoder, const char* srcPath); |
| bool testSetForceSyncFrame(const char* encoder, const char* srcPath); |
| bool testAdaptiveBitRate(const char* encoder, const char* srcPath); |
| bool testOnlyEos(const char* encoder); |
| }; |
| |
| CodecEncoderTest::CodecEncoderTest(const char* mime, int32_t* list0, int len0, int32_t* list1, |
| int len1, int32_t* list2, int len2, int colorFormat) |
| : CodecTestBase(mime), |
| mBitRates{list0}, |
| mLen0{len0}, |
| mEncParamList1{list1}, |
| mLen1{len1}, |
| mEncParamList2{list2}, |
| mLen2{len2}, |
| mColorFormat{colorFormat} { |
| mDefFrameRate = 30; |
| if (!strcmp(mime, AMEDIA_MIMETYPE_VIDEO_H263)) mDefFrameRate = 12; |
| else if (!strcmp(mime, AMEDIA_MIMETYPE_VIDEO_MPEG4)) mDefFrameRate = 12; |
| mMaxBFrames = 0; |
| mInputData = nullptr; |
| mInputLength = 0; |
| mNumBytesSubmitted = 0; |
| mInputOffsetPts = 0; |
| } |
| |
| CodecEncoderTest::~CodecEncoderTest() { |
| deleteSource(); |
| deleteParams(); |
| } |
| |
| void CodecEncoderTest::convertyuv420ptoyuv420sp() { |
| int ySize = kInpFrmWidth * kInpFrmHeight; |
| int uSize = kInpFrmWidth * kInpFrmHeight / 4; |
| int frameSize = ySize + uSize * 2; |
| int totalFrames = mInputLength / frameSize; |
| uint8_t* u = new uint8_t[uSize]; |
| uint8_t* v = new uint8_t[uSize]; |
| uint8_t* frameBase = mInputData; |
| for (int i = 0; i < totalFrames; i++) { |
| uint8_t* uvBase = frameBase + ySize; |
| memcpy(u, uvBase, uSize); |
| memcpy(v, uvBase + uSize, uSize); |
| for (int j = 0, idx = 0; j < uSize; j++, idx += 2) { |
| uvBase[idx] = u[j]; |
| uvBase[idx + 1] = v[j]; |
| } |
| frameBase += frameSize; |
| } |
| delete[] u; |
| delete[] v; |
| } |
| |
| void CodecEncoderTest::setUpSource(const char* srcPath) { |
| FILE* fp = fopen(srcPath, "rbe"); |
| struct stat buf {}; |
| if (fp && !fstat(fileno(fp), &buf)) { |
| deleteSource(); |
| mInputLength = buf.st_size; |
| mInputData = new uint8_t[mInputLength]; |
| fread(mInputData, sizeof(uint8_t), mInputLength, fp); |
| if (mColorFormat == COLOR_FormatYUV420SemiPlanar) { |
| convertyuv420ptoyuv420sp(); |
| } |
| } else { |
| ALOGE("unable to open input file %s", srcPath); |
| } |
| if (fp) fclose(fp); |
| } |
| |
| void CodecEncoderTest::deleteSource() { |
| if (mInputData) { |
| delete[] mInputData; |
| mInputData = nullptr; |
| } |
| mInputLength = 0; |
| } |
| |
| void CodecEncoderTest::setUpParams(int limit) { |
| int count = 0; |
| for (int k = 0; k < mLen0; k++) { |
| int bitrate = mBitRates[k]; |
| if (mIsAudio) { |
| for (int j = 0; j < mLen1; j++) { |
| int rate = mEncParamList1[j]; |
| for (int i = 0; i < mLen2; i++) { |
| int channels = mEncParamList2[i]; |
| AMediaFormat* format = AMediaFormat_new(); |
| AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, mMime); |
| AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, bitrate); |
| AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, rate); |
| AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, channels); |
| mFormats.push_back(format); |
| count++; |
| if (count >= limit) break; |
| } |
| } |
| } else { |
| for (int j = 0; j < mLen1; j++) { |
| int width = mEncParamList1[j]; |
| int height = mEncParamList2[j]; |
| AMediaFormat* format = AMediaFormat_new(); |
| AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, mMime); |
| AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, bitrate); |
| AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_WIDTH, width); |
| AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_HEIGHT, height); |
| AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_FRAME_RATE, mDefFrameRate); |
| AMediaFormat_setInt32(format, TBD_AMEDIACODEC_PARAMETER_KEY_MAX_B_FRAMES, |
| mMaxBFrames); |
| AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY_I_FRAME_INTERVAL, 1.0F); |
| AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_COLOR_FORMAT, mColorFormat); |
| mFormats.push_back(format); |
| count++; |
| if (count >= limit) break; |
| } |
| } |
| } |
| } |
| |
| void CodecEncoderTest::deleteParams() { |
| for (auto format : mFormats) AMediaFormat_delete(format); |
| mFormats.clear(); |
| } |
| |
| void CodecEncoderTest::resetContext(bool isAsync, bool signalEOSWithLastFrame) { |
| CodecTestBase::resetContext(isAsync, signalEOSWithLastFrame); |
| mNumBytesSubmitted = 0; |
| mInputOffsetPts = 0; |
| mNumSyncFramesReceived = 0; |
| mSyncFramesPos.clear(); |
| } |
| |
| bool CodecEncoderTest::flushCodec() { |
| bool isOk = CodecTestBase::flushCodec(); |
| if (mIsAudio) { |
| mInputOffsetPts = (mNumBytesSubmitted + 1024) * 1000000L / (2 * mChannels * mSampleRate); |
| } else { |
| mInputOffsetPts = (mInputCount + 5) * 1000000L / mDefFrameRate; |
| } |
| mPrevOutputPts = mInputOffsetPts - 1; |
| mNumBytesSubmitted = 0; |
| mNumSyncFramesReceived = 0; |
| mSyncFramesPos.clear(); |
| return isOk; |
| } |
| |
| void CodecEncoderTest::fillByteBuffer(uint8_t* inputBuffer) { |
| int width, height, tileWidth, tileHeight; |
| int offset = 0, frmOffset = mNumBytesSubmitted; |
| int numOfPlanes; |
| if (mColorFormat == COLOR_FormatYUV420SemiPlanar) { |
| numOfPlanes = 2; |
| } else { |
| numOfPlanes = 3; |
| } |
| for (int plane = 0; plane < numOfPlanes; plane++) { |
| if (plane == 0) { |
| width = mWidth; |
| height = mHeight; |
| tileWidth = kInpFrmWidth; |
| tileHeight = kInpFrmHeight; |
| } else { |
| if (mColorFormat == COLOR_FormatYUV420SemiPlanar) { |
| width = mWidth; |
| tileWidth = kInpFrmWidth; |
| } else { |
| width = mWidth / 2; |
| tileWidth = kInpFrmWidth / 2; |
| } |
| height = mHeight / 2; |
| tileHeight = kInpFrmHeight / 2; |
| } |
| for (int k = 0; k < height; k += tileHeight) { |
| int rowsToCopy = std::min(height - k, tileHeight); |
| for (int j = 0; j < rowsToCopy; j++) { |
| for (int i = 0; i < width; i += tileWidth) { |
| int colsToCopy = std::min(width - i, tileWidth); |
| memcpy(inputBuffer + (offset + (k + j) * width + i), |
| mInputData + (frmOffset + j * tileWidth), colsToCopy); |
| } |
| } |
| } |
| offset += width * height; |
| frmOffset += tileWidth * tileHeight; |
| } |
| } |
| |
| bool CodecEncoderTest::enqueueInput(size_t bufferIndex) { |
| if (mNumBytesSubmitted >= mInputLength) { |
| return enqueueEOS(bufferIndex); |
| } else { |
| int size = 0; |
| int flags = 0; |
| int64_t pts = mInputOffsetPts; |
| size_t buffSize; |
| uint8_t* inputBuffer = AMediaCodec_getInputBuffer(mCodec, bufferIndex, &buffSize); |
| if (mIsAudio) { |
| pts += mNumBytesSubmitted * 1000000L / (2 * mChannels * mSampleRate); |
| size = std::min(buffSize, mInputLength - mNumBytesSubmitted); |
| memcpy(inputBuffer, mInputData + mNumBytesSubmitted, size); |
| if (mNumBytesSubmitted + size >= mInputLength && mSignalEOSWithLastFrame) { |
| flags |= AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM; |
| mSawInputEOS = true; |
| } |
| mNumBytesSubmitted += size; |
| } else { |
| pts += mInputCount * 1000000L / mDefFrameRate; |
| size = mWidth * mHeight * 3 / 2; |
| int frmSize = kInpFrmWidth * kInpFrmHeight * 3 / 2; |
| if (mNumBytesSubmitted + frmSize > mInputLength) { |
| ALOGE("received partial frame to encode"); |
| return false; |
| } else if (size > buffSize) { |
| ALOGE("frame size exceeds buffer capacity of input buffer %d %zu", size, buffSize); |
| return false; |
| } else { |
| if (mWidth == kInpFrmWidth && mHeight == kInpFrmHeight) { |
| memcpy(inputBuffer, mInputData + mNumBytesSubmitted, size); |
| } else { |
| fillByteBuffer(inputBuffer); |
| } |
| } |
| if (mNumBytesSubmitted + frmSize >= mInputLength && mSignalEOSWithLastFrame) { |
| flags |= AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM; |
| mSawInputEOS = true; |
| } |
| mNumBytesSubmitted += frmSize; |
| } |
| CHECK_STATUS(AMediaCodec_queueInputBuffer(mCodec, bufferIndex, 0, size, pts, flags), |
| "AMediaCodec_queueInputBuffer failed"); |
| ALOGV("input: id: %zu size: %d pts: %d flags: %d", bufferIndex, size, (int)pts, flags); |
| mOutputBuff->saveInPTS(pts); |
| mInputCount++; |
| } |
| return !hasSeenError(); |
| } |
| |
| bool CodecEncoderTest::dequeueOutput(size_t bufferIndex, AMediaCodecBufferInfo* info) { |
| if ((info->flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM) != 0) { |
| mSawOutputEOS = true; |
| } |
| if (info->size > 0) { |
| if (mSaveToMem) { |
| size_t buffSize; |
| uint8_t* buf = AMediaCodec_getOutputBuffer(mCodec, bufferIndex, &buffSize); |
| mOutputBuff->saveToMemory(buf, info); |
| } |
| if ((info->flags & TBD_AMEDIACODEC_BUFFER_FLAG_KEY_FRAME) != 0) { |
| mNumSyncFramesReceived += 1; |
| mSyncFramesPos.push_back(mOutputCount); |
| } |
| if ((info->flags & AMEDIACODEC_BUFFER_FLAG_CODEC_CONFIG) == 0) { |
| mOutputBuff->saveOutPTS(info->presentationTimeUs); |
| mOutputCount++; |
| } |
| } |
| ALOGV("output: id: %zu size: %d pts: %d flags: %d", bufferIndex, info->size, |
| (int)info->presentationTimeUs, info->flags); |
| CHECK_STATUS(AMediaCodec_releaseOutputBuffer(mCodec, bufferIndex, false), |
| "AMediaCodec_releaseOutputBuffer failed"); |
| return !hasSeenError(); |
| } |
| |
| void CodecEncoderTest::initFormat(AMediaFormat* format) { |
| if (mIsAudio) { |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &mSampleRate); |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &mChannels); |
| } else { |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &mWidth); |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &mHeight); |
| } |
| } |
| |
| bool CodecEncoderTest::encodeToMemory(const char* file, const char* encoder, int32_t frameLimit, |
| AMediaFormat* format, OutputManager* ref) { |
| /* TODO(b/149027258) */ |
| if (true) mSaveToMem = false; |
| else mSaveToMem = true; |
| mOutputBuff = ref; |
| mCodec = AMediaCodec_createCodecByName(encoder); |
| if (!mCodec) { |
| ALOGE("unable to create codec %s", encoder); |
| return false; |
| } |
| setUpSource(file); |
| if (!mInputData) return false; |
| if (!configureCodec(format, false, true, true)) return false; |
| initFormat(format); |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| if (!doWork(frameLimit)) return false; |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_STATUS(AMediaCodec_delete(mCodec), "AMediaCodec_delete failed"); |
| mCodec = nullptr; |
| mSaveToMem = false; |
| return !hasSeenError(); |
| } |
| |
| void CodecEncoderTest::forceSyncFrame(AMediaFormat* format) { |
| AMediaFormat_setInt32(format, TBD_AMEDIACODEC_PARAMETER_KEY_REQUEST_SYNC_FRAME, 0); |
| ALOGV("requesting key frame"); |
| AMediaCodec_setParameters(mCodec, format); |
| } |
| |
| void CodecEncoderTest::updateBitrate(AMediaFormat* format, int bitrate) { |
| AMediaFormat_setInt32(format, TBD_AMEDIACODEC_PARAMETER_KEY_VIDEO_BITRATE, bitrate); |
| ALOGV("requesting bitrate to be changed to %d", bitrate); |
| AMediaCodec_setParameters(mCodec, format); |
| } |
| |
| bool CodecEncoderTest::testSimpleEncode(const char* encoder, const char* srcPath) { |
| bool isPass = true; |
| setUpSource(srcPath); |
| if (!mInputData) return false; |
| setUpParams(INT32_MAX); |
| /* TODO(b/149027258) */ |
| if (true) mSaveToMem = false; |
| else mSaveToMem = true; |
| auto ref = &mRefBuff; |
| auto test = &mTestBuff; |
| const bool boolStates[]{true, false}; |
| for (int i = 0; i < mFormats.size() && isPass; i++) { |
| AMediaFormat* format = mFormats[i]; |
| initFormat(format); |
| int loopCounter = 0; |
| for (auto eosType : boolStates) { |
| if (!isPass) break; |
| for (auto isAsync : boolStates) { |
| if (!isPass) break; |
| char log[1000]; |
| snprintf(log, sizeof(log), |
| "format: %s \n codec: %s, file: %s, mode: %s, eos type: %s:: ", |
| AMediaFormat_toString(format), encoder, srcPath, |
| (isAsync ? "async" : "sync"), |
| (eosType ? "eos with last frame" : "eos separate")); |
| mOutputBuff = loopCounter == 0 ? ref : test; |
| mOutputBuff->reset(); |
| /* TODO(b/147348711) */ |
| /* Instead of create and delete codec at every iteration, we would like to create |
| * once and use it for all iterations and delete before exiting */ |
| mCodec = AMediaCodec_createCodecByName(encoder); |
| if (!mCodec) { |
| ALOGE("%s unable to create media codec by name %s", log, encoder); |
| isPass = false; |
| continue; |
| } |
| char* name = nullptr; |
| if (AMEDIA_OK == AMediaCodec_getName(mCodec, &name)) { |
| if (!name || strcmp(name, encoder) != 0) { |
| ALOGE("%s error codec-name act/got: %s/%s", log, name, encoder); |
| if (name) AMediaCodec_releaseName(mCodec, name); |
| return false; |
| } |
| } else { |
| ALOGE("AMediaCodec_getName failed unexpectedly"); |
| return false; |
| } |
| if (name) AMediaCodec_releaseName(mCodec, name); |
| if (!configureCodec(format, isAsync, eosType, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| if (!doWork(INT32_MAX)) return false; |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_STATUS(AMediaCodec_delete(mCodec), "AMediaCodec_delete failed"); |
| mCodec = nullptr; |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR((0 == mInputCount), log, "queued 0 inputs", isPass); |
| CHECK_ERR((0 == mOutputCount), log, "received 0 outputs", isPass); |
| CHECK_ERR((!mIsAudio && mInputCount != mOutputCount), log, |
| "input cnt != output cnt", isPass); |
| CHECK_ERR((loopCounter != 0 && !ref->equals(test)), log, "output is flaky", isPass); |
| CHECK_ERR((loopCounter == 0 && mIsAudio && |
| !ref->isPtsStrictlyIncreasing(mPrevOutputPts)), |
| log, "pts is not strictly increasing", isPass); |
| CHECK_ERR((loopCounter == 0 && !mIsAudio && |
| !ref->isOutPtsListIdenticalToInpPtsList(mMaxBFrames != 0)), |
| log, "input pts list and output pts list are not identical", isPass); |
| loopCounter++; |
| } |
| } |
| } |
| return isPass; |
| } |
| |
| bool CodecEncoderTest::testFlush(const char* encoder, const char* srcPath) { |
| bool isPass = true; |
| setUpSource(srcPath); |
| if (!mInputData) return false; |
| setUpParams(1); |
| mOutputBuff = &mTestBuff; |
| AMediaFormat* format = mFormats[0]; |
| initFormat(format); |
| const bool boolStates[]{true, false}; |
| for (auto isAsync : boolStates) { |
| if (!isPass) break; |
| char log[1000]; |
| snprintf(log, sizeof(log), |
| "format: %s \n codec: %s, file: %s, mode: %s:: ", AMediaFormat_toString(format), |
| encoder, srcPath, (isAsync ? "async" : "sync")); |
| /* TODO(b/147348711) */ |
| /* Instead of create and delete codec at every iteration, we would like to create |
| * once and use it for all iterations and delete before exiting */ |
| mCodec = AMediaCodec_createCodecByName(encoder); |
| if (!mCodec) { |
| ALOGE("unable to create media codec by name %s", encoder); |
| isPass = false; |
| continue; |
| } |
| if (!configureCodec(format, isAsync, true, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| |
| /* test flush in running state before queuing input */ |
| if (!flushCodec()) return false; |
| mOutputBuff->reset(); |
| if (mIsCodecInAsyncMode) { |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| } |
| if (!doWork(23)) return false; |
| CHECK_ERR((!mOutputBuff->isPtsStrictlyIncreasing(mPrevOutputPts)), log, |
| "pts is not strictly increasing", isPass); |
| if (!isPass) continue; |
| |
| /* test flush in running state */ |
| if (!flushCodec()) return false; |
| mOutputBuff->reset(); |
| if (mIsCodecInAsyncMode) { |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| } |
| if (!doWork(INT32_MAX)) return false; |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR((0 == mInputCount), log, "queued 0 inputs", isPass); |
| CHECK_ERR((0 == mOutputCount), log, "received 0 outputs", isPass); |
| CHECK_ERR((mIsAudio && !mOutputBuff->isPtsStrictlyIncreasing(mPrevOutputPts)), log, |
| "pts is not strictly increasing", isPass); |
| CHECK_ERR((!mIsAudio && mInputCount != mOutputCount), log, "input cnt != output cnt", |
| isPass); |
| CHECK_ERR((!mIsAudio && !mOutputBuff->isOutPtsListIdenticalToInpPtsList(mMaxBFrames != 0)), |
| log, "input pts list and output pts list are not identical", isPass); |
| if (!isPass) continue; |
| |
| /* test flush in eos state */ |
| if (!flushCodec()) return false; |
| mOutputBuff->reset(); |
| if (mIsCodecInAsyncMode) { |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| } |
| if (!doWork(INT32_MAX)) return false; |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR((0 == mInputCount), log, "queued 0 inputs", isPass); |
| CHECK_ERR((0 == mOutputCount), log, "received 0 outputs", isPass); |
| CHECK_ERR((mIsAudio && !mOutputBuff->isPtsStrictlyIncreasing(mPrevOutputPts)), log, |
| "pts is not strictly increasing", isPass); |
| CHECK_ERR(!mIsAudio && (mInputCount != mOutputCount), log, "input cnt != output cnt", |
| isPass); |
| CHECK_ERR(!mIsAudio && (!mOutputBuff->isOutPtsListIdenticalToInpPtsList(mMaxBFrames != 0)), |
| log, "input pts list and output pts list are not identical", isPass); |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_STATUS(AMediaCodec_delete(mCodec), "AMediaCodec_delete failed"); |
| mCodec = nullptr; |
| } |
| return isPass; |
| } |
| |
| bool CodecEncoderTest::testReconfigure(const char* encoder, const char* srcPath) { |
| bool isPass = true; |
| setUpSource(srcPath); |
| if (!mInputData) return false; |
| setUpParams(2); |
| auto configRef = &mReconfBuff; |
| if (mFormats.size() > 1) { |
| auto format = mFormats[1]; |
| if (!encodeToMemory(srcPath, encoder, INT32_MAX, format, configRef)) { |
| ALOGE("encodeToMemory failed for file: %s codec: %s \n format: %s", srcPath, encoder, |
| AMediaFormat_toString(format)); |
| return false; |
| } |
| CHECK_ERR(mIsAudio && (!configRef->isPtsStrictlyIncreasing(mPrevOutputPts)), "", |
| "pts is not strictly increasing", isPass); |
| CHECK_ERR(!mIsAudio && (!configRef->isOutPtsListIdenticalToInpPtsList(mMaxBFrames != 0)), |
| "", "input pts list and output pts list are not identical", isPass); |
| if (!isPass) return false; |
| } |
| auto format = mFormats[0]; |
| auto ref = &mRefBuff; |
| if (!encodeToMemory(srcPath, encoder, INT32_MAX, format, ref)) { |
| ALOGE("encodeToMemory failed for file: %s codec: %s \n format: %s", srcPath, encoder, |
| AMediaFormat_toString(format)); |
| return false; |
| } |
| CHECK_ERR(mIsAudio && (!ref->isPtsStrictlyIncreasing(mPrevOutputPts)), "", |
| "pts is not strictly increasing", isPass); |
| CHECK_ERR(!mIsAudio && (!ref->isOutPtsListIdenticalToInpPtsList(mMaxBFrames != 0)), "", |
| "input pts list and output pts list are not identical", isPass); |
| if (!isPass) return false; |
| |
| auto test = &mTestBuff; |
| mOutputBuff = test; |
| const bool boolStates[]{true, false}; |
| for (auto isAsync : boolStates) { |
| if (!isPass) break; |
| char log[1000]; |
| snprintf(log, sizeof(log), |
| "format: %s \n codec: %s, file: %s, mode: %s:: ", AMediaFormat_toString(format), |
| encoder, srcPath, (isAsync ? "async" : "sync")); |
| /* TODO(b/147348711) */ |
| /* Instead of create and delete codec at every iteration, we would like to create |
| * once and use it for all iterations and delete before exiting */ |
| mCodec = AMediaCodec_createCodecByName(encoder); |
| if (!mCodec) { |
| ALOGE("%s unable to create media codec by name %s", log, encoder); |
| isPass = false; |
| continue; |
| } |
| if (!configureCodec(format, isAsync, true, true)) return false; |
| /* test reconfigure in init state */ |
| if (!reConfigureCodec(format, !isAsync, false, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| |
| /* test reconfigure in running state before queuing input */ |
| if (!reConfigureCodec(format, !isAsync, false, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| if (!doWork(23)) return false; |
| |
| /* test reconfigure codec in running state */ |
| if (!reConfigureCodec(format, isAsync, true, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| |
| /* TODO(b/149027258) */ |
| if (true) mSaveToMem = false; |
| else mSaveToMem = true; |
| test->reset(); |
| if (!doWork(INT32_MAX)) return false; |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR((0 == mInputCount), log, "queued 0 inputs", isPass); |
| CHECK_ERR((0 == mOutputCount), log, "received 0 outputs", isPass); |
| CHECK_ERR((!mIsAudio && mInputCount != mOutputCount), log, "input cnt != output cnt", |
| isPass); |
| CHECK_ERR((!ref->equals(test)), log, "output is flaky", isPass); |
| if (!isPass) continue; |
| |
| /* test reconfigure codec at eos state */ |
| if (!reConfigureCodec(format, !isAsync, false, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| test->reset(); |
| if (!doWork(INT32_MAX)) return false; |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR((0 == mInputCount), log, "queued 0 inputs", isPass); |
| CHECK_ERR((0 == mOutputCount), log, "received 0 outputs", isPass); |
| CHECK_ERR((!mIsAudio && mInputCount != mOutputCount), log, "input cnt != output cnt", |
| isPass); |
| CHECK_ERR((!ref->equals(test)), log, "output is flaky", isPass); |
| |
| /* test reconfigure codec for new format */ |
| if (mFormats.size() > 1) { |
| if (!reConfigureCodec(mFormats[1], isAsync, false, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| test->reset(); |
| if (!doWork(INT32_MAX)) return false; |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR((0 == mInputCount), log, "queued 0 inputs", isPass); |
| CHECK_ERR((0 == mOutputCount), log, "received 0 outputs", isPass); |
| CHECK_ERR((!mIsAudio && mInputCount != mOutputCount), log, "input cnt != output cnt", |
| isPass); |
| CHECK_ERR((!configRef->equals(test)), log, "output is flaky", isPass); |
| } |
| mSaveToMem = false; |
| CHECK_STATUS(AMediaCodec_delete(mCodec), "AMediaCodec_delete failed"); |
| mCodec = nullptr; |
| } |
| return isPass; |
| } |
| |
| bool CodecEncoderTest::testOnlyEos(const char* encoder) { |
| bool isPass = true; |
| setUpParams(1); |
| /* TODO(b/149027258) */ |
| if (true) mSaveToMem = false; |
| else mSaveToMem = true; |
| auto ref = &mRefBuff; |
| auto test = &mTestBuff; |
| const bool boolStates[]{true, false}; |
| AMediaFormat* format = mFormats[0]; |
| int loopCounter = 0; |
| for (int k = 0; (k < (sizeof(boolStates) / sizeof(boolStates[0]))) && isPass; k++) { |
| bool isAsync = boolStates[k]; |
| char log[1000]; |
| snprintf(log, sizeof(log), |
| "format: %s \n codec: %s, mode: %s:: ", AMediaFormat_toString(format), encoder, |
| (isAsync ? "async" : "sync")); |
| mOutputBuff = loopCounter == 0 ? ref : test; |
| mOutputBuff->reset(); |
| /* TODO(b/147348711) */ |
| /* Instead of create and delete codec at every iteration, we would like to create |
| * once and use it for all iterations and delete before exiting */ |
| mCodec = AMediaCodec_createCodecByName(encoder); |
| if (!mCodec) { |
| ALOGE("unable to create media codec by name %s", encoder); |
| isPass = false; |
| continue; |
| } |
| if (!configureCodec(format, isAsync, false, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_STATUS(AMediaCodec_delete(mCodec), "AMediaCodec_delete failed"); |
| mCodec = nullptr; |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR(loopCounter != 0 && (!ref->equals(test)), log, "output is flaky", isPass); |
| CHECK_ERR(loopCounter == 0 && mIsAudio && (!ref->isPtsStrictlyIncreasing(mPrevOutputPts)), |
| log, "pts is not strictly increasing", isPass); |
| CHECK_ERR(loopCounter == 0 && !mIsAudio && |
| (!ref->isOutPtsListIdenticalToInpPtsList(mMaxBFrames != 0)), |
| log, "input pts list and output pts list are not identical", isPass); |
| loopCounter++; |
| } |
| return isPass; |
| } |
| |
| bool CodecEncoderTest::testSetForceSyncFrame(const char* encoder, const char* srcPath) { |
| bool isPass = true; |
| setUpSource(srcPath); |
| if (!mInputData) return false; |
| setUpParams(1); |
| AMediaFormat* format = mFormats[0]; |
| AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY_I_FRAME_INTERVAL, 500.f); |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &mWidth); |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &mHeight); |
| // Maximum allowed key frame interval variation from the target value. |
| int kMaxKeyFrameIntervalVariation = 3; |
| int kKeyFrameInterval = 2; // force key frame every 2 seconds. |
| int kKeyFramePos = mDefFrameRate * kKeyFrameInterval; |
| int kNumKeyFrameRequests = 7; |
| AMediaFormat* params = AMediaFormat_new(); |
| mFormats.push_back(params); |
| mOutputBuff = &mTestBuff; |
| const bool boolStates[]{true, false}; |
| for (auto isAsync : boolStates) { |
| if (!isPass) break; |
| char log[1000]; |
| snprintf(log, sizeof(log), |
| "format: %s \n codec: %s, file: %s, mode: %s:: ", AMediaFormat_toString(format), |
| encoder, srcPath, (isAsync ? "async" : "sync")); |
| mOutputBuff->reset(); |
| /* TODO(b/147348711) */ |
| /* Instead of create and delete codec at every iteration, we would like to create |
| * once and use it for all iterations and delete before exiting */ |
| mCodec = AMediaCodec_createCodecByName(encoder); |
| if (!mCodec) { |
| ALOGE("%s unable to create media codec by name %s", log, encoder); |
| isPass = false; |
| continue; |
| } |
| if (!configureCodec(format, isAsync, false, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| for (int i = 0; i < kNumKeyFrameRequests; i++) { |
| if (!doWork(kKeyFramePos)) return false; |
| assert(!mSawInputEOS); |
| forceSyncFrame(params); |
| mNumBytesSubmitted = 0; |
| } |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_STATUS(AMediaCodec_delete(mCodec), "AMediaCodec_delete failed"); |
| mCodec = nullptr; |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR((0 == mInputCount), log, "queued 0 inputs", isPass); |
| CHECK_ERR((0 == mOutputCount), log, "received 0 outputs", isPass); |
| CHECK_ERR((!mIsAudio && mInputCount != mOutputCount), log, "input cnt != output cnt", |
| isPass); |
| CHECK_ERR((!mOutputBuff->isOutPtsListIdenticalToInpPtsList(mMaxBFrames != 0)), log, |
| "input pts list and output pts list are not identical", isPass); |
| CHECK_ERR((mNumSyncFramesReceived < kNumKeyFrameRequests), log, |
| "Num Sync Frames Received != Num Key Frame Requested", isPass); |
| ALOGD("mNumSyncFramesReceived %d", mNumSyncFramesReceived); |
| for (int i = 0, expPos = 0, index = 0; i < kNumKeyFrameRequests; i++) { |
| int j = index; |
| for (; j < mSyncFramesPos.size(); j++) { |
| // Check key frame intervals: |
| // key frame position should not be greater than target value + 3 |
| // key frame position should not be less than target value - 3 |
| if (abs(expPos - mSyncFramesPos.at(j)) <= kMaxKeyFrameIntervalVariation) { |
| index = j; |
| break; |
| } |
| } |
| if (j == mSyncFramesPos.size()) { |
| ALOGW("requested key frame at frame index %d none found near by", expPos); |
| } |
| expPos += kKeyFramePos; |
| } |
| } |
| return isPass; |
| } |
| |
| bool CodecEncoderTest::testAdaptiveBitRate(const char* encoder, const char* srcPath) { |
| bool isPass = true; |
| setUpSource(srcPath); |
| if (!mInputData) return false; |
| setUpParams(1); |
| AMediaFormat* format = mFormats[0]; |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &mWidth); |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &mHeight); |
| int kAdaptiveBitrateInterval = 3; // change bitrate every 3 seconds. |
| int kAdaptiveBitrateDurationFrame = mDefFrameRate * kAdaptiveBitrateInterval; |
| int kBitrateChangeRequests = 7; |
| AMediaFormat* params = AMediaFormat_new(); |
| mFormats.push_back(params); |
| // Setting in CBR Mode |
| AMediaFormat_setInt32(format, TBD_AMEDIAFORMAT_KEY_BIT_RATE_MODE, kBitrateModeConstant); |
| mOutputBuff = &mTestBuff; |
| mSaveToMem = true; |
| const bool boolStates[]{true, false}; |
| for (auto isAsync : boolStates) { |
| if (!isPass) break; |
| char log[1000]; |
| snprintf(log, sizeof(log), |
| "format: %s \n codec: %s, file: %s, mode: %s:: ", AMediaFormat_toString(format), |
| encoder, srcPath, (isAsync ? "async" : "sync")); |
| mOutputBuff->reset(); |
| /* TODO(b/147348711) */ |
| /* Instead of create and delete codec at every iteration, we would like to create |
| * once and use it for all iterations and delete before exiting */ |
| mCodec = AMediaCodec_createCodecByName(encoder); |
| if (!mCodec) { |
| ALOGE("%s unable to create media codec by name %s", log, encoder); |
| isPass = false; |
| continue; |
| } |
| if (!configureCodec(format, isAsync, false, true)) return false; |
| CHECK_STATUS(AMediaCodec_start(mCodec), "AMediaCodec_start failed"); |
| int expOutSize = 0; |
| int bitrate; |
| AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, &bitrate); |
| for (int i = 0; i < kBitrateChangeRequests; i++) { |
| if (!doWork(kAdaptiveBitrateDurationFrame)) return false; |
| assert(!mSawInputEOS); |
| expOutSize += kAdaptiveBitrateInterval * bitrate; |
| if ((i & 1) == 1) bitrate *= 2; |
| else bitrate /= 2; |
| updateBitrate(params, bitrate); |
| mNumBytesSubmitted = 0; |
| } |
| if (!queueEOS()) return false; |
| if (!waitForAllOutputs()) return false; |
| CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed"); |
| CHECK_STATUS(AMediaCodec_delete(mCodec), "AMediaCodec_delete failed"); |
| mCodec = nullptr; |
| CHECK_ERR((hasSeenError()), log, "has seen error", isPass); |
| CHECK_ERR((0 == mInputCount), log, "queued 0 inputs", isPass); |
| CHECK_ERR((0 == mOutputCount), log, "received 0 outputs", isPass); |
| CHECK_ERR((!mIsAudio && mInputCount != mOutputCount), log, "input cnt != output cnt", |
| isPass); |
| CHECK_ERR((!mOutputBuff->isOutPtsListIdenticalToInpPtsList(mMaxBFrames != 0)), log, |
| "input pts list and output pts list are not identical", isPass); |
| /* TODO: validate output br with sliding window constraints Sec 5.2 cdd */ |
| int outSize = mOutputBuff->getOutStreamSize() * 8; |
| float brDev = abs(expOutSize - outSize) * 100.0f / expOutSize; |
| ALOGD("%s relative bitrate error is %f %%", log, brDev); |
| if (brDev > 50) { |
| ALOGE("%s relative bitrate error is is too large %f %%", log, brDev); |
| return false; |
| } |
| } |
| return isPass; |
| } |
| |
| static jboolean nativeTestSimpleEncode(JNIEnv* env, jobject, jstring jEncoder, jstring jsrcPath, |
| jstring jMime, jintArray jList0, jintArray jList1, |
| jintArray jList2, jint colorFormat) { |
| const char* csrcPath = env->GetStringUTFChars(jsrcPath, nullptr); |
| const char* cmime = env->GetStringUTFChars(jMime, nullptr); |
| const char* cEncoder = env->GetStringUTFChars(jEncoder, nullptr); |
| jsize cLen0 = env->GetArrayLength(jList0); |
| jint* cList0 = env->GetIntArrayElements(jList0, nullptr); |
| jsize cLen1 = env->GetArrayLength(jList1); |
| jint* cList1 = env->GetIntArrayElements(jList1, nullptr); |
| jsize cLen2 = env->GetArrayLength(jList2); |
| jint* cList2 = env->GetIntArrayElements(jList2, nullptr); |
| auto codecEncoderTest = new CodecEncoderTest(cmime, cList0, cLen0, cList1, cLen1, cList2, cLen2, |
| (int)colorFormat); |
| bool isPass = codecEncoderTest->testSimpleEncode(cEncoder, csrcPath); |
| delete codecEncoderTest; |
| env->ReleaseIntArrayElements(jList0, cList0, 0); |
| env->ReleaseIntArrayElements(jList1, cList1, 0); |
| env->ReleaseIntArrayElements(jList2, cList2, 0); |
| env->ReleaseStringUTFChars(jEncoder, cEncoder); |
| env->ReleaseStringUTFChars(jMime, cmime); |
| env->ReleaseStringUTFChars(jsrcPath, csrcPath); |
| return static_cast<jboolean>(isPass); |
| } |
| |
| static jboolean nativeTestFlush(JNIEnv* env, jobject, jstring jEncoder, jstring jsrcPath, |
| jstring jMime, jintArray jList0, jintArray jList1, jintArray jList2, |
| jint colorFormat) { |
| const char* csrcPath = env->GetStringUTFChars(jsrcPath, nullptr); |
| const char* cmime = env->GetStringUTFChars(jMime, nullptr); |
| const char* cEncoder = env->GetStringUTFChars(jEncoder, nullptr); |
| jsize cLen0 = env->GetArrayLength(jList0); |
| jint* cList0 = env->GetIntArrayElements(jList0, nullptr); |
| jsize cLen1 = env->GetArrayLength(jList1); |
| jint* cList1 = env->GetIntArrayElements(jList1, nullptr); |
| jsize cLen2 = env->GetArrayLength(jList2); |
| jint* cList2 = env->GetIntArrayElements(jList2, nullptr); |
| auto codecEncoderTest = new CodecEncoderTest(cmime, cList0, cLen0, cList1, cLen1, cList2, cLen2, |
| (int)colorFormat); |
| bool isPass = codecEncoderTest->testFlush(cEncoder, csrcPath); |
| delete codecEncoderTest; |
| env->ReleaseIntArrayElements(jList0, cList0, 0); |
| env->ReleaseIntArrayElements(jList1, cList1, 0); |
| env->ReleaseIntArrayElements(jList2, cList2, 0); |
| env->ReleaseStringUTFChars(jEncoder, cEncoder); |
| env->ReleaseStringUTFChars(jMime, cmime); |
| env->ReleaseStringUTFChars(jsrcPath, csrcPath); |
| return static_cast<jboolean>(isPass); |
| } |
| |
| static jboolean nativeTestReconfigure(JNIEnv* env, jobject, jstring jEncoder, jstring jsrcPath, |
| jstring jMime, jintArray jList0, jintArray jList1, |
| jintArray jList2, jint colorFormat) { |
| bool isPass; |
| const char* csrcPath = env->GetStringUTFChars(jsrcPath, nullptr); |
| const char* cmime = env->GetStringUTFChars(jMime, nullptr); |
| const char* cEncoder = env->GetStringUTFChars(jEncoder, nullptr); |
| jsize cLen0 = env->GetArrayLength(jList0); |
| jint* cList0 = env->GetIntArrayElements(jList0, nullptr); |
| jsize cLen1 = env->GetArrayLength(jList1); |
| jint* cList1 = env->GetIntArrayElements(jList1, nullptr); |
| jsize cLen2 = env->GetArrayLength(jList2); |
| jint* cList2 = env->GetIntArrayElements(jList2, nullptr); |
| auto codecEncoderTest = new CodecEncoderTest(cmime, cList0, cLen0, cList1, cLen1, cList2, cLen2, |
| (int)colorFormat); |
| isPass = codecEncoderTest->testReconfigure(cEncoder, csrcPath); |
| delete codecEncoderTest; |
| env->ReleaseIntArrayElements(jList0, cList0, 0); |
| env->ReleaseIntArrayElements(jList1, cList1, 0); |
| env->ReleaseIntArrayElements(jList2, cList2, 0); |
| env->ReleaseStringUTFChars(jEncoder, cEncoder); |
| env->ReleaseStringUTFChars(jMime, cmime); |
| env->ReleaseStringUTFChars(jsrcPath, csrcPath); |
| return static_cast<jboolean>(isPass); |
| } |
| |
| static jboolean nativeTestSetForceSyncFrame(JNIEnv* env, jobject, jstring jEncoder, |
| jstring jsrcPath, jstring jMime, jintArray jList0, |
| jintArray jList1, jintArray jList2, jint colorFormat) { |
| const char* csrcPath = env->GetStringUTFChars(jsrcPath, nullptr); |
| const char* cmime = env->GetStringUTFChars(jMime, nullptr); |
| const char* cEncoder = env->GetStringUTFChars(jEncoder, nullptr); |
| jsize cLen0 = env->GetArrayLength(jList0); |
| jint* cList0 = env->GetIntArrayElements(jList0, nullptr); |
| jsize cLen1 = env->GetArrayLength(jList1); |
| jint* cList1 = env->GetIntArrayElements(jList1, nullptr); |
| jsize cLen2 = env->GetArrayLength(jList2); |
| jint* cList2 = env->GetIntArrayElements(jList2, nullptr); |
| auto codecEncoderTest = new CodecEncoderTest(cmime, cList0, cLen0, cList1, cLen1, cList2, cLen2, |
| (int)colorFormat); |
| bool isPass = codecEncoderTest->testSetForceSyncFrame(cEncoder, csrcPath); |
| delete codecEncoderTest; |
| env->ReleaseIntArrayElements(jList0, cList0, 0); |
| env->ReleaseIntArrayElements(jList1, cList1, 0); |
| env->ReleaseIntArrayElements(jList2, cList2, 0); |
| env->ReleaseStringUTFChars(jEncoder, cEncoder); |
| env->ReleaseStringUTFChars(jMime, cmime); |
| env->ReleaseStringUTFChars(jsrcPath, csrcPath); |
| return static_cast<jboolean>(isPass); |
| } |
| |
| static jboolean nativeTestAdaptiveBitRate(JNIEnv* env, jobject, jstring jEncoder, jstring jsrcPath, |
| jstring jMime, jintArray jList0, jintArray jList1, |
| jintArray jList2, jint colorFormat) { |
| const char* csrcPath = env->GetStringUTFChars(jsrcPath, nullptr); |
| const char* cmime = env->GetStringUTFChars(jMime, nullptr); |
| const char* cEncoder = env->GetStringUTFChars(jEncoder, nullptr); |
| jsize cLen0 = env->GetArrayLength(jList0); |
| jint* cList0 = env->GetIntArrayElements(jList0, nullptr); |
| jsize cLen1 = env->GetArrayLength(jList1); |
| jint* cList1 = env->GetIntArrayElements(jList1, nullptr); |
| jsize cLen2 = env->GetArrayLength(jList2); |
| jint* cList2 = env->GetIntArrayElements(jList2, nullptr); |
| auto codecEncoderTest = new CodecEncoderTest(cmime, cList0, cLen0, cList1, cLen1, cList2, cLen2, |
| (int)colorFormat); |
| bool isPass = codecEncoderTest->testAdaptiveBitRate(cEncoder, csrcPath); |
| delete codecEncoderTest; |
| env->ReleaseIntArrayElements(jList0, cList0, 0); |
| env->ReleaseIntArrayElements(jList1, cList1, 0); |
| env->ReleaseIntArrayElements(jList2, cList2, 0); |
| env->ReleaseStringUTFChars(jEncoder, cEncoder); |
| env->ReleaseStringUTFChars(jMime, cmime); |
| env->ReleaseStringUTFChars(jsrcPath, csrcPath); |
| return static_cast<jboolean>(isPass); |
| } |
| |
| static jboolean nativeTestOnlyEos(JNIEnv* env, jobject, jstring jEncoder, jstring jMime, |
| jintArray jList0, jintArray jList1, jintArray jList2, |
| jint colorFormat) { |
| const char* cmime = env->GetStringUTFChars(jMime, nullptr); |
| const char* cEncoder = env->GetStringUTFChars(jEncoder, nullptr); |
| jsize cLen0 = env->GetArrayLength(jList0); |
| jint* cList0 = env->GetIntArrayElements(jList0, nullptr); |
| jsize cLen1 = env->GetArrayLength(jList1); |
| jint* cList1 = env->GetIntArrayElements(jList1, nullptr); |
| jsize cLen2 = env->GetArrayLength(jList2); |
| jint* cList2 = env->GetIntArrayElements(jList2, nullptr); |
| auto codecEncoderTest = new CodecEncoderTest(cmime, cList0, cLen0, cList1, cLen1, cList2, cLen2, |
| (int)colorFormat); |
| bool isPass = codecEncoderTest->testOnlyEos(cEncoder); |
| delete codecEncoderTest; |
| env->ReleaseIntArrayElements(jList0, cList0, 0); |
| env->ReleaseIntArrayElements(jList1, cList1, 0); |
| env->ReleaseIntArrayElements(jList2, cList2, 0); |
| env->ReleaseStringUTFChars(jEncoder, cEncoder); |
| env->ReleaseStringUTFChars(jMime, cmime); |
| return static_cast<jboolean>(isPass); |
| } |
| |
| int registerAndroidMediaV2CtsEncoderTest(JNIEnv* env) { |
| const JNINativeMethod methodTable[] = { |
| {"nativeTestSimpleEncode", |
| "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[I[I[II)Z", |
| (void*)nativeTestSimpleEncode}, |
| {"nativeTestFlush", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[I[I[II)Z", |
| (void*)nativeTestFlush}, |
| {"nativeTestReconfigure", |
| "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[I[I[II)Z", |
| (void*)nativeTestReconfigure}, |
| {"nativeTestSetForceSyncFrame", |
| "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[I[I[II)Z", |
| (void*)nativeTestSetForceSyncFrame}, |
| {"nativeTestAdaptiveBitRate", |
| "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[I[I[II)Z", |
| (void*)nativeTestAdaptiveBitRate}, |
| {"nativeTestOnlyEos", "(Ljava/lang/String;Ljava/lang/String;[I[I[II)Z", |
| (void*)nativeTestOnlyEos}, |
| }; |
| jclass c = env->FindClass("android/mediav2/cts/CodecEncoderTest"); |
| return env->RegisterNatives(c, methodTable, sizeof(methodTable) / sizeof(JNINativeMethod)); |
| } |
| |
| extern int registerAndroidMediaV2CtsCodecUnitTest(JNIEnv* env); |
| extern int registerAndroidMediaV2CtsDecoderTest(JNIEnv* env); |
| extern int registerAndroidMediaV2CtsDecoderSurfaceTest(JNIEnv* env); |
| extern int registerAndroidMediaV2CtsEncoderSurfaceTest(JNIEnv* env); |
| |
| extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) { |
| JNIEnv* env; |
| if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) return JNI_ERR; |
| if (registerAndroidMediaV2CtsCodecUnitTest(env) != JNI_OK) return JNI_ERR; |
| if (registerAndroidMediaV2CtsEncoderTest(env) != JNI_OK) return JNI_ERR; |
| if (registerAndroidMediaV2CtsDecoderTest(env) != JNI_OK) return JNI_ERR; |
| if (registerAndroidMediaV2CtsDecoderSurfaceTest(env) != JNI_OK) return JNI_ERR; |
| if (registerAndroidMediaV2CtsEncoderSurfaceTest(env) != JNI_OK) return JNI_ERR; |
| return JNI_VERSION_1_6; |
| } |
