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_mvpred.c 23 * 24 * \brief 25 * This file contains function specific to decoding Motion vector. 26 * 27 * Detailed_description 28 * 29 * \date 30 * 10-12-2002 31 * 32 * \author Arvind Raman 33 ************************************************************************** 34 */ 35#include <string.h> 36#include "ih264d_parse_cavlc.h" 37#include "ih264d_error_handler.h" 38#include "ih264d_structs.h" 39#include "ih264d_defs.h" 40#include "ih264_typedefs.h" 41#include "ih264_macros.h" 42#include "ih264_platform_macros.h" 43#include "ih264d_mb_utils.h" 44#include "ih264d_defs.h" 45#include "ih264d_debug.h" 46#include "ih264d_tables.h" 47#include "ih264d_process_bslice.h" 48#include "ih264d_mvpred.h" 49#include "ih264d_inter_pred.h" 50#include "ih264d_tables.h" 51 52/*! 53 ************************************************************************** 54 * \if ih264d_get_motion_vector_predictor name : Name \endif 55 * 56 * \brief 57 * The routine calculates the motion vector predictor for a given block, 58 * given the candidate MV predictors. 59 * 60 * \param ps_mv_pred: Candidate predictors for the current block 61 * \param ps_currMv: Pointer to the left top edge of the current block in 62 * the MV bank 63 * 64 * \return 65 * _mvPred: The x & y components of the MV predictor. 66 * 67 * \note 68 * The code implements the logic as described in sec 8.4.1.2.1. Given 69 * the candidate predictors and the pointer to the top left edge of the 70 * block in the MV bank. 71 * 72 ************************************************************************** 73 */ 74 75void ih264d_get_motion_vector_predictor(mv_pred_t * ps_result, 76 mv_pred_t **ps_mv_pred, 77 UWORD8 u1_ref_idx, 78 UWORD8 u1_B, 79 const UWORD8 *pu1_mv_pred_condition) 80{ 81 WORD8 c_temp; 82 UWORD8 uc_B2 = (u1_B << 1); 83 84 /* If only one of the candidate blocks has a reference frame equal to 85 the current block then use the same block as the final predictor */ 86 c_temp = 87 (ps_mv_pred[LEFT]->i1_ref_frame[u1_B] == u1_ref_idx) 88 | ((ps_mv_pred[TOP]->i1_ref_frame[u1_B] 89 == u1_ref_idx) << 1) 90 | ((ps_mv_pred[TOP_R]->i1_ref_frame[u1_B] 91 == u1_ref_idx) << 2); 92 c_temp = pu1_mv_pred_condition[c_temp]; 93 94 if(c_temp != -1) 95 { 96 /* Case when only when one of the cadidate block has the same 97 reference frame as the current block */ 98 ps_result->i2_mv[uc_B2 + 0] = ps_mv_pred[c_temp]->i2_mv[uc_B2 + 0]; 99 ps_result->i2_mv[uc_B2 + 1] = ps_mv_pred[c_temp]->i2_mv[uc_B2 + 1]; 100 } 101 else 102 { 103 WORD32 D0, D1; 104 D0 = MIN(ps_mv_pred[0]->i2_mv[uc_B2 + 0], 105 ps_mv_pred[1]->i2_mv[uc_B2 + 0]); 106 D1 = MAX(ps_mv_pred[0]->i2_mv[uc_B2 + 0], 107 ps_mv_pred[1]->i2_mv[uc_B2 + 0]); 108 D1 = MIN(D1, ps_mv_pred[2]->i2_mv[uc_B2 + 0]); 109 ps_result->i2_mv[uc_B2 + 0] = (WORD16)(MAX(D0, D1)); 110 111 D0 = MIN(ps_mv_pred[0]->i2_mv[uc_B2 + 1], 112 ps_mv_pred[1]->i2_mv[uc_B2 + 1]); 113 D1 = MAX(ps_mv_pred[0]->i2_mv[uc_B2 + 1], 114 ps_mv_pred[1]->i2_mv[uc_B2 + 1]); 115 D1 = MIN(D1, ps_mv_pred[2]->i2_mv[uc_B2 + 1]); 116 ps_result->i2_mv[uc_B2 + 1] = (WORD16)(MAX(D0, D1)); 117 118 } 119} 120 121/*! 122 ************************************************************************** 123 * \if ih264d_mbaff_mv_pred name : Name \endif 124 * 125 * \brief 126 * The routine calculates the motion vector predictor for a given block, 127 * given the candidate MV predictors. 128 * 129 * \param ps_mv_pred: Candidate predictors for the current block 130 * \param ps_currMv: Pointer to the left top edge of the current block in 131 * the MV bank 132 * 133 * \return 134 * _mvPred: The x & y components of the MV predictor. 135 * 136 * \note 137 * The code implements the logic as described in sec 8.4.1.2.1. Given 138 * the candidate predictors and the pointer to the top left edge of the 139 * block in the MV bank. 140 * 141 ************************************************************************** 142 */ 143 144void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred, 145 UWORD8 u1_sub_mb_num, 146 mv_pred_t *ps_mv_nmb, 147 mv_pred_t *ps_mv_ntop, 148 dec_struct_t *ps_dec, 149 UWORD8 uc_mb_part_width, 150 dec_mb_info_t *ps_cur_mb_info, 151 UWORD8* pu0_scale) 152{ 153 UWORD16 u2_a_in = 0, u2_b_in = 0, u2_c_in = 0, u2_d_in = 0; 154 mv_pred_t *ps_mvpred_l, *ps_mvpred_tmp; 155 UWORD8 u1_sub_mb_x = (u1_sub_mb_num & 3), uc_sub_mb_y = (u1_sub_mb_num >> 2); 156 UWORD8 u1_is_cur_mb_fld, u1_is_left_mb_fld, u1_is_top_mb_fld; 157 UWORD8 u1_is_cur_mb_top; 158 159 u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag; 160 u1_is_cur_mb_top = ps_cur_mb_info->u1_topmb; 161 162 u1_is_left_mb_fld = ps_cur_mb_info->ps_left_mb->u1_mb_fld; 163 u1_is_top_mb_fld = ps_cur_mb_info->ps_top_mb->u1_mb_fld; 164 165 /* Checking in the subMB exists, calculating their motion vectors to be 166 used as predictors and the reference frames of those subMBs */ 167 ps_mv_pred[LEFT] = &ps_dec->s_default_mv_pred; 168 ps_mv_pred[TOP] = &(ps_dec->s_default_mv_pred); 169 ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred); 170 171 /* Check if the left subMb is available */ 172 if(u1_sub_mb_x) 173 { 174 u2_a_in = 1; 175 ps_mv_pred[LEFT] = (ps_mv_nmb - 1); 176 } 177 else 178 { 179 UWORD8 uc_temp; 180 u2_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK); 181 if(u2_a_in) 182 { 183 ps_mvpred_l = (ps_dec->u4_num_pmbair) ? 184 ps_mv_nmb : 185 (ps_dec->ps_mv_left + (uc_sub_mb_y << 2) + 48 186 - (u1_is_cur_mb_top << 4)); 187 uc_temp = 29; 188 if(u1_is_cur_mb_fld ^ u1_is_left_mb_fld) 189 { 190 if(u1_is_left_mb_fld) 191 { 192 uc_temp += 193 (((uc_sub_mb_y & 1) << 2) 194 + ((uc_sub_mb_y & 2) << 1)); 195 uc_temp += ((u1_is_cur_mb_top) ? 0 : 8); 196 } 197 else 198 { 199 uc_temp = uc_temp - (uc_sub_mb_y << 2); 200 uc_temp += ((u1_is_cur_mb_top) ? 0 : 16); 201 } 202 } 203 ps_mv_pred[LEFT] = (ps_mvpred_l - uc_temp); 204 pu0_scale[LEFT] = u1_is_cur_mb_fld - u1_is_left_mb_fld; 205 } 206 } 207 208 /* Check if the top subMB is available */ 209 if((uc_sub_mb_y > 0) || ((u1_is_cur_mb_top | u1_is_cur_mb_fld) == 0)) 210 { 211 u2_b_in = 1; 212 ps_mv_pred[TOP] = ps_mv_nmb - 4; 213 } 214 else 215 { 216 u2_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK); 217 if(u2_b_in) 218 { 219 /* CHANGED CODE */ 220 221 if(u1_is_top_mb_fld && u1_is_cur_mb_fld) 222 ps_mvpred_tmp = ps_mv_ntop; 223 else 224 { 225 ps_mvpred_tmp = ps_mv_ntop; 226 if(u1_is_cur_mb_top) 227 ps_mvpred_tmp += 16; 228 } 229 230 ps_mv_pred[TOP] = ps_mvpred_tmp; 231 pu0_scale[TOP] = u1_is_cur_mb_fld - u1_is_top_mb_fld; 232 } 233 } 234 235 /* Check if the top right subMb is available. The top right subMb is 236 defined as the top right subMb at the top right corner of the MB 237 partition. The top right subMb index starting from the top left 238 corner of the MB partition is given by 239 TopRightSubMbIndx = TopLeftSubMbIndx + (WidthOfMbPartition - 6) / 2 240 */ 241 u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask, 242 (u1_sub_mb_num + uc_mb_part_width - 1)); 243 if(u2_c_in) 244 { 245 ps_mv_pred[TOP_R] = ps_mv_pred[TOP] + uc_mb_part_width; 246 pu0_scale[TOP_R] = pu0_scale[TOP]; 247 if((uc_sub_mb_y == 0) && ((u1_sub_mb_x + uc_mb_part_width) > 3)) 248 { 249 UWORD8 uc_isTopRtMbFld; 250 uc_isTopRtMbFld = ps_cur_mb_info->ps_top_right_mb->u1_mb_fld; 251 /* CHANGED CODE */ 252 ps_mvpred_tmp = ps_mv_ntop + uc_mb_part_width + 12; 253 ps_mvpred_tmp += (u1_is_cur_mb_top) ? 16 : 0; 254 ps_mvpred_tmp += (u1_is_cur_mb_fld && u1_is_cur_mb_top && uc_isTopRtMbFld) ? 255 0 : 16; 256 ps_mv_pred[TOP_R] = ps_mvpred_tmp; 257 pu0_scale[TOP_R] = u1_is_cur_mb_fld - uc_isTopRtMbFld; 258 } 259 } 260 else 261 { 262 u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u1_sub_mb_num); 263 264 /* Check if the the top left subMB is available */ 265 if(u2_d_in) 266 { 267 UWORD8 uc_isTopLtMbFld; 268 269 ps_mv_pred[TOP_R] = ps_mv_pred[TOP] - 1; 270 pu0_scale[TOP_R] = pu0_scale[TOP]; 271 272 if(u1_sub_mb_x == 0) 273 { 274 if((uc_sub_mb_y > 0) || ((u1_is_cur_mb_top | u1_is_cur_mb_fld) == 0)) 275 { 276 uc_isTopLtMbFld = u1_is_left_mb_fld; 277 ps_mvpred_tmp = ps_mv_pred[LEFT] - 4; 278 279 if((u1_is_cur_mb_fld == 0) && uc_isTopLtMbFld) 280 { 281 ps_mvpred_tmp = ps_mv_pred[LEFT] + 16; 282 ps_mvpred_tmp -= (uc_sub_mb_y & 1) ? 0 : 4; 283 } 284 } 285 else 286 { 287 UWORD32 u4_cond = ps_dec->u4_num_pmbair; 288 uc_isTopLtMbFld = ps_cur_mb_info->u1_topleft_mb_fld; 289 290 /* CHANGED CODE */ 291 ps_mvpred_tmp = ps_mv_ntop - 29; 292 ps_mvpred_tmp += (u1_is_cur_mb_top) ? 16 : 0; 293 if(u1_is_cur_mb_fld && u1_is_cur_mb_top) 294 ps_mvpred_tmp -= (uc_isTopLtMbFld) ? 16 : 0; 295 } 296 ps_mv_pred[TOP_R] = ps_mvpred_tmp; 297 pu0_scale[TOP_R] = u1_is_cur_mb_fld - uc_isTopLtMbFld; 298 } 299 } 300 else if(u2_b_in == 0) 301 { 302 /* If all the subMBs B, C, D are all out of the frame then their MV 303 and their reference picture is equal to that of A */ 304 ps_mv_pred[TOP] = ps_mv_pred[LEFT]; 305 ps_mv_pred[TOP_R] = ps_mv_pred[LEFT]; 306 pu0_scale[TOP] = pu0_scale[LEFT]; 307 pu0_scale[TOP_R] = pu0_scale[LEFT]; 308 } 309 } 310} 311 312/*! 313 ************************************************************************** 314 * \if ih264d_non_mbaff_mv_pred name : Name \endif 315 * 316 * \brief 317 * The routine calculates the motion vector predictor for a given block, 318 * given the candidate MV predictors. 319 * 320 * \param ps_mv_pred: Candidate predictors for the current block 321 * \param ps_currMv: Pointer to the left top edge of the current block in 322 * the MV bank 323 * 324 * \return 325 * _mvPred: The x & y components of the MV predictor. 326 * 327 * \note 328 * The code implements the logic as described in sec 8.4.1.2.1. Given 329 * the candidate predictors and the pointer to the top left edge of the 330 * block in the MV bank. 331 * 332 ************************************************************************** 333 */ 334#if(!MVPRED_NONMBAFF) 335void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred, 336 UWORD8 u1_sub_mb_num, 337 mv_pred_t *ps_mv_nmb, 338 mv_pred_t *ps_mv_ntop, 339 dec_struct_t *ps_dec, 340 UWORD8 uc_mb_part_width, 341 dec_mb_info_t *ps_cur_mb_info) 342{ 343 UWORD16 u2_b_in = 0, u2_c_in = 0, u2_d_in = 0; 344 UWORD8 u1_sub_mb_x = (u1_sub_mb_num & 3), uc_sub_mb_y = (u1_sub_mb_num >> 2); 345 346 /* Checking in the subMB exists, calculating their motion vectors to be 347 used as predictors and the reference frames of those subMBs */ 348 349 ps_mv_pred[LEFT] = &ps_dec->s_default_mv_pred; 350 ps_mv_pred[TOP] = &(ps_dec->s_default_mv_pred); 351 ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred); 352 /* Check if the left subMb is available */ 353 354 if(u1_sub_mb_x) 355 { 356 ps_mv_pred[LEFT] = (ps_mv_nmb - 1); 357 } 358 else 359 { 360 if(ps_cur_mb_info->u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK) 361 { 362 ps_mv_pred[LEFT] = (ps_mv_nmb - 13); 363 } 364 } 365 366 /* Check if the top subMB is available */ 367 if(uc_sub_mb_y) 368 { 369 u2_b_in = 1; 370 ps_mv_ntop = ps_mv_nmb - 4; 371 ps_mv_pred[TOP] = ps_mv_ntop; 372 373 } 374 else 375 { 376 u2_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK); 377 if(u2_b_in) 378 { 379 ps_mv_pred[TOP] = ps_mv_ntop; 380 } 381 } 382 383 /* Check if the top right subMb is available. The top right subMb is 384 defined as the top right subMb at the top right corner of the MB 385 partition. The top right subMb index starting from the top left 386 corner of the MB partition is given by 387 TopRightSubMbIndx = TopLeftSubMbIndx + (WidthOfMbPartition - 6) / 2 388 */ 389 u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask, 390 (u1_sub_mb_num + uc_mb_part_width - 1)); 391 if(u2_c_in) 392 { 393 ps_mv_pred[TOP_R] = (ps_mv_ntop + uc_mb_part_width); 394 395 if(uc_sub_mb_y == 0) 396 { 397 /* CHANGED CODE */ 398 if((u1_sub_mb_x + uc_mb_part_width) > 3) 399 ps_mv_pred[TOP_R] += 12; 400 } 401 } 402 else 403 { 404 u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u1_sub_mb_num); 405 /* Check if the the top left subMB is available */ 406 if(u2_d_in) 407 { 408 /* CHANGED CODE */ 409 ps_mv_pred[TOP_R] = (ps_mv_ntop - 1); 410 if(u1_sub_mb_x == 0) 411 { 412 if(uc_sub_mb_y) 413 { 414 ps_mv_pred[TOP_R] = (ps_mv_nmb - 17); 415 } 416 else 417 { 418 /* CHANGED CODE */ 419 ps_mv_pred[TOP_R] -= 12; 420 } 421 } 422 } 423 else if(u2_b_in == 0) 424 { 425 /* If all the subMBs B, C, D are all out of the frame then their MV 426 and their reference picture is equal to that of A */ 427 ps_mv_pred[TOP] = ps_mv_pred[LEFT]; 428 ps_mv_pred[TOP_R] = ps_mv_pred[LEFT]; 429 } 430 } 431} 432#endif 433 434/*****************************************************************************/ 435/* */ 436/* Function Name : ih264d_mvpred_nonmbaffB */ 437/* */ 438/* Description : This function calculates the motion vector predictor, */ 439/* for B-Slices */ 440/* Inputs : <What inputs does the function take?> */ 441/* Globals : None */ 442/* Processing : The neighbours A(Left),B(Top),C(TopRight) are calculated */ 443/* and based on the type of Mb the prediction is */ 444/* appropriately done */ 445/* Outputs : populates ps_mv_final_pred structure */ 446/* Returns : u1_direct_zero_pred_flag which is used only in */ 447/* decodeSpatialdirect() */ 448/* */ 449/* Issues : <List any issues or problems with this function> */ 450/* */ 451/* Revision History: */ 452/* */ 453/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 454/* 03 05 2005 TA First Draft */ 455/* */ 456/*****************************************************************************/ 457#if(!MVPRED_NONMBAFF) 458UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec, 459 dec_mb_info_t *ps_cur_mb_info, 460 mv_pred_t *ps_mv_nmb, 461 mv_pred_t *ps_mv_ntop, 462 mv_pred_t *ps_mv_final_pred, 463 UWORD8 u1_sub_mb_num, 464 UWORD8 uc_mb_part_width, 465 UWORD8 u1_lx_start, 466 UWORD8 u1_lxend, 467 UWORD8 u1_mb_mc_mode) 468{ 469 UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3; 470 mv_pred_t *ps_mv_pred[3]; 471 UWORD8 uc_B2, uc_lx, u1_ref_idx; 472 UWORD8 u1_direct_zero_pred_flag = 0; 473 474 ih264d_non_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop, 475 ps_dec, uc_mb_part_width, ps_cur_mb_info); 476 477 for(uc_lx = u1_lx_start; uc_lx < u1_lxend; uc_lx++) 478 { 479 u1_ref_idx = ps_mv_final_pred->i1_ref_frame[uc_lx]; 480 uc_B2 = (uc_lx << 1); 481 switch(u1_mb_mc_mode) 482 { 483 case PRED_16x8: 484 /* Directional prediction for a 16x8 MB partition */ 485 if(u1_sub_mb_num == 0) 486 { 487 /* Calculating the MV pred for the top 16x8 block */ 488 if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx) 489 { 490 /* If the reference frame used by the top subMB is same as the 491 reference frame used by the current block then MV predictor to 492 be used for the current block is same as the MV of the top 493 subMB */ 494 ps_mv_final_pred->i2_mv[uc_B2 + 0] = 495 ps_mv_pred[TOP]->i2_mv[uc_B2 + 0]; 496 ps_mv_final_pred->i2_mv[uc_B2 + 1] = 497 ps_mv_pred[TOP]->i2_mv[uc_B2 + 1]; 498 } 499 else 500 { 501 /* The MV predictor is calculated according to the process 502 defined in 8.4.1.2.1 */ 503 ih264d_get_motion_vector_predictor( 504 ps_mv_final_pred, 505 ps_mv_pred, 506 u1_ref_idx, 507 uc_lx, 508 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 509 } 510 } 511 else 512 { 513 if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx) 514 { 515 /* If the reference frame used by the left subMB is same as the 516 reference frame used by the current block then MV predictor to 517 be used for the current block is same as the MV of the left 518 subMB */ 519 ps_mv_final_pred->i2_mv[uc_B2 + 0] = 520 ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0]; 521 ps_mv_final_pred->i2_mv[uc_B2 + 1] = 522 ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1]; 523 } 524 else 525 { 526 /* The MV predictor is calculated according to the process 527 defined in 8.4.1.2.1 */ 528 ih264d_get_motion_vector_predictor( 529 ps_mv_final_pred, 530 ps_mv_pred, 531 u1_ref_idx, 532 uc_lx, 533 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 534 } 535 } 536 break; 537 case PRED_8x16: 538 /* Directional prediction for a 8x16 MB partition */ 539 if(u1_sub_mb_num == 0) 540 { 541 if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx) 542 { 543 /* If the reference frame used by the left subMB is same as the 544 reference frame used by the current block then MV predictor to 545 be used for the current block is same as the MV of the left 546 subMB */ 547 ps_mv_final_pred->i2_mv[uc_B2 + 0] = 548 ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0]; 549 ps_mv_final_pred->i2_mv[uc_B2 + 1] = 550 ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1]; 551 } 552 else 553 { 554 /* The MV predictor is calculated according to the process 555 defined in 8.4.1.2.1 */ 556 ih264d_get_motion_vector_predictor( 557 ps_mv_final_pred, 558 ps_mv_pred, 559 u1_ref_idx, 560 uc_lx, 561 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 562 } 563 } 564 else 565 { 566 if(ps_mv_pred[TOP_R]->i1_ref_frame[uc_lx] == u1_ref_idx) 567 { 568 /* If the reference frame used by the top right subMB is same as 569 the reference frame used by the current block then MV 570 predictor to be used for the current block is same as the MV 571 of the left subMB */ 572 ps_mv_final_pred->i2_mv[uc_B2 + 0] = 573 ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 0]; 574 ps_mv_final_pred->i2_mv[uc_B2 + 1] = 575 ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 1]; 576 } 577 else 578 { 579 /* The MV predictor is calculated according to the process 580 defined in 8.4.1.2.1 */ 581 ih264d_get_motion_vector_predictor( 582 ps_mv_final_pred, 583 ps_mv_pred, 584 u1_ref_idx, 585 uc_lx, 586 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 587 } 588 } 589 break; 590 case B_DIRECT_SPATIAL: 591 /* Case when the MB has been skipped */ 592 /* If either of left or the top subMB is not present 593 OR 594 If both the MV components of either the left or the top subMB are 595 zero and their reference frame pointer pointing to 0 596 then MV for the skipped MB is zero 597 else the Median of the mv_pred_t is used */ 598 uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0]; 599 uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0]; 600 uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0]; 601 602 ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1, 603 MIN(uc_temp2, uc_temp3)); 604 605 uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1]; 606 uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1]; 607 uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1]; 608 609 ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1, 610 MIN(uc_temp2, uc_temp3)); 611 612 if((ps_mv_final_pred->i1_ref_frame[0] < 0) 613 && (ps_mv_final_pred->i1_ref_frame[1] < 0)) 614 { 615 u1_direct_zero_pred_flag = 1; 616 ps_mv_final_pred->i1_ref_frame[0] = 0; 617 ps_mv_final_pred->i1_ref_frame[1] = 0; 618 } 619 ih264d_get_motion_vector_predictor( 620 ps_mv_final_pred, ps_mv_pred, 621 ps_mv_final_pred->i1_ref_frame[0], 0, 622 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 623 624 ih264d_get_motion_vector_predictor( 625 ps_mv_final_pred, ps_mv_pred, 626 ps_mv_final_pred->i1_ref_frame[1], 1, 627 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 628 629 break; 630 case MB_SKIP: 631 /* Case when the MB has been skipped */ 632 /* If either of left or the top subMB is not present 633 OR 634 If both the MV components of either the left or the top subMB are 635 zero and their reference frame pointer pointing to 0 636 then MV for the skipped MB is zero 637 else the Median of the mv_pred_t is used */ 638 u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & 639 LEFT_MB_AVAILABLE_MASK); 640 u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & 641 TOP_MB_AVAILABLE_MASK); 642 if(((u1_a_in * u1_b_in) == 0) 643 || ((ps_mv_pred[LEFT]->i2_mv[0] 644 | ps_mv_pred[LEFT]->i2_mv[1] 645 | ps_mv_pred[LEFT]->i1_ref_frame[0]) 646 == 0) 647 || ((ps_mv_pred[TOP]->i2_mv[0] 648 | ps_mv_pred[TOP]->i2_mv[1] 649 | ps_mv_pred[TOP]->i1_ref_frame[0]) 650 == 0)) 651 { 652 ps_mv_final_pred->i2_mv[0] = 0; 653 ps_mv_final_pred->i2_mv[1] = 0; 654 break; 655 } 656 /* If the condition above is not true calculate the MV predictor 657 according to the process defined in sec 8.4.1.2.1 */ 658 default: 659 ih264d_get_motion_vector_predictor( 660 ps_mv_final_pred, ps_mv_pred, u1_ref_idx, uc_lx, 661 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 662 break; 663 } 664 } 665 return (u1_direct_zero_pred_flag); 666} 667#endif 668 669/*****************************************************************************/ 670/* */ 671/* Function Name : ih264d_mvpred_nonmbaff */ 672/* */ 673/* Description : This function calculates the motion vector predictor, */ 674/* for all the slice types other than B_SLICE */ 675/* Inputs : <What inputs does the function take?> */ 676/* Globals : None */ 677/* Processing : The neighbours A(Left),B(Top),C(TopRight) are calculated */ 678/* and based on the type of Mb the prediction is */ 679/* appropriately done */ 680/* Outputs : populates ps_mv_final_pred structure */ 681/* Returns : u1_direct_zero_pred_flag which is used only in */ 682/* decodeSpatialdirect() */ 683/* */ 684/* Issues : <List any issues or problems with this function> */ 685/* */ 686/* Revision History: */ 687/* */ 688/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 689/* 03 05 2005 TA First Draft */ 690/* */ 691/*****************************************************************************/ 692#if(!MVPRED_NONMBAFF) 693UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec, 694 dec_mb_info_t *ps_cur_mb_info, 695 mv_pred_t *ps_mv_nmb, 696 mv_pred_t *ps_mv_ntop, 697 mv_pred_t *ps_mv_final_pred, 698 UWORD8 u1_sub_mb_num, 699 UWORD8 uc_mb_part_width, 700 UWORD8 u1_lx_start, 701 UWORD8 u1_lxend, 702 UWORD8 u1_mb_mc_mode) 703{ 704 UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3; 705 mv_pred_t *ps_mv_pred[3]; 706 UWORD8 u1_ref_idx; 707 UWORD8 u1_direct_zero_pred_flag = 0; 708 UNUSED(u1_lx_start); 709 UNUSED(u1_lxend); 710 ih264d_non_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop, 711 ps_dec, uc_mb_part_width, ps_cur_mb_info); 712 713 u1_ref_idx = ps_mv_final_pred->i1_ref_frame[0]; 714 715 switch(u1_mb_mc_mode) 716 { 717 case PRED_16x8: 718 /* Directional prediction for a 16x8 MB partition */ 719 if(u1_sub_mb_num == 0) 720 { 721 /* Calculating the MV pred for the top 16x8 block */ 722 if(ps_mv_pred[TOP]->i1_ref_frame[0] == u1_ref_idx) 723 { 724 /* If the reference frame used by the top subMB is same as the 725 reference frame used by the current block then MV predictor to 726 be used for the current block is same as the MV of the top 727 subMB */ 728 729 ps_mv_final_pred->i2_mv[0] = ps_mv_pred[TOP]->i2_mv[0]; 730 ps_mv_final_pred->i2_mv[1] = ps_mv_pred[TOP]->i2_mv[1]; 731 } 732 else 733 { 734 /* The MV predictor is calculated according to the process 735 defined in 8.4.1.2.1 */ 736 ih264d_get_motion_vector_predictor( 737 ps_mv_final_pred, 738 ps_mv_pred, 739 u1_ref_idx, 740 0, 741 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 742 } 743 } 744 else 745 { 746 if(ps_mv_pred[LEFT]->i1_ref_frame[0] == u1_ref_idx) 747 { 748 /* If the reference frame used by the left subMB is same as the 749 reference frame used by the current block then MV predictor to 750 be used for the current block is same as the MV of the left 751 subMB */ 752 753 ps_mv_final_pred->i2_mv[0] = ps_mv_pred[LEFT]->i2_mv[0]; 754 ps_mv_final_pred->i2_mv[1] = ps_mv_pred[LEFT]->i2_mv[1]; 755 } 756 else 757 { 758 /* The MV predictor is calculated according to the process 759 defined in 8.4.1.2.1 */ 760 ih264d_get_motion_vector_predictor( 761 ps_mv_final_pred, 762 ps_mv_pred, 763 u1_ref_idx, 764 0, 765 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 766 } 767 } 768 break; 769 case PRED_8x16: 770 /* Directional prediction for a 8x16 MB partition */ 771 if(u1_sub_mb_num == 0) 772 { 773 if(ps_mv_pred[LEFT]->i1_ref_frame[0] == u1_ref_idx) 774 { 775 /* If the reference frame used by the left subMB is same as the 776 reference frame used by the current block then MV predictor to 777 be used for the current block is same as the MV of the left 778 subMB */ 779 780 ps_mv_final_pred->i2_mv[0] = ps_mv_pred[LEFT]->i2_mv[0]; 781 ps_mv_final_pred->i2_mv[1] = ps_mv_pred[LEFT]->i2_mv[1]; 782 } 783 else 784 { 785 /* The MV predictor is calculated according to the process 786 defined in 8.4.1.2.1 */ 787 ih264d_get_motion_vector_predictor( 788 ps_mv_final_pred, 789 ps_mv_pred, 790 u1_ref_idx, 791 0, 792 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 793 } 794 } 795 else 796 { 797 if(ps_mv_pred[TOP_R]->i1_ref_frame[0] == u1_ref_idx) 798 { 799 /* If the reference frame used by the top right subMB is same as 800 the reference frame used by the current block then MV 801 predictor to be used for the current block is same as the MV 802 of the left subMB */ 803 804 ps_mv_final_pred->i2_mv[0] = ps_mv_pred[TOP_R]->i2_mv[0]; 805 ps_mv_final_pred->i2_mv[1] = ps_mv_pred[TOP_R]->i2_mv[1]; 806 } 807 else 808 { 809 /* The MV predictor is calculated according to the process 810 defined in 8.4.1.2.1 */ 811 ih264d_get_motion_vector_predictor( 812 ps_mv_final_pred, 813 ps_mv_pred, 814 u1_ref_idx, 815 0, 816 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 817 } 818 } 819 break; 820 case B_DIRECT_SPATIAL: 821 /* Case when the MB has been skipped */ 822 /* If either of left or the top subMB is not present 823 OR 824 If both the MV components of either the left or the top subMB are 825 zero and their reference frame pointer pointing to 0 826 then MV for the skipped MB is zero 827 else the Median of the mv_pred_t is used */ 828 uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0]; 829 uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0]; 830 uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0]; 831 832 ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1, 833 MIN(uc_temp2, uc_temp3)); 834 835 uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1]; 836 uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1]; 837 uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1]; 838 839 ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1, 840 MIN(uc_temp2, uc_temp3)); 841 842 if((ps_mv_final_pred->i1_ref_frame[0] < 0) 843 && (ps_mv_final_pred->i1_ref_frame[1] < 0)) 844 { 845 u1_direct_zero_pred_flag = 1; 846 ps_mv_final_pred->i1_ref_frame[0] = 0; 847 ps_mv_final_pred->i1_ref_frame[1] = 0; 848 } 849 ih264d_get_motion_vector_predictor( 850 ps_mv_final_pred, ps_mv_pred, 851 ps_mv_final_pred->i1_ref_frame[0], 0, 852 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 853 854 ih264d_get_motion_vector_predictor( 855 ps_mv_final_pred, ps_mv_pred, 856 ps_mv_final_pred->i1_ref_frame[1], 1, 857 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 858 859 break; 860 case MB_SKIP: 861 /* Case when the MB has been skipped */ 862 /* If either of left or the top subMB is not present 863 OR 864 If both the MV components of either the left or the top subMB are 865 zero and their reference frame pointer pointing to 0 866 then MV for the skipped MB is zero 867 else the Median of the mv_pred_t is used */ 868 u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & 869 LEFT_MB_AVAILABLE_MASK); 870 u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & 871 TOP_MB_AVAILABLE_MASK); 872 if(((u1_a_in * u1_b_in) == 0) 873 || ((ps_mv_pred[LEFT]->i2_mv[0] 874 | ps_mv_pred[LEFT]->i2_mv[1] 875 | ps_mv_pred[LEFT]->i1_ref_frame[0]) 876 == 0) 877 || ((ps_mv_pred[TOP]->i2_mv[0] 878 | ps_mv_pred[TOP]->i2_mv[1] 879 | ps_mv_pred[TOP]->i1_ref_frame[0]) 880 == 0)) 881 { 882 883 ps_mv_final_pred->i2_mv[0] = 0; 884 ps_mv_final_pred->i2_mv[1] = 0; 885 break; 886 } 887 /* If the condition above is not true calculate the MV predictor 888 according to the process defined in sec 8.4.1.2.1 */ 889 default: 890 ih264d_get_motion_vector_predictor( 891 ps_mv_final_pred, ps_mv_pred, u1_ref_idx, 0, 892 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 893 break; 894 } 895 896 return (u1_direct_zero_pred_flag); 897} 898#endif 899 900/*****************************************************************************/ 901/* */ 902/* Function Name : ih264d_mvpred_mbaff */ 903/* */ 904/* Description : This function calculates the motion vector predictor, */ 905/* Inputs : <What inputs does the function take?> */ 906/* Globals : None */ 907/* Processing : The neighbours A(Left),B(Top),C(TopRight) are calculated */ 908/* and based on the type of Mb the prediction is */ 909/* appropriately done */ 910/* Outputs : populates ps_mv_final_pred structure */ 911/* Returns : u1_direct_zero_pred_flag which is used only in */ 912/* decodeSpatialdirect() */ 913/* */ 914/* Issues : <List any issues or problems with this function> */ 915/* */ 916/* Revision History: */ 917/* */ 918/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 919/* 03 05 2005 TA First Draft */ 920/* */ 921/*****************************************************************************/ 922 923UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec, 924 dec_mb_info_t *ps_cur_mb_info, 925 mv_pred_t *ps_mv_nmb, 926 mv_pred_t *ps_mv_ntop, 927 mv_pred_t *ps_mv_final_pred, 928 UWORD8 u1_sub_mb_num, 929 UWORD8 uc_mb_part_width, 930 UWORD8 u1_lx_start, 931 UWORD8 u1_lxend, 932 UWORD8 u1_mb_mc_mode) 933{ 934 UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3; 935 mv_pred_t *ps_mv_pred[3], s_mvPred[3]; 936 UWORD8 uc_B2, pu0_scale[3], i, uc_lx, u1_ref_idx; 937 UWORD8 u1_direct_zero_pred_flag = 0; 938 939 pu0_scale[0] = pu0_scale[1] = pu0_scale[2] = 0; 940 ih264d_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop, ps_dec, 941 uc_mb_part_width, ps_cur_mb_info, pu0_scale); 942 for(i = 0; i < 3; i++) 943 { 944 if(pu0_scale[i] != 0) 945 { 946 memcpy(&s_mvPred[i], ps_mv_pred[i], sizeof(mv_pred_t)); 947 if(pu0_scale[i] == 1) 948 { 949 s_mvPred[i].i1_ref_frame[0] = s_mvPred[i].i1_ref_frame[0] << 1; 950 s_mvPred[i].i1_ref_frame[1] = s_mvPred[i].i1_ref_frame[1] << 1; 951 s_mvPred[i].i2_mv[1] = SIGN_POW2_DIV(s_mvPred[i].i2_mv[1], 1); 952 s_mvPred[i].i2_mv[3] = SIGN_POW2_DIV(s_mvPred[i].i2_mv[3], 1); 953 } 954 else 955 { 956 s_mvPred[i].i1_ref_frame[0] = s_mvPred[i].i1_ref_frame[0] >> 1; 957 s_mvPred[i].i1_ref_frame[1] = s_mvPred[i].i1_ref_frame[1] >> 1; 958 s_mvPred[i].i2_mv[1] = s_mvPred[i].i2_mv[1] << 1; 959 s_mvPred[i].i2_mv[3] = s_mvPred[i].i2_mv[3] << 1; 960 } 961 ps_mv_pred[i] = &s_mvPred[i]; 962 } 963 } 964 965 for(uc_lx = u1_lx_start; uc_lx < u1_lxend; uc_lx++) 966 { 967 u1_ref_idx = ps_mv_final_pred->i1_ref_frame[uc_lx]; 968 uc_B2 = (uc_lx << 1); 969 switch(u1_mb_mc_mode) 970 { 971 case PRED_16x8: 972 /* Directional prediction for a 16x8 MB partition */ 973 if(u1_sub_mb_num == 0) 974 { 975 /* Calculating the MV pred for the top 16x8 block */ 976 if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx) 977 { 978 /* If the reference frame used by the top subMB is same as the 979 reference frame used by the current block then MV predictor to 980 be used for the current block is same as the MV of the top 981 subMB */ 982 ps_mv_final_pred->i2_mv[uc_B2 + 0] = 983 ps_mv_pred[TOP]->i2_mv[uc_B2 + 0]; 984 ps_mv_final_pred->i2_mv[uc_B2 + 1] = 985 ps_mv_pred[TOP]->i2_mv[uc_B2 + 1]; 986 } 987 else 988 { 989 /* The MV predictor is calculated according to the process 990 defined in 8.4.1.2.1 */ 991 ih264d_get_motion_vector_predictor( 992 ps_mv_final_pred, 993 ps_mv_pred, 994 u1_ref_idx, 995 uc_lx, 996 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 997 } 998 } 999 else 1000 { 1001 if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx) 1002 { 1003 /* If the reference frame used by the left subMB is same as the 1004 reference frame used by the current block then MV predictor to 1005 be used for the current block is same as the MV of the left 1006 subMB */ 1007 ps_mv_final_pred->i2_mv[uc_B2 + 0] = 1008 ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0]; 1009 ps_mv_final_pred->i2_mv[uc_B2 + 1] = 1010 ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1]; 1011 } 1012 else 1013 { 1014 /* The MV predictor is calculated according to the process 1015 defined in 8.4.1.2.1 */ 1016 ih264d_get_motion_vector_predictor( 1017 ps_mv_final_pred, 1018 ps_mv_pred, 1019 u1_ref_idx, 1020 uc_lx, 1021 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 1022 } 1023 } 1024 break; 1025 case PRED_8x16: 1026 /* Directional prediction for a 8x16 MB partition */ 1027 if(u1_sub_mb_num == 0) 1028 { 1029 if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx) 1030 { 1031 /* If the reference frame used by the left subMB is same as the 1032 reference frame used by the current block then MV predictor to 1033 be used for the current block is same as the MV of the left 1034 subMB */ 1035 ps_mv_final_pred->i2_mv[uc_B2 + 0] = 1036 ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0]; 1037 ps_mv_final_pred->i2_mv[uc_B2 + 1] = 1038 ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1]; 1039 } 1040 else 1041 { 1042 /* The MV predictor is calculated according to the process 1043 defined in 8.4.1.2.1 */ 1044 ih264d_get_motion_vector_predictor( 1045 ps_mv_final_pred, 1046 ps_mv_pred, 1047 u1_ref_idx, 1048 uc_lx, 1049 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 1050 } 1051 } 1052 else 1053 { 1054 if(ps_mv_pred[TOP_R]->i1_ref_frame[uc_lx] == u1_ref_idx) 1055 { 1056 /* If the reference frame used by the top right subMB is same as 1057 the reference frame used by the current block then MV 1058 predictor to be used for the current block is same as the MV 1059 of the left subMB */ 1060 ps_mv_final_pred->i2_mv[uc_B2 + 0] = 1061 ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 0]; 1062 ps_mv_final_pred->i2_mv[uc_B2 + 1] = 1063 ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 1]; 1064 } 1065 else 1066 { 1067 /* The MV predictor is calculated according to the process 1068 defined in 8.4.1.2.1 */ 1069 ih264d_get_motion_vector_predictor( 1070 ps_mv_final_pred, 1071 ps_mv_pred, 1072 u1_ref_idx, 1073 uc_lx, 1074 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 1075 } 1076 } 1077 break; 1078 case B_DIRECT_SPATIAL: 1079 /* Case when the MB has been skipped */ 1080 /* If either of left or the top subMB is not present 1081 OR 1082 If both the MV components of either the left or the top subMB are 1083 zero and their reference frame pointer pointing to 0 1084 then MV for the skipped MB is zero 1085 else the Median of the mv_pred_t is used */ 1086 uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0]; 1087 uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0]; 1088 uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0]; 1089 1090 ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1, 1091 MIN(uc_temp2, uc_temp3)); 1092 1093 uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1]; 1094 uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1]; 1095 uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1]; 1096 1097 ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1, 1098 MIN(uc_temp2, uc_temp3)); 1099 1100 /* If the reference indices are negative clip the scaled reference indices to -1 */ 1101 /* i.e invalid reference index */ 1102 1103 /*if(ps_mv_final_pred->i1_ref_frame[0] < 0) 1104 ps_mv_final_pred->i1_ref_frame[0] = -1; 1105 1106 if(ps_mv_final_pred->i1_ref_frame[1] < 0) 1107 ps_mv_final_pred->i1_ref_frame[1] = -1; */ 1108 1109 if((ps_mv_final_pred->i1_ref_frame[0] < 0) 1110 && (ps_mv_final_pred->i1_ref_frame[1] < 0)) 1111 { 1112 u1_direct_zero_pred_flag = 1; 1113 ps_mv_final_pred->i1_ref_frame[0] = 0; 1114 ps_mv_final_pred->i1_ref_frame[1] = 0; 1115 } 1116 ih264d_get_motion_vector_predictor( 1117 ps_mv_final_pred, ps_mv_pred, 1118 ps_mv_final_pred->i1_ref_frame[0], 0, 1119 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 1120 1121 ih264d_get_motion_vector_predictor( 1122 ps_mv_final_pred, ps_mv_pred, 1123 ps_mv_final_pred->i1_ref_frame[1], 1, 1124 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 1125 1126 break; 1127 case MB_SKIP: 1128 /* Case when the MB has been skipped */ 1129 /* If either of left or the top subMB is not present 1130 OR 1131 If both the MV components of either the left or the top subMB are 1132 zero and their reference frame pointer pointing to 0 1133 then MV for the skipped MB is zero 1134 else the Median of the mv_pred_t is used */ 1135 u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & 1136 LEFT_MB_AVAILABLE_MASK); 1137 u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & 1138 TOP_MB_AVAILABLE_MASK); 1139 if(((u1_a_in * u1_b_in) == 0) 1140 || ((ps_mv_pred[LEFT]->i2_mv[0] 1141 | ps_mv_pred[LEFT]->i2_mv[1] 1142 | ps_mv_pred[LEFT]->i1_ref_frame[0]) 1143 == 0) 1144 || ((ps_mv_pred[TOP]->i2_mv[0] 1145 | ps_mv_pred[TOP]->i2_mv[1] 1146 | ps_mv_pred[TOP]->i1_ref_frame[0]) 1147 == 0)) 1148 { 1149 ps_mv_final_pred->i2_mv[0] = 0; 1150 ps_mv_final_pred->i2_mv[1] = 0; 1151 break; 1152 } 1153 /* If the condition above is not true calculate the MV predictor 1154 according to the process defined in sec 8.4.1.2.1 */ 1155 default: 1156 ih264d_get_motion_vector_predictor( 1157 ps_mv_final_pred, ps_mv_pred, u1_ref_idx, uc_lx, 1158 (const UWORD8 *)gau1_ih264d_mv_pred_condition); 1159 break; 1160 } 1161 } 1162 return (u1_direct_zero_pred_flag); 1163} 1164 1165 1166 1167 1168void ih264d_rep_mv_colz(dec_struct_t *ps_dec, 1169 mv_pred_t *ps_mv_pred_src, 1170 mv_pred_t *ps_mv_pred_dst, 1171 UWORD8 u1_sub_mb_num, 1172 UWORD8 u1_colz, 1173 UWORD8 u1_ht, 1174 UWORD8 u1_wd) 1175{ 1176 1177 UWORD8 k, m; 1178 UWORD8 *pu1_colz = ps_dec->pu1_col_zero_flag + ps_dec->i4_submb_ofst 1179 + u1_sub_mb_num; 1180 1181 for(k = 0; k < u1_ht; k++) 1182 { 1183 for(m = 0; m < u1_wd; m++) 1184 { 1185 *(ps_mv_pred_dst + m) = *(ps_mv_pred_src); 1186 *(pu1_colz + m) = u1_colz; 1187 1188 } 1189 pu1_colz += SUB_BLK_WIDTH; 1190 ps_mv_pred_dst += SUB_BLK_WIDTH; 1191 } 1192} 1193 1194