/******************************************************************************

 *

 * Copyright (C) 2021 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.

 *

 *****************************************************************************

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

 */

/*****************************************************************************/

/*                                                                           */

/*  File Name         : imvcd_api.c                                          */

/*                                                                           */

/*  Description       : Has all MVC API functions                            */

/*                                                                           */

/*                                                                           */

/*  List of Functions :                                                      */

/*                                                                           */

/*****************************************************************************/

#include <string.h>

#include "ih264_typedefs.h"

#include "iv.h"

#include "ivd.h"

#include "imvcd.h"

#include "ih264_debug.h"

#include "ih264_disp_mgr.h"

#include "ih264_error.h"

#include "ih264_buf_mgr.h"

#include "ih264_platform_macros.h"

#include "ih264d_inter_pred.h"

#include "ih264d_structs.h"

#include "ih264d_deblocking.h"

#include "ih264d_error_handler.h"

#include "ih264d_function_selector.h"

#include "ih264d_nal.h"

#include "ih264d_parse_cavlc.h"

#include "ih264d_parse_headers.h"

#include "ih264d_tables.h"

#include "ih264d_thread_compute_bs.h"

#include "ih264d_utils.h"

#include "ih264d_api_utils.h"

#include "ithread.h"

#include "imvcd_api_utils.h"

#include "imvcd_dpb_manager.h"

#include "imvcd_error_handler.h"

#include "imvcd_nalu_parser.h"

#include "imvcd_structs.h"

#include "imvcd_utils.h"

static void imvcd_free_static_bufs(iv_obj_t *ps_dec_hdl)

{

    mvc_dec_ctxt_t *ps_mvcd_ctxt;

    dec_struct_t *ps_view_ctxt;

    FT_ALIGNED_FREE *pf_aligned_free;

    void *pv_mem_ctxt;

    if(!ps_dec_hdl)

    {

        return;

    }

    ps_mvcd_ctxt = (mvc_dec_ctxt_t *) ps_dec_hdl->pv_codec_handle;

    if(!ps_mvcd_ctxt)

    {

        return;

    }

    ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;

    pf_aligned_free = ps_view_ctxt->pf_aligned_free;

    pv_mem_ctxt = ps_view_ctxt->pv_mem_ctxt;

    imvcd_free_dynamic_bufs(ps_mvcd_ctxt);

    imvcd_bitsteam_buf_free(ps_view_ctxt);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_left_mvpred_addr);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pu4_wts_ofsts_mat);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pu4_mbaff_wt_mat);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pu1_init_dpb_base);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pu1_temp_mc_buffer);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pi2_pred1);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pu1_ref_buff_base);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_left_mb_ctxt_info);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->p_cabac_ctxt_table_t);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ppv_map_ref_idx_to_poc_base);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pu1_bits_buf_static);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pv_scratch_sps_pps);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_bitstrm);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_dpb_cmds);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_sei_parse);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_sei);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_dec_err_status);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_pred);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pv_bs_deblk_thread_handle);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->pv_dec_thread_handle);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_pps);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_view_ctxt->ps_sps);

    ih264_buf_mgr_free(ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr.pv_mem);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr.pv_mem);

    ih264_buf_mgr_free(ps_mvcd_ctxt->s_mvc_au_buf_mgr.pv_mem);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_mvcd_ctxt->s_mvc_au_buf_mgr.pv_mem);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_mvcd_ctxt->ps_dpb_mgr);

    PS_DEC_ALIGNED_FREE(ps_view_ctxt, ps_mvcd_ctxt);

    if(ps_dec_hdl)

    {

        pf_aligned_free(pv_mem_ctxt, ps_dec_hdl);

    }

}

static IV_API_CALL_STATUS_T imvcd_view_ctxt_init(imvcd_create_ip_t *ps_ip,

                                                 dec_struct_t *ps_view_ctxt)

{

    pocstruct_t *ps_prev_poc, *ps_cur_poc;

    WORD32 i4_mem_size;

    void *pv_buf;

    FT_ALIGNED_ALLOC *pf_aligned_alloc = ps_ip->s_ivd_ip.pf_aligned_alloc;

    void *pv_mem_ctxt = ps_ip->s_ivd_ip.pv_mem_ctxt;

    const WORD32 i4_default_alignment = 128;

    ps_view_ctxt->u4_share_disp_buf = 0;

    ps_view_ctxt->u1_chroma_format = ps_ip->s_ivd_ip.e_output_format;

    ps_view_ctxt->pf_aligned_alloc = pf_aligned_alloc;

    ps_view_ctxt->pf_aligned_free = ps_ip->s_ivd_ip.pf_aligned_free;

    ps_view_ctxt->pv_mem_ctxt = ps_ip->s_ivd_ip.pv_mem_ctxt;

    i4_mem_size = ((sizeof(dec_seq_params_t)) * MAX_NUM_SEQ_PARAMS);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_sps = pv_buf;

    i4_mem_size = (sizeof(dec_pic_params_t)) * MAX_NUM_PIC_PARAMS;

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_pps = pv_buf;

    i4_mem_size = ithread_get_handle_size();

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->pv_dec_thread_handle = pv_buf;

    i4_mem_size = ithread_get_handle_size();

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->pv_bs_deblk_thread_handle = pv_buf;

    i4_mem_size = sizeof(pred_info_t) * 2 * 32;

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_pred = pv_buf;

    ps_view_ctxt->pv_disp_buf_mgr = NULL;

    ps_view_ctxt->pv_pic_buf_mgr = NULL;

    ps_view_ctxt->ps_pic_buf_base = NULL;

    i4_mem_size = sizeof(dec_err_status_t);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_dec_err_status = (dec_err_status_t *) pv_buf;

    i4_mem_size = sizeof(sei);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_sei = (sei *) pv_buf;

    i4_mem_size = sizeof(sei);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_sei_parse = (sei *) pv_buf;

    i4_mem_size = sizeof(dpb_commands_t);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_dpb_cmds = (dpb_commands_t *) pv_buf;

    i4_mem_size = sizeof(dec_bit_stream_t);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_bitstrm = (dec_bit_stream_t *) pv_buf;

    i4_mem_size = MAX(sizeof(dec_seq_params_t), sizeof(dec_pic_params_t));

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->pv_scratch_sps_pps = pv_buf;

    ps_view_ctxt->u4_static_bits_buf_size = MIN_BITSTREAMS_BUF_SIZE;

    pv_buf =

        pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, ps_view_ctxt->u4_static_bits_buf_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, ps_view_ctxt->u4_static_bits_buf_size);

    ps_view_ctxt->pu1_bits_buf_static = pv_buf;

    i4_mem_size = (TOTAL_LIST_ENTRIES + PAD_MAP_IDX_POC) * sizeof(void *);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    ps_view_ctxt->ppv_map_ref_idx_to_poc_base = pv_buf;

    ps_view_ctxt->ppv_map_ref_idx_to_poc =

        ps_view_ctxt->ppv_map_ref_idx_to_poc_base + OFFSET_MAP_IDX_POC;

    memset(ps_view_ctxt->ppv_map_ref_idx_to_poc_base, 0, i4_mem_size);

    i4_mem_size = (sizeof(bin_ctxt_model_t) * NUM_CABAC_CTXTS);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->p_cabac_ctxt_table_t = pv_buf;

    i4_mem_size = sizeof(ctxt_inc_mb_info_t);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_left_mb_ctxt_info = pv_buf;

    i4_mem_size = MAX_REF_BUF_SIZE * 2;

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->pu1_ref_buff_base = pv_buf;

    ps_view_ctxt->pu1_ref_buff = ps_view_ctxt->pu1_ref_buff_base + MAX_REF_BUF_SIZE;

    i4_mem_size = sizeof(WORD16) * PRED_BUFFER_WIDTH * PRED_BUFFER_HEIGHT * 2;

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->pi2_pred1 = pv_buf;

    i4_mem_size = sizeof(UWORD8) * (MB_LUM_SIZE);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->pu1_temp_mc_buffer = pv_buf;

    i4_mem_size = (sizeof(UWORD32) * 2 * 3 * ((MAX_FRAMES << 1) * (MAX_FRAMES << 1)) * 2);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->pu4_mbaff_wt_mat = pv_buf;

    i4_mem_size = sizeof(UWORD32) * 2 * 3 * ((MAX_FRAMES << 1) * (MAX_FRAMES << 1));

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->pu4_wts_ofsts_mat = pv_buf;

    i4_mem_size = (sizeof(neighbouradd_t) << 2);

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_view_ctxt->ps_left_mvpred_addr = pv_buf;

    ps_view_ctxt->pv_mv_buf_mgr = NULL;

    ps_view_ctxt->ps_col_mv_base = NULL;

    ps_view_ctxt->init_done = 0;

    ps_view_ctxt->u4_num_cores = 1;

    ps_view_ctxt->u2_pic_ht = ps_view_ctxt->u2_pic_wd = 0;

    ps_view_ctxt->u1_separate_parse = DEFAULT_SEPARATE_PARSE;

    ps_view_ctxt->u4_app_disable_deblk_frm = 0;

    ps_view_ctxt->i4_degrade_type = 0;

    ps_view_ctxt->i4_degrade_pics = 0;

    memset(ps_view_ctxt->ps_pps, 0, ((sizeof(dec_pic_params_t)) * MAX_NUM_PIC_PARAMS));

    memset(ps_view_ctxt->ps_sps, 0, ((sizeof(dec_seq_params_t)) * MAX_NUM_SEQ_PARAMS));

    ps_view_ctxt->p_DeblockPicture[0] = ih264d_deblock_picture_non_mbaff;

    ps_view_ctxt->p_DeblockPicture[1] = ih264d_deblock_picture_mbaff;

    ps_view_ctxt->s_cab_dec_env.pv_codec_handle = ps_view_ctxt;

    ps_view_ctxt->u4_num_fld_in_frm = 0;

    ps_view_ctxt->ps_sei->u1_is_valid = 0;

    ps_view_ctxt->ps_cur_pps = NULL;

    ps_view_ctxt->ps_cur_sps = NULL;

    ps_view_ctxt->ps_cur_slice = NULL;

    ps_view_ctxt->u1_init_dec_flag = 0;

    ps_view_ctxt->u1_first_slice_in_stream = 1;

    ps_view_ctxt->u1_last_pic_not_decoded = 0;

    ps_view_ctxt->u4_app_disp_width = 0;

    ps_view_ctxt->i4_header_decoded = 0;

    ps_view_ctxt->u4_total_frames_decoded = 0;

    ps_view_ctxt->i4_error_code = 0;

    ps_view_ctxt->i4_content_type = IV_CONTENTTYPE_NA;

    ps_view_ctxt->ps_dec_err_status->u1_err_flag = ACCEPT_ALL_PICS;

    ps_view_ctxt->ps_dec_err_status->u1_cur_pic_type = PIC_TYPE_UNKNOWN;

    ps_view_ctxt->ps_dec_err_status->u4_frm_sei_sync = SYNC_FRM_DEFAULT;

    ps_view_ctxt->ps_dec_err_status->u4_cur_frm = INIT_FRAME;

    ps_view_ctxt->ps_dec_err_status->u1_pic_aud_i = PIC_TYPE_UNKNOWN;

    ps_view_ctxt->u1_pr_sl_type = 0xFF;

    ps_view_ctxt->u2_mbx = 0xffff;

    ps_view_ctxt->u2_mby = 0;

    ps_view_ctxt->u4_total_mbs_coded = 0;

    ps_prev_poc = &ps_view_ctxt->s_prev_pic_poc;

    ps_cur_poc = &ps_view_ctxt->s_cur_pic_poc;

    ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb = 0;

    ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb = 0;

    ps_prev_poc->i4_delta_pic_order_cnt_bottom = ps_cur_poc->i4_delta_pic_order_cnt_bottom = 0;

    ps_prev_poc->i4_delta_pic_order_cnt[0] = ps_cur_poc->i4_delta_pic_order_cnt[0] = 0;

    ps_prev_poc->i4_delta_pic_order_cnt[1] = ps_cur_poc->i4_delta_pic_order_cnt[1] = 0;

    ps_prev_poc->u1_mmco_equalto5 = ps_cur_poc->u1_mmco_equalto5 = 0;

    ps_prev_poc->i4_top_field_order_count = ps_cur_poc->i4_top_field_order_count = 0;

    ps_prev_poc->i4_bottom_field_order_count = ps_cur_poc->i4_bottom_field_order_count = 0;

    ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field = 0;

    ps_prev_poc->u1_mmco_equalto5 = ps_cur_poc->u1_mmco_equalto5 = 0;

    ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst = 0;

    ps_view_ctxt->i4_max_poc = 0;

    ps_view_ctxt->i4_prev_max_display_seq = 0;

    ps_view_ctxt->u4_recon_mb_grp = 4;

    ps_view_ctxt->i4_reorder_depth = -1;

    ps_view_ctxt->u1_second_field = 0;

    ps_view_ctxt->s_prev_seq_params.u1_eoseq_pending = 0;

    ps_view_ctxt->u2_crop_offset_y = 0;

    ps_view_ctxt->u2_crop_offset_uv = 0;

    ps_view_ctxt->i4_vui_frame_rate = -1;

    ps_view_ctxt->i4_pic_type = NA_SLICE;

    ps_view_ctxt->i4_frametype = IV_NA_FRAME;

    ps_view_ctxt->i4_content_type = IV_CONTENTTYPE_NA;

    ps_view_ctxt->u1_res_changed = 0;

    ps_view_ctxt->u1_frame_decoded_flag = 0;

    ps_view_ctxt->u4_skip_frm_mask = SKIP_NONE;

    ps_view_ctxt->pf_cavlc_4x4res_block[0] = ih264d_cavlc_4x4res_block_totalcoeff_1;

    ps_view_ctxt->pf_cavlc_4x4res_block[1] = ih264d_cavlc_4x4res_block_totalcoeff_2to10;

    ps_view_ctxt->pf_cavlc_4x4res_block[2] = ih264d_cavlc_4x4res_block_totalcoeff_11to16;

    ps_view_ctxt->pf_cavlc_parse4x4coeff[0] = ih264d_cavlc_parse4x4coeff_n0to7;

    ps_view_ctxt->pf_cavlc_parse4x4coeff[1] = ih264d_cavlc_parse4x4coeff_n8;

    ps_view_ctxt->pf_cavlc_parse_8x8block[0] = ih264d_cavlc_parse_8x8block_none_available;

    ps_view_ctxt->pf_cavlc_parse_8x8block[1] = ih264d_cavlc_parse_8x8block_left_available;

    ps_view_ctxt->pf_cavlc_parse_8x8block[2] = ih264d_cavlc_parse_8x8block_top_available;

    ps_view_ctxt->pf_cavlc_parse_8x8block[3] = ih264d_cavlc_parse_8x8block_both_available;

    ps_view_ctxt->pf_fill_bs1[0][0] = ih264d_fill_bs1_16x16mb_pslice;

    ps_view_ctxt->pf_fill_bs1[0][1] = ih264d_fill_bs1_non16x16mb_pslice;

    ps_view_ctxt->pf_fill_bs1[1][0] = ih264d_fill_bs1_16x16mb_bslice;

    ps_view_ctxt->pf_fill_bs1[1][1] = ih264d_fill_bs1_non16x16mb_bslice;

    ps_view_ctxt->pf_fill_bs_xtra_left_edge[0] = ih264d_fill_bs_xtra_left_edge_cur_frm;

    ps_view_ctxt->pf_fill_bs_xtra_left_edge[1] = ih264d_fill_bs_xtra_left_edge_cur_fld;

    ps_view_ctxt->u2_prv_frame_num = 0;

    ps_view_ctxt->u1_top_bottom_decoded = 0;

    ps_view_ctxt->u1_dangling_field = 0;

    ps_view_ctxt->s_cab_dec_env.cabac_table = gau4_ih264d_cabac_table;

    ps_view_ctxt->pu1_left_mv_ctxt_inc = ps_view_ctxt->u1_left_mv_ctxt_inc_arr[0];

    ps_view_ctxt->pi1_left_ref_idx_ctxt_inc = &ps_view_ctxt->i1_left_ref_idx_ctx_inc_arr[0][0];

    ps_view_ctxt->pu1_left_yuv_dc_csbp = &ps_view_ctxt->u1_yuv_dc_csbp_topmb;

    ps_view_ctxt->u1_flushfrm = 0;

    ps_view_ctxt->s_cab_dec_env.pv_codec_handle = ps_view_ctxt;

    ps_view_ctxt->ps_bitstrm->pv_codec_handle = ps_view_ctxt;

    memset(ps_view_ctxt->disp_bufs, 0, (MAX_DISP_BUFS_NEW) * sizeof(disp_buf_t));

    memset(ps_view_ctxt->u4_disp_buf_mapping, 0, (MAX_DISP_BUFS_NEW) * sizeof(UWORD32));

    memset(ps_view_ctxt->u4_disp_buf_to_be_freed, 0, (MAX_DISP_BUFS_NEW) * sizeof(UWORD32));

    ih264d_init_arch(ps_view_ctxt);

    ih264d_init_function_ptr(ps_view_ctxt);

    ps_view_ctxt->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;

    ps_view_ctxt->init_done = 1;

    return IV_SUCCESS;

}

static IV_API_CALL_STATUS_T imvcd_ctxt_init(imvcd_create_ip_t *ps_ip, mvc_dec_ctxt_t *ps_mvcd_ctxt)

{

    WORD32 i4_mem_size;

    void *pv_buf;

    FT_ALIGNED_ALLOC *pf_aligned_alloc = ps_ip->s_ivd_ip.pf_aligned_alloc;

    void *pv_mem_ctxt = ps_ip->s_ivd_ip.pv_mem_ctxt;

    const WORD32 i4_default_alignment = 128;

    memset(ps_mvcd_ctxt, 0, sizeof(ps_mvcd_ctxt[0]));

    i4_mem_size = sizeof(mvc_dpb_manager_t);

    ps_mvcd_ctxt->ps_dpb_mgr = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == ps_mvcd_ctxt->ps_dpb_mgr), IV_FAIL);

    memset(ps_mvcd_ctxt->ps_dpb_mgr, 0, i4_mem_size);

    imvcd_init_dpb_mgr(ps_mvcd_ctxt->ps_dpb_mgr, &ps_mvcd_ctxt->s_mvc_au_buf_mgr,

                       &ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr, &ps_mvcd_ctxt->s_mvc_disp_buf_mgr);

    ih264_disp_mgr_init(&ps_mvcd_ctxt->s_mvc_disp_buf_mgr);

    i4_mem_size = sizeof(buf_mgr_t) + ithread_get_mutex_lock_size();

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_mvcd_ctxt->s_mvc_au_buf_mgr.pv_mem = pv_buf;

    ps_mvcd_ctxt->s_mvc_au_buf_mgr.ps_buf_mgr_ctxt = pv_buf;

    ih264_buf_mgr_init(ps_mvcd_ctxt->s_mvc_au_buf_mgr.pv_mem);

    i4_mem_size = sizeof(buf_mgr_t) + ithread_get_mutex_lock_size();

    pv_buf = pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    RETURN_IF((NULL == pv_buf), IV_FAIL);

    memset(pv_buf, 0, i4_mem_size);

    ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr.pv_mem = pv_buf;

    ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr.ps_buf_mgr_ctxt = pv_buf;

    ih264_buf_mgr_init(ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr.pv_mem);

    if(IV_SUCCESS != imvcd_view_ctxt_init(ps_ip, &ps_mvcd_ctxt->s_view_dec_ctxt))

    {

        return IV_FAIL;

    }

    ps_mvcd_ctxt->u2_num_views = 0;

    ps_mvcd_ctxt->u2_num_views_decoded = 0;

    return IV_SUCCESS;

}

static IV_API_CALL_STATUS_T imvcd_allocate_static_bufs(imvcd_create_ip_t *ps_ip,

                                                       imvcd_create_op_t *ps_op)

{

    iv_obj_t *ps_dec_hdl;

    mvc_dec_ctxt_t *ps_mvcd_ctxt;

    WORD32 i4_mem_size;

    FT_ALIGNED_ALLOC *pf_aligned_alloc = ps_ip->s_ivd_ip.pf_aligned_alloc;

    void *pv_mem_ctxt = ps_ip->s_ivd_ip.pv_mem_ctxt;

    const WORD32 i4_default_alignment = 128;

    i4_mem_size = sizeof(ps_dec_hdl[0]);

    ps_op->s_ivd_op.pv_handle = ps_dec_hdl =

        (iv_obj_t *) pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    if(NULL == ps_dec_hdl)

    {

        return IV_FAIL;

    }

    i4_mem_size = sizeof(ps_mvcd_ctxt[0]);

    ps_dec_hdl->pv_codec_handle = ps_mvcd_ctxt =

        (mvc_dec_ctxt_t *) pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);

    if(NULL == ps_mvcd_ctxt)

    {

        return IV_FAIL;

    }

    if(IV_SUCCESS != imvcd_ctxt_init(ps_ip, ps_mvcd_ctxt))

    {

        return IV_FAIL;

    }

    return IV_SUCCESS;

}

/* Description - 'Create' API for MVC Decoder */

static IV_API_CALL_STATUS_T imvcd_create(imvcd_create_ip_t *ps_ip, imvcd_create_op_t *ps_op)

{

    if(IV_SUCCESS != imvcd_check_create_structs(ps_ip, ps_op))

    {

        return IV_FAIL;

    }

    if(IV_SUCCESS != imvcd_allocate_static_bufs(ps_ip, ps_op))

    {

        imvcd_free_static_bufs((iv_obj_t *) ps_op->s_ivd_op.pv_handle);

        return IV_FAIL;

    }

    return IV_SUCCESS;

}

/* Description - 'Delete' API for MVC Decoder */

static IV_API_CALL_STATUS_T imvcd_delete(iv_obj_t *ps_dec_hdl)

{

    if(IV_SUCCESS != imvcd_check_dec_handle(ps_dec_hdl))

    {

        return IV_FAIL;

    }

    imvcd_free_static_bufs(ps_dec_hdl);

    return IV_SUCCESS;

}

static IV_API_CALL_STATUS_T imvcd_flush_mode_decode(mvc_dec_ctxt_t *ps_mvcd_ctxt,

                                                    imvcd_video_decode_op_t *ps_op)

{

    dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;

    if(!ps_view_ctxt->u1_init_dec_flag)

    {

        ps_view_ctxt->u1_flushfrm = 0;

        ps_mvcd_ctxt->b_flush_enabled = false;

        ps_op->s_ivd_op.u4_output_present = 0;

        return IV_FAIL;

    }

    if(IV_SUCCESS != imvcd_get_next_display_au_buf(ps_mvcd_ctxt))

    {

        ps_view_ctxt->u1_flushfrm = 0;

        ps_mvcd_ctxt->b_flush_enabled = false;

        ps_op->s_ivd_op.u4_output_present = false;

        return IV_SUCCESS;

    }

    ih264d_export_sei_params(&ps_op->s_ivd_op.s_sei_decode_op, ps_view_ctxt);

    ps_op->s_ivd_op.u4_pic_wd = ps_view_ctxt->u2_disp_width;

    ps_op->s_ivd_op.u4_pic_ht = ps_view_ctxt->u2_disp_height;

    ps_op->s_ivd_op.u4_ts = ps_view_ctxt->s_disp_op.u4_ts;

    ps_op->s_ivd_op.u4_output_present = 1;

    ps_op->s_ivd_op.e_output_format = IV_YUV_420P;

    imvcd_convert_to_app_disp_buf(ps_mvcd_ctxt, ps_op->ps_view_disp_bufs);

    return IV_SUCCESS;

}

static void imvcd_fill_output_struct_from_context(mvc_dec_ctxt_t *ps_mvcd_ctxt,

                                                  imvcd_video_decode_op_t *ps_op)

{

    dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;

    if((ps_op->s_ivd_op.u4_error_code & 0xff) != ERROR_DYNAMIC_RESOLUTION_NOT_SUPPORTED)

    {

        ps_op->s_ivd_op.u4_pic_wd = ps_view_ctxt->u2_disp_width;

        ps_op->s_ivd_op.u4_pic_ht = ps_view_ctxt->u2_disp_height;

    }

    ps_op->s_ivd_op.u4_output_present = ps_view_ctxt->u4_output_present;

    ps_op->s_ivd_op.e_output_format = IV_YUV_420P;

    imvcd_convert_to_app_disp_buf(ps_mvcd_ctxt, ps_op->ps_view_disp_bufs);

    ih264d_export_sei_params(&ps_op->s_ivd_op.s_sei_decode_op, ps_view_ctxt);

}

static void imvcd_video_decode_clean_return(mvc_dec_ctxt_t *ps_mvcd_ctxt,

                                            imvcd_video_decode_ip_t *ps_ip,

                                            imvcd_video_decode_op_t *ps_op)

{

    dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;

    ih264d_signal_decode_thread(ps_view_ctxt);

    ih264d_signal_bs_deblk_thread(ps_view_ctxt);

    imvcd_fill_output_struct_from_context(ps_mvcd_ctxt, ps_op);

    ps_op->s_ivd_op.u4_frame_decoded_flag = 0;

    ps_op->s_ivd_op.u4_num_bytes_consumed = ps_ip->s_ivd_ip.u4_num_Bytes;

}

static FORCEINLINE void imvcd_update_num_pps(mvc_dec_ctxt_t *ps_mvcd_ctxt)

{

    WORD32 i;

    dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;

    ps_mvcd_ctxt->u1_num_pps = 0;

    for(i = 0; i < MAX_NUM_PIC_PARAMS; i++)

    {

        if(ps_view_ctxt->ps_pps[i].u1_is_valid)

        {

            UWORD8 u1_sps_id = ps_view_ctxt->ps_pps[i].ps_sps->u1_seq_parameter_set_id;

            if(ps_mvcd_ctxt->as_subset_sps[u1_sps_id].s_sps_data.u1_is_valid)

            {

                ps_mvcd_ctxt->aps_pps_id_to_subset_sps_map[i] =

                    &ps_mvcd_ctxt->as_subset_sps[u1_sps_id];

            }

            ps_mvcd_ctxt->u1_num_pps++;

        }

    }

}

static FORCEINLINE void imvcd_update_num_sps(mvc_dec_ctxt_t *ps_mvcd_ctxt)

{

    WORD32 i;

    dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;

    ps_mvcd_ctxt->u1_num_sps = 0;

    for(i = 0; i < MAX_NUM_SEQ_PARAMS; i++)

    {

        if(ps_view_ctxt->ps_sps[i].u1_is_valid)

        {

            ps_mvcd_ctxt->u1_num_sps++;

        }

    }

}

static FORCEINLINE void imvcd_update_num_subset_sps(mvc_dec_ctxt_t *ps_mvcd_ctxt)

{

    WORD32 i;

    ps_mvcd_ctxt->u1_num_subset_sps = 0;

    for(i = 0; i < MAX_NUM_SEQ_PARAMS; i++)

    {

        if(ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u1_is_valid)

        {

            ps_mvcd_ctxt->u1_num_subset_sps++;

        }

    }

}

static IV_API_CALL_STATUS_T imvcd_view_decode(iv_obj_t *ps_dec_hdl, imvcd_video_decode_ip_t *ps_ip,

                                              imvcd_video_decode_op_t *ps_op)

{

    UWORD8 *pu1_input_buffer;

    UWORD8 *pu1_bitstream_buf;

    UWORD32 u4_bitstream_buf_size;

    WORD32 i4_nalu_length;

    UWORD32 u4_length_of_start_code;

    WORD32 i4_error_code;

    mvc_dec_ctxt_t *ps_mvcd_ctxt = (mvc_dec_ctxt_t *) ps_dec_hdl->pv_codec_handle;

    dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;

    UWORD32 u4_num_bytes_consumed = 0;

    UWORD32 u4_num_bytes_remaining = ps_ip->s_ivd_ip.u4_num_Bytes;

    bool b_first_start_code_found = false;

    bool b_frame_data_left = true;

    bool b_header_data_left = true;

    UWORD32 u4_next_is_aud = 0;

    ASSERT(u4_num_bytes_remaining > 0);

    imvcd_view_init(ps_mvcd_ctxt);

    do

    {

        pu1_input_buffer = ((UWORD8 *) ps_ip->s_ivd_ip.pv_stream_buffer) + u4_num_bytes_consumed;

        if(!ps_view_ctxt->pu1_bits_buf_dynamic &&

           is_header_decoded(ps_view_ctxt->i4_header_decoded, PPS))

        {

            if(IV_SUCCESS !=

               imvcd_bitstream_buf_alloc(

                   ps_view_ctxt, is_header_decoded(ps_view_ctxt->i4_header_decoded, SUBSET_SPS)

                                     ? ps_mvcd_ctxt->u2_num_views

                                     : 1))

            {

                return IV_FAIL;

            }

        }

        if(ps_view_ctxt->pu1_bits_buf_dynamic)

        {

            pu1_bitstream_buf = ps_view_ctxt->pu1_bits_buf_dynamic;

            u4_bitstream_buf_size = ps_view_ctxt->u4_dynamic_bits_buf_size;

        }

        else

        {

            pu1_bitstream_buf = ps_view_ctxt->pu1_bits_buf_static;

            u4_bitstream_buf_size = ps_view_ctxt->u4_static_bits_buf_size;

        }

        i4_nalu_length = ih264d_find_start_code(pu1_input_buffer, 0, u4_num_bytes_remaining,

                                                &u4_length_of_start_code, &u4_next_is_aud);

        if(i4_nalu_length == -1)

        {

            i4_nalu_length = 0;

        }

        if((0 != u4_next_is_aud) && (1 != u4_next_is_aud))

        {

            return IV_FAIL;

        }

        if(i4_nalu_length)

        {

            /* In some erroneous fuzzer bistreams, the slice data requires more

              parsing than what was implied by the distance between successive

              start codes.The primary culprit is the NEXTBITS macro which requires

              reading 4 additional bytes of the bitstream buffer.To alleviate

              this, 16 bytes per 4x4 TU have been additionally allocated to the

              bitstream buffer. Also, chroma bytes are added for 4:2:0/4:2:2 */

            UWORD32 u4_nalu_buf_size = ((UWORD32) i4_nalu_length) + 8 + EXTRA_BS_OFFSET;

            if(u4_nalu_buf_size > u4_bitstream_buf_size)

            {

                /* 64 extra bytes to account for OOB accesses during SEI parsing in */

                /* some fuzzer bitstreams */

                if(IV_SUCCESS != imvcd_bitstream_buf_realloc(ps_view_ctxt, u4_nalu_buf_size + 64))

                {

                    return IV_FAIL;

                }

                pu1_bitstream_buf = ps_view_ctxt->pu1_bits_buf_dynamic;

                u4_bitstream_buf_size = ps_view_ctxt->u4_dynamic_bits_buf_size;

            }

            memcpy(pu1_bitstream_buf, pu1_input_buffer + u4_length_of_start_code, i4_nalu_length);

            /* Decoder may read extra 8 bytes near end of the frame */

            if(u4_nalu_buf_size < u4_bitstream_buf_size)

            {

                memset(pu1_bitstream_buf + i4_nalu_length, 0, 8 * sizeof(pu1_bitstream_buf[0]));

            }

            b_first_start_code_found = true;

        }

        else

        {

            if(!b_first_start_code_found)

            {

                ps_view_ctxt->i4_error_code = ERROR_START_CODE_NOT_FOUND;

                ps_op->s_ivd_op.u4_error_code |= 1 << IVD_INSUFFICIENTDATA;

                if(ps_view_ctxt->u4_pic_buf_got == 0)

                {

                    imvcd_fill_output_struct_from_context(ps_mvcd_ctxt, ps_op);

                    ps_op->s_ivd_op.u4_error_code = ps_view_ctxt->i4_error_code;

                    imvcd_video_decode_clean_return(ps_mvcd_ctxt, ps_ip, ps_op);

                    return IV_FAIL;

                }

                else

                {

                    ps_view_ctxt->u1_pic_decode_done = 1;

                    continue;

                }

            }

            else

            {

                /* a start code has already been found earlier in the same process

                 * call*/

                b_frame_data_left = false;

                b_header_data_left = false;

                if(!ps_view_ctxt->i4_decode_header && !ps_view_ctxt->u4_pic_buf_got)

                {

                    ps_op->s_ivd_op.u4_error_code = ih264d_map_error(ERROR_UNKNOWN_NAL);

                    imvcd_video_decode_clean_return(ps_mvcd_ctxt, ps_ip, ps_op);

                    return IV_FAIL;

                }

                continue;

            }

        }

        ps_mvcd_ctxt->ae_nalu_id[ps_mvcd_ctxt->u2_num_views_decoded] =

            NAL_UNIT_TYPE(pu1_bitstream_buf[0]);

        ps_mvcd_ctxt->au1_nal_ref_idc[ps_mvcd_ctxt->u2_num_views_decoded] =

            NAL_REF_IDC(pu1_bitstream_buf[0]);

        if(ps_view_ctxt->u4_dec_thread_created &&

           !is_slice_nalu_type(ps_mvcd_ctxt->ae_nalu_id[ps_mvcd_ctxt->u2_num_views_decoded]))

        {

            ps_op->s_ivd_op.u4_error_code = ERROR_FEATURE_UNAVAIL;

            imvcd_video_decode_clean_return(ps_mvcd_ctxt, ps_ip, ps_op);

            return IV_FAIL;

        }

        if(!is_mvc_nalu(ps_mvcd_ctxt->ae_nalu_id[ps_mvcd_ctxt->u2_num_views_decoded]))

        {

            ivd_video_decode_op_t s_avc_op;

            i4_error_code =

                ih264d_parse_nal_unit(ps_dec_hdl, &s_avc_op, pu1_bitstream_buf, i4_nalu_length);

        }

        else

        {

            i4_error_code = imvcd_nalu_parser(ps_mvcd_ctxt, pu1_bitstream_buf, i4_nalu_length);

        }

        if(OK != i4_error_code)

        {

            ps_op->s_ivd_op.u4_error_code = i4_error_code;

            imvcd_video_decode_clean_return(ps_mvcd_ctxt, ps_ip, ps_op);

            return IV_FAIL;

        }

        else if(PPS == ps_mvcd_ctxt->ae_nalu_id[ps_mvcd_ctxt->u2_num_views_decoded])

        {

            imvcd_update_num_pps(ps_mvcd_ctxt);

        }

        else if(SPS == ps_mvcd_ctxt->ae_nalu_id[ps_mvcd_ctxt->u2_num_views_decoded])

        {

            imvcd_update_num_sps(ps_mvcd_ctxt);

        }

        else if(SUBSET_SPS == ps_mvcd_ctxt->ae_nalu_id[ps_mvcd_ctxt->u2_num_views_decoded])

        {

            imvcd_update_num_subset_sps(ps_mvcd_ctxt);

        }

        b_header_data_left = ps_view_ctxt->i4_decode_header &&

                             (!is_header_decoded(ps_view_ctxt->i4_header_decoded, SPS) ||

                              !is_header_decoded(ps_view_ctxt->i4_header_decoded, PPS)) &&

                             (u4_num_bytes_consumed < ps_ip->s_ivd_ip.u4_num_Bytes);

        b_frame_data_left = (!ps_view_ctxt->i4_decode_header &&

                             (!ps_view_ctxt->u1_pic_decode_done || u4_next_is_aud)) &&

                            (u4_num_bytes_consumed < ps_ip->s_ivd_ip.u4_num_Bytes);

        u4_num_bytes_consumed += i4_nalu_length + u4_length_of_start_code;

        u4_num_bytes_remaining -= i4_nalu_length + u4_length_of_start_code;

    } while(b_header_data_left || b_frame_data_left);

    if((i4_error_code == IVD_RES_CHANGED) || (i4_error_code == IVD_MEM_ALLOC_FAILED) ||

       (i4_error_code == ERROR_UNAVAIL_PICBUF_T) || (i4_error_code == ERROR_UNAVAIL_MVBUF_T) ||

       (i4_error_code == ERROR_INV_SPS_PPS_T))

    {

        ih264d_signal_decode_thread(ps_view_ctxt);

        if(ps_view_ctxt->u4_num_cores == 3)

        {

            ih264d_signal_bs_deblk_thread(ps_view_ctxt);

        }

        /* dont consume bitstream for change in resolution case */

        if(i4_error_code == IVD_RES_CHANGED)

        {

            ps_op->s_ivd_op.u4_num_bytes_consumed -= u4_num_bytes_consumed;

        }

        imvcd_video_decode_clean_return(ps_mvcd_ctxt, ps_ip, ps_op);

        return IV_FAIL;

    }

    if(ps_view_ctxt->u1_separate_parse)

    {

        if(ps_view_ctxt->u4_num_cores == 2)

        {

            if((ps_view_ctxt->u4_nmb_deblk == 0) && (ps_view_ctxt->u4_start_recon_deblk == 1))

            {

                tfr_ctxt_t s_tfr_ctxt;

                UWORD32 u4_num_mbs, u4_max_addr;

                tfr_ctxt_t *ps_tfr_cxt = &s_tfr_ctxt;

                pad_mgr_t *ps_pad_mgr = &ps_view_ctxt->s_pad_mgr;

                nalu_mvc_ext_t *ps_cur_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);

                /*BS is done for all mbs while parsing*/

                u4_max_addr = (ps_view_ctxt->u2_frm_wd_in_mbs * ps_view_ctxt->u2_frm_ht_in_mbs) - 1;

                ps_view_ctxt->u4_cur_bs_mb_num = u4_max_addr + 1;

                ps_view_ctxt->ps_cur_pic = &ps_view_ctxt->s_cur_pic;

                imvcd_convert_au_buf_to_view_buf(ps_mvcd_ctxt->ps_cur_au, &ps_view_ctxt->s_cur_pic,

                                                 ps_mvcd_ctxt->u2_num_views_decoded,

                                                 ps_cur_nalu_mvc_ext->u2_view_id);

                ih264d_init_deblk_tfr_ctxt(ps_view_ctxt, ps_pad_mgr, ps_tfr_cxt,

                                           ps_view_ctxt->u2_frm_wd_in_mbs, 0);

                u4_num_mbs = u4_max_addr - ps_view_ctxt->u4_cur_deblk_mb_num + 1;

                if(u4_num_mbs != 0)

                {

                    ih264d_check_mb_map_deblk(ps_view_ctxt, u4_num_mbs, ps_tfr_cxt, 1);

                }

                ps_view_ctxt->u4_start_recon_deblk = 0;

            }

        }

        ih264d_signal_decode_thread(ps_view_ctxt);

        if(ps_view_ctxt->u4_num_cores == 3)

        {

            ih264d_signal_bs_deblk_thread(ps_view_ctxt);

        }

    }

    DATA_SYNC();

    // Report if header (sps and pps) has not been decoded yet

    if(ps_view_ctxt->i4_decode_header &&

       (!is_header_decoded(ps_view_ctxt->i4_header_decoded, SPS) &&

        !is_header_decoded(ps_view_ctxt->i4_header_decoded, PPS)))

    {

        ps_op->s_ivd_op.u4_error_code |= (1 << IVD_INSUFFICIENTDATA);

        imvcd_video_decode_clean_return(ps_mvcd_ctxt, ps_ip, ps_op);

        return IV_FAIL;

    }

    if(ps_view_ctxt->u4_pic_buf_got)

    {

        ps_view_ctxt->u1_top_bottom_decoded = TOP_FIELD_ONLY | BOT_FIELD_ONLY;

        if(((ps_view_ctxt->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC) == 0) &&

           ps_view_ctxt->u1_pic_decode_done)

        {

            nalu_mvc_ext_t *ps_cur_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);

            if(!ps_mvcd_ctxt->au1_nal_ref_idc[ps_mvcd_ctxt->u2_num_views_decoded] &&

               ps_cur_nalu_mvc_ext->u1_inter_view_flag)

            {

                ps_view_ctxt->ps_cur_slice->u1_nal_ref_idc = 1;

            }

            /* Padding only. Deblk has happened already. */

            ih264d_deblock_picture_progressive(ps_view_ctxt);

            if(!ps_mvcd_ctxt->au1_nal_ref_idc[ps_mvcd_ctxt->u2_num_views_decoded] &&

               ps_cur_nalu_mvc_ext->u1_inter_view_flag)

            {

                ps_view_ctxt->ps_cur_slice->u1_nal_ref_idc = 0;

            }

        }

        /*Update the i4_frametype at the end of picture*/

        if(imvcd_is_idr_au(ps_mvcd_ctxt))

        {

            ps_view_ctxt->i4_frametype = IV_IDR_FRAME;

        }

        else if(ps_view_ctxt->i4_pic_type == B_SLICE)

        {

            ps_view_ctxt->i4_frametype = IV_B_FRAME;

        }

        else if(ps_view_ctxt->i4_pic_type == P_SLICE)

        {

            ps_view_ctxt->i4_frametype = IV_P_FRAME;

        }

        else if(ps_view_ctxt->i4_pic_type == I_SLICE)

        {

            ps_view_ctxt->i4_frametype = IV_I_FRAME;

        }

        ps_view_ctxt->i4_content_type = ps_view_ctxt->ps_cur_slice->u1_field_pic_flag;

    }

    /* close deblock thread if it is not closed yet*/

    if(ps_view_ctxt->u4_num_cores == 3)

    {

        ih264d_signal_bs_deblk_thread(ps_view_ctxt);

    }

    if(ps_view_ctxt->u4_dec_thread_created)

    {

        ih264d_signal_decode_thread(ps_view_ctxt);

    }

    if(ps_view_ctxt->u4_bs_deblk_thread_created)

    {

        ih264d_signal_bs_deblk_thread(ps_view_ctxt);

    }

    ps_op->s_ivd_op.u4_num_bytes_consumed = u4_num_bytes_consumed;

    DATA_SYNC();

    return IV_SUCCESS;

}