Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a4e3ab2d authored by Rakesh Kumar's avatar Rakesh Kumar
Browse files

Benchmark: Fixing error propgation for Async callback 

Test: decoderTest --gtest_repeat=10 -P /sdcard/res/
Test: encoderTest --gtest_repeat=10 -P /sdcard/res/

Bug: 141359753

Change-Id: I8206c92174ce32557bc72b346a41050f7f362fa0
parent 429f364c

media/tests/benchmark/src/native/common/BenchmarkCommon.cpp

+2 −2
Original line number Diff line number Diff line
@@ -56,10 +56,10 @@ void OnFormatChangedCB(AMediaCodec *codec, void *userdata, AMediaFormat *format) 


void OnErrorCB(AMediaCodec *codec, void *userdata, media_status_t err, int32_t actionCode,

               const char *detail) {

    (void)codec;

    ALOGV("OnErrorCB: err(%d), actionCode(%d), detail(%s)", err, actionCode, detail);

    ALOGE("OnErrorCB: err(%d), actionCode(%d), detail(%s)", err, actionCode, detail);

    CallBackHandle *self = (CallBackHandle *)userdata;

    self->mSawError = true;

    self->mIOQueue.push([self, codec, err]() { self->onError(codec, err); });

}



AMediaCodec *createMediaCodec(AMediaFormat *format, const char *mime, string codecName,

media/tests/benchmark/src/native/common/BenchmarkCommon.h

+4 −0
Original line number Diff line number Diff line
@@ -87,6 +87,10 @@ class CallBackHandle { 
        (void)codec;

        (void)format;

    }

    virtual void onError(AMediaCodec *codec, media_status_t err) {

        (void)codec;

        (void)err;

    }

    virtual void onOutputAvailable(AMediaCodec *codec, int32_t index,

                                   AMediaCodecBufferInfo *bufferInfo) {

        (void)codec;

media/tests/benchmark/src/native/decoder/Decoder.cpp

+26 −7
Original line number Diff line number Diff line
@@ -32,8 +32,8 @@ tuple<ssize_t, uint32_t, int64_t> readSampleData(uint8_t *inputBuffer, int32_t & 
    int64_t timestamp = frameInfo[frameID].presentationTimeUs;

    ssize_t bytesCount = frameInfo[frameID].size;

    if (bufSize < bytesCount) {

        ALOGE("Error : insufficient resource");

        return make_tuple(0, AMEDIACODEC_ERROR_INSUFFICIENT_RESOURCE, 0);

        ALOGE("Error : Buffer size is insufficient to read sample");

        return make_tuple(0, AMEDIA_ERROR_MALFORMED, 0);

    }



    memcpy(buf, inputBuffer + offset, bytesCount);
@@ -54,6 +54,7 @@ void Decoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 
        size_t bufSize;

        uint8_t *buf = AMediaCodec_getInputBuffer(mCodec, bufIdx, &bufSize);

        if (!buf) {

            mErrorCode = AMEDIA_ERROR_IO;

            mSignalledError = true;

            mDecoderDoneCondition.notify_one();

            return;
@@ -64,7 +65,8 @@ void Decoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 
        int64_t presentationTimeUs = 0;

        tie(bytesRead, flag, presentationTimeUs) = readSampleData(

                mInputBuffer, mOffset, mFrameMetaData, buf, mNumInputFrame, bufSize);

        if (flag == AMEDIACODEC_ERROR_INSUFFICIENT_RESOURCE) {

        if (flag == AMEDIA_ERROR_MALFORMED) {

            mErrorCode = (media_status_t)flag;

            mSignalledError = true;

            mDecoderDoneCondition.notify_one();

            return;
@@ -74,9 +76,10 @@ void Decoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 
        ALOGV("%s bytesRead : %zd presentationTimeUs : %" PRId64 " mSawInputEOS : %s", __FUNCTION__,

              bytesRead, presentationTimeUs, mSawInputEOS ? "TRUE" : "FALSE");



        int status = AMediaCodec_queueInputBuffer(mCodec, bufIdx, 0 /* offset */, bytesRead,

                                                  presentationTimeUs, flag);

        media_status_t status = AMediaCodec_queueInputBuffer(mCodec, bufIdx, 0 /* offset */,

                                                             bytesRead, presentationTimeUs, flag);

        if (AMEDIA_OK != status) {

            mErrorCode = status;

            mSignalledError = true;

            mDecoderDoneCondition.notify_one();

            return;
@@ -127,6 +130,16 @@ void Decoder::onFormatChanged(AMediaCodec *mediaCodec, AMediaFormat *format) { 
    }

}



void Decoder::onError(AMediaCodec *mediaCodec, media_status_t err) {

    ALOGV("In %s", __func__);

    if (mediaCodec == mCodec && mediaCodec) {

        ALOGE("Received Error %d", err);

        mErrorCode = err;

        mSignalledError = true;

        mDecoderDoneCondition.notify_one();

    }

}



void Decoder::setupDecoder() {

    if (!mFormat) mFormat = mExtractor->getFormat();

}
@@ -168,7 +181,8 @@ int32_t Decoder::decode(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &fra 
                ssize_t inIdx = AMediaCodec_dequeueInputBuffer(mCodec, kQueueDequeueTimeoutUs);

                if (inIdx < 0 && inIdx != AMEDIACODEC_INFO_TRY_AGAIN_LATER) {

                    ALOGE("AMediaCodec_dequeueInputBuffer returned invalid index %zd\n", inIdx);

                    return AMEDIA_ERROR_IO;

                    mErrorCode = (media_status_t)inIdx;

                    return mErrorCode;

                } else if (inIdx >= 0) {

                    mStats->addInputTime();

                    onInputAvailable(mCodec, inIdx);
@@ -188,13 +202,18 @@ int32_t Decoder::decode(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &fra 
            } else if (!(outIdx == AMEDIACODEC_INFO_TRY_AGAIN_LATER ||

                         outIdx == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED)) {

                ALOGE("AMediaCodec_dequeueOutputBuffer returned invalid index %zd\n", outIdx);

                return AMEDIA_ERROR_IO;

                mErrorCode = (media_status_t)outIdx;

                return mErrorCode;

            }

        }

    } else {

        unique_lock<mutex> lock(mMutex);

        mDecoderDoneCondition.wait(lock, [this]() { return (mSawOutputEOS || mSignalledError); });

    }

    if (mSignalledError) {

        ALOGE("Received Error while Decoding");

        return mErrorCode;

    }



    if (codecName.empty()) {

        char *decName;

media/tests/benchmark/src/native/decoder/Decoder.h

+4 −0
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ class Decoder : public CallBackHandle { 
          mSawInputEOS(false),

          mSawOutputEOS(false),

          mSignalledError(false),

          mErrorCode(AMEDIA_OK),

          mInputBuffer(nullptr),

          mOutFp(nullptr) {

        mExtractor = new Extractor();
@@ -61,6 +62,8 @@ class Decoder : public CallBackHandle { 


    void onFormatChanged(AMediaCodec *codec, AMediaFormat *format) override;



    void onError(AMediaCodec *mediaCodec, media_status_t err) override;



    void onOutputAvailable(AMediaCodec *codec, int32_t index,

                           AMediaCodecBufferInfo *bufferInfo) override;
@@ -82,6 +85,7 @@ class Decoder : public CallBackHandle { 
    bool mSawInputEOS;

    bool mSawOutputEOS;

    bool mSignalledError;

    media_status_t mErrorCode;



    int32_t mOffset;

    uint8_t *mInputBuffer;

media/tests/benchmark/src/native/encoder/Encoder.cpp

+26 −4
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ void Encoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 
        size_t bufSize = 0;

        char *buf = (char *)AMediaCodec_getInputBuffer(mCodec, bufIdx, &bufSize);

        if (!buf) {

            mErrorCode = AMEDIA_ERROR_IO;

            mSignalledError = true;

            mEncoderDoneCondition.notify_one();

            return;
@@ -41,6 +42,7 @@ void Encoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 


        if (mInputBufferSize < mOffset) {

            ALOGE("Out of bound access of input buffer\n");

            mErrorCode = AMEDIA_ERROR_MALFORMED;

            mSignalledError = true;

            mEncoderDoneCondition.notify_one();

            return;
@@ -51,6 +53,7 @@ void Encoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 
        }

        if (bufSize < bytesRead) {

            ALOGE("bytes to read %zu bufSize %zu \n", bytesRead, bufSize);

            mErrorCode = AMEDIA_ERROR_MALFORMED;

            mSignalledError = true;

            mEncoderDoneCondition.notify_one();

            return;
@@ -58,6 +61,7 @@ void Encoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 
        if (bytesRead < mParams.frameSize && mNumInputFrame < mParams.numFrames - 1) {

            ALOGE("Partial frame at frameID %d bytesRead %zu frameSize %d total numFrames %d\n",

                  mNumInputFrame, bytesRead, mParams.frameSize, mParams.numFrames);

            mErrorCode = AMEDIA_ERROR_MALFORMED;

            mSignalledError = true;

            mEncoderDoneCondition.notify_one();

            return;
@@ -66,6 +70,7 @@ void Encoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 
        size_t bytesgcount = mEleStream->gcount();

        if (bytesgcount != bytesRead) {

            ALOGE("bytes to read %zu actual bytes read %zu \n", bytesRead, bytesgcount);

            mErrorCode = AMEDIA_ERROR_MALFORMED;

            mSignalledError = true;

            mEncoderDoneCondition.notify_one();

            return;
@@ -89,9 +94,10 @@ void Encoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) { 
        ALOGV("%s bytesRead : %zd presentationTimeUs : %" PRIu64 " mSawInputEOS : %s", __FUNCTION__,

              bytesRead, presentationTimeUs, mSawInputEOS ? "TRUE" : "FALSE");



        int status = AMediaCodec_queueInputBuffer(mCodec, bufIdx, 0 /* offset */, bytesRead,

                                                  presentationTimeUs, flag);

        media_status_t status = AMediaCodec_queueInputBuffer(mCodec, bufIdx, 0 /* offset */,

                                                             bytesRead, presentationTimeUs, flag);

        if (AMEDIA_OK != status) {

            mErrorCode = status;

            mSignalledError = true;

            mEncoderDoneCondition.notify_one();

            return;
@@ -133,6 +139,16 @@ void Encoder::onFormatChanged(AMediaCodec *mediaCodec, AMediaFormat *format) { 
    }

}



void Encoder::onError(AMediaCodec *mediaCodec, media_status_t err) {

    ALOGV("In %s", __func__);

    if (mediaCodec == mCodec && mediaCodec) {

        ALOGE("Received Error %d", err);

        mErrorCode = err;

        mSignalledError = true;

        mEncoderDoneCondition.notify_one();

    }

}



void Encoder::setupEncoder() {

    if (!mFormat) mFormat = AMediaFormat_new();

}
@@ -235,7 +251,8 @@ int32_t Encoder::encode(string &codecName, ifstream &eleStream, size_t eleSize, 
                ssize_t inIdx = AMediaCodec_dequeueInputBuffer(mCodec, kQueueDequeueTimeoutUs);

                if (inIdx < 0 && inIdx != AMEDIACODEC_INFO_TRY_AGAIN_LATER) {

                    ALOGE("AMediaCodec_dequeueInputBuffer returned invalid index %zd\n", inIdx);

                    return AMEDIA_ERROR_IO;

                    mErrorCode = (media_status_t)inIdx;

                    return mErrorCode;

                } else if (inIdx >= 0) {

                    mStats->addInputTime();

                    onInputAvailable(mCodec, inIdx);
@@ -255,13 +272,18 @@ int32_t Encoder::encode(string &codecName, ifstream &eleStream, size_t eleSize, 
            } else if (!(outIdx == AMEDIACODEC_INFO_TRY_AGAIN_LATER ||

                         outIdx == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED)) {

                ALOGE("AMediaCodec_dequeueOutputBuffer returned invalid index %zd\n", outIdx);

                return AMEDIA_ERROR_IO;

                mErrorCode = (media_status_t)outIdx;

                return mErrorCode;

            }

        }

    } else {

        unique_lock<mutex> lock(mMutex);

        mEncoderDoneCondition.wait(lock, [this]() { return (mSawOutputEOS || mSignalledError); });

    }

    if (mSignalledError) {

        ALOGE("Received Error while Encoding");

        return mErrorCode;

    }



    if (codecName.empty()) {

        char *encName;