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
ih264d_get_motion_vector_predictor(mv_pred_t * ps_result,mv_pred_t ** ps_mv_pred,UWORD8 u1_ref_idx,UWORD8 u1_B,const UWORD8 * pu1_mv_pred_condition)75 void 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
ih264d_mbaff_mv_pred(mv_pred_t ** ps_mv_pred,UWORD8 u1_sub_mb_num,mv_pred_t * ps_mv_nmb,mv_pred_t * ps_mv_ntop,dec_struct_t * ps_dec,UWORD8 uc_mb_part_width,dec_mb_info_t * ps_cur_mb_info,UWORD8 * pu0_scale)144 void 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)
ih264d_non_mbaff_mv_pred(mv_pred_t ** ps_mv_pred,UWORD8 u1_sub_mb_num,mv_pred_t * ps_mv_nmb,mv_pred_t * ps_mv_ntop,dec_struct_t * ps_dec,UWORD8 uc_mb_part_width,dec_mb_info_t * ps_cur_mb_info)335 void 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)
ih264d_mvpred_nonmbaffB(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,mv_pred_t * ps_mv_nmb,mv_pred_t * ps_mv_ntop,mv_pred_t * ps_mv_final_pred,UWORD8 u1_sub_mb_num,UWORD8 uc_mb_part_width,UWORD8 u1_lx_start,UWORD8 u1_lxend,UWORD8 u1_mb_mc_mode)458 UWORD8 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)
ih264d_mvpred_nonmbaff(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,mv_pred_t * ps_mv_nmb,mv_pred_t * ps_mv_ntop,mv_pred_t * ps_mv_final_pred,UWORD8 u1_sub_mb_num,UWORD8 uc_mb_part_width,UWORD8 u1_lx_start,UWORD8 u1_lxend,UWORD8 u1_mb_mc_mode)693 UWORD8 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
ih264d_mvpred_mbaff(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,mv_pred_t * ps_mv_nmb,mv_pred_t * ps_mv_ntop,mv_pred_t * ps_mv_final_pred,UWORD8 u1_sub_mb_num,UWORD8 uc_mb_part_width,UWORD8 u1_lx_start,UWORD8 u1_lxend,UWORD8 u1_mb_mc_mode)923 UWORD8 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
ih264d_rep_mv_colz(dec_struct_t * ps_dec,mv_pred_t * ps_mv_pred_src,mv_pred_t * ps_mv_pred_dst,UWORD8 u1_sub_mb_num,UWORD8 u1_colz,UWORD8 u1_ht,UWORD8 u1_wd)1168 void 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