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