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

Commit 5ea81b5e authored by Ray Essick's avatar Ray Essick Committed by Automerger Merge Worker
Browse files

Merge "C2SoftAvcDec: add support to use ih264d instead of ivd structures" am: e69e915f 

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

Change-Id: I5e1c07f8733c250b1c73bf8e715d60b7da33bf55
parents 0677f5b8 e69e915f

media/codec2/components/avc/C2SoftAvcDec.cpp

+76 −66
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ 
#include <SimpleC2Interface.h>



#include "C2SoftAvcDec.h"

#include "ih264d.h"



namespace android {
@@ -391,12 +390,14 @@ c2_status_t C2SoftAvcDec::onFlush_sm() { 
    }



    while (true) {

        ivd_video_decode_ip_t s_decode_ip;

        ivd_video_decode_op_t s_decode_op;



        setDecodeArgs(&s_decode_ip, &s_decode_op, nullptr, nullptr, 0, 0, 0);

        (void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op);

        if (0 == s_decode_op.u4_output_present) {

        ih264d_video_decode_ip_t s_h264d_decode_ip = {};

        ih264d_video_decode_op_t s_h264d_decode_op = {};

        ivd_video_decode_ip_t *ps_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;

        ivd_video_decode_op_t *ps_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;



        setDecodeArgs(ps_decode_ip, ps_decode_op, nullptr, nullptr, 0, 0, 0);

        (void) ivdec_api_function(mDecHandle, &s_h264d_decode_ip, &s_h264d_decode_op);

        if (0 == ps_decode_op->u4_output_present) {

            resetPlugin();

            break;

        }
@@ -411,8 +412,8 @@ c2_status_t C2SoftAvcDec::onFlush_sm() { 
}



status_t C2SoftAvcDec::createDecoder() {

    ivdext_create_ip_t s_create_ip;

    ivdext_create_op_t s_create_op;

    ivdext_create_ip_t s_create_ip = {};

    ivdext_create_op_t s_create_op = {};



    s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ivdext_create_ip_t);

    s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
@@ -438,8 +439,8 @@ status_t C2SoftAvcDec::createDecoder() { 
}



status_t C2SoftAvcDec::setNumCores() {

    ivdext_ctl_set_num_cores_ip_t s_set_num_cores_ip;

    ivdext_ctl_set_num_cores_op_t s_set_num_cores_op;

    ivdext_ctl_set_num_cores_ip_t s_set_num_cores_ip = {};

    ivdext_ctl_set_num_cores_op_t s_set_num_cores_op = {};



    s_set_num_cores_ip.u4_size = sizeof(ivdext_ctl_set_num_cores_ip_t);

    s_set_num_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL;
@@ -458,22 +459,26 @@ status_t C2SoftAvcDec::setNumCores() { 
}



status_t C2SoftAvcDec::setParams(size_t stride, IVD_VIDEO_DECODE_MODE_T dec_mode) {

    ivd_ctl_set_config_ip_t s_set_dyn_params_ip;

    ivd_ctl_set_config_op_t s_set_dyn_params_op;



    s_set_dyn_params_ip.u4_size = sizeof(ivd_ctl_set_config_ip_t);

    s_set_dyn_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;

    s_set_dyn_params_ip.e_sub_cmd = IVD_CMD_CTL_SETPARAMS;

    s_set_dyn_params_ip.u4_disp_wd = (UWORD32) stride;

    s_set_dyn_params_ip.e_frm_skip_mode = IVD_SKIP_NONE;

    s_set_dyn_params_ip.e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;

    s_set_dyn_params_ip.e_vid_dec_mode = dec_mode;

    s_set_dyn_params_op.u4_size = sizeof(ivd_ctl_set_config_op_t);

    ih264d_ctl_set_config_ip_t s_h264d_set_dyn_params_ip = {};

    ih264d_ctl_set_config_op_t s_h264d_set_dyn_params_op = {};

    ivd_ctl_set_config_ip_t *ps_set_dyn_params_ip =

        &s_h264d_set_dyn_params_ip.s_ivd_ctl_set_config_ip_t;

    ivd_ctl_set_config_op_t *ps_set_dyn_params_op =

        &s_h264d_set_dyn_params_op.s_ivd_ctl_set_config_op_t;



    ps_set_dyn_params_ip->u4_size = sizeof(ih264d_ctl_set_config_ip_t);

    ps_set_dyn_params_ip->e_cmd = IVD_CMD_VIDEO_CTL;

    ps_set_dyn_params_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;

    ps_set_dyn_params_ip->u4_disp_wd = (UWORD32) stride;

    ps_set_dyn_params_ip->e_frm_skip_mode = IVD_SKIP_NONE;

    ps_set_dyn_params_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;

    ps_set_dyn_params_ip->e_vid_dec_mode = dec_mode;

    ps_set_dyn_params_op->u4_size = sizeof(ih264d_ctl_set_config_op_t);

    IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle,

                                                     &s_set_dyn_params_ip,

                                                     &s_set_dyn_params_op);

                                                     &s_h264d_set_dyn_params_ip,

                                                     &s_h264d_set_dyn_params_op);

    if (status != IV_SUCCESS) {

        ALOGE("error in %s: 0x%x", __func__, s_set_dyn_params_op.u4_error_code);

        ALOGE("error in %s: 0x%x", __func__, ps_set_dyn_params_op->u4_error_code);

        return UNKNOWN_ERROR;

    }
@@ -481,8 +486,8 @@ status_t C2SoftAvcDec::setParams(size_t stride, IVD_VIDEO_DECODE_MODE_T dec_mode 
}



void C2SoftAvcDec::getVersion() {

    ivd_ctl_getversioninfo_ip_t s_get_versioninfo_ip;

    ivd_ctl_getversioninfo_op_t s_get_versioninfo_op;

    ivd_ctl_getversioninfo_ip_t s_get_versioninfo_ip = {};

    ivd_ctl_getversioninfo_op_t s_get_versioninfo_op = {};

    UWORD8 au1_buf[512];



    s_get_versioninfo_ip.u4_size = sizeof(ivd_ctl_getversioninfo_ip_t);
@@ -538,7 +543,7 @@ bool C2SoftAvcDec::setDecodeArgs(ivd_video_decode_ip_t *ps_decode_ip, 
        if (OK != setParams(mStride, IVD_DECODE_FRAME)) return false;

    }



    ps_decode_ip->u4_size = sizeof(ivd_video_decode_ip_t);

    ps_decode_ip->u4_size = sizeof(ih264d_video_decode_ip_t);

    ps_decode_ip->e_cmd = IVD_CMD_VIDEO_DECODE;

    if (inBuffer) {

        ps_decode_ip->u4_ts = tsMarker;
@@ -567,14 +572,14 @@ bool C2SoftAvcDec::setDecodeArgs(ivd_video_decode_ip_t *ps_decode_ip, 
        ps_decode_ip->s_out_buffer.pu1_bufs[2] = mOutBufferFlush + lumaSize + chromaSize;

    }

    ps_decode_ip->s_out_buffer.u4_num_bufs = 3;

    ps_decode_op->u4_size = sizeof(ivd_video_decode_op_t);

    ps_decode_op->u4_size = sizeof(ih264d_video_decode_op_t);



    return true;

}



bool C2SoftAvcDec::getVuiParams() {

    ivdext_ctl_get_vui_params_ip_t s_get_vui_params_ip;

    ivdext_ctl_get_vui_params_op_t s_get_vui_params_op;

    ivdext_ctl_get_vui_params_ip_t s_get_vui_params_ip = {};

    ivdext_ctl_get_vui_params_op_t s_get_vui_params_op = {};



    s_get_vui_params_ip.u4_size = sizeof(ivdext_ctl_get_vui_params_ip_t);

    s_get_vui_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
@@ -622,8 +627,8 @@ bool C2SoftAvcDec::getVuiParams() { 
}



status_t C2SoftAvcDec::setFlushMode() {

    ivd_ctl_flush_ip_t s_set_flush_ip;

    ivd_ctl_flush_op_t s_set_flush_op;

    ivd_ctl_flush_ip_t s_set_flush_ip = {};

    ivd_ctl_flush_op_t s_set_flush_op = {};



    s_set_flush_ip.u4_size = sizeof(ivd_ctl_flush_ip_t);

    s_set_flush_ip.e_cmd = IVD_CMD_VIDEO_CTL;
@@ -641,8 +646,8 @@ status_t C2SoftAvcDec::setFlushMode() { 
}



status_t C2SoftAvcDec::resetDecoder() {

    ivd_ctl_reset_ip_t s_reset_ip;

    ivd_ctl_reset_op_t s_reset_op;

    ivd_ctl_reset_ip_t s_reset_ip = {};

    ivd_ctl_reset_op_t s_reset_op = {};



    s_reset_ip.u4_size = sizeof(ivd_ctl_reset_ip_t);

    s_reset_ip.e_cmd = IVD_CMD_VIDEO_CTL;
@@ -671,8 +676,8 @@ void C2SoftAvcDec::resetPlugin() { 


status_t C2SoftAvcDec::deleteDecoder() {

    if (mDecHandle) {

        ivdext_delete_ip_t s_delete_ip;

        ivdext_delete_op_t s_delete_op;

        ivdext_delete_ip_t s_delete_ip = {};

        ivdext_delete_op_t s_delete_op = {};



        s_delete_ip.s_ivd_delete_ip_t.u4_size = sizeof(ivdext_delete_ip_t);

        s_delete_ip.s_ivd_delete_ip_t.e_cmd = IVD_CMD_DELETE;
@@ -837,8 +842,10 @@ void C2SoftAvcDec::process( 
            return;

        }



        ivd_video_decode_ip_t s_decode_ip;

        ivd_video_decode_op_t s_decode_op;

        ih264d_video_decode_ip_t s_h264d_decode_ip = {};

        ih264d_video_decode_op_t s_h264d_decode_op = {};

        ivd_video_decode_ip_t *ps_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;

        ivd_video_decode_op_t *ps_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;

        {

            C2GraphicView wView = mOutBlock->map().get();

            if (wView.error()) {
@@ -846,7 +853,7 @@ void C2SoftAvcDec::process( 
                work->result = wView.error();

                return;

            }

            if (!setDecodeArgs(&s_decode_ip, &s_decode_op, &rView, &wView,

            if (!setDecodeArgs(ps_decode_ip, ps_decode_op, &rView, &wView,

                               inOffset + inPos, inSize - inPos, workIndex)) {

                mSignalledError = true;

                work->workletsProcessed = 1u;
@@ -862,26 +869,27 @@ void C2SoftAvcDec::process( 
            WORD32 delay;

            GETTIME(&mTimeStart, nullptr);

            TIME_DIFF(mTimeEnd, mTimeStart, delay);

            (void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op);

            (void) ivdec_api_function(mDecHandle, &s_h264d_decode_ip, &s_h264d_decode_op);

            WORD32 decodeTime;

            GETTIME(&mTimeEnd, nullptr);

            TIME_DIFF(mTimeStart, mTimeEnd, decodeTime);

            ALOGV("decodeTime=%6d delay=%6d numBytes=%6d", decodeTime, delay,

                  s_decode_op.u4_num_bytes_consumed);

                  ps_decode_op->u4_num_bytes_consumed);

        }

        if (IVD_MEM_ALLOC_FAILED == (s_decode_op.u4_error_code & IVD_ERROR_MASK)) {

        if (IVD_MEM_ALLOC_FAILED == (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {

            ALOGE("allocation failure in decoder");

            mSignalledError = true;

            work->workletsProcessed = 1u;

            work->result = C2_CORRUPTED;

            return;

        } else if (IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED == (s_decode_op.u4_error_code & IVD_ERROR_MASK)) {

        } else if (IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED ==

                (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {

            ALOGE("unsupported resolution : %dx%d", mWidth, mHeight);

            mSignalledError = true;

            work->workletsProcessed = 1u;

            work->result = C2_CORRUPTED;

            return;

        } else if (IVD_RES_CHANGED == (s_decode_op.u4_error_code & IVD_ERROR_MASK)) {

        } else if (IVD_RES_CHANGED == (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {

            ALOGV("resolution changed");

            drainInternal(DRAIN_COMPONENT_NO_EOS, pool, work);

            resetDecoder();
@@ -890,16 +898,16 @@ void C2SoftAvcDec::process( 


            /* Decode header and get new dimensions */

            setParams(mStride, IVD_DECODE_HEADER);

            (void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op);

        } else if (IS_IVD_FATAL_ERROR(s_decode_op.u4_error_code)) {

            ALOGE("Fatal error in decoder 0x%x", s_decode_op.u4_error_code);

            (void) ivdec_api_function(mDecHandle, ps_decode_ip, ps_decode_op);

        } else if (IS_IVD_FATAL_ERROR(ps_decode_op->u4_error_code)) {

            ALOGE("Fatal error in decoder 0x%x", ps_decode_op->u4_error_code);

            mSignalledError = true;

            work->workletsProcessed = 1u;

            work->result = C2_CORRUPTED;

            return;

        }

        if (s_decode_op.i4_reorder_depth >= 0 && mOutputDelay != s_decode_op.i4_reorder_depth) {

            mOutputDelay = s_decode_op.i4_reorder_depth;

        if (ps_decode_op->i4_reorder_depth >= 0 && mOutputDelay != ps_decode_op->i4_reorder_depth) {

            mOutputDelay = ps_decode_op->i4_reorder_depth;

            ALOGV("New Output delay %d ", mOutputDelay);



            C2PortActualDelayTuning::output outputDelay(mOutputDelay);
@@ -917,16 +925,16 @@ void C2SoftAvcDec::process( 
                return;

            }

        }

        if (0 < s_decode_op.u4_pic_wd && 0 < s_decode_op.u4_pic_ht) {

        if (0 < ps_decode_op->u4_pic_wd && 0 < ps_decode_op->u4_pic_ht) {

            if (mHeaderDecoded == false) {

                mHeaderDecoded = true;

                mStride = ALIGN32(s_decode_op.u4_pic_wd);

                mStride = ALIGN32(ps_decode_op->u4_pic_wd);

                setParams(mStride, IVD_DECODE_FRAME);

            }

            if (s_decode_op.u4_pic_wd != mWidth || s_decode_op.u4_pic_ht != mHeight) {

                mWidth = s_decode_op.u4_pic_wd;

                mHeight = s_decode_op.u4_pic_ht;

                CHECK_EQ(0u, s_decode_op.u4_output_present);

            if (ps_decode_op->u4_pic_wd != mWidth || ps_decode_op->u4_pic_ht != mHeight) {

                mWidth = ps_decode_op->u4_pic_wd;

                mHeight = ps_decode_op->u4_pic_ht;

                CHECK_EQ(0u, ps_decode_op->u4_output_present);



                C2StreamPictureSizeInfo::output size(0u, mWidth, mHeight);

                std::vector<std::unique_ptr<C2SettingResult>> failures;
@@ -945,11 +953,11 @@ void C2SoftAvcDec::process( 
            }

        }

        (void)getVuiParams();

        hasPicture |= (1 == s_decode_op.u4_frame_decoded_flag);

        if (s_decode_op.u4_output_present) {

            finishWork(s_decode_op.u4_ts, work);

        hasPicture |= (1 == ps_decode_op->u4_frame_decoded_flag);

        if (ps_decode_op->u4_output_present) {

            finishWork(ps_decode_op->u4_ts, work);

        }

        inPos += s_decode_op.u4_num_bytes_consumed;

        inPos += ps_decode_op->u4_num_bytes_consumed;

    }

    if (eos) {

        drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work);
@@ -987,16 +995,18 @@ c2_status_t C2SoftAvcDec::drainInternal( 
            ALOGE("graphic view map failed %d", wView.error());

            return C2_CORRUPTED;

        }

        ivd_video_decode_ip_t s_decode_ip;

        ivd_video_decode_op_t s_decode_op;

        if (!setDecodeArgs(&s_decode_ip, &s_decode_op, nullptr, &wView, 0, 0, 0)) {

        ih264d_video_decode_ip_t s_h264d_decode_ip = {};

        ih264d_video_decode_op_t s_h264d_decode_op = {};

        ivd_video_decode_ip_t *ps_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;

        ivd_video_decode_op_t *ps_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;

        if (!setDecodeArgs(ps_decode_ip, ps_decode_op, nullptr, &wView, 0, 0, 0)) {

            mSignalledError = true;

            work->workletsProcessed = 1u;

            return C2_CORRUPTED;

        }

        (void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op);

        if (s_decode_op.u4_output_present) {

            finishWork(s_decode_op.u4_ts, work);

        (void) ivdec_api_function(mDecHandle, &s_h264d_decode_ip, &s_h264d_decode_op);

        if (ps_decode_op->u4_output_present) {

            finishWork(ps_decode_op->u4_ts, work);

        } else {

            fillEmptyWork(work);

            break;

media/codec2/components/avc/C2SoftAvcDec.h

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



#include "ih264_typedefs.h"

#include "iv.h"

#include "ivd.h"

#include "ih264d.h"



namespace android {