• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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