tests/media/jni/NativeCodecTestBase.cpp - platform/cts - Git at Google

 /*
  * 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 "NativeCodecTestBase"
 #include <log/log.h>

 #include "NativeCodecTestBase.h"

 static void onAsyncInputAvailable(AMediaCodec* codec, void* userdata, int32_t index) {
     (void)codec;
     assert(index >= 0);
     auto* aSyncHandle = static_cast<CodecAsyncHandler*>(userdata);
     callbackObject element{index};
     aSyncHandle->pushToInputList(element);
 }

 static void onAsyncOutputAvailable(AMediaCodec* codec, void* userdata, int32_t index,
                                    AMediaCodecBufferInfo* bufferInfo) {
     (void)codec;
     assert(index >= 0);
     auto* aSyncHandle = static_cast<CodecAsyncHandler*>(userdata);
     callbackObject element{index, bufferInfo};
     aSyncHandle->pushToOutputList(element);
 }

 static void onAsyncFormatChanged(AMediaCodec* codec, void* userdata, AMediaFormat* format) {
     (void)codec;
     auto* aSyncHandle = static_cast<CodecAsyncHandler*>(userdata);
     aSyncHandle->setOutputFormat(format);
     ALOGI("Output format changed: %s", AMediaFormat_toString(format));
 }

 static void onAsyncError(AMediaCodec* codec, void* userdata, media_status_t error,
                          int32_t actionCode, const char* detail) {
     (void)codec;
     auto* aSyncHandle = static_cast<CodecAsyncHandler*>(userdata);
     aSyncHandle->setError(true);
     ALOGE("received media codec error: %s , code : %d , action code: %d ", detail, error,
           actionCode);
 }

 CodecAsyncHandler::CodecAsyncHandler() {
     mOutFormat = nullptr;
     mSignalledOutFormatChanged = false;
     mSignalledError = false;
 }

 CodecAsyncHandler::~CodecAsyncHandler() {
     if (mOutFormat) {
         AMediaFormat_delete(mOutFormat);
         mOutFormat = nullptr;
     }
 }

 void CodecAsyncHandler::pushToInputList(callbackObject element) {
     std::unique_lock<std::mutex> lock{mMutex};
     mCbInputQueue.push_back(element);
     mCondition.notify_all();
 }

 void CodecAsyncHandler::pushToOutputList(callbackObject element) {
     std::unique_lock<std::mutex> lock{mMutex};
     mCbOutputQueue.push_back(element);
     mCondition.notify_all();
 }

 callbackObject CodecAsyncHandler::getInput() {
     callbackObject element{-1};
     std::unique_lock<std::mutex> lock{mMutex};
     while (!mSignalledError) {
         if (mCbInputQueue.empty()) {
             mCondition.wait(lock);
         } else {
             element = mCbInputQueue.front();
             mCbInputQueue.pop_front();
             break;
         }
     }
     return element;
 }

 callbackObject CodecAsyncHandler::getOutput() {
     callbackObject element;
     std::unique_lock<std::mutex> lock{mMutex};
     while (!mSignalledError) {
         if (mCbOutputQueue.empty()) {
             mCondition.wait(lock);
         } else {
             element = mCbOutputQueue.front();
             mCbOutputQueue.pop_front();
             break;
         }
     }
     return element;
 }

 callbackObject CodecAsyncHandler::getWork() {
     callbackObject element;
     std::unique_lock<std::mutex> lock{mMutex};
     while (!mSignalledError) {
         if (mCbInputQueue.empty() && mCbOutputQueue.empty()) {
             mCondition.wait(lock);
         } else {
             if (!mCbOutputQueue.empty()) {
                 element = mCbOutputQueue.front();
                 mCbOutputQueue.pop_front();
                 break;
             } else {
                 element = mCbInputQueue.front();
                 mCbInputQueue.pop_front();
                 break;
             }
         }
     }
     return element;
 }

 bool CodecAsyncHandler::isInputQueueEmpty() {
     std::unique_lock<std::mutex> lock{mMutex};
     return mCbInputQueue.empty();
 }

 void CodecAsyncHandler::clearQueues() {
     std::unique_lock<std::mutex> lock{mMutex};
     mCbInputQueue.clear();
     mCbOutputQueue.clear();
 }

 void CodecAsyncHandler::setOutputFormat(AMediaFormat* format) {
     assert(format != nullptr);
     if (mOutFormat) {
         AMediaFormat_delete(mOutFormat);
         mOutFormat = nullptr;
     }
     mOutFormat = format;
     mSignalledOutFormatChanged = true;
 }

 AMediaFormat* CodecAsyncHandler::getOutputFormat() {
     return mOutFormat;
 }

 bool CodecAsyncHandler::hasOutputFormatChanged() {
     return mSignalledOutFormatChanged;
 }

 void CodecAsyncHandler::setError(bool status) {
     std::unique_lock<std::mutex> lock{mMutex};
     mSignalledError = status;
     mCondition.notify_all();
 }

 bool CodecAsyncHandler::getError() {
     return mSignalledError;
 }

 void CodecAsyncHandler::resetContext() {
     clearQueues();
     if (mOutFormat) {
         AMediaFormat_delete(mOutFormat);
         mOutFormat = nullptr;
     }
     mSignalledOutFormatChanged = false;
     mSignalledError = false;
 }

 media_status_t CodecAsyncHandler::setCallBack(AMediaCodec* codec, bool isCodecInAsyncMode) {
     media_status_t status = AMEDIA_OK;
     if (isCodecInAsyncMode) {
         AMediaCodecOnAsyncNotifyCallback callBack = {onAsyncInputAvailable, onAsyncOutputAvailable,
                                                      onAsyncFormatChanged, onAsyncError};
         status = AMediaCodec_setAsyncNotifyCallback(codec, callBack, this);
     }
     return status;
 }

 uint32_t OutputManager::adler32(const uint8_t* input, int offset, int len) {
     constexpr uint32_t modAdler = 65521;
     constexpr uint32_t overflowLimit = 5500;
     uint32_t a = 1;
     uint32_t b = 0;
     for (int i = offset, count = 0; i < len; i++) {
         a += input[i];
         b += a;
         count++;
         if (count > overflowLimit) {
             a %= modAdler;
             b %= modAdler;
             count = 0;
         }
     }
     return b * 65536 + a;
 }

 bool OutputManager::isPtsStrictlyIncreasing(int64_t lastPts) {
     bool result = true;
     for (auto it1 = outPtsArray.cbegin(); it1 < outPtsArray.cend(); it1++) {
         if (lastPts < *it1) {
             lastPts = *it1;
         } else {
             ALOGE("Timestamp ordering check failed: last timestamp: %d / current timestamp: %d",
                   (int)lastPts, (int)*it1);
             result = false;
             break;
         }
     }
     return result;
 }

 bool OutputManager::isOutPtsListIdenticalToInpPtsList(bool requireSorting) {
     bool isEqual = true;
     std::sort(inpPtsArray.begin(), inpPtsArray.end());
     if (requireSorting) {
         std::sort(outPtsArray.begin(), outPtsArray.end());
     }
     if (outPtsArray != inpPtsArray) {
         if (outPtsArray.size() != inpPtsArray.size()) {
             ALOGE("input and output presentation timestamp list sizes are not identical sizes "
                   "exp/rec %d/%d", (int)inpPtsArray.size(), (int)outPtsArray.size());
             isEqual = false;
         } else {
             int count = 0;
             for (auto it1 = outPtsArray.cbegin(), it2 = inpPtsArray.cbegin();
                  it1 < outPtsArray.cend(); it1++, it2++) {
                 if (*it1 != *it2) {
                     ALOGE("input output pts mismatch, exp/rec %d/%d", (int)*it2, (int)*it1);
                     count++;
                 }
                 if (count == 20) {
                     ALOGE("stopping after 20 mismatches ... ");
                     break;
                 }
             }
             if (count != 0) isEqual = false;
         }
     }
     return isEqual;
 }

 bool OutputManager::equals(const OutputManager* that) {
     if (this == that) return true;
     if (outPtsArray != that->outPtsArray) {
         if (outPtsArray.size() != that->outPtsArray.size()) {
             ALOGE("ref and test outputs presentation timestamp arrays are of unequal sizes %d, %d",
                   (int)outPtsArray.size(), (int)that->outPtsArray.size());
             return false;
         } else {
             int count = 0;
             for (auto it1 = outPtsArray.cbegin(), it2 = that->outPtsArray.cbegin();
                  it1 < outPtsArray.cend(); it1++, it2++) {
                 if (*it1 != *it2) {
                     ALOGE("presentation timestamp exp/rec %d/%d", (int)*it1, (int)*it2);
                     count++;
                 }
                 if (count == 20) {
                     ALOGE("stopping after 20 mismatches ... ");
                     break;
                 }
             }
             if (count != 0) return false;
         }
     }
     if (memory != that->memory) {
         if (memory.size() != that->memory.size()) {
             ALOGE("ref and test outputs decoded buffer are of unequal sizes %d, %d",
                   (int)memory.size(), (int)that->memory.size());
             return false;
         } else {
             int count = 0;
             for (auto it1 = memory.cbegin(), it2 = that->memory.cbegin(); it1 < memory.cend();
                  it1++, it2++) {
                 if (*it1 != *it2) {
                     ALOGE("decoded sample exp/rec %d/%d", (int)*it1, (int)*it2);
                     count++;
                 }
                 if (count == 20) {
                     ALOGE("stopping after 20 mismatches ... ");
                     break;
                 }
             }
             if (count != 0) return false;
         }
     }
     if (checksum != that->checksum) {
         if (checksum.size() != that->checksum.size()) {
             ALOGE("ref and test outputs checksum arrays are of unequal sizes %d, %d",
                   (int)checksum.size(), (int)that->checksum.size());
             return false;
         } else {
             int count = 0;
             for (auto it1 = checksum.cbegin(), it2 = that->checksum.cbegin(); it1 < checksum.cend();
                  it1++, it2++) {
                 if (*it1 != *it2) {
                     ALOGE("adler32 checksum exp/rec %u/%u", (int)*it1, (int)*it2);
                     count++;
                 }
                 if (count == 20) {
                     ALOGE("stopping after 20 mismatches ... ");
                     break;
                 }
             }
             if (count != 0) return false;
         }
     }
     return true;
 }

 float OutputManager::getRmsError(uint8_t* refData, int length) {
     long totalErrorSquared = 0;
     if (length != memory.size()) return -1.0F;
     if ((length % 2) != 0) return -1.0F;
     auto* testData = new uint8_t[length];
     std::copy(memory.begin(), memory.end(), testData);
     auto* testDataReinterpret = reinterpret_cast<int16_t*>(testData);
     auto* refDataReinterpret = reinterpret_cast<int16_t*>(refData);
     for (int i = 0; i < length / 2; i++) {
         int d = testDataReinterpret[i] - refDataReinterpret[i];
         totalErrorSquared += d * d;
     }
     delete[] testData;
     long avgErrorSquared = (totalErrorSquared / (length / 2));
     return (float)sqrt(avgErrorSquared);
 }

 CodecTestBase::CodecTestBase(const char* mime) {
     mMime = mime;
     mIsAudio = strncmp(mime, "audio/", strlen("audio/")) == 0;
     mIsCodecInAsyncMode = false;
     mSawInputEOS = false;
     mSawOutputEOS = false;
     mSignalEOSWithLastFrame = false;
     mInputCount = 0;
     mOutputCount = 0;
     mPrevOutputPts = INT32_MIN;
     mSignalledOutFormatChanged = false;
     mOutFormat = nullptr;
     mSaveToMem = false;
     mOutputBuff = nullptr;
     mCodec = nullptr;
 }

 CodecTestBase::~CodecTestBase() {
     if (mOutFormat) {
         AMediaFormat_delete(mOutFormat);
         mOutFormat = nullptr;
     }
     if (mCodec) {
         AMediaCodec_delete(mCodec);
         mCodec = nullptr;
     }
 }

 bool CodecTestBase::configureCodec(AMediaFormat* format, bool isAsync, bool signalEOSWithLastFrame,
                                    bool isEncoder) {
     resetContext(isAsync, signalEOSWithLastFrame);
     CHECK_STATUS(mAsyncHandle.setCallBack(mCodec, isAsync),
                  "AMediaCodec_setAsyncNotifyCallback failed");
     CHECK_STATUS(AMediaCodec_configure(mCodec, format, nullptr, nullptr,
                                        isEncoder ? AMEDIACODEC_CONFIGURE_FLAG_ENCODE : 0),
                  "AMediaCodec_configure failed");
     return true;
 }

 bool CodecTestBase::flushCodec() {
     CHECK_STATUS(AMediaCodec_flush(mCodec), "AMediaCodec_flush failed");
     // TODO(b/147576107): is it ok to clearQueues right away or wait for some signal
     mAsyncHandle.clearQueues();
     mSawInputEOS = false;
     mSawOutputEOS = false;
     mInputCount = 0;
     mOutputCount = 0;
     mPrevOutputPts = INT32_MIN;
     return true;
 }

 bool CodecTestBase::reConfigureCodec(AMediaFormat* format, bool isAsync,
                                      bool signalEOSWithLastFrame, bool isEncoder) {
     CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed");
     return configureCodec(format, isAsync, signalEOSWithLastFrame, isEncoder);
 }

 void CodecTestBase::resetContext(bool isAsync, bool signalEOSWithLastFrame) {
     mAsyncHandle.resetContext();
     mIsCodecInAsyncMode = isAsync;
     mSawInputEOS = false;
     mSawOutputEOS = false;
     mSignalEOSWithLastFrame = signalEOSWithLastFrame;
     mInputCount = 0;
     mOutputCount = 0;
     mPrevOutputPts = INT32_MIN;
     mSignalledOutFormatChanged = false;
     if (mOutFormat) {
         AMediaFormat_delete(mOutFormat);
         mOutFormat = nullptr;
     }
 }

 bool CodecTestBase::enqueueEOS(size_t bufferIndex) {
     if (!hasSeenError() && !mSawInputEOS) {
         CHECK_STATUS(AMediaCodec_queueInputBuffer(mCodec, bufferIndex, 0, 0, 0,
                                                   AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM),
                      "AMediaCodec_queueInputBuffer failed");
         mSawInputEOS = true;
         ALOGV("Queued End of Stream");
     }
     return !hasSeenError();
 }

 bool CodecTestBase::doWork(int frameLimit) {
     bool isOk = true;
     int frameCnt = 0;
     if (mIsCodecInAsyncMode) {
         // output processing after queuing EOS is done in waitForAllOutputs()
         while (!hasSeenError() && isOk && !mSawInputEOS && frameCnt < frameLimit) {
             callbackObject element = mAsyncHandle.getWork();
             if (element.bufferIndex >= 0) {
                 if (element.isInput) {
                     isOk = enqueueInput(element.bufferIndex);
                     frameCnt++;
                 } else {
                     isOk = dequeueOutput(element.bufferIndex, &element.bufferInfo);
                 }
             }
         }
     } else {
         AMediaCodecBufferInfo outInfo;
         // output processing after queuing EOS is done in waitForAllOutputs()
         while (isOk && !mSawInputEOS && frameCnt < frameLimit) {
             ssize_t oBufferID = AMediaCodec_dequeueOutputBuffer(mCodec, &outInfo, kQDeQTimeOutUs);
             if (oBufferID >= 0) {
                 isOk = dequeueOutput(oBufferID, &outInfo);
             } else if (oBufferID == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
                 if (mOutFormat) {
                     AMediaFormat_delete(mOutFormat);
                     mOutFormat = nullptr;
                 }
                 mOutFormat = AMediaCodec_getOutputFormat(mCodec);
                 mSignalledOutFormatChanged = true;
             } else if (oBufferID == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
             } else if (oBufferID == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED) {
             } else {
                 ALOGE("unexpected return value from *_dequeueOutputBuffer: %d", (int)oBufferID);
                 return false;
             }
             ssize_t iBufferId = AMediaCodec_dequeueInputBuffer(mCodec, kQDeQTimeOutUs);
             if (iBufferId >= 0) {
                 isOk = enqueueInput(iBufferId);
                 frameCnt++;
             } else if (iBufferId == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
             } else {
                 ALOGE("unexpected return value from *_dequeueInputBuffer: %d", (int)iBufferId);
                 return false;
             }
         }
     }
     return !hasSeenError() && isOk;
 }

 bool CodecTestBase::queueEOS() {
     bool isOk = true;
     if (mIsCodecInAsyncMode) {
         if (!hasSeenError() && isOk && !mSawInputEOS) {
             callbackObject element = mAsyncHandle.getInput();
             if (element.bufferIndex >= 0) {
                 isOk = enqueueEOS(element.bufferIndex);
             }
         }
     } else {
         if (!mSawInputEOS) {
             int bufferIndex = AMediaCodec_dequeueInputBuffer(mCodec, -1);
             if (bufferIndex >= 0) {
                 isOk = enqueueEOS(bufferIndex);
             } else {
                 ALOGE("unexpected return value from *_dequeueInputBuffer: %d", (int)bufferIndex);
                 return false;
             }
         }
     }
     return !hasSeenError() && isOk;
 }

 bool CodecTestBase::waitForAllOutputs() {
     bool isOk = true;
     if (mIsCodecInAsyncMode) {
         while (!hasSeenError() && isOk && !mSawOutputEOS) {
             callbackObject element = mAsyncHandle.getOutput();
             if (element.bufferIndex >= 0) {
                 isOk = dequeueOutput(element.bufferIndex, &element.bufferInfo);
             }
         }
     } else {
         AMediaCodecBufferInfo outInfo;
         while (!mSawOutputEOS) {
             int bufferID = AMediaCodec_dequeueOutputBuffer(mCodec, &outInfo, kQDeQTimeOutUs);
             if (bufferID >= 0) {
                 isOk = dequeueOutput(bufferID, &outInfo);
             } else if (bufferID == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
                 if (mOutFormat) {
                     AMediaFormat_delete(mOutFormat);
                     mOutFormat = nullptr;
                 }
                 mOutFormat = AMediaCodec_getOutputFormat(mCodec);
                 mSignalledOutFormatChanged = true;
             } else if (bufferID == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
             } else if (bufferID == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED) {
             } else {
                 ALOGE("unexpected return value from *_dequeueOutputBuffer: %d", (int)bufferID);
                 return false;
             }
         }
     }
     return !hasSeenError() && isOk;
 }

 int CodecTestBase::getWidth(AMediaFormat* format) {
     int width = -1;
     int cropLeft, cropRight, cropTop, cropBottom;
     AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &width);
     if (AMediaFormat_getRect(format, "crop", &cropLeft, &cropTop, &cropRight, &cropBottom) ||
         (AMediaFormat_getInt32(format, "crop-left", &cropLeft) &&
         AMediaFormat_getInt32(format, "crop-right", &cropRight))) {
         width = cropRight + 1 - cropLeft;
     }
     return width;
 }

 int CodecTestBase::getHeight(AMediaFormat* format) {
     int height = -1;
     int cropLeft, cropRight, cropTop, cropBottom;
     AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &height);
     if (AMediaFormat_getRect(format, "crop", &cropLeft, &cropTop, &cropRight, &cropBottom) ||
         (AMediaFormat_getInt32(format, "crop-top", &cropTop) &&
         AMediaFormat_getInt32(format, "crop-bottom", &cropBottom))) {
         height = cropBottom + 1 - cropTop;
     }
     return height;
 }

 bool CodecTestBase::isFormatSimilar(AMediaFormat* inpFormat, AMediaFormat* outFormat) {
     const char *refMime = nullptr, *testMime = nullptr;
     bool hasRefMime = AMediaFormat_getString(inpFormat, AMEDIAFORMAT_KEY_MIME, &refMime);
     bool hasTestMime = AMediaFormat_getString(outFormat, AMEDIAFORMAT_KEY_MIME, &testMime);

     if (!hasRefMime || !hasTestMime) return false;
     if (!strncmp(refMime, "audio/", strlen("audio/"))) {
         int32_t refSampleRate = -1;
         int32_t testSampleRate = -2;
         int32_t refNumChannels = -1;
         int32_t testNumChannels = -2;
         AMediaFormat_getInt32(inpFormat, AMEDIAFORMAT_KEY_SAMPLE_RATE, &refSampleRate);
         AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_SAMPLE_RATE, &testSampleRate);
         AMediaFormat_getInt32(inpFormat, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &refNumChannels);
         AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &testNumChannels);
         return refNumChannels == testNumChannels && refSampleRate == testSampleRate &&
                (strncmp(testMime, "audio/", strlen("audio/")) == 0);
     } else if (!strncmp(refMime, "video/", strlen("video/"))) {
         int32_t refWidth = getWidth(inpFormat);
         int32_t testWidth = getWidth(outFormat);
         int32_t refHeight = getHeight(inpFormat);
         int32_t testHeight = getHeight(outFormat);
         return refWidth != -1 && refHeight != -1 && refWidth == testWidth &&
                refHeight == testHeight && (strncmp(testMime, "video/", strlen("video/")) == 0);
     }
     return true;
 }
	/*
	* 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 "NativeCodecTestBase"
	#include <log/log.h>

	#include "NativeCodecTestBase.h"

	static void onAsyncInputAvailable(AMediaCodec* codec, void* userdata, int32_t index) {
	(void)codec;
	assert(index >= 0);
	auto* aSyncHandle = static_cast<CodecAsyncHandler*>(userdata);
	callbackObject element{index};
	aSyncHandle->pushToInputList(element);
	}

	static void onAsyncOutputAvailable(AMediaCodec* codec, void* userdata, int32_t index,
	AMediaCodecBufferInfo* bufferInfo) {
	(void)codec;
	assert(index >= 0);
	auto* aSyncHandle = static_cast<CodecAsyncHandler*>(userdata);
	callbackObject element{index, bufferInfo};
	aSyncHandle->pushToOutputList(element);
	}

	static void onAsyncFormatChanged(AMediaCodec* codec, void* userdata, AMediaFormat* format) {
	(void)codec;
	auto* aSyncHandle = static_cast<CodecAsyncHandler*>(userdata);
	aSyncHandle->setOutputFormat(format);
	ALOGI("Output format changed: %s", AMediaFormat_toString(format));
	}

	static void onAsyncError(AMediaCodec* codec, void* userdata, media_status_t error,
	int32_t actionCode, const char* detail) {
	(void)codec;
	auto* aSyncHandle = static_cast<CodecAsyncHandler*>(userdata);
	aSyncHandle->setError(true);
	ALOGE("received media codec error: %s , code : %d , action code: %d ", detail, error,
	actionCode);
	}

	CodecAsyncHandler::CodecAsyncHandler() {
	mOutFormat = nullptr;
	mSignalledOutFormatChanged = false;
	mSignalledError = false;
	}

	CodecAsyncHandler::~CodecAsyncHandler() {
	if (mOutFormat) {
	AMediaFormat_delete(mOutFormat);
	mOutFormat = nullptr;
	}
	}

	void CodecAsyncHandler::pushToInputList(callbackObject element) {
	std::unique_lock<std::mutex> lock{mMutex};
	mCbInputQueue.push_back(element);
	mCondition.notify_all();
	}

	void CodecAsyncHandler::pushToOutputList(callbackObject element) {
	std::unique_lock<std::mutex> lock{mMutex};
	mCbOutputQueue.push_back(element);
	mCondition.notify_all();
	}

	callbackObject CodecAsyncHandler::getInput() {
	callbackObject element{-1};
	std::unique_lock<std::mutex> lock{mMutex};
	while (!mSignalledError) {
	if (mCbInputQueue.empty()) {
	mCondition.wait(lock);
	} else {
	element = mCbInputQueue.front();
	mCbInputQueue.pop_front();
	break;
	}
	}
	return element;
	}

	callbackObject CodecAsyncHandler::getOutput() {
	callbackObject element;
	std::unique_lock<std::mutex> lock{mMutex};
	while (!mSignalledError) {
	if (mCbOutputQueue.empty()) {
	mCondition.wait(lock);
	} else {
	element = mCbOutputQueue.front();
	mCbOutputQueue.pop_front();
	break;
	}
	}
	return element;
	}

	callbackObject CodecAsyncHandler::getWork() {
	callbackObject element;
	std::unique_lock<std::mutex> lock{mMutex};
	while (!mSignalledError) {
	if (mCbInputQueue.empty() && mCbOutputQueue.empty()) {
	mCondition.wait(lock);
	} else {
	if (!mCbOutputQueue.empty()) {
	element = mCbOutputQueue.front();
	mCbOutputQueue.pop_front();
	break;
	} else {
	element = mCbInputQueue.front();
	mCbInputQueue.pop_front();
	break;
	}
	}
	}
	return element;
	}

	bool CodecAsyncHandler::isInputQueueEmpty() {
	std::unique_lock<std::mutex> lock{mMutex};
	return mCbInputQueue.empty();
	}

	void CodecAsyncHandler::clearQueues() {
	std::unique_lock<std::mutex> lock{mMutex};
	mCbInputQueue.clear();
	mCbOutputQueue.clear();
	}

	void CodecAsyncHandler::setOutputFormat(AMediaFormat* format) {
	assert(format != nullptr);
	if (mOutFormat) {
	AMediaFormat_delete(mOutFormat);
	mOutFormat = nullptr;
	}
	mOutFormat = format;
	mSignalledOutFormatChanged = true;
	}

	AMediaFormat* CodecAsyncHandler::getOutputFormat() {
	return mOutFormat;
	}

	bool CodecAsyncHandler::hasOutputFormatChanged() {
	return mSignalledOutFormatChanged;
	}

	void CodecAsyncHandler::setError(bool status) {
	std::unique_lock<std::mutex> lock{mMutex};
	mSignalledError = status;
	mCondition.notify_all();
	}

	bool CodecAsyncHandler::getError() {
	return mSignalledError;
	}

	void CodecAsyncHandler::resetContext() {
	clearQueues();
	if (mOutFormat) {
	AMediaFormat_delete(mOutFormat);
	mOutFormat = nullptr;
	}
	mSignalledOutFormatChanged = false;
	mSignalledError = false;
	}

	media_status_t CodecAsyncHandler::setCallBack(AMediaCodec* codec, bool isCodecInAsyncMode) {
	media_status_t status = AMEDIA_OK;
	if (isCodecInAsyncMode) {
	AMediaCodecOnAsyncNotifyCallback callBack = {onAsyncInputAvailable, onAsyncOutputAvailable,
	onAsyncFormatChanged, onAsyncError};
	status = AMediaCodec_setAsyncNotifyCallback(codec, callBack, this);
	}
	return status;
	}

	uint32_t OutputManager::adler32(const uint8_t* input, int offset, int len) {
	constexpr uint32_t modAdler = 65521;
	constexpr uint32_t overflowLimit = 5500;
	uint32_t a = 1;
	uint32_t b = 0;
	for (int i = offset, count = 0; i < len; i++) {
	a += input[i];
	b += a;
	count++;
	if (count > overflowLimit) {
	a %= modAdler;
	b %= modAdler;
	count = 0;
	}
	}
	return b * 65536 + a;
	}

	bool OutputManager::isPtsStrictlyIncreasing(int64_t lastPts) {
	bool result = true;
	for (auto it1 = outPtsArray.cbegin(); it1 < outPtsArray.cend(); it1++) {
	if (lastPts < *it1) {
	lastPts = *it1;
	} else {
	ALOGE("Timestamp ordering check failed: last timestamp: %d / current timestamp: %d",
	(int)lastPts, (int)*it1);
	result = false;
	break;
	}
	}
	return result;
	}

	bool OutputManager::isOutPtsListIdenticalToInpPtsList(bool requireSorting) {
	bool isEqual = true;
	std::sort(inpPtsArray.begin(), inpPtsArray.end());
	if (requireSorting) {
	std::sort(outPtsArray.begin(), outPtsArray.end());
	}
	if (outPtsArray != inpPtsArray) {
	if (outPtsArray.size() != inpPtsArray.size()) {
	ALOGE("input and output presentation timestamp list sizes are not identical sizes "
	"exp/rec %d/%d", (int)inpPtsArray.size(), (int)outPtsArray.size());
	isEqual = false;
	} else {
	int count = 0;
	for (auto it1 = outPtsArray.cbegin(), it2 = inpPtsArray.cbegin();
	it1 < outPtsArray.cend(); it1++, it2++) {
	if (it1 != it2) {
	ALOGE("input output pts mismatch, exp/rec %d/%d", (int)it2, (int)it1);
	count++;
	}
	if (count == 20) {
	ALOGE("stopping after 20 mismatches ... ");
	break;
	}
	}
	if (count != 0) isEqual = false;
	}
	}
	return isEqual;
	}

	bool OutputManager::equals(const OutputManager* that) {
	if (this == that) return true;
	if (outPtsArray != that->outPtsArray) {
	if (outPtsArray.size() != that->outPtsArray.size()) {
	ALOGE("ref and test outputs presentation timestamp arrays are of unequal sizes %d, %d",
	(int)outPtsArray.size(), (int)that->outPtsArray.size());
	return false;
	} else {
	int count = 0;
	for (auto it1 = outPtsArray.cbegin(), it2 = that->outPtsArray.cbegin();
	it1 < outPtsArray.cend(); it1++, it2++) {
	if (it1 != it2) {
	ALOGE("presentation timestamp exp/rec %d/%d", (int)it1, (int)it2);
	count++;
	}
	if (count == 20) {
	ALOGE("stopping after 20 mismatches ... ");
	break;
	}
	}
	if (count != 0) return false;
	}
	}
	if (memory != that->memory) {
	if (memory.size() != that->memory.size()) {
	ALOGE("ref and test outputs decoded buffer are of unequal sizes %d, %d",
	(int)memory.size(), (int)that->memory.size());
	return false;
	} else {
	int count = 0;
	for (auto it1 = memory.cbegin(), it2 = that->memory.cbegin(); it1 < memory.cend();
	it1++, it2++) {
	if (it1 != it2) {
	ALOGE("decoded sample exp/rec %d/%d", (int)it1, (int)it2);
	count++;
	}
	if (count == 20) {
	ALOGE("stopping after 20 mismatches ... ");
	break;
	}
	}
	if (count != 0) return false;
	}
	}
	if (checksum != that->checksum) {
	if (checksum.size() != that->checksum.size()) {
	ALOGE("ref and test outputs checksum arrays are of unequal sizes %d, %d",
	(int)checksum.size(), (int)that->checksum.size());
	return false;
	} else {
	int count = 0;
	for (auto it1 = checksum.cbegin(), it2 = that->checksum.cbegin(); it1 < checksum.cend();
	it1++, it2++) {
	if (it1 != it2) {
	ALOGE("adler32 checksum exp/rec %u/%u", (int)it1, (int)it2);
	count++;
	}
	if (count == 20) {
	ALOGE("stopping after 20 mismatches ... ");
	break;
	}
	}
	if (count != 0) return false;
	}
	}
	return true;
	}

	float OutputManager::getRmsError(uint8_t* refData, int length) {
	long totalErrorSquared = 0;
	if (length != memory.size()) return -1.0F;
	if ((length % 2) != 0) return -1.0F;
	auto* testData = new uint8_t[length];
	std::copy(memory.begin(), memory.end(), testData);
	auto* testDataReinterpret = reinterpret_cast<int16_t*>(testData);
	auto* refDataReinterpret = reinterpret_cast<int16_t*>(refData);
	for (int i = 0; i < length / 2; i++) {
	int d = testDataReinterpret[i] - refDataReinterpret[i];
	totalErrorSquared += d * d;
	}
	delete[] testData;
	long avgErrorSquared = (totalErrorSquared / (length / 2));
	return (float)sqrt(avgErrorSquared);
	}

	CodecTestBase::CodecTestBase(const char* mime) {
	mMime = mime;
	mIsAudio = strncmp(mime, "audio/", strlen("audio/")) == 0;
	mIsCodecInAsyncMode = false;
	mSawInputEOS = false;
	mSawOutputEOS = false;
	mSignalEOSWithLastFrame = false;
	mInputCount = 0;
	mOutputCount = 0;
	mPrevOutputPts = INT32_MIN;
	mSignalledOutFormatChanged = false;
	mOutFormat = nullptr;
	mSaveToMem = false;
	mOutputBuff = nullptr;
	mCodec = nullptr;
	}

	CodecTestBase::~CodecTestBase() {
	if (mOutFormat) {
	AMediaFormat_delete(mOutFormat);
	mOutFormat = nullptr;
	}
	if (mCodec) {
	AMediaCodec_delete(mCodec);
	mCodec = nullptr;
	}
	}

	bool CodecTestBase::configureCodec(AMediaFormat* format, bool isAsync, bool signalEOSWithLastFrame,
	bool isEncoder) {
	resetContext(isAsync, signalEOSWithLastFrame);
	CHECK_STATUS(mAsyncHandle.setCallBack(mCodec, isAsync),
	"AMediaCodec_setAsyncNotifyCallback failed");
	CHECK_STATUS(AMediaCodec_configure(mCodec, format, nullptr, nullptr,
	isEncoder ? AMEDIACODEC_CONFIGURE_FLAG_ENCODE : 0),
	"AMediaCodec_configure failed");
	return true;
	}

	bool CodecTestBase::flushCodec() {
	CHECK_STATUS(AMediaCodec_flush(mCodec), "AMediaCodec_flush failed");
	// TODO(b/147576107): is it ok to clearQueues right away or wait for some signal
	mAsyncHandle.clearQueues();
	mSawInputEOS = false;
	mSawOutputEOS = false;
	mInputCount = 0;
	mOutputCount = 0;
	mPrevOutputPts = INT32_MIN;
	return true;
	}

	bool CodecTestBase::reConfigureCodec(AMediaFormat* format, bool isAsync,
	bool signalEOSWithLastFrame, bool isEncoder) {
	CHECK_STATUS(AMediaCodec_stop(mCodec), "AMediaCodec_stop failed");
	return configureCodec(format, isAsync, signalEOSWithLastFrame, isEncoder);
	}

	void CodecTestBase::resetContext(bool isAsync, bool signalEOSWithLastFrame) {
	mAsyncHandle.resetContext();
	mIsCodecInAsyncMode = isAsync;
	mSawInputEOS = false;
	mSawOutputEOS = false;
	mSignalEOSWithLastFrame = signalEOSWithLastFrame;
	mInputCount = 0;
	mOutputCount = 0;
	mPrevOutputPts = INT32_MIN;
	mSignalledOutFormatChanged = false;
	if (mOutFormat) {
	AMediaFormat_delete(mOutFormat);
	mOutFormat = nullptr;
	}
	}

	bool CodecTestBase::enqueueEOS(size_t bufferIndex) {
	if (!hasSeenError() && !mSawInputEOS) {
	CHECK_STATUS(AMediaCodec_queueInputBuffer(mCodec, bufferIndex, 0, 0, 0,
	AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM),
	"AMediaCodec_queueInputBuffer failed");
	mSawInputEOS = true;
	ALOGV("Queued End of Stream");
	}
	return !hasSeenError();
	}

	bool CodecTestBase::doWork(int frameLimit) {
	bool isOk = true;
	int frameCnt = 0;
	if (mIsCodecInAsyncMode) {
	// output processing after queuing EOS is done in waitForAllOutputs()
	while (!hasSeenError() && isOk && !mSawInputEOS && frameCnt < frameLimit) {
	callbackObject element = mAsyncHandle.getWork();
	if (element.bufferIndex >= 0) {
	if (element.isInput) {
	isOk = enqueueInput(element.bufferIndex);
	frameCnt++;
	} else {
	isOk = dequeueOutput(element.bufferIndex, &element.bufferInfo);
	}
	}
	}
	} else {
	AMediaCodecBufferInfo outInfo;
	// output processing after queuing EOS is done in waitForAllOutputs()
	while (isOk && !mSawInputEOS && frameCnt < frameLimit) {
	ssize_t oBufferID = AMediaCodec_dequeueOutputBuffer(mCodec, &outInfo, kQDeQTimeOutUs);
	if (oBufferID >= 0) {
	isOk = dequeueOutput(oBufferID, &outInfo);
	} else if (oBufferID == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
	if (mOutFormat) {
	AMediaFormat_delete(mOutFormat);
	mOutFormat = nullptr;
	}
	mOutFormat = AMediaCodec_getOutputFormat(mCodec);
	mSignalledOutFormatChanged = true;
	} else if (oBufferID == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
	} else if (oBufferID == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED) {
	} else {
	ALOGE("unexpected return value from *_dequeueOutputBuffer: %d", (int)oBufferID);
	return false;
	}
	ssize_t iBufferId = AMediaCodec_dequeueInputBuffer(mCodec, kQDeQTimeOutUs);
	if (iBufferId >= 0) {
	isOk = enqueueInput(iBufferId);
	frameCnt++;
	} else if (iBufferId == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
	} else {
	ALOGE("unexpected return value from *_dequeueInputBuffer: %d", (int)iBufferId);
	return false;
	}
	}
	}
	return !hasSeenError() && isOk;
	}

	bool CodecTestBase::queueEOS() {
	bool isOk = true;
	if (mIsCodecInAsyncMode) {
	if (!hasSeenError() && isOk && !mSawInputEOS) {
	callbackObject element = mAsyncHandle.getInput();
	if (element.bufferIndex >= 0) {
	isOk = enqueueEOS(element.bufferIndex);
	}
	}
	} else {
	if (!mSawInputEOS) {
	int bufferIndex = AMediaCodec_dequeueInputBuffer(mCodec, -1);
	if (bufferIndex >= 0) {
	isOk = enqueueEOS(bufferIndex);
	} else {
	ALOGE("unexpected return value from *_dequeueInputBuffer: %d", (int)bufferIndex);
	return false;
	}
	}
	}
	return !hasSeenError() && isOk;
	}

	bool CodecTestBase::waitForAllOutputs() {
	bool isOk = true;
	if (mIsCodecInAsyncMode) {
	while (!hasSeenError() && isOk && !mSawOutputEOS) {
	callbackObject element = mAsyncHandle.getOutput();
	if (element.bufferIndex >= 0) {
	isOk = dequeueOutput(element.bufferIndex, &element.bufferInfo);
	}
	}
	} else {
	AMediaCodecBufferInfo outInfo;
	while (!mSawOutputEOS) {
	int bufferID = AMediaCodec_dequeueOutputBuffer(mCodec, &outInfo, kQDeQTimeOutUs);
	if (bufferID >= 0) {
	isOk = dequeueOutput(bufferID, &outInfo);
	} else if (bufferID == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
	if (mOutFormat) {
	AMediaFormat_delete(mOutFormat);
	mOutFormat = nullptr;
	}
	mOutFormat = AMediaCodec_getOutputFormat(mCodec);
	mSignalledOutFormatChanged = true;
	} else if (bufferID == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
	} else if (bufferID == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED) {
	} else {
	ALOGE("unexpected return value from *_dequeueOutputBuffer: %d", (int)bufferID);
	return false;
	}
	}
	}
	return !hasSeenError() && isOk;
	}

	int CodecTestBase::getWidth(AMediaFormat* format) {
	int width = -1;
	int cropLeft, cropRight, cropTop, cropBottom;
	AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &width);
	if (AMediaFormat_getRect(format, "crop", &cropLeft, &cropTop, &cropRight, &cropBottom) \|\|
	(AMediaFormat_getInt32(format, "crop-left", &cropLeft) &&
	AMediaFormat_getInt32(format, "crop-right", &cropRight))) {
	width = cropRight + 1 - cropLeft;
	}
	return width;
	}

	int CodecTestBase::getHeight(AMediaFormat* format) {
	int height = -1;
	int cropLeft, cropRight, cropTop, cropBottom;
	AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &height);
	if (AMediaFormat_getRect(format, "crop", &cropLeft, &cropTop, &cropRight, &cropBottom) \|\|
	(AMediaFormat_getInt32(format, "crop-top", &cropTop) &&
	AMediaFormat_getInt32(format, "crop-bottom", &cropBottom))) {
	height = cropBottom + 1 - cropTop;
	}
	return height;
	}

	bool CodecTestBase::isFormatSimilar(AMediaFormat* inpFormat, AMediaFormat* outFormat) {
	const char refMime = nullptr, testMime = nullptr;
	bool hasRefMime = AMediaFormat_getString(inpFormat, AMEDIAFORMAT_KEY_MIME, &refMime);
	bool hasTestMime = AMediaFormat_getString(outFormat, AMEDIAFORMAT_KEY_MIME, &testMime);

	if (!hasRefMime \|\| !hasTestMime) return false;
	if (!strncmp(refMime, "audio/", strlen("audio/"))) {
	int32_t refSampleRate = -1;
	int32_t testSampleRate = -2;
	int32_t refNumChannels = -1;
	int32_t testNumChannels = -2;
	AMediaFormat_getInt32(inpFormat, AMEDIAFORMAT_KEY_SAMPLE_RATE, &refSampleRate);
	AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_SAMPLE_RATE, &testSampleRate);
	AMediaFormat_getInt32(inpFormat, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &refNumChannels);
	AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &testNumChannels);
	return refNumChannels == testNumChannels && refSampleRate == testSampleRate &&
	(strncmp(testMime, "audio/", strlen("audio/")) == 0);
	} else if (!strncmp(refMime, "video/", strlen("video/"))) {
	int32_t refWidth = getWidth(inpFormat);
	int32_t testWidth = getWidth(outFormat);
	int32_t refHeight = getHeight(inpFormat);
	int32_t testHeight = getHeight(outFormat);
	return refWidth != -1 && refHeight != -1 && refWidth == testWidth &&
	refHeight == testHeight && (strncmp(testMime, "video/", strlen("video/")) == 0);
	}
	return true;
	}