Home | History | Annotate | Download | only in decoder
      1 /******************************************************************************
      2  *
      3  * Copyright (C) 2015 The Android Open Source Project
      4  *
      5  * Licensed under the Apache License, Version 2.0 (the "License");
      6  * you may not use this file except in compliance with the License.
      7  * You may obtain a copy of the License at:
      8  *
      9  * http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  *
     17  *****************************************************************************
     18  * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
     19 */
     20 
     21 /*!
     22  **************************************************************************
     23  * \file ih264d_parse_pslice.c
     24  *
     25  * \brief
     26  *    Contains routines that decode a I slice type
     27  *
     28  * Detailed_description
     29  *
     30  * \date
     31  *    07/07/2003
     32  *
     33  * \author  NS
     34  **************************************************************************
     35  */
     36 
     37 #include <string.h>
     38 #include "ih264d_bitstrm.h"
     39 #include "ih264d_defs.h"
     40 #include "ih264d_debug.h"
     41 #include "ih264d_tables.h"
     42 #include "ih264d_structs.h"
     43 #include "ih264d_defs.h"
     44 #include "ih264d_parse_cavlc.h"
     45 #include "ih264d_mb_utils.h"
     46 #include "ih264d_parse_slice.h"
     47 #include "ih264d_mvpred.h"
     48 #include "ih264d_parse_islice.h"
     49 #include "ih264d_process_intra_mb.h"
     50 #include "ih264d_inter_pred.h"
     51 #include "ih264d_process_pslice.h"
     52 #include "ih264d_deblocking.h"
     53 #include "ih264d_cabac.h"
     54 #include "ih264d_parse_mb_header.h"
     55 #include "ih264d_error_handler.h"
     56 #include "ih264d_defs.h"
     57 #include "ih264d_format_conv.h"
     58 #include "ih264d_quant_scaling.h"
     59 #include "ih264d_thread_parse_decode.h"
     60 #include "ih264d_thread_compute_bs.h"
     61 #include "ih264d_process_bslice.h"
     62 #include "ithread.h"
     63 #include "ih264d_utils.h"
     64 #include "ih264d_format_conv.h"
     65 
     66 void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
     67 void ih264d_deblock_mb_level(dec_struct_t *ps_dec,
     68                              dec_mb_info_t *ps_cur_mb_info,
     69                              UWORD32 nmb_index);
     70 
     71 /*!
     72  **************************************************************************
     73  * \if Function name : ih264d_parse_pmb_cavlc \endif
     74  *
     75  * \brief
     76  *    This function parses CAVLC syntax of a P MB.
     77  *
     78  * \return
     79  *    0 on Success and Error code otherwise
     80  **************************************************************************
     81  */
     82 WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
     83                               dec_mb_info_t * ps_cur_mb_info,
     84                               UWORD8 u1_mb_num,
     85                               UWORD8 u1_num_mbsNby2)
     86 {
     87     UWORD32 u1_num_mb_part;
     88     UWORD32 uc_sub_mb;
     89     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
     90     UWORD32 * const pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
     91     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
     92 
     93     parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
     94                     + u1_num_mbsNby2;
     95     WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
     96     const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     97     const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part;
     98     UWORD8 * pu1_col_info = ps_parse_mb_data->u1_col_info;
     99 
    100     UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type;
    101     UWORD32 u4_sum_mb_mode_pack = 0;
    102     WORD32 ret;
    103 
    104     UWORD8 u1_no_submb_part_size_lt8x8_flag = 1;
    105     ps_cur_mb_info->u1_tran_form8x8 = 0;
    106     ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
    107 
    108     ps_cur_mb_info->u1_yuv_dc_block_flag = 0;
    109 
    110     ps_cur_mb_info->u1_mb_mc_mode = u1_mb_type;
    111     uc_sub_mb = ((u1_mb_type == PRED_8x8) | (u1_mb_type == PRED_8x8R0));
    112 
    113     /* Reading the subMB type */
    114     if(uc_sub_mb)
    115     {
    116         WORD32 i;
    117         UWORD8 u1_colz = (PRED_8x8 << 6);
    118 
    119         for(i = 0; i < 4; i++)
    120         {
    121             UWORD32 ui_sub_mb_mode;
    122 
    123             //Inlined ih264d_uev
    124             UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
    125             UWORD32 u4_word, u4_ldz;
    126 
    127             /***************************************************************/
    128             /* Find leading zeros in next 32 bits                          */
    129             /***************************************************************/
    130             NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
    131             u4_ldz = CLZ(u4_word);
    132             /* Flush the ps_bitstrm */
    133             u4_bitstream_offset += (u4_ldz + 1);
    134             /* Read the suffix from the ps_bitstrm */
    135             u4_word = 0;
    136             if(u4_ldz)
    137                 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
    138                         u4_ldz);
    139             *pu4_bitstrm_ofst = u4_bitstream_offset;
    140             ui_sub_mb_mode = ((1 << u4_ldz) + u4_word - 1);
    141             //Inlined ih264d_uev
    142 
    143             if(ui_sub_mb_mode > 3)
    144             {
    145                 return ERROR_SUB_MB_TYPE;
    146             }
    147             else
    148             {
    149                 u4_sum_mb_mode_pack = (u4_sum_mb_mode_pack << 8) | ui_sub_mb_mode;
    150                 /* Storing collocated information */
    151                 *pu1_col_info++ = u1_colz | (UWORD8)(ui_sub_mb_mode << 4);
    152 
    153                 COPYTHECONTEXT("sub_mb_type", ui_sub_mb_mode);
    154             }
    155 
    156             /* check if Motion compensation is done below 8x8 */
    157             if(ui_sub_mb_mode != P_L0_8x8)
    158             {
    159                 u1_no_submb_part_size_lt8x8_flag = 0;
    160             }
    161         }
    162 
    163         //
    164         u1_num_mb_part = 4;
    165     }
    166     else
    167     {
    168         *pu1_col_info++ = (u1_mb_type << 6);
    169         if(u1_mb_type)
    170             *pu1_col_info++ = (u1_mb_type << 6);
    171         u1_num_mb_part = pu1_num_mb_part[u1_mb_type];
    172 
    173     }
    174 
    175     /* Decoding reference index 0: For simple profile the following   */
    176     /* conditions are always true (mb_field_decoding_flag == 0);      */
    177     /* (MbPartPredMode != PredL1)                                     */
    178 
    179     {
    180 
    181         UWORD8 uc_field = ps_cur_mb_info->u1_mb_field_decodingflag;
    182         UWORD8 uc_num_ref_idx_l0_active_minus1 =
    183                         (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0]
    184                                         << (u1_mbaff & uc_field)) - 1;
    185 
    186         if((uc_num_ref_idx_l0_active_minus1 > 0) & (u1_mb_type != PRED_8x8R0))
    187         {
    188             if(1 == uc_num_ref_idx_l0_active_minus1)
    189                 ih264d_parse_pmb_ref_index_cavlc_range1(
    190                                 u1_num_mb_part, ps_bitstrm, pi1_ref_idx,
    191                                 uc_num_ref_idx_l0_active_minus1);
    192             else
    193             {
    194                 ret = ih264d_parse_pmb_ref_index_cavlc(
    195                                 u1_num_mb_part, ps_bitstrm, pi1_ref_idx,
    196                                 uc_num_ref_idx_l0_active_minus1);
    197                 if(ret != OK)
    198                     return ret;
    199             }
    200         }
    201         else
    202         {
    203             /* When there exists only a single frame to predict from */
    204             UWORD8 uc_i;
    205             for(uc_i = 0; uc_i < u1_num_mb_part; uc_i++)
    206                 /* Storing Reference Idx Information */
    207                 pi1_ref_idx[uc_i] = 0;
    208         }
    209     }
    210 
    211     {
    212         UWORD8 u1_p_idx, uc_i;
    213         parse_part_params_t * ps_part = ps_dec->ps_part;
    214         UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
    215         UWORD8 u1_sub_mb_num;
    216         const UWORD8 * pu1_top_left_sub_mb_indx;
    217         mv_pred_t * ps_mv, *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
    218         /* Loading the table pointers */
    219         const UWORD8 * pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
    220         const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
    221         const UWORD8 * pu1_sub_mb_indx_mod =
    222                         (const UWORD8 *)(gau1_ih264d_submb_indx_mod)
    223                                         + (uc_sub_mb * 6);
    224         const UWORD8 * pu1_sub_mb_partw = (const UWORD8 *)gau1_ih264d_submb_partw;
    225         const UWORD8 * pu1_sub_mb_parth = (const UWORD8 *)gau1_ih264d_submb_parth;
    226         const UWORD8 * pu1_num_sub_mb_part =
    227                         (const UWORD8 *)gau1_ih264d_num_submb_part;
    228 
    229         UWORD16 u2_sub_mb_num = 0x028A;
    230 
    231         /*********************************************************/
    232         /* default initialisations for condition (uc_sub_mb == 0) */
    233         /* i.e. all are subpartitions of 8x8                     */
    234         /*********************************************************/
    235         u1_sub_mb_mode = 0;
    236         u1_num_subpart = 1;
    237         u1_mb_part_width = pu1_mb_partw[u1_mb_type];
    238         u1_mb_part_height = pu1_mb_parth[u1_mb_type];
    239         pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
    240         u1_sub_mb_num = 0;
    241 
    242         /* Loop on number of partitions */
    243         for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
    244         {
    245             UWORD8 uc_j;
    246             if(uc_sub_mb)
    247             {
    248                 u1_sub_mb_mode = u4_sum_mb_mode_pack >> 24;
    249                 u1_num_subpart = pu1_num_sub_mb_part[u1_sub_mb_mode];
    250                 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
    251                 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
    252                 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
    253                 u1_sub_mb_num = u2_sub_mb_num >> 12;
    254                 u4_sum_mb_mode_pack <<= 8;
    255                 u2_sub_mb_num <<= 4;
    256             }
    257 
    258             /* Loop on Number of sub-partitions */
    259             for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++)
    260             {
    261                 WORD16 i2_mvx, i2_mvy;
    262                 u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
    263                 ps_mv = ps_mv_start + u1_sub_mb_num;
    264 
    265                 /* Reading the differential Mv from the bitstream */
    266                 //i2_mvx = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
    267                 //inlining ih264d_sev
    268                 {
    269                     UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
    270                     UWORD32 u4_word, u4_ldz, u4_abs_val;
    271 
    272                     /***************************************************************/
    273                     /* Find leading zeros in next 32 bits                          */
    274                     /***************************************************************/
    275                     NEXTBITS_32(u4_word, u4_bitstream_offset,
    276                                 pu4_bitstrm_buf);
    277                     u4_ldz = CLZ(u4_word);
    278 
    279                     /* Flush the ps_bitstrm */
    280                     u4_bitstream_offset += (u4_ldz + 1);
    281 
    282                     /* Read the suffix from the ps_bitstrm */
    283                     u4_word = 0;
    284                     if(u4_ldz)
    285                         GETBITS(u4_word, u4_bitstream_offset,
    286                                 pu4_bitstrm_buf, u4_ldz);
    287 
    288                     *pu4_bitstrm_ofst = u4_bitstream_offset;
    289                     u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1;
    290 
    291                     if(u4_word & 0x1)
    292                         i2_mvx = (-(WORD32)u4_abs_val);
    293                     else
    294                         i2_mvx = (u4_abs_val);
    295                 }
    296                 //inlinined ih264d_sev
    297                 COPYTHECONTEXT("MVD", i2_mvx);
    298                 i2_mvy = ih264d_sev(pu4_bitstrm_ofst,
    299                                      pu4_bitstrm_buf);
    300                 COPYTHECONTEXT("MVD", i2_mvy);
    301 
    302                 /* Storing Info for partitions */
    303                 ps_part->u1_is_direct = PART_NOT_DIRECT;
    304                 ps_part->u1_sub_mb_num = u1_sub_mb_num;
    305                 ps_part->u1_partheight = u1_mb_part_height;
    306                 ps_part->u1_partwidth = u1_mb_part_width;
    307 
    308                 /* Storing Mv residuals */
    309                 ps_mv->i2_mv[0] = i2_mvx;
    310                 ps_mv->i2_mv[1] = i2_mvy;
    311 
    312                 /* Increment partition Index */
    313                 u1_p_idx++;
    314                 ps_part++;
    315             }
    316         }
    317         ps_parse_mb_data->u1_num_part = u1_p_idx;
    318         ps_dec->ps_part = ps_part;
    319     }
    320 
    321     {
    322         UWORD32 u4_cbp;
    323 
    324         /* Read the Coded block pattern */
    325         UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
    326         UWORD32 u4_word, u4_ldz;
    327 
    328         /***************************************************************/
    329         /* Find leading zeros in next 32 bits                          */
    330         /***************************************************************/
    331         NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
    332         u4_ldz = CLZ(u4_word);
    333         /* Flush the ps_bitstrm */
    334         u4_bitstream_offset += (u4_ldz + 1);
    335         /* Read the suffix from the ps_bitstrm */
    336         u4_word = 0;
    337         if(u4_ldz)
    338             GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
    339         *pu4_bitstrm_ofst = u4_bitstream_offset;
    340         u4_cbp = ((1 << u4_ldz) + u4_word - 1);
    341 
    342         if(u4_cbp > 47)
    343             return ERROR_CBP;
    344 
    345         u4_cbp = *((UWORD8*)gau1_ih264d_cbp_inter + u4_cbp);
    346         COPYTHECONTEXT("coded_block_pattern", u4_cbp);
    347         ps_cur_mb_info->u1_cbp = u4_cbp;
    348 
    349         /* Read the transform8x8 u4_flag if present */
    350         if((ps_dec->s_high_profile.u1_transform8x8_present) && (u4_cbp & 0xf)
    351                         && u1_no_submb_part_size_lt8x8_flag)
    352         {
    353             ps_cur_mb_info->u1_tran_form8x8 = ih264d_get_bit_h264(ps_bitstrm);
    354             COPYTHECONTEXT("transform_size_8x8_flag", ps_cur_mb_info->u1_tran_form8x8);
    355             ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = ps_cur_mb_info->u1_tran_form8x8;
    356         }
    357 
    358         /* Read mb_qp_delta */
    359         if(u4_cbp)
    360         {
    361             WORD32 i_temp;
    362 
    363             UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
    364             UWORD32 u4_word, u4_ldz, u4_abs_val;
    365 
    366             /***************************************************************/
    367             /* Find leading zeros in next 32 bits                          */
    368             /***************************************************************/
    369             NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
    370             u4_ldz = CLZ(u4_word);
    371 
    372             /* Flush the ps_bitstrm */
    373             u4_bitstream_offset += (u4_ldz + 1);
    374 
    375             /* Read the suffix from the ps_bitstrm */
    376             u4_word = 0;
    377             if(u4_ldz)
    378                 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
    379                         u4_ldz);
    380 
    381             *pu4_bitstrm_ofst = u4_bitstream_offset;
    382             u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1;
    383 
    384             if(u4_word & 0x1)
    385                 i_temp = (-(WORD32)u4_abs_val);
    386             else
    387                 i_temp = (u4_abs_val);
    388 
    389             if((i_temp < -26) || (i_temp > 25))
    390                 return ERROR_INV_RANGE_QP_T;
    391             //inlinined ih264d_sev
    392 
    393             COPYTHECONTEXT("mb_qp_delta", i_temp);
    394             if(i_temp)
    395             {
    396                 ret = ih264d_update_qp(ps_dec, (WORD8)i_temp);
    397                 if(ret != OK)
    398                     return ret;
    399             }
    400 
    401             ret = ih264d_parse_residual4x4_cavlc(ps_dec, ps_cur_mb_info, 0);
    402             if(ret != OK)
    403                 return ret;
    404             if(EXCEED_OFFSET(ps_bitstrm))
    405                 return ERROR_EOB_TERMINATE_T;
    406         }
    407         else
    408         {
    409             ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
    410         }
    411 
    412 
    413 
    414     }
    415 
    416     return OK;
    417 }
    418 
    419 /*!
    420  **************************************************************************
    421  * \if Function name : ih264d_parse_pmb_cabac \endif
    422  *
    423  * \brief
    424  *    This function parses CABAC syntax of a P MB.
    425  *
    426  * \return
    427  *    0 on Success and Error code otherwise
    428  **************************************************************************
    429  */
    430 WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
    431                               dec_mb_info_t * ps_cur_mb_info,
    432                               UWORD8 u1_mb_num,
    433                               UWORD8 u1_num_mbsNby2)
    434 {
    435     UWORD32 u1_num_mb_part;
    436     UWORD32 uc_sub_mb;
    437     parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
    438                     + u1_num_mbsNby2;
    439     WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
    440     const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part;
    441     const UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type;
    442     UWORD8 * pu1_col_info = ps_parse_mb_data->u1_col_info;
    443     UWORD32 u1_mb_mc_mode = u1_mb_type;
    444     ctxt_inc_mb_info_t * p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info;
    445     decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
    446     dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
    447     UWORD32 u4_sub_mb_pack = 0;
    448     WORD32 ret;
    449 
    450     UWORD8 u1_no_submb_part_size_lt8x8_flag = 1;
    451     ps_cur_mb_info->u1_tran_form8x8 = 0;
    452     ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
    453 
    454     ps_cur_mb_info->u1_yuv_dc_block_flag = 0;
    455 
    456     p_curr_ctxt->u1_mb_type = CAB_P;
    457     ps_cur_mb_info->u1_mb_mc_mode = u1_mb_type;
    458     uc_sub_mb = ((u1_mb_type == PRED_8x8) | (u1_mb_type == PRED_8x8R0));
    459 
    460     /* Reading the subMB type */
    461     if(uc_sub_mb)
    462     {
    463 
    464         UWORD8 u1_colz = (PRED_8x8 << 6);
    465         u1_mb_mc_mode = 0;
    466 
    467         {
    468             UWORD8 u1_sub_mb_mode;
    469             u1_sub_mb_mode = ih264d_parse_submb_type_cabac(
    470                             0, ps_cab_env, ps_bitstrm,
    471                             ps_dec->p_sub_mb_type_t);
    472             if(u1_sub_mb_mode > 3)
    473                 return ERROR_SUB_MB_TYPE;
    474 
    475             u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
    476             /* Storing collocated information */
    477             *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4));
    478             COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
    479             /* check if Motion compensation is done below 8x8 */
    480             if(u1_sub_mb_mode != P_L0_8x8)
    481             {
    482                 u1_no_submb_part_size_lt8x8_flag = 0;
    483             }
    484         }
    485         {
    486             UWORD8 u1_sub_mb_mode;
    487             u1_sub_mb_mode = ih264d_parse_submb_type_cabac(
    488                             0, ps_cab_env, ps_bitstrm,
    489                             ps_dec->p_sub_mb_type_t);
    490             if(u1_sub_mb_mode > 3)
    491                 return ERROR_SUB_MB_TYPE;
    492 
    493             u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
    494             /* Storing collocated information */
    495             *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4));
    496             COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
    497             /* check if Motion compensation is done below 8x8 */
    498             if(u1_sub_mb_mode != P_L0_8x8)
    499             {
    500                 u1_no_submb_part_size_lt8x8_flag = 0;
    501             }
    502         }
    503         {
    504             UWORD8 u1_sub_mb_mode;
    505             u1_sub_mb_mode = ih264d_parse_submb_type_cabac(
    506                             0, ps_cab_env, ps_bitstrm,
    507                             ps_dec->p_sub_mb_type_t);
    508             if(u1_sub_mb_mode > 3)
    509                 return ERROR_SUB_MB_TYPE;
    510 
    511             u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
    512             /* Storing collocated information */
    513             *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4));
    514             COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
    515             /* check if Motion compensation is done below 8x8 */
    516             if(u1_sub_mb_mode != P_L0_8x8)
    517             {
    518                 u1_no_submb_part_size_lt8x8_flag = 0;
    519             }
    520         }
    521         {
    522             UWORD8 u1_sub_mb_mode;
    523             u1_sub_mb_mode = ih264d_parse_submb_type_cabac(
    524                             0, ps_cab_env, ps_bitstrm,
    525                             ps_dec->p_sub_mb_type_t);
    526             if(u1_sub_mb_mode > 3)
    527                 return ERROR_SUB_MB_TYPE;
    528 
    529             u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
    530             /* Storing collocated information */
    531             *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4));
    532             COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
    533             /* check if Motion compensation is done below 8x8 */
    534             if(u1_sub_mb_mode != P_L0_8x8)
    535             {
    536                 u1_no_submb_part_size_lt8x8_flag = 0;
    537             }
    538         }
    539         u1_num_mb_part = 4;
    540     }
    541     else
    542     {
    543         u1_num_mb_part = pu1_num_mb_part[u1_mb_type];
    544         /* Storing collocated Mb and SubMb mode information */
    545         *pu1_col_info++ = (u1_mb_type << 6);
    546         if(u1_mb_type)
    547             *pu1_col_info++ = (u1_mb_type << 6);
    548     }
    549     /* Decoding reference index 0: For simple profile the following   */
    550     /* conditions are always true (mb_field_decoding_flag == 0);      */
    551     /* (MbPartPredMode != PredL1)                                     */
    552     {
    553         WORD8 * pi1_top_ref_idx_ctx_inc_arr = p_curr_ctxt->i1_ref_idx;
    554         WORD8 * pi1_left_ref_idx_ctxt_inc = ps_dec->pi1_left_ref_idx_ctxt_inc;
    555         UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
    556         UWORD8 uc_field = ps_cur_mb_info->u1_mb_field_decodingflag;
    557         UWORD8 uc_num_ref_idx_l0_active_minus1 =
    558                         (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0]
    559                                         << (u1_mbaff & uc_field)) - 1;
    560 
    561         if((uc_num_ref_idx_l0_active_minus1 > 0) & (u1_mb_type != PRED_8x8R0))
    562         {
    563             /* force the routine to decode ref idx for each partition */
    564             *((UWORD32 *)pi1_ref_idx) = 0x01010101;
    565             ret = ih264d_parse_ref_idx_cabac(u1_num_mb_part, 0,
    566                                              uc_num_ref_idx_l0_active_minus1,
    567                                              u1_mb_mc_mode, pi1_ref_idx,
    568                                              pi1_left_ref_idx_ctxt_inc,
    569                                              pi1_top_ref_idx_ctx_inc_arr, ps_cab_env,
    570                                              ps_bitstrm, ps_dec->p_ref_idx_t);
    571             if(ret != OK)
    572                 return ret;
    573         }
    574         else
    575         {
    576             /* When there exists only a single frame to predict from */
    577             pi1_left_ref_idx_ctxt_inc[0] = 0;
    578             pi1_left_ref_idx_ctxt_inc[1] = 0;
    579             pi1_top_ref_idx_ctx_inc_arr[0] = 0;
    580             pi1_top_ref_idx_ctx_inc_arr[1] = 0;
    581             *((UWORD32 *)pi1_ref_idx) = 0;
    582         }
    583     }
    584 
    585     {
    586         UWORD8 u1_p_idx, uc_i;
    587         parse_part_params_t * ps_part = ps_dec->ps_part;
    588         UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
    589         UWORD8 u1_sub_mb_num;
    590         const UWORD8 * pu1_top_left_sub_mb_indx;
    591         mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
    592         UWORD16 u2_sub_mb_num_pack = 0x028A;
    593 
    594         /* Loading the table pointers */
    595         const UWORD8 * pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
    596         const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
    597         const UWORD8 * pu1_sub_mb_indx_mod =
    598                         (const UWORD8 *)(gau1_ih264d_submb_indx_mod)
    599                                         + (uc_sub_mb * 6);
    600         const UWORD8 * pu1_sub_mb_partw = (const UWORD8 *)gau1_ih264d_submb_partw;
    601         const UWORD8 * pu1_sub_mb_parth = (const UWORD8 *)gau1_ih264d_submb_parth;
    602         const UWORD8 * pu1_num_sub_mb_part =
    603                         (const UWORD8 *)gau1_ih264d_num_submb_part;
    604 
    605         /*********************************************************/
    606         /* default initialisations for condition (uc_sub_mb == 0) */
    607         /* i.e. all are subpartitions of 8x8                     */
    608         /*********************************************************/
    609         u1_sub_mb_mode = 0;
    610         u1_num_subpart = 1;
    611         u1_mb_part_width = pu1_mb_partw[u1_mb_type];
    612         u1_mb_part_height = pu1_mb_parth[u1_mb_type];
    613         pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
    614         u1_sub_mb_num = 0;
    615 
    616         /* Loop on number of partitions */
    617         for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
    618         {
    619             UWORD8 uc_j;
    620             if(uc_sub_mb)
    621             {
    622                 u1_sub_mb_mode = u4_sub_mb_pack >> 24;
    623                 u1_num_subpart = pu1_num_sub_mb_part[u1_sub_mb_mode];
    624                 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
    625                 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
    626                 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
    627                 u1_sub_mb_num = u2_sub_mb_num_pack >> 12;
    628                 u4_sub_mb_pack <<= 8;
    629                 u2_sub_mb_num_pack <<= 4;
    630             }
    631             /* Loop on Number of sub-partitions */
    632             for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++)
    633             {
    634                 mv_pred_t * ps_mv;
    635 
    636                 u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
    637                 ps_mv = ps_mv_start + u1_sub_mb_num;
    638 
    639                 /* Storing Info for partitions */
    640                 ps_part->u1_is_direct = PART_NOT_DIRECT;
    641                 ps_part->u1_sub_mb_num = u1_sub_mb_num;
    642                 ps_part->u1_partheight = u1_mb_part_height;
    643                 ps_part->u1_partwidth = u1_mb_part_width;
    644 
    645                 /* Increment partition Index */
    646                 u1_p_idx++;
    647                 ps_part++;
    648 
    649                 ih264d_get_mvd_cabac(u1_sub_mb_num, 0, u1_mb_part_width,
    650                                      u1_mb_part_height, 1, ps_dec, ps_mv);
    651             }
    652         }
    653         ps_parse_mb_data->u1_num_part = u1_p_idx;
    654         ps_dec->ps_part = ps_part;
    655     }
    656     {
    657         UWORD8 u1_cbp;
    658 
    659         /* Read the Coded block pattern */
    660         u1_cbp = (WORD8)ih264d_parse_ctx_cbp_cabac(ps_dec);
    661         COPYTHECONTEXT("coded_block_pattern", u1_cbp);
    662         ps_cur_mb_info->u1_cbp = u1_cbp;
    663         p_curr_ctxt->u1_cbp = u1_cbp;
    664         p_curr_ctxt->u1_intra_chroma_pred_mode = 0;
    665         p_curr_ctxt->u1_yuv_dc_csbp &= 0xFE;
    666         ps_dec->pu1_left_yuv_dc_csbp[0] &= 0x6;
    667 
    668         if(u1_cbp > 47)
    669             return ERROR_CBP;
    670 
    671         ps_cur_mb_info->u1_tran_form8x8 = 0;
    672         ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
    673 
    674         /* Read the transform8x8 u4_flag if present */
    675         if((ps_dec->s_high_profile.u1_transform8x8_present) && (u1_cbp & 0xf)
    676                         && u1_no_submb_part_size_lt8x8_flag)
    677         {
    678             ps_cur_mb_info->u1_tran_form8x8 = ih264d_parse_transform8x8flag_cabac(
    679                             ps_dec, ps_cur_mb_info);
    680             COPYTHECONTEXT("transform_size_8x8_flag", ps_cur_mb_info->u1_tran_form8x8);
    681             p_curr_ctxt->u1_transform8x8_ctxt = ps_cur_mb_info->u1_tran_form8x8;
    682             ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = ps_cur_mb_info->u1_tran_form8x8;
    683 
    684         }
    685         else
    686         {
    687             p_curr_ctxt->u1_transform8x8_ctxt = 0;
    688         }
    689 
    690         /* Read mb_qp_delta */
    691         if(u1_cbp)
    692         {
    693             WORD8 c_temp;
    694             ret = ih264d_parse_mb_qp_delta_cabac(ps_dec, &c_temp);
    695             if(ret != OK)
    696                 return ret;
    697             COPYTHECONTEXT("mb_qp_delta", c_temp);
    698             if(c_temp != 0)
    699             {
    700                 ret = ih264d_update_qp(ps_dec, c_temp);
    701                 if(ret != OK)
    702                     return ret;
    703             }
    704         }
    705         else
    706             ps_dec->i1_prev_mb_qp_delta = 0;
    707 
    708 
    709 
    710         ih264d_parse_residual4x4_cabac(ps_dec, ps_cur_mb_info, 0);
    711         if(EXCEED_OFFSET(ps_dec->ps_bitstrm))
    712             return ERROR_EOB_TERMINATE_T;
    713     }
    714     return OK;
    715 }
    716 
    717 /*!
    718  **************************************************************************
    719  * \if Function name : parsePSliceData \endif
    720  *
    721  * \brief
    722  *    This function parses CAVLC syntax of N MB's of a P slice.
    723  *    1. After parsing syntax of N MB's, for those N MB's (less than N, incase
    724  *       of end of slice or end of row), MB is decoded. This process is carried
    725  *       for one complete MB row or till end of slice.
    726  *    2. Bottom one row of current MB is copied to IntraPredLine buffers.
    727  *       IntraPredLine buffers are used for Intra prediction of next row.
    728  *    3. Current MB row along with previous 4 rows of Luma (and 2 of Chroma) are
    729  *       deblocked.
    730  *    4. 4 rows (2 for Chroma) previous row and 12 rows (6 for Chroma) are
    731  *       DMA'ed to picture buffers.
    732  *
    733  * \return
    734  *    0 on Success and Error code otherwise
    735  **************************************************************************
    736  */
    737 
    738 /*!
    739  **************************************************************************
    740  * \if Function name : ih264d_update_nnz_for_skipmb \endif
    741  *
    742  * \brief
    743  *
    744  * \return
    745  *    None
    746  *
    747  **************************************************************************
    748  */
    749 void ih264d_update_nnz_for_skipmb(dec_struct_t * ps_dec,
    750                                   dec_mb_info_t * ps_cur_mb_info,
    751                                   UWORD8 u1_entrpy)
    752 {
    753     UWORD32 *pu4_buf;
    754     UWORD8 *pu1_buf;
    755     UNUSED(u1_entrpy);
    756     pu1_buf = ps_dec->pu1_left_nnz_y;
    757     pu4_buf = (UWORD32 *)pu1_buf;
    758     *pu4_buf = 0;
    759     pu1_buf = ps_dec->pu1_left_nnz_uv;
    760     pu4_buf = (UWORD32 *)pu1_buf;
    761     *pu4_buf = 0;
    762     pu1_buf = ps_cur_mb_info->ps_curmb->pu1_nnz_y;
    763     pu4_buf = (UWORD32 *)pu1_buf;
    764     *pu4_buf = 0;
    765     pu1_buf = ps_cur_mb_info->ps_curmb->pu1_nnz_uv;
    766     pu4_buf = (UWORD32 *)pu1_buf;
    767     *pu4_buf = 0;
    768     ps_cur_mb_info->ps_curmb->u2_luma_csbp = 0;
    769     ps_cur_mb_info->u2_luma_csbp = 0;
    770     ps_cur_mb_info->u2_chroma_csbp = 0;
    771 }
    772 
    773 
    774 
    775 /*****************************************************************************/
    776 /*                                                                           */
    777 /*  Function Name : ih264d_parse_inter_slice_data_cabac                             */
    778 /*                                                                           */
    779 /*  Description   : This function parses cabac syntax of a inter slice on    */
    780 /*                  N MB basis.                                              */
    781 /*                                                                           */
    782 /*  Inputs        : ps_dec                                                   */
    783 /*                  sliceparams                                              */
    784 /*                  firstMbInSlice                                           */
    785 /*                                                                           */
    786 /*  Processing    : 1. After parsing syntax for N MBs those N MBs are        */
    787 /*                     decoded till the end of slice.                        */
    788 /*                  2. MV prediction and DMA happens on a N/2 MB basis.      */
    789 /*                                                                           */
    790 /*  Returns       : 0                                                        */
    791 /*                                                                           */
    792 /*  Issues        : <List any issues or problems with this function>         */
    793 /*                                                                           */
    794 /*  Revision History:                                                        */
    795 /*                                                                           */
    796 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
    797 /*         13 07 2002   Jay             Draft                                */
    798 /*                                                                           */
    799 /*****************************************************************************/
    800 WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
    801                                            dec_slice_params_t * ps_slice,
    802                                            UWORD16 u2_first_mb_in_slice)
    803 {
    804     UWORD32 uc_more_data_flag;
    805     WORD32 i2_cur_mb_addr;
    806     UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
    807     UWORD32 u1_mbaff;
    808     UWORD32 u1_num_mbs_next, u1_end_of_row;
    809     const UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
    810     UWORD32 u1_slice_end = 0;
    811     UWORD32 u1_tfr_n_mb = 0;
    812     UWORD32 u1_decode_nmb = 0;
    813 
    814 
    815     deblk_mb_t *ps_cur_deblk_mb;
    816     dec_mb_info_t *ps_cur_mb_info;
    817 
    818     parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
    819     UWORD32 u1_inter_mb_skip_type;
    820     UWORD32 u1_inter_mb_type;
    821     UWORD32 u1_deblk_mb_type;
    822     UWORD32 u1_mb_threshold;
    823     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
    824     WORD32 ret = OK;
    825 
    826     /******************************************************/
    827     /* Initialisations specific to B or P slice           */
    828     /******************************************************/
    829     if(ps_slice->u1_slice_type == P_SLICE)
    830     {
    831         u1_inter_mb_skip_type = CAB_P_SKIP;
    832         u1_inter_mb_type = P_MB;
    833         u1_deblk_mb_type = D_INTER_MB;
    834         u1_mb_threshold = 5;
    835     }
    836     else // B_SLICE
    837     {
    838         u1_inter_mb_skip_type = CAB_B_SKIP;
    839         u1_inter_mb_type = B_MB;
    840         u1_deblk_mb_type = D_B_SLICE;
    841         u1_mb_threshold = 23;
    842     }
    843 
    844     /******************************************************/
    845     /* Slice Level Initialisations                        */
    846     /******************************************************/
    847     i2_cur_mb_addr = u2_first_mb_in_slice;
    848     ps_dec->u1_qp = ps_slice->u1_slice_qp;
    849     ih264d_update_qp(ps_dec, 0);
    850     u1_mb_idx = ps_dec->u1_mb_idx;
    851     u1_num_mbs = u1_mb_idx;
    852     u1_num_mbsNby2 = 0;
    853     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
    854     i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
    855     uc_more_data_flag = 1;
    856 
    857     /* Initialisations specific to cabac */
    858     if(ps_bitstrm->u4_ofst & 0x07)
    859     {
    860         ps_bitstrm->u4_ofst += 8;
    861         ps_bitstrm->u4_ofst &= 0xFFFFFFF8;
    862     }
    863 
    864     ret = ih264d_init_cabac_dec_envirnoment(&(ps_dec->s_cab_dec_env), ps_bitstrm);
    865     if(ret != OK)
    866         return ret;
    867 
    868     ps_dec->i1_prev_mb_qp_delta = 0;
    869 
    870     while(!u1_slice_end)
    871     {
    872         UWORD8 u1_mb_type;
    873         UWORD32 u4_mb_skip;
    874 
    875         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
    876 
    877         if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
    878         {
    879             break;
    880         }
    881 
    882         ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
    883         ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
    884 
    885         ps_cur_mb_info->u1_Mux = 0;
    886         ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
    887         ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
    888 
    889         ps_cur_mb_info->u1_end_of_slice = 0;
    890 
    891         /* Storing Default partition info */
    892         ps_parse_mb_data->u1_num_part = 1;
    893         ps_parse_mb_data->u1_isI_mb = 0;
    894 
    895         /***************************************************************/
    896         /* Get the required information for decoding of MB             */
    897         /* mb_x, mb_y , neighbour availablity,                         */
    898         /***************************************************************/
    899         u4_mb_skip = ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 1);
    900 
    901         /*********************************************************************/
    902         /* initialize u1_tran_form8x8 to zero to aviod uninitialized accesses */
    903         /*********************************************************************/
    904         ps_cur_mb_info->u1_tran_form8x8 = 0;
    905         ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
    906 
    907         /***************************************************************/
    908         /* Set the deblocking parameters for this MB                   */
    909         /***************************************************************/
    910         if(ps_dec->u4_app_disable_deblk_frm == 0)
    911             ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
    912                                              ps_dec->u1_mb_ngbr_availablity,
    913                                              ps_dec->u1_cur_mb_fld_dec_flag);
    914 
    915         if(u4_mb_skip)
    916         {
    917 
    918             /* Set appropriate flags in ps_cur_mb_info and ps_dec */
    919             memset(ps_dec->ps_curr_ctxt_mb_info, 0, sizeof(ctxt_inc_mb_info_t));
    920             ps_dec->ps_curr_ctxt_mb_info->u1_mb_type = u1_inter_mb_skip_type;
    921 
    922             MEMSET_16BYTES(&ps_dec->pu1_left_mv_ctxt_inc[0][0], 0);
    923 
    924             *((UWORD32 *)ps_dec->pi1_left_ref_idx_ctxt_inc) = 0;
    925             *(ps_dec->pu1_left_yuv_dc_csbp) = 0;
    926 
    927             ps_dec->i1_prev_mb_qp_delta = 0;
    928             ps_cur_mb_info->u1_mb_type = MB_SKIP;
    929             ps_cur_mb_info->u1_cbp = 0;
    930 
    931             {
    932                 /* Storing Skip partition info */
    933                 parse_part_params_t *ps_part_info = ps_dec->ps_part;
    934                 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
    935                 ps_part_info->u1_sub_mb_num = 0;
    936                 ps_dec->ps_part++;
    937             }
    938 
    939             /* Update Nnzs */
    940             ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CABAC);
    941 
    942             ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
    943             ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
    944             ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
    945 
    946         }
    947         else
    948         {
    949 
    950             /* Macroblock Layer Begins */
    951             /* Decode the u1_mb_type */
    952             u1_mb_type = ih264d_parse_mb_type_cabac(ps_dec);
    953             ps_cur_mb_info->u1_mb_type = u1_mb_type;
    954             if(u1_mb_type > (25 + u1_mb_threshold))
    955                 return ERROR_MB_TYPE;
    956 
    957             /* Parse Macroblock Data */
    958             if(u1_mb_type < u1_mb_threshold)
    959             {
    960                 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
    961                 *(ps_dec->pu1_left_yuv_dc_csbp) &= 0x6;
    962 
    963                 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs,
    964                                           u1_num_mbsNby2);
    965                 if(ret != OK)
    966                     return ret;
    967                 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
    968                 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
    969             }
    970             else
    971             {
    972                 /* Storing Intra partition info */
    973                 ps_parse_mb_data->u1_num_part = 0;
    974                 ps_parse_mb_data->u1_isI_mb = 1;
    975 
    976                 if((25 + u1_mb_threshold) == u1_mb_type)
    977                 {
    978                     /* I_PCM_MB */
    979                     ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
    980                     ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
    981                     if(ret != OK)
    982                         return ret;
    983                     ps_cur_deblk_mb->u1_mb_qp = 0;
    984                 }
    985                 else
    986                 {
    987                     if(u1_mb_type == u1_mb_threshold)
    988                         ps_cur_mb_info->ps_curmb->u1_mb_type = I_4x4_MB;
    989                     else
    990                         ps_cur_mb_info->ps_curmb->u1_mb_type = I_16x16_MB;
    991 
    992                     ret = ih264d_parse_imb_cabac(
    993                                     ps_dec, ps_cur_mb_info,
    994                                     (UWORD8)(u1_mb_type - u1_mb_threshold));
    995                     if(ret != OK)
    996                         return ret;
    997                     ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
    998                 }
    999                 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
   1000 
   1001             }
   1002 
   1003         }
   1004 
   1005         if(u1_mbaff)
   1006         {
   1007             ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
   1008         }
   1009 
   1010 
   1011         if(ps_cur_mb_info->u1_topmb && u1_mbaff)
   1012             uc_more_data_flag = 1;
   1013         else
   1014         {
   1015             uc_more_data_flag = ih264d_decode_terminate(&ps_dec->s_cab_dec_env,
   1016                                                       ps_bitstrm);
   1017             uc_more_data_flag = !uc_more_data_flag;
   1018             COPYTHECONTEXT("Decode Sliceterm",!uc_more_data_flag);
   1019         }
   1020 
   1021         if(u1_mbaff)
   1022         {
   1023             if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
   1024             {
   1025                 return ERROR_EOB_FLUSHBITS_T;
   1026             }
   1027         }
   1028         /* Next macroblock information */
   1029         i2_cur_mb_addr++;
   1030         u1_num_mbs++;
   1031         u1_num_mbsNby2++;
   1032         ps_parse_mb_data++;
   1033 
   1034         /****************************************************************/
   1035         /* Check for End Of Row and other flags that determine when to  */
   1036         /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for   */
   1037         /* N-Mb                                                         */
   1038         /****************************************************************/
   1039         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
   1040         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
   1041         u1_slice_end = !uc_more_data_flag;
   1042         u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
   1043                         || u1_slice_end;
   1044         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
   1045         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
   1046         /*u1_dma_nby2mb   = u1_decode_nmb ||
   1047          (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/
   1048 
   1049 //if(u1_dma_nby2mb)
   1050         if(u1_decode_nmb)
   1051         {
   1052 
   1053             ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
   1054             u1_num_mbsNby2 = 0;
   1055 
   1056             {
   1057                 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
   1058                 ps_dec->ps_part = ps_dec->ps_parse_part_params;
   1059             }
   1060         }
   1061 
   1062         /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d",
   1063          ps_slice->i4_poc >> ps_slice->u1_field_pic_flag,
   1064          ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb));
   1065          H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d, u1_num_mbs: %d", u1_decode_nmb, u1_num_mbs);*/
   1066         if(u1_decode_nmb)
   1067         {
   1068 
   1069             if(ps_dec->u1_separate_parse)
   1070             {
   1071                 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
   1072                                      u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
   1073                 ps_dec->ps_nmb_info +=  u1_num_mbs;
   1074             }
   1075             else
   1076             {
   1077                 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
   1078                                             u1_num_mbs_next, u1_tfr_n_mb,
   1079                                             u1_end_of_row);
   1080             }
   1081             ps_dec->u2_total_mbs_coded += u1_num_mbs;
   1082             if(u1_tfr_n_mb)
   1083                 u1_num_mbs = 0;
   1084             u1_mb_idx = u1_num_mbs;
   1085             ps_dec->u1_mb_idx = u1_num_mbs;
   1086 
   1087         }
   1088     }
   1089 
   1090 
   1091     ps_dec->u4_num_mbs_cur_nmb = 0;
   1092     ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
   1093 
   1094                         - (u2_first_mb_in_slice << u1_mbaff);
   1095 
   1096     return ret;
   1097 }
   1098 
   1099 /*****************************************************************************/
   1100 /*                                                                           */
   1101 /*  Function Name : ih264d_parse_inter_slice_data_cavlc                             */
   1102 /*                                                                           */
   1103 /*  Description   : This function parses cavlc syntax of a inter slice on    */
   1104 /*                  N MB basis.                                              */
   1105 /*                                                                           */
   1106 /*  Inputs        : ps_dec                                                   */
   1107 /*                  sliceparams                                              */
   1108 /*                  firstMbInSlice                                           */
   1109 /*                                                                           */
   1110 /*  Processing    : 1. After parsing syntax for N MBs those N MBs are        */
   1111 /*                     decoded till the end of slice.                        */
   1112 /*                  2. MV prediction and DMA happens on a N/2 MB basis.      */
   1113 /*                                                                           */
   1114 /*  Returns       : 0                                                        */
   1115 /*                                                                           */
   1116 /*  Issues        : <List any issues or problems with this function>         */
   1117 /*                                                                           */
   1118 /*  Revision History:                                                        */
   1119 /*                                                                           */
   1120 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
   1121 /*         13 07 2002   Jay             Draft                                */
   1122 /*                                                                           */
   1123 /*****************************************************************************/
   1124 
   1125 WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
   1126                                            dec_slice_params_t * ps_slice,
   1127                                            UWORD16 u2_first_mb_in_slice)
   1128 {
   1129     UWORD32 uc_more_data_flag;
   1130     WORD32 i2_cur_mb_addr;
   1131     UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
   1132     UWORD32 i2_mb_skip_run;
   1133     UWORD32 u1_read_mb_type;
   1134 
   1135     UWORD32 u1_mbaff;
   1136     UWORD32 u1_num_mbs_next, u1_end_of_row;
   1137     const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
   1138     UWORD32 u1_slice_end = 0;
   1139     UWORD32 u1_tfr_n_mb = 0;
   1140     UWORD32 u1_decode_nmb = 0;
   1141 
   1142     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
   1143     UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
   1144     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
   1145     deblk_mb_t *ps_cur_deblk_mb;
   1146     dec_mb_info_t *ps_cur_mb_info;
   1147     parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
   1148     UWORD32 u1_inter_mb_type;
   1149     UWORD32 u1_deblk_mb_type;
   1150     UWORD32 u1_mb_threshold;
   1151     WORD32 ret = OK;
   1152 
   1153     /******************************************************/
   1154     /* Initialisations specific to B or P slice           */
   1155     /******************************************************/
   1156 
   1157     if(ps_slice->u1_slice_type == P_SLICE)
   1158     {
   1159         u1_inter_mb_type = P_MB;
   1160         u1_deblk_mb_type = D_INTER_MB;
   1161         u1_mb_threshold = 5;
   1162     }
   1163     else // B_SLICE
   1164     {
   1165         u1_inter_mb_type = B_MB;
   1166         u1_deblk_mb_type = D_B_SLICE;
   1167         u1_mb_threshold = 23;
   1168     }
   1169     /******************************************************/
   1170     /* Slice Level Initialisations                        */
   1171     /******************************************************/
   1172     ps_dec->u1_qp = ps_slice->u1_slice_qp;
   1173     ih264d_update_qp(ps_dec, 0);
   1174     u1_mb_idx = ps_dec->u1_mb_idx;
   1175     u1_num_mbs = u1_mb_idx;
   1176 
   1177     u1_num_mbsNby2 = 0;
   1178     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
   1179     i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
   1180     i2_mb_skip_run = 0;
   1181     uc_more_data_flag = 1;
   1182     u1_read_mb_type = 0;
   1183 
   1184     while(!u1_slice_end)
   1185     {
   1186         UWORD8 u1_mb_type;
   1187 
   1188         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
   1189 
   1190         if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
   1191         {
   1192             break;
   1193         }
   1194 
   1195 
   1196         ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
   1197         ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
   1198 
   1199         ps_cur_mb_info->u1_Mux = 0;
   1200         ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
   1201         ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
   1202 
   1203         ps_cur_mb_info->u1_end_of_slice = 0;
   1204 
   1205         /* Storing Default partition info */
   1206         ps_parse_mb_data->u1_num_part = 1;
   1207         ps_parse_mb_data->u1_isI_mb = 0;
   1208 
   1209         if((!i2_mb_skip_run) && (!u1_read_mb_type))
   1210         {
   1211 
   1212             //Inlined ih264d_uev
   1213             UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
   1214             UWORD32 u4_word, u4_ldz;
   1215 
   1216             /***************************************************************/
   1217             /* Find leading zeros in next 32 bits                          */
   1218             /***************************************************************/
   1219             NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
   1220 
   1221             u4_ldz = CLZ(u4_word);
   1222 
   1223             /* Flush the ps_bitstrm */
   1224             u4_bitstream_offset += (u4_ldz + 1);
   1225             /* Read the suffix from the ps_bitstrm */
   1226             u4_word = 0;
   1227             if(u4_ldz)
   1228             {
   1229                 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
   1230                         u4_ldz);
   1231             }
   1232             *pu4_bitstrm_ofst = u4_bitstream_offset;
   1233             i2_mb_skip_run = ((1 << u4_ldz) + u4_word - 1);
   1234             //Inlined ih264d_uev
   1235             COPYTHECONTEXT("mb_skip_run", i2_mb_skip_run);
   1236             uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
   1237             u1_read_mb_type = uc_more_data_flag;
   1238         }
   1239 
   1240         /***************************************************************/
   1241         /* Get the required information for decoding of MB                  */
   1242         /* mb_x, mb_y , neighbour availablity,                              */
   1243         /***************************************************************/
   1244         ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
   1245 
   1246         /***************************************************************/
   1247         /* Set the deblocking parameters for this MB                   */
   1248         /***************************************************************/
   1249         if(ps_dec->u4_app_disable_deblk_frm == 0)
   1250             ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
   1251                                              ps_dec->u1_mb_ngbr_availablity,
   1252                                              ps_dec->u1_cur_mb_fld_dec_flag);
   1253 
   1254         if(i2_mb_skip_run)
   1255         {
   1256             /* Set appropriate flags in ps_cur_mb_info and ps_dec */
   1257             ps_dec->i1_prev_mb_qp_delta = 0;
   1258             ps_dec->u1_sub_mb_num = 0;
   1259             ps_cur_mb_info->u1_mb_type = MB_SKIP;
   1260             ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
   1261             ps_cur_mb_info->u1_cbp = 0;
   1262 
   1263             {
   1264                 /* Storing Skip partition info */
   1265                 parse_part_params_t *ps_part_info = ps_dec->ps_part;
   1266                 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
   1267                 ps_part_info->u1_sub_mb_num = 0;
   1268                 ps_dec->ps_part++;
   1269             }
   1270 
   1271             /* Update Nnzs */
   1272             ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
   1273 
   1274             ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
   1275             ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
   1276 
   1277             i2_mb_skip_run--;
   1278         }
   1279         else
   1280         {
   1281             u1_read_mb_type = 0;
   1282             /**************************************************************/
   1283             /* Macroblock Layer Begins, Decode the u1_mb_type                */
   1284             /**************************************************************/
   1285             {
   1286                 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
   1287                 UWORD32 u4_word, u4_ldz, u4_temp;
   1288 
   1289 
   1290                 //Inlined ih264d_uev
   1291                 /***************************************************************/
   1292                 /* Find leading zeros in next 32 bits                          */
   1293                 /***************************************************************/
   1294                 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
   1295                 u4_ldz = CLZ(u4_word);
   1296                 /* Flush the ps_bitstrm */
   1297                 u4_bitstream_offset += (u4_ldz + 1);
   1298                 /* Read the suffix from the ps_bitstrm */
   1299                 u4_word = 0;
   1300                 if(u4_ldz)
   1301                     GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
   1302                             u4_ldz);
   1303                 *pu4_bitstrm_ofst = u4_bitstream_offset;
   1304                 u4_temp = ((1 << u4_ldz) + u4_word - 1);
   1305                 //Inlined ih264d_uev
   1306                 if(u4_temp > (UWORD32)(25 + u1_mb_threshold))
   1307                     return ERROR_MB_TYPE;
   1308                 u1_mb_type = u4_temp;
   1309                 COPYTHECONTEXT("u1_mb_type", u1_mb_type);
   1310             }
   1311             ps_cur_mb_info->u1_mb_type = u1_mb_type;
   1312 
   1313             /**************************************************************/
   1314             /* Parse Macroblock data                                      */
   1315             /**************************************************************/
   1316             if(u1_mb_type < u1_mb_threshold)
   1317             {
   1318                 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
   1319 
   1320                 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs,
   1321                                           u1_num_mbsNby2);
   1322                 if(ret != OK)
   1323                     return ret;
   1324                 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
   1325             }
   1326             else
   1327             {
   1328                 /* Storing Intra partition info */
   1329                 ps_parse_mb_data->u1_num_part = 0;
   1330                 ps_parse_mb_data->u1_isI_mb = 1;
   1331 
   1332                 if((25 + u1_mb_threshold) == u1_mb_type)
   1333                 {
   1334                     /* I_PCM_MB */
   1335                     ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
   1336                     ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
   1337                     if(ret != OK)
   1338                          return ret;
   1339                     ps_dec->u1_qp = 0;
   1340                 }
   1341                 else
   1342                 {
   1343                     ret = ih264d_parse_imb_cavlc(
   1344                                     ps_dec, ps_cur_mb_info, u1_num_mbs,
   1345                                     (UWORD8)(u1_mb_type - u1_mb_threshold));
   1346                     if(ret != OK)
   1347                         return ret;
   1348                 }
   1349 
   1350                 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
   1351             }
   1352             uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
   1353         }
   1354         ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
   1355 
   1356         if(u1_mbaff)
   1357         {
   1358             ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
   1359             if(!uc_more_data_flag && !i2_mb_skip_run && (0 == (i2_cur_mb_addr & 1)))
   1360             {
   1361                 return ERROR_EOB_FLUSHBITS_T;
   1362             }
   1363         }
   1364         /**************************************************************/
   1365         /* Get next Macroblock address                                */
   1366         /**************************************************************/
   1367         i2_cur_mb_addr++;
   1368 
   1369         u1_num_mbs++;
   1370         u1_num_mbsNby2++;
   1371         ps_parse_mb_data++;
   1372 
   1373         /****************************************************************/
   1374         /* Check for End Of Row and other flags that determine when to  */
   1375         /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for   */
   1376         /* N-Mb                                                         */
   1377         /****************************************************************/
   1378         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
   1379         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
   1380         u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
   1381         u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
   1382                         || u1_slice_end;
   1383         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
   1384         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
   1385 
   1386         /*u1_dma_nby2mb   = u1_decode_nmb ||
   1387          (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/
   1388 
   1389 //if(u1_dma_nby2mb)
   1390         if(u1_decode_nmb)
   1391         {
   1392             ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
   1393             u1_num_mbsNby2 = 0;
   1394 
   1395             {
   1396                 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
   1397                 ps_dec->ps_part = ps_dec->ps_parse_part_params;
   1398             }
   1399         }
   1400 
   1401         /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d",
   1402          ps_slice->i4_poc >> ps_slice->u1_field_pic_flag,
   1403          ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb));
   1404          H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d", u1_decode_nmb);*/
   1405         if(u1_decode_nmb)
   1406         {
   1407 
   1408 
   1409 
   1410             if(ps_dec->u1_separate_parse)
   1411             {
   1412                 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
   1413                                      u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
   1414                 ps_dec->ps_nmb_info +=  u1_num_mbs;
   1415             }
   1416             else
   1417             {
   1418                 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
   1419                                             u1_num_mbs_next, u1_tfr_n_mb,
   1420                                             u1_end_of_row);
   1421             }
   1422             ps_dec->u2_total_mbs_coded += u1_num_mbs;
   1423             if(u1_tfr_n_mb)
   1424                 u1_num_mbs = 0;
   1425             u1_mb_idx = u1_num_mbs;
   1426             ps_dec->u1_mb_idx = u1_num_mbs;
   1427 
   1428         }
   1429 //ps_dec->ps_pred++;
   1430     }
   1431 
   1432     ps_dec->u4_num_mbs_cur_nmb = 0;
   1433     ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
   1434                         - (u2_first_mb_in_slice << u1_mbaff);
   1435 
   1436 
   1437     return ret;
   1438 }
   1439 
   1440 WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
   1441                                 WORD32 num_mb_skip,
   1442                                 UWORD8 u1_is_idr_slice,
   1443                                 UWORD16 u2_frame_num,
   1444                                 pocstruct_t *ps_cur_poc,
   1445                                 WORD32 prev_slice_err)
   1446 {
   1447     WORD32 i2_cur_mb_addr;
   1448     UWORD32 u1_num_mbs, u1_num_mbsNby2;
   1449     UWORD32 u1_mb_idx = ps_dec->u1_mb_idx;
   1450     UWORD32 i2_mb_skip_run;
   1451 
   1452     UWORD32 u1_num_mbs_next, u1_end_of_row;
   1453     const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
   1454     UWORD32 u1_slice_end;
   1455     UWORD32 u1_tfr_n_mb;
   1456     UWORD32 u1_decode_nmb;
   1457     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
   1458     dec_slice_params_t * ps_slice = ps_dec->ps_cur_slice;
   1459     UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
   1460     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
   1461     deblk_mb_t *ps_cur_deblk_mb;
   1462     dec_mb_info_t *ps_cur_mb_info;
   1463     parse_pmbarams_t *ps_parse_mb_data;
   1464     UWORD32 u1_inter_mb_type;
   1465     UWORD32 u1_deblk_mb_type;
   1466     UWORD16 u2_total_mbs_coded;
   1467     UWORD32 u1_mbaff;
   1468     parse_part_params_t *ps_part_info;
   1469     WORD32 ret;
   1470     UNUSED(u1_is_idr_slice);
   1471 
   1472     if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
   1473     {
   1474         ih264d_err_pic_dispbuf_mgr(ps_dec);
   1475         return 0;
   1476     }
   1477 
   1478     if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (num_mb_skip & 1))
   1479     {
   1480         num_mb_skip++;
   1481     }
   1482     ps_dec->ps_dpb_cmds->u1_long_term_reference_flag = 0;
   1483     if(prev_slice_err == 1)
   1484     {
   1485         /* first slice - missing/header corruption */
   1486         ps_dec->ps_cur_slice->u2_frame_num = u2_frame_num;
   1487         {
   1488             WORD32 i, j, poc = 0;
   1489 
   1490             ps_dec->ps_cur_slice->u2_first_mb_in_slice = 0;
   1491 
   1492             ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
   1493             ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
   1494             ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
   1495 
   1496             if(ps_dec->ps_cur_pic != NULL)
   1497                 poc = ps_dec->ps_cur_pic->i4_poc + 2;
   1498 
   1499             j = -1;
   1500             for(i = 0; i < MAX_NUM_PIC_PARAMS; i++)
   1501             {
   1502                    if(ps_dec->ps_pps[i].u1_is_valid == TRUE)
   1503                    {
   1504                        if(ps_dec->ps_pps[i].ps_sps->u1_is_valid == TRUE)
   1505                        {
   1506                            j = i;
   1507                            break;
   1508                        }
   1509                    }
   1510             }
   1511 
   1512             //if valid SPS PPS is not found return error
   1513             if(j == -1)
   1514             {
   1515                 return ERROR_INV_SLICE_HDR_T;
   1516             }
   1517 
   1518             /* call ih264d_start_of_pic only if it was not called earlier*/
   1519             if(ps_dec->u4_pic_buf_got == 0)
   1520             {
   1521                 //initialize slice params required by ih264d_start_of_pic to valid values
   1522                 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
   1523                 ps_dec->ps_cur_slice->u1_nal_ref_idc = 1;
   1524                 ps_dec->ps_cur_slice->u1_nal_unit_type = 1;
   1525                 ret = ih264d_start_of_pic(ps_dec, poc, ps_cur_poc,
   1526                         ps_dec->ps_cur_slice->u2_frame_num,
   1527                         &ps_dec->ps_pps[j]);
   1528 
   1529                 if(ret != OK)
   1530                 {
   1531                     return ret;
   1532                 }
   1533             }
   1534 
   1535             ps_dec->ps_ref_pic_buf_lx[0][0]->u1_pic_buf_id = 0;
   1536 
   1537             ps_dec->u4_output_present = 0;
   1538 
   1539             {
   1540                 ih264d_get_next_display_field(ps_dec,
   1541                                               ps_dec->ps_out_buffer,
   1542                                               &(ps_dec->s_disp_op));
   1543                 /* If error code is non-zero then there is no buffer available for display,
   1544                  hence avoid format conversion */
   1545 
   1546                 if(0 != ps_dec->s_disp_op.u4_error_code)
   1547                 {
   1548                     ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
   1549                 }
   1550                 else
   1551                     ps_dec->u4_output_present = 1;
   1552             }
   1553 
   1554             if(ps_dec->u1_separate_parse == 1)
   1555             {
   1556                 if(ps_dec->u4_dec_thread_created == 0)
   1557                 {
   1558                     ithread_create(ps_dec->pv_dec_thread_handle, NULL,
   1559                                    (void *)ih264d_decode_picture_thread,
   1560                                    (void *)ps_dec);
   1561 
   1562                     ps_dec->u4_dec_thread_created = 1;
   1563                 }
   1564 
   1565                 if((ps_dec->u4_num_cores == 3) &&
   1566                                 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag)
   1567                                 && (ps_dec->u4_bs_deblk_thread_created == 0))
   1568                 {
   1569                     ps_dec->u4_start_recon_deblk = 0;
   1570                     ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL,
   1571                                    (void *)ih264d_recon_deblk_thread,
   1572                                    (void *)ps_dec);
   1573                     ps_dec->u4_bs_deblk_thread_created = 1;
   1574                 }
   1575             }
   1576         }
   1577     }
   1578     else
   1579     {
   1580         // Middle / last slice
   1581 
   1582         dec_slice_struct_t *ps_parse_cur_slice;
   1583         ps_parse_cur_slice = ps_dec->ps_dec_slice_buf + ps_dec->u2_cur_slice_num;
   1584 
   1585         if(ps_dec->u1_slice_header_done
   1586             && ps_parse_cur_slice == ps_dec->ps_parse_cur_slice)
   1587         {
   1588             // Slice data corrupted
   1589             // in the case of mbaff, conceal from the even mb.
   1590             if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
   1591             {
   1592                 ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
   1593                 ps_dec->u2_cur_mb_addr--;
   1594             }
   1595 
   1596             u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
   1597             if(u1_num_mbs)
   1598             {
   1599                 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs - 1;
   1600             }
   1601             else
   1602             {
   1603                 if(ps_dec->u1_separate_parse)
   1604                 {
   1605                     ps_cur_mb_info = ps_dec->ps_nmb_info;
   1606                 }
   1607                 else
   1608                 {
   1609                     ps_cur_mb_info = ps_dec->ps_nmb_info
   1610                             + ps_dec->u4_num_mbs_prev_nmb - 1;
   1611                 }
   1612             }
   1613 
   1614             ps_dec->u2_mby = ps_cur_mb_info->u2_mby;
   1615             ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx;
   1616 
   1617             ps_dec->u1_mb_ngbr_availablity =
   1618                     ps_cur_mb_info->u1_mb_ngbr_availablity;
   1619 
   1620             if(u1_num_mbs)
   1621             {
   1622                 // Going back 1 mb
   1623                 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
   1624                 ps_dec->u2_cur_mb_addr--;
   1625                 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
   1626 
   1627                 // Parse/decode N-MB left unparsed
   1628                 if (ps_dec->u1_pr_sl_type == P_SLICE
   1629                         || ps_dec->u1_pr_sl_type == B_SLICE)
   1630                 {
   1631                     ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx,    u1_num_mbs);
   1632                     ps_dec->ps_part = ps_dec->ps_parse_part_params;
   1633                 }
   1634 
   1635                 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
   1636                 u1_end_of_row = (!u1_num_mbs_next)
   1637                         && (!(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (u1_num_mbs & 0x01)));
   1638                 u1_slice_end = 1;
   1639                 u1_tfr_n_mb = 1;
   1640                 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
   1641 
   1642                 if(ps_dec->u1_separate_parse)
   1643                 {
   1644                     ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
   1645                             u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
   1646                     ps_dec->ps_nmb_info += u1_num_mbs;
   1647                 }
   1648                 else
   1649                 {
   1650                     ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
   1651                             u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
   1652                 }
   1653                 ps_dec->u2_total_mbs_coded += u1_num_mbs;
   1654                 ps_dec->u1_mb_idx = 0;
   1655                 ps_dec->u4_num_mbs_cur_nmb = 0;
   1656             }
   1657 
   1658             if(ps_dec->u2_total_mbs_coded
   1659                     >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
   1660             {
   1661                 ps_dec->u1_pic_decode_done = 1;
   1662                 return 0;
   1663             }
   1664 
   1665             /* Inserting new slice only if the current slice has atleast 1 MB*/
   1666             if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
   1667                     (UWORD32)(ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
   1668             {
   1669                 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
   1670                 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
   1671                 ps_dec->u2_cur_slice_num++;
   1672                 ps_dec->ps_parse_cur_slice++;
   1673             }
   1674 
   1675         }
   1676         else
   1677         {
   1678             // Slice missing / header corrupted
   1679             ps_dec->ps_parse_cur_slice = ps_dec->ps_dec_slice_buf
   1680                                             + ps_dec->u2_cur_slice_num;
   1681         }
   1682     }
   1683 
   1684     /******************************************************/
   1685     /* Initializations to new slice                       */
   1686     /******************************************************/
   1687     {
   1688         WORD32 num_entries;
   1689         WORD32 size;
   1690         UWORD8 *pu1_buf;
   1691 
   1692         num_entries = MAX_FRAMES;
   1693         if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
   1694             (0 == ps_dec->i4_display_delay))
   1695         {
   1696             num_entries = 1;
   1697         }
   1698         num_entries = ((2 * num_entries) + 1);
   1699         num_entries *= 2;
   1700 
   1701         size = num_entries * sizeof(void *);
   1702         size += PAD_MAP_IDX_POC * sizeof(void *);
   1703 
   1704         pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf;
   1705         pu1_buf += size * ps_dec->u2_cur_slice_num;
   1706         ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf;
   1707     }
   1708     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
   1709     ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
   1710     ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
   1711     ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
   1712 
   1713     if(ps_dec->ps_cur_slice->u1_field_pic_flag)
   1714         ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
   1715 
   1716     ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
   1717     ps_dec->ps_parse_cur_slice->u2_log2Y_crwd =    ps_dec->ps_cur_slice->u2_log2Y_crwd;
   1718 
   1719 
   1720     if(ps_dec->u1_separate_parse)
   1721     {
   1722         ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
   1723     }
   1724     else
   1725     {
   1726         ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
   1727     }
   1728 
   1729     /******************************************************/
   1730     /* Initializations specific to P slice                */
   1731     /******************************************************/
   1732     u1_inter_mb_type = P_MB;
   1733     u1_deblk_mb_type = D_INTER_MB;
   1734 
   1735     ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
   1736     ps_dec->ps_parse_cur_slice->slice_type = P_SLICE;
   1737     ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
   1738     ps_dec->ps_part = ps_dec->ps_parse_part_params;
   1739     ps_dec->u2_mbx =
   1740                     (MOD(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
   1741     ps_dec->u2_mby =
   1742                     (DIV(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
   1743     ps_dec->u2_mby <<= u1_mbaff;
   1744 
   1745     /******************************************************/
   1746     /* Parsing / decoding the slice                       */
   1747     /******************************************************/
   1748     ps_dec->u1_slice_header_done = 2;
   1749     ps_dec->u1_qp = ps_slice->u1_slice_qp;
   1750     ih264d_update_qp(ps_dec, 0);
   1751     u1_mb_idx = ps_dec->u1_mb_idx;
   1752     ps_parse_mb_data = ps_dec->ps_parse_mb_data;
   1753     u1_num_mbs = u1_mb_idx;
   1754 
   1755     u1_slice_end = 0;
   1756     u1_tfr_n_mb = 0;
   1757     u1_decode_nmb = 0;
   1758     u1_num_mbsNby2 = 0;
   1759     i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
   1760     i2_mb_skip_run = num_mb_skip;
   1761 
   1762     while(!u1_slice_end)
   1763     {
   1764         UWORD8 u1_mb_type;
   1765 
   1766         if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
   1767             break;
   1768 
   1769         ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
   1770         ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
   1771 
   1772         ps_cur_mb_info->u1_Mux = 0;
   1773         ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
   1774         ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
   1775 
   1776         ps_cur_mb_info->u1_end_of_slice = 0;
   1777 
   1778         /* Storing Default partition info */
   1779         ps_parse_mb_data->u1_num_part = 1;
   1780         ps_parse_mb_data->u1_isI_mb = 0;
   1781 
   1782         /**************************************************************/
   1783         /* Get the required information for decoding of MB            */
   1784         /**************************************************************/
   1785         /* mb_x, mb_y, neighbor availablity, */
   1786         if (u1_mbaff)
   1787             ih264d_get_mb_info_cavlc_mbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
   1788         else
   1789             ih264d_get_mb_info_cavlc_nonmbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
   1790 
   1791         /* Set the deblocking parameters for this MB */
   1792         if(ps_dec->u4_app_disable_deblk_frm == 0)
   1793         {
   1794             ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
   1795                                              ps_dec->u1_mb_ngbr_availablity,
   1796                                              ps_dec->u1_cur_mb_fld_dec_flag);
   1797         }
   1798 
   1799         /* Set appropriate flags in ps_cur_mb_info and ps_dec */
   1800         ps_dec->i1_prev_mb_qp_delta = 0;
   1801         ps_dec->u1_sub_mb_num = 0;
   1802         ps_cur_mb_info->u1_mb_type = MB_SKIP;
   1803         ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
   1804         ps_cur_mb_info->u1_cbp = 0;
   1805 
   1806         /* Storing Skip partition info */
   1807         ps_part_info = ps_dec->ps_part;
   1808         ps_part_info->u1_is_direct = PART_DIRECT_16x16;
   1809         ps_part_info->u1_sub_mb_num = 0;
   1810         ps_dec->ps_part++;
   1811 
   1812         /* Update Nnzs */
   1813         ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
   1814 
   1815         ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
   1816         ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
   1817 
   1818         i2_mb_skip_run--;
   1819 
   1820         ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
   1821 
   1822         if (u1_mbaff)
   1823         {
   1824             ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
   1825         }
   1826 
   1827         /**************************************************************/
   1828         /* Get next Macroblock address                                */
   1829         /**************************************************************/
   1830         i2_cur_mb_addr++;
   1831 
   1832         u1_num_mbs++;
   1833         u1_num_mbsNby2++;
   1834         ps_parse_mb_data++;
   1835 
   1836         /****************************************************************/
   1837         /* Check for End Of Row and other flags that determine when to  */
   1838         /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for   */
   1839         /* N-Mb                                                         */
   1840         /****************************************************************/
   1841         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
   1842         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
   1843         u1_slice_end = !i2_mb_skip_run;
   1844         u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
   1845                         || u1_slice_end;
   1846         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
   1847         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
   1848 
   1849         if(u1_decode_nmb)
   1850         {
   1851             ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
   1852             u1_num_mbsNby2 = 0;
   1853 
   1854             ps_parse_mb_data = ps_dec->ps_parse_mb_data;
   1855             ps_dec->ps_part = ps_dec->ps_parse_part_params;
   1856 
   1857             if(ps_dec->u1_separate_parse)
   1858             {
   1859                 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
   1860                                      u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
   1861                 ps_dec->ps_nmb_info +=  u1_num_mbs;
   1862             }
   1863             else
   1864             {
   1865                 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
   1866                                             u1_tfr_n_mb, u1_end_of_row);
   1867             }
   1868             ps_dec->u2_total_mbs_coded += u1_num_mbs;
   1869             if(u1_tfr_n_mb)
   1870                 u1_num_mbs = 0;
   1871             u1_mb_idx = u1_num_mbs;
   1872             ps_dec->u1_mb_idx = u1_num_mbs;
   1873         }
   1874     }
   1875 
   1876     ps_dec->u4_num_mbs_cur_nmb = 0;
   1877     ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
   1878                         - ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice;
   1879 
   1880     H264_DEC_DEBUG_PRINT("Mbs in slice: %d\n", ps_dec->ps_cur_slice->u4_mbs_in_slice);
   1881 
   1882 
   1883     /* incremented here only if first slice is inserted */
   1884     if(ps_dec->u4_first_slice_in_pic != 0)
   1885     {
   1886         ps_dec->ps_parse_cur_slice++;
   1887         ps_dec->u2_cur_slice_num++;
   1888     }
   1889 
   1890     ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
   1891     ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
   1892 
   1893     if(ps_dec->u2_total_mbs_coded
   1894             >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
   1895     {
   1896         ps_dec->u1_pic_decode_done = 1;
   1897     }
   1898 
   1899     return 0;
   1900 
   1901 }
   1902 
   1903 /*!
   1904  **************************************************************************
   1905  * \if Function name : ih264d_decode_pslice \endif
   1906  *
   1907  * \brief
   1908  *    Decodes a P Slice
   1909  *
   1910  *
   1911  * \return
   1912  *    0 on Success and Error code otherwise
   1913  **************************************************************************
   1914  */
   1915 WORD32 ih264d_parse_pslice(dec_struct_t *ps_dec, UWORD16 u2_first_mb_in_slice)
   1916 {
   1917     dec_pic_params_t * ps_pps = ps_dec->ps_cur_pps;
   1918     dec_slice_params_t * ps_cur_slice = ps_dec->ps_cur_slice;
   1919     dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
   1920     UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
   1921     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
   1922     UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; //ps_dec->ps_cur_sps->u1_mb_aff_flag;
   1923     UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
   1924 
   1925     UWORD32 u4_temp;
   1926     WORD32 i_temp;
   1927     WORD32 ret;
   1928 
   1929     /*--------------------------------------------------------------------*/
   1930     /* Read remaining contents of the slice header                        */
   1931     /*--------------------------------------------------------------------*/
   1932     {
   1933         WORD8 *pi1_buf;
   1934         WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv;
   1935         WORD32 *pi4_mv = (WORD32*)pi2_mv;
   1936         WORD16 *pi16_refFrame;
   1937 
   1938         pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame;
   1939         pi16_refFrame = (WORD16*)pi1_buf;
   1940         *pi4_mv = 0;
   1941         *(pi4_mv + 1) = 0;
   1942         *pi16_refFrame = OUT_OF_RANGE_REF;
   1943         ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8)-1;
   1944         ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8)-1;
   1945     }
   1946 
   1947     ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264(
   1948                     ps_bitstrm);
   1949 
   1950     COPYTHECONTEXT("SH: num_ref_idx_override_flag",
   1951                     ps_cur_slice->u1_num_ref_idx_active_override_flag);
   1952 
   1953     u4_temp = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0];
   1954     if(ps_cur_slice->u1_num_ref_idx_active_override_flag)
   1955     {
   1956         u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + 1;
   1957     }
   1958 
   1959     {
   1960 
   1961 
   1962 
   1963         UWORD8 u1_max_ref_idx = MAX_FRAMES << u1_field_pic_flag;
   1964         if(u4_temp > u1_max_ref_idx || u4_temp < 1)
   1965         {
   1966             return ERROR_NUM_REF;
   1967         }
   1968         ps_cur_slice->u1_num_ref_idx_lx_active[0] = u4_temp;
   1969         COPYTHECONTEXT("SH: num_ref_idx_l0_active_minus1",
   1970                         ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1);
   1971 
   1972     }
   1973 
   1974     {
   1975         UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm);
   1976         COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_l0",uc_refIdxReFlagL0);
   1977 
   1978         ih264d_init_ref_idx_lx_p(ps_dec);
   1979         /* Store the value for future slices in the same picture */
   1980         ps_dec->u1_num_ref_idx_lx_active_prev =
   1981                         ps_cur_slice->u1_num_ref_idx_lx_active[0];
   1982 
   1983         /* Modified temporarily */
   1984         if(uc_refIdxReFlagL0)
   1985         {
   1986             WORD8 ret;
   1987             ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
   1988             ret = ih264d_ref_idx_reordering(ps_dec, 0);
   1989             if(ret == -1)
   1990                 return ERROR_REFIDX_ORDER_T;
   1991             ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
   1992         }
   1993         else
   1994             ps_dec->ps_ref_pic_buf_lx[0] =
   1995                             ps_dec->ps_dpb_mgr->ps_init_dpb[0];
   1996     }
   1997     /* Create refIdx to POC mapping */
   1998     {
   1999         void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1;
   2000         WORD8 idx;
   2001         struct pic_buffer_t *ps_pic;
   2002 
   2003         pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0;
   2004         pui_map_ref_idx_to_poc_lx0[0] = 0; //For ref_idx = -1
   2005         pui_map_ref_idx_to_poc_lx0++;
   2006         for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
   2007         {
   2008             ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
   2009             pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1);
   2010         }
   2011 
   2012         /* Bug Fix Deblocking */
   2013         pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1;
   2014         pui_map_ref_idx_to_poc_lx1[0] = 0;
   2015 
   2016         if(u1_mbaff)
   2017         {
   2018             void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b;
   2019             void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1;
   2020             ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc
   2021                             + TOP_LIST_FLD_L0;
   2022             ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc
   2023                             + BOT_LIST_FLD_L0;
   2024 
   2025             ppv_map_ref_idx_to_poc_lx_t[0] = 0; //  For ref_idx = -1
   2026             ppv_map_ref_idx_to_poc_lx_t++;
   2027             ppv_map_ref_idx_to_poc_lx_b[0] = 0; // For ref_idx = -1
   2028             ppv_map_ref_idx_to_poc_lx_b++;
   2029 
   2030             idx = 0;
   2031             for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
   2032             {
   2033                 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
   2034                 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1);
   2035                 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1);
   2036 
   2037                 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1;
   2038                 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1;
   2039 
   2040                 ppv_map_ref_idx_to_poc_lx_t += 2;
   2041                 ppv_map_ref_idx_to_poc_lx_b += 2;
   2042             }
   2043             ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc
   2044                             + TOP_LIST_FLD_L1;
   2045             ppv_map_ref_idx_to_poc_lx_t1[0] = 0;
   2046             ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc
   2047                             + BOT_LIST_FLD_L1;
   2048             ppv_map_ref_idx_to_poc_lx_b1[0] = 0;
   2049 
   2050         }
   2051 
   2052         if(ps_dec->u4_num_cores >= 3)
   2053         {
   2054             WORD32 num_entries;
   2055             WORD32 size;
   2056 
   2057             num_entries = MAX_FRAMES;
   2058             if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
   2059                 (0 == ps_dec->i4_display_delay))
   2060             {
   2061                 num_entries = 1;
   2062             }
   2063             num_entries = ((2 * num_entries) + 1);
   2064             num_entries *= 2;
   2065 
   2066             size = num_entries * sizeof(void *);
   2067             size += PAD_MAP_IDX_POC * sizeof(void *);
   2068 
   2069             memcpy((void *)ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc,
   2070                    ps_dec->ppv_map_ref_idx_to_poc,
   2071                    size);
   2072         }
   2073 
   2074 
   2075     }
   2076     if(ps_pps->u1_wted_pred_flag)
   2077     {
   2078         ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm);
   2079         if(ret != OK)
   2080             return ret;
   2081         ih264d_form_pred_weight_matrix(ps_dec);
   2082         ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
   2083     }
   2084     else
   2085     {
   2086         ps_dec->ps_cur_slice->u2_log2Y_crwd = 0;
   2087         ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
   2088     }
   2089 
   2090     ps_dec->ps_parse_cur_slice->u2_log2Y_crwd =
   2091                     ps_dec->ps_cur_slice->u2_log2Y_crwd;
   2092 
   2093     if(u1_mbaff && (u1_field_pic_flag == 0))
   2094     {
   2095         ih264d_convert_frm_mbaff_list(ps_dec);
   2096     }
   2097 
   2098     /* G050 */
   2099     if(ps_cur_slice->u1_nal_ref_idc != 0)
   2100     {
   2101         if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
   2102         {
   2103             i_temp = ih264d_read_mmco_commands(ps_dec);
   2104             if (i_temp < 0)
   2105             {
   2106                 return ERROR_DBP_MANAGER_T;
   2107             }
   2108             ps_dec->u4_bitoffset = i_temp;
   2109         }
   2110         else
   2111             ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset;
   2112 
   2113     }
   2114     /* G050 */
   2115 
   2116     if(ps_pps->u1_entropy_coding_mode == CABAC)
   2117     {
   2118         u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
   2119 
   2120         if(u4_temp > MAX_CABAC_INIT_IDC)
   2121         {
   2122             return ERROR_INV_SLICE_HDR_T;
   2123         }
   2124         ps_cur_slice->u1_cabac_init_idc = u4_temp;
   2125         COPYTHECONTEXT("SH: cabac_init_idc",ps_cur_slice->u1_cabac_init_idc);
   2126     }
   2127 
   2128     /* Read slice_qp_delta */
   2129     i_temp = ps_pps->u1_pic_init_qp
   2130                     + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
   2131     if((i_temp < 0) || (i_temp > 51))
   2132     {
   2133         return ERROR_INV_RANGE_QP_T;
   2134     }
   2135     ps_cur_slice->u1_slice_qp = i_temp;
   2136     COPYTHECONTEXT("SH: slice_qp_delta",
   2137                     (WORD8)(ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp));
   2138 
   2139     if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1)
   2140     {
   2141         u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
   2142         if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED)
   2143         {
   2144             return ERROR_INV_SLICE_HDR_T;
   2145         }
   2146 
   2147         COPYTHECONTEXT("SH: disable_deblocking_filter_idc", u4_temp);
   2148         ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp;
   2149         if(u4_temp != 1)
   2150         {
   2151             i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
   2152                             << 1;
   2153             if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
   2154             {
   2155                 return ERROR_INV_SLICE_HDR_T;
   2156             }
   2157             ps_cur_slice->i1_slice_alpha_c0_offset = i_temp;
   2158             COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2",
   2159                             ps_cur_slice->i1_slice_alpha_c0_offset >> 1);
   2160 
   2161             i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
   2162                             << 1;
   2163             if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
   2164             {
   2165                 return ERROR_INV_SLICE_HDR_T;
   2166             }
   2167             ps_cur_slice->i1_slice_beta_offset = i_temp;
   2168             COPYTHECONTEXT("SH: slice_beta_offset_div2",
   2169                             ps_cur_slice->i1_slice_beta_offset >> 1);
   2170         }
   2171         else
   2172         {
   2173             ps_cur_slice->i1_slice_alpha_c0_offset = 0;
   2174             ps_cur_slice->i1_slice_beta_offset = 0;
   2175         }
   2176     }
   2177     else
   2178     {
   2179         ps_cur_slice->u1_disable_dblk_filter_idc = 0;
   2180         ps_cur_slice->i1_slice_alpha_c0_offset = 0;
   2181         ps_cur_slice->i1_slice_beta_offset = 0;
   2182     }
   2183 
   2184     ps_dec->u1_slice_header_done = 2;
   2185 
   2186     if(ps_pps->u1_entropy_coding_mode)
   2187     {
   2188         SWITCHOFFTRACE; SWITCHONTRACECABAC;
   2189         ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac;
   2190         ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cabac;
   2191         ih264d_init_cabac_contexts(P_SLICE, ps_dec);
   2192 
   2193         if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
   2194             ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff;
   2195         else
   2196             ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff;
   2197     }
   2198     else
   2199     {
   2200         SWITCHONTRACE; SWITCHOFFTRACECABAC;
   2201         ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc;
   2202         ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cavlc;
   2203         if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
   2204         {
   2205             ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff;
   2206         }
   2207         else
   2208             ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff;
   2209     }
   2210 
   2211     ps_dec->u1_B = 0;
   2212     ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
   2213     ret = ps_dec->pf_parse_inter_slice(ps_dec, ps_cur_slice, u2_first_mb_in_slice);
   2214     if(ret != OK)
   2215         return ret;
   2216 //    ps_dec->curr_slice_in_error = 0 ;
   2217     return OK;
   2218 }
   2219