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