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_mb_utils.c
     23  *
     24  * \brief
     25  *    Contains utitlity functions needed for Macroblock decoding
     26  *
     27  * \date
     28  *    18/12/2002
     29  *
     30  * \author  AI
     31  **************************************************************************
     32  */
     33 #include <string.h>
     34 #include <stdlib.h>
     35 #include "ih264d_bitstrm.h"
     36 #include "ih264d_defs.h"
     37 #include "ih264d_debug.h"
     38 #include "ih264d_structs.h"
     39 #include "ih264d_defs.h"
     40 #include "ih264d_mb_utils.h"
     41 #include "ih264d_parse_slice.h"
     42 #include "ih264d_error_handler.h"
     43 #include "ih264d_parse_mb_header.h"
     44 #include "ih264d_cabac.h"
     45 #include "ih264d_defs.h"
     46 #include "ih264d_tables.h"
     47 
     48 /*****************************************************************************/
     49 /*                                                                           */
     50 /*  Function Name : get_mb_info_cavlc                                        */
     51 /*                                                                           */
     52 /*  Description   : This function sets the following information of cur MB   */
     53 /*                  (a) mb_x and mb_y                                        */
     54 /*                  (b) Neighbour availablity                                */
     55 /*                  (c) Macroblock location in the frame buffer              */
     56 /*                  (e) For mbaff predicts field/frame u4_flag for topMb        */
     57 /*                      and sets the field/frame for botMb. This is          */
     58 /*                      written in ps_dec->u1_cur_mb_fld_dec_flag            */
     59 /*                                                                           */
     60 /*  Inputs        : pointer to decstruct                                     */
     61 /*                  pointer to current mb info                               */
     62 /*                  currentMbaddress                                         */
     63 /*                                                                           */
     64 /*  Processing    : leftMb and TopMb params are used by DecMbskip and        */
     65 /*                  DecCtxMbfield  modules so that these modules do not      */
     66 /*                  check for neigbour availability and then find the        */
     67 /*                  neigbours for context increments                         */
     68 /*                                                                           */
     69 /*  Returns       : OK                                                       */
     70 /*                                                                           */
     71 /*  Issues        : <List any issues or problems with this function>         */
     72 /*                                                                           */
     73 /*  Revision History:                                                        */
     74 /*                                                                           */
     75 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
     76 /*         13 07 2002   Jay             Draft                                */
     77 /*                                                                           */
     78 /*****************************************************************************/
     79 
     80 UWORD32 ih264d_get_mb_info_cavlc_nonmbaff(dec_struct_t *ps_dec,
     81                                           const UWORD16 u2_cur_mb_address,
     82                                           dec_mb_info_t * ps_cur_mb_info,
     83                                           UWORD32 u4_mbskip_run)
     84 {
     85     WORD32 mb_x;
     86     WORD32 mb_y;
     87     UWORD8 u1_mb_ngbr_avail = 0;
     88     UWORD16 u2_frm_width_in_mb = ps_dec->u2_frm_wd_in_mbs;
     89     WORD16 i2_prev_slice_mbx = ps_dec->i2_prev_slice_mbx;
     90     UWORD16 u2_top_right_mask = TOP_RIGHT_DEFAULT_AVAILABLE;
     91     UWORD16 u2_top_left_mask = TOP_LEFT_DEFAULT_AVAILABLE;
     92     UNUSED(u4_mbskip_run);
     93     /*--------------------------------------------------------------------*/
     94     /* Calculate values of mb_x and mb_y                                  */
     95     /*--------------------------------------------------------------------*/
     96     mb_x = (WORD16)ps_dec->u2_mbx;
     97     mb_y = (WORD16)ps_dec->u2_mby;
     98 
     99     ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
    100 
    101     mb_x++;
    102 
    103     if(mb_x == u2_frm_width_in_mb)
    104     {
    105         mb_x = 0;
    106         mb_y++;
    107     }
    108     if(mb_y > ps_dec->i2_prev_slice_mby)
    109     {
    110         /* if not in the immemdiate row of prev slice end then top
    111          will be available */
    112         if(mb_y > (ps_dec->i2_prev_slice_mby + 1))
    113             i2_prev_slice_mbx = -1;
    114 
    115         if(mb_x > i2_prev_slice_mbx)
    116         {
    117             u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
    118             u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
    119             u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
    120         }
    121 
    122         if((mb_x > (i2_prev_slice_mbx - 1))
    123                         && (mb_x != (u2_frm_width_in_mb - 1)))
    124         {
    125             u1_mb_ngbr_avail |= TOP_RIGHT_MB_AVAILABLE_MASK;
    126             u2_top_right_mask |= TOP_RIGHT_TOPR_AVAILABLE;
    127         }
    128 
    129         if(mb_x > (i2_prev_slice_mbx + 1))
    130         {
    131             u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
    132             u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
    133         }
    134 
    135         /* Next row  Left will be available*/
    136         i2_prev_slice_mbx = -1;
    137     }
    138 
    139     /* Same row */
    140     if(mb_x > (i2_prev_slice_mbx + 1))
    141     {
    142         u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
    143         u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
    144     }
    145 
    146     {
    147         mb_neigbour_params_t *ps_cur_mb_row = ps_dec->ps_cur_mb_row;
    148         mb_neigbour_params_t *ps_top_mb_row = ps_dec->ps_top_mb_row;
    149 
    150         /* copy the parameters of topleft Mb */
    151         ps_cur_mb_info->u1_topleft_mbtype = ps_dec->u1_topleft_mbtype;
    152         /* Neighbour pointer assignments*/
    153         ps_cur_mb_info->ps_curmb = ps_cur_mb_row + mb_x;
    154         ps_cur_mb_info->ps_left_mb = ps_cur_mb_row + mb_x - 1;
    155         ps_cur_mb_info->ps_top_mb = ps_top_mb_row + mb_x;
    156         ps_cur_mb_info->ps_top_right_mb = ps_top_mb_row + mb_x + 1;
    157 
    158         /* Update the parameters of topleftmb*/
    159         ps_dec->u1_topleft_mbtype = ps_cur_mb_info->ps_top_mb->u1_mb_type;
    160     }
    161 
    162     ps_dec->u2_mby = mb_y;
    163     ps_dec->u2_mbx = mb_x;
    164     ps_cur_mb_info->u2_mbx = mb_x;
    165     ps_cur_mb_info->u2_mby = mb_y;
    166     ps_cur_mb_info->u1_topmb = 1;
    167     ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
    168     ps_dec->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
    169     ps_cur_mb_info->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
    170     ps_cur_mb_info->ps_curmb->u1_mb_fld = ps_dec->u1_cur_mb_fld_dec_flag;
    171     ps_cur_mb_info->u1_mb_field_decodingflag = ps_dec->u1_cur_mb_fld_dec_flag;
    172     ps_cur_mb_info->u2_top_left_avail_mask = u2_top_left_mask;
    173     ps_cur_mb_info->u2_top_right_avail_mask = u2_top_right_mask;
    174     return (OK);
    175 
    176 }
    177 
    178 /*****************************************************************************/
    179 /*                                                                           */
    180 /*  Function Name : get_mb_info_cavlc                                        */
    181 /*                                                                           */
    182 /*  Description   : This function sets the following information of cur MB   */
    183 /*                  (a) mb_x and mb_y                                        */
    184 /*                  (b) Neighbour availablity                                */
    185 /*                  (c) Macroblock location in the frame buffer              */
    186 /*                  (e) For mbaff predicts field/frame u4_flag for topMb        */
    187 /*                      and sets the field/frame for botMb. This is          */
    188 /*                      written in ps_dec->u1_cur_mb_fld_dec_flag            */
    189 /*                                                                           */
    190 /*  Inputs        : pointer to decstruct                                     */
    191 /*                  pointer to current mb info                               */
    192 /*                  currentMbaddress                                         */
    193 /*                                                                           */
    194 /*  Processing    : leftMb and TopMb params are used by DecMbskip and        */
    195 /*                  DecCtxMbfield  modules so that these modules do not      */
    196 /*                  check for neigbour availability and then find the        */
    197 /*                  neigbours for context increments                         */
    198 /*                                                                           */
    199 /*  Returns       : OK                                                       */
    200 /*                                                                           */
    201 /*  Issues        : <List any issues or problems with this function>         */
    202 /*                                                                           */
    203 /*  Revision History:                                                        */
    204 /*                                                                           */
    205 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
    206 /*         13 07 2002   Jay             Draft                                */
    207 /*                                                                           */
    208 /*****************************************************************************/
    209 
    210 UWORD32 ih264d_get_mb_info_cavlc_mbaff(dec_struct_t *ps_dec,
    211                                        const UWORD16 u2_cur_mb_address,
    212                                        dec_mb_info_t * ps_cur_mb_info,
    213                                        UWORD32 u4_mbskip_run)
    214 {
    215     UWORD16 u2_mb_x;
    216     UWORD16 u2_mb_y;
    217     UWORD8 u1_mb_ngbr_avail = 0;
    218     UWORD16 u2_frm_width_in_mb = ps_dec->u2_frm_wd_in_mbs;
    219 
    220     UWORD8 u1_top_mb = 1 - (u2_cur_mb_address & 0x01);
    221     WORD16 i2_prev_slice_mbx = ps_dec->i2_prev_slice_mbx;
    222     UWORD8 u1_cur_mb_field = 0;
    223     UWORD16 u2_top_right_mask = TOP_RIGHT_DEFAULT_AVAILABLE;
    224     UWORD16 u2_top_left_mask = TOP_LEFT_DEFAULT_AVAILABLE;
    225 
    226     /*--------------------------------------------------------------------*/
    227     /* Calculate values of mb_x and mb_y                                  */
    228     /*--------------------------------------------------------------------*/
    229     u2_mb_x = ps_dec->u2_mbx;
    230     u2_mb_y = ps_dec->u2_mby;
    231 
    232     ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
    233 
    234 
    235     if(u1_top_mb)
    236     {
    237         u2_mb_x++;
    238         if(u2_mb_x == u2_frm_width_in_mb)
    239         {
    240             u2_mb_x = 0;
    241             u2_mb_y += 2;
    242         }
    243         if(u2_mb_y > ps_dec->i2_prev_slice_mby)
    244         {
    245             /* if not in the immemdiate row of prev slice end then top
    246              will be available */
    247             if(u2_mb_y > (ps_dec->i2_prev_slice_mby + 2))
    248                 i2_prev_slice_mbx = -1;
    249             if(u2_mb_x > i2_prev_slice_mbx)
    250             {
    251                 u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
    252                 u1_cur_mb_field = ps_dec->ps_top_mb_row[u2_mb_x << 1].u1_mb_fld;
    253                 u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
    254                 u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
    255             }
    256             if((u2_mb_x > (i2_prev_slice_mbx - 1))
    257                             && (u2_mb_x != (u2_frm_width_in_mb - 1)))
    258             {
    259                 u1_mb_ngbr_avail |= TOP_RIGHT_MB_AVAILABLE_MASK;
    260                 u2_top_right_mask |= TOP_RIGHT_TOPR_AVAILABLE;
    261             }
    262 
    263             if(u2_mb_x > (i2_prev_slice_mbx + 1))
    264             {
    265                 u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
    266                 u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
    267             }
    268 
    269             i2_prev_slice_mbx = -1;
    270         }
    271         /* Same row */
    272         if(u2_mb_x > (i2_prev_slice_mbx + 1))
    273         {
    274             u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
    275             u1_cur_mb_field =
    276                             ps_dec->ps_cur_mb_row[(u2_mb_x << 1) - 1].u1_mb_fld;
    277             u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
    278         }
    279         /* Read u1_cur_mb_field from the bitstream if u4_mbskip_run <= 1*/
    280         if(u4_mbskip_run <= 1)
    281             u1_cur_mb_field = (UWORD8)ih264d_get_bit_h264(ps_dec->ps_bitstrm);
    282 
    283         ps_dec->u1_cur_mb_fld_dec_flag = u1_cur_mb_field;
    284         ps_dec->u2_top_left_mask = u2_top_left_mask;
    285         ps_dec->u2_top_right_mask = u2_top_right_mask;
    286     }
    287     else
    288     {
    289         u1_mb_ngbr_avail = ps_dec->u1_mb_ngbr_availablity;
    290         u1_cur_mb_field = ps_dec->u1_cur_mb_fld_dec_flag;
    291         u2_top_left_mask = ps_dec->u2_top_left_mask;
    292         u2_top_right_mask = ps_dec->u2_top_right_mask;
    293 
    294         if(!u1_cur_mb_field)
    295         {
    296             /* Top is available */
    297             u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
    298             u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
    299             u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
    300             /* Top Right not available */
    301             u1_mb_ngbr_avail &= TOP_RT_SUBBLOCK_MASK_MOD;
    302             u2_top_right_mask &= (~TOP_RIGHT_TOPR_AVAILABLE);
    303 
    304             if(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK)
    305             {
    306                 u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
    307                 u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
    308                 u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
    309             }
    310         }
    311     }
    312 
    313     ps_dec->u2_mby = u2_mb_y;
    314     ps_dec->u2_mbx = u2_mb_x;
    315     ps_cur_mb_info->u2_mbx = u2_mb_x;
    316     ps_cur_mb_info->u2_mby = u2_mb_y;
    317     ps_cur_mb_info->u1_topmb = u1_top_mb;
    318     ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
    319     ps_dec->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
    320     ps_cur_mb_info->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
    321     ps_cur_mb_info->u1_mb_field_decodingflag = u1_cur_mb_field;
    322     ps_cur_mb_info->u2_top_left_avail_mask = u2_top_left_mask;
    323     ps_cur_mb_info->u2_top_right_avail_mask = u2_top_right_mask;
    324     ih264d_get_mbaff_neighbours(ps_dec, ps_cur_mb_info, u1_cur_mb_field);
    325     return (OK);
    326 }
    327 
    328 /*****************************************************************************/
    329 /*                                                                           */
    330 /*  Function Name : get_mb_info_cabac                                        */
    331 /*                                                                           */
    332 /*  Description   : This function sets the following information of cur MB   */
    333 /*                  (a) mb_x and mb_y                                        */
    334 /*                  (b) Neighbour availablity                                */
    335 /*                  (c) Macroblock location in the frame buffer              */
    336 /*                  (e) leftMb parama and TopMb params of curMB              */
    337 /*                  (f) For Mbaff case leftMb params and TopMb params of     */
    338 /*                      bottomMb are also set if curMB is top                */
    339 /*                  (g) For mbaff predicts field/frame u4_flag for topMb        */
    340 /*                      and sets the field/frame for botMb. This is          */
    341 /*                      written in ps_dec->u1_cur_mb_fld_dec_flag            */
    342 /*                                                                           */
    343 /*  Inputs        : pointer to decstruct                                     */
    344 /*                  pointer to current mb info                               */
    345 /*                  currentMbaddress                                         */
    346 /*                                                                           */
    347 /*  Processing    : leftMb and TopMb params are used by DecMbskip and        */
    348 /*                  DecCtxMbfield  modules so that these modules do not      */
    349 /*                  check for neigbour availability and then find the        */
    350 /*                  neigbours for context increments                         */
    351 /*                                                                           */
    352 /*  Returns       : OK                                                       */
    353 /*                                                                           */
    354 /*  Issues        : <List any issues or problems with this function>         */
    355 /*                                                                           */
    356 /*  Revision History:                                                        */
    357 /*                                                                           */
    358 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
    359 /*         13 07 2002   Jay             Draft                                */
    360 /*                                                                           */
    361 /*****************************************************************************/
    362 UWORD32 ih264d_get_mb_info_cabac_nonmbaff(dec_struct_t *ps_dec,
    363                                           const UWORD16 u2_cur_mb_address,
    364                                           dec_mb_info_t * ps_cur_mb_info,
    365                                           UWORD32 u4_mbskip)
    366 {
    367     WORD32 mb_x;
    368     WORD32 mb_y;
    369     UWORD32 u1_mb_ngbr_avail = 0;
    370     UWORD32 u2_frm_width_in_mb = ps_dec->u2_frm_wd_in_mbs;
    371     UWORD32 u1_top_mb = 1;
    372     WORD32 i2_prev_slice_mbx = ps_dec->i2_prev_slice_mbx;
    373     UWORD32 u2_top_right_mask = TOP_RIGHT_DEFAULT_AVAILABLE;
    374     UWORD32 u2_top_left_mask = TOP_LEFT_DEFAULT_AVAILABLE;
    375     ctxt_inc_mb_info_t * const p_ctx_inc_mb_map = ps_dec->p_ctxt_inc_mb_map;
    376 
    377     /*--------------------------------------------------------------------*/
    378     /* Calculate values of mb_x and mb_y                                  */
    379     /*--------------------------------------------------------------------*/
    380     mb_x = (WORD16)ps_dec->u2_mbx;
    381     mb_y = (WORD16)ps_dec->u2_mby;
    382 
    383     ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
    384 
    385     mb_x++;
    386     if((UWORD32)mb_x == u2_frm_width_in_mb)
    387     {
    388         mb_x = 0;
    389         mb_y++;
    390     }
    391     /*********************************************************************/
    392     /* Cabac Context Initialisations                                     */
    393     /*********************************************************************/
    394     ps_dec->ps_curr_ctxt_mb_info = p_ctx_inc_mb_map + mb_x;
    395     ps_dec->p_left_ctxt_mb_info = p_ctx_inc_mb_map - 1;
    396     ps_dec->p_top_ctxt_mb_info = p_ctx_inc_mb_map - 1;
    397 
    398     /********************************************************************/
    399     /* neighbour availablility                                          */
    400     /********************************************************************/
    401     if(mb_y > ps_dec->i2_prev_slice_mby)
    402     {
    403         /* if not in the immemdiate row of prev slice end then top
    404          will be available */
    405         if(mb_y > (ps_dec->i2_prev_slice_mby + 1))
    406             i2_prev_slice_mbx = -1;
    407 
    408         if(mb_x > i2_prev_slice_mbx)
    409         {
    410             u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
    411             u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
    412             u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
    413             ps_dec->p_top_ctxt_mb_info = ps_dec->ps_curr_ctxt_mb_info;
    414         }
    415         if((mb_x > (i2_prev_slice_mbx - 1))
    416                         && ((UWORD32)mb_x != (u2_frm_width_in_mb - 1)))
    417         {
    418             u1_mb_ngbr_avail |= TOP_RIGHT_MB_AVAILABLE_MASK;
    419             u2_top_right_mask |= TOP_RIGHT_TOPR_AVAILABLE;
    420         }
    421 
    422         if(mb_x > (i2_prev_slice_mbx + 1))
    423         {
    424             u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
    425             u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
    426         }
    427         /* Next row */
    428         i2_prev_slice_mbx = -1;
    429     }
    430     /* Same row */
    431     if(mb_x > (i2_prev_slice_mbx + 1))
    432     {
    433         u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
    434         u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
    435         ps_dec->p_left_ctxt_mb_info = ps_dec->ps_curr_ctxt_mb_info - 1;
    436     }
    437     {
    438         mb_neigbour_params_t *ps_cur_mb_row = ps_dec->ps_cur_mb_row;
    439         mb_neigbour_params_t *ps_top_mb_row = ps_dec->ps_top_mb_row;
    440         /* copy the parameters of topleft Mb */
    441         ps_cur_mb_info->u1_topleft_mbtype = ps_dec->u1_topleft_mbtype;
    442         /* Neighbour pointer assignments*/
    443         ps_cur_mb_info->ps_curmb = ps_cur_mb_row + mb_x;
    444         ps_cur_mb_info->ps_left_mb = ps_cur_mb_row + mb_x - 1;
    445         ps_cur_mb_info->ps_top_mb = ps_top_mb_row + mb_x;
    446         ps_cur_mb_info->ps_top_right_mb = ps_top_mb_row + mb_x + 1;
    447 
    448         /* Update the parameters of topleftmb*/
    449         ps_dec->u1_topleft_mbtype = ps_cur_mb_info->ps_top_mb->u1_mb_type;
    450     }
    451 
    452     ps_dec->u2_mby = mb_y;
    453     ps_dec->u2_mbx = mb_x;
    454     ps_cur_mb_info->u2_mbx = mb_x;
    455     ps_cur_mb_info->u2_mby = mb_y;
    456     ps_cur_mb_info->u1_topmb = u1_top_mb;
    457     ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
    458     ps_dec->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
    459     ps_cur_mb_info->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
    460     ps_cur_mb_info->ps_curmb->u1_mb_fld = ps_dec->u1_cur_mb_fld_dec_flag;
    461     ps_cur_mb_info->u1_mb_field_decodingflag = ps_dec->u1_cur_mb_fld_dec_flag;
    462     ps_cur_mb_info->u2_top_left_avail_mask = u2_top_left_mask;
    463     ps_cur_mb_info->u2_top_right_avail_mask = u2_top_right_mask;
    464 
    465     /*********************************************************************/
    466     /*                  Assign the neigbours                             */
    467     /*********************************************************************/
    468     if(u4_mbskip)
    469     {
    470         UWORD32 u4_ctx_inc =
    471                         2
    472                                         - ((!!(ps_dec->p_top_ctxt_mb_info->u1_mb_type
    473                                                         & CAB_SKIP_MASK))
    474                                                         + (!!(ps_dec->p_left_ctxt_mb_info->u1_mb_type
    475                                                                         & CAB_SKIP_MASK)));
    476 
    477         u4_mbskip = ih264d_decode_bin(u4_ctx_inc, ps_dec->p_mb_skip_flag_t,
    478                                       ps_dec->ps_bitstrm, &ps_dec->s_cab_dec_env);
    479 
    480         if(!u4_mbskip)
    481         {
    482             if(!(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK))
    483             {
    484                 UWORD32 *pu4_buf;
    485                 UWORD8 *pu1_buf;
    486 
    487                 pu1_buf = ps_dec->pu1_left_nnz_y;
    488                 pu4_buf = (UWORD32 *)pu1_buf;
    489                 *pu4_buf = 0;
    490                 pu1_buf = ps_dec->pu1_left_nnz_uv;
    491                 pu4_buf = (UWORD32 *)pu1_buf;
    492                 *pu4_buf = 0;
    493 
    494 
    495                 *(ps_dec->pu1_left_yuv_dc_csbp) = 0;
    496                 MEMSET_16BYTES(&ps_dec->pu1_left_mv_ctxt_inc[0][0], 0);
    497                 *(UWORD32 *)ps_dec->pi1_left_ref_idx_ctxt_inc = 0;
    498             }
    499             if(!(u1_mb_ngbr_avail & TOP_MB_AVAILABLE_MASK))
    500             {
    501                 MEMSET_16BYTES(ps_dec->ps_curr_ctxt_mb_info->u1_mv, 0);
    502                 memset(ps_dec->ps_curr_ctxt_mb_info->i1_ref_idx, 0, 4);
    503             }
    504         }
    505     }
    506     return (u4_mbskip);
    507 }
    508 
    509 /*****************************************************************************/
    510 /*                                                                           */
    511 /*  Function Name : get_mb_info_cabac                                        */
    512 /*                                                                           */
    513 /*  Description   : This function sets the following information of cur MB   */
    514 /*                  (a) mb_x and mb_y                                        */
    515 /*                  (b) Neighbour availablity                                */
    516 /*                  (c) Macroblock location in the frame buffer              */
    517 /*                  (e) leftMb parama and TopMb params of curMB              */
    518 /*                  (f) For Mbaff case leftMb params and TopMb params of     */
    519 /*                      bottomMb are also set if curMB is top                */
    520 /*                  (g) For mbaff predicts field/frame u4_flag for topMb        */
    521 /*                      and sets the field/frame for botMb. This is          */
    522 /*                      written in ps_dec->u1_cur_mb_fld_dec_flag            */
    523 /*                                                                           */
    524 /*  Inputs        : pointer to decstruct                                     */
    525 /*                  pointer to current mb info                               */
    526 /*                  currentMbaddress                                         */
    527 /*                                                                           */
    528 /*  Processing    : leftMb and TopMb params are used by DecMbskip and        */
    529 /*                  DecCtxMbfield  modules so that these modules do not      */
    530 /*                  check for neigbour availability and then find the        */
    531 /*                  neigbours for context increments                         */
    532 /*                                                                           */
    533 /*  Returns       : OK                                                       */
    534 /*                                                                           */
    535 /*  Issues        : <List any issues or problems with this function>         */
    536 /*                                                                           */
    537 /*  Revision History:                                                        */
    538 /*                                                                           */
    539 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
    540 /*         13 07 2002   Jay             Draft                                */
    541 /*                                                                           */
    542 /*****************************************************************************/
    543 
    544 UWORD32 ih264d_get_mb_info_cabac_mbaff(dec_struct_t *ps_dec,
    545                                        const UWORD16 u2_cur_mb_address,
    546                                        dec_mb_info_t * ps_cur_mb_info,
    547                                        UWORD32 u4_mbskip)
    548 {
    549     WORD32 mb_x;
    550     WORD32 mb_y;
    551     UWORD8 u1_mb_ngbr_avail = 0;
    552     UWORD16 u2_frm_width_in_mb = ps_dec->u2_frm_wd_in_mbs;
    553     ctxt_inc_mb_info_t * const p_ctx_inc_mb_map = ps_dec->p_ctxt_inc_mb_map;
    554     ctxt_inc_mb_info_t *ps_curr_ctxt, *ps_top_ctxt, *ps_left_ctxt;
    555     mb_neigbour_params_t *ps_cur_mb_row = ps_dec->ps_cur_mb_row;
    556     mb_neigbour_params_t *ps_top_mb_row = ps_dec->ps_top_mb_row;
    557     UWORD32 u4_left_mb_pair_fld = 0;
    558     UWORD32 u4_top_mb_pair_fld = 0;
    559     UWORD8 u1_cur_mb_field = 0;
    560     UWORD8 u1_top_mb = 1 - (u2_cur_mb_address & 0x01);
    561     WORD16 i2_prev_slice_mbx = ps_dec->i2_prev_slice_mbx;
    562     UWORD16 u2_top_right_mask = TOP_RIGHT_DEFAULT_AVAILABLE;
    563     UWORD16 u2_top_left_mask = TOP_LEFT_DEFAULT_AVAILABLE;
    564 
    565     /*--------------------------------------------------------------------*/
    566     /* Calculate values of mb_x and mb_y                                  */
    567     /*--------------------------------------------------------------------*/
    568     mb_x = (WORD16)ps_dec->u2_mbx;
    569     mb_y = (WORD16)ps_dec->u2_mby;
    570 
    571     ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
    572 
    573     ps_top_ctxt = ps_left_ctxt = p_ctx_inc_mb_map - 1;
    574 
    575     if(u1_top_mb)
    576     {
    577         ctxt_inc_mb_info_t *ps_left_mb_of_bot = ps_left_ctxt;
    578         ctxt_inc_mb_info_t *ps_top_mb_of_bot = ps_top_ctxt;
    579 
    580         mb_x++;
    581 
    582         if(mb_x == u2_frm_width_in_mb)
    583         {
    584             mb_x = 0;
    585             mb_y += 2;
    586         }
    587 
    588         ps_curr_ctxt = p_ctx_inc_mb_map + (mb_x << 1);
    589         if(mb_y > ps_dec->i2_prev_slice_mby)
    590         {
    591             UWORD8 u1_cur_mb_fld_flag_known = 0;
    592             /* Next row */
    593             if(mb_x > 0)
    594             {
    595                 /***********************************************************************/
    596                 /*                    Left Mb is avialable                             */
    597                 /***********************************************************************/
    598                 u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
    599                 ps_left_ctxt = ps_curr_ctxt - 2;
    600                 ps_left_mb_of_bot = ps_curr_ctxt - 1;
    601                 u1_cur_mb_field = u4_left_mb_pair_fld = ps_cur_mb_row[(mb_x
    602                                 << 1) - 1].u1_mb_fld;
    603                 u1_cur_mb_fld_flag_known = 1;
    604                 u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
    605             }
    606             /* if not in the immemdiate row of prev slice end then top
    607              will be available */
    608             if(mb_y > (ps_dec->i2_prev_slice_mby + 2))
    609                 i2_prev_slice_mbx = -1;
    610             if(mb_x > i2_prev_slice_mbx)
    611             {
    612                 /*********************************************************************/
    613                 /*                    Top Mb is avialable                            */
    614                 /*********************************************************************/
    615                 u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
    616                 u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
    617                 u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
    618 
    619                 /* point to MbAddrB + 1 */
    620                 ps_top_ctxt = ps_curr_ctxt + 1;
    621                 u4_top_mb_pair_fld = ps_top_mb_row[(mb_x << 1)].u1_mb_fld;
    622 
    623                 u1_cur_mb_field =
    624                                 u1_cur_mb_fld_flag_known ?
    625                                                 u1_cur_mb_field :
    626                                                 u4_top_mb_pair_fld;
    627                 ps_top_mb_of_bot = u1_cur_mb_field ? ps_top_ctxt : ps_curr_ctxt;
    628 
    629                 /* MbAddrB */
    630                 ps_top_ctxt -= (u1_cur_mb_field && u4_top_mb_pair_fld);
    631             }
    632 
    633             if((mb_x > (i2_prev_slice_mbx - 1))
    634                             && (mb_x != (u2_frm_width_in_mb - 1)))
    635             {
    636                 u1_mb_ngbr_avail |= TOP_RIGHT_MB_AVAILABLE_MASK;
    637                 u2_top_right_mask |= TOP_RIGHT_TOPR_AVAILABLE;
    638             }
    639 
    640             if(mb_x > (i2_prev_slice_mbx + 1))
    641             {
    642                 u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
    643                 u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
    644             }
    645         }
    646         else
    647         {
    648             /* Same row */
    649             if(mb_x > (i2_prev_slice_mbx + 1))
    650             {
    651                 /***************************************************************/
    652                 /*                    Left Mb is avialable                     */
    653                 /***************************************************************/
    654                 u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
    655 
    656                 u1_cur_mb_field = u4_left_mb_pair_fld = ps_cur_mb_row[(mb_x
    657                                 << 1) - 1].u1_mb_fld;
    658                 ps_left_ctxt = ps_curr_ctxt - 2;
    659                 ps_left_mb_of_bot = ps_curr_ctxt - 1;
    660                 u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
    661             }
    662         }
    663         /*********************************************************/
    664         /* Check whether the call is from I slice or Inter slice */
    665         /*********************************************************/
    666         if(u4_mbskip)
    667         {
    668             UWORD32 u4_ctx_inc = 2
    669                             - ((!!(ps_top_ctxt->u1_mb_type & CAB_SKIP_MASK))
    670                                             + (!!(ps_left_ctxt->u1_mb_type
    671                                                             & CAB_SKIP_MASK)));
    672             dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
    673             decoding_envirnoment_t *ps_cab_dec_env = &ps_dec->s_cab_dec_env;
    674             bin_ctxt_model_t *p_mb_skip_flag_t = ps_dec->p_mb_skip_flag_t;
    675 
    676             ps_dec->u4_next_mb_skip = 0;
    677             u4_mbskip = ih264d_decode_bin(u4_ctx_inc, p_mb_skip_flag_t,
    678                                           ps_bitstrm, ps_cab_dec_env);
    679 
    680             if(u4_mbskip)
    681             {
    682                 UWORD32 u4_next_mbskip;
    683                 ps_curr_ctxt->u1_mb_type = CAB_SKIP;
    684 
    685                 u4_ctx_inc =
    686                                 2
    687                                                 - ((!!(ps_top_mb_of_bot->u1_mb_type
    688                                                                 & CAB_SKIP_MASK))
    689                                                                 + (!!(ps_left_mb_of_bot->u1_mb_type
    690                                                                                 & CAB_SKIP_MASK)));
    691 
    692                 /* Decode the skip u4_flag of bottom Mb */
    693                 u4_next_mbskip = ih264d_decode_bin(u4_ctx_inc, p_mb_skip_flag_t,
    694                                                    ps_bitstrm,
    695                                                    ps_cab_dec_env);
    696 
    697                 ps_dec->u4_next_mb_skip = u4_next_mbskip;
    698 
    699                 if(!u4_next_mbskip)
    700                 {
    701                     u4_ctx_inc = u4_top_mb_pair_fld + u4_left_mb_pair_fld;
    702 
    703                     u1_cur_mb_field = ih264d_decode_bin(
    704                                     u4_ctx_inc, ps_dec->p_mb_field_dec_flag_t,
    705                                     ps_bitstrm, ps_cab_dec_env);
    706                 }
    707             }
    708         }
    709 
    710         if(!u4_mbskip)
    711         {
    712             UWORD32 u4_ctx_inc = u4_top_mb_pair_fld + u4_left_mb_pair_fld;
    713             u1_cur_mb_field = ih264d_decode_bin(u4_ctx_inc,
    714                                                 ps_dec->p_mb_field_dec_flag_t,
    715                                                 ps_dec->ps_bitstrm,
    716                                                 &ps_dec->s_cab_dec_env);
    717         }
    718 
    719         ps_dec->u1_cur_mb_fld_dec_flag = u1_cur_mb_field;
    720         ps_dec->u2_top_left_mask = u2_top_left_mask;
    721         ps_dec->u2_top_right_mask = u2_top_right_mask;
    722         ps_dec->u2_mby = mb_y;
    723         ps_dec->u2_mbx = mb_x;
    724     }
    725     else
    726     {
    727         u1_cur_mb_field = ps_dec->u1_cur_mb_fld_dec_flag;
    728         u1_mb_ngbr_avail = ps_dec->u1_mb_ngbr_availablity;
    729         u2_top_left_mask = ps_dec->u2_top_left_mask;
    730         u2_top_right_mask = ps_dec->u2_top_right_mask;
    731         ps_curr_ctxt = p_ctx_inc_mb_map + (mb_x << 1) + 1;
    732 
    733         if(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK)
    734         {
    735             u4_left_mb_pair_fld = ps_cur_mb_row[(mb_x << 1) - 1].u1_mb_fld;
    736 
    737             /* point to A if top else A+1 */
    738             ps_left_ctxt = ps_curr_ctxt - 2
    739                             - (u4_left_mb_pair_fld != u1_cur_mb_field);
    740         }
    741 
    742         if(u1_cur_mb_field)
    743         {
    744             if(u1_mb_ngbr_avail & TOP_MB_AVAILABLE_MASK)
    745             {
    746                 /* point to MbAddrB + 1 */
    747                 ps_top_ctxt = ps_curr_ctxt;
    748             }
    749         }
    750         else
    751         {
    752             /* Top is available */
    753             u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
    754             u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
    755             u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
    756             /* Top Right not available */
    757             u1_mb_ngbr_avail &= TOP_RT_SUBBLOCK_MASK_MOD;
    758             u2_top_right_mask &= (~TOP_RIGHT_TOPR_AVAILABLE);
    759 
    760             if(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK)
    761             {
    762                 u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
    763                 u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
    764                 u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
    765             }
    766 
    767             /* CurMbAddr - 1 */
    768             ps_top_ctxt = ps_curr_ctxt - 1;
    769         }
    770 
    771         if(u4_mbskip)
    772         {
    773             if(ps_curr_ctxt[-1].u1_mb_type & CAB_SKIP_MASK)
    774             {
    775                 /* If previous mb is skipped, return value of next mb skip */
    776                 u4_mbskip = ps_dec->u4_next_mb_skip;
    777 
    778             }
    779             else
    780             {
    781                 /* If previous mb is not skipped then call DecMbSkip */
    782                 UWORD32 u4_ctx_inc =
    783                                 2
    784                                                 - ((!!(ps_top_ctxt->u1_mb_type
    785                                                                 & CAB_SKIP_MASK))
    786                                                                 + (!!(ps_left_ctxt->u1_mb_type
    787                                                                                 & CAB_SKIP_MASK)));
    788 
    789                 u4_mbskip = ih264d_decode_bin(u4_ctx_inc,
    790                                               ps_dec->p_mb_skip_flag_t,
    791                                               ps_dec->ps_bitstrm,
    792                                               &ps_dec->s_cab_dec_env);
    793             }
    794         }
    795     }
    796 
    797     ps_cur_mb_info->u2_mbx = mb_x;
    798     ps_cur_mb_info->u2_mby = mb_y;
    799     ps_cur_mb_info->u1_topmb = u1_top_mb;
    800     ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
    801     ps_dec->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
    802     ps_cur_mb_info->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
    803     ps_cur_mb_info->u1_mb_field_decodingflag = u1_cur_mb_field;
    804     ps_cur_mb_info->u2_top_left_avail_mask = u2_top_left_mask;
    805     ps_cur_mb_info->u2_top_right_avail_mask = u2_top_right_mask;
    806 
    807     ih264d_get_mbaff_neighbours(ps_dec, ps_cur_mb_info, u1_cur_mb_field);
    808     {
    809         ih264d_get_cabac_context_mbaff(ps_dec, ps_cur_mb_info, u4_mbskip);
    810     }
    811 
    812     {
    813         bin_ctxt_model_t *p_cabac_ctxt_table_t = ps_dec->p_cabac_ctxt_table_t;
    814 
    815         if(u1_cur_mb_field)
    816         {
    817             p_cabac_ctxt_table_t += SIGNIFICANT_COEFF_FLAG_FLD;
    818         }
    819         else
    820         {
    821             p_cabac_ctxt_table_t += SIGNIFICANT_COEFF_FLAG_FRAME;
    822         }
    823         {
    824             bin_ctxt_model_t * * p_significant_coeff_flag_t =
    825                             ps_dec->p_significant_coeff_flag_t;
    826             p_significant_coeff_flag_t[0] = p_cabac_ctxt_table_t
    827                             + SIG_COEFF_CTXT_CAT_0_OFFSET;
    828             p_significant_coeff_flag_t[1] = p_cabac_ctxt_table_t
    829                             + SIG_COEFF_CTXT_CAT_1_OFFSET;
    830             p_significant_coeff_flag_t[2] = p_cabac_ctxt_table_t
    831                             + SIG_COEFF_CTXT_CAT_2_OFFSET;
    832             p_significant_coeff_flag_t[3] = p_cabac_ctxt_table_t
    833                             + SIG_COEFF_CTXT_CAT_3_OFFSET;
    834             p_significant_coeff_flag_t[4] = p_cabac_ctxt_table_t
    835                             + SIG_COEFF_CTXT_CAT_4_OFFSET;
    836             p_significant_coeff_flag_t[5] = p_cabac_ctxt_table_t
    837                             + SIG_COEFF_CTXT_CAT_5_OFFSET;
    838 
    839         }
    840     }
    841     return (u4_mbskip);
    842 }
    843 
    844 /*****************************************************************************/
    845 /*                                                                           */
    846 /*  Function Name : ih264d_get_cabac_context_mbaff                                  */
    847 /*                                                                           */
    848 /*  Description   : Gets the current macroblock Cabac Context and sets the   */
    849 /*                  top and left cabac context ptrs in CtxIncMbMap           */
    850 /*                  1. For Coss field left neigbours it alters coded block   */
    851 /*                     u4_flag , motion vectors, reference indices, cbp of      */
    852 /*                     the left neigbours which increases the code i4_size      */
    853 /*                  2. For Coss field top neigbours it alters motion         */
    854 /*                     vectors reference indices of the top neigbours        */
    855 /*                     which further increases the code i4_size                 */
    856 /*                                                                           */
    857 /*  Inputs        : 1. dec_struct_t                                             */
    858 /*                  2. CurMbAddr used for Mbaff (only to see if curMB        */
    859 /*                  is top or bottom)                                        */
    860 /*                  3. uc_curMbFldDecFlag only for Mbaff                     */
    861 /*                                                                           */
    862 /*  Returns       : 0                                                        */
    863 /*                                                                           */
    864 /*  Issues        : code i4_size can be reduced if ui_CodedBlockFlag storage    */
    865 /*                  structure in context is changed. This change however     */
    866 /*                  would break the parseResidual4x4Cabac asm routine.       */
    867 /*                                                                           */
    868 /*  Revision History:                                                        */
    869 /*                                                                           */
    870 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
    871 /*         18 06 2005   Jay                                                  */
    872 /*                                                                           */
    873 /*****************************************************************************/
    874 UWORD32 ih264d_get_cabac_context_mbaff(dec_struct_t * ps_dec,
    875                                        dec_mb_info_t *ps_cur_mb_info,
    876                                        UWORD32 u4_mbskip)
    877 {
    878     const UWORD8 u1_mb_ngbr_availablity = ps_dec->u1_mb_ngbr_availablity;
    879     ctxt_inc_mb_info_t * const p_ctx_inc_mb_map = ps_dec->p_ctxt_inc_mb_map;
    880 
    881     UWORD8 (*pu1_left_mv_ctxt_inc_2d)[4] = &ps_dec->pu1_left_mv_ctxt_inc[0];
    882     WORD8 (*pi1_left_ref_idx_ctxt_inc) = ps_dec->pi1_left_ref_idx_ctxt_inc;
    883     const UWORD8 u1_cur_mb_fld_flag = ps_cur_mb_info->u1_mb_field_decodingflag;
    884     const UWORD8 u1_topmb = ps_cur_mb_info->u1_topmb;
    885     const UWORD8 uc_botMb = 1 - ps_cur_mb_info->u1_topmb;
    886 
    887     ctxt_inc_mb_info_t * ps_leftMB;
    888 
    889     ps_dec->ps_curr_ctxt_mb_info = p_ctx_inc_mb_map + (ps_dec->u2_mbx << 1);
    890     ps_dec->p_top_ctxt_mb_info = ps_dec->ps_curr_ctxt_mb_info;
    891 
    892     if(u1_topmb)
    893     {
    894         pu1_left_mv_ctxt_inc_2d = ps_dec->u1_left_mv_ctxt_inc_arr[0];
    895         pi1_left_ref_idx_ctxt_inc = &ps_dec->i1_left_ref_idx_ctx_inc_arr[0][0];
    896         ps_dec->pu1_left_yuv_dc_csbp = &ps_dec->u1_yuv_dc_csbp_topmb;
    897     }
    898     else
    899     {
    900         /* uc_botMb */
    901         pu1_left_mv_ctxt_inc_2d = ps_dec->u1_left_mv_ctxt_inc_arr[1];
    902         pi1_left_ref_idx_ctxt_inc = &ps_dec->i1_left_ref_idx_ctx_inc_arr[1][0];
    903         ps_dec->pu1_left_yuv_dc_csbp = &ps_dec->u1_yuv_dc_csbp_bot_mb;
    904         ps_dec->ps_curr_ctxt_mb_info += 1;
    905     }
    906 
    907     ps_dec->pu1_left_mv_ctxt_inc = pu1_left_mv_ctxt_inc_2d;
    908     ps_dec->pi1_left_ref_idx_ctxt_inc = pi1_left_ref_idx_ctxt_inc;
    909 
    910     if(u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK)
    911     {
    912         const UWORD8 u1_left_mb_fld_flag = ps_cur_mb_info->ps_left_mb->u1_mb_fld;
    913 
    914         ps_leftMB = ps_dec->ps_curr_ctxt_mb_info - 2;
    915         if(u1_left_mb_fld_flag != u1_cur_mb_fld_flag)
    916         {
    917             ctxt_inc_mb_info_t *ps_tempLeft;
    918             UWORD8 u1_cbp_t, u1_cbp_b;
    919             UWORD8 u1_cr_cpb;
    920 
    921             ps_leftMB -= uc_botMb;
    922             ps_tempLeft = ps_dec->ps_left_mb_ctxt_info;
    923             ps_tempLeft->u1_mb_type = ps_leftMB->u1_mb_type;
    924             ps_tempLeft->u1_intra_chroma_pred_mode =
    925                             ps_leftMB->u1_intra_chroma_pred_mode;
    926 
    927             ps_tempLeft->u1_transform8x8_ctxt = ps_leftMB->u1_transform8x8_ctxt;
    928 
    929             u1_cr_cpb = ps_leftMB->u1_cbp;
    930             /*****************************************************************/
    931             /* reform RefIdx, CBP, MV and CBF ctxInc taking care of A and A+1*/
    932             /*****************************************************************/
    933             if(u1_cur_mb_fld_flag)
    934             {
    935                 /* current MB is a FLD and left a FRM */
    936                 UWORD8 (* const pu1_left_mv_ctxt_inc_2d_arr_top)[4] =
    937                                 ps_dec->u1_left_mv_ctxt_inc_arr[0];
    938                 UWORD8 (* const pu1_left_mv_ctxt_inc_2d_arr_bot)[4] =
    939                                 ps_dec->u1_left_mv_ctxt_inc_arr[1];
    940                 WORD8 (* const i1_left_ref_idx_ctxt_inc_arr_top) =
    941                                 &ps_dec->i1_left_ref_idx_ctx_inc_arr[0][0];
    942                 WORD8 (* const i1_left_ref_idx_ctxt_inc_arr_bot) =
    943                                 &ps_dec->i1_left_ref_idx_ctx_inc_arr[1][0];
    944 
    945                 u1_cbp_t = ps_leftMB->u1_cbp;
    946                 u1_cbp_b = (ps_leftMB + 1)->u1_cbp;
    947                 ps_tempLeft->u1_cbp = (u1_cbp_t & 0x02)
    948                                 | ((u1_cbp_b & 0x02) << 2);
    949 
    950                 // set motionvectors as
    951                 // 0T = 0T  0B = 0T
    952                 // 1T = 2T  1B = 2T
    953                 // 2T = 0B  2B = 0B
    954                 // 3T = 2B  3B = 2B
    955                 if(u1_topmb)
    956                 {
    957                     /********************************************/
    958                     /*    Bottoms  DC CBF = Top DC CBF          */
    959                     /********************************************/
    960                     ps_dec->u1_yuv_dc_csbp_bot_mb =
    961                                     ps_dec->u1_yuv_dc_csbp_topmb;
    962 
    963                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[3] =
    964                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d_arr_bot[2];
    965                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[1] =
    966                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d_arr_top[2];
    967                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[2] =
    968                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d_arr_bot[0];
    969                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[0] =
    970                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d_arr_top[0];
    971 
    972                     i1_left_ref_idx_ctxt_inc_arr_top[1] =
    973                                     i1_left_ref_idx_ctxt_inc_arr_bot[0];
    974                     i1_left_ref_idx_ctxt_inc_arr_top[3] =
    975                                     i1_left_ref_idx_ctxt_inc_arr_bot[2];
    976 
    977                     *(UWORD32 *)(i1_left_ref_idx_ctxt_inc_arr_bot) =
    978                                     *(UWORD32 *)(i1_left_ref_idx_ctxt_inc_arr_top);
    979 
    980                     memcpy(pu1_left_mv_ctxt_inc_2d_arr_bot,
    981                            pu1_left_mv_ctxt_inc_2d_arr_top, 16);
    982                 }
    983 
    984                 {
    985                     UWORD8 i;
    986                     for(i = 0; i < 4; i++)
    987                     {
    988                         pu1_left_mv_ctxt_inc_2d[i][1] >>= 1;
    989                         pu1_left_mv_ctxt_inc_2d[i][3] >>= 1;
    990                     }
    991                 }
    992             }
    993             else
    994             {
    995                 /* current MB is a FRM and left FLD */
    996                 if(u1_topmb)
    997                 {
    998                     u1_cbp_t = ps_leftMB->u1_cbp;
    999                     u1_cbp_t = (u1_cbp_t & 0x02);
   1000                     ps_tempLeft->u1_cbp = (u1_cbp_t | (u1_cbp_t << 2));
   1001 
   1002                     /********************************************/
   1003                     /*    Bottoms  DC CBF = Top DC CBF          */
   1004                     /********************************************/
   1005                     ps_dec->u1_yuv_dc_csbp_bot_mb =
   1006                                     ps_dec->u1_yuv_dc_csbp_topmb;
   1007 
   1008                     // set motionvectors as
   1009                     // 3B = 2B = 3T
   1010                     // 1B = 0B = 2T
   1011                     // 3T = 2T = 1T
   1012                     // 1T = 0T = 0T
   1013 
   1014                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[7] =
   1015                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[3];
   1016                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[6] =
   1017                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[3];
   1018 
   1019                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[5] =
   1020                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[2];
   1021                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[4] =
   1022                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[2];
   1023 
   1024                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[3] =
   1025                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[1];
   1026                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[2] =
   1027                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[1];
   1028 
   1029                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[1] =
   1030                                     *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[0];
   1031 
   1032                     pi1_left_ref_idx_ctxt_inc[7] = (pi1_left_ref_idx_ctxt_inc[3]
   1033                                     - 1);
   1034                     pi1_left_ref_idx_ctxt_inc[6] = (pi1_left_ref_idx_ctxt_inc[3]
   1035                                     - 1);
   1036 
   1037                     pi1_left_ref_idx_ctxt_inc[5] = (pi1_left_ref_idx_ctxt_inc[1]
   1038                                     - 1);
   1039                     pi1_left_ref_idx_ctxt_inc[4] = (pi1_left_ref_idx_ctxt_inc[1]
   1040                                     - 1);
   1041 
   1042                     pi1_left_ref_idx_ctxt_inc[3] = (pi1_left_ref_idx_ctxt_inc[2]
   1043                                     - 1);
   1044                     pi1_left_ref_idx_ctxt_inc[2] = (pi1_left_ref_idx_ctxt_inc[2]
   1045                                     - 1);
   1046 
   1047                     pi1_left_ref_idx_ctxt_inc[1] = (pi1_left_ref_idx_ctxt_inc[0]
   1048                                     - 1);
   1049                     pi1_left_ref_idx_ctxt_inc[0] = (pi1_left_ref_idx_ctxt_inc[0]
   1050                                     - 1);
   1051                 }
   1052                 else
   1053                 {
   1054                     u1_cbp_t = ps_leftMB->u1_cbp;
   1055                     u1_cbp_t = (u1_cbp_t & 0x08);
   1056                     ps_tempLeft->u1_cbp = (u1_cbp_t | (u1_cbp_t >> 2));
   1057                 }
   1058 
   1059                 {
   1060                     UWORD8 i;
   1061                     for(i = 0; i < 4; i++)
   1062                     {
   1063                         pu1_left_mv_ctxt_inc_2d[i][1] <<= 1;
   1064                         pu1_left_mv_ctxt_inc_2d[i][3] <<= 1;
   1065                     }
   1066                 }
   1067 
   1068             }
   1069 
   1070             ps_tempLeft->u1_cbp = ps_tempLeft->u1_cbp + ((u1_cr_cpb >> 4) << 4);
   1071             ps_leftMB = ps_tempLeft;
   1072         }
   1073 
   1074         ps_dec->p_left_ctxt_mb_info = ps_leftMB;
   1075     }
   1076     else
   1077     {
   1078         ps_dec->p_left_ctxt_mb_info = p_ctx_inc_mb_map - 1;
   1079         if(!u4_mbskip)
   1080         {
   1081             *(ps_dec->pu1_left_yuv_dc_csbp) = 0;
   1082 
   1083             MEMSET_16BYTES(&pu1_left_mv_ctxt_inc_2d[0][0], 0);
   1084             *(UWORD32 *)pi1_left_ref_idx_ctxt_inc = 0;
   1085         }
   1086     }
   1087 
   1088     /*************************************************************************/
   1089     /*                Now get the top context mb info                        */
   1090     /*************************************************************************/
   1091     {
   1092         UWORD8 (*u1_top_mv_ctxt_inc_arr_2d)[4] =
   1093                         ps_dec->ps_curr_ctxt_mb_info->u1_mv;
   1094         WORD8 (*pi1_top_ref_idx_ctxt_inc) =
   1095                         ps_dec->ps_curr_ctxt_mb_info->i1_ref_idx;
   1096         UWORD8 uc_topMbFldDecFlag = ps_cur_mb_info->ps_top_mb->u1_mb_fld;
   1097 
   1098         if(u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK)
   1099         {
   1100             if(ps_cur_mb_info->i1_offset)
   1101                 ps_dec->p_top_ctxt_mb_info += 1;
   1102 
   1103             if(!u4_mbskip)
   1104             {
   1105                 memcpy(u1_top_mv_ctxt_inc_arr_2d,
   1106                        &ps_dec->p_top_ctxt_mb_info->u1_mv, 16);
   1107                 memcpy(pi1_top_ref_idx_ctxt_inc,
   1108                        &ps_dec->p_top_ctxt_mb_info->i1_ref_idx, 4);
   1109                 if(uc_topMbFldDecFlag ^ u1_cur_mb_fld_flag)
   1110                 {
   1111                     UWORD8 i;
   1112                     if(u1_cur_mb_fld_flag)
   1113                     {
   1114                         for(i = 0; i < 4; i++)
   1115                         {
   1116                             u1_top_mv_ctxt_inc_arr_2d[i][1] >>= 1;
   1117                             u1_top_mv_ctxt_inc_arr_2d[i][3] >>= 1;
   1118                         }
   1119                     }
   1120                     else
   1121                     {
   1122                         for(i = 0; i < 4; i++)
   1123                         {
   1124                             u1_top_mv_ctxt_inc_arr_2d[i][1] <<= 1;
   1125                             u1_top_mv_ctxt_inc_arr_2d[i][3] <<= 1;
   1126                             pi1_top_ref_idx_ctxt_inc[i] -= 1;
   1127                         }
   1128                     }
   1129                 }
   1130             }
   1131         }
   1132         else
   1133         {
   1134             ps_dec->p_top_ctxt_mb_info = p_ctx_inc_mb_map - 1;
   1135             if(!u4_mbskip)
   1136             {
   1137 
   1138                 MEMSET_16BYTES(&u1_top_mv_ctxt_inc_arr_2d[0][0], 0);
   1139                 memset(pi1_top_ref_idx_ctxt_inc, 0, 4);
   1140             }
   1141         }
   1142     }
   1143 
   1144     return OK;
   1145 }
   1146 
   1147 /*****************************************************************************/
   1148 /*                                                                           */
   1149 /*  Function Name : ih264d_update_mbaff_left_nnz                                    */
   1150 /*                                                                           */
   1151 /*  Description   : This function updates the left luma and chroma nnz for   */
   1152 /*                  mbaff cases.                                             */
   1153 /*                                                                           */
   1154 /*  Inputs        : <What inputs does the function take?>                    */
   1155 /*  Globals       : <Does it use any global variables?>                      */
   1156 /*  Processing    : <Describe how the function operates - include algorithm  */
   1157 /*                  description>                                             */
   1158 /*  Outputs       : <What does the function produce?>                        */
   1159 /*  Returns       : <What does the function return?>                         */
   1160 /*                                                                           */
   1161 /*  Issues        : <List any issues or problems with this function>         */
   1162 /*                                                                           */
   1163 /*  Revision History:                                                        */
   1164 /*                                                                           */
   1165 /*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
   1166 /*         13 07 2002   Ittiam          Draft                                */
   1167 /*                                                                           */
   1168 /*****************************************************************************/
   1169 void ih264d_update_mbaff_left_nnz(dec_struct_t * ps_dec,
   1170                                   dec_mb_info_t * ps_cur_mb_info)
   1171 {
   1172     UWORD32 *pu4_buf;
   1173     UWORD8 *pu1_buf;
   1174     if(ps_cur_mb_info->u1_topmb)
   1175     {
   1176         pu1_buf = ps_dec->pu1_left_nnz_y;
   1177         pu4_buf = (UWORD32 *)pu1_buf;
   1178         ps_dec->u4_n_left_temp_y = *pu4_buf;
   1179 
   1180         pu1_buf = ps_dec->pu1_left_nnz_uv;
   1181         pu4_buf = (UWORD32 *)pu1_buf;
   1182         ps_dec->u4_n_left_temp_uv = *pu4_buf;
   1183     }
   1184     else
   1185     {
   1186 
   1187         ps_dec->u4_n_leftY[0] = ps_dec->u4_n_left_temp_y;
   1188         pu1_buf = ps_dec->pu1_left_nnz_y;
   1189         pu4_buf = (UWORD32 *)pu1_buf;
   1190         ps_dec->u4_n_leftY[1] = *pu4_buf;
   1191         ps_dec->u4_n_left_cr[0] = ps_dec->u4_n_left_temp_uv;
   1192         pu1_buf = ps_dec->pu1_left_nnz_uv;
   1193         pu4_buf = (UWORD32 *)pu1_buf;
   1194         ps_dec->u4_n_left_cr[1] = *pu4_buf;
   1195 
   1196     }
   1197 }
   1198 
   1199 /*!
   1200  **************************************************************************
   1201  * \if Function name : ih264d_get_mbaff_neighbours \endif
   1202  *
   1203  * \brief
   1204  *    Gets the neighbors for the current MB if it is of type MB-AFF
   1205  *  frame.
   1206  *
   1207  * \return
   1208  *    None
   1209  *
   1210  **************************************************************************
   1211  */
   1212 void ih264d_get_mbaff_neighbours(dec_struct_t * ps_dec,
   1213                                  dec_mb_info_t * ps_cur_mb_info,
   1214                                  UWORD8 uc_curMbFldDecFlag)
   1215 {
   1216 
   1217     mb_neigbour_params_t *ps_left_mb;
   1218     mb_neigbour_params_t *ps_top_mb;
   1219     mb_neigbour_params_t *ps_top_right_mb = NULL;
   1220     mb_neigbour_params_t *ps_curmb;
   1221     const UWORD8 u1_topmb = ps_cur_mb_info->u1_topmb;
   1222     const UWORD8 uc_botMb = 1 - u1_topmb;
   1223     const UWORD32 u4_mb_x = ps_cur_mb_info->u2_mbx;
   1224 
   1225     /* Current MbParams location in top row buffer */
   1226     ps_curmb = ps_dec->ps_cur_mb_row + (u4_mb_x << 1) + uc_botMb;
   1227     ps_left_mb = ps_curmb - 2;
   1228     /* point to A if top else A+1 */
   1229     if(uc_botMb && (ps_left_mb->u1_mb_fld != uc_curMbFldDecFlag))
   1230     {
   1231         /* move from A + 1 to A */
   1232         ps_left_mb--;
   1233     }
   1234     ps_cur_mb_info->i1_offset = 0;
   1235     if((uc_curMbFldDecFlag == 0) && uc_botMb)
   1236     {
   1237         mb_neigbour_params_t *ps_topleft_mb;
   1238         /* CurMbAddr - 1 */
   1239         ps_top_mb = ps_curmb - 1;
   1240 
   1241         /* Mark Top right Not available */
   1242         /* point to A */
   1243         ps_topleft_mb = ps_curmb - 3;
   1244 
   1245         if(ps_topleft_mb->u1_mb_fld)
   1246         {
   1247             /* point to A + 1 */
   1248             ps_topleft_mb++;
   1249         }
   1250         ps_cur_mb_info->u1_topleft_mb_fld = ps_topleft_mb->u1_mb_fld;
   1251         ps_cur_mb_info->u1_topleft_mbtype = ps_topleft_mb->u1_mb_type;
   1252     }
   1253     else
   1254     {
   1255         /* Top = B + 1 */
   1256         ps_top_mb = ps_dec->ps_top_mb_row + (u4_mb_x << 1) + 1;
   1257         ps_top_right_mb = ps_top_mb + 2;
   1258         ps_cur_mb_info->i1_offset = 4;
   1259         /* TopRight =  C + 1 */
   1260 
   1261         /* TopLeft = D+1 */
   1262         ps_cur_mb_info->u1_topleft_mb_fld = ps_dec->u1_topleft_mb_fld_bot;
   1263         ps_cur_mb_info->u1_topleft_mbtype = ps_dec->u1_topleft_mbtype_bot;
   1264 
   1265         if(uc_curMbFldDecFlag && u1_topmb)
   1266         {
   1267             if(ps_top_mb->u1_mb_fld)
   1268             {
   1269                 /* MbAddrB */
   1270                 ps_top_mb--;
   1271                 ps_cur_mb_info->i1_offset = 0;
   1272             }
   1273             /* If topright is field then point to C */
   1274             ps_top_right_mb -= ps_top_right_mb->u1_mb_fld ? 1 : 0;
   1275             if(ps_cur_mb_info->u1_topleft_mb_fld)
   1276             {
   1277                 /* TopLeft = D */
   1278                 ps_cur_mb_info->u1_topleft_mb_fld = ps_dec->u1_topleft_mb_fld;
   1279                 ps_cur_mb_info->u1_topleft_mbtype = ps_dec->u1_topleft_mbtype;
   1280             }
   1281         }
   1282     }
   1283     if(u1_topmb)
   1284     {
   1285         /* Update the parameters of topleftmb*/
   1286         ps_dec->u1_topleft_mb_fld = ps_top_mb->u1_mb_fld;
   1287         ps_dec->u1_topleft_mbtype = ps_top_mb->u1_mb_type;
   1288         /* Set invscan and dequantMatrixScan*/
   1289         if(uc_curMbFldDecFlag)
   1290         {
   1291             ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan_fld;
   1292         }
   1293         else
   1294         {
   1295             ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan;
   1296         }
   1297         ps_dec->pu2_quant_scale_y =
   1298                         gau2_ih264_iquant_scale_4x4[ps_dec->u1_qp_y_rem6];
   1299         ps_dec->pu2_quant_scale_u =
   1300                         gau2_ih264_iquant_scale_4x4[ps_dec->u1_qp_u_rem6];
   1301         ps_dec->pu2_quant_scale_v =
   1302                         gau2_ih264_iquant_scale_4x4[ps_dec->u1_qp_v_rem6];
   1303 
   1304     }
   1305     else
   1306     {
   1307         /* Update the parameters of topleftmb*/
   1308         mb_neigbour_params_t *ps_top_mb_temp = ps_dec->ps_top_mb_row
   1309                         + (u4_mb_x << 1) + 1;
   1310         ps_dec->u1_topleft_mb_fld_bot = ps_top_mb_temp->u1_mb_fld;
   1311         ps_dec->u1_topleft_mbtype_bot = ps_top_mb_temp->u1_mb_type;
   1312     }
   1313 
   1314     ps_cur_mb_info->ps_left_mb = ps_left_mb;
   1315     ps_cur_mb_info->ps_top_mb = ps_top_mb;
   1316     ps_cur_mb_info->ps_top_right_mb = ps_top_right_mb;
   1317     ps_cur_mb_info->ps_curmb = ps_curmb;
   1318     ps_curmb->u1_mb_fld = uc_curMbFldDecFlag;
   1319 
   1320     {
   1321         /* Form Left NNZ */
   1322         UWORD8 u1_is_left_mb_fld = ps_left_mb->u1_mb_fld;
   1323         UWORD8 *pu1_left_mb_pair_nnz_y = (UWORD8 *)&ps_dec->u4_n_leftY[0];
   1324         UWORD8 *pu1_left_mb_pair_nnz_uv = (UWORD8 *)&ps_dec->u4_n_left_cr[0];
   1325         UWORD8 *pu1_left_nnz_y = ps_dec->pu1_left_nnz_y;
   1326         UWORD8 *pu1_left_nnz_uv = ps_dec->pu1_left_nnz_uv;
   1327 
   1328         if(uc_curMbFldDecFlag == u1_is_left_mb_fld)
   1329         {
   1330             *(UWORD32 *)pu1_left_nnz_y = *(UWORD32 *)(pu1_left_mb_pair_nnz_y
   1331                             + (uc_botMb << 2));
   1332             *(UWORD32 *)pu1_left_nnz_uv = *(UWORD32 *)(pu1_left_mb_pair_nnz_uv
   1333                             + (uc_botMb << 2));
   1334         }
   1335         else if((uc_curMbFldDecFlag == 0) && u1_topmb && u1_is_left_mb_fld)
   1336         {
   1337             /* 0 0 1 1 of u4_n_leftY[0], 0 0 2 2 of u4_n_left_cr[0] */
   1338             pu1_left_nnz_y[0] = pu1_left_nnz_y[1] = pu1_left_mb_pair_nnz_y[0];
   1339             pu1_left_nnz_y[2] = pu1_left_nnz_y[3] = pu1_left_mb_pair_nnz_y[1];
   1340             pu1_left_nnz_uv[0] = pu1_left_nnz_uv[1] =
   1341                             pu1_left_mb_pair_nnz_uv[0];
   1342             pu1_left_nnz_uv[2] = pu1_left_nnz_uv[3] =
   1343                             pu1_left_mb_pair_nnz_uv[2];
   1344         }
   1345         else if((uc_curMbFldDecFlag == 0) && uc_botMb && u1_is_left_mb_fld)
   1346         {
   1347             /* 2 2 3 3 of u4_n_leftY[0] , 1 1 3 3 of u4_n_left_cr[0] */
   1348             pu1_left_nnz_y[0] = pu1_left_nnz_y[1] = pu1_left_mb_pair_nnz_y[2];
   1349             pu1_left_nnz_y[2] = pu1_left_nnz_y[3] = pu1_left_mb_pair_nnz_y[3];
   1350             pu1_left_nnz_uv[0] = pu1_left_nnz_uv[1] =
   1351                             pu1_left_mb_pair_nnz_uv[1];
   1352             pu1_left_nnz_uv[2] = pu1_left_nnz_uv[3] =
   1353                             pu1_left_mb_pair_nnz_uv[3];
   1354         }
   1355         else
   1356         {
   1357             /* 0 2 0 2 of u4_n_leftY[0], u4_n_leftY[1] */
   1358             pu1_left_nnz_y[0] = pu1_left_mb_pair_nnz_y[0];
   1359             pu1_left_nnz_y[1] = pu1_left_mb_pair_nnz_y[2];
   1360             pu1_left_nnz_y[2] = pu1_left_mb_pair_nnz_y[4 + 0];
   1361             pu1_left_nnz_y[3] = pu1_left_mb_pair_nnz_y[4 + 2];
   1362 
   1363             /* 0 of u4_n_left_cr[0] and 0 u4_n_left_cr[1]
   1364              2 of u4_n_left_cr[0] and 2 u4_n_left_cr[1] */
   1365             pu1_left_nnz_uv[0] = pu1_left_mb_pair_nnz_uv[0];
   1366             pu1_left_nnz_uv[1] = pu1_left_mb_pair_nnz_uv[4 + 0];
   1367             pu1_left_nnz_uv[2] = pu1_left_mb_pair_nnz_uv[2];
   1368             pu1_left_nnz_uv[3] = pu1_left_mb_pair_nnz_uv[4 + 2];
   1369         }
   1370     }
   1371 }
   1372 
   1373 /*
   1374  **************************************************************************
   1375  * \if Function name : ih264d_transfer_mb_group_data \endif
   1376  *
   1377  * \brief
   1378  *     Transfer the Following things
   1379  *     N-Mb DeblkParams Data    ( To Ext DeblkParams Buffer )
   1380  *     N-Mb Recon Data          ( To Ext Frame Buffer )
   1381  *     N-Mb Intrapredline Data  ( Updated Internally)
   1382  *     N-Mb MV Data             ( To Ext MV Buffer )
   1383  *     N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers)
   1384  *
   1385  * \return
   1386  *    None
   1387  *
   1388  **************************************************************************
   1389  */
   1390 void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
   1391                                    const UWORD8 u1_num_mbs,
   1392                                    const UWORD8 u1_end_of_row, /* Cur n-Mb End of Row Flag */
   1393                                    const UWORD8 u1_end_of_row_next /* Next n-Mb End of Row Flag */
   1394                                    )
   1395 {
   1396     dec_mb_info_t *ps_cur_mb_info = ps_dec->ps_nmb_info;
   1397     tfr_ctxt_t *ps_trns_addr = &ps_dec->s_tran_addrecon;
   1398     UWORD16 u2_mb_y;
   1399     UWORD32 y_offset;
   1400     UWORD32 u4_frame_stride;
   1401     mb_neigbour_params_t *ps_temp;
   1402     const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
   1403     UNUSED(u1_end_of_row_next);
   1404 
   1405     ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u1_end_of_row];
   1406     ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u1_end_of_row];
   1407     ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u1_end_of_row];
   1408 
   1409     /* Swap top and current pointers */
   1410     if(u1_end_of_row)
   1411     {
   1412 
   1413         if(ps_dec->u1_separate_parse)
   1414         {
   1415             u2_mb_y = ps_dec->i2_dec_thread_mb_y;
   1416         }
   1417         else
   1418         {
   1419             ps_temp = ps_dec->ps_cur_mb_row;
   1420             ps_dec->ps_cur_mb_row = ps_dec->ps_top_mb_row;
   1421             ps_dec->ps_top_mb_row = ps_temp;
   1422 
   1423             u2_mb_y = ps_dec->u2_mby + (1 + u1_mbaff);
   1424         }
   1425 
   1426         u4_frame_stride = ps_dec->u2_frm_wd_y
   1427                         << ps_dec->ps_cur_slice->u1_field_pic_flag;
   1428         y_offset = (u2_mb_y * u4_frame_stride) << 4;
   1429         ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + y_offset;
   1430 
   1431         u4_frame_stride = ps_dec->u2_frm_wd_uv
   1432                         << ps_dec->ps_cur_slice->u1_field_pic_flag;
   1433         y_offset = (u2_mb_y * u4_frame_stride) << 3;
   1434         ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + y_offset;
   1435         ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + y_offset;
   1436 
   1437         ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
   1438         ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
   1439         ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
   1440     }
   1441 
   1442     /*
   1443      * The Slice boundary is also a valid condition to transfer. So recalculate
   1444      * the Left increment, in case the number of MBs is lesser than the
   1445      * N MB value. u1_num_mbs will be equal to N of N MB if the entire N Mb is
   1446      * decoded.
   1447      */
   1448     ps_dec->s_tran_addrecon.u2_mv_left_inc = ((u1_num_mbs >> u1_mbaff) - 1)
   1449                     << (4 + u1_mbaff);
   1450     ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (u1_num_mbs << 2) - 1
   1451                     - (u1_mbaff << 2);
   1452 
   1453     if(ps_dec->u1_separate_parse == 0)
   1454     {
   1455         /* reassign left MV and cur MV pointers */
   1456         ps_dec->ps_mv_left = ps_dec->ps_mv_cur
   1457                         + ps_dec->s_tran_addrecon.u2_mv_left_inc;
   1458 
   1459         ps_dec->ps_mv_cur += (u1_num_mbs << 4);
   1460     }
   1461 
   1462     /* Increment deblock parameters pointer in external memory */
   1463 
   1464     if(ps_dec->u1_separate_parse == 0)
   1465     {
   1466         ps_dec->ps_deblk_mbn += u1_num_mbs;
   1467     }
   1468 
   1469 }
   1470 
   1471