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