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