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_parse_headers.c 22 * 23 * @brief 24 * Contains functions for parsing headers 25 * 26 * @author 27 * Harish 28 * 29 * @par List of Functions: 30 * 31 * @remarks 32 * None 33 * 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 #include <limits.h> 46 #include <stdint.h> 47 48 #include "ihevc_typedefs.h" 49 #include "iv.h" 50 #include "ivd.h" 51 #include "ihevcd_cxa.h" 52 53 #include "ihevc_defs.h" 54 #include "ihevc_debug.h" 55 #include "ihevc_defs.h" 56 #include "ihevc_structs.h" 57 #include "ihevc_buf_mgr.h" 58 #include "ihevc_dpb_mgr.h" 59 #include "ihevc_macros.h" 60 #include "ihevc_platform_macros.h" 61 #include "ihevc_cabac_tables.h" 62 #include "ihevc_common_tables.h" 63 #include "ihevc_quant_tables.h" 64 65 #include "ihevcd_trace.h" 66 #include "ihevcd_defs.h" 67 #include "ihevcd_function_selector.h" 68 #include "ihevcd_structs.h" 69 #include "ihevcd_error.h" 70 #include "ihevcd_debug.h" 71 #include "ihevcd_nal.h" 72 #include "ihevcd_bitstream.h" 73 #include "ihevcd_parse_headers.h" 74 #include "ihevcd_ref_list.h" 75 76 #define COPY_DEFAULT_SCALING_LIST(pi2_scaling_mat) \ 77 { \ 78 WORD32 scaling_mat_offset[]={0, 16, 32, 48, 64, 80, 96, 160, 224, 288, 352, 416, 480, 736, 992, 1248, 1504, 1760, 2016, 3040}; \ 79 \ 80 /* scaling matrix for 4x4 */ \ 81 memcpy(pi2_scaling_mat, gi2_flat_scale_mat_32x32, 6*16*sizeof(WORD16)); \ 82 /* scaling matrix for 8x8 */ \ 83 memcpy(pi2_scaling_mat + scaling_mat_offset[6], gi2_intra_default_scale_mat_8x8, 64*sizeof(WORD16)); \ 84 memcpy(pi2_scaling_mat + scaling_mat_offset[7], gi2_intra_default_scale_mat_8x8, 64*sizeof(WORD16)); \ 85 memcpy(pi2_scaling_mat + scaling_mat_offset[8], gi2_intra_default_scale_mat_8x8, 64*sizeof(WORD16)); \ 86 memcpy(pi2_scaling_mat + scaling_mat_offset[9], gi2_inter_default_scale_mat_8x8, 64*sizeof(WORD16)); \ 87 memcpy(pi2_scaling_mat + scaling_mat_offset[10], gi2_inter_default_scale_mat_8x8, 64*sizeof(WORD16)); \ 88 memcpy(pi2_scaling_mat + scaling_mat_offset[11], gi2_inter_default_scale_mat_8x8, 64*sizeof(WORD16)); \ 89 /* scaling matrix for 16x16 */ \ 90 memcpy(pi2_scaling_mat + scaling_mat_offset[12], gi2_intra_default_scale_mat_16x16, 256*sizeof(WORD16)); \ 91 memcpy(pi2_scaling_mat + scaling_mat_offset[13], gi2_intra_default_scale_mat_16x16, 256*sizeof(WORD16)); \ 92 memcpy(pi2_scaling_mat + scaling_mat_offset[14], gi2_intra_default_scale_mat_16x16, 256*sizeof(WORD16)); \ 93 memcpy(pi2_scaling_mat + scaling_mat_offset[15], gi2_inter_default_scale_mat_16x16, 256*sizeof(WORD16)); \ 94 memcpy(pi2_scaling_mat + scaling_mat_offset[16], gi2_inter_default_scale_mat_16x16, 256*sizeof(WORD16)); \ 95 memcpy(pi2_scaling_mat + scaling_mat_offset[17], gi2_inter_default_scale_mat_16x16, 256*sizeof(WORD16)); \ 96 /* scaling matrix for 32x32 */ \ 97 memcpy(pi2_scaling_mat + scaling_mat_offset[18], gi2_intra_default_scale_mat_32x32, 1024*sizeof(WORD16)); \ 98 memcpy(pi2_scaling_mat + scaling_mat_offset[19], gi2_inter_default_scale_mat_32x32, 1024*sizeof(WORD16)); \ 99 } 100 101 #define COPY_FLAT_SCALING_LIST(pi2_scaling_mat) \ 102 { \ 103 WORD32 scaling_mat_offset[]={0, 16, 32, 48, 64, 80, 96, 160, 224, 288, 352, 416, 480, 736, 992, 1248, 1504, 1760, 2016, 3040}; \ 104 \ 105 /* scaling matrix for 4x4 */ \ 106 memcpy(pi2_scaling_mat, gi2_flat_scale_mat_32x32, 6*16*sizeof(WORD16)); \ 107 /* scaling matrix for 8x8 */ \ 108 memcpy(pi2_scaling_mat + scaling_mat_offset[6], gi2_flat_scale_mat_32x32, 6*64*sizeof(WORD16)); \ 109 /* scaling matrix for 16x16 */ \ 110 memcpy(pi2_scaling_mat + scaling_mat_offset[12], gi2_flat_scale_mat_32x32, 3*256*sizeof(WORD16)); \ 111 memcpy(pi2_scaling_mat + scaling_mat_offset[15], gi2_flat_scale_mat_32x32, 3*256*sizeof(WORD16)); \ 112 /* scaling matrix for 32x32 */ \ 113 memcpy(pi2_scaling_mat + scaling_mat_offset[18], gi2_flat_scale_mat_32x32, 1024*sizeof(WORD16)); \ 114 memcpy(pi2_scaling_mat + scaling_mat_offset[19], gi2_flat_scale_mat_32x32, 1024*sizeof(WORD16)); \ 115 } 116 117 /* Function declarations */ 118 119 /** 120 ******************************************************************************* 121 * 122 * @brief 123 * Parses Prediction weight table syntax 124 * 125 * @par Description: 126 * Parse Prediction weight table syntax as per Section: 7.3.8.4 127 * 128 * @param[in] ps_bitstrm 129 * Pointer to bitstream context 130 * 131 * @param[in] ps_sps 132 * Current SPS 133 * 134 * @param[in] ps_pps 135 * Current PPS 136 * 137 * @param[in] ps_slice_hdr 138 * Current Slice header 139 * 140 * @returns Error code from IHEVCD_ERROR_T 141 * 142 * @remarks 143 * 144 * 145 ******************************************************************************* 146 */ 147 148 WORD32 ihevcd_parse_pred_wt_ofst(bitstrm_t *ps_bitstrm, 149 sps_t *ps_sps, 150 pps_t *ps_pps, 151 slice_header_t *ps_slice_hdr) 152 { 153 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 154 WORD32 value; 155 UWORD32 u4_value; 156 WORD32 i; 157 158 pred_wt_ofst_t *ps_wt_ofst = &ps_slice_hdr->s_wt_ofst; 159 UNUSED(ps_pps); 160 161 UEV_PARSE("luma_log2_weight_denom", u4_value, ps_bitstrm); 162 if(u4_value > 7) 163 { 164 return IHEVCD_INVALID_PARAMETER; 165 } 166 ps_wt_ofst->i1_luma_log2_weight_denom = u4_value; 167 168 if(ps_sps->i1_chroma_format_idc != 0) 169 { 170 SEV_PARSE("delta_chroma_log2_weight_denom", value, ps_bitstrm); 171 if(((ps_wt_ofst->i1_luma_log2_weight_denom + value) < 0) || 172 ((ps_wt_ofst->i1_luma_log2_weight_denom + value) > 7)) 173 { 174 return IHEVCD_INVALID_PARAMETER; 175 } 176 ps_wt_ofst->i1_chroma_log2_weight_denom = ps_wt_ofst->i1_luma_log2_weight_denom + value; 177 } 178 179 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) 180 { 181 BITS_PARSE("luma_weight_l0_flag[ i ]", value, ps_bitstrm, 1); 182 ps_wt_ofst->i1_luma_weight_l0_flag[i] = value; 183 } 184 185 186 187 if(ps_sps->i1_chroma_format_idc != 0) 188 { 189 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) 190 { 191 BITS_PARSE("chroma_weight_l0_flag[ i ]", value, ps_bitstrm, 1); 192 ps_wt_ofst->i1_chroma_weight_l0_flag[i] = value; 193 } 194 } 195 else 196 { 197 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) 198 { 199 ps_wt_ofst->i1_chroma_weight_l0_flag[i] = 0; 200 } 201 } 202 203 204 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) 205 { 206 if(ps_wt_ofst->i1_luma_weight_l0_flag[i]) 207 { 208 SEV_PARSE("delta_luma_weight_l0[ i ]", value, ps_bitstrm); 209 if( value < -128 || value > 127 ) 210 { 211 return IHEVCD_INVALID_PARAMETER; 212 } 213 214 ps_wt_ofst->i2_luma_weight_l0[i] = (1 << ps_wt_ofst->i1_luma_log2_weight_denom) + value; 215 216 SEV_PARSE("luma_offset_l0[ i ]", value, ps_bitstrm); 217 if( value < -128 || value > 127 ) 218 { 219 return IHEVCD_INVALID_PARAMETER; 220 } 221 ps_wt_ofst->i2_luma_offset_l0[i] = value; 222 223 } 224 else 225 { 226 ps_wt_ofst->i2_luma_weight_l0[i] = (1 << ps_wt_ofst->i1_luma_log2_weight_denom); 227 ps_wt_ofst->i2_luma_offset_l0[i] = 0; 228 } 229 if(ps_wt_ofst->i1_chroma_weight_l0_flag[i]) 230 { 231 WORD32 ofst; 232 WORD32 shift = (1 << (BIT_DEPTH_CHROMA - 1)); 233 SEV_PARSE("delta_chroma_weight_l0[ i ][ j ]", value, ps_bitstrm); 234 if(value < -128 || value > 127) 235 { 236 return IHEVCD_INVALID_PARAMETER; 237 } 238 ps_wt_ofst->i2_chroma_weight_l0_cb[i] = (1 << ps_wt_ofst->i1_chroma_log2_weight_denom) + value; 239 240 241 SEV_PARSE("delta_chroma_offset_l0[ i ][ j ]", value, ps_bitstrm); 242 if( value < -512 || value > 511 ) 243 { 244 return IHEVCD_INVALID_PARAMETER; 245 } 246 ofst = ((shift * ps_wt_ofst->i2_chroma_weight_l0_cb[i]) >> ps_wt_ofst->i1_chroma_log2_weight_denom); 247 ofst = value - ofst + shift; 248 249 ps_wt_ofst->i2_chroma_offset_l0_cb[i] = CLIP_S8(ofst); 250 251 SEV_PARSE("delta_chroma_weight_l0[ i ][ j ]", value, ps_bitstrm); 252 if(value < -128 || value > 127) 253 { 254 return IHEVCD_INVALID_PARAMETER; 255 } 256 ps_wt_ofst->i2_chroma_weight_l0_cr[i] = (1 << ps_wt_ofst->i1_chroma_log2_weight_denom) + value; 257 258 259 SEV_PARSE("delta_chroma_offset_l0[ i ][ j ]", value, ps_bitstrm); 260 if( value < -512 || value > 511 ) 261 { 262 return IHEVCD_INVALID_PARAMETER; 263 } 264 ofst = ((shift * ps_wt_ofst->i2_chroma_weight_l0_cr[i]) >> ps_wt_ofst->i1_chroma_log2_weight_denom); 265 ofst = value - ofst + shift; 266 267 ps_wt_ofst->i2_chroma_offset_l0_cr[i] = CLIP_S8(ofst); 268 269 } 270 else 271 { 272 ps_wt_ofst->i2_chroma_weight_l0_cb[i] = (1 << ps_wt_ofst->i1_chroma_log2_weight_denom); 273 ps_wt_ofst->i2_chroma_weight_l0_cr[i] = (1 << ps_wt_ofst->i1_chroma_log2_weight_denom); 274 275 ps_wt_ofst->i2_chroma_offset_l0_cb[i] = 0; 276 ps_wt_ofst->i2_chroma_offset_l0_cr[i] = 0; 277 } 278 } 279 if(BSLICE == ps_slice_hdr->i1_slice_type) 280 { 281 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) 282 { 283 BITS_PARSE("luma_weight_l1_flag[ i ]", value, ps_bitstrm, 1); 284 ps_wt_ofst->i1_luma_weight_l1_flag[i] = value; 285 } 286 287 if(ps_sps->i1_chroma_format_idc != 0) 288 { 289 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) 290 { 291 BITS_PARSE("chroma_weight_l1_flag[ i ]", value, ps_bitstrm, 1); 292 ps_wt_ofst->i1_chroma_weight_l1_flag[i] = value; 293 } 294 } 295 else 296 { 297 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) 298 { 299 ps_wt_ofst->i1_chroma_weight_l1_flag[i] = 0; 300 } 301 } 302 303 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) 304 { 305 if(ps_wt_ofst->i1_luma_weight_l1_flag[i]) 306 { 307 SEV_PARSE("delta_luma_weight_l1[ i ]", value, ps_bitstrm); 308 if( value < -128 || value > 127 ) 309 { 310 return IHEVCD_INVALID_PARAMETER; 311 } 312 313 ps_wt_ofst->i2_luma_weight_l1[i] = (1 << ps_wt_ofst->i1_luma_log2_weight_denom) + value; 314 315 SEV_PARSE("luma_offset_l1[ i ]", value, ps_bitstrm); 316 if( value < -128 || value > 127 ) 317 { 318 return IHEVCD_INVALID_PARAMETER; 319 } 320 ps_wt_ofst->i2_luma_offset_l1[i] = value; 321 322 } 323 else 324 { 325 ps_wt_ofst->i2_luma_weight_l1[i] = (1 << ps_wt_ofst->i1_luma_log2_weight_denom); 326 ps_wt_ofst->i2_luma_offset_l1[i] = 0; 327 } 328 329 if(ps_wt_ofst->i1_chroma_weight_l1_flag[i]) 330 { 331 WORD32 ofst; 332 WORD32 shift = (1 << (BIT_DEPTH_CHROMA - 1)); 333 SEV_PARSE("delta_chroma_weight_l1[ i ][ j ]", value, ps_bitstrm); 334 if(value < -128 || value > 127) 335 { 336 return IHEVCD_INVALID_PARAMETER; 337 } 338 ps_wt_ofst->i2_chroma_weight_l1_cb[i] = (1 << ps_wt_ofst->i1_chroma_log2_weight_denom) + value;; 339 340 341 SEV_PARSE("delta_chroma_offset_l1[ i ][ j ]", value, ps_bitstrm); 342 if( value < -512 || value > 511 ) 343 { 344 return IHEVCD_INVALID_PARAMETER; 345 } 346 ofst = ((shift * ps_wt_ofst->i2_chroma_weight_l1_cb[i]) >> ps_wt_ofst->i1_chroma_log2_weight_denom); 347 ofst = value - ofst + shift; 348 349 ps_wt_ofst->i2_chroma_offset_l1_cb[i] = CLIP_S8(ofst);; 350 351 SEV_PARSE("delta_chroma_weight_l1[ i ][ j ]", value, ps_bitstrm); 352 if(value < -128 || value > 127) 353 { 354 return IHEVCD_INVALID_PARAMETER; 355 } 356 ps_wt_ofst->i2_chroma_weight_l1_cr[i] = (1 << ps_wt_ofst->i1_chroma_log2_weight_denom) + value; 357 358 359 SEV_PARSE("delta_chroma_offset_l1[ i ][ j ]", value, ps_bitstrm); 360 if( value < -512 || value > 511 ) 361 { 362 return IHEVCD_INVALID_PARAMETER; 363 } 364 ofst = ((shift * ps_wt_ofst->i2_chroma_weight_l1_cr[i]) >> ps_wt_ofst->i1_chroma_log2_weight_denom); 365 ofst = value - ofst + shift; 366 367 ps_wt_ofst->i2_chroma_offset_l1_cr[i] = CLIP_S8(ofst);; 368 369 } 370 else 371 { 372 ps_wt_ofst->i2_chroma_weight_l1_cb[i] = (1 << ps_wt_ofst->i1_chroma_log2_weight_denom); 373 ps_wt_ofst->i2_chroma_weight_l1_cr[i] = (1 << ps_wt_ofst->i1_chroma_log2_weight_denom); 374 375 ps_wt_ofst->i2_chroma_offset_l1_cb[i] = 0; 376 ps_wt_ofst->i2_chroma_offset_l1_cr[i] = 0; 377 378 } 379 } 380 } 381 return ret; 382 } 383 384 /** 385 ******************************************************************************* 386 * 387 * @brief 388 * Parses short term reference picture set 389 * 390 * @par Description 391 * Parses short term reference picture set as per section 7.3.8.2. 392 * Can be called by either SPS or Slice header parsing modules. 393 * 394 * @param[in] ps_bitstrm 395 * Pointer to bitstream structure 396 * 397 * @param[out] ps_stref_picset_base 398 * Pointer to first short term ref pic set structure 399 * 400 * @param[in] num_short_term_ref_pic_sets 401 * Number of short term reference pic sets 402 * 403 * @param[in] idx 404 * Current short term ref pic set id 405 * 406 * @returns Error code from IHEVCD_ERROR_T 407 * 408 * @remarks 409 * 410 ******************************************************************************* 411 */ 412 IHEVCD_ERROR_T ihevcd_short_term_ref_pic_set(bitstrm_t *ps_bitstrm, 413 stref_picset_t *ps_stref_picset_base, 414 WORD32 num_short_term_ref_pic_sets, 415 WORD32 idx, 416 stref_picset_t *ps_stref_picset) 417 { 418 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 419 UWORD32 value; 420 stref_picset_t *ps_stref_picset_ref; 421 WORD32 delta_idx, delta_rps; 422 WORD32 r_idx; 423 WORD32 i; 424 WORD32 j, k, temp; 425 if(idx > 0) 426 { 427 BITS_PARSE("inter_ref_pic_set_prediction_flag", value, ps_bitstrm, 1); 428 ps_stref_picset->i1_inter_ref_pic_set_prediction_flag = value; 429 } 430 else 431 ps_stref_picset->i1_inter_ref_pic_set_prediction_flag = 0; 432 433 if(ps_stref_picset->i1_inter_ref_pic_set_prediction_flag) 434 { 435 WORD32 delta_rps_sign; 436 WORD32 abs_delta_rps; 437 WORD32 num_neg_pics = 0; 438 WORD32 num_pos_pics = 0; 439 WORD32 num_pics = 0; 440 441 if(idx == num_short_term_ref_pic_sets) 442 { 443 UEV_PARSE("delta_idx_minus1", value, ps_bitstrm); 444 if(value > num_short_term_ref_pic_sets - 1) 445 { 446 return IHEVCD_INVALID_PARAMETER; 447 } 448 delta_idx = value + 1; 449 } 450 else 451 { 452 delta_idx = 1; 453 } 454 r_idx = idx - delta_idx; 455 r_idx = CLIP3(r_idx, 0, idx - 1); 456 457 ps_stref_picset_ref = ps_stref_picset_base + r_idx; 458 459 BITS_PARSE("delta_rps_sign", value, ps_bitstrm, 1); 460 delta_rps_sign = value; 461 462 UEV_PARSE("abs_delta_rps_minus1", value, ps_bitstrm); 463 if(value > 32767) 464 { 465 return IHEVCD_INVALID_PARAMETER; 466 } 467 abs_delta_rps = value + 1; 468 469 delta_rps = (1 - 2 * delta_rps_sign) * (abs_delta_rps); 470 471 472 473 for(i = 0; i <= ps_stref_picset_ref->i1_num_delta_pocs; i++) 474 { 475 WORD32 ref_idc; 476 477 /*****************************************************************/ 478 /* ref_idc is parsed as below */ 479 /* bits "1" ref_idc 1 */ 480 /* bits "01" ref_idc 2 */ 481 /* bits "00" ref_idc 0 */ 482 /*****************************************************************/ 483 BITS_PARSE("used_by_curr_pic_flag", value, ps_bitstrm, 1); 484 ref_idc = value; 485 ps_stref_picset->ai1_used[num_pics] = value; 486 /* If ref_idc is zero check for next bit */ 487 if(0 == ref_idc) 488 { 489 BITS_PARSE("use_delta_flag", value, ps_bitstrm, 1); 490 ref_idc = value << 1; 491 } 492 if((ref_idc == 1) || (ref_idc == 2)) 493 { 494 WORD32 delta_poc; 495 delta_poc = delta_rps; 496 delta_poc += 497 ((i < ps_stref_picset_ref->i1_num_delta_pocs) ? 498 ps_stref_picset_ref->ai2_delta_poc[i] : 499 0); 500 501 ps_stref_picset->ai2_delta_poc[num_pics] = delta_poc; 502 503 if(delta_poc < 0) 504 { 505 num_neg_pics++; 506 } 507 else 508 { 509 num_pos_pics++; 510 } 511 num_pics++; 512 } 513 ps_stref_picset->ai1_ref_idc[i] = ref_idc; 514 } 515 516 num_neg_pics = CLIP3(num_neg_pics, 0, MAX_DPB_SIZE - 1); 517 num_pos_pics = CLIP3(num_pos_pics, 0, (MAX_DPB_SIZE - 1 - num_neg_pics)); 518 num_pics = num_neg_pics + num_pos_pics; 519 520 ps_stref_picset->i1_num_ref_idc = 521 ps_stref_picset_ref->i1_num_delta_pocs + 1; 522 ps_stref_picset->i1_num_delta_pocs = num_pics; 523 ps_stref_picset->i1_num_pos_pics = num_pos_pics; 524 ps_stref_picset->i1_num_neg_pics = num_neg_pics; 525 526 527 for(j = 1; j < num_pics; j++) 528 { 529 WORD32 delta_poc = ps_stref_picset->ai2_delta_poc[j]; 530 WORD8 i1_used = ps_stref_picset->ai1_used[j]; 531 for(k = j - 1; k >= 0; k--) 532 { 533 temp = ps_stref_picset->ai2_delta_poc[k]; 534 if(delta_poc < temp) 535 { 536 ps_stref_picset->ai2_delta_poc[k + 1] = temp; 537 ps_stref_picset->ai1_used[k + 1] = ps_stref_picset->ai1_used[k]; 538 ps_stref_picset->ai2_delta_poc[k] = delta_poc; 539 ps_stref_picset->ai1_used[k] = i1_used; 540 } 541 } 542 } 543 // flip the negative values to largest first 544 for(j = 0, k = num_neg_pics - 1; j < num_neg_pics >> 1; j++, k--) 545 { 546 WORD32 delta_poc = ps_stref_picset->ai2_delta_poc[j]; 547 WORD8 i1_used = ps_stref_picset->ai1_used[j]; 548 ps_stref_picset->ai2_delta_poc[j] = ps_stref_picset->ai2_delta_poc[k]; 549 ps_stref_picset->ai1_used[j] = ps_stref_picset->ai1_used[k]; 550 ps_stref_picset->ai2_delta_poc[k] = delta_poc; 551 ps_stref_picset->ai1_used[k] = i1_used; 552 } 553 554 } 555 else 556 { 557 WORD32 prev_poc = 0; 558 WORD32 poc; 559 560 UEV_PARSE("num_negative_pics", value, ps_bitstrm); 561 if(value > MAX_DPB_SIZE - 1) 562 { 563 return IHEVCD_INVALID_PARAMETER; 564 } 565 ps_stref_picset->i1_num_neg_pics = value; 566 567 UEV_PARSE("num_positive_pics", value, ps_bitstrm); 568 if(value > (MAX_DPB_SIZE - 1 - ps_stref_picset->i1_num_neg_pics)) 569 { 570 return IHEVCD_INVALID_PARAMETER; 571 } 572 ps_stref_picset->i1_num_pos_pics = value; 573 574 ps_stref_picset->i1_num_delta_pocs = 575 ps_stref_picset->i1_num_neg_pics + 576 ps_stref_picset->i1_num_pos_pics; 577 578 579 for(i = 0; i < ps_stref_picset->i1_num_neg_pics; i++) 580 { 581 UEV_PARSE("delta_poc_s0_minus1", value, ps_bitstrm); 582 if(value > 32767) 583 { 584 return IHEVCD_INVALID_PARAMETER; 585 } 586 poc = prev_poc - ((WORD32)(value + 1)); 587 prev_poc = poc; 588 ps_stref_picset->ai2_delta_poc[i] = poc; 589 590 BITS_PARSE("used_by_curr_pic_s0_flag", value, ps_bitstrm, 1); 591 ps_stref_picset->ai1_used[i] = value; 592 593 } 594 prev_poc = 0; 595 for(i = ps_stref_picset->i1_num_neg_pics; 596 i < ps_stref_picset->i1_num_delta_pocs; 597 i++) 598 { 599 UEV_PARSE("delta_poc_s1_minus1", value, ps_bitstrm); 600 if(value > 32767) 601 { 602 return IHEVCD_INVALID_PARAMETER; 603 } 604 poc = prev_poc + (value + 1); 605 prev_poc = poc; 606 ps_stref_picset->ai2_delta_poc[i] = poc; 607 608 BITS_PARSE("used_by_curr_pic_s1_flag", value, ps_bitstrm, 1); 609 ps_stref_picset->ai1_used[i] = value; 610 611 } 612 613 } 614 615 return ret; 616 } 617 618 619 static WORD32 ihevcd_parse_sub_layer_hrd_parameters(bitstrm_t *ps_bitstrm, 620 sub_lyr_hrd_params_t *ps_sub_layer_hrd_params, 621 WORD32 cpb_cnt, 622 WORD32 sub_pic_cpb_params_present_flag) 623 { 624 WORD32 ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 625 WORD32 i; 626 627 for(i = 0; i <= cpb_cnt; i++) 628 { 629 UEV_PARSE("bit_rate_value_minus1[ i ]", ps_sub_layer_hrd_params->au4_bit_rate_value_minus1[i], ps_bitstrm); 630 if(ps_sub_layer_hrd_params->au4_bit_rate_value_minus1[i] > UINT_MAX - 1) 631 { 632 return IHEVCD_INVALID_PARAMETER; 633 } 634 UEV_PARSE("cpb_size_value_minus1[ i ]", ps_sub_layer_hrd_params->au4_cpb_size_value_minus1[i], ps_bitstrm); 635 if(ps_sub_layer_hrd_params->au4_cpb_size_value_minus1[i] > UINT_MAX - 1) 636 { 637 return IHEVCD_INVALID_PARAMETER; 638 } 639 if(sub_pic_cpb_params_present_flag) 640 { 641 UEV_PARSE("cpb_size_du_value_minus1[ i ]", ps_sub_layer_hrd_params->au4_cpb_size_du_value_minus1[i], ps_bitstrm); 642 if(ps_sub_layer_hrd_params->au4_cpb_size_du_value_minus1[i] > UINT_MAX - 1) 643 { 644 return IHEVCD_INVALID_PARAMETER; 645 } 646 UEV_PARSE("bit_rate_du_value_minus1[ i ]", ps_sub_layer_hrd_params->au4_bit_rate_du_value_minus1[i], ps_bitstrm); 647 if(ps_sub_layer_hrd_params->au4_bit_rate_du_value_minus1[i] > UINT_MAX - 1) 648 { 649 return IHEVCD_INVALID_PARAMETER; 650 } 651 } 652 BITS_PARSE("cbr_flag[ i ]", ps_sub_layer_hrd_params->au1_cbr_flag[i], ps_bitstrm, 1); 653 } 654 655 return ret; 656 } 657 658 659 static WORD32 ihevcd_parse_hrd_parameters(bitstrm_t *ps_bitstrm, 660 hrd_params_t *ps_hrd, 661 WORD32 common_info_present_flag, 662 WORD32 max_num_sub_layers_minus1) 663 { 664 WORD32 ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 665 WORD32 i; 666 667 ps_hrd->u1_nal_hrd_parameters_present_flag = 0; 668 ps_hrd->u1_vcl_hrd_parameters_present_flag = 0; 669 670 ps_hrd->u1_sub_pic_cpb_params_present_flag = 0; 671 672 ps_hrd->u1_tick_divisor_minus2 = 0; 673 ps_hrd->u1_du_cpb_removal_delay_increment_length_minus1 = 0; 674 ps_hrd->u1_sub_pic_cpb_params_in_pic_timing_sei_flag = 0; 675 ps_hrd->u1_dpb_output_delay_du_length_minus1 = 0; 676 677 ps_hrd->u4_bit_rate_scale = 0; 678 ps_hrd->u4_cpb_size_scale = 0; 679 ps_hrd->u4_cpb_size_du_scale = 0; 680 681 ps_hrd->u1_initial_cpb_removal_delay_length_minus1 = 23; 682 ps_hrd->u1_au_cpb_removal_delay_length_minus1 = 23; 683 ps_hrd->u1_dpb_output_delay_length_minus1 = 23; 684 685 if(common_info_present_flag) 686 { 687 BITS_PARSE("nal_hrd_parameters_present_flag", ps_hrd->u1_nal_hrd_parameters_present_flag, ps_bitstrm, 1); 688 BITS_PARSE("vcl_hrd_parameters_present_flag", ps_hrd->u1_vcl_hrd_parameters_present_flag, ps_bitstrm, 1); 689 690 if(ps_hrd->u1_nal_hrd_parameters_present_flag || ps_hrd->u1_vcl_hrd_parameters_present_flag) 691 { 692 BITS_PARSE("sub_pic_cpb_params_present_flag", ps_hrd->u1_sub_pic_cpb_params_present_flag, ps_bitstrm, 1); 693 if(ps_hrd->u1_sub_pic_cpb_params_present_flag) 694 { 695 BITS_PARSE("tick_divisor_minus2", ps_hrd->u1_tick_divisor_minus2, ps_bitstrm, 8); 696 BITS_PARSE("du_cpb_removal_delay_increment_length_minus1", ps_hrd->u1_du_cpb_removal_delay_increment_length_minus1, ps_bitstrm, 5); 697 BITS_PARSE("sub_pic_cpb_params_in_pic_timing_sei_flag", ps_hrd->u1_sub_pic_cpb_params_in_pic_timing_sei_flag, ps_bitstrm, 1); 698 BITS_PARSE("dpb_output_delay_du_length_minus1", ps_hrd->u1_dpb_output_delay_du_length_minus1, ps_bitstrm, 5); 699 } 700 701 BITS_PARSE("bit_rate_scale", ps_hrd->u4_bit_rate_scale, ps_bitstrm, 4); 702 BITS_PARSE("cpb_size_scale", ps_hrd->u4_cpb_size_scale, ps_bitstrm, 4); 703 if(ps_hrd->u1_sub_pic_cpb_params_present_flag) 704 BITS_PARSE("cpb_size_du_scale", ps_hrd->u4_cpb_size_du_scale, ps_bitstrm, 4); 705 706 BITS_PARSE("initial_cpb_removal_delay_length_minus1", ps_hrd->u1_initial_cpb_removal_delay_length_minus1, ps_bitstrm, 5); 707 BITS_PARSE("au_cpb_removal_delay_length_minus1", ps_hrd->u1_au_cpb_removal_delay_length_minus1, ps_bitstrm, 5); 708 BITS_PARSE("dpb_output_delay_length_minus1", ps_hrd->u1_dpb_output_delay_length_minus1, ps_bitstrm, 5); 709 } 710 } 711 712 713 for(i = 0; i <= max_num_sub_layers_minus1; i++) 714 { 715 BITS_PARSE("fixed_pic_rate_general_flag[ i ]", ps_hrd->au1_fixed_pic_rate_general_flag[i], ps_bitstrm, 1); 716 717 ps_hrd->au1_fixed_pic_rate_within_cvs_flag[i] = 1; 718 ps_hrd->au2_elemental_duration_in_tc_minus1[i] = 0; 719 ps_hrd->au1_low_delay_hrd_flag[i] = 0; 720 ps_hrd->au1_cpb_cnt_minus1[i] = 0; 721 722 if(!ps_hrd->au1_fixed_pic_rate_general_flag[i]) 723 BITS_PARSE("fixed_pic_rate_within_cvs_flag[ i ]", ps_hrd->au1_fixed_pic_rate_within_cvs_flag[i], ps_bitstrm, 1); 724 725 if(ps_hrd->au1_fixed_pic_rate_within_cvs_flag[i]) 726 { 727 UEV_PARSE("elemental_duration_in_tc_minus1[ i ]", ps_hrd->au2_elemental_duration_in_tc_minus1[i], ps_bitstrm); 728 if(ps_hrd->au2_elemental_duration_in_tc_minus1[i] > 2047) 729 { 730 return IHEVCD_INVALID_PARAMETER; 731 } 732 } 733 else 734 { 735 BITS_PARSE("low_delay_hrd_flag[ i ]", ps_hrd->au1_low_delay_hrd_flag[i], ps_bitstrm, 1); 736 } 737 738 if(!ps_hrd->au1_low_delay_hrd_flag[i]) 739 { 740 UEV_PARSE("cpb_cnt_minus1[ i ]", ps_hrd->au1_cpb_cnt_minus1[i], ps_bitstrm); 741 if(ps_hrd->au1_cpb_cnt_minus1[i] > (MAX_CPB_CNT - 1)) 742 { 743 return IHEVCD_INVALID_PARAMETER; 744 } 745 } 746 747 if(ps_hrd->u1_nal_hrd_parameters_present_flag) 748 ihevcd_parse_sub_layer_hrd_parameters(ps_bitstrm, 749 &ps_hrd->as_sub_layer_hrd_params[i], 750 ps_hrd->au1_cpb_cnt_minus1[i], 751 ps_hrd->u1_sub_pic_cpb_params_present_flag); 752 753 if(ps_hrd->u1_vcl_hrd_parameters_present_flag) 754 ihevcd_parse_sub_layer_hrd_parameters(ps_bitstrm, 755 &ps_hrd->as_sub_layer_hrd_params[i], 756 ps_hrd->au1_cpb_cnt_minus1[i], 757 ps_hrd->u1_sub_pic_cpb_params_present_flag); 758 } 759 760 return ret; 761 } 762 763 764 static WORD32 ihevcd_parse_vui_parameters(bitstrm_t *ps_bitstrm, 765 vui_t *ps_vui, 766 WORD32 sps_max_sub_layers_minus1) 767 { 768 WORD32 ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 769 UWORD16 u2_sar_width = 0; 770 UWORD16 u2_sar_height = 0; 771 772 BITS_PARSE("aspect_ratio_info_present_flag", ps_vui->u1_aspect_ratio_info_present_flag, ps_bitstrm, 1); 773 774 ps_vui->u1_aspect_ratio_idc = SAR_UNUSED; 775 u2_sar_width = 0; 776 u2_sar_height = 0; 777 if(ps_vui->u1_aspect_ratio_info_present_flag) 778 { 779 BITS_PARSE("aspect_ratio_idc", ps_vui->u1_aspect_ratio_idc, ps_bitstrm, 8); 780 switch(ps_vui->u1_aspect_ratio_idc) 781 { 782 case SAR_1_1: 783 u2_sar_width = 1; 784 u2_sar_height = 1; 785 break; 786 case SAR_12_11: 787 u2_sar_width = 12; 788 u2_sar_height = 11; 789 break; 790 case SAR_10_11: 791 u2_sar_width = 10; 792 u2_sar_height = 11; 793 break; 794 case SAR_16_11: 795 u2_sar_width = 16; 796 u2_sar_height = 11; 797 break; 798 case SAR_40_33: 799 u2_sar_width = 40; 800 u2_sar_height = 33; 801 break; 802 case SAR_24_11: 803 u2_sar_width = 24; 804 u2_sar_height = 11; 805 break; 806 case SAR_20_11: 807 u2_sar_width = 20; 808 u2_sar_height = 11; 809 break; 810 case SAR_32_11: 811 u2_sar_width = 32; 812 u2_sar_height = 11; 813 break; 814 case SAR_80_33: 815 u2_sar_width = 80; 816 u2_sar_height = 33; 817 break; 818 case SAR_18_11: 819 u2_sar_width = 18; 820 u2_sar_height = 11; 821 break; 822 case SAR_15_11: 823 u2_sar_width = 15; 824 u2_sar_height = 11; 825 break; 826 case SAR_64_33: 827 u2_sar_width = 64; 828 u2_sar_height = 33; 829 break; 830 case SAR_160_99: 831 u2_sar_width = 160; 832 u2_sar_height = 99; 833 break; 834 case SAR_4_3: 835 u2_sar_width = 4; 836 u2_sar_height = 3; 837 break; 838 case SAR_3_2: 839 u2_sar_width = 3; 840 u2_sar_height = 2; 841 break; 842 case SAR_2_1: 843 u2_sar_width = 2; 844 u2_sar_height = 1; 845 break; 846 case EXTENDED_SAR: 847 BITS_PARSE("sar_width", u2_sar_width, ps_bitstrm, 16); 848 BITS_PARSE("sar_height", u2_sar_height, ps_bitstrm, 16); 849 break; 850 default: 851 u2_sar_width = 0; 852 u2_sar_height = 0; 853 break; 854 } 855 } 856 857 ps_vui->u2_sar_width = u2_sar_width; 858 ps_vui->u2_sar_height = u2_sar_height; 859 860 BITS_PARSE("overscan_info_present_flag", ps_vui->u1_overscan_info_present_flag, ps_bitstrm, 1); 861 ps_vui->u1_overscan_appropriate_flag = 0; 862 if(ps_vui->u1_overscan_info_present_flag) 863 BITS_PARSE("overscan_appropriate_flag", ps_vui->u1_overscan_appropriate_flag, ps_bitstrm, 1); 864 865 BITS_PARSE("video_signal_type_present_flag", ps_vui->u1_video_signal_type_present_flag, ps_bitstrm, 1); 866 ps_vui->u1_video_format = VID_FMT_UNSPECIFIED; 867 ps_vui->u1_video_full_range_flag = 0; 868 ps_vui->u1_colour_description_present_flag = 0; 869 ps_vui->u1_colour_primaries = 2; 870 ps_vui->u1_transfer_characteristics = 2; 871 ps_vui->u1_matrix_coefficients = 2; 872 873 if(ps_vui->u1_video_signal_type_present_flag) 874 { 875 BITS_PARSE("video_format", ps_vui->u1_video_format, ps_bitstrm, 3); 876 BITS_PARSE("video_full_range_flag", ps_vui->u1_video_full_range_flag, ps_bitstrm, 1); 877 BITS_PARSE("colour_description_present_flag", ps_vui->u1_colour_description_present_flag, ps_bitstrm, 1); 878 if(ps_vui->u1_colour_description_present_flag) 879 { 880 BITS_PARSE("colour_primaries", ps_vui->u1_colour_primaries, ps_bitstrm, 8); 881 BITS_PARSE("transfer_characteristics", ps_vui->u1_transfer_characteristics, ps_bitstrm, 8); 882 BITS_PARSE("matrix_coeffs", ps_vui->u1_matrix_coefficients, ps_bitstrm, 8); 883 } 884 } 885 886 BITS_PARSE("chroma_loc_info_present_flag", ps_vui->u1_chroma_loc_info_present_flag, ps_bitstrm, 1); 887 ps_vui->u1_chroma_sample_loc_type_top_field = 0; 888 ps_vui->u1_chroma_sample_loc_type_bottom_field = 0; 889 if(ps_vui->u1_chroma_loc_info_present_flag) 890 { 891 UEV_PARSE("chroma_sample_loc_type_top_field", ps_vui->u1_chroma_sample_loc_type_top_field, ps_bitstrm); 892 if(ps_vui->u1_chroma_sample_loc_type_top_field > CHROMA_FMT_IDC_YUV444_PLANES + 1) 893 { 894 return IHEVCD_INVALID_PARAMETER; 895 } 896 UEV_PARSE("chroma_sample_loc_type_bottom_field", ps_vui->u1_chroma_sample_loc_type_bottom_field, ps_bitstrm); 897 if(ps_vui->u1_chroma_sample_loc_type_bottom_field > CHROMA_FMT_IDC_YUV444_PLANES + 1) 898 { 899 return IHEVCD_INVALID_PARAMETER; 900 } 901 } 902 903 BITS_PARSE("neutral_chroma_indication_flag", ps_vui->u1_neutral_chroma_indication_flag, ps_bitstrm, 1); 904 BITS_PARSE("field_seq_flag", ps_vui->u1_field_seq_flag, ps_bitstrm, 1); 905 BITS_PARSE("frame_field_info_present_flag", ps_vui->u1_frame_field_info_present_flag, ps_bitstrm, 1); 906 BITS_PARSE("default_display_window_flag", ps_vui->u1_default_display_window_flag, ps_bitstrm, 1); 907 ps_vui->u4_def_disp_win_left_offset = 0; 908 ps_vui->u4_def_disp_win_right_offset = 0; 909 ps_vui->u4_def_disp_win_top_offset = 0; 910 ps_vui->u4_def_disp_win_bottom_offset = 0; 911 if(ps_vui->u1_default_display_window_flag) 912 { 913 UEV_PARSE("def_disp_win_left_offset", ps_vui->u4_def_disp_win_left_offset, ps_bitstrm); 914 UEV_PARSE("def_disp_win_right_offset", ps_vui->u4_def_disp_win_right_offset, ps_bitstrm); 915 UEV_PARSE("def_disp_win_top_offset", ps_vui->u4_def_disp_win_top_offset, ps_bitstrm); 916 UEV_PARSE("def_disp_win_bottom_offset", ps_vui->u4_def_disp_win_bottom_offset, ps_bitstrm); 917 } 918 919 BITS_PARSE("vui_timing_info_present_flag", ps_vui->u1_vui_timing_info_present_flag, ps_bitstrm, 1); 920 if(ps_vui->u1_vui_timing_info_present_flag) 921 { 922 BITS_PARSE("vui_num_units_in_tick", ps_vui->u4_vui_num_units_in_tick, ps_bitstrm, 32); 923 BITS_PARSE("vui_time_scale", ps_vui->u4_vui_time_scale, ps_bitstrm, 32); 924 BITS_PARSE("vui_poc_proportional_to_timing_flag", ps_vui->u1_poc_proportional_to_timing_flag, ps_bitstrm, 1); 925 if(ps_vui->u1_poc_proportional_to_timing_flag) 926 { 927 UEV_PARSE("vui_num_ticks_poc_diff_one_minus1", ps_vui->u4_num_ticks_poc_diff_one_minus1, ps_bitstrm); 928 if(ps_vui->u4_num_ticks_poc_diff_one_minus1 > UINT_MAX - 1) 929 { 930 return IHEVCD_INVALID_PARAMETER; 931 } 932 } 933 BITS_PARSE("vui_hrd_parameters_present_flag", ps_vui->u1_vui_hrd_parameters_present_flag, ps_bitstrm, 1); 934 if(ps_vui->u1_vui_hrd_parameters_present_flag) 935 { 936 ret = ihevcd_parse_hrd_parameters(ps_bitstrm, &ps_vui->s_vui_hrd_parameters, 1, sps_max_sub_layers_minus1); 937 RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret); 938 } 939 } 940 941 BITS_PARSE("bitstream_restriction_flag", ps_vui->u1_bitstream_restriction_flag, ps_bitstrm, 1); 942 ps_vui->u1_tiles_fixed_structure_flag = 0; 943 ps_vui->u1_motion_vectors_over_pic_boundaries_flag = 1; 944 ps_vui->u1_restricted_ref_pic_lists_flag = 0; 945 ps_vui->u4_min_spatial_segmentation_idc = 0; 946 ps_vui->u1_max_bytes_per_pic_denom = 2; 947 ps_vui->u1_max_bits_per_mincu_denom = 1; 948 ps_vui->u1_log2_max_mv_length_horizontal = 15; 949 ps_vui->u1_log2_max_mv_length_vertical = 15; 950 if(ps_vui->u1_bitstream_restriction_flag) 951 { 952 BITS_PARSE("tiles_fixed_structure_flag", ps_vui->u1_tiles_fixed_structure_flag, ps_bitstrm, 1); 953 BITS_PARSE("motion_vectors_over_pic_boundaries_flag", ps_vui->u1_motion_vectors_over_pic_boundaries_flag, ps_bitstrm, 1); 954 BITS_PARSE("restricted_ref_pic_lists_flag", ps_vui->u1_restricted_ref_pic_lists_flag, ps_bitstrm, 1); 955 956 UEV_PARSE("min_spatial_segmentation_idc", ps_vui->u4_min_spatial_segmentation_idc, ps_bitstrm); 957 if(ps_vui->u4_min_spatial_segmentation_idc > 4095) 958 { 959 return IHEVCD_INVALID_PARAMETER; 960 } 961 UEV_PARSE("max_bytes_per_pic_denom", ps_vui->u1_max_bytes_per_pic_denom, ps_bitstrm); 962 if(ps_vui->u1_max_bytes_per_pic_denom > 16) 963 { 964 return IHEVCD_INVALID_PARAMETER; 965 } 966 UEV_PARSE("max_bits_per_min_cu_denom", ps_vui->u1_max_bits_per_mincu_denom, ps_bitstrm); 967 if(ps_vui->u1_max_bits_per_mincu_denom > 16) 968 { 969 return IHEVCD_INVALID_PARAMETER; 970 } 971 UEV_PARSE("log2_max_mv_length_horizontal", ps_vui->u1_log2_max_mv_length_horizontal, ps_bitstrm); 972 if(ps_vui->u1_max_bits_per_mincu_denom > 16) 973 { 974 return IHEVCD_INVALID_PARAMETER; 975 } 976 UEV_PARSE("log2_max_mv_length_vertical", ps_vui->u1_log2_max_mv_length_vertical, ps_bitstrm); 977 if(ps_vui->u1_max_bits_per_mincu_denom > 15) 978 { 979 return IHEVCD_INVALID_PARAMETER; 980 } 981 } 982 983 return ret; 984 } 985 986 /** 987 ******************************************************************************* 988 * 989 * @brief 990 * Parses profile tier and level info for either general layer of sub_layer 991 * 992 * @par Description 993 * Parses profile tier and level info for either general layer of sub_layer 994 * as per section 7.3.3 995 * 996 * Since the same function is called for parsing general_profile and 997 * sub_layer_profile etc, variables do not specify whether the syntax is 998 * for general or sub_layer. Similarly trace functions also do not differentiate 999 * 1000 * @param[in] ps_bitstrm 1001 * Pointer to bitstream structure 1002 * 1003 * @param[out] ps_ptl 1004 * Pointer to profile, tier level structure 1005 * 1006 * @returns Error code from IHEVCD_ERROR_T 1007 * 1008 * @remarks 1009 * 1010 ******************************************************************************* 1011 */ 1012 1013 static IHEVCD_ERROR_T ihevcd_parse_profile_tier_level_layer(bitstrm_t *ps_bitstrm, 1014 profile_tier_lvl_t *ps_ptl) 1015 { 1016 WORD32 value; 1017 WORD32 i; 1018 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 1019 1020 BITS_PARSE("XXX_profile_space[]", value, ps_bitstrm, 2); 1021 ps_ptl->i1_profile_space = value; 1022 1023 BITS_PARSE("XXX_tier_flag[]", value, ps_bitstrm, 1); 1024 ps_ptl->i1_tier_flag = value; 1025 1026 BITS_PARSE("XXX_profile_idc[]", value, ps_bitstrm, 5); 1027 ps_ptl->i1_profile_idc = value; 1028 1029 for(i = 0; i < MAX_PROFILE_COMPATBLTY; i++) 1030 { 1031 BITS_PARSE("XXX_profile_compatibility_flag[][j]", value, ps_bitstrm, 1); 1032 ps_ptl->ai1_profile_compatibility_flag[i] = value; 1033 } 1034 1035 BITS_PARSE("general_progressive_source_flag", value, ps_bitstrm, 1); 1036 ps_ptl->i1_general_progressive_source_flag = value; 1037 1038 BITS_PARSE("general_interlaced_source_flag", value, ps_bitstrm, 1); 1039 ps_ptl->i1_general_interlaced_source_flag = value; 1040 1041 BITS_PARSE("general_non_packed_constraint_flag", value, ps_bitstrm, 1); 1042 ps_ptl->i1_general_non_packed_constraint_flag = value; 1043 1044 BITS_PARSE("general_frame_only_constraint_flag", value, ps_bitstrm, 1); 1045 ps_ptl->i1_frame_only_constraint_flag = value; 1046 1047 BITS_PARSE("XXX_reserved_zero_44bits[0..15]", value, ps_bitstrm, 16); 1048 1049 BITS_PARSE("XXX_reserved_zero_44bits[16..31]", value, ps_bitstrm, 16); 1050 1051 BITS_PARSE("XXX_reserved_zero_44bits[32..43]", value, ps_bitstrm, 12); 1052 return ret; 1053 } 1054 1055 1056 /** 1057 ******************************************************************************* 1058 * 1059 * @brief 1060 * Parses profile tier and level info 1061 * 1062 * @par Description 1063 * Parses profile tier and level info as per section 7.3.3 1064 * Called during VPS and SPS parsing 1065 * calls ihevcd_parse_profile_tier_level() for general layer and each sub_layers 1066 * 1067 * @param[in] ps_bitstrm 1068 * Pointer to bitstream structure 1069 * 1070 * @param[out] ps_ptl 1071 * Pointer to structure that contains profile, tier level for each layers 1072 * 1073 * @param[in] profile_present 1074 * Flag to indicate if profile data is present 1075 * 1076 * @param[in] max_num_sub_layers 1077 * Number of sub layers present 1078 * 1079 * @returns Error code from IHEVCD_ERROR_T 1080 * 1081 * @remarks 1082 * 1083 ******************************************************************************* 1084 */ 1085 1086 static IHEVCD_ERROR_T ihevcd_profile_tier_level(bitstrm_t *ps_bitstrm, 1087 profile_tier_lvl_info_t *ps_ptl, 1088 WORD32 profile_present, 1089 WORD32 max_num_sub_layers) 1090 { 1091 WORD32 value; 1092 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 1093 WORD32 i; 1094 1095 if(profile_present) 1096 { 1097 ret = ihevcd_parse_profile_tier_level_layer(ps_bitstrm, &ps_ptl->s_ptl_gen); 1098 if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret) 1099 { 1100 return ret; 1101 } 1102 } 1103 1104 BITS_PARSE("general_level_idc", value, ps_bitstrm, 8); 1105 ps_ptl->s_ptl_gen.u1_level_idc = value; 1106 1107 1108 for(i = 0; i < max_num_sub_layers; i++) 1109 { 1110 BITS_PARSE("sub_layer_profile_present_flag[i]", value, ps_bitstrm, 1); 1111 ps_ptl->ai1_sub_layer_profile_present_flag[i] = value; 1112 1113 BITS_PARSE("sub_layer_level_present_flag[i]", value, ps_bitstrm, 1); 1114 ps_ptl->ai1_sub_layer_level_present_flag[i] = value; 1115 } 1116 1117 if(max_num_sub_layers > 0) 1118 { 1119 for(i = max_num_sub_layers; i < 8; i++) 1120 { 1121 BITS_PARSE("reserved_zero_2bits", value, ps_bitstrm, 2); 1122 } 1123 } 1124 1125 for(i = 0; i < max_num_sub_layers; i++) 1126 { 1127 if(ps_ptl->ai1_sub_layer_profile_present_flag[i]) 1128 { 1129 ret = ihevcd_parse_profile_tier_level_layer(ps_bitstrm, 1130 &ps_ptl->as_ptl_sub[i]); 1131 } 1132 if(ps_ptl->ai1_sub_layer_level_present_flag[i]) 1133 { 1134 BITS_PARSE("sub_layer_level_idc[i]", value, ps_bitstrm, 8); 1135 ps_ptl->as_ptl_sub[i].u1_level_idc = value; 1136 1137 } 1138 } 1139 1140 1141 1142 return ret; 1143 } 1144 1145 /** 1146 ******************************************************************************* 1147 * 1148 * @brief 1149 * Parses Scaling List Data syntax 1150 * 1151 * @par Description: 1152 * Parses Scaling List Data syntax as per Section: 7.3.6 1153 * 1154 * @param[in] ps_codec 1155 * Pointer to codec context 1156 * 1157 * @returns Error code from IHEVCD_ERROR_T 1158 * 1159 * @remarks 1160 * 1161 * 1162 ******************************************************************************* 1163 */ 1164 IHEVCD_ERROR_T ihevcd_scaling_list_data(codec_t *ps_codec, WORD16 *pi2_scaling_mat) 1165 { 1166 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 1167 WORD32 size_id; 1168 WORD32 matrix_id; 1169 WORD32 value, dc_value = 0; 1170 UWORD32 u4_value; 1171 WORD32 next_coef; 1172 WORD32 coef_num; 1173 WORD32 i, j, offset; 1174 bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm; 1175 WORD16 *pi2_scaling_mat_offset; 1176 WORD32 scaling_mat_offset[] = { 0, 16, 32, 48, 64, 80, 96, 160, 224, 288, 352, 416, 480, 736, 992, 1248, 1504, 1760, 2016, 3040 }; 1177 UWORD8 *scan_table; 1178 1179 for(size_id = 0; size_id < 4; size_id++) 1180 { 1181 for(matrix_id = 0; matrix_id < ((size_id == 3) ? 2 : 6); matrix_id++) 1182 { 1183 WORD32 scaling_list_pred_mode_flag; 1184 WORD32 scaling_list_delta_coef; 1185 BITS_PARSE("scaling_list_pred_mode_flag", scaling_list_pred_mode_flag, ps_bitstrm, 1); 1186 1187 offset = size_id * 6 + matrix_id; 1188 pi2_scaling_mat_offset = pi2_scaling_mat + scaling_mat_offset[offset]; 1189 1190 if(!scaling_list_pred_mode_flag) 1191 { 1192 WORD32 num_elements; 1193 UEV_PARSE("scaling_list_pred_matrix_id_delta", u4_value, 1194 ps_bitstrm); 1195 if(u4_value > matrix_id) 1196 { 1197 return IHEVCD_INVALID_PARAMETER; 1198 } 1199 1200 num_elements = (1 << (4 + (size_id << 1))); 1201 if(0 != u4_value) 1202 memmove(pi2_scaling_mat_offset, pi2_scaling_mat_offset - u4_value * num_elements, num_elements * sizeof(WORD16)); 1203 } 1204 else 1205 { 1206 next_coef = 8; 1207 coef_num = MIN(64, (1 << (4 + (size_id << 1)))); 1208 1209 if(size_id > 1) 1210 { 1211 SEV_PARSE("scaling_list_dc_coef_minus8", value, 1212 ps_bitstrm); 1213 if(value < -7 || value > 247) 1214 { 1215 return IHEVCD_INVALID_PARAMETER; 1216 } 1217 next_coef = value + 8; 1218 dc_value = next_coef; 1219 } 1220 if(size_id < 2) 1221 { 1222 scan_table = (UWORD8 *)gapv_ihevc_invscan[size_id + 1]; 1223 1224 for(i = 0; i < coef_num; i++) 1225 { 1226 SEV_PARSE("scaling_list_delta_coef", 1227 scaling_list_delta_coef, ps_bitstrm); 1228 if((scaling_list_delta_coef < -256) || (scaling_list_delta_coef > 255)) 1229 { 1230 return IHEVCD_INVALID_PARAMETER; 1231 } 1232 next_coef = (next_coef + scaling_list_delta_coef + 256) 1233 % 256; 1234 pi2_scaling_mat_offset[scan_table[i]] = next_coef; 1235 } 1236 } 1237 else if(size_id == 2) 1238 { 1239 scan_table = (UWORD8 *)gapv_ihevc_invscan[2]; 1240 1241 for(i = 0; i < coef_num; i++) 1242 { 1243 SEV_PARSE("scaling_list_delta_coef", 1244 scaling_list_delta_coef, ps_bitstrm); 1245 if((scaling_list_delta_coef < -256) || (scaling_list_delta_coef > 255)) 1246 { 1247 return IHEVCD_INVALID_PARAMETER; 1248 } 1249 next_coef = (next_coef + scaling_list_delta_coef + 256) 1250 % 256; 1251 1252 offset = scan_table[i]; 1253 offset = (offset >> 3) * 16 * 2 + (offset & 0x7) * 2; 1254 pi2_scaling_mat_offset[offset] = next_coef; 1255 pi2_scaling_mat_offset[offset + 1] = next_coef; 1256 pi2_scaling_mat_offset[offset + 16] = next_coef; 1257 pi2_scaling_mat_offset[offset + 16 + 1] = next_coef; 1258 } 1259 pi2_scaling_mat_offset[0] = dc_value; 1260 } 1261 else 1262 { 1263 scan_table = (UWORD8 *)gapv_ihevc_invscan[2]; 1264 1265 for(i = 0; i < coef_num; i++) 1266 { 1267 SEV_PARSE("scaling_list_delta_coef", 1268 scaling_list_delta_coef, ps_bitstrm); 1269 if((scaling_list_delta_coef < -256) || (scaling_list_delta_coef > 255)) 1270 { 1271 return IHEVCD_INVALID_PARAMETER; 1272 } 1273 next_coef = (next_coef + scaling_list_delta_coef + 256) 1274 % 256; 1275 1276 offset = scan_table[i]; 1277 offset = (offset >> 3) * 32 * 4 + (offset & 0x7) * 4; 1278 1279 for(j = 0; j < 4; j++) 1280 { 1281 pi2_scaling_mat_offset[offset + j * 32] = next_coef; 1282 pi2_scaling_mat_offset[offset + 1 + j * 32] = next_coef; 1283 pi2_scaling_mat_offset[offset + 2 + j * 32] = next_coef; 1284 pi2_scaling_mat_offset[offset + 3 + j * 32] = next_coef; 1285 } 1286 pi2_scaling_mat_offset[0] = dc_value; 1287 } 1288 } 1289 } 1290 } 1291 } 1292 1293 return ret; 1294 } 1295 1296 /** 1297 ******************************************************************************* 1298 * 1299 * @brief 1300 * Parses VPS (Video Parameter Set) 1301 * 1302 * @par Description: 1303 * Parse Video Parameter Set as per Section 7.3.2.1 1304 * update vps structure corresponding to vps ID 1305 * Till parsing VPS id, the elements are stored in local variables and are copied 1306 * later 1307 * 1308 * @param[in] ps_codec 1309 * Pointer to codec context. 1310 * 1311 * @returns Error code from IHEVCD_ERROR_T 1312 * 1313 * @remarks 1314 * 1315 * 1316 ******************************************************************************* 1317 */ 1318 IHEVCD_ERROR_T ihevcd_parse_vps(codec_t *ps_codec) 1319 { 1320 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 1321 WORD32 i; 1322 UWORD32 value; 1323 WORD32 vps_id; 1324 vps_t *ps_vps; 1325 bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm; 1326 BITS_PARSE("vps_video_parameter_set_id", value, ps_bitstrm, 4); 1327 vps_id = value; 1328 1329 if(vps_id >= MAX_VPS_CNT) 1330 { 1331 ps_codec->s_parse.i4_error_code = IHEVCD_UNSUPPORTED_VPS_ID; 1332 return IHEVCD_UNSUPPORTED_VPS_ID; 1333 } 1334 1335 1336 ps_vps = (ps_codec->s_parse.ps_vps_base + vps_id); 1337 1338 ps_vps->i1_vps_id = vps_id; 1339 1340 BITS_PARSE("vps_reserved_three_2bits", value, ps_bitstrm, 2); 1341 ASSERT(value == 3); 1342 1343 BITS_PARSE("vps_max_layers_minus1", value, ps_bitstrm, 6); 1344 //ps_vps->i1_vps_max_layers = value + 1; 1345 1346 1347 1348 BITS_PARSE("vps_max_sub_layers_minus1", value, ps_bitstrm, 3); 1349 if(value > SPS_MAX_SUB_LAYERS - 1) 1350 { 1351 return IHEVCD_INVALID_PARAMETER; 1352 } 1353 ps_vps->i1_vps_max_sub_layers = value + 1; 1354 1355 ASSERT(ps_vps->i1_vps_max_sub_layers < VPS_MAX_SUB_LAYERS); 1356 1357 BITS_PARSE("vps_temporal_id_nesting_flag", value, ps_bitstrm, 1); 1358 ps_vps->i1_vps_temporal_id_nesting_flag = value; 1359 1360 BITS_PARSE("vps_reserved_ffff_16bits", value, ps_bitstrm, 16); 1361 ASSERT(value == 0xFFFF); 1362 // profile_and_level( 1, vps_max_sub_layers_minus1 ) 1363 ret = ihevcd_profile_tier_level(ps_bitstrm, &(ps_vps->s_ptl), 1364 1, (ps_vps->i1_vps_max_sub_layers - 1)); 1365 1366 BITS_PARSE("vps_sub_layer_ordering_info_present_flag", value, ps_bitstrm, 1); 1367 ps_vps->i1_sub_layer_ordering_info_present_flag = value; 1368 i = (ps_vps->i1_sub_layer_ordering_info_present_flag ? 1369 0 : (ps_vps->i1_vps_max_sub_layers - 1)); 1370 for(; i < ps_vps->i1_vps_max_sub_layers; i++) 1371 { 1372 UEV_PARSE("vps_max_dec_pic_buffering[i]", value, ps_bitstrm); 1373 if(value > MAX_DPB_SIZE) 1374 { 1375 return IHEVCD_INVALID_PARAMETER; 1376 } 1377 ps_vps->ai1_vps_max_dec_pic_buffering[i] = value; 1378 1379 /* vps_num_reorder_pics (no max) used in print in order to match with HM */ 1380 UEV_PARSE("vps_num_reorder_pics[i]", value, ps_bitstrm); 1381 if(value >= ps_vps->ai1_vps_max_dec_pic_buffering[i]) 1382 { 1383 return IHEVCD_INVALID_PARAMETER; 1384 } 1385 ps_vps->ai1_vps_max_num_reorder_pics[i] = value; 1386 1387 UEV_PARSE("vps_max_latency_increase[i]", value, ps_bitstrm); 1388 if(value > UINT_MAX - 2) 1389 { 1390 return IHEVCD_INVALID_PARAMETER; 1391 } 1392 ps_vps->ai1_vps_max_latency_increase[i] = value; 1393 } 1394 1395 1396 1397 BITS_PARSE("vps_max_layer_id", value, ps_bitstrm, 6); 1398 //ps_vps->i1_vps_max_layer_id = value; 1399 1400 UEV_PARSE("vps_num_layer_sets_minus1", value, ps_bitstrm); 1401 if(value > 1023) 1402 { 1403 return IHEVCD_INVALID_PARAMETER; 1404 } 1405 //ps_vps->i1_vps_num_layer_sets = value + 1; 1406 1407 BITS_PARSE("vps_timing_info_present_flag", value, ps_bitstrm, 1); 1408 //ps_vps->i1_vps_timing_info_present_flag = value; 1409 1410 1411 1412 return ret; 1413 } 1414 1415 /** 1416 ******************************************************************************* 1417 * 1418 * @brief 1419 * Parses SPS (Sequence Parameter Set) 1420 * sequence_parameter_set_rbsp() 1421 * 1422 * @par Description: 1423 * Parse Sequence Parameter Set as per section Section: 7.3.2.2 1424 * The sps is written to a temporary buffer and copied later to the 1425 * appropriate location 1426 * 1427 * @param[in] ps_codec 1428 * Pointer to codec context 1429 * 1430 * @returns Error code from IHEVCD_ERROR_T 1431 * 1432 * @remarks 1433 * 1434 * 1435 ******************************************************************************* 1436 */ 1437 IHEVCD_ERROR_T ihevcd_parse_sps(codec_t *ps_codec) 1438 { 1439 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 1440 UWORD32 value; 1441 1442 WORD32 i; 1443 WORD32 vps_id; 1444 WORD32 sps_max_sub_layers; 1445 WORD32 sps_id; 1446 WORD32 sps_temporal_id_nesting_flag; 1447 sps_t *ps_sps; 1448 profile_tier_lvl_info_t s_ptl; 1449 bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm; 1450 WORD32 ctb_log2_size_y = 0; 1451 1452 1453 BITS_PARSE("video_parameter_set_id", value, ps_bitstrm, 4); 1454 if(value > MAX_VPS_CNT - 1) 1455 { 1456 return IHEVCD_INVALID_PARAMETER; 1457 } 1458 vps_id = value; 1459 1460 BITS_PARSE("sps_max_sub_layers_minus1", value, ps_bitstrm, 3); 1461 if(value > SPS_MAX_SUB_LAYERS - 1) 1462 { 1463 return IHEVCD_INVALID_PARAMETER; 1464 } 1465 sps_max_sub_layers = value + 1; 1466 1467 BITS_PARSE("sps_temporal_id_nesting_flag", value, ps_bitstrm, 1); 1468 sps_temporal_id_nesting_flag = value; 1469 1470 //profile_and_level( 1, sps_max_sub_layers_minus1 ) 1471 ret = ihevcd_profile_tier_level(ps_bitstrm, &(s_ptl), 1, 1472 (sps_max_sub_layers - 1)); 1473 1474 UEV_PARSE("seq_parameter_set_id", value, ps_bitstrm); 1475 sps_id = value; 1476 if((sps_id >= MAX_SPS_CNT) || (sps_id < 0)) 1477 { 1478 if(ps_codec->i4_sps_done) 1479 return IHEVCD_UNSUPPORTED_SPS_ID; 1480 else 1481 sps_id = 0; 1482 } 1483 1484 1485 ps_sps = (ps_codec->s_parse.ps_sps_base + MAX_SPS_CNT - 1); 1486 /* Reset SPS to zero */ 1487 { 1488 WORD16 *pi2_scaling_mat = ps_sps->pi2_scaling_mat; 1489 memset(ps_sps, 0, sizeof(sps_t)); 1490 ps_sps->pi2_scaling_mat = pi2_scaling_mat; 1491 } 1492 ps_sps->i1_sps_id = sps_id; 1493 ps_sps->i1_vps_id = vps_id; 1494 ps_sps->i1_sps_max_sub_layers = sps_max_sub_layers; 1495 ps_sps->i1_sps_temporal_id_nesting_flag = sps_temporal_id_nesting_flag; 1496 1497 memcpy(&ps_sps->s_ptl, &s_ptl, sizeof(profile_tier_lvl_info_t)); 1498 1499 UEV_PARSE("chroma_format_idc", value, ps_bitstrm); 1500 if(value > 3) 1501 { 1502 return IHEVCD_INVALID_PARAMETER; 1503 } 1504 ps_sps->i1_chroma_format_idc = value; 1505 1506 if(ps_sps->i1_chroma_format_idc != CHROMA_FMT_IDC_YUV420) 1507 { 1508 ps_codec->s_parse.i4_error_code = IHEVCD_UNSUPPORTED_CHROMA_FMT_IDC; 1509 return (IHEVCD_ERROR_T)IHEVCD_UNSUPPORTED_CHROMA_FMT_IDC; 1510 } 1511 1512 if(CHROMA_FMT_IDC_YUV444_PLANES == ps_sps->i1_chroma_format_idc) 1513 { 1514 BITS_PARSE("separate_colour_plane_flag", value, ps_bitstrm, 1); 1515 ps_sps->i1_separate_colour_plane_flag = value; 1516 } 1517 else 1518 { 1519 ps_sps->i1_separate_colour_plane_flag = 0; 1520 } 1521 1522 UEV_PARSE("pic_width_in_luma_samples", value, ps_bitstrm); 1523 if(value > INT16_MAX) 1524 { 1525 return (IHEVCD_ERROR_T)IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED; 1526 } 1527 ps_sps->i2_pic_width_in_luma_samples = value; 1528 1529 UEV_PARSE("pic_height_in_luma_samples", value, ps_bitstrm); 1530 if(value > INT16_MAX) 1531 { 1532 return (IHEVCD_ERROR_T)IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED; 1533 } 1534 ps_sps->i2_pic_height_in_luma_samples = value; 1535 1536 if((0 >= ps_sps->i2_pic_width_in_luma_samples) || (0 >= ps_sps->i2_pic_height_in_luma_samples)) 1537 return IHEVCD_INVALID_PARAMETER; 1538 1539 BITS_PARSE("pic_cropping_flag", value, ps_bitstrm, 1); 1540 ps_sps->i1_pic_cropping_flag = value; 1541 1542 if(ps_sps->i1_pic_cropping_flag) 1543 { 1544 1545 UEV_PARSE("pic_crop_left_offset", value, ps_bitstrm); 1546 if (value >= ps_sps->i2_pic_width_in_luma_samples) 1547 { 1548 return IHEVCD_INVALID_PARAMETER; 1549 } 1550 ps_sps->i2_pic_crop_left_offset = value; 1551 1552 UEV_PARSE("pic_crop_right_offset", value, ps_bitstrm); 1553 if (value >= ps_sps->i2_pic_width_in_luma_samples) 1554 { 1555 return IHEVCD_INVALID_PARAMETER; 1556 } 1557 ps_sps->i2_pic_crop_right_offset = value; 1558 1559 UEV_PARSE("pic_crop_top_offset", value, ps_bitstrm); 1560 if (value >= ps_sps->i2_pic_height_in_luma_samples) 1561 { 1562 return IHEVCD_INVALID_PARAMETER; 1563 } 1564 ps_sps->i2_pic_crop_top_offset = value; 1565 1566 UEV_PARSE("pic_crop_bottom_offset", value, ps_bitstrm); 1567 if (value >= ps_sps->i2_pic_height_in_luma_samples) 1568 { 1569 return IHEVCD_INVALID_PARAMETER; 1570 } 1571 ps_sps->i2_pic_crop_bottom_offset = value; 1572 } 1573 else 1574 { 1575 ps_sps->i2_pic_crop_left_offset = 0; 1576 ps_sps->i2_pic_crop_right_offset = 0; 1577 ps_sps->i2_pic_crop_top_offset = 0; 1578 ps_sps->i2_pic_crop_bottom_offset = 0; 1579 } 1580 1581 1582 UEV_PARSE("bit_depth_luma_minus8", value, ps_bitstrm); 1583 if(0 != value) 1584 return IHEVCD_UNSUPPORTED_BIT_DEPTH; 1585 1586 UEV_PARSE("bit_depth_chroma_minus8", value, ps_bitstrm); 1587 if(0 != value) 1588 return IHEVCD_UNSUPPORTED_BIT_DEPTH; 1589 1590 UEV_PARSE("log2_max_pic_order_cnt_lsb_minus4", value, ps_bitstrm); 1591 if(value > 12) 1592 return IHEVCD_INVALID_PARAMETER; 1593 ps_sps->i1_log2_max_pic_order_cnt_lsb = value + 4; 1594 1595 BITS_PARSE("sps_sub_layer_ordering_info_present_flag", value, ps_bitstrm, 1); 1596 1597 ps_sps->i1_sps_sub_layer_ordering_info_present_flag = value; 1598 1599 1600 i = (ps_sps->i1_sps_sub_layer_ordering_info_present_flag ? 0 : (ps_sps->i1_sps_max_sub_layers - 1)); 1601 for(; i < ps_sps->i1_sps_max_sub_layers; i++) 1602 { 1603 UEV_PARSE("max_dec_pic_buffering", value, ps_bitstrm); 1604 if(value > (MAX_DPB_SIZE - 1)) 1605 { 1606 return IHEVCD_INVALID_PARAMETER; 1607 } 1608 ps_sps->ai1_sps_max_dec_pic_buffering[i] = value + 1; 1609 1610 UEV_PARSE("num_reorder_pics", value, ps_bitstrm); 1611 if(value >= ps_sps->ai1_sps_max_dec_pic_buffering[i]) 1612 { 1613 return IHEVCD_INVALID_PARAMETER; 1614 } 1615 ps_sps->ai1_sps_max_num_reorder_pics[i] = value; 1616 1617 UEV_PARSE("max_latency_increase", value, ps_bitstrm); 1618 if(value > UINT_MAX - 2) 1619 { 1620 return IHEVCD_INVALID_PARAMETER; 1621 } 1622 ps_sps->ai1_sps_max_latency_increase[i] = value; 1623 } 1624 1625 /* Check if sps_max_dec_pic_buffering or sps_max_num_reorder_pics 1626 has changed */ 1627 if(0 != ps_codec->u4_allocate_dynamic_done) 1628 { 1629 sps_t *ps_sps_old = ps_codec->s_parse.ps_sps; 1630 if(ps_sps_old->ai1_sps_max_dec_pic_buffering[ps_sps_old->i1_sps_max_sub_layers - 1] != 1631 ps_sps->ai1_sps_max_dec_pic_buffering[ps_sps->i1_sps_max_sub_layers - 1]) 1632 { 1633 if(0 == ps_codec->i4_first_pic_done) 1634 { 1635 return IHEVCD_INVALID_PARAMETER; 1636 } 1637 ps_codec->i4_reset_flag = 1; 1638 return (IHEVCD_ERROR_T)IVD_RES_CHANGED; 1639 } 1640 1641 if(ps_sps_old->ai1_sps_max_num_reorder_pics[ps_sps_old->i1_sps_max_sub_layers - 1] != 1642 ps_sps->ai1_sps_max_num_reorder_pics[ps_sps->i1_sps_max_sub_layers - 1]) 1643 { 1644 if(0 == ps_codec->i4_first_pic_done) 1645 { 1646 return IHEVCD_INVALID_PARAMETER; 1647 } 1648 ps_codec->i4_reset_flag = 1; 1649 return (IHEVCD_ERROR_T)IVD_RES_CHANGED; 1650 } 1651 } 1652 1653 UEV_PARSE("log2_min_coding_block_size_minus3", value, ps_bitstrm); 1654 if(value > (LOG2_MAX_CU_SIZE - 3)) 1655 { 1656 return IHEVCD_INVALID_PARAMETER; 1657 } 1658 ps_sps->i1_log2_min_coding_block_size = value + 3; 1659 if((ps_sps->i2_pic_width_in_luma_samples % (1 << ps_sps->i1_log2_min_coding_block_size) != 0) || 1660 (ps_sps->i2_pic_height_in_luma_samples % (1 << ps_sps->i1_log2_min_coding_block_size) != 0)) 1661 { 1662 return IHEVCD_INVALID_PARAMETER; 1663 } 1664 1665 UEV_PARSE("log2_diff_max_min_coding_block_size", value, ps_bitstrm); 1666 if(value > (LOG2_MAX_CU_SIZE - ps_sps->i1_log2_min_coding_block_size)) 1667 { 1668 return IHEVCD_INVALID_PARAMETER; 1669 } 1670 ps_sps->i1_log2_diff_max_min_coding_block_size = value; 1671 1672 ctb_log2_size_y = ps_sps->i1_log2_min_coding_block_size + ps_sps->i1_log2_diff_max_min_coding_block_size; 1673 1674 if((ctb_log2_size_y < LOG2_MIN_CTB_SIZE) || (ctb_log2_size_y > LOG2_MAX_CTB_SIZE)) 1675 { 1676 return IHEVCD_INVALID_PARAMETER; 1677 } 1678 ps_sps->i1_log2_ctb_size = ctb_log2_size_y; 1679 1680 UEV_PARSE("log2_min_transform_block_size_minus2", value, ps_bitstrm); 1681 if(value > (LOG2_MAX_TU_SIZE - 2)) 1682 { 1683 return IHEVCD_INVALID_PARAMETER; 1684 } 1685 ps_sps->i1_log2_min_transform_block_size = value + 2; 1686 if(ps_sps->i1_log2_min_transform_block_size >= ps_sps->i1_log2_min_coding_block_size) 1687 { 1688 return IHEVCD_INVALID_PARAMETER; 1689 } 1690 1691 UEV_PARSE("log2_diff_max_min_transform_block_size", value, ps_bitstrm); 1692 if(value > (LOG2_MAX_TU_SIZE - ps_sps->i1_log2_min_transform_block_size)) 1693 { 1694 return IHEVCD_INVALID_PARAMETER; 1695 } 1696 ps_sps->i1_log2_diff_max_min_transform_block_size = value; 1697 1698 ps_sps->i1_log2_max_transform_block_size = ps_sps->i1_log2_min_transform_block_size + 1699 ps_sps->i1_log2_diff_max_min_transform_block_size; 1700 1701 if(ps_sps->i1_log2_max_transform_block_size > ps_sps->i1_log2_ctb_size) 1702 { 1703 return IHEVCD_INVALID_PARAMETER; 1704 } 1705 1706 ps_sps->i1_log2_min_pcm_coding_block_size = 0; 1707 ps_sps->i1_log2_diff_max_min_pcm_coding_block_size = 0; 1708 1709 UEV_PARSE("max_transform_hierarchy_depth_inter", value, ps_bitstrm); 1710 if(value > (ps_sps->i1_log2_ctb_size - ps_sps->i1_log2_min_transform_block_size)) 1711 { 1712 return IHEVCD_INVALID_PARAMETER; 1713 } 1714 ps_sps->i1_max_transform_hierarchy_depth_inter = value; 1715 1716 UEV_PARSE("max_transform_hierarchy_depth_intra", value, ps_bitstrm); 1717 if(value > (ps_sps->i1_log2_ctb_size - ps_sps->i1_log2_min_transform_block_size)) 1718 { 1719 return IHEVCD_INVALID_PARAMETER; 1720 } 1721 ps_sps->i1_max_transform_hierarchy_depth_intra = value; 1722 1723 /* String has a d (enabled) in order to match with HM */ 1724 BITS_PARSE("scaling_list_enabled_flag", value, ps_bitstrm, 1); 1725 ps_sps->i1_scaling_list_enable_flag = value; 1726 1727 if(ps_sps->i1_scaling_list_enable_flag) 1728 { 1729 COPY_DEFAULT_SCALING_LIST(ps_sps->pi2_scaling_mat); 1730 BITS_PARSE("sps_scaling_list_data_present_flag", value, ps_bitstrm, 1); 1731 ps_sps->i1_sps_scaling_list_data_present_flag = value; 1732 1733 if(ps_sps->i1_sps_scaling_list_data_present_flag) 1734 ihevcd_scaling_list_data(ps_codec, ps_sps->pi2_scaling_mat); 1735 } 1736 else 1737 { 1738 COPY_FLAT_SCALING_LIST(ps_sps->pi2_scaling_mat); 1739 } 1740 /* String is asymmetric_motion_partitions_enabled_flag instead of amp_enabled_flag in order to match with HM */ 1741 BITS_PARSE("asymmetric_motion_partitions_enabled_flag", value, ps_bitstrm, 1); 1742 ps_sps->i1_amp_enabled_flag = value; 1743 1744 BITS_PARSE("sample_adaptive_offset_enabled_flag", value, ps_bitstrm, 1); 1745 ps_sps->i1_sample_adaptive_offset_enabled_flag = value; 1746 1747 BITS_PARSE("pcm_enabled_flag", value, ps_bitstrm, 1); 1748 ps_sps->i1_pcm_enabled_flag = value; 1749 1750 if(ps_sps->i1_pcm_enabled_flag) 1751 { 1752 BITS_PARSE("pcm_sample_bit_depth_luma", value, ps_bitstrm, 4); 1753 ps_sps->i1_pcm_sample_bit_depth_luma = value + 1; 1754 1755 BITS_PARSE("pcm_sample_bit_depth_chroma", value, ps_bitstrm, 4); 1756 ps_sps->i1_pcm_sample_bit_depth_chroma = value + 1; 1757 1758 UEV_PARSE("log2_min_pcm_coding_block_size_minus3", value, ps_bitstrm); 1759 if(value < (ps_sps->i1_log2_min_coding_block_size - 3) || value > (MIN(ctb_log2_size_y, 5) - 3)) 1760 { 1761 return IHEVCD_INVALID_PARAMETER; 1762 } 1763 ps_sps->i1_log2_min_pcm_coding_block_size = value + 3; 1764 1765 UEV_PARSE("log2_diff_max_min_pcm_coding_block_size", value, ps_bitstrm); 1766 if(value > MIN(ctb_log2_size_y, 5) - ps_sps->i1_log2_min_pcm_coding_block_size) 1767 { 1768 return IHEVCD_INVALID_PARAMETER; 1769 } 1770 ps_sps->i1_log2_diff_max_min_pcm_coding_block_size = value; 1771 BITS_PARSE("pcm_loop_filter_disable_flag", value, ps_bitstrm, 1); 1772 ps_sps->i1_pcm_loop_filter_disable_flag = value; 1773 1774 } 1775 UEV_PARSE("num_short_term_ref_pic_sets", value, ps_bitstrm); 1776 if(value > MAX_STREF_PICS_SPS) 1777 { 1778 return IHEVCD_INVALID_PARAMETER; 1779 } 1780 ps_sps->i1_num_short_term_ref_pic_sets = value; 1781 1782 for(i = 0; i < ps_sps->i1_num_short_term_ref_pic_sets; i++) 1783 { 1784 ret = ihevcd_short_term_ref_pic_set(ps_bitstrm, &ps_sps->as_stref_picset[0], ps_sps->i1_num_short_term_ref_pic_sets, i, &ps_sps->as_stref_picset[i]); 1785 if (ret != IHEVCD_SUCCESS) 1786 { 1787 return ret; 1788 } 1789 } 1790 1791 BITS_PARSE("long_term_ref_pics_present_flag", value, ps_bitstrm, 1); 1792 ps_sps->i1_long_term_ref_pics_present_flag = value; 1793 1794 if(ps_sps->i1_long_term_ref_pics_present_flag) 1795 { 1796 UEV_PARSE("num_long_term_ref_pics_sps", value, ps_bitstrm); 1797 if(value > MAX_LTREF_PICS_SPS) 1798 { 1799 return IHEVCD_INVALID_PARAMETER; 1800 } 1801 ps_sps->i1_num_long_term_ref_pics_sps = value; 1802 1803 for(i = 0; i < ps_sps->i1_num_long_term_ref_pics_sps; i++) 1804 { 1805 BITS_PARSE("lt_ref_pic_poc_lsb_sps[ i ]", value, ps_bitstrm, ps_sps->i1_log2_max_pic_order_cnt_lsb); 1806 ps_sps->au2_lt_ref_pic_poc_lsb_sps[i] = value; 1807 1808 BITS_PARSE("used_by_curr_pic_lt_sps_flag[ i ]", value, ps_bitstrm, 1); 1809 ps_sps->ai1_used_by_curr_pic_lt_sps_flag[i] = value; 1810 } 1811 } 1812 1813 BITS_PARSE("sps_temporal_mvp_enable_flag", value, ps_bitstrm, 1); 1814 ps_sps->i1_sps_temporal_mvp_enable_flag = value; 1815 1816 /* Print matches HM 8-2 */ 1817 BITS_PARSE("sps_strong_intra_smoothing_enable_flag", value, ps_bitstrm, 1); 1818 ps_sps->i1_strong_intra_smoothing_enable_flag = value; 1819 1820 BITS_PARSE("vui_parameters_present_flag", value, ps_bitstrm, 1); 1821 ps_sps->i1_vui_parameters_present_flag = value; 1822 1823 if(ps_sps->i1_vui_parameters_present_flag) 1824 { 1825 ret = ihevcd_parse_vui_parameters(ps_bitstrm, 1826 &ps_sps->s_vui_parameters, 1827 ps_sps->i1_sps_max_sub_layers - 1); 1828 RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret); 1829 } 1830 1831 BITS_PARSE("sps_extension_flag", value, ps_bitstrm, 1); 1832 1833 if((UWORD8 *)ps_bitstrm->pu4_buf > ps_bitstrm->pu1_buf_max) 1834 { 1835 return IHEVCD_INVALID_PARAMETER; 1836 } 1837 1838 { 1839 WORD32 numerator; 1840 WORD32 ceil_offset; 1841 1842 ceil_offset = (1 << ps_sps->i1_log2_ctb_size) - 1; 1843 numerator = ps_sps->i2_pic_width_in_luma_samples; 1844 1845 ps_sps->i2_pic_wd_in_ctb = ((numerator + ceil_offset) / 1846 (1 << ps_sps->i1_log2_ctb_size)); 1847 1848 numerator = ps_sps->i2_pic_height_in_luma_samples; 1849 ps_sps->i2_pic_ht_in_ctb = ((numerator + ceil_offset) / 1850 (1 << ps_sps->i1_log2_ctb_size)); 1851 1852 ps_sps->i4_pic_size_in_ctb = ps_sps->i2_pic_ht_in_ctb * 1853 ps_sps->i2_pic_wd_in_ctb; 1854 1855 if(0 == ps_codec->i4_sps_done) 1856 ps_codec->s_parse.i4_next_ctb_indx = ps_sps->i4_pic_size_in_ctb; 1857 1858 numerator = ps_sps->i2_pic_width_in_luma_samples; 1859 ps_sps->i2_pic_wd_in_min_cb = numerator / 1860 (1 << ps_sps->i1_log2_min_coding_block_size); 1861 1862 numerator = ps_sps->i2_pic_height_in_luma_samples; 1863 ps_sps->i2_pic_ht_in_min_cb = numerator / 1864 (1 << ps_sps->i1_log2_min_coding_block_size); 1865 } 1866 if((0 != ps_codec->u4_allocate_dynamic_done) && 1867 ((ps_codec->i4_wd != ps_sps->i2_pic_width_in_luma_samples) || 1868 (ps_codec->i4_ht != ps_sps->i2_pic_height_in_luma_samples))) 1869 { 1870 if(0 == ps_codec->i4_first_pic_done) 1871 { 1872 return IHEVCD_INVALID_PARAMETER; 1873 } 1874 ps_codec->i4_reset_flag = 1; 1875 return (IHEVCD_ERROR_T)IVD_RES_CHANGED; 1876 } 1877 1878 if((ps_sps->i2_pic_width_in_luma_samples > MAX_WD) || 1879 ((ps_sps->i2_pic_width_in_luma_samples * ps_sps->i2_pic_height_in_luma_samples) > 1880 (MAX_WD * MAX_HT))) 1881 { 1882 return (IHEVCD_ERROR_T)IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED; 1883 } 1884 1885 /* Update display width and display height */ 1886 { 1887 WORD32 disp_wd, disp_ht; 1888 WORD32 crop_unit_x, crop_unit_y; 1889 crop_unit_x = 1; 1890 crop_unit_y = 1; 1891 1892 if(CHROMA_FMT_IDC_YUV420 == ps_sps->i1_chroma_format_idc) 1893 { 1894 crop_unit_x = 2; 1895 crop_unit_y = 2; 1896 } 1897 1898 disp_wd = ps_sps->i2_pic_width_in_luma_samples; 1899 disp_wd -= ps_sps->i2_pic_crop_left_offset * crop_unit_x; 1900 disp_wd -= ps_sps->i2_pic_crop_right_offset * crop_unit_x; 1901 1902 1903 disp_ht = ps_sps->i2_pic_height_in_luma_samples; 1904 disp_ht -= ps_sps->i2_pic_crop_top_offset * crop_unit_y; 1905 disp_ht -= ps_sps->i2_pic_crop_bottom_offset * crop_unit_y; 1906 1907 if((0 >= disp_wd) || (0 >= disp_ht)) 1908 return IHEVCD_INVALID_PARAMETER; 1909 1910 if((0 != ps_codec->u4_allocate_dynamic_done) && 1911 ((ps_codec->i4_disp_wd != disp_wd) || 1912 (ps_codec->i4_disp_ht != disp_ht))) 1913 { 1914 if(0 == ps_codec->i4_first_pic_done) 1915 { 1916 return IHEVCD_INVALID_PARAMETER; 1917 } 1918 ps_codec->i4_reset_flag = 1; 1919 return (IHEVCD_ERROR_T)IVD_RES_CHANGED; 1920 } 1921 1922 ps_codec->i4_disp_wd = disp_wd; 1923 ps_codec->i4_disp_ht = disp_ht; 1924 1925 1926 ps_codec->i4_wd = ps_sps->i2_pic_width_in_luma_samples; 1927 ps_codec->i4_ht = ps_sps->i2_pic_height_in_luma_samples; 1928 1929 { 1930 WORD32 ref_strd; 1931 ref_strd = ALIGN32(ps_sps->i2_pic_width_in_luma_samples + PAD_WD); 1932 if(ps_codec->i4_strd < ref_strd) 1933 { 1934 ps_codec->i4_strd = ref_strd; 1935 } 1936 } 1937 1938 if(0 == ps_codec->i4_share_disp_buf) 1939 { 1940 if(ps_codec->i4_disp_strd < ps_codec->i4_disp_wd) 1941 { 1942 ps_codec->i4_disp_strd = ps_codec->i4_disp_wd; 1943 } 1944 } 1945 else 1946 { 1947 if(ps_codec->i4_disp_strd < ps_codec->i4_strd) 1948 { 1949 ps_codec->i4_disp_strd = ps_codec->i4_strd; 1950 } 1951 } 1952 } 1953 1954 /* This is used only during initialization to get reorder count etc */ 1955 ps_codec->i4_sps_id = sps_id; 1956 1957 ps_codec->i4_sps_done = 1; 1958 return ret; 1959 } 1960 1961 1962 void ihevcd_unmark_pps(codec_t *ps_codec, WORD32 sps_id) 1963 { 1964 WORD32 pps_id = 0; 1965 pps_t *ps_pps = ps_codec->ps_pps_base; 1966 1967 for(pps_id = 0; pps_id < MAX_PPS_CNT - 1; pps_id++, ps_pps++) 1968 { 1969 if((ps_pps->i1_pps_valid) && 1970 (ps_pps->i1_sps_id == sps_id)) 1971 ps_pps->i1_pps_valid = 0; 1972 } 1973 } 1974 1975 1976 void ihevcd_copy_sps(codec_t *ps_codec, WORD32 sps_id, WORD32 sps_id_ref) 1977 { 1978 sps_t *ps_sps, *ps_sps_ref; 1979 WORD16 *pi2_scaling_mat_backup; 1980 WORD32 scaling_mat_size; 1981 1982 SCALING_MAT_SIZE(scaling_mat_size); 1983 ps_sps_ref = ps_codec->ps_sps_base + sps_id_ref; 1984 ps_sps = ps_codec->ps_sps_base + sps_id; 1985 1986 if(ps_sps->i1_sps_valid) 1987 { 1988 if((ps_sps->i1_log2_ctb_size != ps_sps_ref->i1_log2_ctb_size) || 1989 (ps_sps->i2_pic_wd_in_ctb != ps_sps_ref->i2_pic_wd_in_ctb) || 1990 (ps_sps->i2_pic_ht_in_ctb != ps_sps_ref->i2_pic_ht_in_ctb)) 1991 { 1992 ihevcd_unmark_pps(ps_codec, sps_id); 1993 } 1994 } 1995 1996 pi2_scaling_mat_backup = ps_sps->pi2_scaling_mat; 1997 1998 memcpy(ps_sps, ps_sps_ref, sizeof(sps_t)); 1999 ps_sps->pi2_scaling_mat = pi2_scaling_mat_backup; 2000 memcpy(ps_sps->pi2_scaling_mat, ps_sps_ref->pi2_scaling_mat, scaling_mat_size * sizeof(WORD16)); 2001 ps_sps->i1_sps_valid = 1; 2002 2003 ps_codec->s_parse.ps_sps = ps_sps; 2004 } 2005 2006 2007 /** 2008 ******************************************************************************* 2009 * 2010 * @brief 2011 * Parses PPS (Picture Parameter Set) 2012 * 2013 * @par Description: 2014 * Parse Picture Parameter Set as per section Section: 7.3.2.3 2015 * The pps is written to a temporary buffer and copied later to the 2016 * appropriate location 2017 * 2018 * @param[in] ps_codec 2019 * Pointer to codec context 2020 * 2021 * @returns Error code from IHEVCD_ERROR_T 2022 * 2023 * @remarks 2024 * 2025 * 2026 ******************************************************************************* 2027 */ 2028 IHEVCD_ERROR_T ihevcd_parse_pps(codec_t *ps_codec) 2029 { 2030 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 2031 UWORD32 value; 2032 WORD32 i4_value; 2033 WORD32 pps_id; 2034 2035 pps_t *ps_pps; 2036 sps_t *ps_sps; 2037 bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm; 2038 2039 2040 if(0 == ps_codec->i4_sps_done) 2041 return IHEVCD_INVALID_HEADER; 2042 2043 UEV_PARSE("pic_parameter_set_id", value, ps_bitstrm); 2044 2045 pps_id = value; 2046 if((pps_id >= MAX_PPS_CNT) || (pps_id < 0)) 2047 { 2048 if(ps_codec->i4_pps_done) 2049 return IHEVCD_UNSUPPORTED_PPS_ID; 2050 else 2051 pps_id = 0; 2052 } 2053 2054 2055 ps_pps = (ps_codec->s_parse.ps_pps_base + MAX_PPS_CNT - 1); 2056 2057 ps_pps->i1_pps_id = pps_id; 2058 2059 UEV_PARSE("seq_parameter_set_id", value, ps_bitstrm); 2060 if(value > MAX_SPS_CNT - 2) 2061 { 2062 return IHEVCD_INVALID_PARAMETER; 2063 } 2064 ps_pps->i1_sps_id = value; 2065 2066 ps_sps = (ps_codec->s_parse.ps_sps_base + ps_pps->i1_sps_id); 2067 2068 /* If the SPS that is being referred to has not been parsed, 2069 * copy an existing SPS to the current location */ 2070 if(0 == ps_sps->i1_sps_valid) 2071 { 2072 return IHEVCD_INVALID_HEADER; 2073 2074 /* 2075 sps_t *ps_sps_ref = ps_codec->ps_sps_base; 2076 while(0 == ps_sps_ref->i1_sps_valid) 2077 ps_sps_ref++; 2078 ihevcd_copy_sps(ps_codec, ps_pps->i1_sps_id, ps_sps_ref->i1_sps_id); 2079 */ 2080 } 2081 2082 BITS_PARSE("dependent_slices_enabled_flag", value, ps_bitstrm, 1); 2083 ps_pps->i1_dependent_slice_enabled_flag = value; 2084 2085 BITS_PARSE("output_flag_present_flag", value, ps_bitstrm, 1); 2086 ps_pps->i1_output_flag_present_flag = value; 2087 2088 BITS_PARSE("num_extra_slice_header_bits", value, ps_bitstrm, 3); 2089 ps_pps->i1_num_extra_slice_header_bits = value; 2090 2091 2092 BITS_PARSE("sign_data_hiding_flag", value, ps_bitstrm, 1); 2093 ps_pps->i1_sign_data_hiding_flag = value; 2094 2095 BITS_PARSE("cabac_init_present_flag", value, ps_bitstrm, 1); 2096 ps_pps->i1_cabac_init_present_flag = value; 2097 2098 UEV_PARSE("num_ref_idx_l0_default_active_minus1", value, ps_bitstrm); 2099 if(value > MAX_DPB_SIZE - 2) 2100 { 2101 return IHEVCD_INVALID_PARAMETER; 2102 } 2103 ps_pps->i1_num_ref_idx_l0_default_active = value + 1; 2104 2105 UEV_PARSE("num_ref_idx_l1_default_active_minus1", value, ps_bitstrm); 2106 if(value > MAX_DPB_SIZE - 2) 2107 { 2108 return IHEVCD_INVALID_PARAMETER; 2109 } 2110 ps_pps->i1_num_ref_idx_l1_default_active = value + 1; 2111 2112 SEV_PARSE("pic_init_qp_minus26", i4_value, ps_bitstrm); 2113 if(i4_value < -26 || i4_value > 25) 2114 { 2115 return IHEVCD_INVALID_PARAMETER; 2116 } 2117 ps_pps->i1_pic_init_qp = i4_value + 26; 2118 2119 BITS_PARSE("constrained_intra_pred_flag", value, ps_bitstrm, 1); 2120 ps_pps->i1_constrained_intra_pred_flag = value; 2121 2122 BITS_PARSE("transform_skip_enabled_flag", value, ps_bitstrm, 1); 2123 ps_pps->i1_transform_skip_enabled_flag = value; 2124 2125 BITS_PARSE("cu_qp_delta_enabled_flag", value, ps_bitstrm, 1); 2126 ps_pps->i1_cu_qp_delta_enabled_flag = value; 2127 2128 if(ps_pps->i1_cu_qp_delta_enabled_flag) 2129 { 2130 UEV_PARSE("diff_cu_qp_delta_depth", value, ps_bitstrm); 2131 if(value > ps_sps->i1_log2_diff_max_min_coding_block_size) 2132 { 2133 return IHEVCD_INVALID_PARAMETER; 2134 } 2135 ps_pps->i1_diff_cu_qp_delta_depth = value; 2136 } 2137 else 2138 { 2139 ps_pps->i1_diff_cu_qp_delta_depth = 0; 2140 } 2141 ps_pps->i1_log2_min_cu_qp_delta_size = ps_sps->i1_log2_ctb_size - ps_pps->i1_diff_cu_qp_delta_depth; 2142 /* Print different */ 2143 SEV_PARSE("cb_qp_offset", i4_value, ps_bitstrm); 2144 if(i4_value < -12 || i4_value > 12) 2145 { 2146 return IHEVCD_INVALID_PARAMETER; 2147 } 2148 ps_pps->i1_pic_cb_qp_offset = i4_value; 2149 2150 /* Print different */ 2151 SEV_PARSE("cr_qp_offset", i4_value, ps_bitstrm); 2152 if(i4_value < -12 || i4_value > 12) 2153 { 2154 return IHEVCD_INVALID_PARAMETER; 2155 } 2156 ps_pps->i1_pic_cr_qp_offset = i4_value; 2157 2158 /* Print different */ 2159 BITS_PARSE("slicelevel_chroma_qp_flag", value, ps_bitstrm, 1); 2160 ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag = value; 2161 2162 BITS_PARSE("weighted_pred_flag", value, ps_bitstrm, 1); 2163 ps_pps->i1_weighted_pred_flag = value; 2164 2165 BITS_PARSE("weighted_bipred_flag", value, ps_bitstrm, 1); 2166 ps_pps->i1_weighted_bipred_flag = value; 2167 2168 BITS_PARSE("transquant_bypass_enable_flag", value, ps_bitstrm, 1); 2169 ps_pps->i1_transquant_bypass_enable_flag = value; 2170 2171 BITS_PARSE("tiles_enabled_flag", value, ps_bitstrm, 1); 2172 ps_pps->i1_tiles_enabled_flag = value; 2173 2174 /* When tiles are enabled and width or height is >= 4096, 2175 * CTB Size should at least be 32 while if width or height is >= 8192, 2176 * CTB Size should at least be 64 and so on. 16x16 CTBs can result 2177 * in tile position greater than 255 for 4096 while 32x32 CTBs can result 2178 * in tile position greater than 255 for 8192, 2179 * which decoder does not support. 2180 */ 2181 if (ps_pps->i1_tiles_enabled_flag) 2182 { 2183 if((ps_sps->i1_log2_ctb_size == 4) && 2184 ((ps_sps->i2_pic_width_in_luma_samples >= 4096) || 2185 (ps_sps->i2_pic_height_in_luma_samples >= 4096))) 2186 { 2187 return IHEVCD_INVALID_HEADER; 2188 } 2189 if((ps_sps->i1_log2_ctb_size == 5) && 2190 ((ps_sps->i2_pic_width_in_luma_samples >= 8192) || 2191 (ps_sps->i2_pic_height_in_luma_samples >= 8192))) 2192 { 2193 return IHEVCD_INVALID_HEADER; 2194 } 2195 if((ps_sps->i1_log2_ctb_size == 6) && 2196 ((ps_sps->i2_pic_width_in_luma_samples >= 16384) || 2197 (ps_sps->i2_pic_height_in_luma_samples >= 16384))) 2198 { 2199 return IHEVCD_INVALID_HEADER; 2200 } 2201 } 2202 2203 BITS_PARSE("entropy_coding_sync_enabled_flag", value, ps_bitstrm, 1); 2204 ps_pps->i1_entropy_coding_sync_enabled_flag = value; 2205 2206 ps_pps->i1_loop_filter_across_tiles_enabled_flag = 0; 2207 if(ps_pps->i1_tiles_enabled_flag) 2208 { 2209 WORD32 wd = ALIGN64(ps_codec->i4_wd); 2210 WORD32 ht = ALIGN64(ps_codec->i4_ht); 2211 2212 WORD32 max_tile_cols = (wd + MIN_TILE_WD - 1) / MIN_TILE_WD; 2213 WORD32 max_tile_rows = (ht + MIN_TILE_HT - 1) / MIN_TILE_HT; 2214 2215 UEV_PARSE("num_tile_columns_minus1", value, ps_bitstrm); 2216 ps_pps->i1_num_tile_columns = value + 1; 2217 2218 UEV_PARSE("num_tile_rows_minus1", value, ps_bitstrm); 2219 ps_pps->i1_num_tile_rows = value + 1; 2220 2221 if((ps_pps->i1_num_tile_columns < 1) || 2222 (ps_pps->i1_num_tile_columns > max_tile_cols) || 2223 (ps_pps->i1_num_tile_rows < 1) || 2224 (ps_pps->i1_num_tile_rows > max_tile_rows)) 2225 return IHEVCD_INVALID_HEADER; 2226 2227 BITS_PARSE("uniform_spacing_flag", value, ps_bitstrm, 1); 2228 ps_pps->i1_uniform_spacing_flag = value; 2229 2230 2231 { 2232 2233 UWORD32 start; 2234 WORD32 i, j; 2235 2236 2237 start = 0; 2238 for(i = 0; i < ps_pps->i1_num_tile_columns; i++) 2239 { 2240 tile_t *ps_tile; 2241 if(!ps_pps->i1_uniform_spacing_flag) 2242 { 2243 if(i < (ps_pps->i1_num_tile_columns - 1)) 2244 { 2245 UEV_PARSE("column_width_minus1[ i ]", value, ps_bitstrm); 2246 value += 1; 2247 if (value >= ps_sps->i2_pic_wd_in_ctb - start) 2248 { 2249 return IHEVCD_INVALID_HEADER; 2250 } 2251 } 2252 else 2253 { 2254 value = ps_sps->i2_pic_wd_in_ctb - start; 2255 } 2256 } 2257 else 2258 { 2259 value = ((i + 1) * ps_sps->i2_pic_wd_in_ctb) / ps_pps->i1_num_tile_columns - 2260 (i * ps_sps->i2_pic_wd_in_ctb) / ps_pps->i1_num_tile_columns; 2261 } 2262 2263 for(j = 0; j < ps_pps->i1_num_tile_rows; j++) 2264 { 2265 ps_tile = ps_pps->ps_tile + j * ps_pps->i1_num_tile_columns + i; 2266 ps_tile->u1_pos_x = start; 2267 ps_tile->u2_wd = value; 2268 } 2269 start += value; 2270 2271 if((start > ps_sps->i2_pic_wd_in_ctb) || 2272 (value == 0)) 2273 return IHEVCD_INVALID_HEADER; 2274 } 2275 2276 start = 0; 2277 for(i = 0; i < (ps_pps->i1_num_tile_rows); i++) 2278 { 2279 tile_t *ps_tile; 2280 if(!ps_pps->i1_uniform_spacing_flag) 2281 { 2282 if(i < (ps_pps->i1_num_tile_rows - 1)) 2283 { 2284 2285 UEV_PARSE("row_height_minus1[ i ]", value, ps_bitstrm); 2286 value += 1; 2287 if (value >= ps_sps->i2_pic_ht_in_ctb - start) 2288 { 2289 return IHEVCD_INVALID_HEADER; 2290 } 2291 } 2292 else 2293 { 2294 value = ps_sps->i2_pic_ht_in_ctb - start; 2295 } 2296 } 2297 else 2298 { 2299 value = ((i + 1) * ps_sps->i2_pic_ht_in_ctb) / ps_pps->i1_num_tile_rows - 2300 (i * ps_sps->i2_pic_ht_in_ctb) / ps_pps->i1_num_tile_rows; 2301 } 2302 2303 for(j = 0; j < ps_pps->i1_num_tile_columns; j++) 2304 { 2305 ps_tile = ps_pps->ps_tile + i * ps_pps->i1_num_tile_columns + j; 2306 ps_tile->u1_pos_y = start; 2307 ps_tile->u2_ht = value; 2308 } 2309 start += value; 2310 2311 if((start > ps_sps->i2_pic_ht_in_ctb) || 2312 (value == 0)) 2313 return IHEVCD_INVALID_HEADER; 2314 } 2315 } 2316 2317 2318 BITS_PARSE("loop_filter_across_tiles_enabled_flag", value, ps_bitstrm, 1); 2319 ps_pps->i1_loop_filter_across_tiles_enabled_flag = value; 2320 2321 } 2322 else 2323 { 2324 /* If tiles are not present, set first tile in each PPS to have tile 2325 width and height equal to picture width and height */ 2326 ps_pps->i1_num_tile_columns = 1; 2327 ps_pps->i1_num_tile_rows = 1; 2328 ps_pps->i1_uniform_spacing_flag = 1; 2329 2330 ps_pps->ps_tile->u1_pos_x = 0; 2331 ps_pps->ps_tile->u1_pos_y = 0; 2332 ps_pps->ps_tile->u2_wd = ps_sps->i2_pic_wd_in_ctb; 2333 ps_pps->ps_tile->u2_ht = ps_sps->i2_pic_ht_in_ctb; 2334 } 2335 2336 BITS_PARSE("loop_filter_across_slices_enabled_flag", value, ps_bitstrm, 1); 2337 ps_pps->i1_loop_filter_across_slices_enabled_flag = value; 2338 2339 BITS_PARSE("deblocking_filter_control_present_flag", value, ps_bitstrm, 1); 2340 ps_pps->i1_deblocking_filter_control_present_flag = value; 2341 2342 /* Default values */ 2343 ps_pps->i1_pic_disable_deblocking_filter_flag = 0; 2344 ps_pps->i1_deblocking_filter_override_enabled_flag = 0; 2345 ps_pps->i1_beta_offset_div2 = 0; 2346 ps_pps->i1_tc_offset_div2 = 0; 2347 2348 if(ps_pps->i1_deblocking_filter_control_present_flag) 2349 { 2350 2351 BITS_PARSE("deblocking_filter_override_enabled_flag", value, ps_bitstrm, 1); 2352 ps_pps->i1_deblocking_filter_override_enabled_flag = value; 2353 2354 BITS_PARSE("pic_disable_deblocking_filter_flag", value, ps_bitstrm, 1); 2355 ps_pps->i1_pic_disable_deblocking_filter_flag = value; 2356 2357 if(!ps_pps->i1_pic_disable_deblocking_filter_flag) 2358 { 2359 2360 SEV_PARSE("pps_beta_offset_div2", i4_value, ps_bitstrm); 2361 if(i4_value < -6 || i4_value > 6) 2362 { 2363 return IHEVCD_INVALID_PARAMETER; 2364 } 2365 ps_pps->i1_beta_offset_div2 = i4_value; 2366 2367 SEV_PARSE("pps_tc_offset_div2", i4_value, ps_bitstrm); 2368 if(i4_value < -6 || i4_value > 6) 2369 { 2370 return IHEVCD_INVALID_PARAMETER; 2371 } 2372 ps_pps->i1_tc_offset_div2 = i4_value; 2373 2374 } 2375 } 2376 2377 BITS_PARSE("pps_scaling_list_data_present_flag", value, ps_bitstrm, 1); 2378 ps_pps->i1_pps_scaling_list_data_present_flag = value; 2379 2380 if(ps_pps->i1_pps_scaling_list_data_present_flag) 2381 { 2382 COPY_DEFAULT_SCALING_LIST(ps_pps->pi2_scaling_mat); 2383 ihevcd_scaling_list_data(ps_codec, ps_pps->pi2_scaling_mat); 2384 } 2385 2386 BITS_PARSE("lists_modification_present_flag", value, ps_bitstrm, 1); 2387 ps_pps->i1_lists_modification_present_flag = value; 2388 UEV_PARSE("log2_parallel_merge_level_minus2", value, ps_bitstrm); 2389 if(value > (ps_sps->i1_log2_min_coding_block_size + ps_sps->i1_log2_diff_max_min_coding_block_size)) 2390 { 2391 return IHEVCD_INVALID_PARAMETER; 2392 } 2393 ps_pps->i1_log2_parallel_merge_level = value + 2; 2394 2395 BITS_PARSE("slice_header_extension_present_flag", value, ps_bitstrm, 1); 2396 ps_pps->i1_slice_header_extension_present_flag = value; 2397 /* Not present in HM */ 2398 BITS_PARSE("pps_extension_flag", value, ps_bitstrm, 1); 2399 2400 if((UWORD8 *)ps_bitstrm->pu4_buf > ps_bitstrm->pu1_buf_max) 2401 return IHEVCD_INVALID_PARAMETER; 2402 2403 ps_codec->i4_pps_done = 1; 2404 return ret; 2405 } 2406 2407 2408 void ihevcd_copy_pps(codec_t *ps_codec, WORD32 pps_id, WORD32 pps_id_ref) 2409 { 2410 pps_t *ps_pps, *ps_pps_ref; 2411 WORD16 *pi2_scaling_mat_backup; 2412 WORD32 scaling_mat_size; 2413 tile_t *ps_tile_backup; 2414 WORD32 max_tile_cols, max_tile_rows; 2415 WORD32 wd, ht; 2416 wd = ALIGN64(ps_codec->i4_wd); 2417 ht = ALIGN64(ps_codec->i4_ht); 2418 2419 SCALING_MAT_SIZE(scaling_mat_size); 2420 max_tile_cols = (wd + MIN_TILE_WD - 1) / MIN_TILE_WD; 2421 max_tile_rows = (ht + MIN_TILE_HT - 1) / MIN_TILE_HT; 2422 2423 ps_pps_ref = ps_codec->ps_pps_base + pps_id_ref; 2424 ps_pps = ps_codec->ps_pps_base + pps_id; 2425 2426 pi2_scaling_mat_backup = ps_pps->pi2_scaling_mat; 2427 ps_tile_backup = ps_pps->ps_tile; 2428 2429 memcpy(ps_pps, ps_pps_ref, sizeof(pps_t)); 2430 ps_pps->pi2_scaling_mat = pi2_scaling_mat_backup; 2431 ps_pps->ps_tile = ps_tile_backup; 2432 memcpy(ps_pps->pi2_scaling_mat, ps_pps_ref->pi2_scaling_mat, scaling_mat_size * sizeof(WORD16)); 2433 memcpy(ps_pps->ps_tile, ps_pps_ref->ps_tile, max_tile_cols * max_tile_rows * sizeof(tile_t)); 2434 2435 ps_pps->i1_pps_valid = 1; 2436 2437 ps_codec->s_parse.ps_pps = ps_pps; 2438 } 2439 2440 2441 IHEVCD_ERROR_T ihevcd_parse_buffering_period_sei(codec_t *ps_codec, 2442 sps_t *ps_sps) 2443 { 2444 parse_ctxt_t *ps_parse = &ps_codec->s_parse; 2445 bitstrm_t *ps_bitstrm = &ps_parse->s_bitstrm; 2446 UWORD32 value; 2447 vui_t *ps_vui; 2448 buf_period_sei_params_t *ps_buf_period_sei_params; 2449 UWORD32 i; 2450 hrd_params_t *ps_vui_hdr; 2451 UWORD32 u4_cpb_cnt; 2452 2453 ps_vui = &ps_sps->s_vui_parameters; 2454 ps_vui_hdr = &ps_vui->s_vui_hrd_parameters; 2455 2456 ps_buf_period_sei_params = &ps_parse->s_sei_params.s_buf_period_sei_params; 2457 2458 ps_parse->s_sei_params.i1_buf_period_params_present_flag = 1; 2459 2460 UEV_PARSE("bp_seq_parameter_set_id", value, ps_bitstrm); 2461 if(value > MAX_SPS_CNT - 2) 2462 { 2463 return IHEVCD_INVALID_PARAMETER; 2464 } 2465 ps_buf_period_sei_params->u1_bp_seq_parameter_set_id = value; 2466 2467 if(!ps_vui_hdr->u1_sub_pic_cpb_params_present_flag) 2468 { 2469 BITS_PARSE("irap_cpb_params_present_flag", value, ps_bitstrm, 1); 2470 ps_buf_period_sei_params->u1_rap_cpb_params_present_flag = value; 2471 } 2472 2473 if(ps_buf_period_sei_params->u1_rap_cpb_params_present_flag) 2474 { 2475 BITS_PARSE("cpb_delay_offset", 2476 value, 2477 ps_bitstrm, 2478 (ps_vui_hdr->u1_au_cpb_removal_delay_length_minus1 2479 + 1)); 2480 ps_buf_period_sei_params->u4_cpb_delay_offset = value; 2481 2482 BITS_PARSE("dpb_delay_offset", 2483 value, 2484 ps_bitstrm, 2485 (ps_vui_hdr->u1_dpb_output_delay_length_minus1 2486 + 1)); 2487 ps_buf_period_sei_params->u4_dpb_delay_offset = value; 2488 } 2489 else 2490 { 2491 ps_buf_period_sei_params->u4_cpb_delay_offset = 0; 2492 ps_buf_period_sei_params->u4_dpb_delay_offset = 0; 2493 } 2494 2495 BITS_PARSE("concatenation_flag", value, ps_bitstrm, 1); 2496 ps_buf_period_sei_params->u1_concatenation_flag = value; 2497 2498 BITS_PARSE("au_cpb_removal_delay_delta_minus1", 2499 value, 2500 ps_bitstrm, 2501 (ps_vui_hdr->u1_au_cpb_removal_delay_length_minus1 2502 + 1)); 2503 ps_buf_period_sei_params->u4_au_cpb_removal_delay_delta_minus1 = value; 2504 2505 if(ps_vui_hdr->u1_nal_hrd_parameters_present_flag) 2506 { 2507 u4_cpb_cnt = ps_vui_hdr->au1_cpb_cnt_minus1[0]; 2508 2509 for(i = 0; i <= u4_cpb_cnt; i++) 2510 { 2511 BITS_PARSE("nal_initial_cpb_removal_delay[i]", 2512 value, 2513 ps_bitstrm, 2514 (ps_vui_hdr->u1_initial_cpb_removal_delay_length_minus1 2515 + 1)); 2516 ps_buf_period_sei_params->au4_nal_initial_cpb_removal_delay[i] = 2517 value; 2518 2519 BITS_PARSE("nal_initial_cpb_removal_delay_offset", 2520 value, 2521 ps_bitstrm, 2522 (ps_vui_hdr->u1_initial_cpb_removal_delay_length_minus1 2523 + 1)); 2524 ps_buf_period_sei_params->au4_nal_initial_cpb_removal_delay_offset[i] = 2525 value; 2526 2527 if(ps_vui_hdr->u1_sub_pic_cpb_params_present_flag 2528 || ps_buf_period_sei_params->u1_rap_cpb_params_present_flag) 2529 { 2530 BITS_PARSE("nal_initial_alt_cpb_removal_delay[i]", 2531 value, 2532 ps_bitstrm, 2533 (ps_vui_hdr->u1_initial_cpb_removal_delay_length_minus1 2534 + 1)); 2535 ps_buf_period_sei_params->au4_nal_initial_alt_cpb_removal_delay[i] = 2536 value; 2537 2538 BITS_PARSE("nal_initial_alt_cpb_removal_delay_offset", 2539 value, 2540 ps_bitstrm, 2541 (ps_vui_hdr->u1_initial_cpb_removal_delay_length_minus1 2542 + 1)); 2543 ps_buf_period_sei_params->au4_nal_initial_alt_cpb_removal_delay_offset[i] = 2544 value; 2545 } 2546 } 2547 } 2548 2549 if(ps_vui_hdr->u1_vcl_hrd_parameters_present_flag) 2550 { 2551 u4_cpb_cnt = ps_vui_hdr->au1_cpb_cnt_minus1[0]; 2552 2553 for(i = 0; i <= u4_cpb_cnt; i++) 2554 { 2555 BITS_PARSE("vcl_initial_cpb_removal_delay[i]", 2556 value, 2557 ps_bitstrm, 2558 (ps_vui_hdr->u1_initial_cpb_removal_delay_length_minus1 2559 + 1)); 2560 ps_buf_period_sei_params->au4_vcl_initial_cpb_removal_delay[i] = 2561 value; 2562 2563 BITS_PARSE("vcl_initial_cpb_removal_delay_offset", 2564 value, 2565 ps_bitstrm, 2566 (ps_vui_hdr->u1_initial_cpb_removal_delay_length_minus1 2567 + 1)); 2568 ps_buf_period_sei_params->au4_vcl_initial_cpb_removal_delay_offset[i] = 2569 value; 2570 2571 if(ps_vui_hdr->u1_sub_pic_cpb_params_present_flag 2572 || ps_buf_period_sei_params->u1_rap_cpb_params_present_flag) 2573 { 2574 BITS_PARSE("vcl_initial_alt_cpb_removal_delay[i]", 2575 value, 2576 ps_bitstrm, 2577 (ps_vui_hdr->u1_initial_cpb_removal_delay_length_minus1 2578 + 1)); 2579 ps_buf_period_sei_params->au4_vcl_initial_alt_cpb_removal_delay[i] = 2580 value; 2581 2582 BITS_PARSE("vcl_initial_alt_cpb_removal_delay_offset", 2583 value, 2584 ps_bitstrm, 2585 (ps_vui_hdr->u1_initial_cpb_removal_delay_length_minus1 2586 + 1)); 2587 ps_buf_period_sei_params->au4_vcl_initial_alt_cpb_removal_delay_offset[i] = 2588 value; 2589 } 2590 } 2591 } 2592 2593 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 2594 } 2595 2596 IHEVCD_ERROR_T ihevcd_parse_pic_timing_sei(codec_t *ps_codec, sps_t *ps_sps) 2597 { 2598 parse_ctxt_t *ps_parse = &ps_codec->s_parse; 2599 bitstrm_t *ps_bitstrm = &ps_parse->s_bitstrm; 2600 UWORD32 value; 2601 vui_t *ps_vui; 2602 UWORD32 i; 2603 hrd_params_t *ps_vui_hdr; 2604 UWORD32 u4_cpb_dpb_delays_present_flag = 0; 2605 pic_timing_sei_params_t *ps_pic_timing; 2606 2607 ps_pic_timing = &ps_parse->s_sei_params.s_pic_timing_sei_params; 2608 ps_vui = &ps_sps->s_vui_parameters; 2609 ps_vui_hdr = &ps_vui->s_vui_hrd_parameters; 2610 ps_parse->s_sei_params.i1_pic_timing_params_present_flag = 1; 2611 if(ps_vui->u1_frame_field_info_present_flag) 2612 { 2613 BITS_PARSE("pic_struct", value, ps_bitstrm, 4); 2614 ps_pic_timing->u4_pic_struct = value; 2615 2616 BITS_PARSE("source_scan_type", value, ps_bitstrm, 2); 2617 ps_pic_timing->u4_source_scan_type = value; 2618 2619 BITS_PARSE("duplicate_flag", value, ps_bitstrm, 1); 2620 ps_pic_timing->u1_duplicate_flag = value; 2621 } 2622 2623 if(ps_vui_hdr->u1_nal_hrd_parameters_present_flag 2624 || ps_vui_hdr->u1_vcl_hrd_parameters_present_flag) 2625 { 2626 u4_cpb_dpb_delays_present_flag = 1; 2627 } 2628 else 2629 { 2630 u4_cpb_dpb_delays_present_flag = 0; 2631 } 2632 2633 if(u4_cpb_dpb_delays_present_flag) 2634 { 2635 BITS_PARSE("au_cpb_removal_delay_minus1", value, ps_bitstrm, 2636 (ps_vui_hdr->u1_au_cpb_removal_delay_length_minus1 + 1)); 2637 ps_pic_timing->u4_au_cpb_removal_delay_minus1 = value; 2638 2639 BITS_PARSE("pic_dpb_output_delay", value, ps_bitstrm, 2640 (ps_vui_hdr->u1_dpb_output_delay_length_minus1 + 1)); 2641 ps_pic_timing->u4_pic_dpb_output_delay = value; 2642 2643 if(ps_vui_hdr->u1_sub_pic_cpb_params_present_flag) 2644 { 2645 BITS_PARSE("pic_dpb_output_du_delay", value, ps_bitstrm, 2646 (ps_vui_hdr->u1_dpb_output_delay_du_length_minus1 + 1)); 2647 ps_pic_timing->u4_pic_dpb_output_du_delay = value; 2648 } 2649 2650 if(ps_vui_hdr->u1_sub_pic_cpb_params_present_flag 2651 && ps_vui_hdr->u1_sub_pic_cpb_params_in_pic_timing_sei_flag) 2652 { 2653 UWORD32 num_units_minus1; 2654 UWORD32 array_size; 2655 2656 UEV_PARSE("num_decoding_units_minus1", value, ps_bitstrm); 2657 if(value > (ps_sps->i4_pic_size_in_ctb -1)) 2658 { 2659 return IHEVCD_INVALID_PARAMETER; 2660 } 2661 ps_pic_timing->u4_num_decoding_units_minus1 = value; 2662 2663 num_units_minus1 = ps_pic_timing->u4_num_decoding_units_minus1; 2664 array_size = (sizeof(ps_pic_timing->au4_num_nalus_in_du_minus1) 2665 / sizeof(ps_pic_timing->au4_num_nalus_in_du_minus1[0])); 2666 num_units_minus1 = CLIP3(num_units_minus1, 0,(array_size - 1)); 2667 ps_pic_timing->u4_num_decoding_units_minus1 = num_units_minus1; 2668 2669 BITS_PARSE("du_common_cpb_removal_delay_flag", value, ps_bitstrm, 1); 2670 ps_pic_timing->u1_du_common_cpb_removal_delay_flag = value; 2671 2672 if(ps_pic_timing->u1_du_common_cpb_removal_delay_flag) 2673 { 2674 BITS_PARSE("du_common_cpb_removal_delay_increment_minus1", 2675 value, 2676 ps_bitstrm, 2677 (ps_vui_hdr->u1_du_cpb_removal_delay_increment_length_minus1 2678 + 1)); 2679 ps_pic_timing->u4_du_common_cpb_removal_delay_increment_minus1 = 2680 value; 2681 } 2682 2683 for(i = 0; i <= ps_pic_timing->u4_num_decoding_units_minus1; i++) 2684 { 2685 UEV_PARSE("num_nalus_in_du_minus1", value, ps_bitstrm); 2686 if(value > (ps_sps->i4_pic_size_in_ctb -1)) 2687 { 2688 return IHEVCD_INVALID_PARAMETER; 2689 } 2690 ps_pic_timing->au4_num_nalus_in_du_minus1[i] = value; 2691 2692 if((!ps_pic_timing->u1_du_common_cpb_removal_delay_flag) 2693 && (i < ps_pic_timing->u4_num_decoding_units_minus1)) 2694 { 2695 BITS_PARSE("du_common_cpb_removal_delay_increment_minus1", 2696 value, 2697 ps_bitstrm, 2698 (ps_vui_hdr->u1_du_cpb_removal_delay_increment_length_minus1 2699 + 1)); 2700 ps_pic_timing->au4_du_cpb_removal_delay_increment_minus1[i] = 2701 value; 2702 } 2703 } 2704 } 2705 } 2706 2707 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 2708 } 2709 2710 IHEVCD_ERROR_T ihevcd_parse_time_code_sei(codec_t *ps_codec) 2711 { 2712 parse_ctxt_t *ps_parse = &ps_codec->s_parse; 2713 bitstrm_t *ps_bitstrm = &ps_parse->s_bitstrm; 2714 UWORD32 value; 2715 time_code_t *ps_time_code; 2716 WORD32 i; 2717 2718 ps_parse->s_sei_params.i1_time_code_present_flag = 1; 2719 ps_time_code = &ps_parse->s_sei_params.s_time_code; 2720 2721 BITS_PARSE("num_clock_ts", value, ps_bitstrm, 2); 2722 ps_time_code->u1_num_clock_ts = value; 2723 2724 for(i = 0; i < ps_time_code->u1_num_clock_ts; i++) 2725 { 2726 BITS_PARSE("clock_timestamp_flag[i]", value, ps_bitstrm, 1); 2727 ps_time_code->au1_clock_timestamp_flag[i] = value; 2728 2729 if(ps_time_code->au1_clock_timestamp_flag[i]) 2730 { 2731 BITS_PARSE("units_field_based_flag[i]", value, ps_bitstrm, 1); 2732 ps_time_code->au1_units_field_based_flag[i] = value; 2733 2734 BITS_PARSE("counting_type[i]", value, ps_bitstrm, 5); 2735 ps_time_code->au1_counting_type[i] = value; 2736 2737 BITS_PARSE("full_timestamp_flag[i]", value, ps_bitstrm, 1); 2738 ps_time_code->au1_full_timestamp_flag[i] = value; 2739 2740 BITS_PARSE("discontinuity_flag[i]", value, ps_bitstrm, 1); 2741 ps_time_code->au1_discontinuity_flag[i] = value; 2742 2743 BITS_PARSE("cnt_dropped_flag[i]", value, ps_bitstrm, 1); 2744 ps_time_code->au1_cnt_dropped_flag[i] = value; 2745 2746 BITS_PARSE("n_frames[i]", value, ps_bitstrm, 9); 2747 ps_time_code->au2_n_frames[i] = value; 2748 2749 if(ps_time_code->au1_full_timestamp_flag[i]) 2750 { 2751 BITS_PARSE("seconds_value[i]", value, ps_bitstrm, 6); 2752 ps_time_code->au1_seconds_value[i] = value; 2753 2754 BITS_PARSE("minutes_value[i]", value, ps_bitstrm, 6); 2755 ps_time_code->au1_minutes_value[i] = value; 2756 2757 BITS_PARSE("hours_value[i]", value, ps_bitstrm, 5); 2758 ps_time_code->au1_hours_value[i] = value; 2759 } 2760 else 2761 { 2762 BITS_PARSE("seconds_flag[i]", value, ps_bitstrm, 1); 2763 ps_time_code->au1_seconds_flag[i] = value; 2764 2765 if(ps_time_code->au1_seconds_flag[i]) 2766 { 2767 BITS_PARSE("seconds_value[i]", value, ps_bitstrm, 6); 2768 ps_time_code->au1_seconds_value[i] = value; 2769 2770 BITS_PARSE("minutes_flag[i]", value, ps_bitstrm, 1); 2771 ps_time_code->au1_minutes_flag[i] = value; 2772 2773 if(ps_time_code->au1_minutes_flag[i]) 2774 { 2775 BITS_PARSE("minutes_value[i]", value, ps_bitstrm, 6); 2776 ps_time_code->au1_minutes_value[i] = value; 2777 2778 BITS_PARSE("hours_flag[i]", value, ps_bitstrm, 1); 2779 ps_time_code->au1_hours_flag[i] = value; 2780 2781 if(ps_time_code->au1_hours_flag[i]) 2782 { 2783 BITS_PARSE("hours_value[i]", value, ps_bitstrm, 5); 2784 ps_time_code->au1_hours_value[i] = value; 2785 } 2786 } 2787 } 2788 } 2789 2790 BITS_PARSE("time_offset_length[i]", value, ps_bitstrm, 5); 2791 ps_time_code->au1_time_offset_length[i] = value; 2792 2793 if(ps_time_code->au1_time_offset_length[i] > 0) 2794 { 2795 BITS_PARSE("time_offset_value[i]", value, ps_bitstrm, 2796 ps_time_code->au1_time_offset_length[i]); 2797 ps_time_code->au1_time_offset_value[i] = value; 2798 } 2799 else 2800 { 2801 ps_time_code->au1_time_offset_value[i] = 0; 2802 } 2803 } 2804 } 2805 2806 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 2807 } 2808 2809 IHEVCD_ERROR_T ihevcd_parse_mastering_disp_params_sei(codec_t *ps_codec) 2810 { 2811 parse_ctxt_t *ps_parse = &ps_codec->s_parse; 2812 bitstrm_t *ps_bitstrm = &ps_parse->s_bitstrm; 2813 UWORD32 value; 2814 mastering_dis_col_vol_sei_params_t *ps_mastering_dis_col_vol; 2815 WORD32 i; 2816 2817 ps_parse->s_sei_params.i4_sei_mastering_disp_colour_vol_params_present_flags = 1; 2818 2819 ps_mastering_dis_col_vol = &ps_parse->s_sei_params.s_mastering_dis_col_vol_sei_params; 2820 2821 for(i = 0; i < 3; i++) 2822 { 2823 BITS_PARSE("display_primaries_x[c]", value, ps_bitstrm, 16); 2824 ps_mastering_dis_col_vol->au2_display_primaries_x[i] = value; 2825 2826 BITS_PARSE("display_primaries_y[c]", value, ps_bitstrm, 16); 2827 ps_mastering_dis_col_vol->au2_display_primaries_y[i] = value; 2828 } 2829 2830 BITS_PARSE("white_point_x", value, ps_bitstrm, 16); 2831 ps_mastering_dis_col_vol->u2_white_point_x = value; 2832 2833 BITS_PARSE("white_point_y", value, ps_bitstrm, 16); 2834 ps_mastering_dis_col_vol->u2_white_point_y = value; 2835 2836 BITS_PARSE("max_display_mastering_luminance", value, ps_bitstrm, 32); 2837 ps_mastering_dis_col_vol->u4_max_display_mastering_luminance = value; 2838 2839 BITS_PARSE("min_display_mastering_luminance", value, ps_bitstrm, 32); 2840 ps_mastering_dis_col_vol->u4_min_display_mastering_luminance = value; 2841 2842 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 2843 } 2844 2845 IHEVCD_ERROR_T ihevcd_parse_user_data_registered_itu_t_t35(codec_t *ps_codec, 2846 UWORD32 u4_payload_size) 2847 { 2848 parse_ctxt_t *ps_parse = &ps_codec->s_parse; 2849 bitstrm_t *ps_bitstrm = &ps_parse->s_bitstrm; 2850 UWORD32 value; 2851 user_data_registered_itu_t_t35_t *ps_user_data_registered_itu_t_t35; 2852 UWORD32 i; 2853 UWORD32 j = 0; 2854 2855 ps_parse->s_sei_params.i1_user_data_registered_present_flag = 1; 2856 ps_user_data_registered_itu_t_t35 = 2857 &ps_parse->s_sei_params.as_user_data_registered_itu_t_t35[ps_parse->s_sei_params.i4_sei_user_data_cnt]; 2858 ps_parse->s_sei_params.i4_sei_user_data_cnt++; 2859 2860 ps_user_data_registered_itu_t_t35->i4_payload_size = u4_payload_size; 2861 2862 if(u4_payload_size > MAX_USERDATA_PAYLOAD) 2863 { 2864 u4_payload_size = MAX_USERDATA_PAYLOAD; 2865 } 2866 2867 ps_user_data_registered_itu_t_t35->i4_valid_payload_size = u4_payload_size; 2868 2869 BITS_PARSE("itu_t_t35_country_code", value, ps_bitstrm, 8); 2870 ps_user_data_registered_itu_t_t35->u1_itu_t_t35_country_code = value; 2871 2872 if(0xFF != ps_user_data_registered_itu_t_t35->u1_itu_t_t35_country_code) 2873 { 2874 i = 1; 2875 } 2876 else 2877 { 2878 BITS_PARSE("itu_t_t35_country_code_extension_byte", value, ps_bitstrm, 2879 8); 2880 ps_user_data_registered_itu_t_t35->u1_itu_t_t35_country_code_extension_byte = 2881 value; 2882 2883 i = 2; 2884 } 2885 2886 do 2887 { 2888 BITS_PARSE("itu_t_t35_payload_byte", value, ps_bitstrm, 8); 2889 ps_user_data_registered_itu_t_t35->u1_itu_t_t35_payload_byte[j++] = 2890 value; 2891 2892 i++; 2893 }while(i < u4_payload_size); 2894 2895 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 2896 } 2897 2898 void ihevcd_parse_sei_payload(codec_t *ps_codec, 2899 UWORD32 u4_payload_type, 2900 UWORD32 u4_payload_size, 2901 WORD8 i1_nal_type) 2902 { 2903 parse_ctxt_t *ps_parse = &ps_codec->s_parse; 2904 bitstrm_t *ps_bitstrm = &ps_parse->s_bitstrm; 2905 WORD32 payload_bits_remaining = 0; 2906 sps_t *ps_sps; 2907 2908 UWORD32 i; 2909 2910 for(i = 0; i < MAX_SPS_CNT; i++) 2911 { 2912 ps_sps = ps_codec->ps_sps_base + i; 2913 if(ps_sps->i1_sps_valid) 2914 { 2915 break; 2916 } 2917 } 2918 if(!ps_sps->i1_sps_valid) 2919 { 2920 return; 2921 } 2922 2923 if(NAL_PREFIX_SEI == i1_nal_type) 2924 { 2925 switch(u4_payload_type) 2926 { 2927 case SEI_BUFFERING_PERIOD: 2928 ps_parse->s_sei_params.i1_sei_parameters_present_flag = 1; 2929 ihevcd_parse_buffering_period_sei(ps_codec, ps_sps); 2930 break; 2931 2932 case SEI_PICTURE_TIMING: 2933 ps_parse->s_sei_params.i1_sei_parameters_present_flag = 1; 2934 ihevcd_parse_pic_timing_sei(ps_codec, ps_sps); 2935 break; 2936 2937 case SEI_TIME_CODE: 2938 ps_parse->s_sei_params.i1_sei_parameters_present_flag = 1; 2939 ihevcd_parse_time_code_sei(ps_codec); 2940 break; 2941 2942 case SEI_MASTERING_DISPLAY_COLOUR_VOLUME: 2943 ps_parse->s_sei_params.i4_sei_mastering_disp_colour_vol_params_present_flags = 1; 2944 ihevcd_parse_mastering_disp_params_sei(ps_codec); 2945 break; 2946 2947 case SEI_USER_DATA_REGISTERED_ITU_T_T35: 2948 ps_parse->s_sei_params.i1_sei_parameters_present_flag = 1; 2949 if(ps_parse->s_sei_params.i4_sei_user_data_cnt >= USER_DATA_MAX) 2950 { 2951 for(i = 0; i < u4_payload_size / 4; i++) 2952 { 2953 ihevcd_bits_flush(ps_bitstrm, 4 * 8); 2954 } 2955 2956 ihevcd_bits_flush(ps_bitstrm, (u4_payload_size - i * 4) * 8); 2957 } 2958 else 2959 { 2960 ihevcd_parse_user_data_registered_itu_t_t35(ps_codec, 2961 u4_payload_size); 2962 } 2963 break; 2964 2965 default: 2966 for(i = 0; i < u4_payload_size; i++) 2967 { 2968 ihevcd_bits_flush(ps_bitstrm, 8); 2969 } 2970 break; 2971 } 2972 } 2973 else /* NAL_SUFFIX_SEI */ 2974 { 2975 switch(u4_payload_type) 2976 { 2977 case SEI_USER_DATA_REGISTERED_ITU_T_T35: 2978 ps_parse->s_sei_params.i1_sei_parameters_present_flag = 1; 2979 if(ps_parse->s_sei_params.i4_sei_user_data_cnt >= USER_DATA_MAX) 2980 { 2981 for(i = 0; i < u4_payload_size / 4; i++) 2982 { 2983 ihevcd_bits_flush(ps_bitstrm, 4 * 8); 2984 } 2985 2986 ihevcd_bits_flush(ps_bitstrm, (u4_payload_size - i * 4) * 8); 2987 } 2988 else 2989 { 2990 ihevcd_parse_user_data_registered_itu_t_t35(ps_codec, 2991 u4_payload_size); 2992 } 2993 break; 2994 2995 default: 2996 for(i = 0; i < u4_payload_size; i++) 2997 { 2998 ihevcd_bits_flush(ps_bitstrm, 8); 2999 } 3000 break; 3001 } 3002 } 3003 3004 /** 3005 * By definition the underlying bitstream terminates in a byte-aligned manner. 3006 * 1. Extract all bar the last MIN(bitsremaining,nine) bits as reserved_payload_extension_data 3007 * 2. Examine the final 8 bits to determine the payload_bit_equal_to_one marker 3008 * 3. Extract the remainingreserved_payload_extension_data bits. 3009 * 3010 * If there are fewer than 9 bits available, extract them. 3011 */ 3012 3013 payload_bits_remaining = ihevcd_bits_num_bits_remaining(ps_bitstrm); 3014 if(payload_bits_remaining) /* more_data_in_payload() */ 3015 { 3016 WORD32 final_bits; 3017 WORD32 final_payload_bits = 0; 3018 WORD32 mask = 0xFF; 3019 UWORD32 u4_dummy; 3020 UWORD32 u4_reserved_payload_extension_data; 3021 UNUSED(u4_dummy); 3022 UNUSED(u4_reserved_payload_extension_data); 3023 3024 while(payload_bits_remaining > 9) 3025 { 3026 BITS_PARSE("reserved_payload_extension_data", 3027 u4_reserved_payload_extension_data, ps_bitstrm, 1); 3028 payload_bits_remaining--; 3029 } 3030 3031 final_bits = ihevcd_bits_nxt(ps_bitstrm, payload_bits_remaining); 3032 3033 while(final_bits & (mask >> final_payload_bits)) 3034 { 3035 final_payload_bits++; 3036 continue; 3037 } 3038 3039 while(payload_bits_remaining > (9 - final_payload_bits)) 3040 { 3041 BITS_PARSE("reserved_payload_extension_data", 3042 u4_reserved_payload_extension_data, ps_bitstrm, 1); 3043 payload_bits_remaining--; 3044 } 3045 3046 BITS_PARSE("payload_bit_equal_to_one", u4_dummy, ps_bitstrm, 1); 3047 payload_bits_remaining--; 3048 while(payload_bits_remaining) 3049 { 3050 BITS_PARSE("payload_bit_equal_to_zero", u4_dummy, ps_bitstrm, 1); 3051 payload_bits_remaining--; 3052 } 3053 } 3054 3055 return; 3056 } 3057 3058 IHEVCD_ERROR_T ihevcd_read_rbsp_trailing_bits(codec_t *ps_codec, 3059 UWORD32 u4_bits_left) 3060 { 3061 parse_ctxt_t *ps_parse = &ps_codec->s_parse; 3062 UWORD32 value; 3063 WORD32 cnt = 0; 3064 BITS_PARSE("rbsp_stop_one_bit", value, &ps_parse->s_bitstrm, 1); 3065 u4_bits_left--; 3066 if(value != 1) 3067 { 3068 return (IHEVCD_ERROR_T)IHEVCD_FAIL; 3069 } 3070 while(u4_bits_left) 3071 { 3072 BITS_PARSE("rbsp_alignment_zero_bit", value, &ps_parse->s_bitstrm, 1); 3073 u4_bits_left--; 3074 cnt++; 3075 } 3076 ASSERT(cnt < 8); 3077 3078 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 3079 } 3080 /** 3081 ******************************************************************************* 3082 * 3083 * @brief 3084 * Parses SEI (Supplemental Enhancement Information) 3085 * 3086 * @par Description: 3087 * Parses SEI (Supplemental Enhancement Information) as per Section: 7.3.7 3088 * 3089 * @param[in] ps_codec 3090 * Pointer to codec context 3091 * 3092 * @returns Error code from IHEVCD_ERROR_T 3093 * 3094 * @remarks 3095 * 3096 * 3097 ******************************************************************************* 3098 */ 3099 IHEVCD_ERROR_T ihevcd_parse_sei(codec_t *ps_codec, nal_header_t *ps_nal) 3100 { 3101 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 3102 parse_ctxt_t *ps_parse = &ps_codec->s_parse; 3103 UWORD32 u4_payload_type = 0, u4_last_payload_type_byte = 0; 3104 UWORD32 u4_payload_size = 0, u4_last_payload_size_byte = 0; 3105 UWORD32 value; 3106 bitstrm_t *ps_bitstrm = &ps_parse->s_bitstrm; 3107 UWORD32 u4_bits_left; 3108 3109 u4_bits_left = ihevcd_bits_num_bits_remaining(ps_bitstrm); 3110 3111 while(u4_bits_left > 8) 3112 { 3113 while(ihevcd_bits_nxt(ps_bitstrm, 8) == 0xFF) 3114 { 3115 ihevcd_bits_flush(ps_bitstrm, 8); /* equal to 0xFF */ 3116 u4_payload_type += 255; 3117 } 3118 3119 BITS_PARSE("last_payload_type_byte", value, ps_bitstrm, 8); 3120 u4_last_payload_type_byte = value; 3121 3122 u4_payload_type += u4_last_payload_type_byte; 3123 3124 while(ihevcd_bits_nxt(ps_bitstrm, 8) == 0xFF) 3125 { 3126 ihevcd_bits_flush(ps_bitstrm, 8); /* equal to 0xFF */ 3127 u4_payload_size += 255; 3128 } 3129 3130 BITS_PARSE("last_payload_size_byte", value, ps_bitstrm, 8); 3131 u4_last_payload_size_byte = value; 3132 3133 u4_payload_size += u4_last_payload_size_byte; 3134 u4_bits_left = ihevcd_bits_num_bits_remaining(ps_bitstrm); 3135 u4_payload_size = MIN(u4_payload_size, u4_bits_left / 8); 3136 ihevcd_parse_sei_payload(ps_codec, u4_payload_type, u4_payload_size, 3137 ps_nal->i1_nal_unit_type); 3138 3139 /* Calculate the bits left in the current payload */ 3140 u4_bits_left = ihevcd_bits_num_bits_remaining(ps_bitstrm); 3141 } 3142 3143 // read rbsp_trailing_bits 3144 if(u4_bits_left) 3145 { 3146 ihevcd_read_rbsp_trailing_bits(ps_codec, u4_bits_left); 3147 } 3148 3149 return ret; 3150 } 3151 3152 /** 3153 ******************************************************************************* 3154 * 3155 * @brief 3156 * Parses Access unit delimiter 3157 * 3158 * @par Description: 3159 * Parses Access unit delimiter as per section Section: 7.3.2.5 3160 * 3161 * @param[in] ps_codec 3162 * Pointer to codec context 3163 * 3164 * @returns Error code from IHEVCD_ERROR_T 3165 * 3166 * @remarks 3167 * 3168 * 3169 ******************************************************************************* 3170 */ 3171 WORD32 ihevcd_parse_aud(codec_t *ps_codec) 3172 { 3173 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; 3174 UNUSED(ps_codec); 3175 return ret; 3176 } 3177 3178 WORD32 ihevcd_extend_sign_bit(WORD32 value, WORD32 num_bits) 3179 { 3180 WORD32 ret_value = value; 3181 if(value >> (num_bits - 1)) 3182 { 3183 ret_value |= (0xFFFFFFFF << num_bits); 3184 } 3185 return ret_value; 3186 } 3187 3188 /** 3189 ******************************************************************************* 3190 * 3191 * @brief 3192 * Calculate POC of the current slice 3193 * 3194 * @par Description: 3195 * Calculates the current POC using the previous POC lsb and previous POC msb 3196 * 3197 * @param[in] ps_codec 3198 * Pointer to codec context 3199 * 3200 * @param[in] i1_pic_order_cnt_lsb 3201 * Current POC lsb 3202 * 3203 * @returns Current absolute POC 3204 * 3205 * @remarks 3206 * 3207 * 3208 ******************************************************************************* 3209 */ 3210 3211 WORD32 ihevcd_calc_poc(codec_t *ps_codec, nal_header_t *ps_nal, WORD8 i1_log2_max_poc_lsb, WORD32 i2_poc_lsb) 3212 { 3213 WORD32 i4_abs_poc, i4_poc_msb; 3214 WORD32 max_poc_lsb; 3215 WORD8 i1_nal_unit_type = ps_nal->i1_nal_unit_type; 3216 max_poc_lsb = (1 << i1_log2_max_poc_lsb); 3217 3218 if((!ps_codec->i4_first_pic_done) && (!ps_codec->i4_pic_present)) 3219 ps_codec->i4_prev_poc_msb = -2 * max_poc_lsb; 3220 3221 if(NAL_IDR_N_LP == i1_nal_unit_type 3222 || NAL_IDR_W_LP == i1_nal_unit_type 3223 || NAL_BLA_N_LP == i1_nal_unit_type 3224 || NAL_BLA_W_DLP == i1_nal_unit_type 3225 || NAL_BLA_W_LP == i1_nal_unit_type 3226 || (NAL_CRA == i1_nal_unit_type && !ps_codec->i4_first_pic_done)) 3227 { 3228 i4_poc_msb = ps_codec->i4_prev_poc_msb + 2 * max_poc_lsb; 3229 ps_codec->i4_prev_poc_lsb = 0; 3230 ps_codec->i4_max_prev_poc_lsb = 0; 3231 // ps_codec->i4_prev_poc_msb = 0; 3232 } 3233 else 3234 { 3235 3236 if((i2_poc_lsb < ps_codec->i4_prev_poc_lsb) 3237 && ((ps_codec->i4_prev_poc_lsb - i2_poc_lsb) >= max_poc_lsb / 2)) 3238 { 3239 i4_poc_msb = ps_codec->i4_prev_poc_msb + max_poc_lsb; 3240 } 3241 else if((i2_poc_lsb > ps_codec->i4_prev_poc_lsb) 3242 && ((i2_poc_lsb - ps_codec->i4_prev_poc_lsb) > max_poc_lsb / 2)) 3243 { 3244 i4_poc_msb = ps_codec->i4_prev_poc_msb - max_poc_lsb; 3245 } 3246 else 3247 { 3248 i4_poc_msb = ps_codec->i4_prev_poc_msb; 3249 } 3250 3251 3252 } 3253 3254 i4_abs_poc = i4_poc_msb + i2_poc_lsb; 3255 ps_codec->i4_max_prev_poc_lsb = MAX(ps_codec->i4_max_prev_poc_lsb, i2_poc_lsb); 3256 3257 { 3258 WORD32 is_reference_nal = ((i1_nal_unit_type <= NAL_RSV_VCL_R15) && (i1_nal_unit_type % 2 != 0)) || ((i1_nal_unit_type >= NAL_BLA_W_LP) && (i1_nal_unit_type <= NAL_RSV_RAP_VCL23)); 3259 WORD32 update_prev_poc = ((is_reference_nal) && ((i1_nal_unit_type < NAL_RADL_N) || (i1_nal_unit_type > NAL_RASL_R))); 3260 3261 if((0 == ps_nal->i1_nuh_temporal_id) && 3262 (update_prev_poc)) 3263 { 3264 ps_codec->i4_prev_poc_lsb = i2_poc_lsb; 3265 ps_codec->i4_prev_poc_msb = i4_poc_msb; 3266 } 3267 } 3268 3269 return i4_abs_poc; 3270 } 3271 3272 3273 void ihevcd_copy_slice_hdr(codec_t *ps_codec, WORD32 slice_idx, WORD32 slice_idx_ref) 3274 { 3275 slice_header_t *ps_slice_hdr, *ps_slice_hdr_ref; 3276 WORD32 *pu4_entry_offset_backup; 3277 3278 ps_slice_hdr = ps_codec->s_parse.ps_slice_hdr_base + slice_idx; 3279 ps_slice_hdr_ref = ps_codec->s_parse.ps_slice_hdr_base + slice_idx_ref; 3280 3281 pu4_entry_offset_backup = ps_slice_hdr->pu4_entry_point_offset; 3282 memcpy(ps_slice_hdr, ps_slice_hdr_ref, sizeof(slice_header_t)); 3283 ps_slice_hdr->pu4_entry_point_offset = pu4_entry_offset_backup; 3284 } 3285 3286 3287 3288
