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

Commit 57cc3ae7 authored by Ray Essick's avatar Ray Essick Committed by Automerger Merge Worker
Browse files

Merge "C2SoftAvcEnc: add support to use ih264e instead of ive structures" am: 62a70c5a 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/1533174

Change-Id: I18a19e08568e1566ab0487bffb5b7327ed8d60a8
parents f0fc2d65 62a70c5a

media/codec2/components/avc/C2SoftAvcEnc.cpp

+89 −80
Original line number Diff line number Diff line
@@ -1009,29 +1009,31 @@ c2_status_t C2SoftAvcEnc::initEncoder() { 


    /* Getting MemRecords Attributes */

    {

        iv_fill_mem_rec_ip_t s_fill_mem_rec_ip;

        iv_fill_mem_rec_op_t s_fill_mem_rec_op;



        s_fill_mem_rec_ip.u4_size = sizeof(iv_fill_mem_rec_ip_t);

        s_fill_mem_rec_op.u4_size = sizeof(iv_fill_mem_rec_op_t);



        s_fill_mem_rec_ip.e_cmd = IV_CMD_FILL_NUM_MEM_REC;

        s_fill_mem_rec_ip.ps_mem_rec = mMemRecords;

        s_fill_mem_rec_ip.u4_num_mem_rec = mNumMemRecords;

        s_fill_mem_rec_ip.u4_max_wd = width;

        s_fill_mem_rec_ip.u4_max_ht = height;

        s_fill_mem_rec_ip.u4_max_level = mAVCEncLevel;

        s_fill_mem_rec_ip.e_color_format = DEFAULT_INP_COLOR_FORMAT;

        s_fill_mem_rec_ip.u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;

        s_fill_mem_rec_ip.u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;

        s_fill_mem_rec_ip.u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;

        s_fill_mem_rec_ip.u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;



        status = ive_api_function(nullptr, &s_fill_mem_rec_ip, &s_fill_mem_rec_op);

        ih264e_fill_mem_rec_ip_t s_ih264e_mem_rec_ip = {};

        ih264e_fill_mem_rec_op_t s_ih264e_mem_rec_op = {};

        iv_fill_mem_rec_ip_t *ps_fill_mem_rec_ip = &s_ih264e_mem_rec_ip.s_ive_ip;

        iv_fill_mem_rec_op_t *ps_fill_mem_rec_op = &s_ih264e_mem_rec_op.s_ive_op;



        ps_fill_mem_rec_ip->u4_size = sizeof(ih264e_fill_mem_rec_ip_t);

        ps_fill_mem_rec_op->u4_size = sizeof(ih264e_fill_mem_rec_op_t);



        ps_fill_mem_rec_ip->e_cmd = IV_CMD_FILL_NUM_MEM_REC;

        ps_fill_mem_rec_ip->ps_mem_rec = mMemRecords;

        ps_fill_mem_rec_ip->u4_num_mem_rec = mNumMemRecords;

        ps_fill_mem_rec_ip->u4_max_wd = width;

        ps_fill_mem_rec_ip->u4_max_ht = height;

        ps_fill_mem_rec_ip->u4_max_level = mAVCEncLevel;

        ps_fill_mem_rec_ip->e_color_format = DEFAULT_INP_COLOR_FORMAT;

        ps_fill_mem_rec_ip->u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;

        ps_fill_mem_rec_ip->u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;

        ps_fill_mem_rec_ip->u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;

        ps_fill_mem_rec_ip->u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;



        status = ive_api_function(nullptr, &s_ih264e_mem_rec_ip, &s_ih264e_mem_rec_op);



        if (status != IV_SUCCESS) {

            ALOGE("Fill memory records failed = 0x%x\n",

                    s_fill_mem_rec_op.u4_error_code);

                    ps_fill_mem_rec_op->u4_error_code);

            return C2_CORRUPTED;

        }

    }
@@ -1060,48 +1062,51 @@ c2_status_t C2SoftAvcEnc::initEncoder() { 


    /* Codec Instance Creation */

    {

        ive_init_ip_t s_init_ip;

        ive_init_op_t s_init_op;

        ih264e_init_ip_t s_enc_ip = {};

        ih264e_init_op_t s_enc_op = {};



        ive_init_ip_t *ps_init_ip = &s_enc_ip.s_ive_ip;

        ive_init_op_t *ps_init_op = &s_enc_op.s_ive_op;



        mCodecCtx = (iv_obj_t *)mMemRecords[0].pv_base;

        mCodecCtx->u4_size = sizeof(iv_obj_t);

        mCodecCtx->pv_fxns = (void *)ive_api_function;



        s_init_ip.u4_size = sizeof(ive_init_ip_t);

        s_init_op.u4_size = sizeof(ive_init_op_t);

        ps_init_ip->u4_size = sizeof(ih264e_init_ip_t);

        ps_init_op->u4_size = sizeof(ih264e_init_op_t);



        s_init_ip.e_cmd = IV_CMD_INIT;

        s_init_ip.u4_num_mem_rec = mNumMemRecords;

        s_init_ip.ps_mem_rec = mMemRecords;

        s_init_ip.u4_max_wd = width;

        s_init_ip.u4_max_ht = height;

        s_init_ip.u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;

        s_init_ip.u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;

        s_init_ip.u4_max_level = mAVCEncLevel;

        s_init_ip.e_inp_color_fmt = mIvVideoColorFormat;

        ps_init_ip->e_cmd = IV_CMD_INIT;

        ps_init_ip->u4_num_mem_rec = mNumMemRecords;

        ps_init_ip->ps_mem_rec = mMemRecords;

        ps_init_ip->u4_max_wd = width;

        ps_init_ip->u4_max_ht = height;

        ps_init_ip->u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;

        ps_init_ip->u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;

        ps_init_ip->u4_max_level = mAVCEncLevel;

        ps_init_ip->e_inp_color_fmt = mIvVideoColorFormat;



        if (mReconEnable || mPSNREnable) {

            s_init_ip.u4_enable_recon = 1;

            ps_init_ip->u4_enable_recon = 1;

        } else {

            s_init_ip.u4_enable_recon = 0;

        }

        s_init_ip.e_recon_color_fmt = DEFAULT_RECON_COLOR_FORMAT;

        s_init_ip.e_rc_mode = DEFAULT_RC_MODE;

        s_init_ip.u4_max_framerate = DEFAULT_MAX_FRAMERATE;

        s_init_ip.u4_max_bitrate = DEFAULT_MAX_BITRATE;

        s_init_ip.u4_num_bframes = mBframes;

        s_init_ip.e_content_type = IV_PROGRESSIVE;

        s_init_ip.u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;

        s_init_ip.u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;

        s_init_ip.e_slice_mode = mSliceMode;

        s_init_ip.u4_slice_param = mSliceParam;

        s_init_ip.e_arch = mArch;

        s_init_ip.e_soc = DEFAULT_SOC;



        status = ive_api_function(mCodecCtx, &s_init_ip, &s_init_op);

            ps_init_ip->u4_enable_recon = 0;

        }

        ps_init_ip->e_recon_color_fmt = DEFAULT_RECON_COLOR_FORMAT;

        ps_init_ip->e_rc_mode = DEFAULT_RC_MODE;

        ps_init_ip->u4_max_framerate = DEFAULT_MAX_FRAMERATE;

        ps_init_ip->u4_max_bitrate = DEFAULT_MAX_BITRATE;

        ps_init_ip->u4_num_bframes = mBframes;

        ps_init_ip->e_content_type = IV_PROGRESSIVE;

        ps_init_ip->u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;

        ps_init_ip->u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;

        ps_init_ip->e_slice_mode = mSliceMode;

        ps_init_ip->u4_slice_param = mSliceParam;

        ps_init_ip->e_arch = mArch;

        ps_init_ip->e_soc = DEFAULT_SOC;



        status = ive_api_function(mCodecCtx, &s_enc_ip, &s_enc_op);



        if (status != IV_SUCCESS) {

            ALOGE("Init encoder failed = 0x%x\n", s_init_op.u4_error_code);

            ALOGE("Init encoder failed = 0x%x\n", ps_init_op->u4_error_code);

            return C2_CORRUPTED;

        }

    }
@@ -1429,15 +1434,17 @@ void C2SoftAvcEnc::process( 
    }

    // while (!mSawOutputEOS && !outQueue.empty()) {

    c2_status_t error;

    ive_video_encode_ip_t s_encode_ip;

    ive_video_encode_op_t s_encode_op;

    memset(&s_encode_op, 0, sizeof(s_encode_op));

    ih264e_video_encode_ip_t s_video_encode_ip = {};

    ih264e_video_encode_op_t s_video_encode_op = {};

    ive_video_encode_ip_t *ps_encode_ip = &s_video_encode_ip.s_ive_ip;

    ive_video_encode_op_t *ps_encode_op = &s_video_encode_op.s_ive_op;

    memset(ps_encode_op, 0, sizeof(*ps_encode_op));



    if (!mSpsPpsHeaderReceived) {

        constexpr uint32_t kHeaderLength = MIN_STREAM_SIZE;

        uint8_t header[kHeaderLength];

        error = setEncodeArgs(

                &s_encode_ip, &s_encode_op, nullptr, header, kHeaderLength, workIndex);

                ps_encode_ip, ps_encode_op, nullptr, header, kHeaderLength, workIndex);

        if (error != C2_OK) {

            ALOGE("setEncodeArgs failed: %d", error);

            mSignalledError = true;
@@ -1445,22 +1452,22 @@ void C2SoftAvcEnc::process( 
            work->workletsProcessed = 1u;

            return;

        }

        status = ive_api_function(mCodecCtx, &s_encode_ip, &s_encode_op);

        status = ive_api_function(mCodecCtx, ps_encode_ip, ps_encode_op);



        if (IV_SUCCESS != status) {

            ALOGE("Encode header failed = 0x%x\n",

                    s_encode_op.u4_error_code);

                    ps_encode_op->u4_error_code);

            work->workletsProcessed = 1u;

            return;

        } else {

            ALOGV("Bytes Generated in header %d\n",

                    s_encode_op.s_out_buf.u4_bytes);

                    ps_encode_op->s_out_buf.u4_bytes);

        }



        mSpsPpsHeaderReceived = true;



        std::unique_ptr<C2StreamInitDataInfo::output> csd =

            C2StreamInitDataInfo::output::AllocUnique(s_encode_op.s_out_buf.u4_bytes, 0u);

            C2StreamInitDataInfo::output::AllocUnique(ps_encode_op->s_out_buf.u4_bytes, 0u);

        if (!csd) {

            ALOGE("CSD allocation failed");

            mSignalledError = true;
@@ -1468,7 +1475,7 @@ void C2SoftAvcEnc::process( 
            work->workletsProcessed = 1u;

            return;

        }

        memcpy(csd->m.value, header, s_encode_op.s_out_buf.u4_bytes);

        memcpy(csd->m.value, header, ps_encode_op->s_out_buf.u4_bytes);

        work->worklets.front()->output.configUpdate.push_back(std::move(csd));



        DUMP_TO_FILE(
@@ -1562,7 +1569,7 @@ void C2SoftAvcEnc::process( 
        }



        error = setEncodeArgs(

                &s_encode_ip, &s_encode_op, view.get(), wView.base(), wView.capacity(), workIndex);

                ps_encode_ip, ps_encode_op, view.get(), wView.base(), wView.capacity(), workIndex);

        if (error != C2_OK) {

            ALOGE("setEncodeArgs failed : %d", error);

            mSignalledError = true;
@@ -1579,17 +1586,17 @@ void C2SoftAvcEnc::process( 
        /* Compute time elapsed between end of previous decode()

         * to start of current decode() */

        TIME_DIFF(mTimeEnd, mTimeStart, timeDelay);

        status = ive_api_function(mCodecCtx, &s_encode_ip, &s_encode_op);

        status = ive_api_function(mCodecCtx, &s_video_encode_ip, &s_video_encode_op);



        if (IV_SUCCESS != status) {

            if ((s_encode_op.u4_error_code & 0xFF) == IH264E_BITSTREAM_BUFFER_OVERFLOW) {

            if ((ps_encode_op->u4_error_code & 0xFF) == IH264E_BITSTREAM_BUFFER_OVERFLOW) {

                // TODO: use IVE_CMD_CTL_GETBUFINFO for proper max input size?

                mOutBufferSize *= 2;

                mOutBlock.reset();

                continue;

            }

            ALOGE("Encode Frame failed = 0x%x\n",

                    s_encode_op.u4_error_code);

                    ps_encode_op->u4_error_code);

            mSignalledError = true;

            work->result = C2_CORRUPTED;

            work->workletsProcessed = 1u;
@@ -1599,7 +1606,7 @@ void C2SoftAvcEnc::process( 


    // Hold input buffer reference

    if (inputBuffer) {

        mBuffers[s_encode_ip.s_inp_buf.apv_bufs[0]] = inputBuffer;

        mBuffers[ps_encode_ip->s_inp_buf.apv_bufs[0]] = inputBuffer;

    }



    GETTIME(&mTimeEnd, nullptr);
@@ -1607,9 +1614,9 @@ void C2SoftAvcEnc::process( 
    TIME_DIFF(mTimeStart, mTimeEnd, timeTaken);



    ALOGV("timeTaken=%6d delay=%6d numBytes=%6d", timeTaken, timeDelay,

            s_encode_op.s_out_buf.u4_bytes);

            ps_encode_op->s_out_buf.u4_bytes);



    void *freed = s_encode_op.s_inp_buf.apv_bufs[0];

    void *freed = ps_encode_op->s_inp_buf.apv_bufs[0];

    /* If encoder frees up an input buffer, mark it as free */

    if (freed != nullptr) {

        if (mBuffers.count(freed) == 0u) {
@@ -1621,17 +1628,17 @@ void C2SoftAvcEnc::process( 
        }

    }



    if (s_encode_op.output_present) {

        if (!s_encode_op.s_out_buf.u4_bytes) {

    if (ps_encode_op->output_present) {

        if (!ps_encode_op->s_out_buf.u4_bytes) {

            ALOGE("Error: Output present but bytes generated is zero");

            mSignalledError = true;

            work->result = C2_CORRUPTED;

            work->workletsProcessed = 1u;

            return;

        }

        uint64_t workId = ((uint64_t)s_encode_op.u4_timestamp_high << 32) |

                      s_encode_op.u4_timestamp_low;

        finishWork(workId, work, &s_encode_op);

        uint64_t workId = ((uint64_t)ps_encode_op->u4_timestamp_high << 32) |

                      ps_encode_op->u4_timestamp_low;

        finishWork(workId, work, ps_encode_op);

    }

    if (mSawInputEOS) {

        drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work);
@@ -1671,9 +1678,11 @@ c2_status_t C2SoftAvcEnc::drainInternal( 
            ALOGE("graphic view map failed %d", wView.error());

            return C2_CORRUPTED;

        }

        ive_video_encode_ip_t s_encode_ip;

        ive_video_encode_op_t s_encode_op;

        if (C2_OK != setEncodeArgs(&s_encode_ip, &s_encode_op, nullptr,

        ih264e_video_encode_ip_t s_video_encode_ip = {};

        ih264e_video_encode_op_t s_video_encode_op = {};

        ive_video_encode_ip_t *ps_encode_ip = &s_video_encode_ip.s_ive_ip;

        ive_video_encode_op_t *ps_encode_op = &s_video_encode_op.s_ive_op;

        if (C2_OK != setEncodeArgs(ps_encode_ip, ps_encode_op, nullptr,

                                   wView.base(), wView.capacity(), 0)) {

            ALOGE("setEncodeArgs failed for drainInternal");

            mSignalledError = true;
@@ -1681,9 +1690,9 @@ c2_status_t C2SoftAvcEnc::drainInternal( 
            work->workletsProcessed = 1u;

            return C2_CORRUPTED;

        }

        (void)ive_api_function(mCodecCtx, &s_encode_ip, &s_encode_op);

        (void)ive_api_function(mCodecCtx, &s_video_encode_ip, &s_video_encode_op);



        void *freed = s_encode_op.s_inp_buf.apv_bufs[0];

        void *freed = ps_encode_op->s_inp_buf.apv_bufs[0];

        /* If encoder frees up an input buffer, mark it as free */

        if (freed != nullptr) {

            if (mBuffers.count(freed) == 0u) {
@@ -1695,10 +1704,10 @@ c2_status_t C2SoftAvcEnc::drainInternal( 
            }

        }



        if (s_encode_op.output_present) {

            uint64_t workId = ((uint64_t)s_encode_op.u4_timestamp_high << 32) |

                          s_encode_op.u4_timestamp_low;

            finishWork(workId, work, &s_encode_op);

        if (ps_encode_op->output_present) {

            uint64_t workId = ((uint64_t)ps_encode_op->u4_timestamp_high << 32) |

                          ps_encode_op->u4_timestamp_low;

            finishWork(workId, work, ps_encode_op);

        } else {

            if (work->workletsProcessed != 1u) {

                work->worklets.front()->output.flags = work->input.flags;

media/codec2/components/avc/C2SoftAvcEnc.h

+1 −2
Original line number Diff line number Diff line
@@ -24,8 +24,7 @@ 
#include <SimpleC2Component.h>



#include "ih264_typedefs.h"

#include "iv2.h"

#include "ive2.h"

#include "ih264e.h"



namespace android {