path: root/system/codecs/c2/decoders/hevcdec/GoldfishHevcHelper.cpp

/*
 * Copyright 2022 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.
 */

#include "GoldfishHevcHelper.h"

#define LOG_TAG "GoldfishHevcHelper"
#include <log/log.h>

#include "ihevc_typedefs.h"
#include "ihevcd_cxa.h"

#define DEBUG 0
#if DEBUG
#define DDD(...) ALOGD(__VA_ARGS__)
#else
#define DDD(...) ((void)0)
#endif


#include <Codec2Mapper.h>

#define ivdec_api_function ihevcd_cxa_api_function
#define ivdext_create_ip_t ihevcd_cxa_create_ip_t
#define ivdext_create_op_t ihevcd_cxa_create_op_t
#define ivdext_delete_ip_t ihevcd_cxa_delete_ip_t
#define ivdext_delete_op_t ihevcd_cxa_delete_op_t
#define ivdext_ctl_set_num_cores_ip_t ihevcd_cxa_ctl_set_num_cores_ip_t
#define ivdext_ctl_set_num_cores_op_t ihevcd_cxa_ctl_set_num_cores_op_t
#define ivdext_ctl_get_vui_params_ip_t ihevcd_cxa_ctl_get_vui_params_ip_t
#define ivdext_ctl_get_vui_params_op_t ihevcd_cxa_ctl_get_vui_params_op_t
#define ALIGN128(x) ((((x) + 127) >> 7) << 7)
#define MAX_NUM_CORES 4
#define IVDEXT_CMD_CTL_SET_NUM_CORES                                           \
    (IVD_CONTROL_API_COMMAND_TYPE_T) IHEVCD_CXA_CMD_CTL_SET_NUM_CORES
#define MIN(a, b) (((a) < (b)) ? (a) : (b))

namespace android {

static void *ivd_aligned_malloc(void *ctxt, WORD32 alignment, WORD32 size) {
    (void) ctxt;
    return memalign(alignment, size);
}

static void ivd_aligned_free(void *ctxt, void *mem) {
    (void) ctxt;
    free(mem);
}


GoldfishHevcHelper::GoldfishHevcHelper(int w, int h):mWidth(w),mHeight(h) { createDecoder(); }

GoldfishHevcHelper::~GoldfishHevcHelper() {
    destroyDecoder();
}

void GoldfishHevcHelper::createDecoder() {
    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;
    s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 0;
    s_create_ip.s_ivd_create_ip_t.e_output_format = mIvColorformat;
    s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ivd_aligned_malloc;
    s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ivd_aligned_free;
    s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = nullptr;
    s_create_op.s_ivd_create_op_t.u4_size = sizeof(ivdext_create_op_t);
    IV_API_CALL_STATUS_T status =
        ivdec_api_function(mDecHandle, &s_create_ip, &s_create_op);
    if (status != IV_SUCCESS) {
        ALOGE("error in %s: 0x%x", __func__,
              s_create_op.s_ivd_create_op_t.u4_error_code);
        return;
    }
    mDecHandle = (iv_obj_t *)s_create_op.s_ivd_create_op_t.pv_handle;
    mDecHandle->pv_fxns = (void *)ivdec_api_function;
    mDecHandle->u4_size = sizeof(iv_obj_t);

    mStride = ALIGN128(mWidth);

    setNumCores();
}

void GoldfishHevcHelper::destroyDecoder() {
    if (mDecHandle) {
        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;
        s_delete_op.s_ivd_delete_op_t.u4_size = sizeof(ivdext_delete_op_t);
        IV_API_CALL_STATUS_T status =
            ivdec_api_function(mDecHandle, &s_delete_ip, &s_delete_op);
        if (status != IV_SUCCESS) {
            ALOGE("error in %s: 0x%x", __func__,
                  s_delete_op.s_ivd_delete_op_t.u4_error_code);
        }
        mDecHandle = nullptr;
    }
}

void GoldfishHevcHelper::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 = {};

    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;
    s_set_num_cores_ip.e_sub_cmd = IVDEXT_CMD_CTL_SET_NUM_CORES;
    s_set_num_cores_ip.u4_num_cores = mNumCores;
    s_set_num_cores_op.u4_size = sizeof(ivdext_ctl_set_num_cores_op_t);
    IV_API_CALL_STATUS_T status = ivdec_api_function(
        mDecHandle, &s_set_num_cores_ip, &s_set_num_cores_op);
    if (IV_SUCCESS != status) {
        DDD("error in %s: 0x%x", __func__, s_set_num_cores_op.u4_error_code);
    }
}

void GoldfishHevcHelper::resetDecoder() {
    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;
    s_reset_ip.e_sub_cmd = IVD_CMD_CTL_RESET;
    s_reset_op.u4_size = sizeof(ivd_ctl_reset_op_t);
    IV_API_CALL_STATUS_T status =
        ivdec_api_function(mDecHandle, &s_reset_ip, &s_reset_op);
    if (IV_SUCCESS != status) {
        ALOGE("error in %s: 0x%x", __func__, s_reset_op.u4_error_code);
    }
    setNumCores();
}

void GoldfishHevcHelper::setParams(size_t stride,
                                   IVD_VIDEO_DECODE_MODE_T dec_mode) {
    ihevcd_cxa_ctl_set_config_ip_t s_hevcd_set_dyn_params_ip = {};
    ihevcd_cxa_ctl_set_config_op_t s_hevcd_set_dyn_params_op = {};
    ivd_ctl_set_config_ip_t *ps_set_dyn_params_ip =
        &s_hevcd_set_dyn_params_ip.s_ivd_ctl_set_config_ip_t;
    ivd_ctl_set_config_op_t *ps_set_dyn_params_op =
        &s_hevcd_set_dyn_params_op.s_ivd_ctl_set_config_op_t;

    ps_set_dyn_params_ip->u4_size = sizeof(ihevcd_cxa_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(ihevcd_cxa_ctl_set_config_op_t);
    IV_API_CALL_STATUS_T status = ivdec_api_function(
        mDecHandle, ps_set_dyn_params_ip, ps_set_dyn_params_op);
    if (status != IV_SUCCESS) {
        ALOGE("error in %s: 0x%x", __func__,
              ps_set_dyn_params_op->u4_error_code);
    }
}

bool GoldfishHevcHelper::isVpsFrame(const uint8_t* frame, int inSize) {
    if (inSize < 5) return false;
    if (frame[0] == 0 && frame[1] == 0 && frame[2] == 0 && frame[3] == 1) {
        const bool forbiddenBitIsInvalid = 0x80 & frame[4];
        if (forbiddenBitIsInvalid) {
            return false;
        }
        // nalu type is the lower 6 bits after shiftting to right 1 bit
        uint8_t naluType = 0x3f & (frame[4] >> 1);
        if (naluType == 32
            || naluType == 33
            || naluType == 34
                ) return true;
        else return false;
    } else {
        return false;
    }
}

bool GoldfishHevcHelper::decodeHeader(const uint8_t *frame, int inSize) {
    // should we check the header for vps/sps/pps frame ? otherwise
    // there is no point calling decoder
    if (!isVpsFrame(frame, inSize)) {
        DDD("could not find valid vps frame");
        return false;
    } else {
        DDD("found valid vps frame");
    }

    ihevcd_cxa_video_decode_ip_t s_hevcd_decode_ip = {};
    ihevcd_cxa_video_decode_op_t s_hevcd_decode_op = {};
    ivd_video_decode_ip_t *ps_decode_ip =
        &s_hevcd_decode_ip.s_ivd_video_decode_ip_t;
    ivd_video_decode_op_t *ps_decode_op =
        &s_hevcd_decode_op.s_ivd_video_decode_op_t;

    // setup input/output arguments to decoder
    setDecodeArgs(ps_decode_ip, ps_decode_op, frame, mStride,
            0, // offset
            inSize, // size
            0 // time-stamp, does not matter
            );

    setParams(mStride, IVD_DECODE_HEADER);

    // now kick off the decoding
    IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, ps_decode_ip, ps_decode_op);
    if (status != IV_SUCCESS) {
        ALOGE("failed to call decoder function for header\n");
        ALOGE("error in %s: 0x%x", __func__,
              ps_decode_op->u4_error_code);
    }

    if (IVD_RES_CHANGED == (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {
        DDD("resolution changed, reset decoder");
        resetDecoder();
        setParams(mStride, IVD_DECODE_HEADER);
        ivdec_api_function(mDecHandle, ps_decode_ip, ps_decode_op);
    }

    // get the w/h and update
    if (0 < ps_decode_op->u4_pic_wd && 0 < ps_decode_op->u4_pic_ht) {
        DDD("success decode w/h %d %d", ps_decode_op->u4_pic_wd , ps_decode_op->u4_pic_ht);
        DDD("existing w/h %d %d", mWidth, mHeight);
        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;
            return true;
        } else {
            DDD("success decode w/h, but they are the same %d %d", ps_decode_op->u4_pic_wd , ps_decode_op->u4_pic_ht);
        }
    } else {
        ALOGE("could not decode w/h");
    }

    // get output delay
    if (ps_decode_op->i4_reorder_depth >= 0) {
        if (mOutputDelay != ps_decode_op->i4_reorder_depth) {
            mOutputDelay = ps_decode_op->i4_reorder_depth;
            DDD("New Output delay %d ", mOutputDelay);
        } else {
            DDD("same Output delay %d ", mOutputDelay);
        }
    }

    return false;
}

bool GoldfishHevcHelper::setDecodeArgs(ivd_video_decode_ip_t *ps_decode_ip,
                                       ivd_video_decode_op_t *ps_decode_op,
                                       const uint8_t *inBuffer,
                                       uint32_t displayStride, size_t inOffset,
                                       size_t inSize, uint32_t tsMarker) {
    uint32_t displayHeight = mHeight;
    size_t lumaSize = displayStride * displayHeight;
    size_t chromaSize = lumaSize >> 2;

    if (mStride != displayStride) {
        mStride = displayStride;
    }

    // force decoder to always decode header and get dimensions,
    // hope this will be quick and cheap
    setParams(mStride, IVD_DECODE_HEADER);

    ps_decode_ip->u4_size = sizeof(ihevcd_cxa_video_decode_ip_t);
    ps_decode_ip->e_cmd = IVD_CMD_VIDEO_DECODE;
    if (inBuffer) {
        ps_decode_ip->u4_ts = tsMarker;
        ps_decode_ip->pv_stream_buffer = const_cast<uint8_t *>(inBuffer) + inOffset;
        ps_decode_ip->u4_num_Bytes = inSize;
    } else {
        ps_decode_ip->u4_ts = 0;
        ps_decode_ip->pv_stream_buffer = nullptr;
        ps_decode_ip->u4_num_Bytes = 0;
    }
    DDD("setting pv_stream_buffer 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",
            ((uint8_t*)(ps_decode_ip->pv_stream_buffer))[0],
            ((uint8_t*)(ps_decode_ip->pv_stream_buffer))[1],
            ((uint8_t*)(ps_decode_ip->pv_stream_buffer))[2],
            ((uint8_t*)(ps_decode_ip->pv_stream_buffer))[3],
            ((uint8_t*)(ps_decode_ip->pv_stream_buffer))[4],
            ((uint8_t*)(ps_decode_ip->pv_stream_buffer))[5],
            ((uint8_t*)(ps_decode_ip->pv_stream_buffer))[6],
            ((uint8_t*)(ps_decode_ip->pv_stream_buffer))[7]
            );
    DDD("input bytes %d", ps_decode_ip->u4_num_Bytes);

    ps_decode_ip->s_out_buffer.u4_min_out_buf_size[0] = lumaSize;
    ps_decode_ip->s_out_buffer.u4_min_out_buf_size[1] = chromaSize;
    ps_decode_ip->s_out_buffer.u4_min_out_buf_size[2] = chromaSize;
    {
        ps_decode_ip->s_out_buffer.pu1_bufs[0] = nullptr;
        ps_decode_ip->s_out_buffer.pu1_bufs[1] = nullptr;
        ps_decode_ip->s_out_buffer.pu1_bufs[2] = nullptr;
    }
    ps_decode_ip->s_out_buffer.u4_num_bufs = 3;
    ps_decode_op->u4_size = sizeof(ihevcd_cxa_video_decode_op_t);
    ps_decode_op->u4_output_present = 0;

    return true;
}

} // namespace android