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  * \file ih264d_process_pslice.c
     23  *
     24  * \brief
     25  *    Contains routines that decode a I slice type
     26  *
     27  * Detailed_description
     28  *
     29  * \date
     30  *    21/12/2002
     31  *
     32  * \author  NS
     33  **************************************************************************
     34  */
     35 #include "ih264_typedefs.h"
     36 #include "ih264_macros.h"
     37 #include "ih264_platform_macros.h"
     38 
     39 #include <string.h>
     40 #include "ih264d_bitstrm.h"
     41 #include "ih264d_defs.h"
     42 #include "ih264d_debug.h"
     43 #include "ih264d_structs.h"
     44 #include "ih264d_defs.h"
     45 #include "ih264d_parse_cavlc.h"
     46 #include "ih264d_mb_utils.h"
     47 #include "ih264d_deblocking.h"
     48 #include "ih264d_dpb_manager.h"
     49 #include "ih264d_mvpred.h"
     50 #include "ih264d_inter_pred.h"
     51 #include "ih264d_process_pslice.h"
     52 #include "ih264d_error_handler.h"
     53 #include "ih264d_cabac.h"
     54 #include "ih264d_debug.h"
     55 #include "ih264d_tables.h"
     56 #include "ih264d_parse_slice.h"
     57 #include "ih264d_utils.h"
     58 #include "ih264d_parse_islice.h"
     59 #include "ih264d_process_bslice.h"
     60 #include "ih264d_process_intra_mb.h"
     61 
     62 void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
     63 
     64 void ih264d_insert_pic_in_ref_pic_listx(struct pic_buffer_t *ps_ref_pic_buf_lx,
     65                                         struct pic_buffer_t *ps_pic)
     66 {
     67     *ps_ref_pic_buf_lx = *ps_pic;
     68 }
     69 
     70 WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
     71                                      UWORD8 u1_mb_idx,
     72                                      UWORD8 u1_num_mbs)
     73 {
     74     parse_pmbarams_t * ps_mb_part_info;
     75     parse_part_params_t * ps_part;
     76     mv_pred_t *ps_mv_nmb, *ps_mv_nmb_start, *ps_mv_ntop, *ps_mv_ntop_start;
     77     UWORD32 i, j;
     78     const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     79     dec_mb_info_t * ps_cur_mb_info;
     80     WORD32 i2_mv_x, i2_mv_y;
     81     WORD32 ret;
     82 
     83     ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
     84     ps_mb_part_info = ps_dec->ps_parse_mb_data; // + u1_mb_idx;
     85     ps_part = ps_dec->ps_parse_part_params; // + u1_mb_idx;
     86 
     87     /* N/2 Mb MvPred and Transfer Setup Loop */
     88     for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
     89     {
     90         UWORD32 u1_colz;
     91         UWORD32 u1_field;
     92         mv_pred_t s_mvPred;
     93         mv_pred_t *ps_mv_pred = &s_mvPred;
     94 
     95 
     96 
     97         *ps_mv_pred = ps_dec->s_default_mv_pred;
     98 
     99         ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
    100 
    101         /* Restore the slice scratch MbX and MbY context */
    102         ps_cur_mb_info = ps_dec->ps_nmb_info + i;
    103         u1_field = ps_cur_mb_info->u1_mb_field_decodingflag;
    104 
    105 
    106 
    107         ps_mv_nmb_start = ps_dec->ps_mv_cur + (i << 4);
    108         ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx;
    109         ps_dec->u2_mby = ps_cur_mb_info->u2_mby;
    110         ps_dec->u2_mv_2mb[i & 0x1] = 0;
    111 
    112         /* Look for MV Prediction and Reference Transfer in Non-I Mbs */
    113         if(!ps_mb_part_info->u1_isI_mb)
    114         {
    115             UWORD32 u1_blk_no;
    116             WORD32 i1_ref_idx, i1_ref_idx1;
    117             UWORD32 u1_sub_mb_x, u1_sub_mb_y, u1_sub_mb_num;
    118             UWORD32 u1_num_part, u1_num_ref, u1_wd, u1_ht;
    119             UWORD32 *pu4_wt_offst, **ppu4_wt_ofst;
    120             UWORD32 u1_scale_ref, u4_bot_mb;
    121             WORD8 *pi1_ref_idx = ps_mb_part_info->i1_ref_idx[0];
    122             pic_buffer_t *ps_ref_frame, **pps_ref_frame;
    123             deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + i;
    124 
    125             /* MB Level initialisations */
    126             ps_dec->u4_num_pmbair = i >> u1_mbaff;
    127             ps_dec->u1_mb_idx_mv = i;
    128             ppu4_wt_ofst = ps_mb_part_info->pu4_wt_offst;
    129             pps_ref_frame = ps_dec->ps_ref_pic_buf_lx[0];
    130             /* CHANGED CODE */
    131             ps_mv_ntop_start = ps_mv_nmb_start
    132                             - (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12;
    133 
    134             u1_num_part = ps_mb_part_info->u1_num_part;
    135             ps_cur_deblk_mb->u1_mb_type |= (u1_num_part > 1) << 1;
    136             ps_cur_mb_info->u4_pred_info_pkd_idx = ps_dec->u4_pred_info_pkd_idx;
    137             ps_cur_mb_info->u1_num_pred_parts = 0;
    138 
    139 
    140             /****************************************************/
    141             /* weighted u4_ofst pointer calculations, this loop  */
    142             /* runs maximum 4 times, even in direct cases       */
    143             /****************************************************/
    144             u1_scale_ref = u1_mbaff & u1_field;
    145 
    146             u4_bot_mb = 1 - ps_cur_mb_info->u1_topmb;
    147             if(ps_dec->ps_cur_pps->u1_wted_pred_flag)
    148             {
    149                 u1_num_ref = MIN(u1_num_part, 4);
    150                 for(u1_blk_no = 0; u1_blk_no < u1_num_ref; u1_blk_no++)
    151                 {
    152                     i1_ref_idx = pi1_ref_idx[u1_blk_no];
    153                     if(u1_scale_ref)
    154                         i1_ref_idx >>= 1;
    155                     pu4_wt_offst = (UWORD32*)&ps_dec->pu4_wt_ofsts[2
    156                                     * X3(i1_ref_idx)];
    157                     ppu4_wt_ofst[u1_blk_no] = pu4_wt_offst;
    158                 }
    159             }
    160             else
    161             {
    162                 ppu4_wt_ofst[0] = NULL;
    163                 ppu4_wt_ofst[1] = NULL;
    164                 ppu4_wt_ofst[2] = NULL;
    165                 ppu4_wt_ofst[3] = NULL;
    166             }
    167 
    168             /**************************************************/
    169             /* Loop on Partitions                             */
    170             /**************************************************/
    171             for(j = 0; j < u1_num_part; j++, ps_part++)
    172             {
    173 
    174                 u1_sub_mb_num = ps_part->u1_sub_mb_num;
    175                 ps_dec->u1_sub_mb_num = u1_sub_mb_num;
    176 
    177                 if(PART_NOT_DIRECT != ps_part->u1_is_direct)
    178                 {
    179                     /* Mb Skip Mode */
    180                     /* Setting the default and other members of MvPred Structure */
    181                     s_mvPred.i2_mv[2] = -1;
    182                     s_mvPred.i2_mv[3] = -1;
    183                     s_mvPred.i1_ref_frame[0] = 0;
    184                     i1_ref_idx = (u1_scale_ref && u4_bot_mb) ? MAX_REF_BUFS : 0;
    185                     ps_ref_frame = pps_ref_frame[i1_ref_idx];
    186                     s_mvPred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id;
    187                     s_mvPred.u1_pic_type = ps_ref_frame->u1_pic_type;
    188                     pu4_wt_offst = (UWORD32*)&ps_dec->pu4_wt_ofsts[0];
    189 
    190                     ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, ps_mv_nmb_start,
    191                                       ps_mv_ntop_start, &s_mvPred, 0, 4, 0, 1,
    192                                       MB_SKIP);
    193 
    194 
    195 
    196 
    197 
    198 
    199                     {
    200                         pred_info_pkd_t *ps_pred_pkd;
    201                         ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
    202                     ih264d_fill_pred_info (s_mvPred.i2_mv,4,4,0,PRED_L0,ps_pred_pkd,ps_ref_frame->u1_pic_buf_id,
    203                                            (i1_ref_idx >> u1_scale_ref),pu4_wt_offst,
    204                                            ps_ref_frame->u1_pic_type);
    205 
    206 
    207                     ps_dec->u4_pred_info_pkd_idx++;
    208                     ps_cur_mb_info->u1_num_pred_parts++;
    209                     }
    210 
    211 
    212 
    213                     /* Storing colocated zero information */
    214                     u1_colz = ((ABS(s_mvPred.i2_mv[0]) <= 1)
    215                                     && (ABS(s_mvPred.i2_mv[1]) <= 1))
    216                                     + (u1_field << 1);
    217 
    218                     ih264d_rep_mv_colz(ps_dec, &s_mvPred, ps_mv_nmb_start, 0,
    219                                        u1_colz, 4, 4);
    220                 }
    221                 else
    222                 {
    223                     u1_sub_mb_x = u1_sub_mb_num & 0x03;
    224                     u1_sub_mb_y = u1_sub_mb_num >> 2;
    225                     u1_blk_no =
    226                                     (u1_num_part < 4) ?
    227                                                     j :
    228                                                     (((u1_sub_mb_y >> 1) << 1)
    229                                                                     + (u1_sub_mb_x
    230                                                                                     >> 1));
    231 
    232                     ps_mv_ntop = ps_mv_ntop_start + u1_sub_mb_x;
    233                     ps_mv_nmb = ps_mv_nmb_start + u1_sub_mb_num;
    234 
    235                     u1_wd = ps_part->u1_partwidth;
    236                     u1_ht = ps_part->u1_partheight;
    237 
    238                     /* Populate the colpic info and reference frames */
    239                     i1_ref_idx = pi1_ref_idx[u1_blk_no];
    240                     s_mvPred.i1_ref_frame[0] = i1_ref_idx;
    241 
    242                     /********************************************************/
    243                     /* Predict Mv                                           */
    244                     /* Add Mv Residuals and store back                      */
    245                     /********************************************************/
    246                     ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, ps_mv_nmb, ps_mv_ntop,
    247                                       &s_mvPred, u1_sub_mb_num, u1_wd, 0, 1,
    248                                       ps_cur_mb_info->u1_mb_mc_mode);
    249                     i2_mv_x = ps_mv_nmb->i2_mv[0];
    250                     i2_mv_y = ps_mv_nmb->i2_mv[1];
    251                     i2_mv_x += s_mvPred.i2_mv[0];
    252                     i2_mv_y += s_mvPred.i2_mv[1];
    253                     s_mvPred.i2_mv[0] = i2_mv_x;
    254                     s_mvPred.i2_mv[1] = i2_mv_y;
    255 
    256                     /********************************************************/
    257                     /* Transfer setup call                                  */
    258                     /* convert RefIdx if it is MbAff                        */
    259                     /* Pass Weight Offset and refFrame                      */
    260                     /********************************************************/
    261                     i1_ref_idx1 = i1_ref_idx >> u1_scale_ref;
    262                     if(u1_scale_ref && ((i1_ref_idx & 0x01) != u4_bot_mb))
    263                         i1_ref_idx1 += MAX_REF_BUFS;
    264                     ps_ref_frame = pps_ref_frame[i1_ref_idx1];
    265                     pu4_wt_offst = ppu4_wt_ofst[u1_blk_no];
    266 
    267 
    268 
    269 
    270 
    271 
    272                     {
    273                     pred_info_pkd_t *ps_pred_pkd;
    274                     ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
    275                     ih264d_fill_pred_info (s_mvPred.i2_mv,u1_wd,u1_ht,u1_sub_mb_num,PRED_L0,ps_pred_pkd,
    276                                            ps_ref_frame->u1_pic_buf_id,(i1_ref_idx >> u1_scale_ref),pu4_wt_offst,
    277                                            ps_ref_frame->u1_pic_type);
    278 
    279                     ps_dec->u4_pred_info_pkd_idx++;
    280                     ps_cur_mb_info->u1_num_pred_parts++;
    281                     }
    282 
    283 
    284 
    285                     /* Fill colocated info in MvPred structure */
    286                     s_mvPred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id;
    287                     s_mvPred.u1_pic_type = ps_ref_frame->u1_pic_type;
    288 
    289                     /* Calculating colocated zero information */
    290                     u1_colz =
    291                                     (u1_field << 1)
    292                                                     | ((i1_ref_idx == 0)
    293                                                                     && (ABS(i2_mv_x)
    294                                                                                     <= 1)
    295                                                                     && (ABS(i2_mv_y)
    296                                                                                     <= 1));
    297                     u1_colz |= ps_mb_part_info->u1_col_info[u1_blk_no];
    298 
    299                     /* Replicate the motion vectors and colzero u4_flag  */
    300                     /* for all sub-partitions                         */
    301 
    302                     ih264d_rep_mv_colz(ps_dec, &s_mvPred, ps_mv_nmb,
    303                                        u1_sub_mb_num, u1_colz, u1_ht,
    304                                        u1_wd);
    305                 }
    306             }
    307 
    308         }
    309         else
    310         {
    311             /* Storing colocated zero information */
    312             ih264d_rep_mv_colz(ps_dec, &s_mvPred, ps_mv_nmb_start, 0,
    313                                (UWORD8)(u1_field << 1), 4, 4);
    314 
    315         }
    316         /*if num _cores is set to 3,compute bs will be done in another thread*/
    317         if(ps_dec->u4_num_cores < 3)
    318         {
    319 
    320             if(ps_dec->u4_app_disable_deblk_frm == 0)
    321                 ps_dec->pf_compute_bs(ps_dec, ps_cur_mb_info,
    322                                      (UWORD16)(i >> u1_mbaff));
    323         }
    324     }
    325 
    326 
    327 
    328     return OK;
    329 }
    330 
    331 
    332 WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
    333                                    UWORD8 u1_mb_idx,
    334                                    UWORD8 u1_num_mbs,
    335                                    UWORD8 u1_num_mbs_next,
    336                                    UWORD8 u1_tfr_n_mb,
    337                                    UWORD8 u1_end_of_row)
    338 {
    339     WORD32 i,j;
    340     UWORD32 u1_end_of_row_next;
    341     dec_mb_info_t * ps_cur_mb_info;
    342     UWORD32 u4_update_mbaff = 0;
    343     WORD32 ret;
    344     const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
    345     const UWORD32 u1_slice_type = ps_dec->ps_cur_slice->u1_slice_type;
    346     const WORD32 u1_skip_th = (
    347                     (u1_slice_type != I_SLICE) ?
    348                                     (ps_dec->u1_B ? B_8x8 : PRED_8x8R0) : -1);
    349     const UWORD32 u1_ipcm_th = (
    350                     (u1_slice_type != I_SLICE) ? (ps_dec->u1_B ? 23 : 5) : 0);
    351 
    352 
    353 
    354 
    355 
    356     /* N Mb MC Loop */
    357     for(i = u1_mb_idx; i < u1_num_mbs; i++)
    358     {
    359         ps_cur_mb_info = ps_dec->ps_nmb_info + i;
    360         ps_dec->u4_dma_buf_idx = 0;
    361         ps_dec->u4_pred_info_idx = 0;
    362 
    363         if(ps_cur_mb_info->u1_mb_type <= u1_skip_th)
    364         {
    365             {
    366                 WORD32 pred_cnt = 0;
    367                 pred_info_pkd_t *ps_pred_pkd;
    368                 UWORD32 u4_pred_info_pkd_idx;
    369                 WORD8 i1_pred;
    370 
    371                 u4_pred_info_pkd_idx = ps_cur_mb_info->u4_pred_info_pkd_idx;
    372 
    373                 while(pred_cnt < ps_cur_mb_info->u1_num_pred_parts)
    374                 {
    375 
    376                     ps_pred_pkd = ps_dec->ps_pred_pkd + u4_pred_info_pkd_idx;
    377 
    378                      ps_dec->p_form_mb_part_info(ps_pred_pkd,ps_dec,
    379                                                ps_cur_mb_info->u2_mbx,ps_cur_mb_info->u2_mby,(i >> u1_mbaff),
    380                                          ps_cur_mb_info);
    381                     u4_pred_info_pkd_idx++;
    382                     pred_cnt++;
    383                 }
    384             }
    385 
    386             ps_dec->p_motion_compensate(ps_dec, ps_cur_mb_info);
    387 
    388         }
    389         else if(ps_cur_mb_info->u1_mb_type == MB_SKIP)
    390         {
    391             {
    392                 WORD32 pred_cnt = 0;
    393                 pred_info_pkd_t *ps_pred_pkd;
    394                 UWORD32 u4_pred_info_pkd_idx;
    395                 WORD8 i1_pred;
    396 
    397                 u4_pred_info_pkd_idx = ps_cur_mb_info->u4_pred_info_pkd_idx;
    398 
    399                 while(pred_cnt < ps_cur_mb_info->u1_num_pred_parts)
    400                 {
    401 
    402                     ps_pred_pkd = ps_dec->ps_pred_pkd + u4_pred_info_pkd_idx;
    403 
    404                     ps_dec->p_form_mb_part_info(ps_pred_pkd,ps_dec,
    405                                                ps_cur_mb_info->u2_mbx,ps_cur_mb_info->u2_mby,(i >> u1_mbaff),
    406                                          ps_cur_mb_info);
    407 
    408                     u4_pred_info_pkd_idx++;
    409                     pred_cnt++;
    410                 }
    411             }
    412             /* Decode MB skip */
    413             ps_dec->p_motion_compensate(ps_dec, ps_cur_mb_info);
    414 
    415         }
    416 
    417      }
    418 
    419 
    420     /* N Mb IQ IT RECON  Loop */
    421     for(j = u1_mb_idx; j < i; j++)
    422     {
    423         ps_cur_mb_info = ps_dec->ps_nmb_info + j;
    424 
    425         if(ps_cur_mb_info->u1_mb_type <= u1_skip_th)
    426         {
    427             ih264d_process_inter_mb(ps_dec, ps_cur_mb_info, j);
    428 
    429         }
    430         else if(ps_cur_mb_info->u1_mb_type != MB_SKIP)
    431         {
    432             if((u1_ipcm_th + 25) != ps_cur_mb_info->u1_mb_type)
    433             {
    434                 ps_cur_mb_info->u1_mb_type -= (u1_skip_th + 1);
    435                 ih264d_process_intra_mb(ps_dec, ps_cur_mb_info, j);
    436             }
    437         }
    438 
    439 
    440         if(ps_dec->u4_use_intrapred_line_copy)
    441         {
    442             ih264d_copy_intra_pred_line(ps_dec, ps_cur_mb_info, j);
    443         }
    444 
    445     }
    446 
    447     /*N MB deblocking*/
    448     if(ps_dec->u4_nmb_deblk == 1)
    449     {
    450 
    451         UWORD32 u4_cur_mb, u4_right_mb;
    452         UWORD32 u4_mb_x, u4_mb_y;
    453         UWORD32 u4_wd_y, u4_wd_uv;
    454         tfr_ctxt_t *ps_tfr_cxt = &(ps_dec->s_tran_addrecon);
    455         UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag;
    456         const WORD32 i4_cb_qp_idx_ofst =
    457                        ps_dec->ps_cur_pps->i1_chroma_qp_index_offset;
    458         const WORD32 i4_cr_qp_idx_ofst =
    459                        ps_dec->ps_cur_pps->i1_second_chroma_qp_index_offset;
    460 
    461         u4_wd_y = ps_dec->u2_frm_wd_y << u1_field_pic_flag;
    462         u4_wd_uv = ps_dec->u2_frm_wd_uv << u1_field_pic_flag;
    463 
    464 
    465         ps_cur_mb_info = ps_dec->ps_nmb_info + u1_mb_idx;
    466 
    467         ps_dec->u4_deblk_mb_x = ps_cur_mb_info->u2_mbx;
    468         ps_dec->u4_deblk_mb_y = ps_cur_mb_info->u2_mby;
    469 
    470         for(j = u1_mb_idx; j < i; j++)
    471         {
    472 
    473             ih264d_deblock_mb_nonmbaff(ps_dec, ps_tfr_cxt,
    474                                        i4_cb_qp_idx_ofst, i4_cr_qp_idx_ofst,
    475                                         u4_wd_y, u4_wd_uv);
    476 
    477 
    478         }
    479 
    480 
    481 
    482     }
    483 
    484 
    485 
    486     if(u1_tfr_n_mb)
    487     {
    488         /****************************************************************/
    489         /* Check for End Of Row in Next iteration                       */
    490         /****************************************************************/
    491         u1_end_of_row_next =
    492                         u1_num_mbs_next
    493                                         && (u1_num_mbs_next
    494                                                         <= (ps_dec->u1_recon_mb_grp
    495                                                                         >> u1_mbaff));
    496 
    497         /****************************************************************/
    498         /* Transfer the Following things                                */
    499         /* N-Mb DeblkParams Data    ( To Ext DeblkParams Buffer )       */
    500         /* N-Mb Recon Data          ( To Ext Frame Buffer )             */
    501         /* N-Mb Intrapredline Data  ( Updated Internally)               */
    502         /* N-Mb MV Data             ( To Ext MV Buffer )                */
    503         /* N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers)    */
    504         /****************************************************************/
    505         ih264d_transfer_mb_group_data(ps_dec, u1_num_mbs, u1_end_of_row,
    506                                       u1_end_of_row_next);
    507         ps_dec->u4_num_mbs_prev_nmb = u1_num_mbs;
    508 
    509         ps_dec->u4_pred_info_idx = 0;
    510         ps_dec->u4_dma_buf_idx = 0;
    511 
    512 
    513     }
    514     return OK;
    515 }
    516 
    517 /*!
    518  **************************************************************************
    519  * \if Function name : ih264d_process_inter_mb \endif
    520  *
    521  * \brief
    522  *    This function decodes an Inter MB.
    523  *
    524  *
    525  * \return
    526  *    0 on Success and Error code otherwise
    527  **************************************************************************
    528  */
    529 WORD32 ih264d_process_inter_mb(dec_struct_t * ps_dec,
    530                                dec_mb_info_t * ps_cur_mb_info,
    531                                UWORD8 u1_mb_num)
    532 {
    533     /* CHANGED CODE */
    534     UWORD8 *pu1_rec_y, *pu1_rec_u, *pu1_rec_v;
    535 
    536     /*CHANGED CODE */
    537     UWORD32 ui_rec_width, u4_recwidth_cr;
    538     WORD16 *pi2_y_coeff;
    539     UWORD32 u1_mb_field_decoding_flag;
    540     const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
    541     UWORD32 uc_botMb;
    542     UWORD32 u4_num_pmbair;
    543     /* CHANGED CODE */
    544     tfr_ctxt_t *ps_frame_buf = ps_dec->ps_frame_buf_ip_recon;
    545     UWORD32 u4_luma_dc_only_csbp = 0;
    546     UWORD32 u4_luma_dc_only_cbp = 0;
    547     /* CHANGED CODE */
    548 
    549     uc_botMb = 1 - ps_cur_mb_info->u1_topmb;
    550     u4_num_pmbair = (u1_mb_num >> u1_mbaff);
    551     u1_mb_field_decoding_flag = ps_cur_mb_info->u1_mb_field_decodingflag;
    552 
    553 
    554     /* CHANGED CODE */
    555     pu1_rec_y = ps_frame_buf->pu1_dest_y + (u4_num_pmbair << 4);
    556     pu1_rec_u =
    557                     ps_frame_buf->pu1_dest_u
    558                                     + (u4_num_pmbair << 3) * YUV420SP_FACTOR;
    559     pu1_rec_v = ps_frame_buf->pu1_dest_v + (u4_num_pmbair << 3);
    560     ui_rec_width = ps_dec->u2_frm_wd_y << u1_mb_field_decoding_flag;
    561     u4_recwidth_cr = ps_dec->u2_frm_wd_uv << u1_mb_field_decoding_flag;
    562 
    563     /* CHANGED CODE */
    564 
    565     if(u1_mbaff)
    566     {
    567         if(uc_botMb)
    568         {
    569             pu1_rec_y += (u1_mb_field_decoding_flag ?
    570                             (ui_rec_width >> 1) : (ui_rec_width << 4));
    571             pu1_rec_u += (u1_mb_field_decoding_flag ?
    572                             (u4_recwidth_cr >> 1) : (u4_recwidth_cr << 3));
    573             pu1_rec_v += (u1_mb_field_decoding_flag ?
    574                             (u4_recwidth_cr >> 1) : (u4_recwidth_cr << 3));
    575         }
    576     }
    577 
    578     if(!ps_cur_mb_info->u1_tran_form8x8)
    579     {
    580         u4_luma_dc_only_csbp = ih264d_unpack_luma_coeff4x4_mb(ps_dec,
    581                                        ps_cur_mb_info,
    582                                        0);
    583     }
    584     else
    585     {
    586         if(!ps_dec->ps_cur_pps->u1_entropy_coding_mode)
    587         {
    588             u4_luma_dc_only_cbp = ih264d_unpack_luma_coeff4x4_mb(ps_dec,
    589                                            ps_cur_mb_info,
    590                                            0);
    591         }
    592         else
    593         {
    594             u4_luma_dc_only_cbp = ih264d_unpack_luma_coeff8x8_mb(ps_dec,
    595                                            ps_cur_mb_info);
    596         }
    597     }
    598 
    599     pi2_y_coeff = ps_dec->pi2_coeff_data;
    600     /* Inverse Transform and Reconstruction */
    601     if(ps_cur_mb_info->u1_cbp & 0x0f)
    602     {
    603         /* CHANGED CODE */
    604         if(!ps_cur_mb_info->u1_tran_form8x8)
    605         {
    606             UWORD32 i;
    607             WORD16 ai2_tmp[16];
    608             for(i = 0; i < 16; i++)
    609             {
    610                 if(CHECKBIT(ps_cur_mb_info->u2_luma_csbp, i))
    611                 {
    612                     WORD16 *pi2_level = pi2_y_coeff + (i << 4);
    613                     UWORD8 *pu1_pred_sblk = pu1_rec_y + ((i & 0x3) * BLK_SIZE)
    614                                     + (i >> 2) * (ui_rec_width << 2);
    615                     PROFILE_DISABLE_IQ_IT_RECON()
    616                     {
    617                         if(CHECKBIT(u4_luma_dc_only_csbp, i))
    618                         {
    619                             ps_dec->pf_iquant_itrans_recon_luma_4x4_dc(
    620                                             pi2_level,
    621                                             pu1_pred_sblk,
    622                                             pu1_pred_sblk,
    623                                             ui_rec_width,
    624                                             ui_rec_width,
    625                                             gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qp_rem6],
    626                                             (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[3],
    627                                             ps_cur_mb_info->u1_qp_div6, ai2_tmp, 0,
    628                                             NULL);
    629                         }
    630                         else
    631                         {
    632                             ps_dec->pf_iquant_itrans_recon_luma_4x4(
    633                                             pi2_level,
    634                                             pu1_pred_sblk,
    635                                             pu1_pred_sblk,
    636                                             ui_rec_width,
    637                                             ui_rec_width,
    638                                             gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qp_rem6],
    639                                             (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[3],
    640                                             ps_cur_mb_info->u1_qp_div6, ai2_tmp, 0,
    641                                             NULL);
    642                         }
    643                     }
    644                 }
    645             }
    646         }
    647         else
    648         {
    649             WORD16 *pi2_scale_matrix_ptr;
    650             WORD32 i;
    651 
    652             pi2_scale_matrix_ptr =
    653                             ps_dec->s_high_profile.i2_scalinglist8x8[1];
    654 
    655             for(i = 0; i < 4; i++)
    656             {
    657                 WORD16 ai2_tmp[64];
    658                 WORD16 *pi16_levelBlock = pi2_y_coeff + (i << 6); /* move to the next 8x8 adding 64 */
    659 
    660                 UWORD8 *pu1_pred_sblk = pu1_rec_y + ((i & 0x1) * BLK8x8SIZE)
    661                                 + (i >> 1) * (ui_rec_width << 3);
    662                 if(CHECKBIT(ps_cur_mb_info->u1_cbp, i))
    663                 {
    664                     PROFILE_DISABLE_IQ_IT_RECON()
    665                     {
    666                         if(CHECKBIT(u4_luma_dc_only_cbp, i))
    667                         {
    668                             ps_dec->pf_iquant_itrans_recon_luma_8x8_dc(
    669                                             pi16_levelBlock,
    670                                             pu1_pred_sblk,
    671                                             pu1_pred_sblk,
    672                                             ui_rec_width,
    673                                             ui_rec_width,
    674                                             gau1_ih264d_dequant8x8_cavlc[ps_cur_mb_info->u1_qp_rem6],
    675                                             (UWORD16 *)pi2_scale_matrix_ptr,
    676                                             ps_cur_mb_info->u1_qp_div6, ai2_tmp, 0,
    677                                             NULL);
    678                         }
    679                         else
    680                         {
    681                             ps_dec->pf_iquant_itrans_recon_luma_8x8(
    682                                             pi16_levelBlock,
    683                                             pu1_pred_sblk,
    684                                             pu1_pred_sblk,
    685                                             ui_rec_width,
    686                                             ui_rec_width,
    687                                             gau1_ih264d_dequant8x8_cavlc[ps_cur_mb_info->u1_qp_rem6],
    688                                             (UWORD16 *)pi2_scale_matrix_ptr,
    689                                             ps_cur_mb_info->u1_qp_div6, ai2_tmp, 0,
    690                                             NULL);
    691                         }
    692                     }
    693                 }
    694             }
    695 
    696         }
    697     }
    698 
    699     /* Decode Chroma Block */
    700     ih264d_unpack_chroma_coeff4x4_mb(ps_dec,
    701                                      ps_cur_mb_info);
    702     /*--------------------------------------------------------------------*/
    703     /* Chroma Blocks decoding                                             */
    704     /*--------------------------------------------------------------------*/
    705     {
    706         UWORD8 u1_chroma_cbp = (UWORD8)(ps_cur_mb_info->u1_cbp >> 4);
    707 
    708         if(u1_chroma_cbp != CBPC_ALLZERO)
    709         {
    710             UWORD32 u4_scale_u = ps_cur_mb_info->u1_qpc_div6;
    711             UWORD32 u4_scale_v = ps_cur_mb_info->u1_qpcr_div6;
    712             UWORD16 u2_chroma_csbp = ps_cur_mb_info->u2_chroma_csbp;
    713 
    714             pi2_y_coeff = ps_dec->pi2_coeff_data;
    715 
    716             {
    717                 UWORD32 i;
    718                 WORD16 ai2_tmp[16];
    719                 for(i = 0; i < 4; i++)
    720                 {
    721                     WORD16 *pi2_level = pi2_y_coeff + (i << 4);
    722                     UWORD8 *pu1_pred_sblk = pu1_rec_u
    723                                     + ((i & 0x1) * BLK_SIZE * YUV420SP_FACTOR)
    724                                     + (i >> 1) * (u4_recwidth_cr << 2);
    725                     PROFILE_DISABLE_IQ_IT_RECON()
    726                     {
    727                         if(CHECKBIT(u2_chroma_csbp, i))
    728                         {
    729                             ps_dec->pf_iquant_itrans_recon_chroma_4x4(
    730                                             pi2_level,
    731                                             pu1_pred_sblk,
    732                                             pu1_pred_sblk,
    733                                             u4_recwidth_cr,
    734                                             u4_recwidth_cr,
    735                                             gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qpc_rem6],
    736                                             (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[4],
    737                                             u4_scale_u, ai2_tmp, pi2_level);
    738                         }
    739                         else if(pi2_level[0] != 0)
    740                         {
    741                             ps_dec->pf_iquant_itrans_recon_chroma_4x4_dc(
    742                                             pi2_level,
    743                                             pu1_pred_sblk,
    744                                             pu1_pred_sblk,
    745                                             u4_recwidth_cr,
    746                                             u4_recwidth_cr,
    747                                             gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qpc_rem6],
    748                                             (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[4],
    749                                             u4_scale_u, ai2_tmp, pi2_level);
    750                         }
    751                     }
    752                 }
    753             }
    754 
    755             pi2_y_coeff += MB_CHROM_SIZE;
    756             u2_chroma_csbp >>= 4;
    757 
    758             {
    759                 UWORD32 i;
    760                 WORD16 ai2_tmp[16];
    761                 for(i = 0; i < 4; i++)
    762                 {
    763                     WORD16 *pi2_level = pi2_y_coeff + (i << 4);
    764                     UWORD8 *pu1_pred_sblk = pu1_rec_u + 1
    765                                     + ((i & 0x1) * BLK_SIZE * YUV420SP_FACTOR)
    766                                     + (i >> 1) * (u4_recwidth_cr << 2);
    767                     PROFILE_DISABLE_IQ_IT_RECON()
    768                     {
    769                         if(CHECKBIT(u2_chroma_csbp, i))
    770                         {
    771                             ps_dec->pf_iquant_itrans_recon_chroma_4x4(
    772                                             pi2_level,
    773                                             pu1_pred_sblk,
    774                                             pu1_pred_sblk,
    775                                             u4_recwidth_cr,
    776                                             u4_recwidth_cr,
    777                                             gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qpcr_rem6],
    778                                             (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[5],
    779                                             u4_scale_v, ai2_tmp, pi2_level);
    780                         }
    781                         else if(pi2_level[0] != 0)
    782                         {
    783                             ps_dec->pf_iquant_itrans_recon_chroma_4x4_dc(
    784                                             pi2_level,
    785                                             pu1_pred_sblk,
    786                                             pu1_pred_sblk,
    787                                             u4_recwidth_cr,
    788                                             u4_recwidth_cr,
    789                                             gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qpcr_rem6],
    790                                             (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[5],
    791                                             u4_scale_v, ai2_tmp, pi2_level);
    792                         }
    793                     }
    794                 }
    795             }
    796         }
    797     }
    798     return (0);
    799 }
    800 
    801 /*!
    802  **************************************************************************
    803  * \if Function name : ih264d_parse_pred_weight_table \endif
    804  *
    805  * \brief
    806  *    Implements pred_weight_table() of 7.3.3.2.
    807  *
    808  * \return
    809  *    None
    810  *
    811  **************************************************************************
    812  */
    813 WORD32 ih264d_parse_pred_weight_table(dec_slice_params_t * ps_cur_slice,
    814                                       dec_bit_stream_t * ps_bitstrm)
    815 {
    816     UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    817     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
    818     WORD8 i, cont, lx;
    819     UWORD8 uc_weight_flag;
    820     UWORD32 *pui32_weight_offset_lx;
    821     WORD16 c_weight, c_offset;
    822     UWORD32 ui32_y_def_weight_ofst, ui32_cr_def_weight_ofst;
    823     UWORD32 ui32_temp;
    824     UWORD8 uc_luma_log2_weight_denom;
    825     UWORD8 uc_chroma_log2_weight_denom;
    826 
    827     /* Variables for error resilience checks */
    828     UWORD32 u4_temp;
    829     WORD32 i_temp;
    830 
    831     u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
    832     if(u4_temp & MASK_LOG2_WEIGHT_DENOM)
    833     {
    834         return ERROR_PRED_WEIGHT_TABLE_T;
    835     }
    836     uc_luma_log2_weight_denom = u4_temp;
    837     COPYTHECONTEXT("SH: luma_log2_weight_denom",uc_luma_log2_weight_denom);
    838     ui32_y_def_weight_ofst = (1 << uc_luma_log2_weight_denom);
    839 
    840     u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
    841     if(u4_temp & MASK_LOG2_WEIGHT_DENOM)
    842     {
    843         return ERROR_PRED_WEIGHT_TABLE_T;
    844     }
    845     uc_chroma_log2_weight_denom = u4_temp;
    846     COPYTHECONTEXT("SH: chroma_log2_weight_denom",uc_chroma_log2_weight_denom);
    847     ui32_cr_def_weight_ofst = (1 << uc_chroma_log2_weight_denom);
    848 
    849     ps_cur_slice->u2_log2Y_crwd = uc_luma_log2_weight_denom
    850                     | (uc_chroma_log2_weight_denom << 8);
    851 
    852     cont = (ps_cur_slice->u1_slice_type == B_SLICE);
    853     lx = 0;
    854     do
    855     {
    856         for(i = 0; i < ps_cur_slice->u1_num_ref_idx_lx_active[lx]; i++)
    857         {
    858             pui32_weight_offset_lx = ps_cur_slice->u4_wt_ofst_lx[lx][i];
    859 
    860             uc_weight_flag = ih264d_get_bit_h264(ps_bitstrm);
    861             pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    862             COPYTHECONTEXT("SH: luma_weight_l0_flag",uc_weight_flag);
    863             if(uc_weight_flag)
    864             {
    865                 i_temp = ih264d_sev(pu4_bitstrm_ofst,
    866                                     pu4_bitstrm_buf);
    867                 if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
    868                     return ERROR_PRED_WEIGHT_TABLE_T;
    869                 c_weight = i_temp;
    870                 COPYTHECONTEXT("SH: luma_weight_l0",c_weight);
    871 
    872                 i_temp = ih264d_sev(pu4_bitstrm_ofst,
    873                                     pu4_bitstrm_buf);
    874                 if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
    875                     return ERROR_PRED_WEIGHT_TABLE_T;
    876                 c_offset = i_temp;
    877                 COPYTHECONTEXT("SH: luma_offset_l0",c_offset);
    878 
    879                 ui32_temp = (c_offset << 16) | (c_weight & 0xFFFF);
    880                 pui32_weight_offset_lx[0] = ui32_temp;
    881             }
    882             else
    883             {
    884 
    885                 pui32_weight_offset_lx[0] = ui32_y_def_weight_ofst;
    886             }
    887 
    888             {
    889                 WORD8 c_weightCb, c_weightCr, c_offsetCb, c_offsetCr;
    890                 uc_weight_flag = ih264d_get_bit_h264(ps_bitstrm);
    891                 pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    892                 COPYTHECONTEXT("SH: chroma_weight_l0_flag",uc_weight_flag);
    893                 if(uc_weight_flag)
    894                 {
    895                     i_temp = ih264d_sev(pu4_bitstrm_ofst,
    896                                         pu4_bitstrm_buf);
    897                     if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
    898                         return ERROR_PRED_WEIGHT_TABLE_T;
    899                     c_weightCb = i_temp;
    900                     COPYTHECONTEXT("SH: chroma_weight_l0",c_weightCb);
    901 
    902                     i_temp = ih264d_sev(pu4_bitstrm_ofst,
    903                                         pu4_bitstrm_buf);
    904                     if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
    905                         return ERROR_PRED_WEIGHT_TABLE_T;
    906                     c_offsetCb = i_temp;
    907                     COPYTHECONTEXT("SH: chroma_weight_l0",c_offsetCb);
    908 
    909                     ui32_temp = (c_offsetCb << 16) | (c_weightCb & 0xFFFF);
    910                     pui32_weight_offset_lx[1] = ui32_temp;
    911 
    912                     i_temp = ih264d_sev(pu4_bitstrm_ofst,
    913                                         pu4_bitstrm_buf);
    914                     if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
    915                         return ERROR_PRED_WEIGHT_TABLE_T;
    916                     c_weightCr = i_temp;
    917                     COPYTHECONTEXT("SH: chroma_weight_l0",c_weightCr);
    918 
    919                     i_temp = ih264d_sev(pu4_bitstrm_ofst,
    920                                         pu4_bitstrm_buf);
    921                     if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
    922                         return ERROR_PRED_WEIGHT_TABLE_T;
    923                     c_offsetCr = i_temp;
    924                     COPYTHECONTEXT("SH: chroma_weight_l0",c_offsetCr);
    925 
    926                     ui32_temp = (c_offsetCr << 16) | (c_weightCr & 0xFFFF);
    927                     pui32_weight_offset_lx[2] = ui32_temp;
    928                 }
    929                 else
    930                 {
    931                     pui32_weight_offset_lx[1] = ui32_cr_def_weight_ofst;
    932                     pui32_weight_offset_lx[2] = ui32_cr_def_weight_ofst;
    933                 }
    934             }
    935         }
    936         lx++;
    937     }
    938     while(cont--);
    939 
    940     return OK;
    941 }
    942 
    943 
    944 /*****************************************************************************/
    945 /*                                                                           */
    946 /*  Function Name : ih264d_init_ref_idx_lx_p                                        */
    947 /*                                                                           */
    948 /*  Description   : This function initializes the reference picture L0 list  */
    949 /*                  for P slices as per section 8.2.4.2.1 and 8.2.4.2.2.     */
    950 /*                                                                           */
    951 /*  Inputs        : pointer to ps_dec struture                               */
    952 /*  Globals       : NO                                                       */
    953 /*  Processing    : arranges all the short term pictures according to        */
    954 /*                  pic_num in descending order starting from curr pic_num.  */
    955 /*                  and inserts it in L0 list followed by all Long term      */
    956 /*                  pictures in ascending order.                             */
    957 /*                                                                           */
    958 /*  Returns       : void                                                     */
    959 /*                                                                           */
    960 /*  Issues        : <List any issues or problems with this function>         */
    961 /*                                                                           */
    962 /*  Revision History:                                                        */
    963 /*                                                                           */
    964 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
    965 /*         13 07 2002   Jay             Draft                                */
    966 /*                                                                           */
    967 /*****************************************************************************/
    968 void ih264d_init_ref_idx_lx_p(dec_struct_t *ps_dec)
    969 {
    970     struct pic_buffer_t *ps_ref_pic_buf_lx;
    971     dpb_manager_t *ps_dpb_mgr;
    972     struct dpb_info_t *ps_next_dpb;
    973     WORD8 i;
    974     UWORD8 u1_max_lt_index, u1_min_lt_index, u1_lt_index;
    975     UWORD8 u1_field_pic_flag;
    976     dec_slice_params_t *ps_cur_slice;
    977     UWORD8 u1_L0;
    978     WORD32 i4_cur_pic_num, i4_min_st_pic_num;
    979     WORD32 i4_temp_pic_num, i4_ref_pic_num;
    980     UWORD8 u1_num_short_term_bufs;
    981     UWORD8 u1_max_ref_idx_l0;
    982 
    983     ps_cur_slice = ps_dec->ps_cur_slice;
    984     u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
    985     u1_max_ref_idx_l0 = ps_cur_slice->u1_num_ref_idx_lx_active[0]
    986                     << u1_field_pic_flag;
    987 
    988     ps_dpb_mgr = ps_dec->ps_dpb_mgr;
    989     /* Get the current frame number */
    990     i4_cur_pic_num = ps_dec->ps_cur_pic->i4_pic_num;
    991 
    992     /* Get Min pic_num,MinLt */
    993     i4_min_st_pic_num = i4_cur_pic_num;
    994     u1_max_lt_index = MAX_REF_BUFS + 1;
    995     u1_min_lt_index = MAX_REF_BUFS + 1;
    996 
    997     /* Start from ST head */
    998     ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head;
    999     for(i = 0; i < ps_dpb_mgr->u1_num_st_ref_bufs; i++)
   1000     {
   1001         i4_ref_pic_num = ps_next_dpb->ps_pic_buf->i4_pic_num;
   1002         if(i4_ref_pic_num < i4_cur_pic_num)
   1003         {
   1004             /* RefPic Buf pic_num is before Current pic_num in decode order */
   1005             i4_min_st_pic_num = MIN(i4_min_st_pic_num, i4_ref_pic_num);
   1006         }
   1007 
   1008         /* Chase the next link */
   1009         ps_next_dpb = ps_next_dpb->ps_prev_short;
   1010     }
   1011 
   1012     /* Start from LT head */
   1013     ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
   1014     if(ps_next_dpb)
   1015     {
   1016         u1_max_lt_index = ps_next_dpb->u1_lt_idx;
   1017         u1_min_lt_index = ps_next_dpb->u1_lt_idx;
   1018 
   1019         for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
   1020         {
   1021             u1_lt_index = ps_next_dpb->u1_lt_idx;
   1022             u1_max_lt_index = (UWORD8)(MAX(u1_max_lt_index, u1_lt_index));
   1023             u1_min_lt_index = (UWORD8)(MIN(u1_min_lt_index, u1_lt_index));
   1024 
   1025             /* Chase the next link */
   1026             ps_next_dpb = ps_next_dpb->ps_prev_long;
   1027         }
   1028     }
   1029     /* 1. Initialize refIdxL0 */
   1030     u1_L0 = 0;
   1031     if(u1_field_pic_flag)
   1032     {
   1033         ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0];
   1034         ps_ref_pic_buf_lx += MAX_REF_BUFS;
   1035         i4_temp_pic_num = i4_cur_pic_num;
   1036     }
   1037     else
   1038     {
   1039         ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0];
   1040         i4_temp_pic_num = i4_cur_pic_num;
   1041     }
   1042 
   1043     /* Arrange all short term buffers in output order as given by pic_num */
   1044     /* Arrange pic_num's less than Curr pic_num in the descending pic_num */
   1045     /* order starting from (Curr pic_num - 1)                             */
   1046     for(; i4_temp_pic_num >= i4_min_st_pic_num; i4_temp_pic_num--)
   1047     {
   1048         /* Start from ST head */
   1049         ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head;
   1050         for(i = 0; i < ps_dpb_mgr->u1_num_st_ref_bufs; i++)
   1051         {
   1052             if((WORD32)ps_next_dpb->ps_pic_buf->i4_pic_num == i4_temp_pic_num)
   1053             {
   1054                 /* Copy info in pic buffer */
   1055                 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
   1056                                                    ps_next_dpb->ps_pic_buf);
   1057                 ps_ref_pic_buf_lx++;
   1058                 u1_L0++;
   1059                 break;
   1060             }
   1061             ps_next_dpb = ps_next_dpb->ps_prev_short;
   1062         }
   1063     }
   1064 
   1065     /* Arrange all Long term buffers in ascending order, in LongtermIndex */
   1066     /* Start from LT head */
   1067     u1_num_short_term_bufs = u1_L0;
   1068     for(u1_lt_index = u1_min_lt_index; u1_lt_index <= u1_max_lt_index;
   1069                     u1_lt_index++)
   1070     {
   1071         ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
   1072         for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
   1073         {
   1074             if(ps_next_dpb->u1_lt_idx == u1_lt_index)
   1075             {
   1076                 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
   1077                                                    ps_next_dpb->ps_pic_buf);
   1078 
   1079                 ps_ref_pic_buf_lx->u1_long_term_pic_num =
   1080                                 ps_ref_pic_buf_lx->u1_long_term_frm_idx;
   1081                 ps_ref_pic_buf_lx++;
   1082                 u1_L0++;
   1083                 break;
   1084             }
   1085             ps_next_dpb = ps_next_dpb->ps_prev_long;
   1086         }
   1087     }
   1088 
   1089     if(u1_field_pic_flag)
   1090     {
   1091         /* Initialize the rest of the entries in the */
   1092         /* reference list to handle of errors        */
   1093         {
   1094             UWORD8 u1_i;
   1095             pic_buffer_t *ps_ref_pic;
   1096 
   1097             ps_ref_pic = ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS;
   1098 
   1099             if(NULL == ps_ref_pic->pu1_buf1)
   1100             {
   1101                 ps_ref_pic = ps_dec->ps_cur_pic;
   1102             }
   1103             for(u1_i = u1_L0; u1_i < u1_max_ref_idx_l0; u1_i++)
   1104             {
   1105                 *ps_ref_pic_buf_lx = *ps_ref_pic;
   1106                 ps_ref_pic_buf_lx++;
   1107             }
   1108         }
   1109 
   1110         ih264d_convert_frm_to_fld_list(
   1111                         ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS, &u1_L0,
   1112                         ps_dec, u1_num_short_term_bufs);
   1113 
   1114         ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0] + u1_L0;
   1115     }
   1116 
   1117     /* Initialize the rest of the entries in the */
   1118     /* reference list to handle of errors        */
   1119     {
   1120         UWORD8 u1_i;
   1121         pic_buffer_t *ps_ref_pic;
   1122 
   1123         ps_ref_pic = ps_dpb_mgr->ps_init_dpb[0][0];
   1124 
   1125         if(NULL == ps_ref_pic->pu1_buf1)
   1126         {
   1127             ps_ref_pic = ps_dec->ps_cur_pic;
   1128         }
   1129         for(u1_i = u1_L0; u1_i < u1_max_ref_idx_l0; u1_i++)
   1130         {
   1131             *ps_ref_pic_buf_lx = *ps_ref_pic;
   1132             ps_ref_pic_buf_lx++;
   1133         }
   1134     }
   1135     ps_dec->ps_cur_slice->u1_initial_list_size[0] = u1_L0;
   1136 }
   1137 
   1138