/src/libmpeg2/decoder/impeg2d_mc.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 |
23 | | * impeg2d_mc.c |
24 | | * |
25 | | * @brief |
26 | | * Contains MC function definitions for MPEG2 decoder |
27 | | * |
28 | | * @author |
29 | | * Harish |
30 | | * |
31 | | * @par List of Functions: |
32 | | * - impeg2d_motion_comp() |
33 | | * - impeg2d_motion_comp_recon_buf() |
34 | | * - impeg2d_mc_1mv() |
35 | | * - impeg2d_mc_fw_or_bk_mb() |
36 | | * - impeg2d_mc_frm_dual_prime() |
37 | | * - impeg2d_mc_fld_dual_prime() |
38 | | * - impeg2d_mc_4mv() |
39 | | * - impeg2d_mc_2mv() |
40 | | * - impeg2d_dec_intra_mb() |
41 | | * - impeg2d_dec_skip_p_mb() |
42 | | * - impeg2d_dec_skip_b_mb() |
43 | | * - impeg2d_dec_skip_mbs() |
44 | | * - impeg2d_dec_0mv_coded_mb() |
45 | | * - impeg2d_mc_halfx_halfy() |
46 | | * - impeg2d_mc_halfx_fully() |
47 | | * - impeg2d_mc_fullx_halfy() |
48 | | * - impeg2d_mc_fullx_fully() |
49 | | * - impeg2d_set_mc_params() |
50 | | * |
51 | | * @remarks |
52 | | * None |
53 | | * |
54 | | ******************************************************************************* |
55 | | */ |
56 | | #include <string.h> |
57 | | |
58 | | #include "iv_datatypedef.h" |
59 | | #include "iv.h" |
60 | | |
61 | | #include "impeg2_buf_mgr.h" |
62 | | #include "impeg2_disp_mgr.h" |
63 | | #include "impeg2_defs.h" |
64 | | #include "impeg2_platform_macros.h" |
65 | | #include "impeg2_inter_pred.h" |
66 | | #include "impeg2_idct.h" |
67 | | #include "impeg2_globals.h" |
68 | | #include "impeg2_format_conv.h" |
69 | | #include "impeg2_macros.h" |
70 | | |
71 | | #include "ivd.h" |
72 | | #include "impeg2d.h" |
73 | | #include "impeg2d_bitstream.h" |
74 | | #include "impeg2d_structs.h" |
75 | | #include "impeg2d_globals.h" |
76 | | #include "impeg2d_pic_proc.h" |
77 | | #include "impeg2d_debug.h" |
78 | | #include "impeg2d_mv_dec.h" |
79 | | #include "impeg2d_mc.h" |
80 | | |
81 | | /*****************************************************************************/ |
82 | | /* */ |
83 | | /* Function Name : impeg2d_motion_comp */ |
84 | | /* */ |
85 | | /* Description : Perform motion compensation and store the resulting block*/ |
86 | | /* in the buf */ |
87 | | /* */ |
88 | | /* Inputs : params - Parameters required to do motion compensation */ |
89 | | /* */ |
90 | | /* Globals : */ |
91 | | /* */ |
92 | | /* Processing : Calls appropriate functions depending on the mode of */ |
93 | | /* compensation */ |
94 | | /* */ |
95 | | /* Outputs : buf - Buffer for the motion compensation result */ |
96 | | /* */ |
97 | | /* Returns : None */ |
98 | | /* */ |
99 | | /* Issues : None */ |
100 | | /* */ |
101 | | /* Revision History: */ |
102 | | /* */ |
103 | | /* DD MM YYYY Author(s) Changes */ |
104 | | /* 14 09 2005 Hairsh M First Version */ |
105 | | /* */ |
106 | | /*****************************************************************************/ |
107 | | void impeg2d_motion_comp(dec_state_t *ps_dec, mb_mc_params_t *ps_params,yuv_buf_t *ps_buf) |
108 | 1.24M | { |
109 | | |
110 | 1.24M | PROFILE_DISABLE_MC_RETURN; |
111 | | |
112 | | /* Perform motion compensation for Y */ |
113 | 1.24M | ps_dec->pf_mc[ps_params->s_luma.u4_mode]((void *)ps_dec, ps_params->s_ref.pu1_y + ps_params->s_luma.u4_src_offset, |
114 | 1.24M | ps_params->s_luma.u4_src_wd, |
115 | 1.24M | ps_buf->pu1_y + ps_params->s_luma.u4_dst_offset_res_buf, |
116 | 1.24M | ps_params->s_luma.u4_dst_wd_res_buf, |
117 | 1.24M | ps_params->s_luma.u4_cols, |
118 | 1.24M | ps_params->s_luma.u4_rows); |
119 | | /* Perform motion compensation for U */ |
120 | 1.24M | ps_dec->pf_mc[ps_params->s_chroma.u4_mode]((void *)ps_dec, ps_params->s_ref.pu1_u + ps_params->s_chroma.u4_src_offset, |
121 | 1.24M | ps_params->s_chroma.u4_src_wd, |
122 | 1.24M | ps_buf->pu1_u + ps_params->s_chroma.u4_dst_offset_res_buf, |
123 | 1.24M | ps_params->s_chroma.u4_dst_wd_res_buf, |
124 | 1.24M | ps_params->s_chroma.u4_cols, |
125 | 1.24M | ps_params->s_chroma.u4_rows); |
126 | | |
127 | | /* Perform motion compensation for V */ |
128 | 1.24M | ps_dec->pf_mc[ps_params->s_chroma.u4_mode]((void *)ps_dec, ps_params->s_ref.pu1_v + ps_params->s_chroma.u4_src_offset, |
129 | 1.24M | ps_params->s_chroma.u4_src_wd, |
130 | 1.24M | ps_buf->pu1_v + ps_params->s_chroma.u4_dst_offset_res_buf, |
131 | 1.24M | ps_params->s_chroma.u4_dst_wd_res_buf, |
132 | 1.24M | ps_params->s_chroma.u4_cols, |
133 | 1.24M | ps_params->s_chroma.u4_rows); |
134 | 1.24M | } |
135 | | |
136 | | |
137 | | |
138 | | /*****************************************************************************/ |
139 | | /* */ |
140 | | /* Function Name : impeg2d_motion_comp_recon_buf */ |
141 | | /* */ |
142 | | /* Description : Perform motion compensation and store the resulting block*/ |
143 | | /* in the buf */ |
144 | | /* */ |
145 | | /* Inputs : params - Parameters required to do motion compensation */ |
146 | | /* */ |
147 | | /* Globals : */ |
148 | | /* */ |
149 | | /* Processing : Calls appropriate functions depending on the mode of */ |
150 | | /* compensation */ |
151 | | /* */ |
152 | | /* Outputs : buf - Buffer for the motion compensation result */ |
153 | | /* */ |
154 | | /* Returns : None */ |
155 | | /* */ |
156 | | /* Issues : None */ |
157 | | /* */ |
158 | | /* Revision History: */ |
159 | | /* */ |
160 | | /* DD MM YYYY Author(s) Changes */ |
161 | | /* 14 09 2005 Harish M First Version */ |
162 | | /* */ |
163 | | /*****************************************************************************/ |
164 | | void impeg2d_motion_comp_recon_buf(dec_state_t *ps_dec, |
165 | | mb_mc_params_t *ps_params, |
166 | | yuv_buf_t *ps_dest_buf) |
167 | 3.71M | { |
168 | | |
169 | 3.71M | PROFILE_DISABLE_MC_RETURN; |
170 | | |
171 | | /* Perform motion compensation for Y */ |
172 | 3.71M | ps_dec->pf_mc[ps_params->s_luma.u4_mode](ps_dec, ps_params->s_ref.pu1_y + ps_params->s_luma.u4_src_offset, |
173 | 3.71M | ps_params->s_luma.u4_src_wd, |
174 | 3.71M | ps_dest_buf->pu1_y + ps_params->s_luma.u4_dst_offset_cur_frm, |
175 | 3.71M | ps_params->s_luma.u4_dst_wd_cur_frm, |
176 | 3.71M | ps_params->s_luma.u4_cols, |
177 | 3.71M | ps_params->s_luma.u4_rows); |
178 | | |
179 | | /* Perform motion compensation for U */ |
180 | | |
181 | 3.71M | ps_dec->pf_mc[ps_params->s_chroma.u4_mode](ps_dec, ps_params->s_ref.pu1_u + ps_params->s_chroma.u4_src_offset, |
182 | 3.71M | ps_params->s_chroma.u4_src_wd, |
183 | 3.71M | ps_dest_buf->pu1_u + ps_params->s_chroma.u4_dst_offset_cur_frm, |
184 | 3.71M | ps_params->s_chroma.u4_dst_wd_cur_frm, |
185 | 3.71M | ps_params->s_chroma.u4_cols, |
186 | 3.71M | ps_params->s_chroma.u4_rows); |
187 | | |
188 | | /* Perform motion compensation for V */ |
189 | 3.71M | ps_dec->pf_mc[ps_params->s_chroma.u4_mode](ps_dec, ps_params->s_ref.pu1_v + ps_params->s_chroma.u4_src_offset, |
190 | 3.71M | ps_params->s_chroma.u4_src_wd, |
191 | 3.71M | ps_dest_buf->pu1_v + ps_params->s_chroma.u4_dst_offset_cur_frm, |
192 | 3.71M | ps_params->s_chroma.u4_dst_wd_cur_frm, |
193 | 3.71M | ps_params->s_chroma.u4_cols, |
194 | 3.71M | ps_params->s_chroma.u4_rows); |
195 | 3.71M | } |
196 | | |
197 | | |
198 | | |
199 | | /*****************************************************************************/ |
200 | | /* */ |
201 | | /* Function Name : impeg2d_mc_1mv */ |
202 | | /* */ |
203 | | /* Description : Perform motion compensation and store the resulting block*/ |
204 | | /* in the buf */ |
205 | | /* */ |
206 | | /* Inputs : params - Parameters required to do motion compensation */ |
207 | | /* */ |
208 | | /* Globals : */ |
209 | | /* */ |
210 | | /* Processing : Calls appropriate functions depending on the mode of */ |
211 | | /* compensation */ |
212 | | /* */ |
213 | | /* Outputs : buf - Buffer for the motion compensation result */ |
214 | | /* */ |
215 | | /* Returns : None */ |
216 | | /* */ |
217 | | /* Issues : None */ |
218 | | /* */ |
219 | | /* Revision History: */ |
220 | | /* */ |
221 | | /* DD MM YYYY Author(s) Changes */ |
222 | | /* 14 09 2005 Hairsh M First Version */ |
223 | | /* */ |
224 | | /*****************************************************************************/ |
225 | | void impeg2d_mc_1mv(dec_state_t *ps_dec) |
226 | 3.58M | { |
227 | | |
228 | 3.58M | impeg2d_motion_comp_recon_buf(ps_dec, &ps_dec->as_mb_mc_params[ps_dec->e_mb_pred][FIRST], &ps_dec->s_dest_buf); |
229 | 3.58M | } |
230 | | |
231 | | |
232 | | |
233 | | /*****************************************************************************/ |
234 | | /* */ |
235 | | /* Function Name : impeg2d_mc_fw_or_bk_mb */ |
236 | | /* */ |
237 | | /* Description : Perform motion compensation and store the resulting block*/ |
238 | | /* in the buf */ |
239 | | /* */ |
240 | | /* Inputs : params - Parameters required to do motion compensation */ |
241 | | /* */ |
242 | | /* Globals : */ |
243 | | /* */ |
244 | | /* Processing : Calls appropriate functions depending on the mode of */ |
245 | | /* compensation */ |
246 | | /* */ |
247 | | /* Outputs : buf - Buffer for the motion compensation result */ |
248 | | /* */ |
249 | | /* Returns : None */ |
250 | | /* */ |
251 | | /* Issues : None */ |
252 | | /* */ |
253 | | /* Revision History: */ |
254 | | /* */ |
255 | | /* DD MM YYYY Author(s) Changes */ |
256 | | /* 14 09 2005 Hairsh M First Version */ |
257 | | /* */ |
258 | | /*****************************************************************************/ |
259 | | void impeg2d_mc_fw_or_bk_mb(dec_state_t *ps_dec) |
260 | 61.1k | { |
261 | 61.1k | impeg2d_motion_comp_recon_buf(ps_dec, &ps_dec->as_mb_mc_params[FORW][FIRST], &ps_dec->s_dest_buf); |
262 | 61.1k | impeg2d_motion_comp_recon_buf(ps_dec, &ps_dec->as_mb_mc_params[FORW][SECOND], &ps_dec->s_dest_buf); |
263 | 61.1k | } |
264 | | |
265 | | |
266 | | |
267 | | /*****************************************************************************/ |
268 | | /* */ |
269 | | /* Function Name : impeg2d_mc_frm_dual_prime */ |
270 | | /* */ |
271 | | /* Description : Perform motion compensation and store the resulting block*/ |
272 | | /* in the buf */ |
273 | | /* */ |
274 | | /* Inputs : params - Parameters required to do motion compensation */ |
275 | | /* */ |
276 | | /* Globals : */ |
277 | | /* */ |
278 | | /* Processing : Calls appropriate functions depending on the mode of */ |
279 | | /* compensation */ |
280 | | /* */ |
281 | | /* Outputs : buf - Buffer for the motion compensation result */ |
282 | | /* */ |
283 | | /* Returns : None */ |
284 | | /* */ |
285 | | /* Issues : None */ |
286 | | /* */ |
287 | | /* Revision History: */ |
288 | | /* */ |
289 | | /* DD MM YYYY Author(s) Changes */ |
290 | | /* 14 09 2005 Hairsh M First Version */ |
291 | | /* */ |
292 | | /*****************************************************************************/ |
293 | | void impeg2d_mc_frm_dual_prime(dec_state_t *ps_dec) |
294 | 17.6k | { |
295 | | /************************************************************************/ |
296 | | /* Perform Motion Compensation */ |
297 | | /************************************************************************/ |
298 | 17.6k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[FORW][FIRST], &ps_dec->s_mc_fw_buf); |
299 | 17.6k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[BACK][FIRST], &ps_dec->s_mc_bk_buf); |
300 | | |
301 | 17.6k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[FORW][SECOND], &ps_dec->s_mc_fw_buf); |
302 | 17.6k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[BACK][SECOND], &ps_dec->s_mc_bk_buf); |
303 | | |
304 | | |
305 | | |
306 | 17.6k | ps_dec->pf_interpolate(&ps_dec->s_mc_fw_buf,&ps_dec->s_mc_bk_buf,&ps_dec->s_dest_buf,ps_dec->u2_picture_width); |
307 | 17.6k | } |
308 | | |
309 | | |
310 | | |
311 | | /*****************************************************************************/ |
312 | | /* */ |
313 | | /* Function Name : impeg2d_mc_fld_dual_prime */ |
314 | | /* */ |
315 | | /* Description : Perform motion compensation and store the resulting block*/ |
316 | | /* in the buf */ |
317 | | /* */ |
318 | | /* Inputs : params - Parameters required to do motion compensation */ |
319 | | /* */ |
320 | | /* Globals : */ |
321 | | /* */ |
322 | | /* Processing : Calls appropriate functions depending on the mode of */ |
323 | | /* compensation */ |
324 | | /* */ |
325 | | /* Outputs : buf - Buffer for the motion compensation result */ |
326 | | /* */ |
327 | | /* Returns : None */ |
328 | | /* */ |
329 | | /* Issues : None */ |
330 | | /* */ |
331 | | /* Revision History: */ |
332 | | /* */ |
333 | | /* DD MM YYYY Author(s) Changes */ |
334 | | /* 14 09 2005 Hairsh M First Version */ |
335 | | /* */ |
336 | | /*****************************************************************************/ |
337 | | void impeg2d_mc_fld_dual_prime(dec_state_t *ps_dec) |
338 | 1.13k | { |
339 | | /************************************************************************/ |
340 | | /* Perform Motion Compensation */ |
341 | | /************************************************************************/ |
342 | 1.13k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[FORW][FIRST], &ps_dec->s_mc_fw_buf); |
343 | 1.13k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[FORW][SECOND], &ps_dec->s_mc_bk_buf); |
344 | | |
345 | | |
346 | 1.13k | ps_dec->pf_interpolate(&ps_dec->s_mc_fw_buf,&ps_dec->s_mc_bk_buf,&ps_dec->s_dest_buf,ps_dec->u2_picture_width); |
347 | 1.13k | } |
348 | | |
349 | | |
350 | | |
351 | | |
352 | | |
353 | | /*****************************************************************************/ |
354 | | /* */ |
355 | | /* Function Name : impeg2d_mc_4mv */ |
356 | | /* */ |
357 | | /* Description : Perform motion compensation and store the resulting block*/ |
358 | | /* in the buf */ |
359 | | /* */ |
360 | | /* Inputs : params - Parameters required to do motion compensation */ |
361 | | /* */ |
362 | | /* Globals : */ |
363 | | /* */ |
364 | | /* Processing : Calls appropriate functions depending on the mode of */ |
365 | | /* compensation */ |
366 | | /* */ |
367 | | /* Outputs : buf - Buffer for the motion compensation result */ |
368 | | /* */ |
369 | | /* Returns : None */ |
370 | | /* */ |
371 | | /* Issues : None */ |
372 | | /* */ |
373 | | /* Revision History: */ |
374 | | /* */ |
375 | | /* DD MM YYYY Author(s) Changes */ |
376 | | /* 14 09 2005 Hairsh M First Version */ |
377 | | /* */ |
378 | | /*****************************************************************************/ |
379 | | void impeg2d_mc_4mv(dec_state_t *ps_dec) |
380 | 32.4k | { |
381 | | /************************************************************************/ |
382 | | /* Perform Motion Compensation */ |
383 | | /************************************************************************/ |
384 | 32.4k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[FORW][FIRST], &ps_dec->s_mc_fw_buf); |
385 | 32.4k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[BACK][FIRST], &ps_dec->s_mc_bk_buf); |
386 | 32.4k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[FORW][SECOND], &ps_dec->s_mc_fw_buf); |
387 | 32.4k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[BACK][SECOND], &ps_dec->s_mc_bk_buf); |
388 | | |
389 | 32.4k | ps_dec->pf_interpolate(&ps_dec->s_mc_fw_buf,&ps_dec->s_mc_bk_buf,&ps_dec->s_dest_buf,ps_dec->u2_picture_width); |
390 | 32.4k | } |
391 | | |
392 | | /*****************************************************************************/ |
393 | | /* */ |
394 | | /* Function Name : impeg2d_mc_2mv */ |
395 | | /* */ |
396 | | /* Description : Perform motion compensation and store the resulting block*/ |
397 | | /* in the buf */ |
398 | | /* */ |
399 | | /* Inputs : params - Parameters required to do motion compensation */ |
400 | | /* */ |
401 | | /* Globals : */ |
402 | | /* */ |
403 | | /* Processing : Calls appropriate functions depending on the mode of */ |
404 | | /* compensation */ |
405 | | /* */ |
406 | | /* Outputs : buf - Buffer for the motion compensation result */ |
407 | | /* */ |
408 | | /* Returns : None */ |
409 | | /* */ |
410 | | /* Issues : None */ |
411 | | /* */ |
412 | | /* Revision History: */ |
413 | | /* */ |
414 | | /* DD MM YYYY Author(s) Changes */ |
415 | | /* 14 09 2005 Hairsh M First Version */ |
416 | | /* */ |
417 | | /*****************************************************************************/ |
418 | | void impeg2d_mc_2mv(dec_state_t *ps_dec) |
419 | 52.9k | { |
420 | | /************************************************************************/ |
421 | | /* Perform Motion Compensation */ |
422 | | /************************************************************************/ |
423 | 52.9k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[FORW][FIRST], &ps_dec->s_mc_fw_buf); |
424 | 52.9k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[BACK][FIRST], &ps_dec->s_mc_bk_buf); |
425 | | |
426 | 52.9k | ps_dec->pf_interpolate(&ps_dec->s_mc_fw_buf,&ps_dec->s_mc_bk_buf,&ps_dec->s_dest_buf,ps_dec->u2_picture_width); |
427 | 52.9k | } |
428 | | |
429 | | /***************************************************************************** |
430 | | * Function Name : impeg2d_dec_intra_mb |
431 | | * |
432 | | * Description : Performs decoding of Intra MB |
433 | | * |
434 | | * Arguments : |
435 | | * dec : Decoder state |
436 | | * |
437 | | * Values Returned : None |
438 | | *****************************************************************************/ |
439 | | void impeg2d_dec_intra_mb(dec_state_t *ps_dec) |
440 | 8.59k | { |
441 | | |
442 | 8.59k | ps_dec->u2_cbp = 0x3F; |
443 | 8.59k | if(ps_dec->u2_concealment_motion_vectors) |
444 | 4.04k | { |
445 | | |
446 | 4.04k | stream_t *ps_stream; |
447 | | |
448 | 4.04k | ps_stream = &ps_dec->s_bit_stream; |
449 | | /* Decode the concealment motion vector */ |
450 | 4.04k | impeg2d_dec_mv(ps_stream,ps_dec->ai2_pred_mv[FORW][FIRST],ps_dec->ai2_mv[FORW][FIRST], |
451 | 4.04k | ps_dec->au2_f_code[FORW],0,ps_dec->u2_fld_pic); |
452 | | |
453 | | |
454 | | /* Set the second motion vector predictor */ |
455 | 4.04k | ps_dec->ai2_pred_mv[FORW][SECOND][MV_X] = ps_dec->ai2_pred_mv[FORW][FIRST][MV_X]; |
456 | 4.04k | ps_dec->ai2_pred_mv[FORW][SECOND][MV_Y] = ps_dec->ai2_pred_mv[FORW][FIRST][MV_Y]; |
457 | | |
458 | | /* Flush the marker bit */ |
459 | 4.04k | if(0 == (impeg2d_bit_stream_get(ps_stream,1))) |
460 | 471 | { |
461 | | /* Ignore marker bit error */ |
462 | 471 | } |
463 | 4.04k | } |
464 | 4.55k | else |
465 | 4.55k | { |
466 | | /* Reset the motion vector predictors */ |
467 | 4.55k | memset(ps_dec->ai2_pred_mv,0,sizeof(ps_dec->ai2_pred_mv)); |
468 | 4.55k | } |
469 | 8.59k | } |
470 | | |
471 | | /***************************************************************************** |
472 | | * Function Name : impeg2d_dec_skip_p_mb |
473 | | * |
474 | | * Description : Performs decoding needed for Skipped MB encountered in |
475 | | * P Pictures and B Pictures with previous MB not bi-predicted |
476 | | * |
477 | | * Arguments : |
478 | | * dec : Decoder state |
479 | | * |
480 | | * Values Returned : None |
481 | | *****************************************************************************/ |
482 | | void impeg2d_dec_skip_p_mb(dec_state_t *ps_dec, WORD32 u4_num_of_mbs) |
483 | 764k | { |
484 | 764k | WORD16 *pi2_mv; |
485 | | |
486 | 764k | e_mb_type_t e_mb_type; |
487 | 764k | mb_mc_params_t *ps_mc; |
488 | | |
489 | | |
490 | 764k | WORD32 i4_iter; |
491 | 764k | UWORD32 u4_dst_wd; |
492 | 764k | UWORD32 u4_dst_offset_x; |
493 | 764k | UWORD32 u4_dst_offset_y; |
494 | 764k | UWORD32 u4_frm_offset = 0; |
495 | 764k | yuv_buf_t s_dst; |
496 | | |
497 | 764k | u4_dst_wd = ps_dec->u2_frame_width; |
498 | | |
499 | 764k | if(ps_dec->u2_picture_structure != FRAME_PICTURE) |
500 | 15.4k | { |
501 | 15.4k | u4_dst_wd <<= 1; |
502 | 15.4k | if(ps_dec->u2_picture_structure == BOTTOM_FIELD) |
503 | 13.1k | { |
504 | 13.1k | u4_frm_offset = ps_dec->u2_frame_width; |
505 | 13.1k | } |
506 | 15.4k | } |
507 | | |
508 | 15.4M | for (i4_iter = u4_num_of_mbs; i4_iter > 0; i4_iter--) |
509 | 14.6M | { |
510 | 14.6M | if(ps_dec->u2_picture_structure == FRAME_PICTURE) |
511 | 14.6M | { |
512 | 14.6M | e_mb_type = MC_FRM_FW_AND_BK_2MV; |
513 | 14.6M | } |
514 | 81.0k | else |
515 | 81.0k | { |
516 | 81.0k | e_mb_type = MC_FLD_FW_AND_BK_2MV; |
517 | 81.0k | } |
518 | | |
519 | 14.6M | ps_dec->u2_prev_intra_mb = 0; |
520 | 14.6M | pi2_mv = (WORD16 *)&(ps_dec->ai2_mv[FORW][FIRST]); |
521 | | |
522 | | /* Reset the motion vector predictors */ |
523 | 14.6M | if(ps_dec->e_pic_type == P_PIC) |
524 | 14.0M | { |
525 | 14.0M | memset(ps_dec->ai2_pred_mv,0,sizeof(ps_dec->ai2_pred_mv)); |
526 | 14.0M | pi2_mv[MV_X] = pi2_mv[MV_Y] = 0; |
527 | | |
528 | 14.0M | ps_dec->u2_cbp = 0; |
529 | | |
530 | 14.0M | pi2_mv = (WORD16 *)&ps_dec->ai2_mv[FORW][FIRST]; |
531 | 14.0M | ps_mc = &ps_dec->as_mb_mc_params[FORW][FIRST]; |
532 | 14.0M | ps_mc->s_ref = ps_dec->as_ref_buf[ps_dec->e_mb_pred][ps_dec->u2_fld_parity]; |
533 | | |
534 | 14.0M | impeg2d_set_mc_params(&ps_mc->s_luma, &ps_mc->s_chroma, e_mb_type, 0, |
535 | 14.0M | pi2_mv, ps_dec->u2_mb_x, ps_dec->u2_mb_y, ps_dec->u2_frame_width, ps_dec->u2_frame_height,ps_dec->u2_picture_width); |
536 | | |
537 | | |
538 | 14.0M | u4_dst_offset_x = (ps_dec->u2_mb_x << 4) + u4_frm_offset; |
539 | 14.0M | u4_dst_offset_y = (ps_dec->u2_mb_y << 4) * u4_dst_wd; |
540 | | |
541 | 14.0M | s_dst.pu1_y = ps_dec->s_cur_frm_buf.pu1_y + u4_dst_offset_x + u4_dst_offset_y; |
542 | | |
543 | 14.0M | u4_dst_offset_x = u4_dst_offset_x >> 1; |
544 | 14.0M | u4_dst_offset_y = u4_dst_offset_y >> 2; |
545 | | |
546 | 14.0M | s_dst.pu1_u = ps_dec->s_cur_frm_buf.pu1_u + u4_dst_offset_x + u4_dst_offset_y; |
547 | 14.0M | s_dst.pu1_v = ps_dec->s_cur_frm_buf.pu1_v + u4_dst_offset_x + u4_dst_offset_y; |
548 | | |
549 | | |
550 | 14.0M | ps_mc->s_ref.pu1_y += ps_mc->s_luma.u4_src_offset; |
551 | 14.0M | ps_mc->s_ref.pu1_u += ps_mc->s_chroma.u4_src_offset; |
552 | 14.0M | ps_mc->s_ref.pu1_v += ps_mc->s_chroma.u4_src_offset; |
553 | | |
554 | 14.0M | ps_dec->pf_copy_mb(&ps_mc->s_ref, &s_dst, ps_mc->s_luma.u4_src_wd, u4_dst_wd); |
555 | 14.0M | } |
556 | | |
557 | 636k | else |
558 | 636k | { |
559 | 636k | pi2_mv[MV_X] = ps_dec->ai2_pred_mv[ps_dec->e_mb_pred][FIRST][MV_X]; |
560 | 636k | pi2_mv[MV_Y] = ps_dec->ai2_pred_mv[ps_dec->e_mb_pred][FIRST][MV_Y]; |
561 | | |
562 | 636k | ps_dec->u2_cbp = 0; |
563 | | |
564 | 636k | pi2_mv = (WORD16 *)&ps_dec->ai2_mv[FORW][FIRST]; |
565 | 636k | ps_mc = &ps_dec->as_mb_mc_params[FORW][FIRST]; |
566 | 636k | ps_mc->s_ref = ps_dec->as_ref_buf[ps_dec->e_mb_pred][ps_dec->u2_fld_parity]; |
567 | | |
568 | 636k | impeg2d_set_mc_params(&ps_mc->s_luma, &ps_mc->s_chroma, e_mb_type, 0, |
569 | 636k | pi2_mv, ps_dec->u2_mb_x, ps_dec->u2_mb_y, ps_dec->u2_frame_width, ps_dec->u2_frame_height,ps_dec->u2_picture_width); |
570 | | |
571 | 636k | u4_dst_offset_x = (ps_dec->u2_mb_x << 4) + u4_frm_offset; |
572 | 636k | u4_dst_offset_y = (ps_dec->u2_mb_y << 4) * u4_dst_wd; |
573 | | |
574 | 636k | ps_mc->s_luma.u4_dst_offset_res_buf = u4_dst_offset_x + u4_dst_offset_y; |
575 | 636k | ps_mc->s_luma.u4_dst_wd_res_buf = u4_dst_wd; |
576 | | |
577 | 636k | u4_dst_offset_x = u4_dst_offset_x >> 1; |
578 | 636k | u4_dst_offset_y = u4_dst_offset_y >> 2; |
579 | | |
580 | 636k | ps_mc->s_chroma.u4_dst_offset_res_buf = u4_dst_offset_x + u4_dst_offset_y; |
581 | 636k | ps_mc->s_chroma.u4_dst_wd_res_buf = u4_dst_wd >> 1; |
582 | | |
583 | 636k | impeg2d_motion_comp(ps_dec, ps_mc, &ps_dec->s_cur_frm_buf); |
584 | 636k | } |
585 | | |
586 | | |
587 | | /********************************************************************/ |
588 | | /* Common MB processing tasks */ |
589 | | /********************************************************************/ |
590 | 14.6M | ps_dec->u2_mb_x++; |
591 | 14.6M | ps_dec->u2_num_mbs_left--; |
592 | | |
593 | 14.6M | if (ps_dec->u2_mb_x == ps_dec->u2_num_horiz_mb) |
594 | 99.4k | { |
595 | 99.4k | ps_dec->u2_mb_x = 0; |
596 | 99.4k | ps_dec->u2_mb_y++; |
597 | 99.4k | } |
598 | 14.6M | } |
599 | | |
600 | 764k | } |
601 | | |
602 | | /******************************************************************************* |
603 | | * Function Name : impeg2d_dec_skip_b_mb |
604 | | * |
605 | | * Description : Performs processing needed for Skipped MB encountered in |
606 | | * B Pictures with previous MB bi-predicted. |
607 | | * |
608 | | * Arguments : |
609 | | * dec : Decoder state |
610 | | * |
611 | | * Values Returned : None |
612 | | *******************************************************************************/ |
613 | | void impeg2d_dec_skip_b_mb(dec_state_t *ps_dec, WORD32 u4_num_of_mbs) |
614 | 53.6k | { |
615 | | |
616 | | |
617 | 53.6k | WORD16 *pi2_mv; |
618 | | |
619 | 53.6k | UWORD32 i; |
620 | 53.6k | e_mb_type_t e_mb_type; |
621 | 53.6k | mb_mc_params_t *ps_mc; |
622 | | |
623 | 53.6k | WORD32 i4_iter; |
624 | 53.6k | UWORD32 u4_dst_wd; |
625 | 53.6k | yuv_buf_t s_dst; |
626 | 53.6k | UWORD32 u4_dst_offset_x; |
627 | 53.6k | UWORD32 u4_dst_offset_y; |
628 | 53.6k | UWORD32 u4_frm_offset = 0; |
629 | | |
630 | 53.6k | u4_dst_wd = ps_dec->u2_frame_width; |
631 | 53.6k | s_dst = ps_dec->s_cur_frm_buf; |
632 | | |
633 | 53.6k | if(ps_dec->u2_picture_structure != FRAME_PICTURE) |
634 | 1.68k | { |
635 | 1.68k | u4_dst_wd <<= 1; |
636 | 1.68k | if(ps_dec->u2_picture_structure == BOTTOM_FIELD) |
637 | 795 | { |
638 | 795 | u4_frm_offset = ps_dec->u2_frame_width; |
639 | 795 | } |
640 | 1.68k | } |
641 | | |
642 | 203k | for (i4_iter = u4_num_of_mbs; i4_iter > 0; i4_iter--) |
643 | 150k | { |
644 | 150k | ps_dec->u2_prev_intra_mb = 0; |
645 | | |
646 | 150k | if(ps_dec->u2_picture_structure == FRAME_PICTURE) |
647 | 143k | { |
648 | 143k | e_mb_type = MC_FRM_FW_AND_BK_2MV; |
649 | 143k | } |
650 | 6.88k | else |
651 | 6.88k | { |
652 | 6.88k | e_mb_type = MC_FLD_FW_AND_BK_2MV; |
653 | 6.88k | } |
654 | | |
655 | | /************************************************************************/ |
656 | | /* Setting of first motion vector for B MB */ |
657 | | /************************************************************************/ |
658 | 150k | pi2_mv = (WORD16 *)&(ps_dec->ai2_mv[FORW][FIRST]); |
659 | 150k | { |
660 | 150k | pi2_mv[MV_X] = ps_dec->ai2_pred_mv[FORW][FIRST][MV_X]; |
661 | 150k | pi2_mv[MV_Y] = ps_dec->ai2_pred_mv[FORW][FIRST][MV_Y]; |
662 | 150k | } |
663 | | /************************************************************************/ |
664 | | /* Setting of second motion vector for B MB */ |
665 | | /************************************************************************/ |
666 | 150k | pi2_mv = (WORD16 *)&(ps_dec->ai2_mv[BACK][FIRST]); |
667 | 150k | { |
668 | 150k | pi2_mv[MV_X] = ps_dec->ai2_pred_mv[BACK][FIRST][MV_X]; |
669 | 150k | pi2_mv[MV_Y] = ps_dec->ai2_pred_mv[BACK][FIRST][MV_Y]; |
670 | 150k | } |
671 | 150k | ps_dec->u2_cbp = 0; |
672 | | |
673 | 450k | for(i = 0; i < 2; i++) |
674 | 299k | { |
675 | 299k | pi2_mv = (WORD16 *)&ps_dec->ai2_mv[i][FIRST]; |
676 | 299k | ps_mc = &ps_dec->as_mb_mc_params[i][FIRST]; |
677 | 299k | ps_mc->s_ref = ps_dec->as_ref_buf[i][ps_dec->u2_fld_parity]; |
678 | | |
679 | 299k | impeg2d_set_mc_params(&ps_mc->s_luma, &ps_mc->s_chroma, e_mb_type, 0, pi2_mv, ps_dec->u2_mb_x, |
680 | 299k | ps_dec->u2_mb_y, ps_dec->u2_frame_width, ps_dec->u2_frame_height,ps_dec->u2_picture_width); |
681 | 299k | } |
682 | | |
683 | 150k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[FORW][FIRST], &ps_dec->s_mc_fw_buf); |
684 | 150k | impeg2d_motion_comp(ps_dec, &ps_dec->as_mb_mc_params[BACK][FIRST], &ps_dec->s_mc_bk_buf); |
685 | | |
686 | 150k | u4_dst_offset_x = (ps_dec->u2_mb_x << 4) + u4_frm_offset; |
687 | 150k | u4_dst_offset_y = (ps_dec->u2_mb_y << 4) * u4_dst_wd; |
688 | | |
689 | 150k | s_dst.pu1_y = ps_dec->s_cur_frm_buf.pu1_y + u4_dst_offset_x + u4_dst_offset_y; |
690 | | |
691 | 150k | u4_dst_offset_x = u4_dst_offset_x >> 1; |
692 | 150k | u4_dst_offset_y = u4_dst_offset_y >> 2; |
693 | | |
694 | 150k | s_dst.pu1_u = ps_dec->s_cur_frm_buf.pu1_u + u4_dst_offset_x + u4_dst_offset_y; |
695 | 150k | s_dst.pu1_v = ps_dec->s_cur_frm_buf.pu1_v + u4_dst_offset_x + u4_dst_offset_y; |
696 | | |
697 | 150k | ps_dec->pf_interpolate(&ps_dec->s_mc_fw_buf,&ps_dec->s_mc_bk_buf,&s_dst, u4_dst_wd); |
698 | | // dec->pf_copy_mb(&dec->mc_buf, &dst, MB_SIZE, dst_wd); |
699 | | |
700 | | /********************************************************************/ |
701 | | /* Common MB processing tasks */ |
702 | | /********************************************************************/ |
703 | 150k | ps_dec->u2_mb_x++; |
704 | 150k | ps_dec->u2_num_mbs_left--; |
705 | | |
706 | 150k | if (ps_dec->u2_mb_x == ps_dec->u2_num_horiz_mb) |
707 | 945 | { |
708 | 945 | ps_dec->u2_mb_x = 0; |
709 | 945 | ps_dec->u2_mb_y++; |
710 | 945 | } |
711 | 150k | } |
712 | 53.6k | } |
713 | | /******************************************************************************* |
714 | | * Function Name : impeg2d_dec_skip_mbs |
715 | | * |
716 | | * Description : Performs processing needed for Skipped MB encountered in |
717 | | * B Pictures with previous MB bi-predicted. |
718 | | * |
719 | | * Arguments : |
720 | | * dec : Decoder state |
721 | | * |
722 | | * Values Returned : None |
723 | | *******************************************************************************/ |
724 | | void impeg2d_dec_skip_mbs(dec_state_t *ps_dec, UWORD16 u2_num_skip_mbs) |
725 | 817k | { |
726 | 817k | PROFILE_DISABLE_SKIP_MB(); |
727 | | |
728 | 817k | if(ps_dec->e_mb_pred == BIDIRECT) |
729 | 53.6k | { |
730 | 53.6k | impeg2d_dec_skip_b_mb(ps_dec, u2_num_skip_mbs); |
731 | 53.6k | } |
732 | 764k | else |
733 | 764k | { |
734 | 764k | impeg2d_dec_skip_p_mb(ps_dec, u2_num_skip_mbs); |
735 | 764k | } |
736 | | |
737 | 817k | ps_dec->u2_def_dc_pred[Y_LUMA] = 128 << ps_dec->u2_intra_dc_precision; |
738 | 817k | ps_dec->u2_def_dc_pred[U_CHROMA] = 128 << ps_dec->u2_intra_dc_precision; |
739 | 817k | ps_dec->u2_def_dc_pred[V_CHROMA] = 128 << ps_dec->u2_intra_dc_precision; |
740 | 817k | } |
741 | | |
742 | | |
743 | | |
744 | | |
745 | | /***************************************************************************** |
746 | | * Function Name : impeg2d_dec_0mv_coded_mb |
747 | | * |
748 | | * Description : Decodes the MB with 0 MV but coded. This can occur in P |
749 | | * pictures only |
750 | | * |
751 | | * Arguments : |
752 | | * dec : Decoder state |
753 | | * |
754 | | * Values Returned : None |
755 | | *****************************************************************************/ |
756 | | void impeg2d_dec_0mv_coded_mb(dec_state_t *ps_dec) |
757 | 436k | { |
758 | | |
759 | | |
760 | 436k | WORD16 *pi2_mv; |
761 | 436k | e_mb_type_t e_mb_type; |
762 | 436k | mb_mc_params_t *ps_mc; |
763 | | |
764 | 436k | if(ps_dec->u2_picture_structure == FRAME_PICTURE) |
765 | 425k | { |
766 | 425k | e_mb_type = MC_FRM_FW_AND_BK_2MV; |
767 | 425k | } |
768 | 11.0k | else |
769 | 11.0k | { |
770 | 11.0k | e_mb_type = MC_FLD_FW_AND_BK_2MV; |
771 | 11.0k | } |
772 | | |
773 | | |
774 | | |
775 | | |
776 | | /* Reset the motion vector predictors */ |
777 | 436k | memset(ps_dec->ai2_pred_mv,0,sizeof(ps_dec->ai2_pred_mv)); |
778 | | |
779 | 436k | pi2_mv = (WORD16 *)&ps_dec->ai2_mv[FORW][FIRST]; |
780 | 436k | ps_mc = &ps_dec->as_mb_mc_params[FORW][FIRST]; |
781 | 436k | ps_mc->s_ref = ps_dec->as_ref_buf[FORW][ps_dec->u2_fld_parity]; |
782 | | |
783 | 436k | pi2_mv[MV_X] = 0; |
784 | 436k | pi2_mv[MV_Y] = 0; |
785 | | |
786 | 436k | impeg2d_set_mc_params(&ps_mc->s_luma, &ps_mc->s_chroma, e_mb_type, 0, |
787 | 436k | pi2_mv, ps_dec->u2_mb_x, ps_dec->u2_mb_y, ps_dec->u2_frame_width, ps_dec->u2_frame_height,ps_dec->u2_picture_width); |
788 | 436k | } |
789 | | |
790 | | /*****************************************************************************/ |
791 | | /* */ |
792 | | /* Function Name : impeg2d_mc_halfx_halfy() */ |
793 | | /* */ |
794 | | /* Description : Gets the buffer from (0.5,0.5) to (8.5,8.5) */ |
795 | | /* and the above block of size 8 x 8 will be placed as a */ |
796 | | /* block from the current position of out_buf */ |
797 | | /* */ |
798 | | /* Inputs : ref - Reference frame from which the block will be */ |
799 | | /* block will be extracted. */ |
800 | | /* ref_wid - WIdth of reference frame */ |
801 | | /* out_wid - WIdth of the output frame */ |
802 | | /* blk_width - width of the block */ |
803 | | /* blk_width - height of the block */ |
804 | | /* */ |
805 | | /* Globals : None */ |
806 | | /* */ |
807 | | /* Processing : Point to the (0,0),(1,0),(0,1),(1,1) position in */ |
808 | | /* the ref frame.Interpolate these four values to get the */ |
809 | | /* value at(0.5,0.5).Repeat this to get an 8 x 8 block */ |
810 | | /* using 9 x 9 block from reference frame */ |
811 | | /* */ |
812 | | /* Outputs : out - Output containing the extracted block */ |
813 | | /* */ |
814 | | /* Returns : None */ |
815 | | /* */ |
816 | | /* Issues : None */ |
817 | | /* */ |
818 | | /* Revision History: */ |
819 | | /* */ |
820 | | /* DD MM YYYY Author(s) Changes */ |
821 | | /* 05 09 2005 Harish M First Version */ |
822 | | /* */ |
823 | | /*****************************************************************************/ |
824 | | void impeg2d_mc_halfx_halfy(void *pv_dec, |
825 | | UWORD8 *pu1_ref, |
826 | | UWORD32 u4_ref_wid, |
827 | | UWORD8 *pu1_out, |
828 | | UWORD32 u4_out_wid, |
829 | | UWORD32 u4_blk_width, |
830 | | UWORD32 u4_blk_height) |
831 | 2.65M | { |
832 | 2.65M | UWORD8 *pu1_out_ptr,*pu1_ref_ptr; |
833 | 2.65M | dec_state_t *ps_dec = (dec_state_t *)pv_dec; |
834 | | |
835 | 2.65M | pu1_out_ptr = pu1_out; |
836 | 2.65M | pu1_ref_ptr = pu1_ref; |
837 | | |
838 | 2.65M | if((u4_blk_width == MB_SIZE) && (u4_blk_height == MB_SIZE)) |
839 | 475k | { |
840 | | |
841 | | /*luma 16 x 16*/ |
842 | | |
843 | | /*block 0*/ |
844 | 475k | ps_dec->pf_halfx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
845 | | |
846 | | /*block1*/ |
847 | 475k | pu1_out_ptr = (pu1_out + BLK_SIZE); |
848 | 475k | pu1_ref_ptr = (pu1_ref + BLK_SIZE); |
849 | 475k | ps_dec->pf_halfx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
850 | | |
851 | | /*block 2*/ |
852 | 475k | pu1_out_ptr = pu1_out + BLK_SIZE * u4_out_wid; |
853 | 475k | pu1_ref_ptr = pu1_ref + BLK_SIZE * u4_ref_wid; |
854 | 475k | ps_dec->pf_halfx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
855 | | |
856 | | /*block 3*/ |
857 | 475k | pu1_out_ptr = pu1_out + BLK_SIZE * u4_out_wid + BLK_SIZE; |
858 | 475k | pu1_ref_ptr = pu1_ref + BLK_SIZE * u4_ref_wid + BLK_SIZE; |
859 | 475k | ps_dec->pf_halfx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
860 | | |
861 | | |
862 | | |
863 | | |
864 | 475k | } |
865 | 2.17M | else if ((u4_blk_width == BLK_SIZE) && (u4_blk_height == BLK_SIZE)) |
866 | 1.98M | { |
867 | | /*chroma 8 x 8*/ |
868 | 1.98M | ps_dec->pf_halfx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
869 | 1.98M | } |
870 | 190k | else if ((u4_blk_width == MB_SIZE) && (u4_blk_height == BLK_SIZE)) |
871 | 55.4k | { |
872 | | /*block 0*/ |
873 | 55.4k | ps_dec->pf_halfx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
874 | | |
875 | | /*block 1*/ |
876 | 55.4k | pu1_out_ptr = (pu1_out + BLK_SIZE); |
877 | 55.4k | pu1_ref_ptr = (pu1_ref + BLK_SIZE); |
878 | 55.4k | ps_dec->pf_halfx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
879 | | |
880 | 55.4k | } |
881 | | |
882 | 135k | else |
883 | 135k | { |
884 | 135k | UWORD8 *ref_p0,*ref_p1,*ref_p2,*ref_p3; |
885 | 135k | UWORD32 i,j; |
886 | | /* P0-P3 are the pixels in the reference frame and Q is the value being */ |
887 | | /* estimated */ |
888 | | /* |
889 | | P0 P1 |
890 | | Q |
891 | | P2 P3 |
892 | | */ |
893 | | |
894 | 135k | ref_p0 = pu1_ref; |
895 | 135k | ref_p1 = pu1_ref + 1; |
896 | 135k | ref_p2 = pu1_ref + u4_ref_wid; |
897 | 135k | ref_p3 = pu1_ref + u4_ref_wid + 1; |
898 | | |
899 | 682k | for(i = 0; i < u4_blk_height; i++) |
900 | 547k | { |
901 | 4.91M | for(j = 0; j < u4_blk_width; j++) |
902 | 4.36M | { |
903 | 4.36M | *pu1_out++ = (( (*ref_p0++ ) |
904 | 4.36M | + (*ref_p1++ ) |
905 | 4.36M | + (*ref_p2++ ) |
906 | 4.36M | + (*ref_p3++ ) + 2 ) >> 2); |
907 | 4.36M | } |
908 | 547k | ref_p0 += u4_ref_wid - u4_blk_width; |
909 | 547k | ref_p1 += u4_ref_wid - u4_blk_width; |
910 | 547k | ref_p2 += u4_ref_wid - u4_blk_width; |
911 | 547k | ref_p3 += u4_ref_wid - u4_blk_width; |
912 | | |
913 | 547k | pu1_out += u4_out_wid - u4_blk_width; |
914 | 547k | } |
915 | 135k | } |
916 | 2.65M | return; |
917 | 2.65M | } |
918 | | |
919 | | /*****************************************************************************/ |
920 | | /* */ |
921 | | /* Function Name : impeg2d_mc_halfx_fully() */ |
922 | | /* */ |
923 | | /* Description : Gets the buffer from (0.5,0) to (8.5,8) */ |
924 | | /* and the above block of size 8 x 8 will be placed as a */ |
925 | | /* block from the current position of out_buf */ |
926 | | /* */ |
927 | | /* Inputs : ref - Reference frame from which the block will be */ |
928 | | /* block will be extracted. */ |
929 | | /* ref_wid - WIdth of reference frame */ |
930 | | /* out_wid - WIdth of the output frame */ |
931 | | /* blk_width - width of the block */ |
932 | | /* blk_width - height of the block */ |
933 | | /* */ |
934 | | /* Globals : None */ |
935 | | /* */ |
936 | | /* Processing : Point to the (0,0) and (1,0) position in the ref frame */ |
937 | | /* Interpolate these two values to get the value at(0.5,0) */ |
938 | | /* Repeat this to get an 8 x 8 block using 9 x 8 block from */ |
939 | | /* reference frame */ |
940 | | /* */ |
941 | | /* Outputs : out - Output containing the extracted block */ |
942 | | /* */ |
943 | | /* Returns : None */ |
944 | | /* */ |
945 | | /* Issues : None */ |
946 | | /* */ |
947 | | /* Revision History: */ |
948 | | /* */ |
949 | | /* DD MM YYYY Author(s) Changes */ |
950 | | /* 05 09 2005 Harish M First Version */ |
951 | | /* */ |
952 | | /*****************************************************************************/ |
953 | | |
954 | | void impeg2d_mc_halfx_fully(void *pv_dec, |
955 | | UWORD8 *pu1_ref, |
956 | | UWORD32 u4_ref_wid, |
957 | | UWORD8 *pu1_out, |
958 | | UWORD32 u4_out_wid, |
959 | | UWORD32 u4_blk_width, |
960 | | UWORD32 u4_blk_height) |
961 | 2.70M | { |
962 | 2.70M | UWORD8 *pu1_out_ptr,*pu1_ref_ptr; |
963 | 2.70M | dec_state_t *ps_dec = (dec_state_t *)pv_dec; |
964 | | |
965 | 2.70M | pu1_out_ptr = pu1_out; |
966 | 2.70M | pu1_ref_ptr = pu1_ref; |
967 | | |
968 | 2.70M | if((u4_blk_width == MB_SIZE) && (u4_blk_height == MB_SIZE)) |
969 | 891k | { |
970 | | |
971 | | /*luma 16 x 16*/ |
972 | | |
973 | | /*block 0*/ |
974 | 891k | ps_dec->pf_halfx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
975 | | |
976 | | /*block1*/ |
977 | 891k | pu1_out_ptr = (pu1_out + BLK_SIZE); |
978 | 891k | pu1_ref_ptr = (pu1_ref + BLK_SIZE); |
979 | 891k | ps_dec->pf_halfx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
980 | | |
981 | | /*block 2*/ |
982 | 891k | pu1_out_ptr = pu1_out + BLK_SIZE * u4_out_wid; |
983 | 891k | pu1_ref_ptr = pu1_ref + BLK_SIZE * u4_ref_wid; |
984 | 891k | ps_dec->pf_halfx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
985 | | |
986 | | /*block 3*/ |
987 | 891k | pu1_out_ptr = pu1_out + BLK_SIZE * u4_out_wid + BLK_SIZE; |
988 | 891k | pu1_ref_ptr = pu1_ref + BLK_SIZE * u4_ref_wid + BLK_SIZE; |
989 | 891k | ps_dec->pf_halfx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
990 | | |
991 | | |
992 | | |
993 | | |
994 | 891k | } |
995 | 1.81M | else if ((u4_blk_width == BLK_SIZE) && (u4_blk_height == BLK_SIZE)) |
996 | 1.59M | { |
997 | | /*chroma 8 x 8*/ |
998 | 1.59M | ps_dec->pf_halfx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
999 | 1.59M | } |
1000 | 220k | else if ((u4_blk_width == MB_SIZE) && (u4_blk_height == BLK_SIZE)) |
1001 | 76.7k | { |
1002 | | /*block 0*/ |
1003 | 76.7k | ps_dec->pf_halfx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1004 | | |
1005 | | /*block 1*/ |
1006 | 76.7k | pu1_out_ptr = (pu1_out + BLK_SIZE); |
1007 | 76.7k | pu1_ref_ptr = (pu1_ref + BLK_SIZE); |
1008 | 76.7k | ps_dec->pf_halfx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1009 | | |
1010 | 76.7k | } |
1011 | | |
1012 | 143k | else |
1013 | 143k | { |
1014 | 143k | UWORD8 *ref_p0,*ref_p1; |
1015 | 143k | UWORD32 i,j; |
1016 | | |
1017 | | /* P0-P3 are the pixels in the reference frame and Q is the value being */ |
1018 | | /* estimated */ |
1019 | | /* |
1020 | | P0 Q P1 |
1021 | | */ |
1022 | | |
1023 | 143k | ref_p0 = pu1_ref; |
1024 | 143k | ref_p1 = pu1_ref + 1; |
1025 | | |
1026 | 749k | for(i = 0; i < u4_blk_height; i++) |
1027 | 606k | { |
1028 | 5.44M | for(j = 0; j < u4_blk_width; j++) |
1029 | 4.83M | { |
1030 | 4.83M | *pu1_out++ = ((( *ref_p0++ ) |
1031 | 4.83M | + (*ref_p1++) + 1 ) >> 1); |
1032 | 4.83M | } |
1033 | 606k | ref_p0 += u4_ref_wid - u4_blk_width; |
1034 | 606k | ref_p1 += u4_ref_wid - u4_blk_width; |
1035 | | |
1036 | 606k | pu1_out += u4_out_wid - u4_blk_width; |
1037 | 606k | } |
1038 | 143k | } |
1039 | 2.70M | return; |
1040 | 2.70M | } |
1041 | | |
1042 | | |
1043 | | /*****************************************************************************/ |
1044 | | /* */ |
1045 | | /* Function Name : impeg2d_mc_fullx_halfy() */ |
1046 | | /* */ |
1047 | | /* Description : Gets the buffer from (0,0.5) to (8,8.5) */ |
1048 | | /* and the above block of size 8 x 8 will be placed as a */ |
1049 | | /* block from the current position of out_buf */ |
1050 | | /* */ |
1051 | | /* Inputs : ref - Reference frame from which the block will be */ |
1052 | | /* block will be extracted. */ |
1053 | | /* ref_wid - WIdth of reference frame */ |
1054 | | /* out_wid - WIdth of the output frame */ |
1055 | | /* blk_width - width of the block */ |
1056 | | /* blk_width - height of the block */ |
1057 | | /* */ |
1058 | | /* Globals : None */ |
1059 | | /* */ |
1060 | | /* Processing : Point to the (0,0) and (0,1) position in the ref frame */ |
1061 | | /* Interpolate these two values to get the value at(0,0.5) */ |
1062 | | /* Repeat this to get an 8 x 8 block using 8 x 9 block from */ |
1063 | | /* reference frame */ |
1064 | | /* */ |
1065 | | /* Outputs : out - Output containing the extracted block */ |
1066 | | /* */ |
1067 | | /* Returns : None */ |
1068 | | /* */ |
1069 | | /* Issues : None */ |
1070 | | /* */ |
1071 | | /* Revision History: */ |
1072 | | /* */ |
1073 | | /* DD MM YYYY Author(s) Changes */ |
1074 | | /* 05 09 2005 Harish M First Version */ |
1075 | | /* */ |
1076 | | /*****************************************************************************/ |
1077 | | void impeg2d_mc_fullx_halfy(void *pv_dec, |
1078 | | UWORD8 *pu1_ref, |
1079 | | UWORD32 u4_ref_wid, |
1080 | | UWORD8 *pu1_out, |
1081 | | UWORD32 u4_out_wid, |
1082 | | UWORD32 u4_blk_width, |
1083 | | UWORD32 u4_blk_height) |
1084 | 3.05M | { |
1085 | | |
1086 | 3.05M | UWORD8 *pu1_out_ptr,*pu1_ref_ptr; |
1087 | 3.05M | dec_state_t *ps_dec = (dec_state_t *)pv_dec; |
1088 | 3.05M | pu1_out_ptr = pu1_out; |
1089 | 3.05M | pu1_ref_ptr = pu1_ref; |
1090 | | |
1091 | 3.05M | if((u4_blk_width == MB_SIZE) && (u4_blk_height == MB_SIZE)) |
1092 | 686k | { |
1093 | | |
1094 | | /*luma 16 x 16*/ |
1095 | | |
1096 | | /*block 0*/ |
1097 | 686k | ps_dec->pf_fullx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1098 | | |
1099 | | /*block1*/ |
1100 | 686k | pu1_out_ptr = (pu1_out + BLK_SIZE); |
1101 | 686k | pu1_ref_ptr = (pu1_ref + BLK_SIZE); |
1102 | 686k | ps_dec->pf_fullx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1103 | | |
1104 | | /*block 2*/ |
1105 | 686k | pu1_out_ptr = pu1_out + BLK_SIZE * u4_out_wid; |
1106 | 686k | pu1_ref_ptr = pu1_ref + BLK_SIZE * u4_ref_wid; |
1107 | 686k | ps_dec->pf_fullx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1108 | | |
1109 | | /*block 3*/ |
1110 | 686k | pu1_out_ptr = pu1_out + BLK_SIZE * u4_out_wid + BLK_SIZE; |
1111 | 686k | pu1_ref_ptr = pu1_ref + BLK_SIZE * u4_ref_wid + BLK_SIZE; |
1112 | 686k | ps_dec->pf_fullx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1113 | | |
1114 | | |
1115 | | |
1116 | | |
1117 | 686k | } |
1118 | 2.37M | else if ((u4_blk_width == BLK_SIZE) && (u4_blk_height == BLK_SIZE)) |
1119 | 2.16M | { |
1120 | | /*chroma 8 x 8*/ |
1121 | 2.16M | ps_dec->pf_fullx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1122 | 2.16M | } |
1123 | 208k | else if ((u4_blk_width == MB_SIZE) && (u4_blk_height == BLK_SIZE)) |
1124 | 74.4k | { |
1125 | | /*block 0*/ |
1126 | 74.4k | ps_dec->pf_fullx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1127 | | |
1128 | | /*block 1*/ |
1129 | 74.4k | pu1_out_ptr = (pu1_out + BLK_SIZE); |
1130 | 74.4k | pu1_ref_ptr = (pu1_ref + BLK_SIZE); |
1131 | 74.4k | ps_dec->pf_fullx_halfy_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1132 | | |
1133 | 74.4k | } |
1134 | | |
1135 | 141k | else if ((u4_blk_width == BLK_SIZE) && (u4_blk_height == (BLK_SIZE / 2))) |
1136 | 141k | { |
1137 | 141k | UWORD8 *ref_p0,*ref_p1; |
1138 | 141k | UWORD32 i,j; |
1139 | | /* P0-P3 are the pixels in the reference frame and Q is the value being */ |
1140 | | /* estimated */ |
1141 | | /* |
1142 | | P0 |
1143 | | x |
1144 | | P1 |
1145 | | */ |
1146 | 141k | ref_p0 = pu1_ref; |
1147 | 141k | ref_p1 = pu1_ref + u4_ref_wid; |
1148 | | |
1149 | 704k | for(i = 0; i < u4_blk_height; i++) |
1150 | 562k | { |
1151 | 5.05M | for(j = 0; j < u4_blk_width; j++) |
1152 | 4.49M | { |
1153 | 4.49M | *pu1_out++ = ((( *ref_p0++) |
1154 | 4.49M | + (*ref_p1++) + 1 ) >> 1); |
1155 | 4.49M | } |
1156 | 562k | ref_p0 += u4_ref_wid - u4_blk_width; |
1157 | 562k | ref_p1 += u4_ref_wid - u4_blk_width; |
1158 | | |
1159 | 562k | pu1_out += u4_out_wid - u4_blk_width; |
1160 | 562k | } |
1161 | 141k | } |
1162 | 3.05M | return; |
1163 | 3.05M | } |
1164 | | |
1165 | | /*****************************************************************************/ |
1166 | | /* */ |
1167 | | /* Function Name : impeg2d_mc_fullx_fully() */ |
1168 | | /* */ |
1169 | | /* Description : Gets the buffer from (x,y) to (x+8,y+8) */ |
1170 | | /* and the above block of size 8 x 8 will be placed as a */ |
1171 | | /* block from the current position of out_buf */ |
1172 | | /* */ |
1173 | | /* Inputs : ref - Reference frame from which the block will be */ |
1174 | | /* block will be extracted. */ |
1175 | | /* ref_wid - WIdth of reference frame */ |
1176 | | /* out_wid - WIdth of the output frame */ |
1177 | | /* blk_width - width of the block */ |
1178 | | /* blk_width - height of the block */ |
1179 | | /* */ |
1180 | | /* Globals : None */ |
1181 | | /* */ |
1182 | | /* Processing : Point to the (0,0) position in the ref frame */ |
1183 | | /* Get an 8 x 8 block from reference frame */ |
1184 | | /* */ |
1185 | | /* Outputs : out - Output containing the extracted block */ |
1186 | | /* */ |
1187 | | /* Returns : None */ |
1188 | | /* */ |
1189 | | /* Issues : None */ |
1190 | | /* */ |
1191 | | /* Revision History: */ |
1192 | | /* */ |
1193 | | /* DD MM YYYY Author(s) Changes */ |
1194 | | /* 05 09 2005 Harish M First Version */ |
1195 | | /* */ |
1196 | | /*****************************************************************************/ |
1197 | | |
1198 | | void impeg2d_mc_fullx_fully(void *pv_dec, |
1199 | | UWORD8 *pu1_ref, |
1200 | | UWORD32 u4_ref_wid, |
1201 | | UWORD8 *pu1_out, |
1202 | | UWORD32 u4_out_wid, |
1203 | | UWORD32 u4_blk_width, |
1204 | | UWORD32 u4_blk_height) |
1205 | 6.39M | { |
1206 | | |
1207 | 6.39M | UWORD8 *pu1_out_ptr,*pu1_ref_ptr; |
1208 | 6.39M | dec_state_t *ps_dec = (dec_state_t *)pv_dec; |
1209 | | |
1210 | 6.39M | pu1_out_ptr = pu1_out; |
1211 | 6.39M | pu1_ref_ptr = pu1_ref; |
1212 | | |
1213 | 6.39M | if((u4_blk_width == MB_SIZE) && (u4_blk_height == MB_SIZE)) |
1214 | 2.58M | { |
1215 | | |
1216 | | /*luma 16 x 16*/ |
1217 | | |
1218 | | /*block 0*/ |
1219 | 2.58M | ps_dec->pf_fullx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1220 | | |
1221 | | /*block1*/ |
1222 | 2.58M | pu1_out_ptr = (pu1_out + BLK_SIZE); |
1223 | 2.58M | pu1_ref_ptr = (pu1_ref + BLK_SIZE); |
1224 | 2.58M | ps_dec->pf_fullx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1225 | | |
1226 | | /*block 2*/ |
1227 | 2.58M | pu1_out_ptr = pu1_out + BLK_SIZE * u4_out_wid; |
1228 | 2.58M | pu1_ref_ptr = pu1_ref + BLK_SIZE * u4_ref_wid; |
1229 | 2.58M | ps_dec->pf_fullx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1230 | | |
1231 | | /*block 3*/ |
1232 | 2.58M | pu1_out_ptr = pu1_out + BLK_SIZE * u4_out_wid + BLK_SIZE; |
1233 | 2.58M | pu1_ref_ptr = pu1_ref + BLK_SIZE * u4_ref_wid + BLK_SIZE; |
1234 | 2.58M | ps_dec->pf_fullx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1235 | | |
1236 | | |
1237 | | |
1238 | | |
1239 | 2.58M | } |
1240 | 3.80M | else if ((u4_blk_width == BLK_SIZE) && (u4_blk_height == BLK_SIZE)) |
1241 | 3.50M | { |
1242 | | /*chroma 8 x 8*/ |
1243 | 3.50M | ps_dec->pf_fullx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1244 | 3.50M | } |
1245 | 305k | else if ((u4_blk_width == MB_SIZE) && (u4_blk_height == BLK_SIZE)) |
1246 | 115k | { |
1247 | | /*block 0*/ |
1248 | 115k | ps_dec->pf_fullx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1249 | | |
1250 | | /*block 1*/ |
1251 | 115k | pu1_out_ptr = (pu1_out + BLK_SIZE); |
1252 | 115k | pu1_ref_ptr = (pu1_ref + BLK_SIZE); |
1253 | 115k | ps_dec->pf_fullx_fully_8x8(pu1_out_ptr,pu1_ref_ptr,u4_ref_wid,u4_out_wid); |
1254 | | |
1255 | 115k | } |
1256 | 189k | else |
1257 | 189k | { |
1258 | 189k | UWORD32 i; |
1259 | | |
1260 | 1.03M | for(i = 0; i < u4_blk_height; i++) |
1261 | 847k | { |
1262 | 847k | memmove(pu1_out, pu1_ref, u4_blk_width); |
1263 | 847k | pu1_ref += u4_ref_wid; |
1264 | 847k | pu1_out += u4_out_wid; |
1265 | 847k | } |
1266 | 189k | } |
1267 | 6.39M | return; |
1268 | 6.39M | } |
1269 | | |
1270 | | /******************************************************************************* |
1271 | | * Function Name : impeg2d_set_mc_params |
1272 | | * |
1273 | | * Description : Sets the parameters for Motion Compensation |
1274 | | * |
1275 | | * Arguments : |
1276 | | * luma : Parameters for luma blocks |
1277 | | * chroma : Parameters for chroma blocks |
1278 | | * type : Motion compensation type |
1279 | | * mv_num : Number of motion vectors |
1280 | | * mv : Motion Vectors |
1281 | | * mb_x : X co-ordinate of MB |
1282 | | * mb_y : Y co-ordinate of MB |
1283 | | * frm_wd : Width of the frame |
1284 | | * |
1285 | | * Values Returned : None |
1286 | | *******************************************************************************/ |
1287 | | void impeg2d_set_mc_params(comp_mc_params_t *ps_luma, |
1288 | | comp_mc_params_t *ps_chroma, |
1289 | | e_mb_type_t e_type, |
1290 | | UWORD16 u2_mv_num, |
1291 | | WORD16 ai2_mv[], |
1292 | | UWORD16 u2_mb_x, |
1293 | | UWORD16 u2_mb_y, |
1294 | | UWORD16 u2_frm_wd, |
1295 | | UWORD16 u2_frm_ht, |
1296 | | UWORD16 u2_picture_width) |
1297 | 19.3M | { |
1298 | 19.3M | WORD16 i2_mvy_round; |
1299 | 19.3M | WORD16 i2_mvx_round; |
1300 | 19.3M | const mc_type_consts_t *ps_mc_params; |
1301 | 19.3M | WORD16 i2_mvx_fullp_round; |
1302 | 19.3M | WORD16 i2_mvy_fullp_round; |
1303 | 19.3M | UWORD32 u4_frm_chroma_wd; |
1304 | 19.3M | WORD16 i2_pix_x, i2_pix_y; |
1305 | | |
1306 | 19.3M | ps_mc_params = &gas_impeg2d_mc_params_luma[e_type][u2_mv_num]; |
1307 | | /****************************************************************************/ |
1308 | | /* get luma mc params */ |
1309 | | /****************************************************************************/ |
1310 | 19.3M | i2_pix_x = MB_SIZE * u2_mb_x + (ai2_mv[MV_X]>>1); |
1311 | 19.3M | i2_pix_y = (MB_SIZE * u2_mb_y + |
1312 | 19.3M | (ai2_mv[MV_Y]>>1) * ps_mc_params->mvy_cf + u2_mv_num * ps_mc_params->mv_num_cf) * ps_mc_params->frm_wd_cf; |
1313 | | |
1314 | | // clip pix_x and pix_y so as it falls inside the frame boundary |
1315 | 19.3M | CLIP(i2_pix_x, (u2_frm_wd-16), 0); |
1316 | 19.3M | CLIP(i2_pix_y, (u2_frm_ht-16), 0); |
1317 | | |
1318 | 19.3M | ps_luma->u4_src_offset = i2_pix_x + i2_pix_y * u2_frm_wd; |
1319 | | |
1320 | | |
1321 | | /* keep offset in full pel */ |
1322 | 19.3M | ps_luma->u4_rows = ps_mc_params->rows; |
1323 | 19.3M | ps_luma->u4_cols = MB_SIZE; |
1324 | 19.3M | ps_luma->u4_dst_wd_res_buf = ps_mc_params->dst_wd; |
1325 | 19.3M | ps_luma->u4_src_wd = u2_frm_wd * ps_mc_params->src_wd_cf; |
1326 | 19.3M | ps_luma->u4_dst_offset_res_buf = ps_mc_params->dst_offset_scale * MB_SIZE; |
1327 | 19.3M | ps_luma->u4_dst_offset_cur_frm = ps_mc_params->dst_offset_scale * u2_picture_width; |
1328 | 19.3M | ps_luma->u4_mode = ((ai2_mv[MV_X] & 1) << 1) | (ai2_mv[MV_Y] & 1); |
1329 | | |
1330 | | /****************************************************************************/ |
1331 | | /* get chroma mc params */ |
1332 | | /****************************************************************************/ |
1333 | 19.3M | ps_mc_params = &gas_impeg2d_mc_params_chroma[e_type][u2_mv_num]; |
1334 | 19.3M | i2_mvx_round = ((ai2_mv[MV_X] + IS_NEG(ai2_mv[MV_X]))>>1); |
1335 | 19.3M | i2_mvy_round = ((ai2_mv[MV_Y] + IS_NEG(ai2_mv[MV_Y]))>>1); |
1336 | | |
1337 | 19.3M | i2_mvx_fullp_round = (i2_mvx_round>>1); |
1338 | 19.3M | i2_mvy_fullp_round = (i2_mvy_round>>1)*ps_mc_params->mvy_cf; |
1339 | | |
1340 | 19.3M | u4_frm_chroma_wd = (u2_frm_wd>>1); |
1341 | | |
1342 | 19.3M | i2_pix_x = (MB_SIZE/2) * u2_mb_x + i2_mvx_fullp_round; |
1343 | 19.3M | i2_pix_y = ((MB_SIZE/2) * u2_mb_y + i2_mvy_fullp_round + u2_mv_num * |
1344 | 19.3M | ps_mc_params->mv_num_cf)*ps_mc_params->frm_wd_cf; |
1345 | | |
1346 | 19.3M | CLIP(i2_pix_x, ((u2_frm_wd / 2)-8), 0); |
1347 | 19.3M | CLIP(i2_pix_y, ((u2_frm_ht / 2)-8), 0); |
1348 | 19.3M | ps_chroma->u4_src_offset = i2_pix_x + i2_pix_y * u4_frm_chroma_wd; |
1349 | | |
1350 | | |
1351 | | /* keep offset in full pel */ |
1352 | 19.3M | ps_chroma->u4_rows = ps_mc_params->rows; |
1353 | 19.3M | ps_chroma->u4_cols = (MB_SIZE >> 1); |
1354 | 19.3M | ps_chroma->u4_dst_wd_res_buf = ps_mc_params->dst_wd; |
1355 | 19.3M | ps_chroma->u4_src_wd = (u2_frm_wd>>1) * ps_mc_params->src_wd_cf; |
1356 | 19.3M | ps_chroma->u4_dst_offset_res_buf = ps_mc_params->dst_offset_scale * MB_CHROMA_SIZE; |
1357 | 19.3M | ps_chroma->u4_dst_offset_cur_frm = ps_mc_params->dst_offset_scale * (u2_picture_width >> 1); |
1358 | 19.3M | ps_chroma->u4_mode = ((i2_mvx_round & 1) << 1) | (i2_mvy_round & 1); |
1359 | | |
1360 | | |
1361 | | |
1362 | 19.3M | ps_luma->u4_dst_wd_cur_frm = u2_picture_width; |
1363 | 19.3M | ps_chroma->u4_dst_wd_cur_frm = u2_picture_width >> 1; |
1364 | | |
1365 | 19.3M | if(ps_luma->u4_dst_wd_res_buf == MB_SIZE * 2) |
1366 | 301k | { |
1367 | 301k | ps_luma->u4_dst_wd_cur_frm = u2_frm_wd << 1; |
1368 | 301k | ps_chroma->u4_dst_wd_cur_frm = u2_frm_wd; |
1369 | 301k | } |
1370 | 19.3M | } |
1371 | | |
1372 | | |