/*
*
* Copyright 2015 Rockchip Electronics Co. LTD
*
* 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 MODULE_TAG "h264d_api"

#include <string.h>

#include "mpp_env.h"
#include "mpp_platform.h"
#include "mpp_packet_impl.h"

#include "h264d_api.h"
#include "h264d_global.h"
#include "h264d_parse.h"
#include "h264d_sps.h"
#include "h264d_slice.h"
#include "h264d_dpb.h"
#include "h264d_init.h"
#include "mpp_dec_cb_param.h"

RK_U32 rkv_h264d_parse_debug = 0;

static MPP_RET free_input_ctx(H264dInputCtx_t *p_Inp)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, !p_Inp);
    close_stream_file(p_Inp);
    MPP_FREE(p_Inp->spspps_buf);

__RETURN:
    return ret = MPP_OK;
}
static MPP_RET init_input_ctx(H264dInputCtx_t *p_Inp, ParserCfg *init)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, !p_Inp && !init);

    mpp_env_get_u32("rkv_h264d_mvc_disable", &p_Inp->mvc_disable, 1);
    open_stream_file(p_Inp, "/sdcard");
    if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
        p_Inp->spspps_size = HEAD_BUF_MAX_SIZE;
        p_Inp->spspps_buf = mpp_malloc_size(RK_U8, p_Inp->spspps_size);
        MEM_CHECK(ret, p_Inp->spspps_buf);
    }

__RETURN:
    return ret = MPP_OK;
__FAILED:
    free_input_ctx(p_Inp);
    return ret;
}


static MPP_RET free_cur_ctx(H264dCurCtx_t *p_Cur)
{
    RK_U32 i = 0;
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, !p_Cur);

    if (p_Cur) {
        for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
            MPP_FREE(p_Cur->listP[i]);
            MPP_FREE(p_Cur->listB[i]);
        }
        MPP_FREE(p_Cur->strm.nalu_buf);
        MPP_FREE(p_Cur->strm.head_buf);

        for (i = 0; i < MAX_MARKING_TIMES; i++)
            MPP_FREE(p_Cur->dec_ref_pic_marking_buffer[i]);

        MPP_FREE(p_Cur->subsps);
        MPP_FREE(p_Cur->sei);
    }

__RETURN:
    return ret = MPP_OK;
}
static MPP_RET init_cur_ctx(H264dCurCtx_t *p_Cur)
{
    RK_U32 i = 0;
    MPP_RET ret = MPP_ERR_UNKNOW;
    H264dCurStream_t *p_strm = NULL;

    INP_CHECK(ret, !p_Cur);

    p_strm = &p_Cur->strm;
    p_strm->nalu_max_size = NALU_BUF_MAX_SIZE;
    p_strm->nalu_buf = mpp_malloc_size(RK_U8, p_strm->nalu_max_size);
    p_strm->head_max_size = HEAD_BUF_MAX_SIZE;
    p_strm->head_buf = mpp_malloc_size(RK_U8, p_strm->head_max_size);
    MEM_CHECK(ret, p_strm->nalu_buf && p_strm->head_buf);
    p_strm->prefixdata = 0xffffffff;
    for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
        p_Cur->listP[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*));
        p_Cur->listB[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*));
        MEM_CHECK(ret, p_Cur->listP[i] && p_Cur->listB[i]); // +1 for reordering
    }
    reset_cur_slice(p_Cur, &p_Cur->slice);

__RETURN:
    return ret = MPP_OK;
__FAILED:
    free_cur_ctx(p_Cur);

    return ret;
}


static MPP_RET free_vid_ctx(H264dVideoCtx_t *p_Vid)
{
    RK_U32 i = 0;
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, !p_Vid);

    for (i = 0; i < MAXSPS; i++) {
        if (p_Vid->subspsSet[i])
            recycle_subsps(p_Vid->subspsSet[i]);
    }
    for (i = 0; i < MAXSPS; i++) {
        MPP_FREE(p_Vid->spsSet[i]);
        MPP_FREE(p_Vid->ppsSet[i]);
        MPP_FREE(p_Vid->subspsSet[i]);
    }
    for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
        free_dpb(p_Vid->p_Dpb_layer[i]);
        MPP_FREE(p_Vid->p_Dpb_layer[i]);
    }
    free_storable_picture(p_Vid->p_Dec, p_Vid->dec_pic);
    if (p_Vid->pic_st) {
        mpp_mem_pool_deinit(p_Vid->pic_st);
        p_Vid->pic_st = NULL;
    }

__RETURN:
    return ret = MPP_OK;
}
static MPP_RET init_vid_ctx(H264dVideoCtx_t *p_Vid)
{
    RK_U32 i = 0;
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, !p_Vid);

    for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
        p_Vid->p_Dpb_layer[i] = mpp_calloc(H264_DpbBuf_t, 1);
        MEM_CHECK(ret, p_Vid->p_Dpb_layer[i]);
        p_Vid->p_Dpb_layer[i]->layer_id  = i;
        p_Vid->p_Dpb_layer[i]->p_Vid     = p_Vid;
        p_Vid->p_Dpb_layer[i]->init_done = 0;
        p_Vid->p_Dpb_layer[i]->poc_interval = 2;
    }

    //!< init active_sps
    p_Vid->active_sps       = NULL;
    p_Vid->active_subsps    = NULL;
    p_Vid->active_sps_id[0] = -1;
    p_Vid->active_sps_id[1] = -1;
    p_Vid->pic_st = mpp_mem_pool_init(sizeof(H264_StorePic_t));
__RETURN:
    return ret = MPP_OK;
__FAILED:
    free_vid_ctx(p_Vid);

    return ret;
}

static MPP_RET free_dxva_ctx(H264dDxvaCtx_t *p_dxva)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, NULL == p_dxva);

    MPP_FREE(p_dxva->slice_long);
    MPP_FREE(p_dxva->bitstream);
    MPP_FREE(p_dxva->syn.buf);

__RETURN:
    return ret = MPP_OK;
}

static MPP_RET init_dxva_ctx(H264dDxvaCtx_t *p_dxva)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, !p_dxva);

    p_dxva->slice_count    = 0;
    p_dxva->max_slice_size = MAX_SLICE_NUM;
    p_dxva->max_strm_size  = BITSTREAM_MAX_SIZE;
    p_dxva->slice_long  = mpp_calloc(DXVA_Slice_H264_Long,  p_dxva->max_slice_size);
    MEM_CHECK(ret, p_dxva->slice_long);
    p_dxva->bitstream   = mpp_malloc(RK_U8, p_dxva->max_strm_size);
    p_dxva->syn.buf     = mpp_calloc(DXVA2_DecodeBufferDesc, SYNTAX_BUF_SIZE);
    MEM_CHECK(ret, p_dxva->bitstream && p_dxva->syn.buf);

__RETURN:
    return ret = MPP_OK;

__FAILED:
    return ret;
}

static MPP_RET free_dec_ctx(H264_DecCtx_t *p_Dec)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, NULL == p_Dec);

    if (p_Dec->mem) {
        free_dxva_ctx(&p_Dec->mem->dxva_ctx);
        MPP_FREE(p_Dec->mem);
    }
    //!< free mpp packet
    mpp_packet_deinit(&p_Dec->task_pkt);

__RETURN:
    return ret = MPP_OK;
}
static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
{
    RK_U32 i = 0;
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, !p_Dec);

    p_Dec->mem = mpp_calloc(H264_DecMem_t, 1);
    MEM_CHECK(ret, p_Dec->mem);
    p_Dec->dpb_mark         = p_Dec->mem->dpb_mark;           //!< for write out, MAX_DPB_SIZE
    p_Dec->dpb_info         = p_Dec->mem->dpb_info;           //!< 16
    p_Dec->refpic_info_p    = p_Dec->mem->refpic_info_p;      //!< 32
    p_Dec->refpic_info_b[0] = p_Dec->mem->refpic_info_b[0];   //!< [2][32]
    p_Dec->refpic_info_b[1] = p_Dec->mem->refpic_info_b[1];   //!< [2][32]
    //!< init dxva memory
    p_Dec->mem->dxva_ctx.p_Dec = p_Dec;
    FUN_CHECK(ret = init_dxva_ctx(&p_Dec->mem->dxva_ctx));
    p_Dec->dxva_ctx = &p_Dec->mem->dxva_ctx;
    //!< init Dpb_memory Mark
    for (i = 0; i < MAX_MARK_SIZE; i++) {
        reset_dpb_mark(&p_Dec->dpb_mark[i]);
        p_Dec->dpb_mark[i].mark_idx = i;
    }
    mpp_buf_slot_setup(p_Dec->frame_slots, MAX_MARK_SIZE);
    //!< malloc mpp packet
    mpp_packet_init(&p_Dec->task_pkt, p_Dec->dxva_ctx->bitstream, p_Dec->dxva_ctx->max_strm_size);
    MEM_CHECK(ret, p_Dec->task_pkt);
    //!< set Dec support decoder method
    p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME;
    p_Dec->next_state = SliceSTATE_ResetSlice;
    p_Dec->nalu_ret = NALU_NULL;
    p_Dec->have_slice_data = 0;
    p_Dec->last_frame_slot_idx = -1;
    memset(&p_Dec->errctx, 0, sizeof(H264dErrCtx_t));
__RETURN:
    return ret = MPP_OK;

__FAILED:
    free_dec_ctx(p_Dec);

    return ret;
}

static MPP_RET h264d_flush_dpb_eos(H264_DecCtx_t *p_Dec)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    INP_CHECK(ret, !p_Dec->p_Vid);

    FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[0], 1));
    FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[0], 1));
    if (p_Dec->mvc_valid) {
        // layer_id == 1
        FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[1], 1));
        FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[1], 2));
    }

    flush_dpb_buf_slot(p_Dec);

__RETURN:
    return ret = MPP_OK;
__FAILED:
    return ret = MPP_NOK;
}
/*!
***********************************************************************
* \brief
*   alloc all buffer
***********************************************************************
*/

MPP_RET h264d_init(void *decoder, ParserCfg *init)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
    INP_CHECK(ret, !p_Dec);
    memset(p_Dec, 0, sizeof(H264_DecCtx_t));

    mpp_env_get_u32("rkv_h264d_debug", &rkv_h264d_parse_debug, H264D_DBG_ERROR);

    //!< get init frame_slots and packet_slots
    p_Dec->frame_slots  = init->frame_slots;
    p_Dec->packet_slots = init->packet_slots;
    p_Dec->cfg = init->cfg;
    mpp_frame_init(&p_Dec->curframe);
    //!< malloc decoder buffer
    p_Dec->p_Inp = mpp_calloc(H264dInputCtx_t, 1);
    p_Dec->p_Cur = mpp_calloc(H264dCurCtx_t, 1);
    p_Dec->p_Vid = mpp_calloc(H264dVideoCtx_t, 1);
    MEM_CHECK(ret, p_Dec->p_Inp && p_Dec->p_Cur && p_Dec->p_Vid);
    p_Dec->p_Inp->p_Dec = p_Dec;
    p_Dec->p_Inp->p_Cur = p_Dec->p_Cur;
    p_Dec->p_Inp->p_Vid = p_Dec->p_Vid;

    p_Dec->p_Cur->p_Dec = p_Dec;
    p_Dec->p_Cur->p_Inp = p_Dec->p_Inp;
    p_Dec->p_Cur->p_Vid = p_Dec->p_Vid;

    p_Dec->p_Vid->p_Dec = p_Dec;
    p_Dec->p_Vid->p_Inp = p_Dec->p_Inp;
    p_Dec->p_Vid->p_Cur = p_Dec->p_Cur;
    p_Dec->hw_info      = init->hw_info;
    FUN_CHECK(ret = init_input_ctx(p_Dec->p_Inp, init));
    FUN_CHECK(ret = init_cur_ctx(p_Dec->p_Cur));
    FUN_CHECK(ret = init_vid_ctx(p_Dec->p_Vid));
    FUN_CHECK(ret = init_dec_ctx(p_Dec));
    p_Dec->immediate_out = p_Dec->cfg->base.fast_out;
__RETURN:
    return ret = MPP_OK;
__FAILED:
    h264d_deinit(decoder);

    return ret;
}
/*!
***********************************************************************
* \brief
*   free all buffer
***********************************************************************
*/
MPP_RET h264d_deinit(void *decoder)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;

    INP_CHECK(ret, !decoder);

    mpp_frame_deinit(&p_Dec->curframe);
    free_input_ctx(p_Dec->p_Inp);
    MPP_FREE(p_Dec->p_Inp);
    free_cur_ctx(p_Dec->p_Cur);
    MPP_FREE(p_Dec->p_Cur);
    free_vid_ctx(p_Dec->p_Vid);
    MPP_FREE(p_Dec->p_Vid);
    free_dec_ctx(p_Dec);

__RETURN:
    return ret = MPP_OK;
}
/*!
***********************************************************************
* \brief
*   reset
***********************************************************************
*/
MPP_RET h264d_reset(void *decoder)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
    H264dCurStream_t *p_strm = NULL;

    INP_CHECK(ret, !decoder);

    FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[0], 1));
    FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[0], 1));
    if (p_Dec->mvc_valid) {
        // layer_id == 1
        FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[1], 1));
        FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[1], 2));
    }
    flush_dpb_buf_slot(p_Dec);
    //!< reset input parameter
    p_Dec->p_Inp->in_buf        = NULL;
    p_Dec->p_Inp->pkt_eos       = 0;
    p_Dec->p_Inp->task_eos      = 0;
    p_Dec->p_Inp->in_pts        = 0;
    p_Dec->p_Inp->in_dts        = 0;
    p_Dec->p_Inp->has_get_eos   = 0;
    //!< reset video parameter
    p_Dec->p_Vid->have_outpicture_flag = 0;
    p_Dec->p_Vid->exit_picture_flag    = 0;
    p_Dec->p_Vid->active_mvc_sps_flag  = 0;
    p_Dec->p_Vid->g_framecnt           = 0;
    p_Dec->p_Vid->dec_pic = NULL;
    p_Dec->p_Vid->last_pic = NULL;
    memset(&p_Dec->p_Vid->old_pic, 0, sizeof(H264_StorePic_t));
    memset(&p_Dec->errctx, 0, sizeof(H264dErrCtx_t));
    //!< reset current time stamp
    p_Dec->p_Cur->last_dts  = 0;
    p_Dec->p_Cur->last_pts  = 0;
    p_Dec->p_Cur->curr_dts  = 0;
    p_Dec->p_Cur->curr_pts  = 0;
    //!< reset current stream
    p_strm = &p_Dec->p_Cur->strm;
    p_strm->prefixdata      = 0xffffffff;
    p_strm->nalu_offset     = 0;
    p_strm->nalu_len        = 0;
    p_strm->head_offset     = 0;
    p_strm->startcode_found = 0;
    p_strm->endcode_found   = 0;
    p_strm->startcode_found = p_Dec->p_Inp->is_nalff;
    //!< reset decoder parameter
    p_Dec->next_state = SliceSTATE_ResetSlice;
    p_Dec->nalu_ret = NALU_NULL;
    p_Dec->have_slice_data = 0;
    p_Dec->is_new_frame   = 0;
    p_Dec->is_parser_end  = 0;
    p_Dec->dxva_ctx->strm_offset = 0;
    p_Dec->dxva_ctx->slice_count = 0;
    p_Dec->last_frame_slot_idx   = -1;

__RETURN:
    return ret = MPP_OK;
__FAILED:
    return ret = MPP_NOK;
}

/*!
***********************************************************************
* \brief
*   flush
***********************************************************************
*/
MPP_RET  h264d_flush(void *decoder)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;

    INP_CHECK(ret, !decoder);
    INP_CHECK(ret, !p_Dec->p_Inp);
    INP_CHECK(ret, !p_Dec->p_Vid);

    FUN_CHECK(ret = output_dpb(p_Dec, p_Dec->p_Vid->p_Dpb_layer[0]));
    if (p_Dec->mvc_valid) {
        FUN_CHECK(ret = output_dpb(p_Dec, p_Dec->p_Vid->p_Dpb_layer[1]));
    }

__RETURN:
    return ret = MPP_OK;
__FAILED:
    return ret = MPP_NOK;
}

/*!
***********************************************************************
* \brief
*   control/perform
***********************************************************************
*/
MPP_RET  h264d_control(void *decoder, MpiCmd cmd_type, void *param)
{
    (void) decoder;
    (void) cmd_type;
    (void) param;
    return MPP_OK;
}


/*!
***********************************************************************
* \brief
*   prepare
***********************************************************************
*/
#define MAX_STREM_IN_SIZE         (10*1024*1024)
MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    H264dInputCtx_t *p_Inp = NULL;
    H264_DecCtx_t   *p_Dec = (H264_DecCtx_t *)decoder;

    INP_CHECK(ret, !decoder && !pkt && !task);

    p_Inp = p_Dec->p_Inp;
    if (p_Inp->has_get_eos || p_Dec->errctx.un_spt_flag) {
        mpp_packet_set_length(pkt, 0);
        goto __RETURN;
    }
    p_Inp->in_pkt = pkt;
    p_Inp->in_pts = mpp_packet_get_pts(pkt);
    p_Inp->in_dts = mpp_packet_get_dts(pkt);
    p_Inp->in_length = mpp_packet_get_length(pkt);
    p_Inp->pkt_eos = mpp_packet_get_eos(pkt);
    p_Inp->in_buf = (RK_U8 *)mpp_packet_get_pos(pkt);

    if (p_Inp->pkt_eos) {
        p_Inp->has_get_eos = 1;
        if (p_Inp->in_length < 4) {
            p_Inp->in_buf      = NULL;
            p_Inp->in_length   = 0;
            task->flags.eos = p_Inp->pkt_eos;
            h264d_flush_dpb_eos(p_Dec);
            goto __RETURN;
        }
    }

    if (p_Inp->in_length > MAX_STREM_IN_SIZE) {
        H264D_ERR("[pkt_in_timeUs] input error, stream too large, pts=%lld, eos=%d, len=%d, pkt_no=%d",
                  p_Inp->in_pts, p_Inp->pkt_eos, p_Inp->in_length, p_Dec->p_Vid->g_framecnt);
        mpp_packet_set_length(pkt, 0);
        ret = MPP_NOK;
        goto __FAILED;
    }
    //!< avcC stream
    if (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA) {
        RK_U8 *pdata = p_Inp->in_buf;

        p_Inp->is_nalff = (p_Inp->in_length > 3) &&
                          (pdata[0] || pdata[1] || (pdata[2] > 1) || (!pdata[2] && pdata[3] > 1));
        mpp_log("is_avcC=%d\n", p_Inp->is_nalff);
        if (p_Inp->is_nalff) {
            (ret = parse_prepare_avcC_header(p_Inp, p_Dec->p_Cur));
            goto __RETURN;
        }
    }
    H264D_DBG(H264D_DBG_INPUT, "[pkt_in_timeUs] is_avcC=%d, in_pts=%lld, pkt_eos=%d, len=%d, pkt_no=%d",
              p_Inp->is_nalff, p_Inp->in_pts, p_Inp->pkt_eos, p_Inp->in_length, p_Dec->p_Vid->g_framecnt);
    if (p_Inp->is_nalff) {
        (ret = parse_prepare_avcC_data(p_Inp, p_Dec->p_Cur));
        task->valid = p_Inp->task_valid;  //!< prepare valid flag
    } else  {
        fwrite_stream_to_file(p_Inp, p_Inp->in_buf, (RK_U32)p_Inp->in_length);
        do {
            if (p_Dec->cfg->base.split_parse) {
                ret = parse_prepare(p_Inp, p_Dec->p_Cur);
            } else {
                ret = parse_prepare_fast(p_Inp, p_Dec->p_Cur);
            }
            task->valid = p_Inp->task_valid;  //!< prepare valid flag
        } while (mpp_packet_get_length(pkt) && !task->valid);
    }
    task->flags.eos = p_Inp->pkt_eos;
    if (task->valid) {
        memset(p_Dec->dxva_ctx->bitstream + p_Dec->dxva_ctx->strm_offset, 0,
               MPP_ALIGN(p_Dec->dxva_ctx->strm_offset, 16) - p_Dec->dxva_ctx->strm_offset);
        mpp_packet_set_data(p_Dec->task_pkt, p_Dec->dxva_ctx->bitstream);
        mpp_packet_set_length(p_Dec->task_pkt, MPP_ALIGN(p_Dec->dxva_ctx->strm_offset, 16));
        mpp_packet_set_size(p_Dec->task_pkt, p_Dec->dxva_ctx->max_strm_size);
        task->input_packet = p_Dec->task_pkt;
    } else {
        task->input_packet = NULL;
    }
__RETURN:

    return ret = MPP_OK;
__FAILED:
    return ret;
}


/*!
***********************************************************************
* \brief
*   parser
***********************************************************************
*/
MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
    H264dErrCtx_t *p_err = &p_Dec->errctx;

    in_task->valid = 0;
    p_Dec->in_task = in_task;
    p_err->cur_err_flag  = 0;
    p_err->used_ref_flag = 0;
    p_Dec->is_parser_end = 0;
    if (p_Dec->p_Cur->sei)
        memset(p_Dec->p_Cur->sei, 0, sizeof(*p_Dec->p_Cur->sei));

    ret = parse_loop(p_Dec);
    if (ret) {
        in_task->flags.parse_err = 1;
    }

    if (p_Dec->is_parser_end) {
        p_Dec->is_parser_end = 0;
        p_Dec->p_Vid->g_framecnt++;
        ret = update_dpb(p_Dec);
        if (ret) {
            in_task->flags.ref_err = 1;
        }
        if (in_task->flags.eos) {
            h264d_flush_dpb_eos(p_Dec);
        }
    }
    in_task->valid = 1;
    if (!in_task->flags.parse_err) {
        in_task->syntax.number = p_Dec->dxva_ctx->syn.num;
        in_task->syntax.data   = (void *)p_Dec->dxva_ctx->syn.buf;
        in_task->flags.used_for_ref = p_err->used_ref_flag;
        in_task->flags.ref_err |= (!p_Dec->cfg->base.disable_error
                                   && (p_err->dpb_err_flag | p_err->cur_err_flag)) ? 1 : 0;
    }

    return ret;
}

/*!
***********************************************************************
* \brief
*   callback
***********************************************************************
*/
MPP_RET h264d_callback(void *decoder, void *errinfo)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
    DecCbHalDone *ctx = (DecCbHalDone *)errinfo;

    INP_CHECK(ret, !decoder);

    {
        MppFrame mframe = NULL;
        HalDecTask *task_dec = (HalDecTask *)ctx->task;

        if (task_dec->output >= 0)
            mpp_buf_slot_get_prop(p_Dec->frame_slots, task_dec->output, SLOT_FRAME_PTR, &mframe);

        if (mframe) {
            RK_U32 task_err = task_dec->flags.parse_err || task_dec->flags.ref_err;
            if (ctx->hard_err || task_err) {
                if (task_dec->flags.used_for_ref) {
                    mpp_frame_set_errinfo(mframe, MPP_FRAME_ERR_UNKNOW);
                } else {
                    mpp_frame_set_discard(mframe, MPP_FRAME_ERR_UNKNOW);
                }
            }
            H264D_DBG(H264D_DBG_CALLBACK, "[CALLBACK] g_no=%d, out_idx=%d, dpberr=%d, harderr=%d, ref_flag=%d, errinfo=%d, discard=%d\n",
                      p_Dec->p_Vid->g_framecnt, task_dec->output, task_err, ctx->hard_err, task_dec->flags.used_for_ref,
                      mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe));
        }
    }

__RETURN:
    return ret = MPP_OK;
}
/*!
***********************************************************************
* \brief
*   api struct interface
***********************************************************************
*/

const ParserApi api_h264d_parser = {
    .name = "h264d_parse",
    .coding = MPP_VIDEO_CodingAVC,
    .ctx_size = sizeof(H264_DecCtx_t),
    .flag = 0,
    .init = h264d_init,
    .deinit = h264d_deinit,
    .prepare = h264d_prepare,
    .parse = h264d_parse,
    .reset = h264d_reset,
    .flush = h264d_flush,
    .control = h264d_control,
    .callback = h264d_callback,
};