werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
unplugged-system/external/libavc/decoder/svc/isvcd_utils.c

909 lines
34 KiB
C
Raw Permalink Blame History

/******************************************************************************
*
* Copyright (C) 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.
*
*****************************************************************************
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
/**
*******************************************************************************
* @file
* isvcd_utils.c
*
* @brief
* Contains routines that handle of start and end of pic processing
*
* @author
* Kishore
*
* @remarks
* None
*
*******************************************************************************
*/
#include <string.h>
#include "ih264_typedefs.h"
#include "ithread.h"
#include "ih264d_deblocking.h"
#include "ih264d_parse_slice.h"
#include "ih264d_parse_cavlc.h"
#include "ih264d_dpb_manager.h"
#include "ih264d_defs.h"
#include "isvcd_structs.h"
#include "ih264d_mem_request.h"
#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "ih264_platform_macros.h"
#include "ih264d_tables.h"
#include "ih264d_debug.h"
#include "ih264d_mb_utils.h"
#include "ih264d_error_handler.h"
#include "ih264d_dpb_manager.h"
#include "ih264d_utils.h"
#include "ih264d_defs.h"
#include "ih264d_tables.h"
#include "ih264d_inter_pred.h"
#include "ih264d_dpb_manager.h"
#include "iv.h"
#include "ivd.h"
#include "ih264d_format_conv.h"
#include "ih264_error.h"
#include "ih264_disp_mgr.h"
#include "ih264_buf_mgr.h"
#include "ih264d_utils.h"
WORD32 ih264d_init_dec_mb_grp(dec_struct_t *ps_dec);
/*!
**************************************************************************
* \if Function name : isvcd_free_dynamic_bufs \endif
*
* \brief
* This function frees dynamic memory allocated by Decoder.
*
* \param ps_dec: Pointer to dec_struct_t.
*
* \return
* Returns i4_status as returned by MemManager.
*
**************************************************************************
*/
WORD16 isvcd_free_dynamic_bufs(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
{
dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
/* Free any avc dynamic buffers that are allocated */
ih264d_free_dynamic_bufs(ps_dec);
PS_DEC_ALIGNED_FREE(ps_dec, ps_svc_lyr_dec->pu1_crop_wnd_flag);
PS_DEC_ALIGNED_FREE(ps_dec, ps_svc_lyr_dec->ps_inter_lyr_mb_prms_base);
PS_DEC_ALIGNED_FREE(ps_dec, ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_base);
PS_DEC_ALIGNED_FREE(ps_dec, ps_svc_lyr_dec->pi2_il_residual_resample_luma_base);
PS_DEC_ALIGNED_FREE(ps_dec, ps_svc_lyr_dec->pi2_il_residual_resample_chroma_base);
PS_DEC_ALIGNED_FREE(ps_dec, ps_svc_lyr_dec->ps_svc_frm_mb_info);
PS_DEC_ALIGNED_FREE(ps_dec, ps_svc_lyr_dec->pu2_frm_res_luma_csbp);
PS_DEC_ALIGNED_FREE(ps_dec, ps_svc_lyr_dec->pu1_svc_base_mode_flag);
return 0;
}
/*!
**************************************************************************
* \if Function name : isvcd_allocate_dynamic_bufs \endif
*
* \brief
* This function allocates memory required by Decoder.
*
* \param ps_dec: Pointer to dec_struct_t.
*
* \return
* Returns i4_status as returned by MemManager.
*
**************************************************************************
*/
WORD16 isvcd_allocate_dynamic_bufs(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
{
dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
WORD16 i16_status = 0;
UWORD8 uc_frmOrFld = (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag);
dec_seq_params_t *ps_sps = ps_dec->ps_cur_sps;
UWORD32 u4_total_mbs = ps_sps->u2_total_num_of_mbs << uc_frmOrFld;
WORD32 size;
void *pv_buf;
void *pv_mem_ctxt = ps_dec->pv_mem_ctxt;
size = u4_total_mbs;
i16_status = ih264d_allocate_dynamic_bufs(ps_dec);
if(i16_status != OK)
{
/* Free any dynamic buffers that are allocated */
ih264d_free_dynamic_bufs(ps_dec);
ps_dec->i4_error_code = IVD_MEM_ALLOC_FAILED;
return IVD_MEM_ALLOC_FAILED;
}
if(u4_total_mbs == 0)
{
return IVD_MEM_ALLOC_FAILED;
}
/* Allocate frame level mb info */
size = sizeof(dec_svc_mb_info_t) * u4_total_mbs;
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
ps_svc_lyr_dec->ps_svc_frm_mb_info = pv_buf;
memset(ps_svc_lyr_dec->ps_svc_frm_mb_info, 0, size);
/* Allocate frame level residual luma csbp info */
size = sizeof(UWORD16) * u4_total_mbs;
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
ps_svc_lyr_dec->pu2_frm_res_luma_csbp = pv_buf;
memset(ps_svc_lyr_dec->pu2_frm_res_luma_csbp, 0, size);
ps_svc_lyr_dec->i4_frm_res_luma_csbp_stride = ps_dec->u2_frm_wd_in_mbs;
/* Allocate frame level residual luma csbp info */
size = sizeof(UWORD8) * u4_total_mbs;
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
ps_svc_lyr_dec->pu1_svc_base_mode_flag = pv_buf;
memset(ps_svc_lyr_dec->pu1_svc_base_mode_flag, 0, size);
ps_svc_lyr_dec->i4_frm_svc_base_mode_cabac_stride = ps_dec->u2_frm_wd_in_mbs;
ps_svc_lyr_dec->i4_frm_svc_base_mode_cabac_size = u4_total_mbs;
/* Allocate frame level crop windows flags */
size = sizeof(UWORD8) * u4_total_mbs;
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
ps_svc_lyr_dec->pu1_crop_wnd_flag = pv_buf;
memset(ps_svc_lyr_dec->pu1_crop_wnd_flag, 0, size);
/**********************************/
/*Creation of Inter layer buffers */
/**********************************/
/* MB type buffer : one element per MB */
size = (ps_dec->u2_frm_wd_in_mbs + 2) * (ps_dec->u2_frm_ht_in_mbs + 2) *
sizeof(inter_lyr_mb_prms_t);
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
memset(pv_buf, -1, size);
ps_svc_lyr_dec->ps_inter_lyr_mb_prms_base = pv_buf;
ps_svc_lyr_dec->u2_inter_lyr_mb_prms_stride = ps_dec->u2_frm_wd_in_mbs + 2;
ps_svc_lyr_dec->ps_inter_lyr_mb_prms_frm_start =
ps_svc_lyr_dec->ps_inter_lyr_mb_prms_base + 1 + ps_svc_lyr_dec->u2_inter_lyr_mb_prms_stride;
ps_svc_lyr_dec->u4_inter_lyr_mb_prms_size = (ps_dec->u2_frm_wd_in_mbs + 2) *
(ps_dec->u2_frm_ht_in_mbs + 2) *
sizeof(inter_lyr_mb_prms_t);
/* Luma Residual data at each layer : dafault 0*/
size = ((ps_dec->u2_pic_wd + 4) * (ps_dec->u2_pic_ht + 4)) * sizeof(WORD16);
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
memset(pv_buf, 0, size);
ps_svc_lyr_dec->pi2_il_residual_resample_luma_base = pv_buf;
ps_svc_lyr_dec->u2_residual_resample_luma_stride = (ps_dec->u2_pic_wd + 4);
ps_svc_lyr_dec->pi2_il_residual_resample_mb_luma_frm_start =
ps_svc_lyr_dec->pi2_il_residual_resample_luma_base + 2 +
(2 * ps_svc_lyr_dec->u2_residual_resample_luma_stride);
ps_svc_lyr_dec->u4_residual_resample_luma_size =
((ps_dec->u2_pic_wd + 4) * (ps_dec->u2_pic_ht + 4)) * sizeof(WORD16);
/* Chroma Residual data at each layer : dafault 0*/
size = (((4 + ps_dec->u2_pic_wd) * ((4 + ps_dec->u2_pic_ht) >> 1)) * sizeof(WORD16));
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
memset(pv_buf, 0, size);
ps_svc_lyr_dec->pi2_il_residual_resample_chroma_base = pv_buf;
ps_svc_lyr_dec->u2_residual_resample_chroma_stride = (ps_dec->u2_pic_wd + 4);
ps_svc_lyr_dec->pi2_il_residual_resample_mb_chroma_frm_start =
ps_svc_lyr_dec->pi2_il_residual_resample_chroma_base + 2 +
ps_svc_lyr_dec->u2_residual_resample_chroma_stride;
ps_svc_lyr_dec->u4_residual_resample_chroma_size =
(((4 + ps_dec->u2_pic_wd) * ((4 + ps_dec->u2_pic_ht) >> 1)) * sizeof(WORD16));
/* mv bank buffer : 16 elements per MB: each at 4x4 block level */
size = ((ps_dec->u2_pic_wd) * (ps_dec->u2_pic_ht >> 4)) * sizeof(mv_pred_t);
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
memset(pv_buf, 0, size);
ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_base = pv_buf;
/*syntax for SVC related bin ctxt tables*/
{
bin_ctxt_model_t *const p_cabac_ctxt_table_t = ps_dec->p_cabac_ctxt_table_t;
ps_svc_lyr_dec->ps_base_mode_flag = p_cabac_ctxt_table_t + CABAC_BASE_MODE_FLAG;
ps_svc_lyr_dec->ps_motion_prediction_flag_l0 = p_cabac_ctxt_table_t + CABAC_MOT_PRED_FLAG0;
ps_svc_lyr_dec->ps_motion_prediction_flag_l1 = p_cabac_ctxt_table_t + CABAC_MOT_PRED_FLAG1;
ps_svc_lyr_dec->ps_residual_prediction_flag = p_cabac_ctxt_table_t + CABAC_RES_PRED_FLAG;
}
return (i16_status);
}
/*!
**************************************************************************
* \if Function name : isvcd_decode_pic_order_cnt \endif
*
* \brief
* Calculates picture order count of picture.
*
* \return
* Returns the pic order count of the picture to which current
* Slice belongs.
*
**************************************************************************
*/
WORD32 isvcd_decode_pic_order_cnt(
UWORD8 u1_is_idr_slice, UWORD32 u2_frame_num, pocstruct_t *ps_prev_poc, pocstruct_t *ps_cur_poc,
dec_slice_params_t *ps_cur_slice, /*!< Pointer to current slice Params*/
dec_pic_params_t *ps_pps, UWORD8 u1_nal_ref_idc, UWORD8 u1_bottom_field_flag,
UWORD8 u1_field_pic_flag, WORD32 *pi4_poc, dec_struct_t *ps_dec)
{
WORD64 i8_pic_msb;
WORD32 i4_top_field_order_cnt = 0, i4_bottom_field_order_cnt = 0;
dec_seq_params_t *ps_seq = ps_dec->ps_cur_sps;
WORD32 i4_prev_frame_num_ofst;
switch(ps_seq->u1_pic_order_cnt_type)
{
case 0:
/* POC TYPE 0 */
if(u1_is_idr_slice)
{
ps_prev_poc->i4_pic_order_cnt_msb = 0;
ps_prev_poc->i4_pic_order_cnt_lsb = 0;
}
if(ps_prev_poc->u1_mmco_equalto5)
{
if(ps_prev_poc->u1_bot_field != 1)
{
ps_prev_poc->i4_pic_order_cnt_msb = 0;
ps_prev_poc->i4_pic_order_cnt_lsb = ps_prev_poc->i4_top_field_order_count;
}
else
{
ps_prev_poc->i4_pic_order_cnt_msb = 0;
ps_prev_poc->i4_pic_order_cnt_lsb = 0;
}
}
if((ps_cur_poc->i4_pic_order_cnt_lsb < ps_prev_poc->i4_pic_order_cnt_lsb) &&
((ps_prev_poc->i4_pic_order_cnt_lsb - ps_cur_poc->i4_pic_order_cnt_lsb) >=
(ps_seq->i4_max_pic_order_cntLsb >> 1)))
{
i8_pic_msb =
(WORD64) ps_prev_poc->i4_pic_order_cnt_msb + ps_seq->i4_max_pic_order_cntLsb;
}
else if((ps_cur_poc->i4_pic_order_cnt_lsb > ps_prev_poc->i4_pic_order_cnt_lsb) &&
((ps_cur_poc->i4_pic_order_cnt_lsb - ps_prev_poc->i4_pic_order_cnt_lsb) >=
(ps_seq->i4_max_pic_order_cntLsb >> 1)))
{
i8_pic_msb =
(WORD64) ps_prev_poc->i4_pic_order_cnt_msb - ps_seq->i4_max_pic_order_cntLsb;
}
else
{
i8_pic_msb = ps_prev_poc->i4_pic_order_cnt_msb;
}
if(!u1_field_pic_flag || !u1_bottom_field_flag)
{
WORD64 i8_result = i8_pic_msb + ps_cur_poc->i4_pic_order_cnt_lsb;
if(IS_OUT_OF_RANGE_S32(i8_result))
{
return ERROR_INV_POC;
}
i4_top_field_order_cnt = (WORD32) i8_result;
}
if(!u1_field_pic_flag)
{
WORD64 i8_result =
(WORD64) i4_top_field_order_cnt + ps_cur_poc->i4_delta_pic_order_cnt_bottom;
if(IS_OUT_OF_RANGE_S32(i8_result))
{
return ERROR_INV_POC;
}
i4_bottom_field_order_cnt = (WORD32) i8_result;
}
else if(u1_bottom_field_flag)
{
WORD64 i8_result = i8_pic_msb + ps_cur_poc->i4_pic_order_cnt_lsb;
if(IS_OUT_OF_RANGE_S32(i8_result))
{
return ERROR_INV_POC;
}
i4_bottom_field_order_cnt = (WORD32) i8_result;
}
if(IS_OUT_OF_RANGE_S32(i8_pic_msb))
{
return ERROR_INV_POC;
}
ps_cur_poc->i4_pic_order_cnt_msb = (WORD32) i8_pic_msb;
break;
case 1:
{
/* POC TYPE 1 */
UWORD8 i;
WORD32 prev_frame_num;
WORD32 frame_num_ofst;
WORD32 abs_frm_num;
WORD32 poc_cycle_cnt, frame_num_in_poc_cycle;
WORD64 i8_expected_delta_poc_cycle;
WORD32 expected_poc;
WORD64 i8_result;
prev_frame_num = (WORD32) ps_cur_slice->u2_frame_num;
if(!u1_is_idr_slice)
{
if(ps_cur_slice->u1_mmco_equalto5)
{
prev_frame_num = 0;
i4_prev_frame_num_ofst = 0;
}
else
{
i4_prev_frame_num_ofst = ps_prev_poc->i4_prev_frame_num_ofst;
}
}
else
i4_prev_frame_num_ofst = 0;
/* 1. Derivation for FrameNumOffset */
if(u1_is_idr_slice)
{
frame_num_ofst = 0;
ps_cur_poc->i4_delta_pic_order_cnt[0] = 0;
ps_cur_poc->i4_delta_pic_order_cnt[1] = 0;
}
else if(prev_frame_num > ((WORD32) u2_frame_num))
{
WORD64 i8_result =
i4_prev_frame_num_ofst + (WORD64) ps_seq->u2_u4_max_pic_num_minus1 + 1;
if(IS_OUT_OF_RANGE_S32(i8_result))
{
return ERROR_INV_FRAME_NUM;
}
frame_num_ofst = (WORD32) i8_result;
}
else
frame_num_ofst = i4_prev_frame_num_ofst;
/* 2. Derivation for absFrameNum */
if(0 != ps_seq->u1_num_ref_frames_in_pic_order_cnt_cycle)
{
WORD64 i8_result = frame_num_ofst + (WORD64) u2_frame_num;
if(IS_OUT_OF_RANGE_S32(i8_result))
{
return ERROR_INV_FRAME_NUM;
}
abs_frm_num = (WORD32) i8_result;
}
else
abs_frm_num = 0;
if((u1_nal_ref_idc == 0) && (abs_frm_num > 0)) abs_frm_num = abs_frm_num - 1;
/* 4. expectedDeltaPerPicOrderCntCycle is derived as */
i8_expected_delta_poc_cycle = 0;
for(i = 0; i < ps_seq->u1_num_ref_frames_in_pic_order_cnt_cycle; i++)
{
i8_expected_delta_poc_cycle += ps_seq->i4_ofst_for_ref_frame[i];
}
/* 3. When absFrameNum > 0, picOrderCntCycleCnt and
frame_num_in_poc_cycle are derived as : */
/* 5. expectedPicOrderCnt is derived as : */
if(abs_frm_num > 0)
{
poc_cycle_cnt =
DIV((abs_frm_num - 1), ps_seq->u1_num_ref_frames_in_pic_order_cnt_cycle);
frame_num_in_poc_cycle =
MOD((abs_frm_num - 1), ps_seq->u1_num_ref_frames_in_pic_order_cnt_cycle);
i8_result = poc_cycle_cnt * i8_expected_delta_poc_cycle;
for(i = 0; i <= frame_num_in_poc_cycle; i++)
{
i8_result = i8_result + ps_seq->i4_ofst_for_ref_frame[i];
}
if(IS_OUT_OF_RANGE_S32(i8_result)) return ERROR_INV_POC;
expected_poc = (WORD32) i8_result;
}
else
expected_poc = 0;
if(u1_nal_ref_idc == 0)
{
i8_result = (WORD64) expected_poc + ps_seq->i4_ofst_for_non_ref_pic;
if(IS_OUT_OF_RANGE_S32(i8_result)) return ERROR_INV_POC;
expected_poc = (WORD32) i8_result;
}
/* 6. TopFieldOrderCnt or BottomFieldOrderCnt are derived as */
if(!u1_field_pic_flag)
{
i8_result = (WORD64) expected_poc + ps_cur_poc->i4_delta_pic_order_cnt[0];
if(IS_OUT_OF_RANGE_S32(i8_result)) return ERROR_INV_POC;
i4_top_field_order_cnt = (WORD32) i8_result;
i8_result = (WORD64) i4_top_field_order_cnt +
ps_seq->i4_ofst_for_top_to_bottom_field +
ps_cur_poc->i4_delta_pic_order_cnt[1];
if(IS_OUT_OF_RANGE_S32(i8_result)) return ERROR_INV_POC;
i4_bottom_field_order_cnt = (WORD32) i8_result;
}
else if(!u1_bottom_field_flag)
{
i8_result = (WORD64) expected_poc + ps_cur_poc->i4_delta_pic_order_cnt[0];
if(IS_OUT_OF_RANGE_S32(i8_result)) return ERROR_INV_POC;
i4_top_field_order_cnt = (WORD32) i8_result;
}
else
{
i8_result = (WORD64) expected_poc + ps_seq->i4_ofst_for_top_to_bottom_field +
ps_cur_poc->i4_delta_pic_order_cnt[0];
if(IS_OUT_OF_RANGE_S32(i8_result)) return ERROR_INV_POC;
i4_bottom_field_order_cnt = (WORD32) i8_result;
}
/* Copy the current POC info into Previous POC structure */
ps_cur_poc->i4_prev_frame_num_ofst = frame_num_ofst;
}
break;
case 2:
{
/* POC TYPE 2 */
WORD32 prev_frame_num;
WORD32 frame_num_ofst;
WORD32 tmp_poc;
prev_frame_num = (WORD32) ps_cur_slice->u2_frame_num;
if(!u1_is_idr_slice)
{
if(ps_cur_slice->u1_mmco_equalto5)
{
prev_frame_num = 0;
i4_prev_frame_num_ofst = 0;
}
else
i4_prev_frame_num_ofst = ps_prev_poc->i4_prev_frame_num_ofst;
}
else
i4_prev_frame_num_ofst = 0;
/* 1. Derivation for FrameNumOffset */
if(u1_is_idr_slice)
{
frame_num_ofst = 0;
ps_cur_poc->i4_delta_pic_order_cnt[0] = 0;
ps_cur_poc->i4_delta_pic_order_cnt[1] = 0;
}
else if(prev_frame_num > ((WORD32) u2_frame_num))
{
WORD64 i8_result =
i4_prev_frame_num_ofst + (WORD64) ps_seq->u2_u4_max_pic_num_minus1 + 1;
if(IS_OUT_OF_RANGE_S32(i8_result))
{
return ERROR_INV_FRAME_NUM;
}
frame_num_ofst = (WORD32) i8_result;
}
else
frame_num_ofst = i4_prev_frame_num_ofst;
/* 2. Derivation for tempPicOrderCnt */
if(u1_is_idr_slice)
tmp_poc = 0;
else if(u1_nal_ref_idc == 0)
{
WORD64 i8_result = ((frame_num_ofst + (WORD64) u2_frame_num) << 1) - 1;
if(IS_OUT_OF_RANGE_S32(i8_result))
{
return ERROR_INV_POC;
}
tmp_poc = (WORD32) i8_result;
}
else
{
WORD64 i8_result = (frame_num_ofst + (WORD64) u2_frame_num) << 1;
if(IS_OUT_OF_RANGE_S32(i8_result))
{
return ERROR_INV_POC;
}
tmp_poc = (WORD32) i8_result;
}
/* 6. TopFieldOrderCnt or BottomFieldOrderCnt are derived as */
if(!u1_field_pic_flag)
{
i4_top_field_order_cnt = tmp_poc;
i4_bottom_field_order_cnt = tmp_poc;
}
else if(!u1_bottom_field_flag)
i4_top_field_order_cnt = tmp_poc;
else
i4_bottom_field_order_cnt = tmp_poc;
/* Copy the current POC info into Previous POC structure */
ps_prev_poc->i4_prev_frame_num_ofst = frame_num_ofst;
ps_cur_poc->i4_prev_frame_num_ofst = frame_num_ofst;
}
break;
default:
return ERROR_INV_POC_TYPE_T;
break;
}
if(!u1_field_pic_flag) // or a complementary field pair
{
*pi4_poc = MIN(i4_top_field_order_cnt, i4_bottom_field_order_cnt);
ps_pps->i4_top_field_order_cnt = i4_top_field_order_cnt;
ps_pps->i4_bottom_field_order_cnt = i4_bottom_field_order_cnt;
}
else if(!u1_bottom_field_flag)
{
*pi4_poc = i4_top_field_order_cnt;
ps_pps->i4_top_field_order_cnt = i4_top_field_order_cnt;
}
else
{
*pi4_poc = i4_bottom_field_order_cnt;
ps_pps->i4_bottom_field_order_cnt = i4_bottom_field_order_cnt;
}
ps_pps->i4_avg_poc = *pi4_poc;
return OK;
}
/*****************************************************************************/
/* */
/* Function Name : isvcd_decode_gaps_in_frame_num */
/* */
/* Description : This function decodes gaps in frame number */
/* */
/* Inputs : ps_dec Decoder parameters */
/* u2_frame_num current frame number */
/* */
/* Globals : None */
/* Processing : This functionality needs to be implemented */
/* Outputs : None */
/* Returns : None */
/* */
/* Issues : Not implemented */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 06 05 2002 NS Draft */
/* */
/*****************************************************************************/
WORD32 isvcd_decode_gaps_in_frame_num(dec_struct_t *ps_dec, UWORD16 u2_frame_num)
{
UWORD32 u4_next_frm_num, u4_start_frm_num;
UWORD32 u4_max_frm_num;
pocstruct_t s_tmp_poc;
WORD32 i4_poc;
dec_slice_params_t *ps_cur_slice;
dec_pic_params_t *ps_pic_params;
WORD8 i1_gap_idx;
WORD32 *i4_gaps_start_frm_num;
dpb_manager_t *ps_dpb_mgr;
WORD8 *pi1_gaps_per_seq;
WORD32 ret;
ps_cur_slice = ps_dec->ps_cur_slice;
if(ps_cur_slice->u1_field_pic_flag)
{
if(ps_dec->u2_prev_ref_frame_num == u2_frame_num) return 0;
}
u4_next_frm_num = ps_dec->u2_prev_ref_frame_num + 1;
u4_max_frm_num = ps_dec->ps_cur_sps->u2_u4_max_pic_num_minus1 + 1;
if(u4_next_frm_num >= u4_max_frm_num)
{
u4_next_frm_num -= u4_max_frm_num;
}
if(u4_next_frm_num == u2_frame_num)
{
return (0);
}
if((ps_dec->u1_nal_unit_type == IDR_SLICE_NAL) && (u4_next_frm_num >= u2_frame_num))
{
return (0);
}
u4_start_frm_num = u4_next_frm_num;
s_tmp_poc.i4_pic_order_cnt_lsb = 0;
s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
s_tmp_poc.i4_pic_order_cnt_lsb = 0;
s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
ps_cur_slice = ps_dec->ps_cur_slice;
ps_pic_params = ps_dec->ps_cur_pps;
ps_dpb_mgr = ps_dec->ps_dpb_mgr;
/* Find a empty slot to store gap seqn info */
i4_gaps_start_frm_num = ps_dpb_mgr->ai4_gaps_start_frm_num;
for(i1_gap_idx = 0; i1_gap_idx < MAX_FRAMES; i1_gap_idx++)
{
if(INVALID_FRAME_NUM == i4_gaps_start_frm_num[i1_gap_idx]) break;
}
if(MAX_FRAMES == i1_gap_idx)
{
UWORD32 i4_error_code;
i4_error_code = ERROR_DBP_MANAGER_T;
return i4_error_code;
}
i4_poc = 0;
i4_gaps_start_frm_num[i1_gap_idx] = u4_start_frm_num;
ps_dpb_mgr->ai4_gaps_end_frm_num[i1_gap_idx] = u2_frame_num - 1;
pi1_gaps_per_seq = ps_dpb_mgr->ai1_gaps_per_seq;
pi1_gaps_per_seq[i1_gap_idx] = 0;
while(u4_next_frm_num != u2_frame_num)
{
ih264d_delete_nonref_nondisplay_pics(ps_dpb_mgr);
if(ps_pic_params->ps_sps->u1_pic_order_cnt_type)
{
/* allocate a picture buffer and insert it as ST node */
ret =
isvcd_decode_pic_order_cnt(0, u4_next_frm_num, &ps_dec->s_prev_pic_poc, &s_tmp_poc,
ps_cur_slice, ps_pic_params, 1, 0, 0, &i4_poc, ps_dec);
if(ret != OK) return ret;
/* Display seq no calculations */
if(i4_poc >= ps_dec->i4_max_poc) ps_dec->i4_max_poc = i4_poc;
/* IDR Picture or POC wrap around */
if(i4_poc == 0)
{
WORD64 i8_temp;
i8_temp = (WORD64) ps_dec->i4_prev_max_display_seq + ps_dec->i4_max_poc +
ps_dec->u1_max_dec_frame_buffering + 1;
/*If i4_prev_max_display_seq overflows integer range, reset it */
ps_dec->i4_prev_max_display_seq =
IS_OUT_OF_RANGE_S32(i8_temp) ? 0 : (WORD32) i8_temp;
ps_dec->i4_max_poc = 0;
}
ps_cur_slice->u1_mmco_equalto5 = 0;
ps_cur_slice->u2_frame_num = u4_next_frm_num;
}
if(ps_dpb_mgr->i1_poc_buf_id_entries >= ps_dec->u1_max_dec_frame_buffering)
{
ret = ih264d_assign_display_seq(ps_dec);
if(ret != OK) return ret;
}
{
WORD64 i8_display_poc;
i8_display_poc = (WORD64) ps_dec->i4_prev_max_display_seq + i4_poc;
if(IS_OUT_OF_RANGE_S32(i8_display_poc))
{
ps_dec->i4_prev_max_display_seq = 0;
}
}
ret = ih264d_insert_pic_in_display_list(ps_dec->ps_dpb_mgr, (WORD8) DO_NOT_DISP,
(WORD32) (ps_dec->i4_prev_max_display_seq + i4_poc),
u4_next_frm_num);
if(ret != OK) return ret;
pi1_gaps_per_seq[i1_gap_idx]++;
ret = ih264d_do_mmco_for_gaps(ps_dpb_mgr, ps_dec->ps_cur_sps->u1_num_ref_frames);
if(ret != OK) return ret;
ih264d_delete_nonref_nondisplay_pics(ps_dpb_mgr);
u4_next_frm_num++;
if(u4_next_frm_num >= u4_max_frm_num)
{
u4_next_frm_num -= u4_max_frm_num;
}
}
return OK;
}
/*!
**************************************************************************
* \if Function name : isvcd_init_pic \endif
*
* \brief
* Initializes the picture.
*
* \return
* 0 on Success and Error code otherwise
*
* \note
* This function is called when first slice of the
* NON -IDR picture is encountered.
**************************************************************************
*/
WORD32 isvcd_init_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_frame_num, WORD32 i4_poc,
dec_pic_params_t *ps_pps)
{
dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
dec_seq_params_t *ps_seq = ps_dec->ps_cur_sps;
prev_seq_params_t *ps_prev_seq_params = &ps_dec->s_prev_seq_params;
WORD32 ret;
ps_dec->ps_cur_slice->u2_frame_num = u2_frame_num;
ps_dec->ps_cur_slice->i4_poc = i4_poc;
ps_dec->ps_cur_pps = ps_pps;
ps_dec->ps_cur_pps->pv_codec_handle = ps_dec;
ps_dec->ps_dpb_mgr->i4_max_frm_num = ps_seq->u2_u4_max_pic_num_minus1 + 1;
ps_dec->ps_dpb_mgr->u2_pic_ht = ps_dec->u2_pic_ht;
ps_dec->ps_dpb_mgr->u2_pic_wd = ps_dec->u2_pic_wd;
ps_dec->i4_pic_type = NA_SLICE;
ps_dec->i4_frametype = IV_NA_FRAME;
ps_dec->i4_content_type = IV_CONTENTTYPE_NA;
/*--------------------------------------------------------------------*/
/* Get the value of MaxMbAddress and frmheight in Mbs */
/*--------------------------------------------------------------------*/
ps_seq->u2_max_mb_addr =
(ps_seq->u2_frm_wd_in_mbs *
(ps_dec->u2_pic_ht >> (4 + ps_dec->ps_cur_slice->u1_field_pic_flag))) -
1;
ps_dec->u2_frm_ht_in_mbs = (ps_dec->u2_pic_ht >> (4 + ps_dec->ps_cur_slice->u1_field_pic_flag));
/***************************************************************************/
/* If change in Level or the required PicBuffers i4_size is more than the */
/* current one FREE the current PicBuffers and allocate affresh */
/***************************************************************************/
if(!ps_dec->u1_init_dec_flag)
{
ps_dec->u1_max_dec_frame_buffering = ih264d_get_dpb_size(ps_seq);
ps_dec->i4_display_delay = ps_dec->u1_max_dec_frame_buffering;
if((1 == ps_seq->u1_vui_parameters_present_flag) &&
(1 == ps_seq->s_vui.u1_bitstream_restriction_flag))
{
if(ps_seq->u1_frame_mbs_only_flag == 1)
ps_dec->i4_display_delay = ps_seq->s_vui.u4_num_reorder_frames + 1;
else
ps_dec->i4_display_delay = ps_seq->s_vui.u4_num_reorder_frames * 2 + 2;
}
if(IVD_DECODE_FRAME_OUT == ps_dec->e_frm_out_mode) ps_dec->i4_display_delay = 0;
if(ps_dec->u4_share_disp_buf == 0)
{
if(ps_seq->u1_frame_mbs_only_flag == 1)
ps_dec->u1_pic_bufs = ps_dec->i4_display_delay + ps_seq->u1_num_ref_frames + 1;
else
ps_dec->u1_pic_bufs = ps_dec->i4_display_delay + ps_seq->u1_num_ref_frames * 2 + 2;
}
else
{
ps_dec->u1_pic_bufs = (WORD32) ps_dec->u4_num_disp_bufs;
}
/* Ensure at least two buffers are allocated */
ps_dec->u1_pic_bufs = MAX(ps_dec->u1_pic_bufs, 2);
if(ps_dec->u4_share_disp_buf == 0)
ps_dec->u1_pic_bufs = MIN(ps_dec->u1_pic_bufs, (H264_MAX_REF_PICS * 2));
ps_dec->u1_max_dec_frame_buffering =
MIN(ps_dec->u1_max_dec_frame_buffering, ps_dec->u1_pic_bufs);
/* Temporary hack to run Tractor Cav/Cab/MbAff Profiler streams also for
* CAFI1_SVA_C.264 in conformance*/
if(ps_dec->u1_init_dec_flag)
{
ih264d_release_pics_in_dpb((void *) ps_dec, ps_dec->u1_pic_bufs);
ih264d_release_display_bufs(ps_dec);
ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr);
}
/*********************************************************************/
/* Configuring decoder parameters based on level and then */
/* fresh pointer initialisation in decoder scratch and state buffers */
/*********************************************************************/
if(!ps_dec->u1_init_dec_flag || ((ps_seq->u1_level_idc < H264_LEVEL_3_0) ^
(ps_prev_seq_params->u1_level_idc < H264_LEVEL_3_0)))
{
ret = ih264d_init_dec_mb_grp(ps_dec);
if(ret != OK) return ret;
}
ret = isvcd_allocate_dynamic_bufs(ps_svc_lyr_dec);
if(ret != OK)
{
/* Free any dynamic buffers that are allocated */
isvcd_free_dynamic_bufs(ps_svc_lyr_dec);
ps_dec->i4_error_code = IVD_MEM_ALLOC_FAILED;
return IVD_MEM_ALLOC_FAILED;
}
ret = ih264d_create_pic_buffers(ps_dec->u1_pic_bufs, ps_dec);
if(ret != OK) return ret;
ret = ih264d_create_mv_bank(ps_dec, ps_dec->u2_pic_wd, ps_dec->u2_pic_ht);
if(ret != OK) return ret;
/* In shared mode, set all of them as used by display */
if(ps_dec->u4_share_disp_buf == 1)
{
WORD32 i;
for(i = 0; i < ps_dec->u1_pic_bufs; i++)
{
ih264_buf_mgr_set_status((buf_mgr_t *) ps_dec->pv_pic_buf_mgr, i, BUF_MGR_IO);
}
}
ps_dec->u1_init_dec_flag = 1;
ps_prev_seq_params->u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
ps_prev_seq_params->u1_level_idc = ps_seq->u1_level_idc;
ps_prev_seq_params->u1_profile_idc = ps_seq->u1_profile_idc;
ps_prev_seq_params->u2_frm_ht_in_mbs = ps_seq->u2_frm_ht_in_mbs;
ps_prev_seq_params->u1_frame_mbs_only_flag = ps_seq->u1_frame_mbs_only_flag;
ps_prev_seq_params->u1_direct_8x8_inference_flag = ps_seq->u1_direct_8x8_inference_flag;
ps_dec->i4_cur_display_seq = 0;
ps_dec->i4_prev_max_display_seq = 0;
ps_dec->i4_max_poc = 0;
{
/* 0th entry of CtxtIncMbMap will be always be containing default values
for CABAC context representing MB not available */
ctxt_inc_mb_info_t *p_DefCtxt = ps_dec->p_ctxt_inc_mb_map - 1;
UWORD8 *pu1_temp;
WORD8 i;
p_DefCtxt->u1_mb_type = CAB_SKIP;
p_DefCtxt->u1_cbp = 0x0f;
p_DefCtxt->u1_intra_chroma_pred_mode = 0;
p_DefCtxt->u1_yuv_dc_csbp = 0x7;
p_DefCtxt->u1_transform8x8_ctxt = 0;
pu1_temp = (UWORD8 *) p_DefCtxt->i1_ref_idx;
for(i = 0; i < 4; i++, pu1_temp++) (*pu1_temp) = 0;
pu1_temp = (UWORD8 *) p_DefCtxt->u1_mv;
for(i = 0; i < 16; i++, pu1_temp++) (*pu1_temp) = 0;
ps_dec->ps_def_ctxt_mb_info = p_DefCtxt;
}
}
/* reset DBP commands read u4_flag */
ps_dec->ps_dpb_cmds->u1_dpb_commands_read = 0;
return OK;
}
Reference in New Issue View Git Blame Copy Permalink