/src/libavc/decoder/ih264d_mvpred.c
Line | Count | Source |
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 | | |
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 | 2.17M | { |
81 | 2.17M | WORD8 c_temp; |
82 | 2.17M | 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 | 2.17M | c_temp = |
87 | 2.17M | (ps_mv_pred[LEFT]->i1_ref_frame[u1_B] == u1_ref_idx) |
88 | 2.17M | | ((ps_mv_pred[TOP]->i1_ref_frame[u1_B] |
89 | 2.17M | == u1_ref_idx) << 1) |
90 | 2.17M | | ((ps_mv_pred[TOP_R]->i1_ref_frame[u1_B] |
91 | 2.17M | == u1_ref_idx) << 2); |
92 | 2.17M | c_temp = pu1_mv_pred_condition[c_temp]; |
93 | | |
94 | 2.17M | if(c_temp != -1) |
95 | 85.8k | { |
96 | | /* Case when only when one of the cadidate block has the same |
97 | | reference frame as the current block */ |
98 | 85.8k | ps_result->i2_mv[uc_B2 + 0] = ps_mv_pred[c_temp]->i2_mv[uc_B2 + 0]; |
99 | 85.8k | ps_result->i2_mv[uc_B2 + 1] = ps_mv_pred[c_temp]->i2_mv[uc_B2 + 1]; |
100 | 85.8k | } |
101 | 2.08M | else |
102 | 2.08M | { |
103 | 2.08M | WORD32 D0, D1; |
104 | 2.08M | D0 = MIN(ps_mv_pred[0]->i2_mv[uc_B2 + 0], |
105 | 2.08M | ps_mv_pred[1]->i2_mv[uc_B2 + 0]); |
106 | 2.08M | D1 = MAX(ps_mv_pred[0]->i2_mv[uc_B2 + 0], |
107 | 2.08M | ps_mv_pred[1]->i2_mv[uc_B2 + 0]); |
108 | 2.08M | D1 = MIN(D1, ps_mv_pred[2]->i2_mv[uc_B2 + 0]); |
109 | 2.08M | ps_result->i2_mv[uc_B2 + 0] = (WORD16)(MAX(D0, D1)); |
110 | | |
111 | 2.08M | D0 = MIN(ps_mv_pred[0]->i2_mv[uc_B2 + 1], |
112 | 2.08M | ps_mv_pred[1]->i2_mv[uc_B2 + 1]); |
113 | 2.08M | D1 = MAX(ps_mv_pred[0]->i2_mv[uc_B2 + 1], |
114 | 2.08M | ps_mv_pred[1]->i2_mv[uc_B2 + 1]); |
115 | 2.08M | D1 = MIN(D1, ps_mv_pred[2]->i2_mv[uc_B2 + 1]); |
116 | 2.08M | ps_result->i2_mv[uc_B2 + 1] = (WORD16)(MAX(D0, D1)); |
117 | | |
118 | 2.08M | } |
119 | 2.17M | } |
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 | | |
144 | | void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred, |
145 | | UWORD32 u4_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 | 0 | { |
153 | 0 | UWORD16 u2_a_in = 0, u2_b_in = 0, u2_c_in = 0, u2_d_in = 0; |
154 | 0 | mv_pred_t *ps_mvpred_l, *ps_mvpred_tmp; |
155 | 0 | UWORD32 u4_sub_mb_x = (u4_sub_mb_num & 3), uc_sub_mb_y = (u4_sub_mb_num >> 2); |
156 | 0 | UWORD8 u1_is_cur_mb_fld, u1_is_left_mb_fld, u1_is_top_mb_fld; |
157 | 0 | UWORD8 u1_is_cur_mb_top; |
158 | |
|
159 | 0 | u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag; |
160 | 0 | u1_is_cur_mb_top = ps_cur_mb_info->u1_topmb; |
161 | |
|
162 | 0 | u1_is_left_mb_fld = ps_cur_mb_info->ps_left_mb->u1_mb_fld; |
163 | 0 | 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 | 0 | ps_mv_pred[LEFT] = &ps_dec->s_default_mv_pred; |
168 | 0 | ps_mv_pred[TOP] = &(ps_dec->s_default_mv_pred); |
169 | 0 | ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred); |
170 | | |
171 | | /* Check if the left subMb is available */ |
172 | 0 | if(u4_sub_mb_x) |
173 | 0 | { |
174 | 0 | u2_a_in = 1; |
175 | 0 | ps_mv_pred[LEFT] = (ps_mv_nmb - 1); |
176 | 0 | } |
177 | 0 | else |
178 | 0 | { |
179 | 0 | UWORD8 uc_temp; |
180 | 0 | u2_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK); |
181 | 0 | if(u2_a_in) |
182 | 0 | { |
183 | 0 | ps_mvpred_l = (ps_dec->u4_num_pmbair) ? |
184 | 0 | ps_mv_nmb : |
185 | 0 | (ps_dec->ps_mv_left + (uc_sub_mb_y << 2) + 48 |
186 | 0 | - (u1_is_cur_mb_top << 4)); |
187 | 0 | uc_temp = 29; |
188 | 0 | if(u1_is_cur_mb_fld ^ u1_is_left_mb_fld) |
189 | 0 | { |
190 | 0 | if(u1_is_left_mb_fld) |
191 | 0 | { |
192 | 0 | uc_temp += |
193 | 0 | (((uc_sub_mb_y & 1) << 2) |
194 | 0 | + ((uc_sub_mb_y & 2) << 1)); |
195 | 0 | uc_temp += ((u1_is_cur_mb_top) ? 0 : 8); |
196 | 0 | } |
197 | 0 | else |
198 | 0 | { |
199 | 0 | uc_temp = uc_temp - (uc_sub_mb_y << 2); |
200 | 0 | uc_temp += ((u1_is_cur_mb_top) ? 0 : 16); |
201 | 0 | } |
202 | 0 | } |
203 | 0 | ps_mv_pred[LEFT] = (ps_mvpred_l - uc_temp); |
204 | 0 | pu0_scale[LEFT] = u1_is_cur_mb_fld - u1_is_left_mb_fld; |
205 | 0 | } |
206 | 0 | } |
207 | | |
208 | | /* Check if the top subMB is available */ |
209 | 0 | if((uc_sub_mb_y > 0) || ((u1_is_cur_mb_top | u1_is_cur_mb_fld) == 0)) |
210 | 0 | { |
211 | 0 | u2_b_in = 1; |
212 | 0 | ps_mv_pred[TOP] = ps_mv_nmb - 4; |
213 | 0 | } |
214 | 0 | else |
215 | 0 | { |
216 | 0 | u2_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK); |
217 | 0 | if(u2_b_in) |
218 | 0 | { |
219 | | /* CHANGED CODE */ |
220 | |
|
221 | 0 | if(u1_is_top_mb_fld && u1_is_cur_mb_fld) |
222 | 0 | ps_mvpred_tmp = ps_mv_ntop; |
223 | 0 | else |
224 | 0 | { |
225 | 0 | ps_mvpred_tmp = ps_mv_ntop; |
226 | 0 | if(u1_is_cur_mb_top) |
227 | 0 | ps_mvpred_tmp += 16; |
228 | 0 | } |
229 | |
|
230 | 0 | ps_mv_pred[TOP] = ps_mvpred_tmp; |
231 | 0 | pu0_scale[TOP] = u1_is_cur_mb_fld - u1_is_top_mb_fld; |
232 | 0 | } |
233 | 0 | } |
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 | 0 | u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask, |
242 | 0 | (u4_sub_mb_num + uc_mb_part_width - 1)); |
243 | 0 | if(u2_c_in) |
244 | 0 | { |
245 | 0 | ps_mv_pred[TOP_R] = ps_mv_pred[TOP] + uc_mb_part_width; |
246 | 0 | pu0_scale[TOP_R] = pu0_scale[TOP]; |
247 | 0 | if((uc_sub_mb_y == 0) && ((u4_sub_mb_x + uc_mb_part_width) > 3)) |
248 | 0 | { |
249 | 0 | UWORD8 uc_isTopRtMbFld; |
250 | 0 | uc_isTopRtMbFld = ps_cur_mb_info->ps_top_right_mb->u1_mb_fld; |
251 | | /* CHANGED CODE */ |
252 | 0 | ps_mvpred_tmp = ps_mv_ntop + uc_mb_part_width + 12; |
253 | 0 | ps_mvpred_tmp += (u1_is_cur_mb_top) ? 16 : 0; |
254 | 0 | ps_mvpred_tmp += (u1_is_cur_mb_fld && u1_is_cur_mb_top && uc_isTopRtMbFld) ? |
255 | 0 | 0 : 16; |
256 | 0 | ps_mv_pred[TOP_R] = ps_mvpred_tmp; |
257 | 0 | pu0_scale[TOP_R] = u1_is_cur_mb_fld - uc_isTopRtMbFld; |
258 | 0 | } |
259 | 0 | } |
260 | 0 | else |
261 | 0 | { |
262 | 0 | u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u4_sub_mb_num); |
263 | | |
264 | | /* Check if the the top left subMB is available */ |
265 | 0 | if(u2_d_in) |
266 | 0 | { |
267 | 0 | UWORD8 uc_isTopLtMbFld; |
268 | |
|
269 | 0 | ps_mv_pred[TOP_R] = ps_mv_pred[TOP] - 1; |
270 | 0 | pu0_scale[TOP_R] = pu0_scale[TOP]; |
271 | |
|
272 | 0 | if(u4_sub_mb_x == 0) |
273 | 0 | { |
274 | 0 | if((uc_sub_mb_y > 0) || ((u1_is_cur_mb_top | u1_is_cur_mb_fld) == 0)) |
275 | 0 | { |
276 | 0 | uc_isTopLtMbFld = u1_is_left_mb_fld; |
277 | 0 | ps_mvpred_tmp = ps_mv_pred[LEFT] - 4; |
278 | |
|
279 | 0 | if((u1_is_cur_mb_fld == 0) && uc_isTopLtMbFld) |
280 | 0 | { |
281 | 0 | ps_mvpred_tmp = ps_mv_pred[LEFT] + 16; |
282 | 0 | ps_mvpred_tmp -= (uc_sub_mb_y & 1) ? 0 : 4; |
283 | 0 | } |
284 | 0 | } |
285 | 0 | else |
286 | 0 | { |
287 | 0 | UWORD32 u4_cond = ps_dec->u4_num_pmbair; |
288 | 0 | uc_isTopLtMbFld = ps_cur_mb_info->u1_topleft_mb_fld; |
289 | | |
290 | | /* CHANGED CODE */ |
291 | 0 | ps_mvpred_tmp = ps_mv_ntop - 29; |
292 | 0 | ps_mvpred_tmp += (u1_is_cur_mb_top) ? 16 : 0; |
293 | 0 | if(u1_is_cur_mb_fld && u1_is_cur_mb_top) |
294 | 0 | ps_mvpred_tmp -= (uc_isTopLtMbFld) ? 16 : 0; |
295 | 0 | } |
296 | 0 | ps_mv_pred[TOP_R] = ps_mvpred_tmp; |
297 | 0 | pu0_scale[TOP_R] = u1_is_cur_mb_fld - uc_isTopLtMbFld; |
298 | 0 | } |
299 | 0 | } |
300 | 0 | else if(u2_b_in == 0) |
301 | 0 | { |
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 | 0 | ps_mv_pred[TOP] = ps_mv_pred[LEFT]; |
305 | 0 | ps_mv_pred[TOP_R] = ps_mv_pred[LEFT]; |
306 | 0 | pu0_scale[TOP] = pu0_scale[LEFT]; |
307 | 0 | pu0_scale[TOP_R] = pu0_scale[LEFT]; |
308 | 0 | } |
309 | 0 | } |
310 | 0 | } |
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) |
335 | | void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred, |
336 | | UWORD32 u4_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 | 14.2M | { |
343 | 14.2M | UWORD16 u2_b_in = 0, u2_c_in = 0, u2_d_in = 0; |
344 | 14.2M | UWORD32 u4_sub_mb_x = (u4_sub_mb_num & 3), uc_sub_mb_y = (u4_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 | 14.2M | ps_mv_pred[LEFT] = &ps_dec->s_default_mv_pred; |
350 | 14.2M | ps_mv_pred[TOP] = &(ps_dec->s_default_mv_pred); |
351 | 14.2M | ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred); |
352 | | /* Check if the left subMb is available */ |
353 | | |
354 | 14.2M | if(u4_sub_mb_x) |
355 | 240k | { |
356 | 240k | ps_mv_pred[LEFT] = (ps_mv_nmb - 1); |
357 | 240k | } |
358 | 14.0M | else |
359 | 14.0M | { |
360 | 14.0M | if(ps_cur_mb_info->u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK) |
361 | 11.8M | { |
362 | 11.8M | ps_mv_pred[LEFT] = (ps_mv_nmb - 13); |
363 | 11.8M | } |
364 | 14.0M | } |
365 | | |
366 | | /* Check if the top subMB is available */ |
367 | 14.2M | if(uc_sub_mb_y) |
368 | 244k | { |
369 | 244k | u2_b_in = 1; |
370 | 244k | ps_mv_ntop = ps_mv_nmb - 4; |
371 | 244k | ps_mv_pred[TOP] = ps_mv_ntop; |
372 | | |
373 | 244k | } |
374 | 14.0M | else |
375 | 14.0M | { |
376 | 14.0M | u2_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK); |
377 | 14.0M | if(u2_b_in) |
378 | 13.2M | { |
379 | 13.2M | ps_mv_pred[TOP] = ps_mv_ntop; |
380 | 13.2M | } |
381 | 14.0M | } |
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 | 14.2M | u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask, |
390 | 14.2M | (u4_sub_mb_num + uc_mb_part_width - 1)); |
391 | 14.2M | if(u2_c_in) |
392 | 11.3M | { |
393 | 11.3M | ps_mv_pred[TOP_R] = (ps_mv_ntop + uc_mb_part_width); |
394 | | |
395 | 11.3M | if(uc_sub_mb_y == 0) |
396 | 11.2M | { |
397 | | /* CHANGED CODE */ |
398 | 11.2M | if((u4_sub_mb_x + uc_mb_part_width) > 3) |
399 | 11.1M | ps_mv_pred[TOP_R] += 12; |
400 | 11.2M | } |
401 | 11.3M | } |
402 | 2.98M | else |
403 | 2.98M | { |
404 | 2.98M | u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u4_sub_mb_num); |
405 | | /* Check if the the top left subMB is available */ |
406 | 2.98M | if(u2_d_in) |
407 | 2.14M | { |
408 | | /* CHANGED CODE */ |
409 | 2.14M | ps_mv_pred[TOP_R] = (ps_mv_ntop - 1); |
410 | 2.14M | if(u4_sub_mb_x == 0) |
411 | 2.04M | { |
412 | 2.04M | if(uc_sub_mb_y) |
413 | 53.3k | { |
414 | 53.3k | ps_mv_pred[TOP_R] = (ps_mv_nmb - 17); |
415 | 53.3k | } |
416 | 1.99M | else |
417 | 1.99M | { |
418 | | /* CHANGED CODE */ |
419 | 1.99M | ps_mv_pred[TOP_R] -= 12; |
420 | 1.99M | } |
421 | 2.04M | } |
422 | 2.14M | } |
423 | 836k | else if(u2_b_in == 0) |
424 | 800k | { |
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 | 800k | ps_mv_pred[TOP] = ps_mv_pred[LEFT]; |
428 | 800k | ps_mv_pred[TOP_R] = ps_mv_pred[LEFT]; |
429 | 800k | } |
430 | 2.98M | } |
431 | 14.2M | } |
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) |
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 | | UWORD32 u4_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 | 3.90M | { |
469 | 3.90M | UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3; |
470 | 3.90M | mv_pred_t *ps_mv_pred[3]; |
471 | 3.90M | UWORD8 uc_B2, uc_lx, u1_ref_idx; |
472 | 3.90M | UWORD8 u1_direct_zero_pred_flag = 0; |
473 | | |
474 | 3.90M | ih264d_non_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop, |
475 | 3.90M | ps_dec, uc_mb_part_width, ps_cur_mb_info); |
476 | | |
477 | 7.89M | for(uc_lx = u1_lx_start; uc_lx < u1_lxend; uc_lx++) |
478 | 3.98M | { |
479 | 3.98M | u1_ref_idx = ps_mv_final_pred->i1_ref_frame[uc_lx]; |
480 | 3.98M | uc_B2 = (uc_lx << 1); |
481 | 3.98M | switch(u1_mb_mc_mode) |
482 | 3.98M | { |
483 | 83.3k | case PRED_16x8: |
484 | | /* Directional prediction for a 16x8 MB partition */ |
485 | 83.3k | if(u4_sub_mb_num == 0) |
486 | 35.0k | { |
487 | | /* Calculating the MV pred for the top 16x8 block */ |
488 | 35.0k | if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx) |
489 | 17.9k | { |
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 | 17.9k | ps_mv_final_pred->i2_mv[uc_B2 + 0] = |
495 | 17.9k | ps_mv_pred[TOP]->i2_mv[uc_B2 + 0]; |
496 | 17.9k | ps_mv_final_pred->i2_mv[uc_B2 + 1] = |
497 | 17.9k | ps_mv_pred[TOP]->i2_mv[uc_B2 + 1]; |
498 | 17.9k | } |
499 | 17.0k | else |
500 | 17.0k | { |
501 | | /* The MV predictor is calculated according to the process |
502 | | defined in 8.4.1.2.1 */ |
503 | 17.0k | ih264d_get_motion_vector_predictor( |
504 | 17.0k | ps_mv_final_pred, |
505 | 17.0k | ps_mv_pred, |
506 | 17.0k | u1_ref_idx, |
507 | 17.0k | uc_lx, |
508 | 17.0k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
509 | 17.0k | } |
510 | 35.0k | } |
511 | 48.3k | else |
512 | 48.3k | { |
513 | 48.3k | if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx) |
514 | 22.3k | { |
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 | 22.3k | ps_mv_final_pred->i2_mv[uc_B2 + 0] = |
520 | 22.3k | ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0]; |
521 | 22.3k | ps_mv_final_pred->i2_mv[uc_B2 + 1] = |
522 | 22.3k | ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1]; |
523 | 22.3k | } |
524 | 25.9k | else |
525 | 25.9k | { |
526 | | /* The MV predictor is calculated according to the process |
527 | | defined in 8.4.1.2.1 */ |
528 | 25.9k | ih264d_get_motion_vector_predictor( |
529 | 25.9k | ps_mv_final_pred, |
530 | 25.9k | ps_mv_pred, |
531 | 25.9k | u1_ref_idx, |
532 | 25.9k | uc_lx, |
533 | 25.9k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
534 | 25.9k | } |
535 | 48.3k | } |
536 | 83.3k | break; |
537 | 44.3k | case PRED_8x16: |
538 | | /* Directional prediction for a 8x16 MB partition */ |
539 | 44.3k | if(u4_sub_mb_num == 0) |
540 | 22.4k | { |
541 | 22.4k | if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx) |
542 | 10.9k | { |
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 | 10.9k | ps_mv_final_pred->i2_mv[uc_B2 + 0] = |
548 | 10.9k | ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0]; |
549 | 10.9k | ps_mv_final_pred->i2_mv[uc_B2 + 1] = |
550 | 10.9k | ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1]; |
551 | 10.9k | } |
552 | 11.5k | else |
553 | 11.5k | { |
554 | | /* The MV predictor is calculated according to the process |
555 | | defined in 8.4.1.2.1 */ |
556 | 11.5k | ih264d_get_motion_vector_predictor( |
557 | 11.5k | ps_mv_final_pred, |
558 | 11.5k | ps_mv_pred, |
559 | 11.5k | u1_ref_idx, |
560 | 11.5k | uc_lx, |
561 | 11.5k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
562 | 11.5k | } |
563 | 22.4k | } |
564 | 21.9k | else |
565 | 21.9k | { |
566 | 21.9k | if(ps_mv_pred[TOP_R]->i1_ref_frame[uc_lx] == u1_ref_idx) |
567 | 12.8k | { |
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 | 12.8k | ps_mv_final_pred->i2_mv[uc_B2 + 0] = |
573 | 12.8k | ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 0]; |
574 | 12.8k | ps_mv_final_pred->i2_mv[uc_B2 + 1] = |
575 | 12.8k | ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 1]; |
576 | 12.8k | } |
577 | 9.10k | else |
578 | 9.10k | { |
579 | | /* The MV predictor is calculated according to the process |
580 | | defined in 8.4.1.2.1 */ |
581 | 9.10k | ih264d_get_motion_vector_predictor( |
582 | 9.10k | ps_mv_final_pred, |
583 | 9.10k | ps_mv_pred, |
584 | 9.10k | u1_ref_idx, |
585 | 9.10k | uc_lx, |
586 | 9.10k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
587 | 9.10k | } |
588 | 21.9k | } |
589 | 44.3k | break; |
590 | 763k | 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 | 763k | uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0]; |
599 | 763k | uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0]; |
600 | 763k | uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0]; |
601 | | |
602 | 763k | ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1, |
603 | 763k | MIN(uc_temp2, uc_temp3)); |
604 | | |
605 | 763k | uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1]; |
606 | 763k | uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1]; |
607 | 763k | uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1]; |
608 | | |
609 | 763k | ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1, |
610 | 763k | MIN(uc_temp2, uc_temp3)); |
611 | | |
612 | 763k | if((ps_mv_final_pred->i1_ref_frame[0] < 0) |
613 | 60.7k | && (ps_mv_final_pred->i1_ref_frame[1] < 0)) |
614 | 13.9k | { |
615 | 13.9k | u1_direct_zero_pred_flag = 1; |
616 | 13.9k | ps_mv_final_pred->i1_ref_frame[0] = 0; |
617 | 13.9k | ps_mv_final_pred->i1_ref_frame[1] = 0; |
618 | 13.9k | } |
619 | 763k | ih264d_get_motion_vector_predictor( |
620 | 763k | ps_mv_final_pred, ps_mv_pred, |
621 | 763k | ps_mv_final_pred->i1_ref_frame[0], 0, |
622 | 763k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
623 | | |
624 | 763k | ih264d_get_motion_vector_predictor( |
625 | 763k | ps_mv_final_pred, ps_mv_pred, |
626 | 763k | ps_mv_final_pred->i1_ref_frame[1], 1, |
627 | 763k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
628 | | |
629 | 763k | break; |
630 | 2.83M | 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 | 2.83M | u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & |
639 | 2.83M | LEFT_MB_AVAILABLE_MASK); |
640 | 2.83M | u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & |
641 | 2.83M | TOP_MB_AVAILABLE_MASK); |
642 | 2.83M | if(((u1_a_in * u1_b_in) == 0) |
643 | 2.40M | || ((ps_mv_pred[LEFT]->i2_mv[0] |
644 | 2.40M | | ps_mv_pred[LEFT]->i2_mv[1] |
645 | 2.40M | | ps_mv_pred[LEFT]->i1_ref_frame[0]) |
646 | 2.40M | == 0) |
647 | 1.14k | || ((ps_mv_pred[TOP]->i2_mv[0] |
648 | 1.14k | | ps_mv_pred[TOP]->i2_mv[1] |
649 | 1.14k | | ps_mv_pred[TOP]->i1_ref_frame[0]) |
650 | 1.14k | == 0)) |
651 | 2.83M | { |
652 | 2.83M | ps_mv_final_pred->i2_mv[0] = 0; |
653 | 2.83M | ps_mv_final_pred->i2_mv[1] = 0; |
654 | 2.83M | break; |
655 | 2.83M | } |
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 | 258k | default: |
659 | 258k | ih264d_get_motion_vector_predictor( |
660 | 258k | ps_mv_final_pred, ps_mv_pred, u1_ref_idx, uc_lx, |
661 | 258k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
662 | 258k | break; |
663 | 3.98M | } |
664 | 3.98M | } |
665 | 3.90M | return (u1_direct_zero_pred_flag); |
666 | 3.90M | } |
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) |
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 | | UWORD32 u4_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 | 10.3M | { |
704 | 10.3M | UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3; |
705 | 10.3M | mv_pred_t *ps_mv_pred[3]; |
706 | 10.3M | UWORD8 u1_ref_idx; |
707 | 10.3M | UWORD8 u1_direct_zero_pred_flag = 0; |
708 | 10.3M | UNUSED(u1_lx_start); |
709 | 10.3M | UNUSED(u1_lxend); |
710 | 10.3M | ih264d_non_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop, |
711 | 10.3M | ps_dec, uc_mb_part_width, ps_cur_mb_info); |
712 | | |
713 | 10.3M | u1_ref_idx = ps_mv_final_pred->i1_ref_frame[0]; |
714 | | |
715 | 10.3M | switch(u1_mb_mc_mode) |
716 | 10.3M | { |
717 | 49.8k | case PRED_16x8: |
718 | | /* Directional prediction for a 16x8 MB partition */ |
719 | 49.8k | if(u4_sub_mb_num == 0) |
720 | 24.9k | { |
721 | | /* Calculating the MV pred for the top 16x8 block */ |
722 | 24.9k | if(ps_mv_pred[TOP]->i1_ref_frame[0] == u1_ref_idx) |
723 | 12.9k | { |
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 | 12.9k | ps_mv_final_pred->i2_mv[0] = ps_mv_pred[TOP]->i2_mv[0]; |
730 | 12.9k | ps_mv_final_pred->i2_mv[1] = ps_mv_pred[TOP]->i2_mv[1]; |
731 | 12.9k | } |
732 | 12.0k | else |
733 | 12.0k | { |
734 | | /* The MV predictor is calculated according to the process |
735 | | defined in 8.4.1.2.1 */ |
736 | 12.0k | ih264d_get_motion_vector_predictor( |
737 | 12.0k | ps_mv_final_pred, |
738 | 12.0k | ps_mv_pred, |
739 | 12.0k | u1_ref_idx, |
740 | 12.0k | 0, |
741 | 12.0k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
742 | 12.0k | } |
743 | 24.9k | } |
744 | 24.9k | else |
745 | 24.9k | { |
746 | 24.9k | if(ps_mv_pred[LEFT]->i1_ref_frame[0] == u1_ref_idx) |
747 | 9.27k | { |
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 | 9.27k | ps_mv_final_pred->i2_mv[0] = ps_mv_pred[LEFT]->i2_mv[0]; |
754 | 9.27k | ps_mv_final_pred->i2_mv[1] = ps_mv_pred[LEFT]->i2_mv[1]; |
755 | 9.27k | } |
756 | 15.6k | else |
757 | 15.6k | { |
758 | | /* The MV predictor is calculated according to the process |
759 | | defined in 8.4.1.2.1 */ |
760 | 15.6k | ih264d_get_motion_vector_predictor( |
761 | 15.6k | ps_mv_final_pred, |
762 | 15.6k | ps_mv_pred, |
763 | 15.6k | u1_ref_idx, |
764 | 15.6k | 0, |
765 | 15.6k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
766 | 15.6k | } |
767 | 24.9k | } |
768 | 49.8k | break; |
769 | 48.5k | case PRED_8x16: |
770 | | /* Directional prediction for a 8x16 MB partition */ |
771 | 48.5k | if(u4_sub_mb_num == 0) |
772 | 25.2k | { |
773 | 25.2k | if(ps_mv_pred[LEFT]->i1_ref_frame[0] == u1_ref_idx) |
774 | 7.28k | { |
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 | 7.28k | ps_mv_final_pred->i2_mv[0] = ps_mv_pred[LEFT]->i2_mv[0]; |
781 | 7.28k | ps_mv_final_pred->i2_mv[1] = ps_mv_pred[LEFT]->i2_mv[1]; |
782 | 7.28k | } |
783 | 17.9k | else |
784 | 17.9k | { |
785 | | /* The MV predictor is calculated according to the process |
786 | | defined in 8.4.1.2.1 */ |
787 | 17.9k | ih264d_get_motion_vector_predictor( |
788 | 17.9k | ps_mv_final_pred, |
789 | 17.9k | ps_mv_pred, |
790 | 17.9k | u1_ref_idx, |
791 | 17.9k | 0, |
792 | 17.9k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
793 | 17.9k | } |
794 | 25.2k | } |
795 | 23.3k | else |
796 | 23.3k | { |
797 | 23.3k | if(ps_mv_pred[TOP_R]->i1_ref_frame[0] == u1_ref_idx) |
798 | 14.4k | { |
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 | 14.4k | ps_mv_final_pred->i2_mv[0] = ps_mv_pred[TOP_R]->i2_mv[0]; |
805 | 14.4k | ps_mv_final_pred->i2_mv[1] = ps_mv_pred[TOP_R]->i2_mv[1]; |
806 | 14.4k | } |
807 | 8.82k | else |
808 | 8.82k | { |
809 | | /* The MV predictor is calculated according to the process |
810 | | defined in 8.4.1.2.1 */ |
811 | 8.82k | ih264d_get_motion_vector_predictor( |
812 | 8.82k | ps_mv_final_pred, |
813 | 8.82k | ps_mv_pred, |
814 | 8.82k | u1_ref_idx, |
815 | 8.82k | 0, |
816 | 8.82k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
817 | 8.82k | } |
818 | 23.3k | } |
819 | 48.5k | break; |
820 | 0 | 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 | 0 | uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0]; |
829 | 0 | uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0]; |
830 | 0 | uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0]; |
831 | |
|
832 | 0 | ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1, |
833 | 0 | MIN(uc_temp2, uc_temp3)); |
834 | |
|
835 | 0 | uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1]; |
836 | 0 | uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1]; |
837 | 0 | uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1]; |
838 | |
|
839 | 0 | ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1, |
840 | 0 | MIN(uc_temp2, uc_temp3)); |
841 | |
|
842 | 0 | if((ps_mv_final_pred->i1_ref_frame[0] < 0) |
843 | 0 | && (ps_mv_final_pred->i1_ref_frame[1] < 0)) |
844 | 0 | { |
845 | 0 | u1_direct_zero_pred_flag = 1; |
846 | 0 | ps_mv_final_pred->i1_ref_frame[0] = 0; |
847 | 0 | ps_mv_final_pred->i1_ref_frame[1] = 0; |
848 | 0 | } |
849 | 0 | ih264d_get_motion_vector_predictor( |
850 | 0 | ps_mv_final_pred, ps_mv_pred, |
851 | 0 | ps_mv_final_pred->i1_ref_frame[0], 0, |
852 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
853 | |
|
854 | 0 | ih264d_get_motion_vector_predictor( |
855 | 0 | ps_mv_final_pred, ps_mv_pred, |
856 | 0 | ps_mv_final_pred->i1_ref_frame[1], 1, |
857 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
858 | |
|
859 | 0 | break; |
860 | 10.0M | 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 | 10.0M | u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & |
869 | 10.0M | LEFT_MB_AVAILABLE_MASK); |
870 | 10.0M | u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & |
871 | 10.0M | TOP_MB_AVAILABLE_MASK); |
872 | 10.0M | if(((u1_a_in * u1_b_in) == 0) |
873 | 7.92M | || ((ps_mv_pred[LEFT]->i2_mv[0] |
874 | 7.92M | | ps_mv_pred[LEFT]->i2_mv[1] |
875 | 7.92M | | ps_mv_pred[LEFT]->i1_ref_frame[0]) |
876 | 7.92M | == 0) |
877 | 33.1k | || ((ps_mv_pred[TOP]->i2_mv[0] |
878 | 33.1k | | ps_mv_pred[TOP]->i2_mv[1] |
879 | 33.1k | | ps_mv_pred[TOP]->i1_ref_frame[0]) |
880 | 33.1k | == 0)) |
881 | 10.0M | { |
882 | | |
883 | 10.0M | ps_mv_final_pred->i2_mv[0] = 0; |
884 | 10.0M | ps_mv_final_pred->i2_mv[1] = 0; |
885 | 10.0M | break; |
886 | 10.0M | } |
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 | 268k | default: |
890 | 268k | ih264d_get_motion_vector_predictor( |
891 | 268k | ps_mv_final_pred, ps_mv_pred, u1_ref_idx, 0, |
892 | 268k | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
893 | 268k | break; |
894 | 10.3M | } |
895 | | |
896 | 10.3M | return (u1_direct_zero_pred_flag); |
897 | 10.3M | } |
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 | | |
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 | | UWORD32 u4_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 | 0 | { |
934 | 0 | UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3; |
935 | 0 | mv_pred_t *ps_mv_pred[3], s_mvPred[3]; |
936 | 0 | UWORD8 uc_B2, pu0_scale[3], i, uc_lx, u1_ref_idx; |
937 | 0 | UWORD8 u1_direct_zero_pred_flag = 0; |
938 | |
|
939 | 0 | pu0_scale[0] = pu0_scale[1] = pu0_scale[2] = 0; |
940 | 0 | ih264d_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop, ps_dec, |
941 | 0 | uc_mb_part_width, ps_cur_mb_info, pu0_scale); |
942 | 0 | for(i = 0; i < 3; i++) |
943 | 0 | { |
944 | 0 | if(pu0_scale[i] != 0) |
945 | 0 | { |
946 | 0 | memcpy(&s_mvPred[i], ps_mv_pred[i], sizeof(mv_pred_t)); |
947 | 0 | if(pu0_scale[i] == 1) |
948 | 0 | { |
949 | 0 | s_mvPred[i].i1_ref_frame[0] = s_mvPred[i].i1_ref_frame[0] << 1; |
950 | 0 | s_mvPred[i].i1_ref_frame[1] = s_mvPred[i].i1_ref_frame[1] << 1; |
951 | 0 | s_mvPred[i].i2_mv[1] = SIGN_POW2_DIV(s_mvPred[i].i2_mv[1], 1); |
952 | 0 | s_mvPred[i].i2_mv[3] = SIGN_POW2_DIV(s_mvPred[i].i2_mv[3], 1); |
953 | 0 | } |
954 | 0 | else |
955 | 0 | { |
956 | 0 | s_mvPred[i].i1_ref_frame[0] = s_mvPred[i].i1_ref_frame[0] >> 1; |
957 | 0 | s_mvPred[i].i1_ref_frame[1] = s_mvPred[i].i1_ref_frame[1] >> 1; |
958 | 0 | s_mvPred[i].i2_mv[1] = s_mvPred[i].i2_mv[1] << 1; |
959 | 0 | s_mvPred[i].i2_mv[3] = s_mvPred[i].i2_mv[3] << 1; |
960 | 0 | } |
961 | 0 | ps_mv_pred[i] = &s_mvPred[i]; |
962 | 0 | } |
963 | 0 | } |
964 | |
|
965 | 0 | for(uc_lx = u1_lx_start; uc_lx < u1_lxend; uc_lx++) |
966 | 0 | { |
967 | 0 | u1_ref_idx = ps_mv_final_pred->i1_ref_frame[uc_lx]; |
968 | 0 | uc_B2 = (uc_lx << 1); |
969 | 0 | switch(u1_mb_mc_mode) |
970 | 0 | { |
971 | 0 | case PRED_16x8: |
972 | | /* Directional prediction for a 16x8 MB partition */ |
973 | 0 | if(u4_sub_mb_num == 0) |
974 | 0 | { |
975 | | /* Calculating the MV pred for the top 16x8 block */ |
976 | 0 | if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx) |
977 | 0 | { |
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 | 0 | ps_mv_final_pred->i2_mv[uc_B2 + 0] = |
983 | 0 | ps_mv_pred[TOP]->i2_mv[uc_B2 + 0]; |
984 | 0 | ps_mv_final_pred->i2_mv[uc_B2 + 1] = |
985 | 0 | ps_mv_pred[TOP]->i2_mv[uc_B2 + 1]; |
986 | 0 | } |
987 | 0 | else |
988 | 0 | { |
989 | | /* The MV predictor is calculated according to the process |
990 | | defined in 8.4.1.2.1 */ |
991 | 0 | ih264d_get_motion_vector_predictor( |
992 | 0 | ps_mv_final_pred, |
993 | 0 | ps_mv_pred, |
994 | 0 | u1_ref_idx, |
995 | 0 | uc_lx, |
996 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
997 | 0 | } |
998 | 0 | } |
999 | 0 | else |
1000 | 0 | { |
1001 | 0 | if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx) |
1002 | 0 | { |
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 | 0 | ps_mv_final_pred->i2_mv[uc_B2 + 0] = |
1008 | 0 | ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0]; |
1009 | 0 | ps_mv_final_pred->i2_mv[uc_B2 + 1] = |
1010 | 0 | ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1]; |
1011 | 0 | } |
1012 | 0 | else |
1013 | 0 | { |
1014 | | /* The MV predictor is calculated according to the process |
1015 | | defined in 8.4.1.2.1 */ |
1016 | 0 | ih264d_get_motion_vector_predictor( |
1017 | 0 | ps_mv_final_pred, |
1018 | 0 | ps_mv_pred, |
1019 | 0 | u1_ref_idx, |
1020 | 0 | uc_lx, |
1021 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
1022 | 0 | } |
1023 | 0 | } |
1024 | 0 | break; |
1025 | 0 | case PRED_8x16: |
1026 | | /* Directional prediction for a 8x16 MB partition */ |
1027 | 0 | if(u4_sub_mb_num == 0) |
1028 | 0 | { |
1029 | 0 | if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx) |
1030 | 0 | { |
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 | 0 | ps_mv_final_pred->i2_mv[uc_B2 + 0] = |
1036 | 0 | ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0]; |
1037 | 0 | ps_mv_final_pred->i2_mv[uc_B2 + 1] = |
1038 | 0 | ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1]; |
1039 | 0 | } |
1040 | 0 | else |
1041 | 0 | { |
1042 | | /* The MV predictor is calculated according to the process |
1043 | | defined in 8.4.1.2.1 */ |
1044 | 0 | ih264d_get_motion_vector_predictor( |
1045 | 0 | ps_mv_final_pred, |
1046 | 0 | ps_mv_pred, |
1047 | 0 | u1_ref_idx, |
1048 | 0 | uc_lx, |
1049 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
1050 | 0 | } |
1051 | 0 | } |
1052 | 0 | else |
1053 | 0 | { |
1054 | 0 | if(ps_mv_pred[TOP_R]->i1_ref_frame[uc_lx] == u1_ref_idx) |
1055 | 0 | { |
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 | 0 | ps_mv_final_pred->i2_mv[uc_B2 + 0] = |
1061 | 0 | ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 0]; |
1062 | 0 | ps_mv_final_pred->i2_mv[uc_B2 + 1] = |
1063 | 0 | ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 1]; |
1064 | 0 | } |
1065 | 0 | else |
1066 | 0 | { |
1067 | | /* The MV predictor is calculated according to the process |
1068 | | defined in 8.4.1.2.1 */ |
1069 | 0 | ih264d_get_motion_vector_predictor( |
1070 | 0 | ps_mv_final_pred, |
1071 | 0 | ps_mv_pred, |
1072 | 0 | u1_ref_idx, |
1073 | 0 | uc_lx, |
1074 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
1075 | 0 | } |
1076 | 0 | } |
1077 | 0 | break; |
1078 | 0 | 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 | 0 | uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0]; |
1087 | 0 | uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0]; |
1088 | 0 | uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0]; |
1089 | |
|
1090 | 0 | ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1, |
1091 | 0 | MIN(uc_temp2, uc_temp3)); |
1092 | |
|
1093 | 0 | uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1]; |
1094 | 0 | uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1]; |
1095 | 0 | uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1]; |
1096 | |
|
1097 | 0 | ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1, |
1098 | 0 | 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 | 0 | if((ps_mv_final_pred->i1_ref_frame[0] < 0) |
1110 | 0 | && (ps_mv_final_pred->i1_ref_frame[1] < 0)) |
1111 | 0 | { |
1112 | 0 | u1_direct_zero_pred_flag = 1; |
1113 | 0 | ps_mv_final_pred->i1_ref_frame[0] = 0; |
1114 | 0 | ps_mv_final_pred->i1_ref_frame[1] = 0; |
1115 | 0 | } |
1116 | 0 | ih264d_get_motion_vector_predictor( |
1117 | 0 | ps_mv_final_pred, ps_mv_pred, |
1118 | 0 | ps_mv_final_pred->i1_ref_frame[0], 0, |
1119 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
1120 | |
|
1121 | 0 | ih264d_get_motion_vector_predictor( |
1122 | 0 | ps_mv_final_pred, ps_mv_pred, |
1123 | 0 | ps_mv_final_pred->i1_ref_frame[1], 1, |
1124 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
1125 | |
|
1126 | 0 | break; |
1127 | 0 | 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 | 0 | u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & |
1136 | 0 | LEFT_MB_AVAILABLE_MASK); |
1137 | 0 | u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & |
1138 | 0 | TOP_MB_AVAILABLE_MASK); |
1139 | 0 | if(((u1_a_in * u1_b_in) == 0) |
1140 | 0 | || ((ps_mv_pred[LEFT]->i2_mv[0] |
1141 | 0 | | ps_mv_pred[LEFT]->i2_mv[1] |
1142 | 0 | | ps_mv_pred[LEFT]->i1_ref_frame[0]) |
1143 | 0 | == 0) |
1144 | 0 | || ((ps_mv_pred[TOP]->i2_mv[0] |
1145 | 0 | | ps_mv_pred[TOP]->i2_mv[1] |
1146 | 0 | | ps_mv_pred[TOP]->i1_ref_frame[0]) |
1147 | 0 | == 0)) |
1148 | 0 | { |
1149 | 0 | ps_mv_final_pred->i2_mv[0] = 0; |
1150 | 0 | ps_mv_final_pred->i2_mv[1] = 0; |
1151 | 0 | break; |
1152 | 0 | } |
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 | 0 | default: |
1156 | 0 | ih264d_get_motion_vector_predictor( |
1157 | 0 | ps_mv_final_pred, ps_mv_pred, u1_ref_idx, uc_lx, |
1158 | 0 | (const UWORD8 *)gau1_ih264d_mv_pred_condition); |
1159 | 0 | break; |
1160 | 0 | } |
1161 | 0 | } |
1162 | 0 | return (u1_direct_zero_pred_flag); |
1163 | 0 | } |
1164 | | |
1165 | | |
1166 | | |
1167 | | |
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 | | UWORD32 u4_sub_mb_num, |
1172 | | UWORD8 u1_colz, |
1173 | | UWORD8 u1_ht, |
1174 | | UWORD8 u1_wd) |
1175 | 15.1M | { |
1176 | | |
1177 | 15.1M | UWORD8 k, m; |
1178 | 15.1M | UWORD8 *pu1_colz = ps_dec->pu1_col_zero_flag + ps_dec->i4_submb_ofst |
1179 | 15.1M | + u4_sub_mb_num; |
1180 | | |
1181 | 74.5M | for(k = 0; k < u1_ht; k++) |
1182 | 59.3M | { |
1183 | 294M | for(m = 0; m < u1_wd; m++) |
1184 | 234M | { |
1185 | 234M | *(ps_mv_pred_dst + m) = *(ps_mv_pred_src); |
1186 | 234M | *(pu1_colz + m) = u1_colz; |
1187 | | |
1188 | 234M | } |
1189 | 59.3M | pu1_colz += SUB_BLK_WIDTH; |
1190 | 59.3M | ps_mv_pred_dst += SUB_BLK_WIDTH; |
1191 | 59.3M | } |
1192 | 15.1M | } |
1193 | | |