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 
ih264d_get_mb_info_cavlc_nonmbaff(dec_struct_t * ps_dec,const UWORD16 u2_cur_mb_address,dec_mb_info_t * ps_cur_mb_info,UWORD32 u4_mbskip_run)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 
ih264d_get_mb_info_cavlc_mbaff(dec_struct_t * ps_dec,const UWORD16 u2_cur_mb_address,dec_mb_info_t * ps_cur_mb_info,UWORD32 u4_mbskip_run)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 /*****************************************************************************/
ih264d_get_mb_info_cabac_nonmbaff(dec_struct_t * ps_dec,const UWORD16 u2_cur_mb_address,dec_mb_info_t * ps_cur_mb_info,UWORD32 u4_mbskip)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 
ih264d_get_mb_info_cabac_mbaff(dec_struct_t * ps_dec,const UWORD16 u2_cur_mb_address,dec_mb_info_t * ps_cur_mb_info,UWORD32 u4_mbskip)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 /*****************************************************************************/
ih264d_get_cabac_context_mbaff(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,UWORD32 u4_mbskip)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 /*****************************************************************************/
ih264d_update_mbaff_left_nnz(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info)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  */
ih264d_get_mbaff_neighbours(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,UWORD8 uc_curMbFldDecFlag)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  */
ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,const UWORD8 u1_num_mbs,const UWORD8 u1_end_of_row,const UWORD8 u1_end_of_row_next)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