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