1 /****************************************************************************** 2 * 3 * Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore 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 /** 19 ******************************************************************************* 20 * @file 21 * ihevcd_decode.c 22 * 23 * @brief 24 * Contains codecs main decode function 25 * 26 * @author 27 * Harish 28 * 29 * @par List of Functions: 30 * - fill_outargs() 31 * - ihevcd_decode 32 * @remarks 33 * None 34 * 35 ******************************************************************************* 36 */ 37 /*****************************************************************************/ 38 /* File Includes */ 39 /*****************************************************************************/ 40 #include <stdio.h> 41 #include <stddef.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <assert.h> 45 46 #include "ihevc_typedefs.h" 47 #include "iv.h" 48 #include "ivd.h" 49 #include "ihevcd_cxa.h" 50 #include "ithread.h" 51 52 #include "ihevc_defs.h" 53 #include "ihevc_debug.h" 54 #include "ihevc_structs.h" 55 #include "ihevc_macros.h" 56 #include "ihevc_platform_macros.h" 57 #include "ihevc_cabac_tables.h" 58 #include "ihevc_disp_mgr.h" 59 #include "ihevc_buf_mgr.h" 60 #include "ihevc_dpb_mgr.h" 61 #include "ihevc_error.h" 62 63 #include "ihevcd_defs.h" 64 #include "ihevcd_function_selector.h" 65 #include "ihevcd_structs.h" 66 #include "ihevcd_error.h" 67 #include "ihevcd_nal.h" 68 #include "ihevcd_bitstream.h" 69 #include "ihevcd_fmt_conv.h" 70 #include "ihevcd_job_queue.h" 71 #include "ihevcd_debug.h" 72 #include "ihevcd_parse_slice.h" 73 #include "ihevcd_process_slice.h" 74 #include "ihevcd_ittiam_logo.h" 75 #include "ihevcd_profile.h" 76 77 #define NUM_FRAMES_LIMIT_ENABLED 0 78 79 #if NUM_FRAMES_LIMIT_ENABLED 80 #define NUM_FRAMES_LIMIT 10000 81 #else 82 #define NUM_FRAMES_LIMIT 0x7FFFFFFF 83 #endif 84 85 IHEVCD_ERROR_T ihevcd_check_out_buf_size(codec_t *ps_codec); 86 IHEVCD_ERROR_T ihevcd_fmt_conv(codec_t *ps_codec, 87 process_ctxt_t *ps_proc, 88 UWORD8 *pu1_y_dst, 89 UWORD8 *pu1_u_dst, 90 UWORD8 *pu1_v_dst, 91 WORD32 cur_row, 92 WORD32 num_rows); 93 WORD32 ihevcd_init(codec_t *ps_codec); 94 95 WORD32 ihevcd_allocate_dynamic_bufs(codec_t *ps_codec); 96 WORD32 ihevcd_free_dynamic_bufs(codec_t *ps_codec); 97 /*****************************************************************************/ 98 /* Function Prototypes */ 99 /*****************************************************************************/ 100 101 102 /** 103 ******************************************************************************* 104 * 105 * @brief Fills output arguments for decode process 106 * 107 * @par Description 108 * Fills elements in the output structure based on the current state 109 * 110 * @param[in] ps_codec 111 * Codec context 112 * 113 * @param[in] ps_dec_ip 114 * Pointer to input structure 115 * 116 * @param[in] ps_dec_op 117 * Pointer to output structure 118 * 119 * @returns none 120 * 121 * @remarks 122 * 123 ******************************************************************************* 124 */ 125 static UWORD32 ihevcd_map_error(IHEVCD_ERROR_T e_error) 126 { 127 UWORD32 error_code = 0; 128 error_code = e_error; 129 switch(error_code) 130 { 131 case IHEVCD_SUCCESS : 132 break; 133 case IHEVCD_INIT_NOT_DONE: 134 case IHEVCD_LEVEL_UNSUPPORTED: 135 case IHEVCD_NUM_REF_UNSUPPORTED: 136 case IHEVCD_NUM_REORDER_UNSUPPORTED: 137 case IHEVCD_NUM_EXTRA_DISP_UNSUPPORTED: 138 case IHEVCD_INSUFFICIENT_MEM_MVBANK: 139 case IHEVCD_INSUFFICIENT_MEM_PICBUF: 140 error_code |= 1 << IVD_FATALERROR; 141 break; 142 case IHEVCD_INVALID_DISP_STRD: 143 case IHEVCD_CXA_VERS_BUF_INSUFFICIENT: 144 case IHEVCD_UNSUPPORTED_VPS_ID: 145 case IHEVCD_UNSUPPORTED_SPS_ID: 146 case IHEVCD_UNSUPPORTED_PPS_ID: 147 case IHEVCD_UNSUPPORTED_CHROMA_FMT_IDC: 148 case IHEVCD_UNSUPPORTED_BIT_DEPTH: 149 case IHEVCD_BUF_MGR_ERROR: 150 case IHEVCD_NO_FREE_MVBANK: 151 case IHEVCD_NO_FREE_PICBUF: 152 case IHEVCD_SLICE_IN_HEADER_MODE: 153 case IHEVCD_END_OF_SEQUENCE: 154 break; 155 default: 156 break; 157 } 158 return error_code; 159 } 160 /** 161 ******************************************************************************* 162 * 163 * @brief Fills output arguments for decode process 164 * 165 * @par Description 166 * Fills elements in the output structure based on the current state 167 * 168 * @param[in] ps_codec 169 * Codec context 170 * 171 * @param[in] ps_dec_ip 172 * Pointer to input structure 173 * 174 * @param[in] ps_dec_op 175 * Pointer to output structure 176 * 177 * @returns none 178 * 179 * @remarks 180 * 181 ******************************************************************************* 182 */ 183 static void ihevcd_fill_outargs(codec_t *ps_codec, 184 ivd_video_decode_ip_t *ps_dec_ip, 185 ivd_video_decode_op_t *ps_dec_op) 186 { 187 188 ps_dec_op->u4_error_code = ihevcd_map_error((IHEVCD_ERROR_T)ps_codec->i4_error_code); 189 ps_dec_op->u4_num_bytes_consumed = ps_dec_ip->u4_num_Bytes 190 - ps_codec->i4_bytes_remaining; 191 if(ps_codec->i4_sps_done) 192 { 193 ps_dec_op->u4_pic_wd = ps_codec->i4_disp_wd; 194 ps_dec_op->u4_pic_ht = ps_codec->i4_disp_ht; 195 } 196 else 197 { 198 ps_dec_op->u4_pic_wd = 0; 199 ps_dec_op->u4_pic_ht = 0; 200 } 201 202 ps_dec_op->e_pic_type = ps_codec->e_dec_pic_type; 203 ps_dec_op->u4_frame_decoded_flag = ps_codec->i4_pic_present; 204 ps_dec_op->u4_new_seq = 0; 205 206 ps_dec_op->u4_output_present = 0; 207 ps_dec_op->u4_progressive_frame_flag = 1; 208 if(ps_codec->i4_sps_done) 209 { 210 sps_t *ps_sps = (ps_codec->s_parse.ps_sps_base + ps_codec->i4_sps_id); 211 profile_tier_lvl_info_t *ps_ptl; 212 ps_ptl = &ps_sps->s_ptl; 213 if((0 == ps_ptl->s_ptl_gen.i1_general_progressive_source_flag) && 214 (1 == ps_ptl->s_ptl_gen.i1_general_interlaced_source_flag)) 215 { 216 ps_dec_op->u4_progressive_frame_flag = 0; 217 } 218 } 219 220 ps_dec_op->u4_is_ref_flag = 1; 221 ps_dec_op->e_output_format = ps_codec->e_chroma_fmt; 222 ps_dec_op->u4_is_ref_flag = 1; 223 224 ps_dec_op->e4_fld_type = IV_FLD_TYPE_DEFAULT; 225 226 ps_dec_op->u4_ts = (UWORD32)(-1); 227 ps_dec_op->u4_disp_buf_id = ps_codec->i4_disp_buf_id; 228 if(ps_codec->i4_flush_mode) 229 { 230 ps_dec_op->u4_num_bytes_consumed = 0; 231 /*In the case of flush ,since no frame is decoded set pic type as invalid*/ 232 ps_dec_op->u4_is_ref_flag = 0; 233 ps_dec_op->e_pic_type = IV_NA_FRAME; 234 ps_dec_op->u4_frame_decoded_flag = 0; 235 236 } 237 /* If there is a display buffer */ 238 if(ps_codec->ps_disp_buf) 239 { 240 pic_buf_t *ps_disp_buf = ps_codec->ps_disp_buf; 241 sei_params_t *ps_sei = &ps_disp_buf->s_sei_params; 242 243 if(ps_sei->i1_sei_parameters_present_flag && 244 ps_sei->i1_pic_timing_params_present_flag) 245 { 246 UWORD32 u4_pic_struct; 247 u4_pic_struct = ps_sei->s_pic_timing_sei_params.u4_pic_struct; 248 switch(u4_pic_struct) 249 { 250 case 1: 251 ps_dec_op->e4_fld_type = IV_TOP_FLD; 252 ps_dec_op->u4_progressive_frame_flag = 0; 253 break; 254 case 2: 255 ps_dec_op->e4_fld_type = IV_BOT_FLD; 256 ps_dec_op->u4_progressive_frame_flag = 0; 257 break; 258 case 0: 259 default: 260 ps_dec_op->e4_fld_type = IV_FLD_TYPE_DEFAULT; 261 ps_dec_op->u4_progressive_frame_flag = 1; 262 break; 263 } 264 } 265 ps_dec_op->u4_output_present = 1; 266 ps_dec_op->u4_ts = ps_disp_buf->u4_ts; 267 if((ps_codec->i4_flush_mode == 0) && (ps_codec->s_parse.i4_end_of_frame == 0)) 268 ps_dec_op->u4_output_present = 0; 269 ps_dec_op->s_disp_frm_buf.u4_y_wd = ps_codec->i4_disp_wd; 270 ps_dec_op->s_disp_frm_buf.u4_y_ht = ps_codec->i4_disp_ht; 271 272 if(ps_codec->i4_share_disp_buf) 273 { 274 ps_dec_op->s_disp_frm_buf.pv_y_buf = ps_disp_buf->pu1_luma; 275 if(ps_codec->e_chroma_fmt != IV_YUV_420P) 276 { 277 ps_dec_op->s_disp_frm_buf.pv_u_buf = ps_disp_buf->pu1_chroma; 278 ps_dec_op->s_disp_frm_buf.pv_v_buf = NULL; 279 } 280 else 281 { 282 WORD32 i; 283 UWORD8 *pu1_u_dst = NULL, *pu1_v_dst = NULL; 284 for(i = 0; i < ps_codec->i4_share_disp_buf_cnt; i++) 285 { 286 WORD32 diff = ps_disp_buf->pu1_luma - ps_codec->s_disp_buffer[i].pu1_bufs[0]; 287 if(diff == (ps_codec->i4_strd * PAD_TOP + PAD_LEFT)) 288 { 289 pu1_u_dst = ps_codec->s_disp_buffer[i].pu1_bufs[1]; 290 pu1_u_dst += (ps_codec->i4_strd * PAD_TOP) / 4 + (PAD_LEFT / 2); 291 292 pu1_v_dst = ps_codec->s_disp_buffer[i].pu1_bufs[2]; 293 pu1_v_dst += (ps_codec->i4_strd * PAD_TOP) / 4 + (PAD_LEFT / 2); 294 break; 295 } 296 } 297 ps_dec_op->s_disp_frm_buf.pv_u_buf = pu1_u_dst; 298 ps_dec_op->s_disp_frm_buf.pv_v_buf = pu1_v_dst; 299 } 300 ps_dec_op->s_disp_frm_buf.u4_y_strd = ps_codec->i4_strd; 301 } 302 else 303 { 304 ps_dec_op->s_disp_frm_buf.pv_y_buf = 305 ps_dec_ip->s_out_buffer.pu1_bufs[0]; 306 ps_dec_op->s_disp_frm_buf.pv_u_buf = 307 ps_dec_ip->s_out_buffer.pu1_bufs[1]; 308 ps_dec_op->s_disp_frm_buf.pv_v_buf = 309 ps_dec_ip->s_out_buffer.pu1_bufs[2]; 310 ps_dec_op->s_disp_frm_buf.u4_y_strd = ps_codec->i4_disp_strd; 311 } 312 313 if((IV_YUV_420SP_VU == ps_codec->e_chroma_fmt) 314 || (IV_YUV_420SP_UV == ps_codec->e_chroma_fmt)) 315 { 316 ps_dec_op->s_disp_frm_buf.u4_u_strd = 317 ps_dec_op->s_disp_frm_buf.u4_y_strd; 318 ps_dec_op->s_disp_frm_buf.u4_v_strd = 0; 319 ps_dec_op->s_disp_frm_buf.u4_u_wd = 320 ps_dec_op->s_disp_frm_buf.u4_y_wd; 321 ps_dec_op->s_disp_frm_buf.u4_v_wd = 0; 322 ps_dec_op->s_disp_frm_buf.u4_u_ht = 323 ps_dec_op->s_disp_frm_buf.u4_y_ht / 2; 324 ps_dec_op->s_disp_frm_buf.u4_v_ht = 0; 325 } 326 else if(IV_YUV_420P == ps_codec->e_chroma_fmt) 327 { 328 ps_dec_op->s_disp_frm_buf.u4_u_strd = 329 ps_dec_op->s_disp_frm_buf.u4_y_strd / 2; 330 ps_dec_op->s_disp_frm_buf.u4_v_strd = 331 ps_dec_op->s_disp_frm_buf.u4_y_strd / 2; 332 ps_dec_op->s_disp_frm_buf.u4_u_wd = 333 ps_dec_op->s_disp_frm_buf.u4_y_wd / 2; 334 ps_dec_op->s_disp_frm_buf.u4_v_wd = 335 ps_dec_op->s_disp_frm_buf.u4_y_wd / 2; 336 ps_dec_op->s_disp_frm_buf.u4_u_ht = 337 ps_dec_op->s_disp_frm_buf.u4_y_ht / 2; 338 ps_dec_op->s_disp_frm_buf.u4_v_ht = 339 ps_dec_op->s_disp_frm_buf.u4_y_ht / 2; 340 } 341 342 } 343 else if(ps_codec->i4_flush_mode) 344 { 345 ps_dec_op->u4_error_code = IHEVCD_END_OF_SEQUENCE; 346 /* Come out of flush mode */ 347 ps_codec->i4_flush_mode = 0; 348 } 349 350 } 351 352 /** 353 ******************************************************************************* 354 * 355 * @brief 356 * Codec process call 357 * 358 * @par Description: 359 * Codec process call Tests for few error checks Handle flush and decode 360 * header related code Parse bitstream for start codes For each NAL unit 361 * call decode NAL function Once a complete frame is decoded (in frame 362 * decode mode) Fill output arguments and return 363 * 364 * @param[in] ps_codec_obj 365 * Pointer to codec object at API level 366 * 367 * @param[in] pv_api_ip 368 * Pointer to input argument structure 369 * 370 * @param[in] pv_api_op 371 * Pointer to output argument structure 372 * 373 * @returns Status 374 * 375 * @remarks 376 * 377 * 378 ******************************************************************************* 379 */ 380 WORD32 ihevcd_decode(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op) 381 { 382 WORD32 ret = IV_SUCCESS; 383 codec_t *ps_codec = (codec_t *)(ps_codec_obj->pv_codec_handle); 384 ivd_video_decode_ip_t *ps_dec_ip; 385 ivd_video_decode_op_t *ps_dec_op; 386 387 WORD32 proc_idx = 0; 388 WORD32 prev_proc_idx = 0; 389 390 /* Initialize error code */ 391 ps_codec->i4_error_code = 0; 392 393 ps_dec_ip = (ivd_video_decode_ip_t *)pv_api_ip; 394 ps_dec_op = (ivd_video_decode_op_t *)pv_api_op; 395 396 { 397 UWORD32 u4_size = ps_dec_op->u4_size; 398 memset(ps_dec_op, 0, sizeof(ivd_video_decode_op_t)); 399 ps_dec_op->u4_size = u4_size; //Restore size field 400 } 401 if(ps_codec->i4_init_done != 1) 402 { 403 ps_dec_op->u4_error_code |= 1 << IVD_FATALERROR; 404 ps_dec_op->u4_error_code |= IHEVCD_INIT_NOT_DONE; 405 return IV_FAIL; 406 } 407 408 if(ps_codec->u4_pic_cnt >= NUM_FRAMES_LIMIT) 409 { 410 ps_dec_op->u4_error_code |= 1 << IVD_FATALERROR; 411 ps_dec_op->u4_error_code |= IHEVCD_NUM_FRAMES_LIMIT_REACHED; 412 return IV_FAIL; 413 } 414 415 /* If reset flag is set, flush the existing buffers */ 416 if(ps_codec->i4_reset_flag) 417 { 418 ps_codec->i4_flush_mode = 1; 419 } 420 421 /*Data memory barries instruction,so that bitstream write by the application is complete*/ 422 //arm_dsb(); 423 /* In case the decoder is not in flush mode check for input buffer validity */ 424 if(0 == ps_codec->i4_flush_mode) 425 { 426 if(ps_dec_ip->pv_stream_buffer == NULL) 427 { 428 ps_dec_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM; 429 ps_dec_op->u4_error_code |= IVD_DEC_FRM_BS_BUF_NULL; 430 return IV_FAIL; 431 } 432 if(ps_dec_ip->u4_num_Bytes <= MIN_START_CODE_LEN) 433 { 434 if((WORD32)ps_dec_ip->u4_num_Bytes > 0) 435 ps_dec_op->u4_num_bytes_consumed = ps_dec_ip->u4_num_Bytes; 436 else 437 ps_dec_op->u4_num_bytes_consumed = 0; 438 439 ps_dec_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM; 440 ps_dec_op->u4_error_code |= IVD_DEC_NUMBYTES_INV; 441 return IV_FAIL; 442 443 } 444 } 445 446 #ifdef APPLY_CONCEALMENT 447 { 448 WORD32 num_mbs; 449 450 num_mbs = (ps_codec->i4_wd * ps_codec->i4_ht + 255) >> 8; 451 /* Reset MB Count at the beginning of every process call */ 452 ps_codec->mb_count = 0; 453 memset(ps_codec->mb_map, 0, ((num_mbs + 7) >> 3)); 454 } 455 #endif 456 457 if(0 == ps_codec->i4_share_disp_buf && ps_codec->i4_header_mode == 0) 458 { 459 UWORD32 i; 460 if((ps_dec_ip->s_out_buffer.u4_num_bufs <= 0) || 461 (ps_dec_ip->s_out_buffer.u4_num_bufs > IVD_VIDDEC_MAX_IO_BUFFERS)) 462 { 463 ps_dec_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM; 464 ps_dec_op->u4_error_code |= IVD_DISP_FRM_ZERO_OP_BUFS; 465 return IV_FAIL; 466 } 467 468 for(i = 0; i < ps_dec_ip->s_out_buffer.u4_num_bufs; i++) 469 { 470 if(ps_dec_ip->s_out_buffer.pu1_bufs[i] == NULL) 471 { 472 ps_dec_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM; 473 ps_dec_op->u4_error_code |= IVD_DISP_FRM_OP_BUF_NULL; 474 return IV_FAIL; 475 } 476 477 if(ps_dec_ip->s_out_buffer.u4_min_out_buf_size[i] == 0) 478 { 479 ps_dec_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM; 480 ps_dec_op->u4_error_code |= IVD_DISP_FRM_ZERO_OP_BUF_SIZE; 481 return IV_FAIL; 482 } 483 } 484 } 485 486 ps_codec->ps_out_buffer = &ps_dec_ip->s_out_buffer; 487 ps_codec->u4_ts = ps_dec_ip->u4_ts; 488 if(ps_codec->i4_flush_mode) 489 { 490 491 ps_dec_op->u4_pic_wd = ps_codec->i4_disp_wd; 492 ps_dec_op->u4_pic_ht = ps_codec->i4_disp_ht; 493 494 ps_dec_op->u4_new_seq = 0; 495 496 ps_codec->ps_disp_buf = (pic_buf_t *)ihevc_disp_mgr_get( 497 (disp_mgr_t *)ps_codec->pv_disp_buf_mgr, &ps_codec->i4_disp_buf_id); 498 /* In case of non-shared mode, then convert/copy the frame to output buffer */ 499 /* Only if the codec is in non-shared mode or in shared mode but needs 420P output */ 500 if((ps_codec->ps_disp_buf) 501 && ((0 == ps_codec->i4_share_disp_buf) 502 || (IV_YUV_420P 503 == ps_codec->e_chroma_fmt))) 504 { 505 506 process_ctxt_t *ps_proc = &ps_codec->as_process[prev_proc_idx]; 507 if(0 == ps_proc->i4_init_done) 508 { 509 ihevcd_init_proc_ctxt(ps_proc, 0); 510 } 511 512 /* Output buffer check */ 513 ret = ihevcd_check_out_buf_size(ps_codec); 514 RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret); 515 516 /* Set remaining number of rows to be processed */ 517 ret = ihevcd_fmt_conv(ps_codec, &ps_codec->as_process[prev_proc_idx], 518 ps_dec_ip->s_out_buffer.pu1_bufs[0], 519 ps_dec_ip->s_out_buffer.pu1_bufs[1], 520 ps_dec_ip->s_out_buffer.pu1_bufs[2], 0, 521 ps_codec->i4_disp_ht); 522 523 ihevc_buf_mgr_release((buf_mgr_t *)ps_codec->pv_pic_buf_mgr, 524 ps_codec->i4_disp_buf_id, BUF_MGR_DISP); 525 } 526 527 ihevcd_fill_outargs(ps_codec, ps_dec_ip, ps_dec_op); 528 529 if(1 == ps_dec_op->u4_output_present) 530 { 531 WORD32 xpos = ps_codec->i4_disp_wd - 32 - LOGO_WD; 532 WORD32 ypos = ps_codec->i4_disp_ht - 32 - LOGO_HT; 533 534 if(ypos < 0) 535 ypos = 0; 536 537 if(xpos < 0) 538 xpos = 0; 539 540 INSERT_LOGO(ps_dec_ip->s_out_buffer.pu1_bufs[0], 541 ps_dec_ip->s_out_buffer.pu1_bufs[1], 542 ps_dec_ip->s_out_buffer.pu1_bufs[2], ps_codec->i4_disp_strd, 543 xpos, 544 ypos, 545 ps_codec->e_chroma_fmt, 546 ps_codec->i4_disp_wd, 547 ps_codec->i4_disp_ht); 548 } 549 550 551 if(NULL == ps_codec->ps_disp_buf) 552 { 553 /* If in flush mode and there are no more buffers to flush, 554 * check for the reset flag and reset the decoder */ 555 if(ps_codec->i4_reset_flag) 556 { 557 ihevcd_init(ps_codec); 558 } 559 return (IV_FAIL); 560 } 561 562 return (IV_SUCCESS); 563 564 } 565 /* In case of shared mode, check if there is a free buffer for reconstruction */ 566 if((0 == ps_codec->i4_header_mode) && (1 == ps_codec->i4_share_disp_buf)) 567 { 568 WORD32 buf_status; 569 buf_status = 1; 570 if(ps_codec->pv_pic_buf_mgr) 571 buf_status = ihevc_buf_mgr_check_free((buf_mgr_t *)ps_codec->pv_pic_buf_mgr); 572 573 /* If there is no free buffer, then return with an error code */ 574 if(0 == buf_status) 575 { 576 ps_dec_op->u4_error_code = IVD_DEC_REF_BUF_NULL; 577 ps_dec_op->u4_error_code |= (1 << IVD_UNSUPPORTEDPARAM); 578 return IV_FAIL; 579 } 580 } 581 ps_codec->i4_bytes_remaining = ps_dec_ip->u4_num_Bytes; 582 ps_codec->pu1_inp_bitsbuf = (UWORD8 *)ps_dec_ip->pv_stream_buffer; 583 ps_codec->s_parse.i4_end_of_frame = 0; 584 585 ps_codec->i4_pic_present = 0; 586 ps_codec->i4_slice_error = 0; 587 ps_codec->ps_disp_buf = NULL; 588 589 if(ps_codec->i4_num_cores > 1) 590 { 591 ithread_set_affinity(0); 592 } 593 while(MIN_START_CODE_LEN < ps_codec->i4_bytes_remaining) 594 { 595 WORD32 nal_len; 596 WORD32 nal_ofst; 597 WORD32 bits_len; 598 599 if(ps_codec->i4_slice_error) 600 { 601 slice_header_t *ps_slice_hdr_next = ps_codec->s_parse.ps_slice_hdr_base + (ps_codec->s_parse.i4_cur_slice_idx & (MAX_SLICE_HDR_CNT - 1)); 602 WORD32 next_slice_addr = ps_slice_hdr_next->i2_ctb_x + 603 ps_slice_hdr_next->i2_ctb_y * ps_codec->s_parse.ps_sps->i2_pic_wd_in_ctb; 604 if(ps_codec->s_parse.i4_next_ctb_indx == next_slice_addr) 605 ps_codec->i4_slice_error = 0; 606 } 607 608 if(ps_codec->pu1_bitsbuf_dynamic) 609 { 610 ps_codec->pu1_bitsbuf = ps_codec->pu1_bitsbuf_dynamic; 611 ps_codec->u4_bitsbuf_size = ps_codec->u4_bitsbuf_size_dynamic; 612 } 613 else 614 { 615 ps_codec->pu1_bitsbuf = ps_codec->pu1_bitsbuf_static; 616 ps_codec->u4_bitsbuf_size = ps_codec->u4_bitsbuf_size_static; 617 } 618 619 nal_ofst = ihevcd_nal_search_start_code(ps_codec->pu1_inp_bitsbuf, 620 ps_codec->i4_bytes_remaining); 621 622 ps_codec->i4_nal_ofst = nal_ofst; 623 { 624 WORD32 bytes_remaining = ps_codec->i4_bytes_remaining - nal_ofst; 625 626 bytes_remaining = MIN((UWORD32)bytes_remaining, ps_codec->u4_bitsbuf_size); 627 ihevcd_nal_remv_emuln_bytes(ps_codec->pu1_inp_bitsbuf + nal_ofst, 628 ps_codec->pu1_bitsbuf, 629 bytes_remaining, 630 &nal_len, &bits_len); 631 632 /* Decoder may read upto 8 extra bytes at the end of frame */ 633 /* These are not used, but still set them to zero to avoid uninitialized reads */ 634 if(bits_len < (WORD32)(ps_codec->u4_bitsbuf_size - 8)) 635 { 636 memset(ps_codec->pu1_bitsbuf + bits_len, 0, 2 * sizeof(UWORD32)); 637 } 638 } 639 /* This may be used to update the offsets for tiles and entropy sync row offsets */ 640 ps_codec->i4_num_emln_bytes = nal_len - bits_len; 641 ps_codec->i4_nal_len = nal_len; 642 643 ihevcd_bits_init(&ps_codec->s_parse.s_bitstrm, ps_codec->pu1_bitsbuf, 644 bits_len); 645 646 ret = ihevcd_nal_unit(ps_codec); 647 648 /* If the frame is incomplete and 649 * the bytes remaining is zero or a header is received, 650 * complete the frame treating it to be in error */ 651 if(ps_codec->i4_pic_present && 652 (ps_codec->s_parse.i4_next_ctb_indx != ps_codec->s_parse.ps_sps->i4_pic_size_in_ctb)) 653 { 654 if((ps_codec->i4_bytes_remaining - (nal_len + nal_ofst) <= MIN_START_CODE_LEN) || 655 (ps_codec->i4_header_in_slice_mode)) 656 { 657 slice_header_t *ps_slice_hdr_next; 658 659 ps_codec->s_parse.i4_cur_slice_idx--; 660 if(ps_codec->s_parse.i4_cur_slice_idx < 0) 661 ps_codec->s_parse.i4_cur_slice_idx = 0; 662 663 ps_slice_hdr_next = ps_codec->s_parse.ps_slice_hdr_base + ((ps_codec->s_parse.i4_cur_slice_idx + 1) & (MAX_SLICE_HDR_CNT - 1)); 664 ps_slice_hdr_next->i2_ctb_x = 0; 665 ps_slice_hdr_next->i2_ctb_y = ps_codec->s_parse.ps_sps->i2_pic_ht_in_ctb; 666 ps_codec->i4_slice_error = 1; 667 continue; 668 } 669 } 670 671 if(IHEVCD_IGNORE_SLICE == ret) 672 { 673 ps_codec->pu1_inp_bitsbuf += (nal_ofst + nal_len); 674 ps_codec->i4_bytes_remaining -= (nal_ofst + nal_len); 675 676 continue; 677 } 678 679 if(IVD_RES_CHANGED == ret) 680 { 681 break; 682 } 683 684 /* Update bytes remaining and bytes consumed and input bitstream pointer */ 685 /* Do not consume the NAL in the following cases */ 686 /* Slice header reached during header decode mode */ 687 /* TODO: Next picture's slice reached */ 688 if(ret != IHEVCD_SLICE_IN_HEADER_MODE) 689 { 690 if((0 == ps_codec->i4_slice_error) || 691 (ps_codec->i4_bytes_remaining - (nal_len + nal_ofst) <= MIN_START_CODE_LEN)) 692 { 693 ps_codec->pu1_inp_bitsbuf += (nal_ofst + nal_len); 694 ps_codec->i4_bytes_remaining -= (nal_ofst + nal_len); 695 } 696 if(ret != IHEVCD_SUCCESS) 697 break; 698 699 if(ps_codec->s_parse.i4_end_of_frame) 700 break; 701 } 702 else 703 { 704 ret = IHEVCD_SUCCESS; 705 break; 706 } 707 708 /* Allocate dynamic bitstream buffer once SPS is decoded */ 709 if((ps_codec->u4_allocate_dynamic_done == 0) && ps_codec->i4_sps_done) 710 { 711 WORD32 ret; 712 ret = ihevcd_allocate_dynamic_bufs(ps_codec); 713 if(ret != IV_SUCCESS) 714 { 715 /* Free any dynamic buffers that are allocated */ 716 ihevcd_free_dynamic_bufs(ps_codec); 717 ps_codec->i4_error_code = IVD_MEM_ALLOC_FAILED; 718 ps_dec_op->u4_error_code |= 1 << IVD_FATALERROR; 719 ps_dec_op->u4_error_code |= IVD_MEM_ALLOC_FAILED; 720 721 return IV_FAIL; 722 } 723 } 724 725 BREAK_AFTER_SLICE_NAL(); 726 } 727 728 if(1 == ps_codec->i4_pic_present && 0 == ps_codec->s_parse.i4_end_of_frame) 729 { 730 slice_header_t *ps_slice_hdr_next; 731 ps_codec->i4_slice_error = 1; 732 ps_codec->s_parse.i4_cur_slice_idx--; 733 if(ps_codec->s_parse.i4_cur_slice_idx < 0) 734 ps_codec->s_parse.i4_cur_slice_idx = 0; 735 736 ps_slice_hdr_next = ps_codec->s_parse.ps_slice_hdr_base + ((ps_codec->s_parse.i4_cur_slice_idx + 1) & (MAX_SLICE_HDR_CNT - 1)); 737 ps_slice_hdr_next->i2_ctb_x = -1; 738 ps_slice_hdr_next->i2_ctb_y = -1; 739 740 ihevcd_parse_slice_data(ps_codec); 741 ASSERT(ps_codec->s_parse.i4_end_of_frame != 0); 742 } 743 744 if(1 == ps_codec->i4_pic_present) 745 { 746 WORD32 i; 747 sps_t *ps_sps = ps_codec->s_parse.ps_sps; 748 ps_codec->i4_first_pic_done = 1; 749 750 /*TODO temporary fix: end_of_frame is checked before adding format conversion to job queue */ 751 if(ps_codec->i4_num_cores > 1 && ps_codec->s_parse.i4_end_of_frame) 752 { 753 754 /* Add job queue for format conversion / frame copy for each ctb row */ 755 /* Only if the codec is in non-shared mode or in shared mode but needs 420P output */ 756 process_ctxt_t *ps_proc; 757 758 /* i4_num_cores - 1 contexts are currently being used by other threads */ 759 ps_proc = &ps_codec->as_process[ps_codec->i4_num_cores - 1]; 760 761 if((ps_codec->ps_disp_buf) && 762 ((0 == ps_codec->i4_share_disp_buf) || (IV_YUV_420P == ps_codec->e_chroma_fmt))) 763 { 764 /* If format conversion jobs were not issued in pic_init() add them here */ 765 if((0 == ps_codec->u4_enable_fmt_conv_ahead) || 766 (ps_codec->i4_disp_buf_id == ps_proc->i4_cur_pic_buf_id)) 767 for(i = 0; i < ps_sps->i2_pic_ht_in_ctb; i++) 768 { 769 proc_job_t s_job; 770 IHEVCD_ERROR_T ret; 771 s_job.i4_cmd = CMD_FMTCONV; 772 s_job.i2_ctb_cnt = 0; 773 s_job.i2_ctb_x = 0; 774 s_job.i2_ctb_y = i; 775 s_job.i2_slice_idx = 0; 776 s_job.i4_tu_coeff_data_ofst = 0; 777 ret = ihevcd_jobq_queue((jobq_t *)ps_codec->s_parse.pv_proc_jobq, 778 &s_job, sizeof(proc_job_t), 1); 779 if(ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS) 780 return (WORD32)ret; 781 } 782 } 783 /* Reached end of frame : Signal terminate */ 784 /* The terminate flag is checked only after all the jobs are dequeued */ 785 ret = ihevcd_jobq_terminate((jobq_t *)ps_codec->s_parse.pv_proc_jobq); 786 787 while(1) 788 { 789 IHEVCD_ERROR_T ret; 790 proc_job_t s_job; 791 process_ctxt_t *ps_proc; 792 793 /* i4_num_cores - 1 contexts are currently being used by other threads */ 794 ps_proc = &ps_codec->as_process[ps_codec->i4_num_cores - 1]; 795 796 ret = ihevcd_jobq_dequeue((jobq_t *)ps_proc->pv_proc_jobq, &s_job, 797 sizeof(proc_job_t), 1); 798 if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret) 799 break; 800 801 ps_proc->i4_ctb_cnt = s_job.i2_ctb_cnt; 802 ps_proc->i4_ctb_x = s_job.i2_ctb_x; 803 ps_proc->i4_ctb_y = s_job.i2_ctb_y; 804 ps_proc->i4_cur_slice_idx = s_job.i2_slice_idx; 805 806 if(CMD_PROCESS == s_job.i4_cmd) 807 { 808 ihevcd_init_proc_ctxt(ps_proc, s_job.i4_tu_coeff_data_ofst); 809 810 ihevcd_process(ps_proc); 811 } 812 else if(CMD_FMTCONV == s_job.i4_cmd) 813 { 814 sps_t *ps_sps = ps_codec->s_parse.ps_sps; 815 WORD32 num_rows = 1 << ps_sps->i1_log2_ctb_size; 816 if(0 == ps_proc->i4_init_done) 817 { 818 ihevcd_init_proc_ctxt(ps_proc, 0); 819 } 820 821 num_rows = MIN(num_rows, (ps_codec->i4_disp_ht - (s_job.i2_ctb_y << ps_sps->i1_log2_ctb_size))); 822 if(num_rows < 0) 823 num_rows = 0; 824 825 ihevcd_fmt_conv(ps_codec, ps_proc, 826 ps_dec_ip->s_out_buffer.pu1_bufs[0], 827 ps_dec_ip->s_out_buffer.pu1_bufs[1], 828 ps_dec_ip->s_out_buffer.pu1_bufs[2], 829 s_job.i2_ctb_y << ps_sps->i1_log2_ctb_size, 830 num_rows); 831 } 832 } 833 } 834 /* In case of non-shared mode and while running in single core mode, then convert/copy the frame to output buffer */ 835 /* Only if the codec is in non-shared mode or in shared mode but needs 420P output */ 836 else if((ps_codec->ps_disp_buf) && ((0 == ps_codec->i4_share_disp_buf) || 837 (IV_YUV_420P == ps_codec->e_chroma_fmt)) && 838 (ps_codec->s_parse.i4_end_of_frame)) 839 { 840 process_ctxt_t *ps_proc = &ps_codec->as_process[proc_idx]; 841 /* Set remaining number of rows to be processed */ 842 ps_codec->s_fmt_conv.i4_num_rows = ps_codec->i4_disp_ht 843 - ps_codec->s_fmt_conv.i4_cur_row; 844 if(0 == ps_proc->i4_init_done) 845 { 846 ihevcd_init_proc_ctxt(ps_proc, 0); 847 } 848 849 if(ps_codec->s_fmt_conv.i4_num_rows < 0) 850 ps_codec->s_fmt_conv.i4_num_rows = 0; 851 852 ret = ihevcd_fmt_conv(ps_codec, ps_proc, 853 ps_dec_ip->s_out_buffer.pu1_bufs[0], 854 ps_dec_ip->s_out_buffer.pu1_bufs[1], 855 ps_dec_ip->s_out_buffer.pu1_bufs[2], 856 ps_codec->s_fmt_conv.i4_cur_row, 857 ps_codec->s_fmt_conv.i4_num_rows); 858 ps_codec->s_fmt_conv.i4_cur_row += ps_codec->s_fmt_conv.i4_num_rows; 859 860 } 861 862 863 DEBUG_DUMP_MV_MAP(ps_codec); 864 865 /* Mark MV Buf as needed for reference */ 866 ihevc_buf_mgr_set_status((buf_mgr_t *)ps_codec->pv_mv_buf_mgr, 867 ps_codec->as_process[proc_idx].i4_cur_mv_bank_buf_id, 868 BUF_MGR_REF); 869 870 /* Mark pic buf as needed for reference */ 871 ihevc_buf_mgr_set_status((buf_mgr_t *)ps_codec->pv_pic_buf_mgr, 872 ps_codec->as_process[proc_idx].i4_cur_pic_buf_id, 873 BUF_MGR_REF); 874 875 /* Mark pic buf as needed for display */ 876 ihevc_buf_mgr_set_status((buf_mgr_t *)ps_codec->pv_pic_buf_mgr, 877 ps_codec->as_process[proc_idx].i4_cur_pic_buf_id, 878 BUF_MGR_DISP); 879 880 /* Insert the current picture as short term reference */ 881 ihevc_dpb_mgr_insert_ref((dpb_mgr_t *)ps_codec->pv_dpb_mgr, 882 ps_codec->as_process[proc_idx].ps_cur_pic, 883 ps_codec->as_process[proc_idx].i4_cur_pic_buf_id); 884 885 /* If a frame was displayed (in non-shared mode), then release it from display manager */ 886 if((0 == ps_codec->i4_share_disp_buf) && (ps_codec->ps_disp_buf)) 887 ihevc_buf_mgr_release((buf_mgr_t *)ps_codec->pv_pic_buf_mgr, 888 ps_codec->i4_disp_buf_id, BUF_MGR_DISP); 889 890 /* Wait for threads */ 891 for(i = 0; i < (ps_codec->i4_num_cores - 1); i++) 892 { 893 if(ps_codec->ai4_process_thread_created[i]) 894 { 895 ithread_join(ps_codec->apv_process_thread_handle[i], NULL); 896 ps_codec->ai4_process_thread_created[i] = 0; 897 } 898 } 899 900 DEBUG_VALIDATE_PADDED_REGION(&ps_codec->as_process[proc_idx]); 901 if(ps_codec->u4_pic_cnt > 0) 902 { 903 DEBUG_DUMP_PIC_PU(ps_codec); 904 } 905 DEBUG_DUMP_PIC_BUFFERS(ps_codec); 906 907 /* Increment the number of pictures decoded */ 908 ps_codec->u4_pic_cnt++; 909 } 910 ihevcd_fill_outargs(ps_codec, ps_dec_ip, ps_dec_op); 911 912 if(1 == ps_dec_op->u4_output_present) 913 { 914 WORD32 xpos = ps_codec->i4_disp_wd - 32 - LOGO_WD; 915 WORD32 ypos = ps_codec->i4_disp_ht - 32 - LOGO_HT; 916 917 if(ypos < 0) 918 ypos = 0; 919 920 if(xpos < 0) 921 xpos = 0; 922 923 INSERT_LOGO(ps_dec_ip->s_out_buffer.pu1_bufs[0], 924 ps_dec_ip->s_out_buffer.pu1_bufs[1], 925 ps_dec_ip->s_out_buffer.pu1_bufs[2], ps_codec->i4_disp_strd, 926 xpos, 927 ypos, 928 ps_codec->e_chroma_fmt, 929 ps_codec->i4_disp_wd, 930 ps_codec->i4_disp_ht); 931 } 932 933 934 return ret; 935 } 936 937
