impeg2d_pnb_pic.c revision 4262d8eeee23d169ab0a141f103592f7172d95bc
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*******************************************************************************/ 63WORD32 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*******************************************************************************/ 284WORD32 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(ps_dec->u2_first_mb) 303 { 304 /****************************************************************/ 305 /* Section 6.3.17 */ 306 /* The first MB of a slice cannot be skipped */ 307 /* But the mb_addr_incr can be > 1, because at the beginning of */ 308 /* a slice, it indicates the offset from the last MB in the */ 309 /* previous row. Hence for the first slice in a row, the */ 310 /* mb_addr_incr needs to be 1. */ 311 /****************************************************************/ 312 /* MB_x is set to zero whenever MB_y changes. */ 313 ps_dec->u2_mb_x = u2_mb_addr_incr - 1; 314 /* For error resilience */ 315 ps_dec->u2_mb_x = MIN(ps_dec->u2_mb_x, (ps_dec->u2_num_horiz_mb - 1)); 316 ps_dec->u2_num_mbs_left = ((ps_dec->u2_num_vert_mb - ps_dec->u2_mb_y) 317 * ps_dec->u2_num_horiz_mb) - ps_dec->u2_mb_x; 318 319 /****************************************************************/ 320 /* mb_addr_incr is forced to 1 because in this decoder it is used */ 321 /* more as an indicator of the number of MBs skipped than the */ 322 /* as defined by the standard (Section 6.3.17) */ 323 /****************************************************************/ 324 u2_mb_addr_incr = 1; 325 ps_dec->u2_first_mb = 0; 326 } 327 else 328 { 329 /****************************************************************/ 330 /* In MPEG-2, the last MB of the row cannot be skipped and the */ 331 /* mb_addr_incr cannot be such that it will take the current MB */ 332 /* beyond the current row */ 333 /* In MPEG-1, the slice could start and end anywhere and is not */ 334 /* restricted to a row like in MPEG-2. Hence this check should */ 335 /* not be done for MPEG-1 streams. */ 336 /****************************************************************/ 337 if(ps_dec->u2_is_mpeg2 && 338 ((ps_dec->u2_mb_x + u2_mb_addr_incr) > ps_dec->u2_num_horiz_mb)) 339 { 340 u2_mb_addr_incr = ps_dec->u2_num_horiz_mb - ps_dec->u2_mb_x; 341 } 342 343 if ((u2_mb_addr_incr - 1) > ps_dec->u2_num_mbs_left) 344 { 345 /* If the number of skip MBs are more than the number of MBs 346 * left, indicate error. 347 */ 348 return IV_FAIL; 349 } 350 351 impeg2d_dec_skip_mbs(ps_dec, (UWORD16)(u2_mb_addr_incr - 1)); 352 } 353 354 } 355 u4_next_word = (UWORD16)impeg2d_bit_stream_nxt(ps_stream,16); 356 /*-----------------------------------------------------------------------*/ 357 /* MB type */ 358 /*-----------------------------------------------------------------------*/ 359 { 360 u2_mb_type = ps_dec->pu2_mb_type[BITS((UWORD16)u4_next_word,15,10)]; 361 u2_len = BITS(u2_mb_type,15,8); 362 u2_total_len = u2_len; 363 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << u2_len); 364 } 365 /*-----------------------------------------------------------------------*/ 366 /* motion type */ 367 /*-----------------------------------------------------------------------*/ 368 { 369 WORD32 i4_motion_type = ps_dec->u2_motion_type; 370 371 if((u2_mb_type & MB_FORW_OR_BACK) && ps_dec->u2_read_motion_type) 372 { 373 ps_dec->u2_motion_type = BITS((UWORD16)u4_next_word,15,14); 374 u2_total_len += MB_MOTION_TYPE_LEN; 375 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << MB_MOTION_TYPE_LEN); 376 i4_motion_type = ps_dec->u2_motion_type; 377 378 } 379 380 381 if ((u2_mb_type & MB_FORW_OR_BACK) && 382 ((i4_motion_type == 0) || 383 (i4_motion_type == 3) || 384 (i4_motion_type == 4) || 385 (i4_motion_type >= 7))) 386 { 387 //TODO: VANG Check for validity 388 i4_motion_type = 1; 389 } 390 391 } 392 /*-----------------------------------------------------------------------*/ 393 /* dct type */ 394 /*-----------------------------------------------------------------------*/ 395 { 396 if((u2_mb_type & MB_CODED) && ps_dec->u2_read_dct_type) 397 { 398 ps_dec->u2_field_dct = BIT((UWORD16)u4_next_word,15); 399 u2_total_len += MB_DCT_TYPE_LEN; 400 u4_next_word = (UWORD16)LSW((UWORD16)u4_next_word << MB_DCT_TYPE_LEN); 401 } 402 } 403 /*-----------------------------------------------------------------------*/ 404 /* Quant scale code */ 405 /*-----------------------------------------------------------------------*/ 406 if(u2_mb_type & MB_QUANT) 407 { 408 UWORD16 u2_quant_scale_code; 409 u2_quant_scale_code = BITS((UWORD16)u4_next_word,15,11); 410 411 ps_dec->u1_quant_scale = (ps_dec->u2_q_scale_type) ? 412 gau1_impeg2_non_linear_quant_scale[u2_quant_scale_code] : (u2_quant_scale_code << 1); 413 u2_total_len += MB_QUANT_SCALE_CODE_LEN; 414 } 415 impeg2d_bit_stream_flush(ps_stream,u2_total_len); 416 /*-----------------------------------------------------------------------*/ 417 /* Set the function pointers */ 418 /*-----------------------------------------------------------------------*/ 419 ps_dec->u2_coded_mb = (UWORD16)(u2_mb_type & MB_CODED); 420 421 if(u2_mb_type & MB_BIDRECT) 422 { 423 UWORD16 u2_index = (ps_dec->u2_motion_type); 424 425 ps_dec->u2_prev_intra_mb = 0; 426 ps_dec->e_mb_pred = BIDIRECT; 427 ps_dec_mb_params = &ps_dec->ps_func_bi_direct[u2_index]; 428 ps_dec->s_mb_type = ps_dec_mb_params->s_mb_type; 429 if(NULL == ps_dec_mb_params->pf_func_mb_params) 430 return -1; 431 ps_dec_mb_params->pf_func_mb_params(ps_dec); 432 } 433 else if(u2_mb_type & MB_FORW_OR_BACK) 434 { 435 436 UWORD16 u2_refPic = !(u2_mb_type & MB_MV_FORW); 437 UWORD16 u2_index = (ps_dec->u2_motion_type); 438 ps_dec->u2_prev_intra_mb = 0; 439 ps_dec->e_mb_pred = (e_pred_direction_t)u2_refPic; 440 ps_dec_mb_params = &ps_dec->ps_func_forw_or_back[u2_index]; 441 ps_dec->s_mb_type = ps_dec_mb_params->s_mb_type; 442 if(NULL == ps_dec_mb_params->pf_func_mb_params) 443 return -1; 444 ps_dec_mb_params->pf_func_mb_params(ps_dec); 445 446 } 447 else if(u2_mb_type & MB_TYPE_INTRA) 448 { 449 ps_dec->u2_prev_intra_mb = 1; 450 impeg2d_dec_intra_mb(ps_dec); 451 452 } 453 else 454 { 455 ps_dec->u2_prev_intra_mb =0; 456 ps_dec->e_mb_pred = FORW; 457 ps_dec->u2_motion_type = 0; 458 impeg2d_dec_0mv_coded_mb(ps_dec); 459 } 460 461 /*-----------------------------------------------------------------------*/ 462 /* decode cbp */ 463 /*-----------------------------------------------------------------------*/ 464 if((u2_mb_type & MB_TYPE_INTRA)) 465 { 466 ps_dec->u2_cbp = 0x3f; 467 ps_dec->u2_prev_intra_mb = 1; 468 } 469 else 470 { 471 ps_dec->u2_prev_intra_mb = 0; 472 ps_dec->u2_def_dc_pred[Y_LUMA] = 128 << ps_dec->u2_intra_dc_precision; 473 ps_dec->u2_def_dc_pred[U_CHROMA] = 128 << ps_dec->u2_intra_dc_precision; 474 ps_dec->u2_def_dc_pred[V_CHROMA] = 128 << ps_dec->u2_intra_dc_precision; 475 if((ps_dec->u2_coded_mb)) 476 { 477 UWORD16 cbpValue; 478 cbpValue = gau2_impeg2d_cbp_code[impeg2d_bit_stream_nxt(ps_stream,MB_CBP_LEN)]; 479 ps_dec->u2_cbp = cbpValue & 0xFF; 480 impeg2d_bit_stream_flush(ps_stream,(cbpValue >> 8) & 0x0FF); 481 } 482 else 483 { 484 ps_dec->u2_cbp = 0; 485 } 486 } 487 return 0; 488} 489 490/******************************************************************************* 491* Function Name : impeg2d_dec_p_b_slice 492* 493* Description : Decodes P and B slices 494* 495* Arguments : 496* dec : Decoder state 497* 498* Values Returned : None 499*******************************************************************************/ 500IMPEG2D_ERROR_CODES_T impeg2d_dec_p_b_slice(dec_state_t *ps_dec) 501{ 502 WORD16 *pi2_vld_out; 503 UWORD32 i; 504 yuv_buf_t *ps_cur_frm_buf = &ps_dec->s_cur_frm_buf; 505 506 UWORD32 u4_frm_offset = 0; 507 const dec_mb_params_t *ps_dec_mb_params; 508 IMPEG2D_ERROR_CODES_T e_error = (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE; 509 510 pi2_vld_out = ps_dec->ai2_vld_buf; 511 memset(ps_dec->ai2_pred_mv,0,sizeof(ps_dec->ai2_pred_mv)); 512 513 ps_dec->u2_prev_intra_mb = 0; 514 ps_dec->u2_first_mb = 1; 515 516 ps_dec->u2_picture_width = ps_dec->u2_frame_width; 517 518 if(ps_dec->u2_picture_structure != FRAME_PICTURE) 519 { 520 ps_dec->u2_picture_width <<= 1; 521 if(ps_dec->u2_picture_structure == BOTTOM_FIELD) 522 { 523 u4_frm_offset = ps_dec->u2_frame_width; 524 } 525 } 526 527 do 528 { 529 UWORD32 u4_x_offset, u4_y_offset; 530 WORD32 ret; 531 532 533 UWORD32 u4_x_dst_offset = 0; 534 UWORD32 u4_y_dst_offset = 0; 535 UWORD8 *pu1_out_p; 536 UWORD8 *pu1_pred; 537 WORD32 u4_pred_strd; 538 539 IMPEG2D_TRACE_MB_START(ps_dec->u2_mb_x, ps_dec->u2_mb_y); 540 541 if(ps_dec->e_pic_type == B_PIC) 542 ret = impeg2d_dec_pnb_mb_params(ps_dec); 543 else 544 ret = impeg2d_dec_p_mb_params(ps_dec); 545 546 if(ret) 547 return IMPEG2D_MB_TEX_DECODE_ERR; 548 549 if(0 >= ps_dec->u2_num_mbs_left) 550 { 551 break; 552 } 553 554 IMPEG2D_TRACE_MB_START(ps_dec->u2_mb_x, ps_dec->u2_mb_y); 555 556 u4_x_dst_offset = u4_frm_offset + (ps_dec->u2_mb_x << 4); 557 u4_y_dst_offset = (ps_dec->u2_mb_y << 4) * ps_dec->u2_picture_width; 558 pu1_out_p = ps_cur_frm_buf->pu1_y + u4_x_dst_offset + u4_y_dst_offset; 559 if(ps_dec->u2_prev_intra_mb == 0) 560 { 561 UWORD32 offset_x, offset_y, stride; 562 UWORD16 index = (ps_dec->u2_motion_type); 563 /*only for non intra mb's*/ 564 if(ps_dec->e_mb_pred == BIDIRECT) 565 { 566 ps_dec_mb_params = &ps_dec->ps_func_bi_direct[index]; 567 } 568 else 569 { 570 ps_dec_mb_params = &ps_dec->ps_func_forw_or_back[index]; 571 } 572 573 stride = ps_dec->u2_picture_width; 574 575 offset_x = u4_frm_offset + (ps_dec->u2_mb_x << 4); 576 577 offset_y = (ps_dec->u2_mb_y << 4); 578 579 ps_dec->s_dest_buf.pu1_y = ps_cur_frm_buf->pu1_y + offset_y * stride + offset_x; 580 581 stride = stride >> 1; 582 583 ps_dec->s_dest_buf.pu1_u = ps_cur_frm_buf->pu1_u + (offset_y >> 1) * stride 584 + (offset_x >> 1); 585 586 ps_dec->s_dest_buf.pu1_v = ps_cur_frm_buf->pu1_v + (offset_y >> 1) * stride 587 + (offset_x >> 1); 588 589 PROFILE_DISABLE_MC_IF0 590 ps_dec_mb_params->pf_mc(ps_dec); 591 592 } 593 for(i = 0; i < NUM_LUMA_BLKS; ++i) 594 { 595 if((ps_dec->u2_cbp & (1 << (BLOCKS_IN_MB - 1 - i))) != 0) 596 { 597 e_error = ps_dec->pf_vld_inv_quant(ps_dec, pi2_vld_out, ps_dec->pu1_inv_scan_matrix, 598 ps_dec->u2_prev_intra_mb, Y_LUMA, 0); 599 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error) 600 { 601 return e_error; 602 } 603 604 u4_x_offset = gai2_impeg2_blk_x_off[i]; 605 606 if(ps_dec->u2_field_dct == 0) 607 u4_y_offset = gai2_impeg2_blk_y_off_frm[i] ; 608 else 609 u4_y_offset = gai2_impeg2_blk_y_off_fld[i] ; 610 611 612 613 614 615 IMPEG2D_IDCT_INP_STATISTICS(pi2_vld_out, ps_dec->u4_non_zero_cols, ps_dec->u4_non_zero_rows); 616 617 PROFILE_DISABLE_IDCT_IF0 618 { 619 WORD32 idx; 620 if(1 == (ps_dec->u4_non_zero_cols | ps_dec->u4_non_zero_rows)) 621 idx = 0; 622 else 623 idx = 1; 624 625 if(0 == ps_dec->u2_prev_intra_mb) 626 { 627 pu1_pred = pu1_out_p + u4_y_offset * ps_dec->u2_picture_width + u4_x_offset; 628 u4_pred_strd = ps_dec->u2_picture_width << ps_dec->u2_field_dct; 629 } 630 else 631 { 632 pu1_pred = (UWORD8 *)gau1_impeg2_zerobuf; 633 u4_pred_strd = 8; 634 } 635 636 ps_dec->pf_idct_recon[idx * 2 + ps_dec->i4_last_value_one](pi2_vld_out, 637 ps_dec->ai2_idct_stg1, 638 pu1_pred, 639 pu1_out_p + u4_y_offset * ps_dec->u2_picture_width + u4_x_offset, 640 8, 641 u4_pred_strd, 642 ps_dec->u2_picture_width << ps_dec->u2_field_dct, 643 ~ps_dec->u4_non_zero_cols, ~ps_dec->u4_non_zero_rows); 644 } 645 } 646 647 } 648 649 /* For U and V blocks, divide the x and y offsets by 2. */ 650 u4_x_dst_offset >>= 1; 651 u4_y_dst_offset >>= 2; 652 653 654 /* In case of chrominance blocks the DCT will be frame DCT */ 655 /* i = 0, U component and i = 1 is V componet */ 656 if((ps_dec->u2_cbp & 0x02) != 0) 657 { 658 pu1_out_p = ps_cur_frm_buf->pu1_u + u4_x_dst_offset + u4_y_dst_offset; 659 e_error = ps_dec->pf_vld_inv_quant(ps_dec, pi2_vld_out, ps_dec->pu1_inv_scan_matrix, 660 ps_dec->u2_prev_intra_mb, U_CHROMA, 0); 661 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error) 662 { 663 return e_error; 664 } 665 666 667 IMPEG2D_IDCT_INP_STATISTICS(pi2_vld_out, ps_dec->u4_non_zero_cols, ps_dec->u4_non_zero_rows); 668 669 PROFILE_DISABLE_IDCT_IF0 670 { 671 WORD32 idx; 672 if(1 == (ps_dec->u4_non_zero_cols | ps_dec->u4_non_zero_rows)) 673 idx = 0; 674 else 675 idx = 1; 676 677 if(0 == ps_dec->u2_prev_intra_mb) 678 { 679 pu1_pred = pu1_out_p; 680 u4_pred_strd = ps_dec->u2_picture_width >> 1; 681 } 682 else 683 { 684 pu1_pred = (UWORD8 *)gau1_impeg2_zerobuf; 685 u4_pred_strd = 8; 686 } 687 688 ps_dec->pf_idct_recon[idx * 2 + ps_dec->i4_last_value_one](pi2_vld_out, 689 ps_dec->ai2_idct_stg1, 690 pu1_pred, 691 pu1_out_p, 692 8, 693 u4_pred_strd, 694 ps_dec->u2_picture_width >> 1, 695 ~ps_dec->u4_non_zero_cols, ~ps_dec->u4_non_zero_rows); 696 697 } 698 699 } 700 701 702 if((ps_dec->u2_cbp & 0x01) != 0) 703 { 704 pu1_out_p = ps_cur_frm_buf->pu1_v + u4_x_dst_offset + u4_y_dst_offset; 705 e_error = ps_dec->pf_vld_inv_quant(ps_dec, pi2_vld_out, ps_dec->pu1_inv_scan_matrix, 706 ps_dec->u2_prev_intra_mb, V_CHROMA, 0); 707 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error) 708 { 709 return e_error; 710 } 711 712 713 IMPEG2D_IDCT_INP_STATISTICS(pi2_vld_out, ps_dec->u4_non_zero_cols, ps_dec->u4_non_zero_rows); 714 715 PROFILE_DISABLE_IDCT_IF0 716 { 717 WORD32 idx; 718 if(1 == (ps_dec->u4_non_zero_cols | ps_dec->u4_non_zero_rows)) 719 idx = 0; 720 else 721 idx = 1; 722 if(0 == ps_dec->u2_prev_intra_mb) 723 { 724 pu1_pred = pu1_out_p; 725 u4_pred_strd = ps_dec->u2_picture_width >> 1; 726 } 727 else 728 { 729 pu1_pred = (UWORD8 *)gau1_impeg2_zerobuf; 730 u4_pred_strd = 8; 731 } 732 733 ps_dec->pf_idct_recon[idx * 2 + ps_dec->i4_last_value_one](pi2_vld_out, 734 ps_dec->ai2_idct_stg1, 735 pu1_pred, 736 pu1_out_p, 737 8, 738 u4_pred_strd, 739 ps_dec->u2_picture_width >> 1, 740 ~ps_dec->u4_non_zero_cols, ~ps_dec->u4_non_zero_rows); 741 742 } 743 } 744 745 ps_dec->u2_num_mbs_left--; 746 ps_dec->u2_first_mb = 0; 747 ps_dec->u2_mb_x++; 748 749 if(ps_dec->s_bit_stream.u4_offset > ps_dec->s_bit_stream.u4_max_offset) 750 { 751 return IMPEG2D_BITSTREAM_BUFF_EXCEEDED_ERR; 752 } 753 else if (ps_dec->u2_mb_x == ps_dec->u2_num_horiz_mb) 754 { 755 ps_dec->u2_mb_x = 0; 756 ps_dec->u2_mb_y++; 757 758 } 759 } 760 while(ps_dec->u2_num_mbs_left != 0 && impeg2d_bit_stream_nxt(&ps_dec->s_bit_stream,23) != 0x0); 761 return e_error; 762} 763