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 #include <stdio.h>
21 #include <string.h>
22
23 #include "iv_datatypedef.h"
24 #include "iv.h"
25
26 #include "impeg2_buf_mgr.h"
27 #include "impeg2_disp_mgr.h"
28 #include "impeg2_defs.h"
29 #include "impeg2_platform_macros.h"
30 #include "impeg2_inter_pred.h"
31 #include "impeg2_idct.h"
32 #include "impeg2_globals.h"
33 #include "impeg2_mem_func.h"
34 #include "impeg2_format_conv.h"
35 #include "impeg2_macros.h"
36
37 #include "ivd.h"
38 #include "impeg2d.h"
39 #include "impeg2d_bitstream.h"
40 #include "impeg2d_structs.h"
41 #include "impeg2d_vld_tables.h"
42 #include "impeg2d_vld.h"
43 #include "impeg2d_pic_proc.h"
44 #include "impeg2d_debug.h"
45 #include "impeg2d_mc.h"
46
47 #define BLK_SIZE 8
48 #define LUMA_BLK_SIZE (2 * (BLK_SIZE))
49 #define CHROMA_BLK_SIZE (BLK_SIZE)
50
51
52 /*******************************************************************************
53 *
54 * Function Name : impeg2d_dec_p_mb_params
55 *
56 * Description : Decodes the parameters for P
57 *
58 * Arguments :
59 * dec : Decoder context
60 *
61 * Values Returned : None
62 *******************************************************************************/
impeg2d_dec_p_mb_params(dec_state_t * ps_dec)63 WORD32 impeg2d_dec_p_mb_params(dec_state_t *ps_dec)
64 {
65 stream_t *ps_stream = &ps_dec->s_bit_stream;
66 UWORD16 u2_mb_addr_incr;
67 UWORD16 u2_total_len;
68 UWORD16 u2_len;
69 UWORD16 u2_mb_type;
70 UWORD32 u4_next_word;
71 const dec_mb_params_t *ps_dec_mb_params;
72 if(impeg2d_bit_stream_nxt(ps_stream,1) == 1)
73 {
74 impeg2d_bit_stream_flush(ps_stream,1);
75
76 }
77 else
78 {
79 u2_mb_addr_incr = impeg2d_get_mb_addr_incr(ps_stream);
80
81 if(!u2_mb_addr_incr)
82 {
83 return IV_FAIL;
84 }
85
86 if(0 == ps_dec->u2_first_mb)
87 {
88 /****************************************************************/
89 /* If the 2nd member of a field picture pair is a P picture and */
90 /* the first one was an I picture, there cannot be any skipped */
91 /* MBs in the second field picture */
92 /****************************************************************/
93 /*
94 if((dec->picture_structure != FRAME_PICTURE) &&
95 (dec->f->FieldFuncCall != 0) &&
96 (dec->las->u1_last_coded_vop_type == I))
97 {
98 core0_err_handler((void *)(VOLParams),
99 ITTMPEG2_ERR_INVALID_MB_SKIP);
100 }
101 */
102 /****************************************************************/
103 /* In MPEG-2, the last MB of the row cannot be skipped and the */
104 /* MBAddrIncr cannot be such that it will take the current MB */
105 /* beyond the current row */
106 /* In MPEG-1, the slice could start and end anywhere and is not */
107 /* restricted to a row like in MPEG-2. Hence this check should */
108 /* not be done for MPEG-1 streams. */
109 /****************************************************************/
110 if(ps_dec->u2_is_mpeg2 && ((ps_dec->u2_mb_x + u2_mb_addr_incr) > ps_dec->u2_num_horiz_mb) )
111 {
112 u2_mb_addr_incr = ps_dec->u2_num_horiz_mb - ps_dec->u2_mb_x;
113 }
114
115 if ((u2_mb_addr_incr - 1) > ps_dec->u2_num_mbs_left)
116 {
117 /* If the number of skip MBs are more than the number of MBs
118 * left, indicate error.
119 */
120 return IV_FAIL;
121 }
122
123 impeg2d_dec_skip_mbs(ps_dec, (UWORD16)(u2_mb_addr_incr - 1));
124 }
125 else
126 {
127
128 /****************************************************************/
129 /* Section 6.3.17 */
130 /* The first MB of a slice cannot be skipped */
131 /* But the mb_addr_incr can be > 1, because at the beginning of */
132 /* a slice, it indicates the offset from the last MB in the */
133 /* previous row. Hence for the first slice in a row, the */
134 /* mb_addr_incr needs to be 1. */
135 /****************************************************************/
136 /* MB_x is set to zero whenever MB_y changes. */
137 ps_dec->u2_mb_x = u2_mb_addr_incr - 1;
138 /* For error resilience */
139 ps_dec->u2_mb_x = MIN(ps_dec->u2_mb_x, (ps_dec->u2_num_horiz_mb - 1));
140 ps_dec->u2_num_mbs_left = ((ps_dec->u2_num_vert_mb - ps_dec->u2_mb_y)
141 * ps_dec->u2_num_horiz_mb) - ps_dec->u2_mb_x;
142
143 /****************************************************************/
144 /* mb_addr_incr is forced to 1 because in this decoder it is used */
145 /* more as an indicator of the number of MBs skipped than the */
146 /* as defined by the standard (Section 6.3.17) */
147 /****************************************************************/
148 u2_mb_addr_incr = 1;
149 ps_dec->u2_first_mb = 0;
150
151 }
152
153 }
154 u4_next_word = (UWORD16)impeg2d_bit_stream_nxt(ps_stream,16);
155 /*-----------------------------------------------------------------------*/
156 /* MB type */
157 /*-----------------------------------------------------------------------*/
158 {
159 u2_mb_type = ps_dec->pu2_mb_type[BITS((UWORD16)u4_next_word,15,10)];
160 u2_len = BITS(u2_mb_type,15,8);
161 u2_total_len = u2_len;
162 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << u2_len);
163 }
164 /*-----------------------------------------------------------------------*/
165 /* motion type */
166 /*-----------------------------------------------------------------------*/
167 {
168 if((u2_mb_type & MB_FORW_OR_BACK) && ps_dec->u2_read_motion_type)
169 {
170 WORD32 i4_motion_type;
171 ps_dec->u2_motion_type = BITS((UWORD16)u4_next_word,15,14);
172 u2_total_len += MB_MOTION_TYPE_LEN;
173 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << MB_MOTION_TYPE_LEN);
174 i4_motion_type = ps_dec->u2_motion_type;
175
176 if((i4_motion_type == 0) ||
177 (i4_motion_type == 4) ||
178 (i4_motion_type > 7))
179 {
180 //TODO : VANG Check for validity
181 i4_motion_type = 1;
182 }
183
184 }
185 }
186 /*-----------------------------------------------------------------------*/
187 /* dct type */
188 /*-----------------------------------------------------------------------*/
189 {
190 if((u2_mb_type & MB_CODED) && ps_dec->u2_read_dct_type)
191 {
192 ps_dec->u2_field_dct = BIT((UWORD16)u4_next_word,15);
193 u2_total_len += MB_DCT_TYPE_LEN;
194 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << MB_DCT_TYPE_LEN);
195 }
196 }
197 /*-----------------------------------------------------------------------*/
198 /* Quant scale code */
199 /*-----------------------------------------------------------------------*/
200 if(u2_mb_type & MB_QUANT)
201 {
202 UWORD16 u2_quant_scale_code;
203 u2_quant_scale_code = BITS((UWORD16)u4_next_word,15,11);
204
205 ps_dec->u1_quant_scale = (ps_dec->u2_q_scale_type) ?
206 gau1_impeg2_non_linear_quant_scale[u2_quant_scale_code] : (u2_quant_scale_code << 1);
207 u2_total_len += MB_QUANT_SCALE_CODE_LEN;
208 }
209 impeg2d_bit_stream_flush(ps_stream,u2_total_len);
210 /*-----------------------------------------------------------------------*/
211 /* Set the function pointers */
212 /*-----------------------------------------------------------------------*/
213 ps_dec->u2_coded_mb = (UWORD16)(u2_mb_type & MB_CODED);
214
215 if(u2_mb_type & MB_FORW_OR_BACK)
216 {
217
218 UWORD16 refPic = !(u2_mb_type & MB_MV_FORW);
219 UWORD16 index = (ps_dec->u2_motion_type);
220 ps_dec->u2_prev_intra_mb = 0;
221 ps_dec->e_mb_pred = (e_pred_direction_t)refPic;
222 ps_dec_mb_params = &ps_dec->ps_func_forw_or_back[index];
223 ps_dec->s_mb_type = ps_dec_mb_params->s_mb_type;
224 if(NULL == ps_dec_mb_params->pf_func_mb_params)
225 return -1;
226 ps_dec_mb_params->pf_func_mb_params(ps_dec);
227
228 }
229 else if(u2_mb_type & MB_TYPE_INTRA)
230 {
231 ps_dec->u2_prev_intra_mb = 1;
232 impeg2d_dec_intra_mb(ps_dec);
233
234 }
235 else
236 {
237 ps_dec->u2_prev_intra_mb = 0;
238 ps_dec->e_mb_pred = FORW;
239 ps_dec->u2_motion_type = 0;
240 impeg2d_dec_0mv_coded_mb(ps_dec);
241 }
242
243 /*-----------------------------------------------------------------------*/
244 /* decode cbp */
245 /*-----------------------------------------------------------------------*/
246 if((u2_mb_type & MB_TYPE_INTRA))
247 {
248 ps_dec->u2_cbp = 0x3f;
249 ps_dec->u2_prev_intra_mb = 1;
250 }
251 else
252 {
253 ps_dec->u2_prev_intra_mb = 0;
254 ps_dec->u2_def_dc_pred[Y_LUMA] = 128 << ps_dec->u2_intra_dc_precision;
255 ps_dec->u2_def_dc_pred[U_CHROMA] = 128 << ps_dec->u2_intra_dc_precision;
256 ps_dec->u2_def_dc_pred[V_CHROMA] = 128 << ps_dec->u2_intra_dc_precision;
257 if((ps_dec->u2_coded_mb))
258 {
259 UWORD16 cbpValue;
260 cbpValue = gau2_impeg2d_cbp_code[impeg2d_bit_stream_nxt(ps_stream,MB_CBP_LEN)];
261 ps_dec->u2_cbp = cbpValue & 0xFF;
262 impeg2d_bit_stream_flush(ps_stream,(cbpValue >> 8) & 0x0FF);
263 }
264 else
265 {
266 ps_dec->u2_cbp = 0;
267 }
268 }
269 return 0;
270 }
271
272
273 /*******************************************************************************
274 *
275 * Function Name : impeg2d_dec_pnb_mb_params
276 *
277 * Description : Decodes the parameters for P and B pictures
278 *
279 * Arguments :
280 * dec : Decoder context
281 *
282 * Values Returned : None
283 *******************************************************************************/
impeg2d_dec_pnb_mb_params(dec_state_t * ps_dec)284 WORD32 impeg2d_dec_pnb_mb_params(dec_state_t *ps_dec)
285 {
286 stream_t *ps_stream = &ps_dec->s_bit_stream;
287 UWORD16 u2_mb_addr_incr;
288 UWORD16 u2_total_len;
289 UWORD16 u2_len;
290 UWORD16 u2_mb_type;
291 UWORD32 u4_next_word;
292 const dec_mb_params_t *ps_dec_mb_params;
293 if(impeg2d_bit_stream_nxt(ps_stream,1) == 1)
294 {
295 impeg2d_bit_stream_flush(ps_stream,1);
296
297 }
298 else
299 {
300 u2_mb_addr_incr = impeg2d_get_mb_addr_incr(ps_stream);
301
302 if(0 == u2_mb_addr_incr)
303 {
304 return IV_FAIL;
305 }
306
307 if(ps_dec->u2_first_mb)
308 {
309 /****************************************************************/
310 /* Section 6.3.17 */
311 /* The first MB of a slice cannot be skipped */
312 /* But the mb_addr_incr can be > 1, because at the beginning of */
313 /* a slice, it indicates the offset from the last MB in the */
314 /* previous row. Hence for the first slice in a row, the */
315 /* mb_addr_incr needs to be 1. */
316 /****************************************************************/
317 /* MB_x is set to zero whenever MB_y changes. */
318 ps_dec->u2_mb_x = u2_mb_addr_incr - 1;
319 /* For error resilience */
320 ps_dec->u2_mb_x = MIN(ps_dec->u2_mb_x, (ps_dec->u2_num_horiz_mb - 1));
321 ps_dec->u2_num_mbs_left = ((ps_dec->u2_num_vert_mb - ps_dec->u2_mb_y)
322 * ps_dec->u2_num_horiz_mb) - ps_dec->u2_mb_x;
323
324 /****************************************************************/
325 /* mb_addr_incr is forced to 1 because in this decoder it is used */
326 /* more as an indicator of the number of MBs skipped than the */
327 /* as defined by the standard (Section 6.3.17) */
328 /****************************************************************/
329 u2_mb_addr_incr = 1;
330 ps_dec->u2_first_mb = 0;
331 }
332 else
333 {
334 /****************************************************************/
335 /* In MPEG-2, the last MB of the row cannot be skipped and the */
336 /* mb_addr_incr cannot be such that it will take the current MB */
337 /* beyond the current row */
338 /* In MPEG-1, the slice could start and end anywhere and is not */
339 /* restricted to a row like in MPEG-2. Hence this check should */
340 /* not be done for MPEG-1 streams. */
341 /****************************************************************/
342 if(ps_dec->u2_is_mpeg2 &&
343 ((ps_dec->u2_mb_x + u2_mb_addr_incr) > ps_dec->u2_num_horiz_mb))
344 {
345 u2_mb_addr_incr = ps_dec->u2_num_horiz_mb - ps_dec->u2_mb_x;
346 }
347
348 if ((u2_mb_addr_incr - 1) > ps_dec->u2_num_mbs_left)
349 {
350 /* If the number of skip MBs are more than the number of MBs
351 * left, indicate error.
352 */
353 return IV_FAIL;
354 }
355
356 impeg2d_dec_skip_mbs(ps_dec, (UWORD16)(u2_mb_addr_incr - 1));
357 }
358
359 }
360 u4_next_word = (UWORD16)impeg2d_bit_stream_nxt(ps_stream,16);
361 /*-----------------------------------------------------------------------*/
362 /* MB type */
363 /*-----------------------------------------------------------------------*/
364 {
365 u2_mb_type = ps_dec->pu2_mb_type[BITS((UWORD16)u4_next_word,15,10)];
366 u2_len = BITS(u2_mb_type,15,8);
367 u2_total_len = u2_len;
368 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << u2_len);
369 }
370 /*-----------------------------------------------------------------------*/
371 /* motion type */
372 /*-----------------------------------------------------------------------*/
373 {
374 WORD32 i4_motion_type = ps_dec->u2_motion_type;
375
376 if((u2_mb_type & MB_FORW_OR_BACK) && ps_dec->u2_read_motion_type)
377 {
378 ps_dec->u2_motion_type = BITS((UWORD16)u4_next_word,15,14);
379 u2_total_len += MB_MOTION_TYPE_LEN;
380 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << MB_MOTION_TYPE_LEN);
381 i4_motion_type = ps_dec->u2_motion_type;
382
383 }
384
385
386 if ((u2_mb_type & MB_FORW_OR_BACK) &&
387 ((i4_motion_type == 0) ||
388 (i4_motion_type == 3) ||
389 (i4_motion_type == 4) ||
390 (i4_motion_type >= 7)))
391 {
392 //TODO: VANG Check for validity
393 i4_motion_type = 1;
394 }
395
396 }
397 /*-----------------------------------------------------------------------*/
398 /* dct type */
399 /*-----------------------------------------------------------------------*/
400 {
401 if((u2_mb_type & MB_CODED) && ps_dec->u2_read_dct_type)
402 {
403 ps_dec->u2_field_dct = BIT((UWORD16)u4_next_word,15);
404 u2_total_len += MB_DCT_TYPE_LEN;
405 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << MB_DCT_TYPE_LEN);
406 }
407 }
408 /*-----------------------------------------------------------------------*/
409 /* Quant scale code */
410 /*-----------------------------------------------------------------------*/
411 if(u2_mb_type & MB_QUANT)
412 {
413 UWORD16 u2_quant_scale_code;
414 u2_quant_scale_code = BITS((UWORD16)u4_next_word,15,11);
415
416 ps_dec->u1_quant_scale = (ps_dec->u2_q_scale_type) ?
417 gau1_impeg2_non_linear_quant_scale[u2_quant_scale_code] : (u2_quant_scale_code << 1);
418 u2_total_len += MB_QUANT_SCALE_CODE_LEN;
419 }
420 impeg2d_bit_stream_flush(ps_stream,u2_total_len);
421 /*-----------------------------------------------------------------------*/
422 /* Set the function pointers */
423 /*-----------------------------------------------------------------------*/
424 ps_dec->u2_coded_mb = (UWORD16)(u2_mb_type & MB_CODED);
425
426 if(u2_mb_type & MB_BIDRECT)
427 {
428 UWORD16 u2_index = (ps_dec->u2_motion_type);
429
430 ps_dec->u2_prev_intra_mb = 0;
431 ps_dec->e_mb_pred = BIDIRECT;
432 ps_dec_mb_params = &ps_dec->ps_func_bi_direct[u2_index];
433 ps_dec->s_mb_type = ps_dec_mb_params->s_mb_type;
434 if(NULL == ps_dec_mb_params->pf_func_mb_params)
435 return -1;
436 ps_dec_mb_params->pf_func_mb_params(ps_dec);
437 }
438 else if(u2_mb_type & MB_FORW_OR_BACK)
439 {
440
441 UWORD16 u2_refPic = !(u2_mb_type & MB_MV_FORW);
442 UWORD16 u2_index = (ps_dec->u2_motion_type);
443 ps_dec->u2_prev_intra_mb = 0;
444 ps_dec->e_mb_pred = (e_pred_direction_t)u2_refPic;
445 ps_dec_mb_params = &ps_dec->ps_func_forw_or_back[u2_index];
446 ps_dec->s_mb_type = ps_dec_mb_params->s_mb_type;
447 if(NULL == ps_dec_mb_params->pf_func_mb_params)
448 return -1;
449 ps_dec_mb_params->pf_func_mb_params(ps_dec);
450
451 }
452 else if(u2_mb_type & MB_TYPE_INTRA)
453 {
454 ps_dec->u2_prev_intra_mb = 1;
455 impeg2d_dec_intra_mb(ps_dec);
456
457 }
458 else
459 {
460 ps_dec->u2_prev_intra_mb =0;
461 ps_dec->e_mb_pred = FORW;
462 ps_dec->u2_motion_type = 0;
463 impeg2d_dec_0mv_coded_mb(ps_dec);
464 }
465
466 /*-----------------------------------------------------------------------*/
467 /* decode cbp */
468 /*-----------------------------------------------------------------------*/
469 if((u2_mb_type & MB_TYPE_INTRA))
470 {
471 ps_dec->u2_cbp = 0x3f;
472 ps_dec->u2_prev_intra_mb = 1;
473 }
474 else
475 {
476 ps_dec->u2_prev_intra_mb = 0;
477 ps_dec->u2_def_dc_pred[Y_LUMA] = 128 << ps_dec->u2_intra_dc_precision;
478 ps_dec->u2_def_dc_pred[U_CHROMA] = 128 << ps_dec->u2_intra_dc_precision;
479 ps_dec->u2_def_dc_pred[V_CHROMA] = 128 << ps_dec->u2_intra_dc_precision;
480 if((ps_dec->u2_coded_mb))
481 {
482 UWORD16 cbpValue;
483 cbpValue = gau2_impeg2d_cbp_code[impeg2d_bit_stream_nxt(ps_stream,MB_CBP_LEN)];
484 ps_dec->u2_cbp = cbpValue & 0xFF;
485 impeg2d_bit_stream_flush(ps_stream,(cbpValue >> 8) & 0x0FF);
486 }
487 else
488 {
489 ps_dec->u2_cbp = 0;
490 }
491 }
492 return 0;
493 }
494
495 /*******************************************************************************
496 * Function Name : impeg2d_dec_p_b_slice
497 *
498 * Description : Decodes P and B slices
499 *
500 * Arguments :
501 * dec : Decoder state
502 *
503 * Values Returned : None
504 *******************************************************************************/
impeg2d_dec_p_b_slice(dec_state_t * ps_dec)505 IMPEG2D_ERROR_CODES_T impeg2d_dec_p_b_slice(dec_state_t *ps_dec)
506 {
507 WORD16 *pi2_vld_out;
508 UWORD32 i;
509 yuv_buf_t *ps_cur_frm_buf = &ps_dec->s_cur_frm_buf;
510
511 UWORD32 u4_frm_offset = 0;
512 const dec_mb_params_t *ps_dec_mb_params;
513 IMPEG2D_ERROR_CODES_T e_error = (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE;
514
515 pi2_vld_out = ps_dec->ai2_vld_buf;
516 memset(ps_dec->ai2_pred_mv,0,sizeof(ps_dec->ai2_pred_mv));
517
518 ps_dec->u2_prev_intra_mb = 0;
519 ps_dec->u2_first_mb = 1;
520
521 ps_dec->u2_picture_width = ps_dec->u2_frame_width;
522
523 if(ps_dec->u2_picture_structure != FRAME_PICTURE)
524 {
525 ps_dec->u2_picture_width <<= 1;
526 if(ps_dec->u2_picture_structure == BOTTOM_FIELD)
527 {
528 u4_frm_offset = ps_dec->u2_frame_width;
529 }
530 }
531
532 do
533 {
534 UWORD32 u4_x_offset, u4_y_offset;
535 WORD32 ret;
536
537
538 UWORD32 u4_x_dst_offset = 0;
539 UWORD32 u4_y_dst_offset = 0;
540 UWORD8 *pu1_out_p;
541 UWORD8 *pu1_pred;
542 WORD32 u4_pred_strd;
543
544 IMPEG2D_TRACE_MB_START(ps_dec->u2_mb_x, ps_dec->u2_mb_y);
545
546 if(ps_dec->e_pic_type == B_PIC)
547 ret = impeg2d_dec_pnb_mb_params(ps_dec);
548 else
549 ret = impeg2d_dec_p_mb_params(ps_dec);
550
551 if(ret)
552 return IMPEG2D_MB_TEX_DECODE_ERR;
553
554 if(0 >= ps_dec->u2_num_mbs_left)
555 {
556 break;
557 }
558
559 IMPEG2D_TRACE_MB_START(ps_dec->u2_mb_x, ps_dec->u2_mb_y);
560
561 u4_x_dst_offset = u4_frm_offset + (ps_dec->u2_mb_x << 4);
562 u4_y_dst_offset = (ps_dec->u2_mb_y << 4) * ps_dec->u2_picture_width;
563 pu1_out_p = ps_cur_frm_buf->pu1_y + u4_x_dst_offset + u4_y_dst_offset;
564 if(ps_dec->u2_prev_intra_mb == 0)
565 {
566 UWORD32 offset_x, offset_y, stride;
567 UWORD16 index = (ps_dec->u2_motion_type);
568 /*only for non intra mb's*/
569 if(ps_dec->e_mb_pred == BIDIRECT)
570 {
571 ps_dec_mb_params = &ps_dec->ps_func_bi_direct[index];
572 }
573 else
574 {
575 ps_dec_mb_params = &ps_dec->ps_func_forw_or_back[index];
576 }
577
578 stride = ps_dec->u2_picture_width;
579
580 offset_x = u4_frm_offset + (ps_dec->u2_mb_x << 4);
581
582 offset_y = (ps_dec->u2_mb_y << 4);
583
584 ps_dec->s_dest_buf.pu1_y = ps_cur_frm_buf->pu1_y + offset_y * stride + offset_x;
585
586 stride = stride >> 1;
587
588 ps_dec->s_dest_buf.pu1_u = ps_cur_frm_buf->pu1_u + (offset_y >> 1) * stride
589 + (offset_x >> 1);
590
591 ps_dec->s_dest_buf.pu1_v = ps_cur_frm_buf->pu1_v + (offset_y >> 1) * stride
592 + (offset_x >> 1);
593
594 PROFILE_DISABLE_MC_IF0
595 ps_dec_mb_params->pf_mc(ps_dec);
596
597 }
598 for(i = 0; i < NUM_LUMA_BLKS; ++i)
599 {
600 if((ps_dec->u2_cbp & (1 << (BLOCKS_IN_MB - 1 - i))) != 0)
601 {
602 e_error = ps_dec->pf_vld_inv_quant(ps_dec, pi2_vld_out, ps_dec->pu1_inv_scan_matrix,
603 ps_dec->u2_prev_intra_mb, Y_LUMA, 0);
604 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
605 {
606 return e_error;
607 }
608
609 u4_x_offset = gai2_impeg2_blk_x_off[i];
610
611 if(ps_dec->u2_field_dct == 0)
612 u4_y_offset = gai2_impeg2_blk_y_off_frm[i] ;
613 else
614 u4_y_offset = gai2_impeg2_blk_y_off_fld[i] ;
615
616
617
618
619
620 IMPEG2D_IDCT_INP_STATISTICS(pi2_vld_out, ps_dec->u4_non_zero_cols, ps_dec->u4_non_zero_rows);
621
622 PROFILE_DISABLE_IDCT_IF0
623 {
624 WORD32 idx;
625 if(1 == (ps_dec->u4_non_zero_cols | ps_dec->u4_non_zero_rows))
626 idx = 0;
627 else
628 idx = 1;
629
630 if(0 == ps_dec->u2_prev_intra_mb)
631 {
632 pu1_pred = pu1_out_p + u4_y_offset * ps_dec->u2_picture_width + u4_x_offset;
633 u4_pred_strd = ps_dec->u2_picture_width << ps_dec->u2_field_dct;
634 }
635 else
636 {
637 pu1_pred = (UWORD8 *)gau1_impeg2_zerobuf;
638 u4_pred_strd = 8;
639 }
640
641 ps_dec->pf_idct_recon[idx * 2 + ps_dec->i4_last_value_one](pi2_vld_out,
642 ps_dec->ai2_idct_stg1,
643 pu1_pred,
644 pu1_out_p + u4_y_offset * ps_dec->u2_picture_width + u4_x_offset,
645 8,
646 u4_pred_strd,
647 ps_dec->u2_picture_width << ps_dec->u2_field_dct,
648 ~ps_dec->u4_non_zero_cols, ~ps_dec->u4_non_zero_rows);
649 }
650 }
651
652 }
653
654 /* For U and V blocks, divide the x and y offsets by 2. */
655 u4_x_dst_offset >>= 1;
656 u4_y_dst_offset >>= 2;
657
658
659 /* In case of chrominance blocks the DCT will be frame DCT */
660 /* i = 0, U component and i = 1 is V componet */
661 if((ps_dec->u2_cbp & 0x02) != 0)
662 {
663 pu1_out_p = ps_cur_frm_buf->pu1_u + u4_x_dst_offset + u4_y_dst_offset;
664 e_error = ps_dec->pf_vld_inv_quant(ps_dec, pi2_vld_out, ps_dec->pu1_inv_scan_matrix,
665 ps_dec->u2_prev_intra_mb, U_CHROMA, 0);
666 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
667 {
668 return e_error;
669 }
670
671
672 IMPEG2D_IDCT_INP_STATISTICS(pi2_vld_out, ps_dec->u4_non_zero_cols, ps_dec->u4_non_zero_rows);
673
674 PROFILE_DISABLE_IDCT_IF0
675 {
676 WORD32 idx;
677 if(1 == (ps_dec->u4_non_zero_cols | ps_dec->u4_non_zero_rows))
678 idx = 0;
679 else
680 idx = 1;
681
682 if(0 == ps_dec->u2_prev_intra_mb)
683 {
684 pu1_pred = pu1_out_p;
685 u4_pred_strd = ps_dec->u2_picture_width >> 1;
686 }
687 else
688 {
689 pu1_pred = (UWORD8 *)gau1_impeg2_zerobuf;
690 u4_pred_strd = 8;
691 }
692
693 ps_dec->pf_idct_recon[idx * 2 + ps_dec->i4_last_value_one](pi2_vld_out,
694 ps_dec->ai2_idct_stg1,
695 pu1_pred,
696 pu1_out_p,
697 8,
698 u4_pred_strd,
699 ps_dec->u2_picture_width >> 1,
700 ~ps_dec->u4_non_zero_cols, ~ps_dec->u4_non_zero_rows);
701
702 }
703
704 }
705
706
707 if((ps_dec->u2_cbp & 0x01) != 0)
708 {
709 pu1_out_p = ps_cur_frm_buf->pu1_v + u4_x_dst_offset + u4_y_dst_offset;
710 e_error = ps_dec->pf_vld_inv_quant(ps_dec, pi2_vld_out, ps_dec->pu1_inv_scan_matrix,
711 ps_dec->u2_prev_intra_mb, V_CHROMA, 0);
712 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
713 {
714 return e_error;
715 }
716
717
718 IMPEG2D_IDCT_INP_STATISTICS(pi2_vld_out, ps_dec->u4_non_zero_cols, ps_dec->u4_non_zero_rows);
719
720 PROFILE_DISABLE_IDCT_IF0
721 {
722 WORD32 idx;
723 if(1 == (ps_dec->u4_non_zero_cols | ps_dec->u4_non_zero_rows))
724 idx = 0;
725 else
726 idx = 1;
727 if(0 == ps_dec->u2_prev_intra_mb)
728 {
729 pu1_pred = pu1_out_p;
730 u4_pred_strd = ps_dec->u2_picture_width >> 1;
731 }
732 else
733 {
734 pu1_pred = (UWORD8 *)gau1_impeg2_zerobuf;
735 u4_pred_strd = 8;
736 }
737
738 ps_dec->pf_idct_recon[idx * 2 + ps_dec->i4_last_value_one](pi2_vld_out,
739 ps_dec->ai2_idct_stg1,
740 pu1_pred,
741 pu1_out_p,
742 8,
743 u4_pred_strd,
744 ps_dec->u2_picture_width >> 1,
745 ~ps_dec->u4_non_zero_cols, ~ps_dec->u4_non_zero_rows);
746
747 }
748 }
749
750 ps_dec->u2_num_mbs_left--;
751 ps_dec->u2_first_mb = 0;
752 ps_dec->u2_mb_x++;
753
754 if(ps_dec->s_bit_stream.u4_offset > ps_dec->s_bit_stream.u4_max_offset)
755 {
756 return IMPEG2D_BITSTREAM_BUFF_EXCEEDED_ERR;
757 }
758 else if (ps_dec->u2_mb_x == ps_dec->u2_num_horiz_mb)
759 {
760 ps_dec->u2_mb_x = 0;
761 ps_dec->u2_mb_y++;
762
763 }
764 }
765 while(ps_dec->u2_num_mbs_left != 0 && impeg2d_bit_stream_nxt(&ps_dec->s_bit_stream,23) != 0x0);
766 return e_error;
767 }
768