wrapper/libavc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

libavcdec: Add support for 4096x4096 resolution

Browse source 
Bug:
Test: ./avcdec

Change-Id: Ie111f58e04bbd045e94167cdb978c571662567fb
This commit is contained in:
Vivek Jadhav 2025-07-07 16:59:15 +05:30 • committed by Harish Mahendrakar
parent f308c61af0
commit 2f6371b3b8
43 changed files with 676 additions and 671 deletions
Download patch file Download diff file Expand all files Collapse all files

16
decoder/ih264d_api.c
View file

@ -1265,7 +1265,7 @@ void ih264d_init_decoder(void * ps_dec_params)
ps_dec->u1_pr_sl_type = 0xFF;
ps_dec->u2_mbx = 0xffff;
ps_dec->u2_mby = 0;
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_total_mbs_coded = 0;
/* POC initializations */
ps_prev_poc = &ps_dec->s_prev_pic_poc;
@ -1291,7 +1291,7 @@ void ih264d_init_decoder(void * ps_dec_params)
ps_dec->i4_max_poc = 0;
ps_dec->i4_prev_max_display_seq = 0;
ps_dec->u1_recon_mb_grp = 4;
ps_dec->u4_recon_mb_grp = 4;
ps_dec->i4_reorder_depth = -1;
/* Field PIC initializations */
@ -2490,8 +2490,8 @@ WORD32 ih264d_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
ih264d_init_decoder(ps_dec);
}
ps_dec->u2_cur_mb_addr = 0;
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_cur_mb_addr = 0;
ps_dec->u4_total_mbs_coded = 0;
ps_dec->u2_cur_slice_num = 0;
ps_dec->cur_dec_mb_num = 0;
ps_dec->cur_recon_mb_num = 0;
@ -2663,7 +2663,7 @@ WORD32 ih264d_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
if((ps_dec->u4_pic_buf_got == 1)
&& (ret != IVD_MEM_ALLOC_FAILED)
&& ps_dec->u2_total_mbs_coded < ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
&& ps_dec->u4_total_mbs_coded < ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
// last slice - missing/corruption
WORD32 num_mb_skipped;
@ -2673,14 +2673,14 @@ WORD32 ih264d_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
WORD32 ht_in_mbs;
ht_in_mbs = ps_dec->u2_pic_ht >> (4 + ps_dec->ps_cur_slice->u1_field_pic_flag);
num_mb_skipped = (ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
- ps_dec->u2_total_mbs_coded;
- ps_dec->u4_total_mbs_coded;
if(ps_dec->u4_first_slice_in_pic && (ps_dec->u4_pic_buf_got == 0))
prev_slice_err = 1;
else
prev_slice_err = 2;
if(ps_dec->u4_first_slice_in_pic && (ps_dec->u2_total_mbs_coded == 0))
if(ps_dec->u4_first_slice_in_pic && (ps_dec->u4_total_mbs_coded == 0))
prev_slice_err = 1;
ret1 = ih264d_mark_err_slice_skip(ps_dec, num_mb_skipped, ps_dec->u1_nal_unit_type == IDR_SLICE_NAL, ps_dec->ps_cur_slice->u2_frame_num,
@ -2819,7 +2819,7 @@ WORD32 ih264d_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
/*set to complete ,as we dont support partial frame decode*/
if(ps_dec->i4_header_decoded == 3)
{
ps_dec->u2_total_mbs_coded = ps_dec->ps_cur_sps->u2_max_mb_addr + 1;
ps_dec->u4_total_mbs_coded = ps_dec->ps_cur_sps->u4_max_mb_addr + 1;
}
/*Update the i4_frametype at the end of picture*/

6
decoder/ih264d_defs.h
View file

@ -36,9 +36,9 @@
*/
#include <stdint.h>
#define H264_MAX_FRAME_WIDTH 4080
#define H264_MAX_FRAME_HEIGHT 4080
#define H264_MAX_FRAME_SIZE (4096 * 2048)
#define H264_MAX_FRAME_WIDTH 4096
#define H264_MAX_FRAME_HEIGHT 4096
#define H264_MAX_FRAME_SIZE (4096 * 4096)
#define H264_MIN_FRAME_WIDTH 16
#define H264_MIN_FRAME_HEIGHT 16

34
decoder/ih264d_mb_utils.c
View file

@ -97,7 +97,7 @@ UWORD32 ih264d_get_mb_info_cavlc_nonmbaff(dec_struct_t *ps_dec,
mb_x = (WORD16)ps_dec->u2_mbx;
mb_y = (WORD16)ps_dec->u2_mby;
ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
mb_x++;
@ -230,7 +230,7 @@ UWORD32 ih264d_get_mb_info_cavlc_mbaff(dec_struct_t *ps_dec,
u2_mb_x = ps_dec->u2_mbx;
u2_mb_y = ps_dec->u2_mby;
ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
if(u1_top_mb)
@ -381,7 +381,7 @@ UWORD32 ih264d_get_mb_info_cabac_nonmbaff(dec_struct_t *ps_dec,
mb_x = (WORD16)ps_dec->u2_mbx;
mb_y = (WORD16)ps_dec->u2_mby;
ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
mb_x++;
if((UWORD32)mb_x == u2_frm_width_in_mb)
@ -569,7 +569,7 @@ UWORD32 ih264d_get_mb_info_cabac_mbaff(dec_struct_t *ps_dec,
mb_x = (WORD16)ps_dec->u2_mbx;
mb_y = (WORD16)ps_dec->u2_mby;
ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
ps_top_ctxt = ps_left_ctxt = p_ctx_inc_mb_map - 1;
@ -1389,9 +1389,9 @@ void ih264d_get_mbaff_neighbours(dec_struct_t * ps_dec,
**************************************************************************
*/
void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
const UWORD8 u1_num_mbs,
const UWORD8 u1_end_of_row, /* Cur n-Mb End of Row Flag */
const UWORD8 u1_end_of_row_next /* Next n-Mb End of Row Flag */
const UWORD32 u4_num_mbs,
const UWORD32 u4_end_of_row, /* Cur n-Mb End of Row Flag */
const UWORD32 u4_end_of_row_next /* Next n-Mb End of Row Flag */
)
{
dec_mb_info_t *ps_cur_mb_info = ps_dec->ps_nmb_info;
@ -1401,14 +1401,14 @@ void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
UWORD32 u4_frame_stride;
mb_neigbour_params_t *ps_temp;
const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
UNUSED(u1_end_of_row_next);
UNUSED(u4_end_of_row_next);
ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u1_end_of_row];
ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u1_end_of_row];
ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u1_end_of_row];
ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u4_end_of_row];
ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u4_end_of_row];
ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u4_end_of_row];
/* Swap top and current pointers */
if(u1_end_of_row)
if(u4_end_of_row)
{
if(ps_dec->u1_separate_parse)
@ -1443,12 +1443,12 @@ void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
/*
* The Slice boundary is also a valid condition to transfer. So recalculate
* the Left increment, in case the number of MBs is lesser than the
* N MB value. u1_num_mbs will be equal to N of N MB if the entire N Mb is
* N MB value. u4_num_mbs will be equal to N of N MB if the entire N Mb is
* decoded.
*/
ps_dec->s_tran_addrecon.u2_mv_left_inc = ((u1_num_mbs >> u1_mbaff) - 1)
ps_dec->s_tran_addrecon.u2_mv_left_inc = ((WORD16)(u4_num_mbs >> u1_mbaff) - 1)
<< (4 + u1_mbaff);
ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (u1_num_mbs << 2) - 1
ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (WORD16)(u4_num_mbs << 2) - 1
- (u1_mbaff << 2);
if(ps_dec->u1_separate_parse == 0)
@ -1457,14 +1457,14 @@ void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
ps_dec->ps_mv_left = ps_dec->ps_mv_cur
+ ps_dec->s_tran_addrecon.u2_mv_left_inc;
ps_dec->ps_mv_cur += (u1_num_mbs << 4);
ps_dec->ps_mv_cur += (u4_num_mbs << 4);
}
/* Increment deblock parameters pointer in external memory */
if(ps_dec->u1_separate_parse == 0)
{
ps_dec->ps_deblk_mbn += u1_num_mbs;
ps_dec->ps_deblk_mbn += u4_num_mbs;
}
}

6
decoder/ih264d_mb_utils.h
View file

@ -283,9 +283,9 @@ void ih264d_get_mbaff_neighbours(dec_struct_t * ps_dec,
void ih264d_update_mbaff_left_nnz(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info);
void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
const UWORD8 u1_num_mbs,
const UWORD8 u1_end_of_row, /* Cur n-Mb End of Row Flag */
const UWORD8 u1_end_of_row_next /* Next n-Mb End of Row Flag */
const UWORD32 u4_num_mbs,
const UWORD32 u4_end_of_row, /* Cur n-Mb End of Row Flag */
const UWORD32 u4_end_of_row_next /* Next n-Mb End of Row Flag */
);
void ih264d_populate_mb_info_map(dec_struct_t *ps_dec,

56
decoder/ih264d_mvpred.c
View file

@ -142,7 +142,7 @@ void ih264d_get_motion_vector_predictor(mv_pred_t * ps_result,
*/
void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
dec_struct_t *ps_dec,
@ -152,7 +152,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
{
UWORD16 u2_a_in = 0, u2_b_in = 0, u2_c_in = 0, u2_d_in = 0;
mv_pred_t *ps_mvpred_l, *ps_mvpred_tmp;
UWORD8 u1_sub_mb_x = (u1_sub_mb_num & 3), uc_sub_mb_y = (u1_sub_mb_num >> 2);
UWORD32 u4_sub_mb_x = (u4_sub_mb_num & 3), uc_sub_mb_y = (u4_sub_mb_num >> 2);
UWORD8 u1_is_cur_mb_fld, u1_is_left_mb_fld, u1_is_top_mb_fld;
UWORD8 u1_is_cur_mb_top;
@ -169,7 +169,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred);
/* Check if the left subMb is available */
if(u1_sub_mb_x)
if(u4_sub_mb_x)
{
u2_a_in = 1;
ps_mv_pred[LEFT] = (ps_mv_nmb - 1);
@ -239,12 +239,12 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
TopRightSubMbIndx = TopLeftSubMbIndx + (WidthOfMbPartition - 6) / 2
*/
u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask,
(u1_sub_mb_num + uc_mb_part_width - 1));
(u4_sub_mb_num + uc_mb_part_width - 1));
if(u2_c_in)
{
ps_mv_pred[TOP_R] = ps_mv_pred[TOP] + uc_mb_part_width;
pu0_scale[TOP_R] = pu0_scale[TOP];
if((uc_sub_mb_y == 0) && ((u1_sub_mb_x + uc_mb_part_width) > 3))
if((uc_sub_mb_y == 0) && ((u4_sub_mb_x + uc_mb_part_width) > 3))
{
UWORD8 uc_isTopRtMbFld;
uc_isTopRtMbFld = ps_cur_mb_info->ps_top_right_mb->u1_mb_fld;
@ -259,7 +259,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
}
else
{
u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u1_sub_mb_num);
u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u4_sub_mb_num);
/* Check if the the top left subMB is available */
if(u2_d_in)
@ -269,7 +269,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
ps_mv_pred[TOP_R] = ps_mv_pred[TOP] - 1;
pu0_scale[TOP_R] = pu0_scale[TOP];
if(u1_sub_mb_x == 0)
if(u4_sub_mb_x == 0)
{
if((uc_sub_mb_y > 0) || ((u1_is_cur_mb_top | u1_is_cur_mb_fld) == 0))
{
@ -333,7 +333,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
*/
#if(!MVPRED_NONMBAFF)
void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
dec_struct_t *ps_dec,
@ -341,7 +341,7 @@ void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
dec_mb_info_t *ps_cur_mb_info)
{
UWORD16 u2_b_in = 0, u2_c_in = 0, u2_d_in = 0;
UWORD8 u1_sub_mb_x = (u1_sub_mb_num & 3), uc_sub_mb_y = (u1_sub_mb_num >> 2);
UWORD32 u4_sub_mb_x = (u4_sub_mb_num & 3), uc_sub_mb_y = (u4_sub_mb_num >> 2);
/* Checking in the subMB exists, calculating their motion vectors to be
used as predictors and the reference frames of those subMBs */
@ -351,7 +351,7 @@ void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred);
/* Check if the left subMb is available */
if(u1_sub_mb_x)
if(u4_sub_mb_x)
{
ps_mv_pred[LEFT] = (ps_mv_nmb - 1);
}
@ -387,7 +387,7 @@ void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
TopRightSubMbIndx = TopLeftSubMbIndx + (WidthOfMbPartition - 6) / 2
*/
u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask,
(u1_sub_mb_num + uc_mb_part_width - 1));
(u4_sub_mb_num + uc_mb_part_width - 1));
if(u2_c_in)
{
ps_mv_pred[TOP_R] = (ps_mv_ntop + uc_mb_part_width);
@ -395,19 +395,19 @@ void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
if(uc_sub_mb_y == 0)
{
/* CHANGED CODE */
if((u1_sub_mb_x + uc_mb_part_width) > 3)
if((u4_sub_mb_x + uc_mb_part_width) > 3)
ps_mv_pred[TOP_R] += 12;
}
}
else
{
u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u1_sub_mb_num);
u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u4_sub_mb_num);
/* Check if the the top left subMB is available */
if(u2_d_in)
{
/* CHANGED CODE */
ps_mv_pred[TOP_R] = (ps_mv_ntop - 1);
if(u1_sub_mb_x == 0)
if(u4_sub_mb_x == 0)
{
if(uc_sub_mb_y)
{
@ -460,7 +460,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
mv_pred_t *ps_mv_final_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 uc_mb_part_width,
UWORD8 u1_lx_start,
UWORD8 u1_lxend,
@ -471,7 +471,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
UWORD8 uc_B2, uc_lx, u1_ref_idx;
UWORD8 u1_direct_zero_pred_flag = 0;
ih264d_non_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
ih264d_non_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
ps_dec, uc_mb_part_width, ps_cur_mb_info);
for(uc_lx = u1_lx_start; uc_lx < u1_lxend; uc_lx++)
@ -482,7 +482,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
{
case PRED_16x8:
/* Directional prediction for a 16x8 MB partition */
if(u1_sub_mb_num == 0)
if(u4_sub_mb_num == 0)
{
/* Calculating the MV pred for the top 16x8 block */
if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx)
@ -536,7 +536,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
break;
case PRED_8x16:
/* Directional prediction for a 8x16 MB partition */
if(u1_sub_mb_num == 0)
if(u4_sub_mb_num == 0)
{
if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx)
{
@ -695,7 +695,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
mv_pred_t *ps_mv_final_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 uc_mb_part_width,
UWORD8 u1_lx_start,
UWORD8 u1_lxend,
@ -707,7 +707,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
UWORD8 u1_direct_zero_pred_flag = 0;
UNUSED(u1_lx_start);
UNUSED(u1_lxend);
ih264d_non_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
ih264d_non_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
ps_dec, uc_mb_part_width, ps_cur_mb_info);
u1_ref_idx = ps_mv_final_pred->i1_ref_frame[0];
@ -716,7 +716,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
{
case PRED_16x8:
/* Directional prediction for a 16x8 MB partition */
if(u1_sub_mb_num == 0)
if(u4_sub_mb_num == 0)
{
/* Calculating the MV pred for the top 16x8 block */
if(ps_mv_pred[TOP]->i1_ref_frame[0] == u1_ref_idx)
@ -768,7 +768,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
break;
case PRED_8x16:
/* Directional prediction for a 8x16 MB partition */
if(u1_sub_mb_num == 0)
if(u4_sub_mb_num == 0)
{
if(ps_mv_pred[LEFT]->i1_ref_frame[0] == u1_ref_idx)
{
@ -925,7 +925,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
mv_pred_t *ps_mv_final_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 uc_mb_part_width,
UWORD8 u1_lx_start,
UWORD8 u1_lxend,
@ -937,7 +937,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
UWORD8 u1_direct_zero_pred_flag = 0;
pu0_scale[0] = pu0_scale[1] = pu0_scale[2] = 0;
ih264d_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop, ps_dec,
ih264d_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop, ps_dec,
uc_mb_part_width, ps_cur_mb_info, pu0_scale);
for(i = 0; i < 3; i++)
{
@ -970,7 +970,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
{
case PRED_16x8:
/* Directional prediction for a 16x8 MB partition */
if(u1_sub_mb_num == 0)
if(u4_sub_mb_num == 0)
{
/* Calculating the MV pred for the top 16x8 block */
if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx)
@ -1024,7 +1024,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
break;
case PRED_8x16:
/* Directional prediction for a 8x16 MB partition */
if(u1_sub_mb_num == 0)
if(u4_sub_mb_num == 0)
{
if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx)
{
@ -1168,7 +1168,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
void ih264d_rep_mv_colz(dec_struct_t *ps_dec,
mv_pred_t *ps_mv_pred_src,
mv_pred_t *ps_mv_pred_dst,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 u1_colz,
UWORD8 u1_ht,
UWORD8 u1_wd)
@ -1176,7 +1176,7 @@ void ih264d_rep_mv_colz(dec_struct_t *ps_dec,
UWORD8 k, m;
UWORD8 *pu1_colz = ps_dec->pu1_col_zero_flag + ps_dec->i4_submb_ofst
+ u1_sub_mb_num;
+ u4_sub_mb_num;
for(k = 0; k < u1_ht; k++)
{

12
decoder/ih264d_mvpred.h
View file

@ -95,7 +95,7 @@ void ih264d_get_motion_vector_predictor(mv_pred_t * ps_result,
UWORD8 u1_B,
const UWORD8 *pu1_mv_pred_condition);
void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
dec_struct_t *ps_dec,
@ -103,7 +103,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
dec_mb_info_t *ps_cur_mb_info,
UWORD8* pu0_scale);
void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
dec_struct_t *ps_dec,
@ -114,7 +114,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
mv_pred_t *ps_mv_final_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 uc_mb_part_width,
UWORD8 u1_lx_start,
UWORD8 u1_lxend,
@ -125,7 +125,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
mv_pred_t *ps_mv_final_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 uc_mb_part_width,
UWORD8 u1_lx_start,
UWORD8 u1_lxend,
@ -136,7 +136,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
mv_pred_t *ps_mv_final_pred,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 uc_mb_part_width,
UWORD8 u1_lx_start,
UWORD8 u1_lxend,
@ -145,7 +145,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
void ih264d_rep_mv_colz(dec_struct_t *ps_dec,
mv_pred_t *ps_mv_pred_src,
mv_pred_t *ps_mv_pred_dst,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 u1_colz,
UWORD8 u1_ht,
UWORD8 u1_wd);

63
decoder/ih264d_parse_bslice.c
View file

@ -74,8 +74,8 @@ void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
*/
WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2)
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2)
{
dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
@ -88,7 +88,7 @@ WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
+ 4;
parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
+ u1_num_mbsNby2;
+ u4_num_mbsNby2;
UWORD8 * pu1_col_info = ps_parse_mb_data->u1_col_info;
WORD8 (*pi1_ref_idx)[MAX_REFIDX_INFO_PER_MB] = ps_parse_mb_data->i1_ref_idx;
UWORD8 u1_mb_type = ps_cur_mb_info->u1_mb_type;
@ -241,7 +241,7 @@ WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
UWORD8 u1_p_idx = 0, u1_num_submb_part, uc_lx;
parse_part_params_t * ps_part;
mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
UWORD8 u1_mb_part_wd, u1_mb_part_ht;
/* Initialisations */
@ -397,15 +397,15 @@ WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2)
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2)
{
/* Loads from ps_dec */
decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
ctxt_inc_mb_info_t *p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info;
parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
+ u1_num_mbsNby2;
+ u4_num_mbsNby2;
/* table pointer loads */
const UWORD8 * pu1_sub_mb_pred_modes = (UWORD8 *)(gau1_ih264d_submb_pred_modes)
@ -539,7 +539,7 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
UWORD8 u1_num_submb_part;
parse_part_params_t *ps_part;
/* Initialisations */
mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
ps_part = ps_dec->ps_part;
/* Default initialization for non subMb case */
@ -550,7 +550,7 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
/* Decoding the MV for the subMB */
for(uc_lx = 0; uc_lx < 2; uc_lx++)
{
UWORD8 u1_sub_mb_num = 0;
UWORD32 u4_sub_mb_num = 0;
UWORD32 u4_mb_pred_mode_tmp = u4_mb_pred_mode;
UWORD32 u4_mb_mc_mode_tmp = u4_mb_mc_mode;
UWORD8 u1_mb_mc_mode_1, u1_pred_mode, uc_i;
@ -572,7 +572,7 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
{
u1_mb_part_wd = pu1_sub_mb_partw[u1_mb_mc_mode_1];
u1_mb_part_ht = pu1_sub_mb_parth[u1_mb_mc_mode_1];
u1_sub_mb_num = u2_sub_mb_num >> 12;
u4_sub_mb_num = u2_sub_mb_num >> 12;
pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_mc_mode_1 << 1);
u1_num_submb_part = pu1_num_sub_mb_part[u1_mb_mc_mode_1];
u2_sub_mb_num = u2_sub_mb_num << 4;
@ -582,15 +582,15 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
uc_j++, pu1_top_left_sub_mb_indx++)
{
mv_pred_t *ps_mv;
u1_sub_mb_num = u1_sub_mb_num + *pu1_top_left_sub_mb_indx;
ps_mv = ps_mv_start + u1_sub_mb_num;
u4_sub_mb_num = u4_sub_mb_num + *pu1_top_left_sub_mb_indx;
ps_mv = ps_mv_start + u4_sub_mb_num;
/* Storing Info for partitions, writing only once */
if(uc_lx)
{
ps_part->u1_is_direct = (!i1_pred);
ps_part->u1_pred_mode = i1_pred;
ps_part->u1_sub_mb_num = u1_sub_mb_num;
ps_part->u1_sub_mb_num = u4_sub_mb_num;
ps_part->u1_partheight = u1_mb_part_ht;
ps_part->u1_partwidth = u1_mb_part_wd;
@ -599,7 +599,7 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
ps_part++;
}
ih264d_get_mvd_cabac(u1_sub_mb_num, u1_b2, u1_mb_part_wd,
ih264d_get_mvd_cabac(u4_sub_mb_num, u1_b2, u1_mb_part_wd,
u1_mb_part_ht,
(UWORD8)(i1_pred & u1_pred_mode), ps_dec,
ps_mv);
@ -629,11 +629,11 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
*/
WORD32 ih264d_parse_bmb_cabac(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2)
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2)
{
UWORD8 u1_cbp;
deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_mb_num;
deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u4_mb_num;
const UWORD8 *puc_mb_mc_mode = (const UWORD8 *)gau1_ih264d_mb_mc_mode;
UWORD8 u1_mb_type = ps_cur_mb_info->u1_mb_type;
ctxt_inc_mb_info_t *p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info;
@ -649,8 +649,8 @@ WORD32 ih264d_parse_bmb_cabac(dec_struct_t * ps_dec,
ps_cur_deblk_mb->u1_mb_type |= D_B_SLICE;
if(u1_mb_type != B_DIRECT)
{
ret = ih264d_parse_bmb_non_direct_cabac(ps_dec, ps_cur_mb_info, u1_mb_num,
u1_num_mbsNby2);
ret = ih264d_parse_bmb_non_direct_cabac(ps_dec, ps_cur_mb_info, u4_mb_num,
u4_num_mbsNby2);
if(ret != OK)
return ret;
}
@ -744,11 +744,11 @@ WORD32 ih264d_parse_bmb_cabac(dec_struct_t * ps_dec,
*/
WORD32 ih264d_parse_bmb_cavlc(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2)
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2)
{
UWORD32 u4_cbp;
deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_mb_num;
deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u4_mb_num;
dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
UWORD32 * pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
@ -768,8 +768,8 @@ WORD32 ih264d_parse_bmb_cavlc(dec_struct_t * ps_dec,
ps_cur_deblk_mb->u1_mb_type |= D_B_SLICE;
if(u1_mb_type != B_DIRECT)
{
ret = ih264d_parse_bmb_non_direct_cavlc(ps_dec, ps_cur_mb_info, u1_mb_num,
u1_num_mbsNby2);
ret = ih264d_parse_bmb_non_direct_cavlc(ps_dec, ps_cur_mb_info, u4_mb_num,
u4_num_mbsNby2);
if(ret != OK)
return ret;
}
@ -883,26 +883,27 @@ WORD32 ih264d_parse_bmb_cavlc(dec_struct_t * ps_dec,
}
WORD32 ih264d_mv_pred_ref_tfr_nby2_bmb(dec_struct_t * ps_dec,
UWORD8 u1_mb_idx,
UWORD8 u1_num_mbs)
UWORD32 u4_mb_idx,
UWORD32 u4_num_mbs)
{
parse_pmbarams_t * ps_mb_part_info;
parse_part_params_t * ps_part;
mv_pred_t *ps_mv_nmb, *ps_mv_nmb_start, *ps_mv_ntop, *ps_mv_ntop_start;
pic_buffer_t * ps_ref_frame;
UWORD8 u1_direct_mode_width;
UWORD8 i, j;
UWORD32 i;
UWORD8 j;
dec_mb_info_t * ps_cur_mb_info;
const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
UWORD8 u1_field;
WORD32 ret = 0;
ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
ps_dec->i4_submb_ofst -= (WORD32)(u4_num_mbs - u4_mb_idx) << 4;
ps_mb_part_info = ps_dec->ps_parse_mb_data;
ps_part = ps_dec->ps_parse_part_params;
/* N/2 Mb MvPred and Transfer Setup Loop */
for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
for(i = u4_mb_idx; i < u4_num_mbs; i++, ps_mb_part_info++)
{
UWORD8 u1_colz = 0;
ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
@ -919,7 +920,7 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_bmb(dec_struct_t * ps_dec,
ps_dec->u2_mv_2mb[i & 0x1] = 0;
/* Look for MV Prediction and Reference Transfer in Non-I Mbs */
if(!ps_mb_part_info->u1_isI_mb)
if(!ps_mb_part_info->u4_isI_mb)
{
UWORD8 u1_blk_no;
WORD16 i1_ref_idx, i1_ref_idx1;
@ -938,7 +939,7 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_bmb(dec_struct_t * ps_dec,
/* MB Level initialisations */
ps_dec->u4_num_pmbair = i >> u1_mbaff;
ps_dec->u1_mb_idx_mv = i;
ps_dec->u4_mb_idx_mv = i;
/* CHANGED CODE */
ps_mv_ntop_start = ps_mv_nmb_start

10
decoder/ih264d_parse_headers.c
View file

@ -903,13 +903,13 @@ WORD32 ih264d_parse_sps(dec_struct_t *ps_dec, dec_bit_stream_t *ps_bitstrm)
/*--------------------------------------------------------------------*/
/* Get the value of MaxMbAddress and Number of bits needed for it */
/*--------------------------------------------------------------------*/
ps_seq->u2_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs
* ps_seq->u2_frm_ht_in_mbs) - 1;
ps_seq->u4_max_mb_addr = ((UWORD32)ps_seq->u2_frm_wd_in_mbs
* (UWORD32)ps_seq->u2_frm_ht_in_mbs) - 1;
ps_seq->u2_total_num_of_mbs = ps_seq->u2_max_mb_addr + 1;
ps_seq->u4_total_num_of_mbs = ps_seq->u4_max_mb_addr + 1;
ps_seq->u1_level_idc = ih264d_correct_level_idc(
u1_level_idc, ps_seq->u2_total_num_of_mbs);
u1_level_idc, ps_seq->u4_total_num_of_mbs);
u1_frm = ih264d_get_bit_h264(ps_bitstrm);
if((ps_dec->i4_header_decoded & 1) && (ps_seq->u1_frame_mbs_only_flag != u1_frm))
@ -1154,7 +1154,7 @@ WORD32 ih264d_parse_sps(dec_struct_t *ps_dec, dec_bit_stream_t *ps_bitstrm)
ps_dec->u2_pic_wd = u2_pic_wd;
ps_dec->u2_pic_ht = u2_pic_ht;
ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
ps_dec->u4_total_mbs = ps_seq->u4_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
/* Determining the Width and Height of Frame from that of Picture */
ps_dec->u2_frm_wd_y = u2_frm_wd_y;

148
decoder/ih264d_parse_islice.c
View file

@ -87,7 +87,7 @@ void ih264d_itrans_recon_luma_dc(dec_struct_t *ps_dec,
*/
WORD32 ih264d_parse_imb_cavlc(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD32 u4_mb_num,
UWORD8 u1_mb_type)
{
WORD32 i4_delta_qp;
@ -101,7 +101,7 @@ WORD32 ih264d_parse_imb_cavlc(dec_struct_t * ps_dec,
dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
UNUSED(u1_mb_num);
UNUSED(u4_mb_num);
ps_cur_mb_info->u1_tran_form8x8 = 0;
ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
@ -756,16 +756,16 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
UWORD16 u2_first_mb_in_slice)
{
UWORD8 uc_more_data_flag;
UWORD8 u1_num_mbs, u1_mb_idx;
UWORD32 u4_num_mbs, u4_mb_idx;
dec_mb_info_t *ps_cur_mb_info;
deblk_mb_t *ps_cur_deblk_mb;
dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
WORD16 i2_cur_mb_addr;
WORD32 i4_cur_mb_addr;
UWORD8 u1_mbaff;
UWORD8 u1_num_mbs_next, u1_end_of_row, u1_tfr_n_mb;
UWORD32 u4_num_mbs_next, u4_end_of_row, u4_tfr_n_mb;
WORD32 ret = OK;
ps_dec->u1_qp = ps_slice->u1_slice_qp;
@ -773,11 +773,11 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
/* initializations */
u1_mb_idx = ps_dec->u1_mb_idx;
u1_num_mbs = u1_mb_idx;
u4_mb_idx = ps_dec->u4_mb_idx;
u4_num_mbs = u4_mb_idx;
uc_more_data_flag = 1;
i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
i4_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
do
{
@ -785,14 +785,14 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i4_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
ps_cur_mb_info = ps_dec->ps_nmb_info + u4_num_mbs;
ps_dec->u4_num_mbs_cur_nmb = u4_num_mbs;
ps_dec->u4_num_pmbair = (u4_num_mbs >> u1_mbaff);
ps_cur_mb_info->u1_end_of_slice = 0;
@ -800,12 +800,12 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
/* Get the required information for decoding of MB */
/* mb_x, mb_y , neighbour availablity, */
/***************************************************************/
ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 0);
ps_dec->pf_get_mb_info(ps_dec, i4_cur_mb_addr, ps_cur_mb_info, 0);
/***************************************************************/
/* Set the deblocking parameters for this MB */
/***************************************************************/
ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u4_num_mbs;
if(ps_dec->u4_app_disable_deblk_frm == 0)
ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
@ -852,14 +852,14 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
{
/* I_PCM_MB */
ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u4_num_mbs);
if(ret != OK)
return ret;
ps_cur_deblk_mb->u1_mb_qp = 0;
}
else
{
ret = ih264d_parse_imb_cavlc(ps_dec, ps_cur_mb_info, u1_num_mbs, u1_mb_type);
ret = ih264d_parse_imb_cavlc(ps_dec, ps_cur_mb_info, u4_num_mbs, u1_mb_type);
if(ret != OK)
return ret;
ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
@ -876,7 +876,7 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
if(u1_mbaff)
{
ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
if(!uc_more_data_flag && (0 == (i4_cur_mb_addr & 1)))
{
return ERROR_EOB_FLUSHBITS_T;
}
@ -885,12 +885,12 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
/* Get next Macroblock address */
/**************************************************************/
i2_cur_mb_addr++;
i4_cur_mb_addr++;
/* Store the colocated information */
{
mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_num_mbs << 4);
mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u4_num_mbs << 4);
mv_pred_t s_mvPred =
{
@ -906,50 +906,50 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
{
if(ps_dec->u4_app_disable_deblk_frm == 0)
ps_dec->pf_compute_bs(ps_dec, ps_cur_mb_info,
(UWORD16)(u1_num_mbs >> u1_mbaff));
(UWORD16)(u4_num_mbs >> u1_mbaff));
}
u1_num_mbs++;
u4_num_mbs++;
/****************************************************************/
/* Check for End Of Row */
/****************************************************************/
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
u4_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u4_end_of_row = (!u4_num_mbs_next) && (!(u1_mbaff && (u4_num_mbs & 0x01)));
u4_tfr_n_mb = (u4_num_mbs == ps_dec->u4_recon_mb_grp) || u4_end_of_row
|| (!uc_more_data_flag);
ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
/*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d",
ps_slice->i4_poc >> ps_slice->u1_field_pic_flag,
ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb));
H264_DEC_DEBUG_PRINT("u1_tfr_n_mb || (!uc_more_data_flag): %d", u1_tfr_n_mb || (!uc_more_data_flag));*/
if(u1_tfr_n_mb || (!uc_more_data_flag))
H264_DEC_DEBUG_PRINT("u4_tfr_n_mb || (!uc_more_data_flag): %d", u4_tfr_n_mb || (!uc_more_data_flag));*/
if(u4_tfr_n_mb || (!uc_more_data_flag))
{
if(ps_dec->u1_separate_parse)
{
ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
ps_dec->ps_nmb_info += u1_num_mbs;
ih264d_parse_tfr_nmb(ps_dec, u4_mb_idx, u4_num_mbs,
u4_num_mbs_next, u4_tfr_n_mb, u4_end_of_row);
ps_dec->ps_nmb_info += u4_num_mbs;
}
else
{
ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
u1_num_mbs_next, u1_tfr_n_mb,
u1_end_of_row);
ih264d_decode_recon_tfr_nmb(ps_dec, u4_mb_idx, u4_num_mbs,
u4_num_mbs_next, u4_tfr_n_mb,
u4_end_of_row);
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb)
u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_total_mbs_coded += u4_num_mbs;
if(u4_tfr_n_mb)
u4_num_mbs = 0;
u4_mb_idx = u4_num_mbs;
ps_dec->u4_mb_idx = u4_num_mbs;
}
}
while(uc_more_data_flag);
ps_dec->u4_num_mbs_cur_nmb = 0;
ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
ps_dec->ps_cur_slice->u4_mbs_in_slice = i4_cur_mb_addr
- (u2_first_mb_in_slice << u1_mbaff);
@ -985,15 +985,15 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
UWORD16 u2_first_mb_in_slice)
{
UWORD8 uc_more_data_flag;
UWORD8 u1_num_mbs, u1_mb_idx;
UWORD32 u4_num_mbs, u4_mb_idx;
dec_mb_info_t *ps_cur_mb_info;
deblk_mb_t *ps_cur_deblk_mb;
dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
WORD16 i2_cur_mb_addr;
WORD32 i4_cur_mb_addr;
UWORD8 u1_mbaff;
UWORD8 u1_num_mbs_next, u1_end_of_row, u1_tfr_n_mb;
UWORD32 u4_num_mbs_next, u4_end_of_row, u4_tfr_n_mb;
WORD32 ret = OK;
ps_dec->u1_qp = ps_slice->u1_slice_qp;
@ -1013,18 +1013,18 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
ps_dec->i1_prev_mb_qp_delta = 0;
/* initializations */
u1_mb_idx = ps_dec->u1_mb_idx;
u1_num_mbs = u1_mb_idx;
u4_mb_idx = ps_dec->u4_mb_idx;
u4_num_mbs = u4_mb_idx;
uc_more_data_flag = 1;
i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
i4_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
do
{
UWORD16 u2_mbx;
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i4_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -1032,9 +1032,9 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
{
UWORD8 u1_mb_type;
ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
ps_cur_mb_info = ps_dec->ps_nmb_info + u4_num_mbs;
ps_dec->u4_num_mbs_cur_nmb = u4_num_mbs;
ps_dec->u4_num_pmbair = (u4_num_mbs >> u1_mbaff);
ps_cur_mb_info->u1_end_of_slice = 0;
@ -1042,7 +1042,7 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
/* Get the required information for decoding of MB */
/* mb_x, mb_y , neighbour availablity, */
/***************************************************************/
ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 0);
ps_dec->pf_get_mb_info(ps_dec, i4_cur_mb_addr, ps_cur_mb_info, 0);
u2_mbx = ps_dec->u2_mbx;
/*********************************************************************/
@ -1054,7 +1054,7 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
/***************************************************************/
/* Set the deblocking parameters for this MB */
/***************************************************************/
ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u4_num_mbs;
if(ps_dec->u4_app_disable_deblk_frm == 0)
ih264d_set_deblocking_parameters(
ps_cur_deblk_mb, ps_slice,
@ -1077,7 +1077,7 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
{
/* I_PCM_MB */
ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u4_num_mbs);
if(ret != OK)
return ret;
ps_cur_deblk_mb->u1_mb_qp = 0;
@ -1114,17 +1114,17 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
if(u1_mbaff)
{
if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
if(!uc_more_data_flag && (0 == (i4_cur_mb_addr & 1)))
{
return ERROR_EOB_FLUSHBITS_T;
}
}
/* Next macroblock information */
i2_cur_mb_addr++;
i4_cur_mb_addr++;
/* Store the colocated information */
{
mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_num_mbs << 4);
mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u4_num_mbs << 4);
mv_pred_t s_mvPred =
{
{ 0, 0, 0, 0 },
@ -1139,49 +1139,49 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
{
if(ps_dec->u4_app_disable_deblk_frm == 0)
ps_dec->pf_compute_bs(ps_dec, ps_cur_mb_info,
(UWORD16)(u1_num_mbs >> u1_mbaff));
(UWORD16)(u4_num_mbs >> u1_mbaff));
}
u1_num_mbs++;
u4_num_mbs++;
}
/****************************************************************/
/* Check for End Of Row */
/****************************************************************/
u1_num_mbs_next = i2_pic_wdin_mbs - u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
u4_num_mbs_next = i2_pic_wdin_mbs - u2_mbx - 1;
u4_end_of_row = (!u4_num_mbs_next) && (!(u1_mbaff && (u4_num_mbs & 0x01)));
u4_tfr_n_mb = (u4_num_mbs == ps_dec->u4_recon_mb_grp) || u4_end_of_row
|| (!uc_more_data_flag);
ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
if(u1_tfr_n_mb || (!uc_more_data_flag))
if(u4_tfr_n_mb || (!uc_more_data_flag))
{
if(ps_dec->u1_separate_parse)
{
ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
ps_dec->ps_nmb_info += u1_num_mbs;
ih264d_parse_tfr_nmb(ps_dec, u4_mb_idx, u4_num_mbs,
u4_num_mbs_next, u4_tfr_n_mb, u4_end_of_row);
ps_dec->ps_nmb_info += u4_num_mbs;
}
else
{
ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
u1_num_mbs_next, u1_tfr_n_mb,
u1_end_of_row);
ih264d_decode_recon_tfr_nmb(ps_dec, u4_mb_idx, u4_num_mbs,
u4_num_mbs_next, u4_tfr_n_mb,
u4_end_of_row);
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb)
u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_total_mbs_coded += u4_num_mbs;
if(u4_tfr_n_mb)
u4_num_mbs = 0;
u4_mb_idx = u4_num_mbs;
ps_dec->u4_mb_idx = u4_num_mbs;
}
}
while(uc_more_data_flag);
ps_dec->u4_num_mbs_cur_nmb = 0;
ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
ps_dec->ps_cur_slice->u4_mbs_in_slice = i4_cur_mb_addr
- (u2_first_mb_in_slice << u1_mbaff);
@ -1211,7 +1211,7 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
WORD32 ih264d_parse_ipcm_mb(dec_struct_t * ps_dec,
dec_mb_info_t *ps_cur_mb_info,
UWORD8 u1_mbNum)
UWORD32 u4_mbNum)
{
dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
@ -1263,7 +1263,7 @@ WORD32 ih264d_parse_ipcm_mb(dec_struct_t * ps_dec,
ps_dec->i1_prev_mb_qp_delta = 0;
/* Get neighbour MB's */
u1_num_mb_pair = (u1_mbNum >> u1_mbaff);
u1_num_mb_pair = (u4_mbNum >> u1_mbaff);
/*****************************************************************************/
/* calculate the RECON buffer YUV pointers for the PCM data */

32
decoder/ih264d_parse_islice.h
View file

@ -50,7 +50,7 @@ WORD32 ih264d_parse_residual4x4_cabac(dec_struct_t * ps_dec,
UWORD8 u1_offset);
WORD32 ih264d_parse_imb_cavlc(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD32 u4_mb_num,
UWORD8 u1_mb_type);
WORD32 ih264d_parse_imb_cabac(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
@ -64,32 +64,32 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
UWORD16 u2_first_mb_in_slice);
WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2);
WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2);
WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_mbNumModNBy2);
UWORD32 u4_mb_num,
UWORD32 u4_mbNumModNBy2);
WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_mbNumModNBy2);
UWORD32 u4_mb_num,
UWORD32 u4_mbNumModNBy2);
WORD32 ih264d_parse_bmb_cavlc(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2);
WORD32 ih264d_parse_bmb_cabac(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2);
WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
dec_slice_params_t * ps_slice,
@ -101,12 +101,12 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
WORD32 ParseBMb(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2);
WORD32 ih264d_parse_ipcm_mb(dec_struct_t * ps_dec,
dec_mb_info_t *ps_cur_mb_info,
UWORD8 u1_mbNum);
UWORD32 u4_mbNum);
WORD32 ih264d_parse_islice(dec_struct_t *ps_dec,
UWORD16 u2_first_mb_in_slice);

2
decoder/ih264d_parse_mb_header.c
View file

@ -1308,7 +1308,7 @@ WORD16 ih264d_parse_mvd_cabac(dec_bit_stream_t * ps_bitstrm,
{
/* Read Suffix */
k = ih264d_decode_bypass_bins_unary(ps_cab_env, ps_bitstrm);
i2_suf = (1 << k) - 1;
i2_suf = (k > 15) ? INT16_MAX : ((1 << k) - 1);
k = k + 3;
i2_suf = (i2_suf << 3);
i2_mvd += i2_suf;

112
decoder/ih264d_parse_pslice.c
View file

@ -82,8 +82,8 @@ void ih264d_deblock_mb_level(dec_struct_t *ps_dec,
*/
WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2)
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2)
{
UWORD32 u1_num_mb_part;
UWORD32 uc_sub_mb;
@ -92,7 +92,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
+ u1_num_mbsNby2;
+ u4_num_mbsNby2;
WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part;
@ -202,7 +202,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
else
{
/* When there exists only a single frame to predict from */
UWORD8 uc_i;
UWORD32 uc_i;
for(uc_i = 0; uc_i < u1_num_mb_part; uc_i++)
/* Storing Reference Idx Information */
pi1_ref_idx[uc_i] = 0;
@ -210,12 +210,13 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
}
{
UWORD8 u1_p_idx, uc_i;
UWORD8 u1_p_idx;
UWORD32 uc_i;
parse_part_params_t * ps_part = ps_dec->ps_part;
UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
UWORD8 u1_sub_mb_num;
UWORD32 u4_sub_mb_num;
const UWORD8 * pu1_top_left_sub_mb_indx;
mv_pred_t * ps_mv, *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
mv_pred_t * ps_mv, *ps_mv_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
/* Loading the table pointers */
const UWORD8 * pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
@ -238,7 +239,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
u1_mb_part_width = pu1_mb_partw[u1_mb_type];
u1_mb_part_height = pu1_mb_parth[u1_mb_type];
pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
u1_sub_mb_num = 0;
u4_sub_mb_num = 0;
/* Loop on number of partitions */
for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
@ -251,7 +252,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
u1_sub_mb_num = u2_sub_mb_num >> 12;
u4_sub_mb_num = u2_sub_mb_num >> 12;
u4_sum_mb_mode_pack <<= 8;
u2_sub_mb_num <<= 4;
}
@ -260,8 +261,8 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++)
{
WORD16 i2_mvx, i2_mvy;
u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
ps_mv = ps_mv_start + u1_sub_mb_num;
u4_sub_mb_num += *pu1_top_left_sub_mb_indx;
ps_mv = ps_mv_start + u4_sub_mb_num;
/* Reading the differential Mv from the bitstream */
//i2_mvx = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
@ -302,7 +303,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
/* Storing Info for partitions */
ps_part->u1_is_direct = PART_NOT_DIRECT;
ps_part->u1_sub_mb_num = u1_sub_mb_num;
ps_part->u1_sub_mb_num = u4_sub_mb_num;
ps_part->u1_partheight = u1_mb_part_height;
ps_part->u1_partwidth = u1_mb_part_width;
@ -430,13 +431,13 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
*/
WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2)
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2)
{
UWORD32 u1_num_mb_part;
UWORD32 uc_sub_mb;
parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
+ u1_num_mbsNby2;
+ u4_num_mbsNby2;
WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part;
const UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type;
@ -584,12 +585,13 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
}
{
UWORD8 u1_p_idx, uc_i;
UWORD8 u1_p_idx;
UWORD32 uc_i;
parse_part_params_t * ps_part = ps_dec->ps_part;
UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
UWORD8 u1_sub_mb_num;
UWORD32 u4_sub_mb_num;
const UWORD8 * pu1_top_left_sub_mb_indx;
mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
UWORD16 u2_sub_mb_num_pack = 0x028A;
/* Loading the table pointers */
@ -612,7 +614,7 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
u1_mb_part_width = pu1_mb_partw[u1_mb_type];
u1_mb_part_height = pu1_mb_parth[u1_mb_type];
pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
u1_sub_mb_num = 0;
u4_sub_mb_num = 0;
/* Loop on number of partitions */
for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
@ -625,7 +627,7 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
u1_sub_mb_num = u2_sub_mb_num_pack >> 12;
u4_sub_mb_num = u2_sub_mb_num_pack >> 12;
u4_sub_mb_pack <<= 8;
u2_sub_mb_num_pack <<= 4;
}
@ -634,12 +636,12 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
{
mv_pred_t * ps_mv;
u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
ps_mv = ps_mv_start + u1_sub_mb_num;
u4_sub_mb_num += *pu1_top_left_sub_mb_indx;
ps_mv = ps_mv_start + u4_sub_mb_num;
/* Storing Info for partitions */
ps_part->u1_is_direct = PART_NOT_DIRECT;
ps_part->u1_sub_mb_num = u1_sub_mb_num;
ps_part->u1_sub_mb_num = u4_sub_mb_num;
ps_part->u1_partheight = u1_mb_part_height;
ps_part->u1_partwidth = u1_mb_part_width;
@ -647,7 +649,7 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
u1_p_idx++;
ps_part++;
ih264d_get_mvd_cabac(u1_sub_mb_num, 0, u1_mb_part_width,
ih264d_get_mvd_cabac(u4_sub_mb_num, 0, u1_mb_part_width,
u1_mb_part_height, 1, ps_dec, ps_mv);
}
}
@ -848,7 +850,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
i2_cur_mb_addr = u2_first_mb_in_slice;
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
u1_num_mbsNby2 = 0;
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
@ -875,7 +877,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -891,7 +893,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
/* Storing Default partition info */
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
/***************************************************************/
/* Get the required information for decoding of MB */
@ -972,7 +974,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
{
/* Storing Intra partition info */
ps_parse_mb_data->u1_num_part = 0;
ps_parse_mb_data->u1_isI_mb = 1;
ps_parse_mb_data->u4_isI_mb = 1;
if((25 + u1_mb_threshold) == u1_mb_type)
{
@ -1046,7 +1048,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_slice_end = !uc_more_data_flag;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row
|| u1_slice_end;
u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@ -1085,11 +1087,11 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
u1_num_mbs_next, u1_tfr_n_mb,
u1_end_of_row);
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb)
u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
}
@ -1178,7 +1180,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
/******************************************************/
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
u1_num_mbsNby2 = 0;
@ -1194,7 +1196,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -1211,7 +1213,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
/* Storing Default partition info */
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
if((!i2_mb_skip_run) && (!u1_read_mb_type))
{
@ -1334,7 +1336,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
{
/* Storing Intra partition info */
ps_parse_mb_data->u1_num_part = 0;
ps_parse_mb_data->u1_isI_mb = 1;
ps_parse_mb_data->u4_isI_mb = 1;
if((25 + u1_mb_threshold) == u1_mb_type)
{
@ -1391,7 +1393,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row
|| u1_slice_end;
u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@ -1432,11 +1434,11 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
u1_num_mbs_next, u1_tfr_n_mb,
u1_end_of_row);
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb)
u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
//ps_dec->ps_pred++;
@ -1459,7 +1461,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
{
WORD32 i2_cur_mb_addr;
UWORD32 u1_num_mbs, u1_num_mbsNby2;
UWORD32 u1_mb_idx = ps_dec->u1_mb_idx;
UWORD32 u1_mb_idx = ps_dec->u4_mb_idx;
UWORD32 i2_mb_skip_run;
UWORD32 u1_num_mbs_next, u1_end_of_row;
@ -1634,7 +1636,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
{
ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
ps_dec->u2_cur_mb_addr--;
ps_dec->u4_cur_mb_addr--;
}
u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
@ -1665,7 +1667,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
{
// Going back 1 mb
ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
ps_dec->u2_cur_mb_addr--;
ps_dec->u4_cur_mb_addr--;
ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
// Parse/decode N-MB left unparsed
@ -1694,12 +1696,12 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u1_mb_idx = 0;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
ps_dec->u4_mb_idx = 0;
ps_dec->u4_num_mbs_cur_nmb = 0;
}
if(ps_dec->u2_total_mbs_coded
if(ps_dec->u4_total_mbs_coded
>= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
ps_dec->u1_pic_decode_done = 1;
@ -1708,7 +1710,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
/* Inserting new slice only if the current slice has atleast 1 MB*/
if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
(UWORD32)(ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
(UWORD32)(ps_dec->u4_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
{
ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
@ -1750,14 +1752,14 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf;
}
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u4_total_mbs_coded >> u1_mbaff;
ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
if(ps_dec->ps_cur_slice->u1_field_pic_flag)
ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u4_total_mbs_coded >> u1_mbaff;
ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
@ -1792,7 +1794,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
ps_dec->u1_slice_header_done = 2;
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
ps_parse_mb_data = ps_dec->ps_parse_mb_data;
u1_num_mbs = u1_mb_idx;
@ -1800,14 +1802,14 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
u1_tfr_n_mb = 0;
u1_decode_nmb = 0;
u1_num_mbsNby2 = 0;
i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
i2_cur_mb_addr = ps_dec->u4_total_mbs_coded;
i2_mb_skip_run = num_mb_skip;
while(!u1_slice_end)
{
UWORD8 u1_mb_type;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
break;
ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
@ -1821,7 +1823,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
/* Storing Default partition info */
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
/**************************************************************/
/* Get the required information for decoding of MB */
@ -1885,7 +1887,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_slice_end = !i2_mb_skip_run;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row
|| u1_slice_end;
u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@ -1909,11 +1911,11 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
u1_tfr_n_mb, u1_end_of_row);
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb)
u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
}
@ -1934,7 +1936,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
if(ps_dec->u2_total_mbs_coded
if(ps_dec->u4_total_mbs_coded
>= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
ps_dec->u1_pic_decode_done = 1;

56
decoder/ih264d_parse_slice.c
View file

@ -566,10 +566,10 @@ WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0];
/* CHANGED CODE */
ps_dec->u1_mv_top_p = 0;
ps_dec->u1_mb_idx = 0;
ps_dec->u4_mb_idx = 0;
/* CHANGED CODE */
ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv;
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_total_mbs_coded = 0;
ps_dec->i4_submb_ofst = -(SUB_BLK_SIZE);
ps_dec->u4_pred_info_idx = 0;
ps_dec->u4_pred_info_pkd_idx = 0;
@ -627,13 +627,13 @@ WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
UWORD8 u1_mbaff = ps_cur_slice->u1_mbaff_frame_flag;
UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4)
% (ps_dec->u1_recon_mb_grp >> u1_mbaff));
UWORD16 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4)
% (ps_dec->u4_recon_mb_grp >> u1_mbaff));
UWORD16 ui16_lastmbs_widthY =
(uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u1_recon_mb_grp
(uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u4_recon_mb_grp
>> u1_mbaff) << 4));
UWORD16 ui16_lastmbs_widthUV =
uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u1_recon_mb_grp
uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u4_recon_mb_grp
>> u1_mbaff) << 3);
ps_dec->s_tran_addrecon.pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
@ -652,9 +652,9 @@ WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
}
/* Normal Increment of Pointer */
ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u1_recon_mb_grp << 4)
ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u4_recon_mb_grp << 4)
>> u1_mbaff);
ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u1_recon_mb_grp << 4)
ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u4_recon_mb_grp << 4)
>> u1_mbaff);
/* End of Row Increment */
@ -670,9 +670,9 @@ WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
/* Assign picture numbers to each frame/field */
/* only once per picture. */
ih264d_assign_pic_num(ps_dec);
ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (ps_dec->u1_recon_mb_grp
ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (ps_dec->u4_recon_mb_grp
<< 2) - 1 - (u1_mbaff << 2);
ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u1_recon_mb_grp
ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u4_recon_mb_grp
>> u1_mbaff) - 1) << (4 + u1_mbaff);
}
/**********************************************************************/
@ -765,8 +765,8 @@ WORD32 ih264d_end_of_pic_dispbuf_mgr(dec_struct_t * ps_dec)
|| (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL))
{
ps_dec->ps_cur_pic->i4_poc = 0;
if(ps_dec->u2_total_mbs_coded
== (ps_dec->ps_cur_sps->u2_max_mb_addr + 1))
if(ps_dec->u4_total_mbs_coded
== (ps_dec->ps_cur_sps->u4_max_mb_addr + 1))
ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr);
ih264d_release_display_bufs(ps_dec);
}
@ -1081,7 +1081,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
WORD32 ret, end_of_frame;
WORD32 prev_slice_err, num_mb_skipped;
UWORD8 u1_mbaff;
UWORD32 u4_mbaff;
pocstruct_t *ps_cur_poc;
UWORD32 u4_temp;
@ -1101,7 +1101,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
/*we currently don not support ASO*/
if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag)
<= ps_dec->u2_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0))
<= ps_dec->u4_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0))
{
return ERROR_CORRUPTED_SLICE;
}
@ -1184,7 +1184,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
}
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_total_mbs_coded = 0;
}
/* Get the field related flags */
if(!ps_seq->u1_frame_mbs_only_flag)
@ -1305,7 +1305,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
/* Check for error in slice and parse the missing/corrupted MB's */
/* as skip-MB's in an inserted P-slice */
/*--------------------------------------------------------------------*/
u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
u4_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
prev_slice_err = 0;
if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
@ -1338,7 +1338,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
ps_cur_slice->u1_bottom_field_flag = 0;
num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
- ps_dec->u2_total_mbs_coded;
- ps_dec->u4_total_mbs_coded;
ps_cur_poc = &ps_dec->s_cur_pic_poc;
u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
@ -1349,7 +1349,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
{
// first slice - missing/header corruption
prev_slice_err = 1;
num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
num_mb_skipped = u2_first_mb_in_slice << u4_mbaff;
ps_cur_poc = &s_tmp_poc;
// initializing slice parameters
@ -1373,21 +1373,21 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
prev_slice_err = 2;
num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs
* ps_dec->u2_frm_wd_in_mbs)
- ps_dec->u2_total_mbs_coded;
- ps_dec->u4_total_mbs_coded;
ps_cur_poc = &s_tmp_poc;
}
}
else
{
if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
if((u2_first_mb_in_slice << u4_mbaff) > ps_dec->u4_total_mbs_coded)
{
// previous slice - missing/corruption
prev_slice_err = 2;
num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff)
- ps_dec->u2_total_mbs_coded;
num_mb_skipped = (u2_first_mb_in_slice << u4_mbaff)
- ps_dec->u4_total_mbs_coded;
ps_cur_poc = &s_tmp_poc;
}
else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
else if((u2_first_mb_in_slice << u4_mbaff) < ps_dec->u4_total_mbs_coded)
{
return ERROR_CORRUPTED_SLICE;
}
@ -1411,7 +1411,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
return ERROR_INCOMPLETE_FRAME;
}
if(ps_dec->u2_total_mbs_coded
if(ps_dec->u4_total_mbs_coded
>= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
/* return if all MBs in frame are parsed*/
@ -1501,7 +1501,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
/* Increment only if the current slice has atleast 1 more MB */
if (ps_dec->u4_first_slice_in_pic == 0 &&
(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
(UWORD32)(ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
(UWORD32)(ps_dec->u4_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
{
ps_dec->ps_parse_cur_slice++;
ps_dec->u2_cur_slice_num++;
@ -1791,7 +1791,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
+ (u2_first_mb_in_slice << u1_mb_aff);
}
ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
ps_dec->u4_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv
+ ((u2_first_mb_in_slice << u1_mb_aff) << 4);
@ -1813,7 +1813,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
u2_mb_x = 0xffff;
u2_mb_y = 0;
// assign the deblock structure pointers to start of slice
ps_dec->u2_cur_mb_addr = 0;
ps_dec->u4_cur_mb_addr = 0;
ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
@ -1938,7 +1938,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
/* End of Picture detection */
if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
if(ps_dec->u4_total_mbs_coded >= (ps_seq->u4_max_mb_addr + 1))
{
ps_dec->u1_pic_decode_done = 1;

55
decoder/ih264d_process_bslice.c
View file

@ -71,13 +71,14 @@ void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
UWORD8 u1_wd_x,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num)
UWORD32 u4_mb_num)
{
mv_pred_t s_mv_pred, *ps_mv;
UWORD8 u1_col_zero_flag, u1_sub_mb_num, u1_direct_zero_pred_flag = 0;
UWORD32 u4_sub_mb_num;
UWORD8 u1_col_zero_flag, u1_direct_zero_pred_flag = 0;
UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
mv_pred_t *ps_mv_ntop_start;
mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
UWORD8 partition_size, sub_partition, u1_mb_partw, u1_mb_parth;
UWORD8 i;
WORD8 i1_pred, i1_ref_frame0, i1_ref_frame1;
@ -104,7 +105,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
WORD32 ret = 0;
/* CHANGED CODE */
ps_mv_ntop_start = ps_dec->ps_mv_cur + (u1_mb_num << 4)
ps_mv_ntop_start = ps_dec->ps_mv_cur + (u4_mb_num << 4)
- (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12;
/* assign default values for MotionVector as zero */
@ -251,7 +252,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
i2_mvY1 = i2_spat_pred_mv[3];
}
u1_sub_mb_num = ps_dec->u1_sub_mb_num;
u4_sub_mb_num = ps_dec->u1_sub_mb_num;
u1_mb_partw = (u1_wd_x >> 2);
@ -266,7 +267,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
i2_mv[1] = i2_mv_y;
ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u1_sub_mb_num,i1_pred,
ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u4_sub_mb_num,i1_pred,
ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
ps_pic_buff0->u1_pic_type);
ps_dec->u4_pred_info_pkd_idx++;
@ -288,7 +289,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
i2_mv[1] = i2_mvY1;
ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u1_sub_mb_num,i1_pred,
ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u4_sub_mb_num,i1_pred,
ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
ps_pic_buff1->u1_pic_type);
ps_dec->u4_pred_info_pkd_idx++;
@ -331,8 +332,8 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
&& (ABS(i2_mv_y) <= 1));
u1_colz |= (u1_packed_mb_sub_mb_mode << 6);
}
ps_mv = ps_mv_nmb_start + u1_sub_mb_num;
ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz,
ps_mv = ps_mv_nmb_start + u4_sub_mb_num;
ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num, u1_colz,
u1_mb_partw, u1_mb_partw);
if(u1_wd_x == MB_SIZE)
ps_dec->u1_currB_type = 0;
@ -434,7 +435,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
for(i = 0; i < s_mvdirect.i1_num_partitions; i++)
{
partition_size = s_mvdirect.i1_partitionsize[i];
u1_sub_mb_num = s_mvdirect.i1_submb_num[i];
u4_sub_mb_num = s_mvdirect.i1_submb_num[i];
sub_partition = partition_size >> 2;
partition_size &= 0x3;
@ -458,7 +459,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1)))
{
pi2_final_mv0 = &i2_def_mv[0];
ui2_mask_fwd |= (u2_mask << u1_sub_mb_num);
ui2_mask_fwd |= (u2_mask << u4_sub_mb_num);
}
else
pi2_final_mv0 = &i2_spat_pred_mv[0];
@ -466,15 +467,15 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1)))
{
pi2_final_mv1 = &i2_def_mv[0];
ui2_mask_bwd |= (u2_mask << u1_sub_mb_num);
ui2_mask_bwd |= (u2_mask << u4_sub_mb_num);
}
else
pi2_final_mv1 = &i2_spat_pred_mv[2];
if(ps_cur_mb_info->u1_Mux != 1)
{
/*u1_sub_mb_x = u1_sub_mb_num & 0x03;
uc_sub_mb_y = (u1_sub_mb_num >> 2);*/
/*u1_sub_mb_x = u4_sub_mb_num & 0x03;
uc_sub_mb_y = (u4_sub_mb_num >> 2);*/
if(i1_ref_frame0 >= 0)
{
@ -483,7 +484,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
WORD8 i1_ref_idx= 0;
ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
ih264d_fill_pred_info(pi2_final_mv0,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,i1_pred,
ih264d_fill_pred_info(pi2_final_mv0,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,i1_pred,
ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
ps_pic_buff0->u1_pic_type);
ps_dec->u4_pred_info_pkd_idx++;
@ -501,7 +502,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
WORD8 i1_ref_idx= 0;
ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
ih264d_fill_pred_info(pi2_final_mv1,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,i1_pred,
ih264d_fill_pred_info(pi2_final_mv1,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,i1_pred,
ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
ps_pic_buff1->u1_pic_type);
ps_dec->u4_pred_info_pkd_idx++;
@ -549,8 +550,8 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
&& (ABS(i2_mv_y) <= 1));
u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
}
ps_mv = ps_mv_nmb_start + u1_sub_mb_num;
ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz,
ps_mv = ps_mv_nmb_start + u4_sub_mb_num;
ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num, u1_colz,
u1_mb_parth, u1_mb_partw);
}
i = 0;
@ -582,11 +583,11 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
UWORD8 u1_wd_x,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num)
UWORD32 u4_mb_num)
{
struct pic_buffer_t *ps_pic_buff0, *ps_pic_buff1, *ps_col_pic;
mv_pred_t *ps_mv, s_temp_mv_pred;
UWORD8 u1_sub_mb_num;
UWORD32 u4_sub_mb_num;
UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
WORD16 i2_mv_x0, i2_mv_y0, i2_mv_x1, i2_mv_y1;
UWORD8 u1_mb_partw, u1_mb_parth;
@ -615,7 +616,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
{
UWORD8 u1_colz;
partition_size = s_mvdirect.i1_partitionsize[i];
u1_sub_mb_num = s_mvdirect.i1_submb_num[i];
u4_sub_mb_num = s_mvdirect.i1_submb_num[i];
ps_mv = ps_col_pic->ps_mv + s_mvdirect.i4_mv_indices[i];
/* This should be removed to catch unitialized memory read */
@ -810,8 +811,8 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
{
mv_pred_t *ps_mv;
/*u1_sub_mb_x = u1_sub_mb_num & 0x03;
uc_sub_mb_y = u1_sub_mb_num >> 2;*/
/*u1_sub_mb_x = u4_sub_mb_num & 0x03;
uc_sub_mb_y = u4_sub_mb_num >> 2;*/
if(ps_dec->ps_cur_pps->u1_wted_bipred_idc)
{
UWORD8 u1_idx =
@ -851,7 +852,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
i2_mv[1] = i2_mv_y0;
ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,PRED_L0 | PRED_L1,
ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,PRED_L0 | PRED_L1,
ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
ps_pic_buff0->u1_pic_type);
ps_dec->u4_pred_info_pkd_idx++;
@ -868,7 +869,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
i2_mv[1] = i2_mv_y1;
ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,PRED_L0 | PRED_L1,
ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,PRED_L0 | PRED_L1,
ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
ps_pic_buff1->u1_pic_type);
ps_dec->u4_pred_info_pkd_idx++;
@ -886,7 +887,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
s_temp_mv_pred.i1_ref_frame[1] = 0;
s_temp_mv_pred.u1_col_ref_pic_idx = ps_pic_buff0->u1_mv_buf_id;
s_temp_mv_pred.u1_pic_type = ps_pic_buff0->u1_pic_type;
ps_mv = ps_dec->ps_mv_cur + (u1_mb_num << 4) + u1_sub_mb_num;
ps_mv = ps_dec->ps_mv_cur + (u4_mb_num << 4) + u4_sub_mb_num;
{
WORD16 i2_mv_x = 0, i2_mv_y = 0;
@ -914,7 +915,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
<= 1));
u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
}
ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num,
ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num,
u1_colz, u1_mb_parth, u1_mb_partw);
}
}

8
decoder/ih264d_process_bslice.h
View file

@ -43,11 +43,11 @@ WORD32 ih264d_parse_bslice(dec_struct_t * ps_dec,
WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
UWORD8 u1_wd_x,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num);
UWORD32 u4_mb_num);
WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
UWORD8 u1_wd_x,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num);
UWORD32 u4_mb_num);
WORD32 parseBSliceData(dec_struct_t * ps_dec,
dec_slice_params_t * ps_slice,
UWORD16 u2_first_mb_in_slice);
@ -102,7 +102,7 @@ void ih264d_fld_to_mbaff(dec_struct_t *ps_dec,
WORD32 ih264d_cal_col_pic(dec_struct_t *ps_dec);
WORD32 ih264d_mv_pred_ref_tfr_nby2_bmb(dec_struct_t * ps_dec,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbsNby2);
#endif /* _IH264D_PARSE_BSLICE_H_ */

29
decoder/ih264d_process_intra_mb.c
View file

@ -715,7 +715,7 @@ UWORD32 ih264d_unpack_luma_coeff8x8_mb(dec_struct_t * ps_dec,
*/
WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num)
UWORD32 u4_mb_num)
{
UWORD8 u1_mb_type = ps_cur_mb_info->u1_mb_type;
UWORD8 uc_temp = ps_cur_mb_info->u1_mb_ngbr_availablity;
@ -758,7 +758,7 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
UWORD8 *pu1_prev_intra4x4_pred_mode_data = (UWORD8 *)ps_dec->pv_proc_tu_coeff_data; //Pointer to keep track of intra4x4_pred_mode data in pv_proc_tu_coeff_data buffer
u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
u1_topmb = ps_cur_mb_info->u1_topmb;
u4_num_pmbair = (u1_mb_num >> u1_mbaff);
u4_num_pmbair = (u4_mb_num >> u1_mbaff);
/*--------------------------------------------------------------------*/
@ -1353,7 +1353,8 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
else if((u1_mb_type == I_4x4_MB) && (ps_cur_mb_info->u1_tran_form8x8 == 1))
{
UWORD8 u1_is_left_sub_block, u1_is_top_sub_block = uc_useTopMB;
UWORD8 u1_sub_blk_x, u1_sub_blk_y, u1_sub_mb_num;
UWORD8 u1_sub_blk_x, u1_sub_blk_y;
UWORD32 u4_sub_mb_num;
WORD8 i1_top_pred_mode;
WORD8 i1_left_pred_mode;
UWORD8 *pu1_top, *pu1_left, *pu1_top_left;
@ -1565,20 +1566,20 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
}
/* Scan the sub-blocks in Raster Scan Order */
for(u1_sub_mb_num = 0; u1_sub_mb_num < 4; u1_sub_mb_num++)
for(u4_sub_mb_num = 0; u4_sub_mb_num < 4; u4_sub_mb_num++)
{
u1_sub_blk_x = (u1_sub_mb_num & 0x1);
u1_sub_blk_y = (u1_sub_mb_num >> 1);
u1_sub_blk_x = (u4_sub_mb_num & 0x1);
u1_sub_blk_y = (u4_sub_mb_num >> 1);
i1_top_pred_mode = pi1_cur_pred_mode[u1_sub_blk_x << 1];
i1_left_pred_mode = pi1_left_pred_mode[u1_sub_blk_y << 1];
if(2 == u1_sub_mb_num)
if(2 == u4_sub_mb_num)
{
i1_left_pred_mode = pi1_left_pred_mode[(u1_sub_blk_y << 1)
+ u4_4x4_left_offset];
}
u1_use_top_right_mb = (!!CHECKBIT(ui2_top_rt_mask, u1_sub_mb_num));
u1_use_top_right_mb = (!!CHECKBIT(ui2_top_rt_mask, u4_sub_mb_num));
/*********** left subblock availability**********/
if(u1_sub_blk_x)
@ -1621,7 +1622,7 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
}
/***************** Top Left *********************/
if(u1_sub_mb_num)
if(u4_sub_mb_num)
{
pu1_top_left = (u1_sub_blk_x) ?
pu1_top - 1 : pu1_left - ui_rec_width;
@ -1649,10 +1650,10 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
/* for a MB with 8x8 intrapredicition */
/********************************************************************/
PROFILE_DISABLE_INTRA_PRED()
if(!pu1_prev_intra4x4_pred_mode_flag[u1_sub_mb_num])
if(!pu1_prev_intra4x4_pred_mode_flag[u4_sub_mb_num])
{
i1_intra_pred = pu1_rem_intra4x4_pred_mode[u1_sub_mb_num]
+ (pu1_rem_intra4x4_pred_mode[u1_sub_mb_num]
i1_intra_pred = pu1_rem_intra4x4_pred_mode[u4_sub_mb_num]
+ (pu1_rem_intra4x4_pred_mode[u4_sub_mb_num]
>= i1_intra_pred);
}
i1_intra_pred = CLIP3(0, 8, i1_intra_pred);
@ -1694,7 +1695,7 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
}
/* Inverse Transform and Reconstruction */
if(CHECKBIT(ps_cur_mb_info->u1_cbp, u1_sub_mb_num))
if(CHECKBIT(ps_cur_mb_info->u1_cbp, u4_sub_mb_num))
{
WORD16 *pi2_scale_matrix_ptr;
WORD16 ai2_tmp[64];
@ -1703,7 +1704,7 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
ps_dec->s_high_profile.i2_scalinglist8x8[0];
PROFILE_DISABLE_IQ_IT_RECON()
{
if(CHECKBIT(u4_luma_dc_only_cbp, u1_sub_mb_num))
if(CHECKBIT(u4_luma_dc_only_cbp, u4_sub_mb_num))
{
ps_dec->pf_iquant_itrans_recon_luma_8x8_dc(
pi2_y_coeff1,

2
decoder/ih264d_process_intra_mb.h
View file

@ -59,7 +59,7 @@ WORD32 ih264d_read_intra_pred_modes(dec_struct_t *ps_dec,
WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num);
UWORD32 u4_mb_num);
#endif /* _IH264D_PROCESS_INTRA_MB_H_ */

50
decoder/ih264d_process_pslice.c
View file

@ -68,8 +68,8 @@ void ih264d_insert_pic_in_ref_pic_listx(struct pic_buffer_t *ps_ref_pic_buf_lx,
}
WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
UWORD8 u1_mb_idx,
UWORD8 u1_num_mbs)
UWORD32 u4_mb_idx,
UWORD32 u4_num_mbs)
{
parse_pmbarams_t * ps_mb_part_info;
parse_part_params_t * ps_part;
@ -80,12 +80,12 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
WORD32 i2_mv_x, i2_mv_y;
WORD32 ret;
ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
ps_mb_part_info = ps_dec->ps_parse_mb_data; // + u1_mb_idx;
ps_part = ps_dec->ps_parse_part_params; // + u1_mb_idx;
ps_dec->i4_submb_ofst -= (WORD32)(u4_num_mbs - u4_mb_idx) << 4;
ps_mb_part_info = ps_dec->ps_parse_mb_data; // + u4_mb_idx;
ps_part = ps_dec->ps_parse_part_params; // + u4_mb_idx;
/* N/2 Mb MvPred and Transfer Setup Loop */
for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
for(i = u4_mb_idx; i < u4_num_mbs; i++, ps_mb_part_info++)
{
UWORD32 u1_colz;
UWORD32 u1_field;
@ -110,7 +110,7 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
ps_dec->u2_mv_2mb[i & 0x1] = 0;
/* Look for MV Prediction and Reference Transfer in Non-I Mbs */
if(!ps_mb_part_info->u1_isI_mb)
if(!ps_mb_part_info->u4_isI_mb)
{
UWORD32 u1_blk_no;
WORD32 i1_ref_idx, i1_ref_idx1;
@ -124,7 +124,7 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
/* MB Level initialisations */
ps_dec->u4_num_pmbair = i >> u1_mbaff;
ps_dec->u1_mb_idx_mv = i;
ps_dec->u4_mb_idx_mv = i;
ppu4_wt_ofst = ps_mb_part_info->pu4_wt_offst;
pps_ref_frame = ps_dec->ps_ref_pic_buf_lx[0];
/* CHANGED CODE */
@ -330,11 +330,11 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
UWORD8 u1_mb_idx,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbs_next,
UWORD8 u1_tfr_n_mb,
UWORD8 u1_end_of_row)
UWORD32 u4_mb_idx,
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbs_next,
UWORD32 u4_tfr_n_mb,
UWORD32 u4_end_of_row)
{
WORD32 i,j;
UWORD32 u1_end_of_row_next;
@ -354,7 +354,7 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
/* N Mb MC Loop */
for(i = u1_mb_idx; i < u1_num_mbs; i++)
for(i = u4_mb_idx; i < u4_num_mbs; i++)
{
ps_cur_mb_info = ps_dec->ps_nmb_info + i;
ps_dec->u4_dma_buf_idx = 0;
@ -418,7 +418,7 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
/* N Mb IQ IT RECON Loop */
for(j = u1_mb_idx; j < i; j++)
for(j = u4_mb_idx; j < i; j++)
{
ps_cur_mb_info = ps_dec->ps_nmb_info + j;
@ -462,12 +462,12 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
u4_wd_uv = ps_dec->u2_frm_wd_uv << u1_field_pic_flag;
ps_cur_mb_info = ps_dec->ps_nmb_info + u1_mb_idx;
ps_cur_mb_info = ps_dec->ps_nmb_info + u4_mb_idx;
ps_dec->u4_deblk_mb_x = ps_cur_mb_info->u2_mbx;
ps_dec->u4_deblk_mb_y = ps_cur_mb_info->u2_mby;
for(j = u1_mb_idx; j < i; j++)
for(j = u4_mb_idx; j < i; j++)
{
ih264d_deblock_mb_nonmbaff(ps_dec, ps_tfr_cxt,
@ -483,15 +483,15 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
if(u1_tfr_n_mb)
if(u4_tfr_n_mb)
{
/****************************************************************/
/* Check for End Of Row in Next iteration */
/****************************************************************/
u1_end_of_row_next =
u1_num_mbs_next
&& (u1_num_mbs_next
<= (ps_dec->u1_recon_mb_grp
u4_num_mbs_next
&& (u4_num_mbs_next
<= (ps_dec->u4_recon_mb_grp
>> u1_mbaff));
/****************************************************************/
@ -502,9 +502,9 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
/* N-Mb MV Data ( To Ext MV Buffer ) */
/* N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers) */
/****************************************************************/
ih264d_transfer_mb_group_data(ps_dec, u1_num_mbs, u1_end_of_row,
ih264d_transfer_mb_group_data(ps_dec, u4_num_mbs, u4_end_of_row,
u1_end_of_row_next);
ps_dec->u4_num_mbs_prev_nmb = u1_num_mbs;
ps_dec->u4_num_mbs_prev_nmb = u4_num_mbs;
ps_dec->u4_pred_info_idx = 0;
ps_dec->u4_dma_buf_idx = 0;
@ -528,7 +528,7 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
*/
WORD32 ih264d_process_inter_mb(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num)
UWORD32 u4_mb_num)
{
/* CHANGED CODE */
UWORD8 *pu1_rec_y, *pu1_rec_u, *pu1_rec_v;
@ -547,7 +547,7 @@ WORD32 ih264d_process_inter_mb(dec_struct_t * ps_dec,
/* CHANGED CODE */
uc_botMb = 1 - ps_cur_mb_info->u1_topmb;
u4_num_pmbair = (u1_mb_num >> u1_mbaff);
u4_num_pmbair = (u4_mb_num >> u1_mbaff);
u1_mb_field_decoding_flag = ps_cur_mb_info->u1_mb_field_decodingflag;

16
decoder/ih264d_process_pslice.h
View file

@ -49,20 +49,20 @@ WORD32 parsePSliceData(dec_struct_t * ps_dec,
WORD32 ih264d_process_inter_mb(dec_struct_t * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num);
UWORD32 u4_mb_num);
void ih264d_init_ref_idx_lx_p(dec_struct_t *ps_dec);
WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbsNby2);
WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
UWORD8 u1_mb_idx,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbs_next,
UWORD8 u1_tfr_n_mb,
UWORD8 u1_end_of_row);
UWORD32 u4_mb_idx,
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbs_next,
UWORD32 u4_tfr_n_mb,
UWORD32 u4_end_of_row);
void ih264d_insert_pic_in_ref_pic_listx(struct pic_buffer_t *ps_ref_pic_buf_lx,
struct pic_buffer_t *ps_pic);

34
decoder/ih264d_structs.h
View file

@ -318,8 +318,8 @@ typedef struct
/* Following are derived from the above two */
UWORD16 u2_fld_ht_in_mbs; /** Field height expressed in MB units */
UWORD16 u2_max_mb_addr; /** Total number of macroblocks in a coded picture */
UWORD16 u2_total_num_of_mbs; /** Total number of macroblocks in a coded picture */
UWORD32 u4_max_mb_addr; /** Total number of macroblocks in a coded picture */
UWORD32 u4_total_num_of_mbs; /** Total number of macroblocks in a coded picture */
UWORD32 u4_fld_ht; /** field height */
UWORD32 u4_cwidth; /** chroma width */
UWORD32 u4_chr_frm_ht; /** chroma height */
@ -517,7 +517,7 @@ typedef struct
WORD32 (*pf_decodeDirect)(struct _DecStruct *ps_dec,
UWORD8 u1_wd_x,
dec_mb_info_t *ps_cur_mb_info,
UWORD8 u1_mb_num);
UWORD32 u4_mb_num);
UWORD8 u1_redundant_pic_cnt;
WORD8 i1_slice_qs_delta;
UWORD8 u1_nal_ref_idc; /** NAL ref idc of the Slice NAL unit */
@ -581,7 +581,7 @@ typedef struct
typedef struct
{
UWORD8 u1_isI_mb;
UWORD32 u4_isI_mb;
UWORD8 u1_num_part;
UWORD32 *pu4_wt_offst[MAX_REFIDX_INFO_PER_MB];
WORD8 i1_ref_idx[2][MAX_REFIDX_INFO_PER_MB];
@ -795,8 +795,8 @@ typedef struct _DecStruct
/************************************************************/
/* MB_GROUP should be a multiple of 2 */
/************************************************************/
UWORD8 u1_recon_mb_grp;
UWORD8 u1_recon_mb_grp_pair;
UWORD32 u4_recon_mb_grp;
UWORD32 u4_recon_mb_grp_pair;
/* Variables to handle Cabac */
decoding_envirnoment_t s_cab_dec_env; /* < Structure for decoding_envirnoment_t */
/* These things need to be updated at each MbLevel */
@ -988,11 +988,11 @@ typedef struct _DecStruct
/* Function pointers to read Params common to CAVLC and CABAC */
WORD32 (*pf_parse_inter_mb)(struct _DecStruct * ps_dec,
dec_mb_info_t * ps_cur_mb_info,
UWORD8 u1_mb_num,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_mb_num,
UWORD32 u4_num_mbsNby2);
WORD32 (*pf_mvpred_ref_tfr_nby2mb)(struct _DecStruct * ps_dec,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbsNby2);
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbsNby2);
WORD32 (*pf_parse_inter_slice)(struct _DecStruct * ps_dec,
dec_slice_params_t * ps_slice,
@ -1061,7 +1061,7 @@ typedef struct _DecStruct
/* Variables used for gaps in frame number */
UWORD16 u2_prev_ref_frame_num;
UWORD8 u1_mb_idx;
UWORD32 u4_mb_idx;
struct pic_buffer_t *ps_col_pic;
void (*pf_parse_mvdirect)(struct _DecStruct*,
struct pic_buffer_t*,
@ -1087,7 +1087,7 @@ typedef struct _DecStruct
mv_pred_t *ps_mv_pred,
mv_pred_t *ps_mv_nmb,
mv_pred_t *ps_mv_ntop,
UWORD8 u1_sub_mb_num,
UWORD32 u4_sub_mb_num,
UWORD8 uc_mb_part_width,
UWORD8 uc_lxstart,
UWORD8 uc_lxend,
@ -1113,12 +1113,12 @@ typedef struct _DecStruct
by declaring this after a pointer or an integer */
WORD8 pi1_left_pred_mode[8];
UWORD8 u1_mb_idx_mv;
UWORD32 u4_mb_idx_mv;
UWORD16 u2_mv_2mb[2];
UWORD32 u4_skip_frm_mask;
/* variable for finding the no.of mbs decoded in the current picture */
UWORD16 u2_total_mbs_coded;
UWORD32 u4_total_mbs_coded;
/* member added for supporting fragmented annex - B */
// frg_annex_read_t s_frag_annex_read;
/* added for vui_t, sei support*/
@ -1305,9 +1305,9 @@ typedef struct _DecStruct
ivd_get_display_frame_op_t s_disp_op;
UWORD32 u4_output_present;
volatile UWORD16 cur_dec_mb_num;
volatile UWORD16 cur_recon_mb_num;
volatile UWORD16 u2_cur_mb_addr;
volatile UWORD32 cur_dec_mb_num;
volatile UWORD32 cur_recon_mb_num;
volatile UWORD32 u4_cur_mb_addr;
WORD16 i2_dec_thread_mb_y;
WORD16 i2_recon_thread_mb_y;

30
decoder/ih264d_thread_compute_bs.c
View file

@ -385,7 +385,7 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
UWORD32 u4_mb_num;
UWORD16 u2_first_mb_in_slice;
UWORD32 i2_pic_wdin_mbs;
UWORD8 u1_num_mbsleft, u1_end_of_row;
UWORD32 u4_num_mbsleft, u4_end_of_row;
UWORD8 u1_mbaff;
UWORD16 i16_mb_x, i16_mb_y;
WORD32 j;
@ -445,7 +445,7 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
}
}
u4_max_addr = ps_dec->ps_cur_sps->u2_max_mb_addr;
u4_max_addr = ps_dec->ps_cur_sps->u4_max_mb_addr;
u1_mb_aff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
u2_first_mb_in_slice = ps_dec->ps_computebs_cur_slice->u4_first_mb_in_slice;
i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
@ -513,17 +513,17 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
{
WORD32 recon_mb_grp,bs_mb_grp;
WORD32 nop_cnt = 8*128;
u1_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u1_mbaff);
if(u1_num_mbsleft <= ps_dec->u1_recon_mb_grp)
u4_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u1_mbaff);
if(u4_num_mbsleft <= ps_dec->u4_recon_mb_grp)
{
recon_mb_grp = u1_num_mbsleft;
u1_end_of_row = 1;
recon_mb_grp = u4_num_mbsleft;
u4_end_of_row = 1;
i16_mb_x = 0;
}
else
{
recon_mb_grp = ps_dec->u1_recon_mb_grp;
u1_end_of_row = 0;
recon_mb_grp = ps_dec->u4_recon_mb_grp;
u4_end_of_row = 0;
i16_mb_x += (recon_mb_grp >> u1_mbaff);
}
@ -609,18 +609,18 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
if(j != recon_mb_grp)
{
u1_end_of_row = 0;
u4_end_of_row = 0;
}
{
tfr_ctxt_t *ps_trns_addr = &ps_dec->s_tran_iprecon;
UWORD16 u2_mb_y;
ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u1_end_of_row];
ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u1_end_of_row];
ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u1_end_of_row];
ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u4_end_of_row];
ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u4_end_of_row];
ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u4_end_of_row];
if(u1_end_of_row)
if(u4_end_of_row)
{
ps_dec->i2_recon_thread_mb_y += (1 << u1_mbaff);
u2_mb_y = ps_dec->i2_recon_thread_mb_y;
@ -665,7 +665,7 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
if(ps_dec->u4_cur_bs_mb_num > ps_dec->u4_cur_deblk_mb_num)
{
if(u1_end_of_row)
if(u4_end_of_row)
{
u4_num_mbs = ps_dec->u4_cur_bs_mb_num
- ps_dec->u4_cur_deblk_mb_num;
@ -724,7 +724,7 @@ void ih264d_recon_deblk_thread(dec_struct_t *ps_dec)
DEBUG_THREADS_PRINTF(" Exit compute bs slice \n");
if(ps_dec->cur_recon_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(ps_dec->cur_recon_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}

114
decoder/ih264d_thread_parse_decode.c
View file

@ -60,31 +60,31 @@ void ih264d_copy_intra_pred_line(dec_struct_t *ps_dec,
UWORD32 nmb_index);
void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec,
UWORD8 u1_mb_idx,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbs_next,
UWORD8 u1_tfr_n_mb,
UWORD8 u1_end_of_row)
UWORD32 u4_mb_idx,
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbs_next,
UWORD32 u4_tfr_n_mb,
UWORD32 u4_end_of_row)
{
WORD32 i, u4_mb_num;
const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
UWORD32 u4_n_mb_start;
UNUSED(u1_mb_idx);
UNUSED(u1_num_mbs_next);
if(u1_tfr_n_mb)
UNUSED(u4_mb_idx);
UNUSED(u4_num_mbs_next);
if(u4_tfr_n_mb)
{
u4_n_mb_start = (ps_dec->u2_cur_mb_addr + 1) - u1_num_mbs;
u4_n_mb_start = (ps_dec->u4_cur_mb_addr + 1) - u4_num_mbs;
// copy into s_frmMbInfo
u4_mb_num = u4_n_mb_start;
u4_mb_num = (ps_dec->u2_cur_mb_addr + 1) - u1_num_mbs;
u4_mb_num = (ps_dec->u4_cur_mb_addr + 1) - u4_num_mbs;
for(i = 0; i < u1_num_mbs; i++)
for(i = 0; i < u4_num_mbs; i++)
{
UPDATE_SLICE_NUM_MAP(ps_dec->pu2_slice_num_map, u4_mb_num,
ps_dec->u2_cur_slice_num);
@ -110,13 +110,13 @@ void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec,
/* Swap top and current pointers */
ps_dec->s_tran_addrecon_parse.pu1_dest_y +=
ps_dec->s_tran_addrecon_parse.u4_inc_y[u1_end_of_row];
ps_dec->s_tran_addrecon_parse.u4_inc_y[u4_end_of_row];
ps_dec->s_tran_addrecon_parse.pu1_dest_u +=
ps_dec->s_tran_addrecon_parse.u4_inc_uv[u1_end_of_row];
ps_dec->s_tran_addrecon_parse.u4_inc_uv[u4_end_of_row];
ps_dec->s_tran_addrecon_parse.pu1_dest_v +=
ps_dec->s_tran_addrecon_parse.u4_inc_uv[u1_end_of_row];
ps_dec->s_tran_addrecon_parse.u4_inc_uv[u4_end_of_row];
if(u1_end_of_row)
if(u4_end_of_row)
{
UWORD16 u2_mb_y;
UWORD32 u4_frame_stride, y_offset;
@ -141,7 +141,7 @@ void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec,
}
ps_dec->ps_deblk_mbn += u1_num_mbs;
ps_dec->ps_deblk_mbn += u4_num_mbs;
/*
* The Slice boundary is also a valid condition to transfer. So recalculate
@ -149,25 +149,25 @@ void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec,
* N MB value. c_numMbs will be equal to N of N MB if the entire N Mb is
* decoded.
*/
ps_dec->s_tran_addrecon.u2_mv_left_inc = ((u1_num_mbs >> u1_mbaff) - 1)
ps_dec->s_tran_addrecon.u2_mv_left_inc = ((u4_num_mbs >> u1_mbaff) - 1)
<< (4 + u1_mbaff);
ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (u1_num_mbs << 2) - 1
ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (u4_num_mbs << 2) - 1
- (u1_mbaff << 2);
/* reassign left MV and cur MV pointers */
ps_dec->ps_mv_left = ps_dec->ps_mv_cur
+ ps_dec->s_tran_addrecon.u2_mv_left_inc;
ps_dec->ps_mv_cur += (u1_num_mbs << 4);
ps_dec->u4_num_mbs_prev_nmb = u1_num_mbs;
ps_dec->ps_mv_cur += (u4_num_mbs << 4);
ps_dec->u4_num_mbs_prev_nmb = u4_num_mbs;
}
}
void ih264d_decode_tfr_nmb(dec_struct_t * ps_dec,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbs_next,
UWORD8 u1_end_of_row)
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbs_next,
UWORD32 u4_end_of_row)
{
UWORD32 u1_end_of_row_next;
@ -177,8 +177,8 @@ void ih264d_decode_tfr_nmb(dec_struct_t * ps_dec,
/****************************************************************/
/* Check for End Of Row in Next iteration */
/****************************************************************/
u1_end_of_row_next = u1_num_mbs_next &&
((u1_num_mbs_next) <= (ps_dec->u1_recon_mb_grp >> u1_mbaff));
u1_end_of_row_next = u4_num_mbs_next &&
((u4_num_mbs_next) <= (ps_dec->u4_recon_mb_grp >> u1_mbaff));
/****************************************************************/
/* Transfer the Following things */
@ -188,19 +188,19 @@ void ih264d_decode_tfr_nmb(dec_struct_t * ps_dec,
/* N-Mb MV Data ( To Ext MV Buffer ) */
/* N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers) */
/****************************************************************/
if(u1_end_of_row)
if(u4_end_of_row)
{
ps_dec->i2_dec_thread_mb_y += (1 << u1_mbaff);
}
ih264d_transfer_mb_group_data(ps_dec, u1_num_mbs, u1_end_of_row,
ih264d_transfer_mb_group_data(ps_dec, u4_num_mbs, u4_end_of_row,
u1_end_of_row_next);
}
WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbs_next,
UWORD8 u1_end_of_row)
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbs_next,
UWORD32 u4_end_of_row)
{
WORD32 i,j;
dec_mb_info_t * ps_cur_mb_info;
@ -231,7 +231,7 @@ WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
UWORD32 u4_max_mb = (UWORD32)(ps_dec->i2_dec_thread_mb_y + (1 << u1_mbaff)) * ps_dec->u2_frm_wd_in_mbs - 1;
u4_mb_num = u2_cur_dec_mb_num;
/*introducing 1 MB delay*/
u4_mb_num = MIN(u4_mb_num + u1_num_mbs + 1, u4_max_mb);
u4_mb_num = MIN(u4_mb_num + u4_num_mbs + 1, u4_max_mb);
CHECK_MB_MAP_BYTE(u4_mb_num, ps_dec->pu1_dec_mb_map, u4_cond);
if(u4_cond)
@ -268,7 +268,7 @@ WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
}
}
/* N Mb MC Loop */
for(i = 0; i < u1_num_mbs; i++)
for(i = 0; i < u4_num_mbs; i++)
{
u4_mb_num = u2_cur_dec_mb_num;
@ -420,26 +420,26 @@ WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
}
/*handle the last mb in picture case*/
if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
ps_dec->u4_cur_slice_decode_done = 1;
if(i != u1_num_mbs)
if(i != u4_num_mbs)
{
u1_end_of_row = 0;
u4_end_of_row = 0;
/*Number of MB's left in row*/
u1_num_mbs_next = u1_num_mbs_next + ((u1_num_mbs - i) >> u1_mbaff);
u4_num_mbs_next = u4_num_mbs_next + ((u4_num_mbs - i) >> u1_mbaff);
}
ih264d_decode_tfr_nmb(ps_dec, (i), u1_num_mbs_next, u1_end_of_row);
ih264d_decode_tfr_nmb(ps_dec, (i), u4_num_mbs_next, u4_end_of_row);
return OK;
}
WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec)
{
UWORD8 u1_num_mbs_next, u1_num_mbsleft, u1_end_of_row = 0;
UWORD32 u4_num_mbs_next, u4_num_mbsleft, u4_end_of_row = 0;
const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
UWORD8 u1_mbaff, u1_num_mbs;
UWORD32 u4_mbaff, u4_num_mbs;
UWORD16 u2_first_mb_in_slice;
UWORD16 i16_mb_x, i16_mb_y;
@ -484,25 +484,25 @@ WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec)
nop_cnt = 8*128;
ithread_yield();
}
DEBUG_THREADS_PRINTF("waiting for mb mapcur_dec_mb_num = %d,ps_dec->u2_cur_mb_addr = %d\n",u2_cur_dec_mb_num,
ps_dec->u2_cur_mb_addr);
DEBUG_THREADS_PRINTF("waiting for mb mapcur_dec_mb_num = %d,ps_dec->u4_cur_mb_addr = %d\n",u2_cur_dec_mb_num,
ps_dec->u4_cur_mb_addr);
}
}
u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
u4_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
u2_first_mb_in_slice = ps_dec->ps_decode_cur_slice->u4_first_mb_in_slice;
i16_mb_x = MOD(u2_first_mb_in_slice, i2_pic_wdin_mbs);
i16_mb_y = DIV(u2_first_mb_in_slice, i2_pic_wdin_mbs);
i16_mb_y <<= u1_mbaff;
i16_mb_y <<= u4_mbaff;
ps_dec->i2_dec_thread_mb_y = i16_mb_y;
ps_dec->cur_dec_mb_num = u2_first_mb_in_slice << u1_mbaff;
ps_dec->cur_dec_mb_num = u2_first_mb_in_slice << u4_mbaff;
if((ps_dec->u4_num_cores == 2) || !ps_dec->i1_recon_in_thread3_flag)
{
@ -560,30 +560,30 @@ WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec)
while(ps_dec->u4_cur_slice_decode_done != 1)
{
u1_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u1_mbaff);
u4_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u4_mbaff);
if(u1_num_mbsleft <= ps_dec->u1_recon_mb_grp)
if(u4_num_mbsleft <= ps_dec->u4_recon_mb_grp)
{
u1_num_mbs = u1_num_mbsleft;
u4_num_mbs = u4_num_mbsleft;
/*Indicate number of mb's left in a row*/
u1_num_mbs_next = 0;
u1_end_of_row = 1;
u4_num_mbs_next = 0;
u4_end_of_row = 1;
i16_mb_x = 0;
}
else
{
u1_num_mbs = ps_dec->u1_recon_mb_grp;
u4_num_mbs = ps_dec->u4_recon_mb_grp;
/*Indicate number of mb's left in a row*/
u1_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x
- (ps_dec->u1_recon_mb_grp >> u1_mbaff);
i16_mb_x += (u1_num_mbs >> u1_mbaff);
u1_end_of_row = 0;
u4_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x
- (ps_dec->u4_recon_mb_grp >> u4_mbaff);
i16_mb_x += (u4_num_mbs >> u4_mbaff);
u4_end_of_row = 0;
}
ret = ih264d_decode_recon_tfr_nmb_thread(ps_dec, u1_num_mbs, u1_num_mbs_next,
u1_end_of_row);
ret = ih264d_decode_recon_tfr_nmb_thread(ps_dec, u4_num_mbs, u4_num_mbs_next,
u4_end_of_row);
if(ret != OK)
return ret;
}
@ -625,7 +625,7 @@ void ih264d_decode_picture_thread(dec_struct_t *ps_dec )
if(ps_dec->cur_dec_mb_num
> ps_dec->ps_cur_sps->u2_max_mb_addr)
> ps_dec->ps_cur_sps->u4_max_mb_addr)
{
/*Last slice in frame*/
break;

22
decoder/ih264d_thread_parse_decode.h
View file

@ -27,19 +27,19 @@
#ifndef _IH264D_THREAD_PARSE_DECPDE_H_
#define _IH264D_THREAD_PARSE_DECPDE_H_
void ih264d_parse_tfr_nmb(dec_struct_t *ps_dec,
UWORD8 u1_mb_idx,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbs_next,
UWORD8 u1_tfr_n_mb,
UWORD8 u1_end_of_row);
UWORD32 u4_mb_idx,
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbs_next,
UWORD32 u4_tfr_n_mb,
UWORD32 u4_end_of_row);
void ih264d_decode_tfr_nmb(dec_struct_t *ps_dec,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbs_next,
UWORD8 u1_end_of_row);
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbs_next,
UWORD32 u4_end_of_row);
WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
UWORD8 u1_num_mbs,
UWORD8 u1_num_mbs_next,
UWORD8 u1_end_of_row);
UWORD32 u4_num_mbs,
UWORD32 u4_num_mbs_next,
UWORD32 u4_end_of_row);
void ih264d_decode_picture_thread(dec_struct_t *ps_dec);
WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec);

30
decoder/ih264d_utils.c
View file

@ -725,8 +725,8 @@ WORD32 ih264d_get_dpb_size(dec_seq_params_t *ps_seq)
}
/**************************************************************************/
/* This function initialises the value of ps_dec->u1_recon_mb_grp */
/* ps_dec->u1_recon_mb_grp must satisfy the following criteria */
/* This function initialises the value of ps_dec->u4_recon_mb_grp */
/* ps_dec->u4_recon_mb_grp must satisfy the following criteria */
/* - multiple of 2 (required for N/2 parse-mvpred design) */
/* - multiple of 4 (if it is not a frame_mbs_only sequence), */
/* in this case N/2 itself needs to be even for mbpair processing */
@ -738,16 +738,16 @@ WORD32 ih264d_init_dec_mb_grp(dec_struct_t *ps_dec)
dec_seq_params_t *ps_seq = ps_dec->ps_cur_sps;
UWORD8 u1_frm = ps_seq->u1_frame_mbs_only_flag;
ps_dec->u1_recon_mb_grp = ps_dec->u2_frm_wd_in_mbs << ps_seq->u1_mb_aff_flag;
ps_dec->u4_recon_mb_grp = ps_dec->u2_frm_wd_in_mbs << ps_seq->u1_mb_aff_flag;
ps_dec->u1_recon_mb_grp_pair = ps_dec->u1_recon_mb_grp >> 1;
ps_dec->u4_recon_mb_grp_pair = ps_dec->u4_recon_mb_grp >> 1;
if(!ps_dec->u1_recon_mb_grp)
if(!ps_dec->u4_recon_mb_grp)
{
return ERROR_MB_GROUP_ASSGN_T;
}
ps_dec->u4_num_mbs_prev_nmb = ps_dec->u1_recon_mb_grp;
ps_dec->u4_num_mbs_prev_nmb = ps_dec->u4_recon_mb_grp;
return OK;
}
@ -796,9 +796,9 @@ WORD32 ih264d_init_pic(dec_struct_t *ps_dec,
/*--------------------------------------------------------------------*/
/* 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
ps_seq->u4_max_mb_addr =
((UWORD32)ps_seq->u2_frm_wd_in_mbs
* ((UWORD32)ps_dec->u2_pic_ht
>> (4
+ ps_dec->ps_cur_slice->u1_field_pic_flag)))
- 1;
@ -1917,7 +1917,7 @@ WORD16 ih264d_allocate_dynamic_bufs(dec_struct_t * ps_dec)
UWORD16 u4_chroma_wd = ps_dec->u2_frm_wd_uv;
WORD8 c_i = 0;
dec_seq_params_t *ps_sps = ps_dec->ps_cur_sps;
UWORD32 u4_total_mbs = ps_sps->u2_total_num_of_mbs << uc_frmOrFld;
UWORD32 u4_total_mbs = ps_sps->u4_total_num_of_mbs << uc_frmOrFld;
UWORD32 u4_wd_mbs = ps_dec->u2_frm_wd_in_mbs;
UWORD32 u4_ht_mbs = ps_dec->u2_frm_ht_in_mbs;
UWORD32 u4_blk_wd;
@ -1958,14 +1958,14 @@ WORD16 ih264d_allocate_dynamic_bufs(dec_struct_t * ps_dec)
ps_dec->ps_pred_start = ps_dec->ps_pred;
size = sizeof(parse_pmbarams_t) * (ps_dec->u1_recon_mb_grp);
size = sizeof(parse_pmbarams_t) * (ps_dec->u4_recon_mb_grp);
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_dec->ps_parse_mb_data = pv_buf;
size = sizeof(parse_part_params_t)
* ((ps_dec->u1_recon_mb_grp) << 4);
* ((ps_dec->u4_recon_mb_grp) << 4);
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
memset(pv_buf, 0, size);
@ -1988,14 +1988,14 @@ WORD16 ih264d_allocate_dynamic_bufs(dec_struct_t * ps_dec)
for CABAC context representing MB not available */
ps_dec->p_ctxt_inc_mb_map += 1;
size = (sizeof(mv_pred_t) * ps_dec->u1_recon_mb_grp
size = (sizeof(mv_pred_t) * ps_dec->u4_recon_mb_grp
* 16);
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_dec->ps_mv_p[0] = pv_buf;
size = (sizeof(mv_pred_t) * ps_dec->u1_recon_mb_grp
size = (sizeof(mv_pred_t) * ps_dec->u4_recon_mb_grp
* 16);
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
@ -2007,7 +2007,7 @@ WORD16 ih264d_allocate_dynamic_bufs(dec_struct_t * ps_dec)
for(i = 0; i < MV_SCRATCH_BUFS; i++)
{
size = (sizeof(mv_pred_t)
* ps_dec->u1_recon_mb_grp * 4);
* ps_dec->u4_recon_mb_grp * 4);
pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
memset(pv_buf, 0, size);

6
decoder/mvc/imvcd_api.c
View file

@ -345,7 +345,7 @@ static IV_API_CALL_STATUS_T imvcd_view_ctxt_init(imvcd_create_ip_t *ps_ip,
ps_view_ctxt->u1_pr_sl_type = 0xFF;
ps_view_ctxt->u2_mbx = 0xffff;
ps_view_ctxt->u2_mby = 0;
ps_view_ctxt->u2_total_mbs_coded = 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;
@ -363,7 +363,7 @@ static IV_API_CALL_STATUS_T imvcd_view_ctxt_init(imvcd_create_ip_t *ps_ip,
ps_view_ctxt->i4_max_poc = 0;
ps_view_ctxt->i4_prev_max_display_seq = 0;
ps_view_ctxt->u1_recon_mb_grp = 4;
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;
@ -1042,7 +1042,7 @@ static IV_API_CALL_STATUS_T imvcd_finish_au_decode(mvc_dec_ctxt_t *ps_mvcd_ctxt,
ps_cur_au->i4_poc = 0;
ps_cur_au->i4_avg_poc = 0;
if(ps_view_ctxt->u2_total_mbs_coded == (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
if(ps_view_ctxt->u4_total_mbs_coded == (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1))
{
imvcd_reset_dpb(ps_dpb_mgr);
}

4
decoder/mvc/imvcd_api_utils.c
View file

@ -350,8 +350,8 @@ void imvcd_view_init(mvc_dec_ctxt_t *ps_mvcd_ctxt)
ps_view_ctxt->u4_num_fld_in_frm = 0;
ps_view_ctxt->u4_slice_start_code_found = 0;
ps_view_ctxt->u2_cur_mb_addr = 0;
ps_view_ctxt->u2_total_mbs_coded = 0;
ps_view_ctxt->u4_cur_mb_addr = 0;
ps_view_ctxt->u4_total_mbs_coded = 0;
ps_view_ctxt->u2_cur_slice_num = 0;
ps_view_ctxt->cur_dec_mb_num = 0;
ps_view_ctxt->cur_recon_mb_num = 0;

12
decoder/mvc/imvcd_error_handler.c
View file

@ -105,14 +105,14 @@ static IV_API_CALL_STATUS_T imvcd_check_sps_and_subset_sps(mvc_dec_ctxt_t *ps_mv
if(i4_max_mb_addr == INT32_MIN)
{
i4_max_mb_addr = ps_view_ctxt->ps_sps[i].u2_max_mb_addr;
i4_max_mb_addr = ps_view_ctxt->ps_sps[i].u4_max_mb_addr;
}
else if(i4_max_mb_addr != ps_view_ctxt->ps_sps[i].u2_max_mb_addr)
else if(i4_max_mb_addr != ps_view_ctxt->ps_sps[i].u4_max_mb_addr)
{
return IV_FAIL;
}
if(ps_view_ctxt->ps_sps[i].u2_max_mb_addr >
if(ps_view_ctxt->ps_sps[i].u4_max_mb_addr >
imvcd_get_num_mbs_in_level(ps_view_ctxt->ps_sps[i].u1_level_idc))
{
return IV_FAIL;
@ -148,14 +148,14 @@ static IV_API_CALL_STATUS_T imvcd_check_sps_and_subset_sps(mvc_dec_ctxt_t *ps_mv
if(i4_max_mb_addr == INT32_MIN)
{
i4_max_mb_addr = ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u2_max_mb_addr;
i4_max_mb_addr = ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u4_max_mb_addr;
}
else if(i4_max_mb_addr != ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u2_max_mb_addr)
else if(i4_max_mb_addr != ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u4_max_mb_addr)
{
return IV_FAIL;
}
if(ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u2_max_mb_addr >
if(ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u4_max_mb_addr >
imvcd_get_num_mbs_in_level(ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u1_level_idc))
{
return IV_FAIL;

4
decoder/mvc/imvcd_nalu_parser.c
View file

@ -281,10 +281,10 @@ static WORD32 imvcd_parse_subset_sps(mvc_dec_ctxt_t *ps_mvcd_ctxt, dec_bit_strea
return IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED;
}
ps_subset_sps->s_sps_data.u2_max_mb_addr =
ps_subset_sps->s_sps_data.u4_max_mb_addr =
ps_subset_sps->s_sps_data.u2_frm_wd_in_mbs * ps_subset_sps->s_sps_data.u2_frm_ht_in_mbs - 1;
ps_subset_sps->s_sps_data.u2_total_num_of_mbs = ps_subset_sps->s_sps_data.u2_max_mb_addr + 1;
ps_subset_sps->s_sps_data.u4_total_num_of_mbs = ps_subset_sps->s_sps_data.u4_max_mb_addr + 1;
ps_subset_sps->s_sps_data.u1_frame_mbs_only_flag = ih264d_get_bit_h264(ps_bitstrm);

70
decoder/mvc/imvcd_slice_functions.c
View file

@ -69,7 +69,7 @@ static WORD32 imvcd_set_first_mb_in_slice(dec_struct_t *ps_view_ctxt)
}
if(((ps_cur_slice->u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <=
ps_view_ctxt->u2_cur_mb_addr) &&
ps_view_ctxt->u4_cur_mb_addr) &&
(ps_view_ctxt->u4_first_slice_in_pic == 0))
{
return ERROR_CORRUPTED_SLICE;
@ -832,7 +832,7 @@ static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_p
ps_view_ctxt->i4_frametype = IV_NA_FRAME;
ps_view_ctxt->i4_content_type = IV_CONTENTTYPE_NA;
ps_sps->u2_max_mb_addr = ps_sps->u2_frm_wd_in_mbs * ps_sps->u2_frm_ht_in_mbs - 1;
ps_sps->u4_max_mb_addr = ps_sps->u2_frm_wd_in_mbs * ps_sps->u2_frm_ht_in_mbs - 1;
ps_view_ctxt->u2_frm_ht_in_mbs = ps_sps->u2_frm_ht_in_mbs;
if(!ps_view_ctxt->u1_init_dec_flag)
@ -957,7 +957,7 @@ static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_p
{
UWORD32 num_mbs;
num_mbs = ps_view_ctxt->ps_cur_sps->u2_total_num_of_mbs;
num_mbs = ps_view_ctxt->ps_cur_sps->u4_total_num_of_mbs;
if(ps_view_ctxt->pu1_dec_mb_map)
{
@ -1095,8 +1095,8 @@ static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_p
// Increment by 2 ,so that left mb (mbaff decrements by 2) will always be
// valid
ps_view_ctxt->ps_top_mb_row += 2;
ps_view_ctxt->u1_mb_idx = 0;
ps_view_ctxt->u2_total_mbs_coded = 0;
ps_view_ctxt->u4_mb_idx = 0;
ps_view_ctxt->u4_total_mbs_coded = 0;
ps_view_ctxt->i4_submb_ofst = -(SUB_BLK_SIZE);
ps_view_ctxt->i2_prev_slice_mbx = -1;
ps_view_ctxt->i2_prev_slice_mby = 0;
@ -1148,8 +1148,8 @@ static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_p
ps_mvcd_ctxt->ps_cur_au->i4_frame_num,
ps_sps->u1_gaps_in_frame_num_value_allowed_flag);
ps_view_ctxt->s_tran_addrecon.u2_mv_top_left_inc = (ps_view_ctxt->u1_recon_mb_grp << 2) - 1;
ps_view_ctxt->s_tran_addrecon.u2_mv_left_inc = (ps_view_ctxt->u1_recon_mb_grp - 1) << 4;
ps_view_ctxt->s_tran_addrecon.u2_mv_top_left_inc = (ps_view_ctxt->u4_recon_mb_grp << 2) - 1;
ps_view_ctxt->s_tran_addrecon.u2_mv_left_inc = (ps_view_ctxt->u4_recon_mb_grp - 1) << 4;
}
if((ps_sps->u1_profile_idc == HIGH_PROFILE_IDC) ||
@ -1242,9 +1242,9 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
nalu_mvc_ext_t *ps_cur_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);
UWORD32 u4_num_mbs = 0;
UWORD32 u4_mb_idx = ps_view_ctxt->u1_mb_idx;
UWORD32 u4_mb_idx = ps_view_ctxt->u4_mb_idx;
UWORD32 u4_remaining_mbs =
(ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1) - ps_view_ctxt->u2_total_mbs_coded;
(ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1) - ps_view_ctxt->u4_total_mbs_coded;
if(ps_view_ctxt->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
{
@ -1255,7 +1255,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
return OK;
}
if((ISLICE == ps_slice->u1_slice_type) || (0 == ps_view_ctxt->u2_total_mbs_coded))
if((ISLICE == ps_slice->u1_slice_type) || (0 == ps_view_ctxt->u4_total_mbs_coded))
{
yuv_buf_props_t *ps_view_buf =
&ps_mvcd_ctxt->ps_cur_au->as_view_buffers[ps_cur_nalu_mvc_ext->u2_view_id];
@ -1290,34 +1290,34 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
ps_view_ctxt->ps_dpb_cmds->u1_long_term_reference_flag = 0;
if(ps_view_ctxt->u2_total_mbs_coded > 0)
if(ps_view_ctxt->u4_total_mbs_coded > 0)
{
ps_view_ctxt->u2_total_mbs_coded -=
ps_view_ctxt->u2_total_mbs_coded % ps_view_ctxt->ps_cur_sps->u2_frm_wd_in_mbs;
ps_view_ctxt->u4_total_mbs_coded -=
ps_view_ctxt->u4_total_mbs_coded % ps_view_ctxt->ps_cur_sps->u2_frm_wd_in_mbs;
u4_remaining_mbs =
(ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1) - ps_view_ctxt->u2_total_mbs_coded;
(ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1) - ps_view_ctxt->u4_total_mbs_coded;
while(ps_view_ctxt->u4_dec_thread_created &&
(ps_view_ctxt->cur_dec_mb_num < ps_view_ctxt->u2_total_mbs_coded))
(ps_view_ctxt->cur_dec_mb_num < ps_view_ctxt->u4_total_mbs_coded))
{
NOP(1 << 10);
}
while(ps_view_ctxt->u4_bs_deblk_thread_created &&
(ps_view_ctxt->cur_recon_mb_num < ps_view_ctxt->u2_total_mbs_coded))
(ps_view_ctxt->cur_recon_mb_num < ps_view_ctxt->u4_total_mbs_coded))
{
NOP(1 << 10);
}
while(ps_view_ctxt->u4_bs_deblk_thread_created &&
(ps_view_ctxt->u4_cur_deblk_mb_num < ps_view_ctxt->u2_total_mbs_coded))
(ps_view_ctxt->u4_cur_deblk_mb_num < ps_view_ctxt->u4_total_mbs_coded))
{
NOP(1 << 10);
}
ps_view_ctxt->ps_nmb_info = ps_view_ctxt->ps_frm_mb_info + ps_view_ctxt->u2_total_mbs_coded;
ps_view_ctxt->ps_nmb_info = ps_view_ctxt->ps_frm_mb_info + ps_view_ctxt->u4_total_mbs_coded;
ps_view_ctxt->ps_deblk_mbn = ps_view_ctxt->ps_cur_deblk_mb =
ps_view_ctxt->ps_deblk_pic + ps_view_ctxt->u2_total_mbs_coded;
ps_view_ctxt->ps_deblk_pic + ps_view_ctxt->u4_total_mbs_coded;
}
u4_num_mbs = ps_view_ctxt->u4_num_mbs_cur_nmb = 0;
@ -1336,7 +1336,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
ps_view_ctxt->u1_mb_ngbr_availablity = ps_cur_mb_info->u1_mb_ngbr_availablity;
if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
if(ps_view_ctxt->u4_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1))
{
ps_view_ctxt->u1_pic_decode_done = 1;
@ -1350,8 +1350,8 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
(volatile void **) ps_view_ctxt->pv_map_ref_idx_to_poc_buf;
ps_slice->i1_slice_alpha_c0_offset = 0;
ps_slice->i1_slice_beta_offset = 0;
ps_slice->u2_first_mb_in_slice = ps_view_ctxt->u2_total_mbs_coded;
ps_view_ctxt->ps_parse_cur_slice->u4_first_mb_in_slice = ps_view_ctxt->u2_total_mbs_coded;
ps_slice->u2_first_mb_in_slice = ps_view_ctxt->u4_total_mbs_coded;
ps_view_ctxt->ps_parse_cur_slice->u4_first_mb_in_slice = ps_view_ctxt->u4_total_mbs_coded;
ps_view_ctxt->ps_parse_cur_slice->u2_log2Y_crwd = ps_slice->u2_log2Y_crwd;
if(ps_view_ctxt->u1_separate_parse)
@ -1375,28 +1375,28 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
ps_view_ctxt->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
ps_view_ctxt->ps_part = ps_view_ctxt->ps_parse_part_params;
ps_view_ctxt->u2_mbx =
MOD(ps_view_ctxt->u2_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
MOD((WORD32)ps_view_ctxt->u4_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
ps_view_ctxt->u2_mby =
DIV(ps_view_ctxt->u2_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
DIV((WORD32)ps_view_ctxt->u4_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
/******************************************************/
/* Parsing / decoding the slice */
/******************************************************/
ps_view_ctxt->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_view_ctxt, 0);
u4_mb_idx = ps_view_ctxt->u1_mb_idx;
u4_mb_idx = ps_view_ctxt->u4_mb_idx;
ps_parse_mb_data = ps_view_ctxt->ps_parse_mb_data;
u4_num_mbs = u4_mb_idx;
b_is_slice_end = false;
b_tfr_n_mb = false;
b_decode_nmb = false;
i2_cur_mb_addr = ps_view_ctxt->u2_total_mbs_coded;
i2_cur_mb_addr = ps_view_ctxt->u4_total_mbs_coded;
u4_mb_skip_run = u4_remaining_mbs;
while(!b_is_slice_end)
{
if(i2_cur_mb_addr > ps_view_ctxt->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_view_ctxt->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -1411,7 +1411,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
ps_cur_deblk_mb = ps_view_ctxt->ps_deblk_mbn + u4_num_mbs;
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
/**************************************************************/
/* Get the required information for decoding of MB */
@ -1464,7 +1464,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
b_is_slice_end = !u4_mb_skip_run;
ps_cur_mb_info->u1_end_of_slice = !u4_mb_skip_run;
b_tfr_n_mb =
(u4_num_mbs == ps_view_ctxt->u1_recon_mb_grp) || b_is_end_of_row || b_is_slice_end;
(u4_num_mbs == ps_view_ctxt->u4_recon_mb_grp) || b_is_end_of_row || b_is_slice_end;
b_decode_nmb = b_tfr_n_mb || b_is_slice_end;
if(b_decode_nmb)
@ -1487,7 +1487,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
b_tfr_n_mb, b_is_end_of_row);
}
ps_view_ctxt->u2_total_mbs_coded += u4_num_mbs;
ps_view_ctxt->u4_total_mbs_coded += u4_num_mbs;
if(b_tfr_n_mb)
{
@ -1495,7 +1495,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
}
u4_mb_idx = u4_num_mbs;
ps_view_ctxt->u1_mb_idx = u4_num_mbs;
ps_view_ctxt->u4_mb_idx = u4_num_mbs;
}
}
@ -1503,7 +1503,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
ps_view_ctxt->i2_prev_slice_mbx = ps_view_ctxt->u2_mbx;
ps_view_ctxt->i2_prev_slice_mby = ps_view_ctxt->u2_mby;
if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
if(ps_view_ctxt->u4_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1))
{
ps_view_ctxt->u1_pic_decode_done = 1;
}
@ -1909,7 +1909,7 @@ static WORD32 imvcd_finish_slice_decode(mvc_dec_ctxt_t *ps_mvcd_ctxt)
imvcd_dpb_reset_ivp_ctxt(ps_mvcd_ctxt->ps_dpb_mgr);
/* End of Picture detection */
if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
if(ps_view_ctxt->u4_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1))
{
ps_view_ctxt->u1_pic_decode_done = 1;
}
@ -2027,7 +2027,7 @@ WORD32 imvcd_parse_decode_slice(mvc_dec_ctxt_t *ps_mvcd_ctxt)
{
ps_view_ctxt->u2_mbx = 0xffff;
ps_view_ctxt->u2_mby = 0;
ps_view_ctxt->u2_total_mbs_coded = 0;
ps_view_ctxt->u4_total_mbs_coded = 0;
if(0 == u2_view_order_id)
{
@ -2287,7 +2287,7 @@ WORD32 imvcd_parse_decode_slice(mvc_dec_ctxt_t *ps_mvcd_ctxt)
ps_view_ctxt->i4_submb_ofst = -SUB_BLK_SIZE;
ps_view_ctxt->u2_cur_mb_addr = 0;
ps_view_ctxt->u4_cur_mb_addr = 0;
ps_view_ctxt->ps_deblk_mbn = ps_view_ctxt->ps_deblk_pic;
ps_view_ctxt->ps_mv_cur = ps_mvcd_ctxt->ps_cur_au->ps_au_mv_data->aps_mvs[u2_view_id];

12
decoder/mvc/imvcd_utils.c
View file

@ -686,7 +686,7 @@ WORD32 imvcd_allocate_dynamic_bufs(mvc_dec_ctxt_t *ps_mvcd_ctxt)
dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
dec_seq_params_t *ps_sps = ps_view_ctxt->ps_cur_sps;
UWORD32 u4_total_mbs = ps_sps->u2_total_num_of_mbs;
UWORD32 u4_total_mbs = ps_sps->u4_total_num_of_mbs;
UWORD32 u4_wd_mbs = ps_view_ctxt->u2_frm_wd_in_mbs;
UWORD32 u4_ht_mbs = ps_view_ctxt->u2_frm_ht_in_mbs;
const WORD32 i4_default_alignment = 128;
@ -726,13 +726,13 @@ WORD32 imvcd_allocate_dynamic_bufs(mvc_dec_ctxt_t *ps_mvcd_ctxt)
ps_view_ctxt->ps_computebs_cur_slice = ps_view_ctxt->ps_dec_slice_buf;
ps_view_ctxt->ps_pred_start = ps_view_ctxt->ps_pred;
i4_mem_size = sizeof(parse_pmbarams_t) * (ps_view_ctxt->u1_recon_mb_grp);
i4_mem_size = sizeof(parse_pmbarams_t) * (ps_view_ctxt->u4_recon_mb_grp);
pv_buf = ps_view_ctxt->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_parse_mb_data = pv_buf;
i4_mem_size = sizeof(parse_part_params_t) * ((ps_view_ctxt->u1_recon_mb_grp) << 4);
i4_mem_size = sizeof(parse_part_params_t) * ((ps_view_ctxt->u4_recon_mb_grp) << 4);
pv_buf = ps_view_ctxt->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);
@ -753,13 +753,13 @@ WORD32 imvcd_allocate_dynamic_bufs(mvc_dec_ctxt_t *ps_mvcd_ctxt)
for CABAC context representing MB not available */
ps_view_ctxt->p_ctxt_inc_mb_map += 1;
i4_mem_size = sizeof(mv_pred_t) * ps_view_ctxt->u1_recon_mb_grp * 16;
i4_mem_size = sizeof(mv_pred_t) * ps_view_ctxt->u4_recon_mb_grp * 16;
pv_buf = ps_view_ctxt->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_mv_p[0] = pv_buf;
i4_mem_size = sizeof(mv_pred_t) * ps_view_ctxt->u1_recon_mb_grp * 16;
i4_mem_size = sizeof(mv_pred_t) * ps_view_ctxt->u4_recon_mb_grp * 16;
pv_buf = ps_view_ctxt->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);
@ -767,7 +767,7 @@ WORD32 imvcd_allocate_dynamic_bufs(mvc_dec_ctxt_t *ps_mvcd_ctxt)
for(i = 0; i < MV_SCRATCH_BUFS; i++)
{
i4_mem_size = (sizeof(mv_pred_t) * ps_view_ctxt->u1_recon_mb_grp * 4);
i4_mem_size = (sizeof(mv_pred_t) * ps_view_ctxt->u4_recon_mb_grp * 4);
pv_buf = ps_view_ctxt->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);

16
decoder/svc/isvcd_api.c
View file

@ -1148,7 +1148,7 @@ void isvcd_init_decoder(svc_dec_lyr_struct_t *ps_dec_svc_lyr_params)
ps_dec->u1_pr_sl_type = 0xFF;
ps_dec->u2_mbx = 0xffff;
ps_dec->u2_mby = 0;
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_total_mbs_coded = 0;
/* POC initializations */
ps_prev_poc = &ps_dec->s_prev_pic_poc;
@ -1169,7 +1169,7 @@ void isvcd_init_decoder(svc_dec_lyr_struct_t *ps_dec_svc_lyr_params)
ps_dec->i4_max_poc = 0;
ps_dec->i4_prev_max_display_seq = 0;
ps_dec->u1_recon_mb_grp = 4;
ps_dec->u4_recon_mb_grp = 4;
ps_dec->i4_reorder_depth = -1;
/* Field PIC initializations */
@ -5222,8 +5222,8 @@ WORD32 isvcd_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
ps_dec->i4_content_type = IV_CONTENTTYPE_NA;
ps_dec->u4_slice_start_code_found = 0;
ps_dec->u2_cur_mb_addr = 0;
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_cur_mb_addr = 0;
ps_dec->u4_total_mbs_coded = 0;
ps_dec->u2_cur_slice_num = 0;
ps_dec->cur_dec_mb_num = 0;
ps_dec->cur_recon_mb_num = 0;
@ -5354,7 +5354,7 @@ WORD32 isvcd_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
ps_cur_node = ps_cur_node->ps_top_node;
if((ps_dec->u4_pic_buf_got == 1) && (ret != IVD_MEM_ALLOC_FAILED) &&
ps_dec->u2_total_mbs_coded < ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
ps_dec->u4_total_mbs_coded < ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
// last slice - missing/corruption
WORD32 num_mb_skipped;
@ -5364,14 +5364,14 @@ WORD32 isvcd_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
WORD32 ht_in_mbs;
ht_in_mbs = ps_dec->u2_pic_ht >> (4 + ps_dec->ps_cur_slice->u1_field_pic_flag);
num_mb_skipped =
(ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
(ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
if(ps_dec->u4_first_slice_in_pic && (ps_dec->u4_pic_buf_got == 0))
prev_slice_err = 1;
else
prev_slice_err = 2;
if(ps_dec->u2_total_mbs_coded == 0)
if(ps_dec->u4_total_mbs_coded == 0)
{
prev_slice_err = 1;
}
@ -5542,7 +5542,7 @@ WORD32 isvcd_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
/*set to complete ,as we dont support partial frame decode*/
if(ps_dec->i4_header_decoded == 3)
{
ps_dec->u2_total_mbs_coded = ps_dec->ps_cur_sps->u2_max_mb_addr + 1;
ps_dec->u4_total_mbs_coded = ps_dec->ps_cur_sps->u4_max_mb_addr + 1;
}
/*Update the i4_frametype at the end of picture*/

6
decoder/svc/isvcd_defs.h
View file

@ -49,9 +49,9 @@ typedef enum
#define FLUSH 2
#define SVCD_MAX_FRAME_WIDTH 4080
#define SVCD_MAX_FRAME_HEIGHT 4080
#define SVCD_MAX_FRAME_SIZE (4096 * 2048)
#define SVCD_MAX_FRAME_WIDTH 4096
#define SVCD_MAX_FRAME_HEIGHT 4096
#define SVCD_MAX_FRAME_SIZE (4096 * 4096)
#define SVCD_MIN_FRAME_WIDTH 32
#define SVCD_MIN_FRAME_HEIGHT 32

4
decoder/svc/isvcd_mb_utils.c
View file

@ -104,7 +104,7 @@ UWORD32 isvcd_get_mb_info_cabac_nonmbaff(dec_struct_t *ps_dec, const UWORD16 u2_
/*--------------------------------------------------------------------*/
mb_x = (WORD16) ps_dec->u2_mbx;
mb_y = (WORD16) ps_dec->u2_mby;
ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
mb_x++;
if((UWORD32) mb_x == u2_frm_width_in_mb)
@ -283,7 +283,7 @@ UWORD32 isvcd_get_mb_info_cavlc_nonmbaff(dec_struct_t *ps_dec, const UWORD16 u2_
mb_x = (WORD16) ps_dec->u2_mbx;
mb_y = (WORD16) ps_dec->u2_mby;
ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
mb_x++;

10
decoder/svc/isvcd_parse_ebslice.c
View file

@ -231,7 +231,7 @@ WORD32 isvcd_parse_bmb_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec, dec_mb_info_t
* 0 on Success and Error code otherwise
**************************************************************************
*/
WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, UWORD8 u1_num_mbs)
WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD32 u4_mb_idx, UWORD32 u4_num_mbs)
{
svc_dec_lyr_struct_t *ps_svc_lyr_dec = (svc_dec_lyr_struct_t *) ps_dec;
parse_pmbarams_t *ps_mb_part_info;
@ -247,12 +247,12 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
WORD32 ret = 0;
WORD16 i2_mv_x, i2_mv_y;
ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
ps_dec->i4_submb_ofst -= (u4_num_mbs - u4_mb_idx) << 4;
ps_mb_part_info = ps_dec->ps_parse_mb_data;
ps_part = ps_dec->ps_parse_part_params;
/* N/2 Mb MvPred and Transfer Setup Loop */
for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
for(i = u4_mb_idx; i < u4_num_mbs; i++, ps_mb_part_info++)
{
UWORD8 u1_colz = 0;
ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
@ -267,7 +267,7 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
ps_dec->u2_mv_2mb[i & 0x1] = 0;
/* Look for MV Prediction and Reference Transfer in Non-I Mbs */
if(!ps_mb_part_info->u1_isI_mb)
if(!ps_mb_part_info->u4_isI_mb)
{
UWORD8 u1_blk_no;
WORD16 i1_ref_idx, i1_ref_idx1;
@ -287,7 +287,7 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
/* MB Level initialisations */
ps_dec->u4_num_pmbair = i >> u1_mbaff;
ps_dec->u1_mb_idx_mv = i;
ps_dec->u4_mb_idx_mv = i;
i4_mb_mode_svc = isvcd_interlyr_motion_mode_pred(
ps_svc_lyr_dec, ps_cur_mb_info, ps_svc_cur_mb_info, ps_mb_part_info, ps_part);

40
decoder/svc/isvcd_parse_eislice.c
View file

@ -134,7 +134,7 @@ WORD32 isvcd_parse_islice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
ps_dec->i1_prev_mb_qp_delta = 0;
/* initializations */
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
uc_more_data_flag = 1;
i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
@ -143,7 +143,7 @@ WORD32 isvcd_parse_islice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
UWORD16 u2_mbx;
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -253,7 +253,7 @@ WORD32 isvcd_parse_islice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_tfr_n_mb =
(u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
(u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
if(u1_tfr_n_mb || (!uc_more_data_flag))
@ -279,10 +279,10 @@ WORD32 isvcd_parse_islice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_end_of_row);
}
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
} while(uc_more_data_flag);
@ -339,7 +339,7 @@ WORD32 isvcd_parse_islice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
/* initializations */
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
uc_more_data_flag = 1;
@ -348,7 +348,7 @@ WORD32 isvcd_parse_islice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
{
UWORD8 u1_mb_type;
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -460,7 +460,7 @@ WORD32 isvcd_parse_islice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_tfr_n_mb =
(u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
(u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
if(u1_tfr_n_mb || (!uc_more_data_flag))
@ -486,10 +486,10 @@ WORD32 isvcd_parse_islice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_end_of_row);
}
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
} while(uc_more_data_flag);
@ -1230,7 +1230,7 @@ WORD32 isvcd_parse_eislice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
ps_dec->i1_prev_mb_qp_delta = 0;
ps_cab_env = &ps_dec->s_cab_dec_env;
/* initializations */
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
uc_more_data_flag = 1;
i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
@ -1238,7 +1238,7 @@ WORD32 isvcd_parse_eislice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
{
UWORD16 u2_mbx;
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -1402,7 +1402,7 @@ WORD32 isvcd_parse_eislice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_tfr_n_mb =
(u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
(u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
if(u1_tfr_n_mb || (!uc_more_data_flag))
@ -1421,10 +1421,10 @@ WORD32 isvcd_parse_eislice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_end_of_row);
if(ret != OK) return ret;
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
} while(uc_more_data_flag);
@ -1482,7 +1482,7 @@ WORD32 isvcd_parse_eislice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
ih264d_update_qp(ps_dec, 0);
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
uc_more_data_flag = 1;
i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
@ -1491,7 +1491,7 @@ WORD32 isvcd_parse_eislice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
{
UWORD8 u1_mb_type;
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -1627,7 +1627,7 @@ WORD32 isvcd_parse_eislice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_tfr_n_mb =
(u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
(u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
if(u1_tfr_n_mb || (!uc_more_data_flag))
@ -1646,10 +1646,10 @@ WORD32 isvcd_parse_eislice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_end_of_row);
if(ret != OK) return ret;
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
} while(uc_more_data_flag);

94
decoder/svc/isvcd_parse_epslice.c
View file

@ -549,7 +549,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
i2_cur_mb_addr = u2_first_mb_in_slice;
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
u1_num_mbsNby2 = 0;
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
@ -575,7 +575,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -590,7 +590,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
/* Storing Default partition info */
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
/***************************************************************/
/* Get the required information for decoding of MB */
@ -671,7 +671,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
{
/* Storing Intra partition info */
ps_parse_mb_data->u1_num_part = 0;
ps_parse_mb_data->u1_isI_mb = 1;
ps_parse_mb_data->u4_isI_mb = 1;
if((25 + u1_mb_threshold) == u1_mb_type)
{
@ -737,7 +737,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_slice_end = !uc_more_data_flag;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@ -775,10 +775,10 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_end_of_row);
}
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
}
@ -864,7 +864,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
/******************************************************/
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
u1_num_mbsNby2 = 0;
@ -879,7 +879,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
UWORD8 u1_mb_type;
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -894,7 +894,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
/* Storing Default partition info */
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
if((!i2_mb_skip_run) && (!u1_read_mb_type))
{
@ -1019,7 +1019,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
{
/* Storing Intra partition info */
ps_parse_mb_data->u1_num_part = 0;
ps_parse_mb_data->u1_isI_mb = 1;
ps_parse_mb_data->u4_isI_mb = 1;
if((25 + u1_mb_threshold) == u1_mb_type)
{
@ -1073,7 +1073,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@ -1109,10 +1109,10 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_end_of_row);
}
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
}
@ -1203,7 +1203,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
i2_cur_mb_addr = u2_first_mb_in_slice;
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
u1_num_mbsNby2 = 0;
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
@ -1228,7 +1228,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
UWORD8 u1_mb_type;
UWORD32 u4_mb_skip;
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -1243,7 +1243,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
/* Storing Default partition info */
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
/***************************************************************/
/* Get the required information for decoding of MB */
@ -1424,7 +1424,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
{
/* Storing Intra partition info */
ps_parse_mb_data->u1_num_part = 0;
ps_parse_mb_data->u1_isI_mb = 1;
ps_parse_mb_data->u4_isI_mb = 1;
if((25 + u1_mb_threshold) == u1_mb_type)
{
@ -1451,7 +1451,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
}
}
ps_parse_mb_data->u1_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
ps_parse_mb_data->u4_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
}
}
@ -1495,7 +1495,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_slice_end = !uc_more_data_flag;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@ -1524,10 +1524,10 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
u1_end_of_row);
if(ret != OK) return ret;
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
}
@ -1621,7 +1621,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
/******************************************************/
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
u1_num_mbs = u1_mb_idx;
u1_num_mbsNby2 = 0;
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
@ -1636,7 +1636,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
break;
}
@ -1653,7 +1653,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
/* Storing Default partition info */
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
if((!i2_mb_skip_run) && (!u1_read_mb_type))
{
@ -1859,7 +1859,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
}
}
ps_parse_mb_data->u1_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
ps_parse_mb_data->u4_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
}
uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
}
@ -1894,7 +1894,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@ -1923,10 +1923,10 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
u1_end_of_row);
if(ret != OK) return ret;
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
}
@ -2656,7 +2656,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
WORD32 i2_cur_mb_addr;
UWORD32 u1_num_mbs;
UWORD32 u1_mb_idx = ps_dec->u1_mb_idx;
UWORD32 u1_mb_idx = ps_dec->u4_mb_idx;
UWORD32 i2_mb_skip_run;
UWORD32 u1_num_mbs_next, u1_end_of_row;
const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
@ -2804,7 +2804,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
{
ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
ps_dec->u2_cur_mb_addr--;
ps_dec->u4_cur_mb_addr--;
}
u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
@ -2832,7 +2832,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
{
// Going back 1 mb
ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
ps_dec->u2_cur_mb_addr--;
ps_dec->u4_cur_mb_addr--;
ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
// Parse/decode N-MB left unparsed
@ -2868,12 +2868,12 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
u1_tfr_n_mb, u1_end_of_row);
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u1_mb_idx = 0;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
ps_dec->u4_mb_idx = 0;
ps_dec->u4_num_mbs_cur_nmb = 0;
}
if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
if(ps_dec->u4_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
ps_dec->u1_pic_decode_done = 1;
return 0;
@ -2881,7 +2881,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
/* Inserting new slice only if the current slice has atleast 1 MB*/
if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
(UWORD32) (ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
(UWORD32) (ps_dec->u4_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
{
ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
@ -2920,14 +2920,14 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **) pu1_buf;
}
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u4_total_mbs_coded >> u1_mbaff;
ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
if(ps_dec->ps_cur_slice->u1_field_pic_flag)
ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u4_total_mbs_coded >> u1_mbaff;
ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
if(ps_dec->u1_separate_parse)
@ -2964,15 +2964,15 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mb_idx = ps_dec->u1_mb_idx;
u1_mb_idx = ps_dec->u4_mb_idx;
ps_parse_mb_data = ps_dec->ps_parse_mb_data;
u1_num_mbs = u1_mb_idx;
u1_slice_end = 0;
u1_tfr_n_mb = 0;
u1_decode_nmb = 0;
i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
i2_cur_mb_addr = ps_dec->u4_total_mbs_coded;
i2_mb_skip_run = num_mb_skip;
if(0 == ps_dec->u2_total_mbs_coded)
if(0 == ps_dec->u4_total_mbs_coded)
{
ps_dec->ps_cur_mb_row = ps_dec->ps_nbr_mb_row; //[0];
// Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid
@ -2996,7 +2996,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
}
while(!u1_slice_end)
{
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr) break;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr) break;
ps_svc_cur_mb_info = ps_svc_lyr_dec->ps_svc_nmb_info + u1_num_mbs;
ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
@ -3008,7 +3008,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
/* Storing Default partition info */
ps_parse_mb_data->u1_num_part = 1;
ps_parse_mb_data->u1_isI_mb = 0;
ps_parse_mb_data->u4_isI_mb = 0;
/**************************************************************/
/* Get the required information for decoding of MB */
@ -3100,7 +3100,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_slice_end = !i2_mb_skip_run;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@ -3136,10 +3136,10 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
u1_end_of_row);
}
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
ps_dec->u4_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb) u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
ps_dec->u4_mb_idx = u1_num_mbs;
}
}
@ -3159,7 +3159,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
if(ps_dec->u4_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
ps_dec->u1_pic_decode_done = 1;
}

12
decoder/svc/isvcd_parse_headers.c
View file

@ -418,11 +418,11 @@ WORD32 isvcd_parse_subset_sps(svc_dec_lyr_struct_t *ps_svc_lyr_dec, dec_bit_stre
/*--------------------------------------------------------------------*/
/* Get the value of MaxMbAddress and Number of bits needed for it */
/*--------------------------------------------------------------------*/
ps_seq->u2_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs * ps_seq->u2_frm_ht_in_mbs) - 1;
ps_seq->u4_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs * ps_seq->u2_frm_ht_in_mbs) - 1;
ps_seq->u2_total_num_of_mbs = ps_seq->u2_max_mb_addr + 1;
ps_seq->u4_total_num_of_mbs = ps_seq->u4_max_mb_addr + 1;
ps_seq->u1_level_idc = ih264d_correct_level_idc(u1_level_idc, ps_seq->u2_total_num_of_mbs);
ps_seq->u1_level_idc = ih264d_correct_level_idc(u1_level_idc, ps_seq->u4_total_num_of_mbs);
u1_frm = ih264d_get_bit_h264(ps_bitstrm);
@ -1379,9 +1379,9 @@ WORD32 isvcd_parse_sps(svc_dec_lyr_struct_t *ps_svc_lyr_dec, dec_bit_stream_t *p
/*--------------------------------------------------------------------*/
/* Get the value of MaxMbAddress and Number of bits needed for it */
/*--------------------------------------------------------------------*/
ps_seq->u2_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs * ps_seq->u2_frm_ht_in_mbs) - 1;
ps_seq->u2_total_num_of_mbs = ps_seq->u2_max_mb_addr + 1;
ps_seq->u1_level_idc = ih264d_correct_level_idc(u1_level_idc, ps_seq->u2_total_num_of_mbs);
ps_seq->u4_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs * ps_seq->u2_frm_ht_in_mbs) - 1;
ps_seq->u4_total_num_of_mbs = ps_seq->u4_max_mb_addr + 1;
ps_seq->u1_level_idc = ih264d_correct_level_idc(u1_level_idc, ps_seq->u4_total_num_of_mbs);
u1_frm = ih264d_get_bit_h264(ps_bitstrm);
if((ps_dec->i4_header_decoded & 1) &&

72
decoder/svc/isvcd_parse_slice.c
View file

@ -290,7 +290,7 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
if(ps_dec->u1_separate_parse)
{
UWORD32 num_mbs;
num_mbs = ps_dec->ps_cur_sps->u2_total_num_of_mbs
num_mbs = ps_dec->ps_cur_sps->u4_total_num_of_mbs
<< (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag);
if(ps_dec->pu1_dec_mb_map)
@ -472,9 +472,9 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0];
ps_dec->u1_mv_top_p = 0;
ps_dec->u1_mb_idx = 0;
ps_dec->u4_mb_idx = 0;
ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv;
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_total_mbs_coded = 0;
ps_dec->i4_submb_ofst = -(SUB_BLK_SIZE);
ps_dec->u4_pred_info_idx = 0;
ps_dec->u4_pred_info_pkd_idx = 0;
@ -548,11 +548,11 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
{
UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag;
UWORD8 u1_mbaff = ps_cur_slice->u1_mbaff_frame_flag;
UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4) % (ps_dec->u1_recon_mb_grp >> u1_mbaff));
UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4) % (ps_dec->u4_recon_mb_grp >> u1_mbaff));
UWORD16 ui16_lastmbs_widthY =
(uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u1_recon_mb_grp >> u1_mbaff) << 4));
(uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u4_recon_mb_grp >> u1_mbaff) << 4));
UWORD16 ui16_lastmbs_widthUV =
uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u1_recon_mb_grp >> u1_mbaff) << 3);
uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u4_recon_mb_grp >> u1_mbaff) << 3);
ps_dec->s_tran_addrecon.pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
ps_dec->s_tran_addrecon.pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
@ -568,8 +568,8 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
}
/* Normal Increment of Pointer */
ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u1_recon_mb_grp << 4) >> u1_mbaff);
ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u1_recon_mb_grp << 4) >> u1_mbaff);
ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u4_recon_mb_grp << 4) >> u1_mbaff);
ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u4_recon_mb_grp << 4) >> u1_mbaff);
/* End of Row Increment */
ps_dec->s_tran_addrecon.u4_inc_y[1] =
@ -583,8 +583,8 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
/* only once per picture. */
ih264d_assign_pic_num(ps_dec);
ps_dec->s_tran_addrecon.u2_mv_top_left_inc =
(ps_dec->u1_recon_mb_grp << 2) - 1 - (u1_mbaff << 2);
ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u1_recon_mb_grp >> u1_mbaff) - 1)
(ps_dec->u4_recon_mb_grp << 2) - 1 - (u1_mbaff << 2);
ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u4_recon_mb_grp >> u1_mbaff) - 1)
<< (4 + u1_mbaff);
}
/**********************************************************************/
@ -697,7 +697,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
}
/*we currently don not support ASO*/
if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u2_cur_mb_addr) &&
if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u4_cur_mb_addr) &&
(ps_dec->u4_first_slice_in_pic == 0))
{
return ERROR_CORRUPTED_SLICE;
@ -794,7 +794,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
ps_dec->u2_pic_wd = ps_subset_seq->u2_pic_wd;
ps_dec->u2_pic_ht = ps_subset_seq->u2_pic_ht;
ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
ps_dec->u4_total_mbs = ps_seq->u4_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
/* Determining the Width and Height of Frame from that of Picture */
ps_dec->u2_frm_wd_y = ps_subset_seq->u2_frm_wd_y;
@ -847,7 +847,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
}
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_total_mbs_coded = 0;
}
/* Get the field related flags */
if(!ps_seq->u1_frame_mbs_only_flag)
@ -983,7 +983,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
ps_cur_slice->u1_bottom_field_flag = 0;
num_mb_skipped =
(ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
(ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
ps_cur_poc = &ps_dec->s_cur_pic_poc;
u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
@ -1015,20 +1015,20 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
* conceal the current frame completely */
prev_slice_err = 2;
num_mb_skipped =
(ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
(ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
ps_cur_poc = &s_tmp_poc;
}
}
else
{
if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u4_total_mbs_coded)
{
// previous slice - missing/corruption
prev_slice_err = 2;
num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u2_total_mbs_coded;
num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u4_total_mbs_coded;
ps_cur_poc = &s_tmp_poc;
}
else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u4_total_mbs_coded)
{
return ERROR_CORRUPTED_SLICE;
}
@ -1052,7 +1052,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
return ERROR_INCOMPLETE_FRAME;
}
if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
if(ps_dec->u4_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
/* return if all MBs in frame are parsed*/
ps_dec->u1_first_slice_in_stream = 0;
@ -1129,7 +1129,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
/* Increment only if the current slice has atleast 1 more MB */
if(ps_dec->u4_first_slice_in_pic == 0 &&
(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
(UWORD32) (ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
(UWORD32) (ps_dec->u4_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
{
ps_dec->ps_parse_cur_slice++;
ps_dec->u2_cur_slice_num++;
@ -1405,7 +1405,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
}
ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
ps_dec->u4_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
ps_dec->ps_mv_cur =
ps_dec->s_cur_pic.ps_mv + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
@ -1427,7 +1427,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
u2_mb_x = 0xffff;
u2_mb_y = 0;
// assign the deblock structure pointers to start of slice
ps_dec->u2_cur_mb_addr = 0;
ps_dec->u4_cur_mb_addr = 0;
ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
@ -1548,7 +1548,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
/* End of Picture detection */
if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
if(ps_dec->u4_total_mbs_coded >= (ps_seq->u4_max_mb_addr + 1))
{
ps_dec->u1_pic_decode_done = 1;
}
@ -1947,7 +1947,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
}
/*we currently don not support ASO*/
if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u2_cur_mb_addr) &&
if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u4_cur_mb_addr) &&
(ps_dec->u4_first_slice_in_pic == 0))
{
return ERROR_CORRUPTED_SLICE;
@ -2045,7 +2045,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
ps_dec->u2_pic_wd = ps_subset_seq->u2_pic_wd;
ps_dec->u2_pic_ht = ps_subset_seq->u2_pic_ht;
ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
ps_dec->u4_total_mbs = ps_seq->u4_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
/* Determining the Width and Height of Frame from that of Picture */
ps_dec->u2_frm_wd_y = ps_subset_seq->u2_frm_wd_y;
@ -2097,7 +2097,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
}
ps_dec->u2_total_mbs_coded = 0;
ps_dec->u4_total_mbs_coded = 0;
}
/* Get the field related flags */
if(!ps_seq->u1_frame_mbs_only_flag)
@ -2232,7 +2232,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
ps_cur_slice->u1_bottom_field_flag = 0;
num_mb_skipped =
(ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
(ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
ps_cur_poc = &ps_dec->s_cur_pic_poc;
u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
@ -2264,20 +2264,20 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
* conceal the current frame completely */
prev_slice_err = 2;
num_mb_skipped =
(ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
(ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
ps_cur_poc = &s_tmp_poc;
}
}
else
{
if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u4_total_mbs_coded)
{
// previous slice - missing/corruption
prev_slice_err = 2;
num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u2_total_mbs_coded;
num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u4_total_mbs_coded;
ps_cur_poc = &s_tmp_poc;
}
else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u4_total_mbs_coded)
{
return ERROR_CORRUPTED_SLICE;
}
@ -2301,7 +2301,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
return ERROR_INCOMPLETE_FRAME;
}
if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
if(ps_dec->u4_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
{
/* return if all MBs in frame are parsed*/
ps_dec->u1_first_slice_in_stream = 0;
@ -2378,7 +2378,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
/* Increment only if the current slice has atleast 1 more MB */
if(ps_dec->u4_first_slice_in_pic == 0 &&
(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
(UWORD32) (ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
(UWORD32) (ps_dec->u4_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
{
ps_dec->ps_parse_cur_slice++;
ps_dec->u2_cur_slice_num++;
@ -2660,7 +2660,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
}
ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
ps_dec->u4_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
ps_dec->ps_mv_cur =
ps_dec->s_cur_pic.ps_mv + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
@ -2682,7 +2682,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
u2_mb_x = 0xffff;
u2_mb_y = 0;
// assign the deblock structure pointers to start of slice
ps_dec->u2_cur_mb_addr = 0;
ps_dec->u4_cur_mb_addr = 0;
ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
@ -2795,7 +2795,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
/* End of Picture detection */
if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
if(ps_dec->u4_total_mbs_coded >= (ps_seq->u4_max_mb_addr + 1))
{
ps_dec->u1_pic_decode_done = 1;
}

6
decoder/svc/isvcd_process_ebslice.h
View file

@ -46,8 +46,8 @@ WORD32 isvcd_parse_ebslice(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_firs
WORD32 isvcd_parse_bslice(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_first_mb_in_slice);
WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_svc_lyr_dec, UWORD8 u1_mb_idx,
UWORD8 u1_num_mbs);
WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_svc_lyr_dec, UWORD32 u4_mb_idx,
UWORD32 u4_num_mbs);
WORD32 isvcd_parse_bmb_non_direct_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
dec_mb_info_t *ps_cur_mb_info,
@ -60,5 +60,5 @@ WORD32 isvcd_parse_bmb_non_direct_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
UWORD8 u1_num_mbsNby2);
WORD32 isvcd_decode_spatial_direct(dec_struct_t *ps_svc_lyr_dec, UWORD8 u1_wd_x,
dec_mb_info_t *ps_cur_mb_info, UWORD8 u1_mb_num);
dec_mb_info_t *ps_cur_mb_info, UWORD32 u4_mb_num);
#endif /* _ISVCD_PROCESS_EBSLICE_H_ */

18
decoder/svc/isvcd_process_epslice.c
View file

@ -178,7 +178,7 @@ WORD32 isvcd_interlyr_motion_mode_pred(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
* 0 on Success and Error code otherwise
**************************************************************************
*/
WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, UWORD8 u1_num_mbs)
WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD32 u4_mb_idx, UWORD32 u4_num_mbs)
{
svc_dec_lyr_struct_t *ps_svc_lyr_dec = (svc_dec_lyr_struct_t *) ps_dec;
parse_pmbarams_t *ps_mb_part_info;
@ -190,12 +190,12 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
dec_svc_mb_info_t *ps_svc_cur_mb_info;
WORD32 i2_mv_x, i2_mv_y;
ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
ps_dec->i4_submb_ofst -= (u4_num_mbs - u4_mb_idx) << 4;
ps_mb_part_info = ps_dec->ps_parse_mb_data;
ps_part = ps_dec->ps_parse_part_params;
/* N/2 Mb MvPred and Transfer Setup Loop */
for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
for(i = u4_mb_idx; i < u4_num_mbs; i++, ps_mb_part_info++)
{
UWORD32 u1_colz;
UWORD32 u1_field;
@ -217,7 +217,7 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
ps_dec->u2_mv_2mb[i & 0x1] = 0;
/* Look for MV Prediction and Reference Transfer in Non-I Mbs */
if(!ps_mb_part_info->u1_isI_mb)
if(!ps_mb_part_info->u4_isI_mb)
{
UWORD32 u1_blk_no;
WORD32 i1_ref_idx, i1_ref_idx1;
@ -233,7 +233,7 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
/* MB Level initialisations */
ps_dec->u4_num_pmbair = i >> u1_mbaff;
ps_dec->u1_mb_idx_mv = i;
ps_dec->u4_mb_idx_mv = i;
ppu4_wt_ofst = ps_mb_part_info->pu4_wt_offst;
pps_ref_frame = ps_dec->ps_ref_pic_buf_lx[0];
@ -1415,7 +1415,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_non_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_
for(j = u1_mb_idx; j < i; j++)
{
if(ps_dec->u4_cur_deblk_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(ps_dec->u4_cur_deblk_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
return NOT_OK;
}
@ -1430,7 +1430,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_non_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_
/* Check for End Of Row in Next iteration */
/****************************************************************/
u1_end_of_row_next =
u1_num_mbs_next && (u1_num_mbs_next <= (ps_dec->u1_recon_mb_grp >> u1_mbaff));
u1_num_mbs_next && (u1_num_mbs_next <= (ps_dec->u4_recon_mb_grp >> u1_mbaff));
/****************************************************************/
/* Transfer the Following things */
@ -1600,7 +1600,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
}
}
if(ps_dec->u4_cur_deblk_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(ps_dec->u4_cur_deblk_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
return NOT_OK;
}
@ -1616,7 +1616,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
/* Check for End Of Row in Next iteration */
/****************************************************************/
u1_end_of_row_next =
u1_num_mbs_next && (u1_num_mbs_next <= (ps_dec->u1_recon_mb_grp >> u1_mbaff));
u1_num_mbs_next && (u1_num_mbs_next <= (ps_dec->u4_recon_mb_grp >> u1_mbaff));
/****************************************************************/
/* Transfer the Following things */

4
decoder/svc/isvcd_process_epslice.h
View file

@ -71,8 +71,8 @@ WORD32 isvcd_process_inter_mb_rsd_pred_target_lyr(svc_dec_lyr_struct_t *ps_svc_l
UWORD8 u1_inference_mode,
UWORD16 *pu2_res_luma_csbp);
WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_num_mbs,
UWORD8 u1_num_mbsNby2);
WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD32 u4_num_mbs,
UWORD32 u4_num_mbsNby2);
WORD32 isvcd_decode_recon_tfr_nmb_non_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
UWORD8 u1_mb_idx, UWORD8 u1_num_mbs,

10
decoder/svc/isvcd_thread_parse_decode.c
View file

@ -344,7 +344,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_thread(svc_dec_lyr_struct_t *ps_svc_lyr_dec, U
}
/*handle the last mb in picture case*/
if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
ps_dec->u4_cur_slice_decode_done = 1;
if(i != u1_num_mbs)
@ -496,7 +496,7 @@ WORD32 isvcd_decode_slice_thread(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
{
u1_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u1_mbaff);
if(u1_num_mbsleft <= ps_dec->u1_recon_mb_grp)
if(u1_num_mbsleft <= ps_dec->u4_recon_mb_grp)
{
u1_num_mbs = u1_num_mbsleft;
@ -507,10 +507,10 @@ WORD32 isvcd_decode_slice_thread(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
}
else
{
u1_num_mbs = ps_dec->u1_recon_mb_grp;
u1_num_mbs = ps_dec->u4_recon_mb_grp;
/*Indicate number of mb's left in a row*/
u1_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x - (ps_dec->u1_recon_mb_grp >> u1_mbaff);
u1_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x - (ps_dec->u4_recon_mb_grp >> u1_mbaff);
i16_mb_x += (u1_num_mbs >> u1_mbaff);
u1_end_of_row = 0;
}
@ -572,7 +572,7 @@ void isvcd_decode_picture_thread(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
if(OK != ret) break;
DEBUG_THREADS_PRINTF(" Exit isvcd_decode_slice_thread\n");
if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
{
/*Last slice in frame*/
break;

4
decoder/svc/isvcd_utils.c
View file

@ -117,7 +117,7 @@ WORD16 isvcd_allocate_dynamic_bufs(svc_dec_lyr_struct_t *ps_svc_lyr_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;
UWORD32 u4_total_mbs = ps_sps->u4_total_num_of_mbs << uc_frmOrFld;
WORD32 size;
void *pv_buf;
void *pv_mem_ctxt = ps_dec->pv_mem_ctxt;
@ -773,7 +773,7 @@ WORD32 isvcd_init_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_frame_num
/*--------------------------------------------------------------------*/
/* Get the value of MaxMbAddress and frmheight in Mbs */
/*--------------------------------------------------------------------*/
ps_seq->u2_max_mb_addr =
ps_seq->u4_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;