1 /****************************************************************************** 2 * 3 * Copyright (C) 2018 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ***************************************************************************** 18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore 19 */ 20 21 /** 22 ****************************************************************************** 23 * @file ihevce_encode_header.c 24 * 25 * @brief 26 * This file contains function definitions related to header encoding 27 * 28 * @author 29 * Ittiam 30 * 31 * List of Functions 32 * ihevce_generate_nal_unit_header 33 * ihevce_generate_when_profile_present 34 * ihevce_generate_profile_tier_level 35 * ihevce_short_term_ref_pic_set 36 * ihevce_generate_bit_rate_pic_rate_info 37 * ihevce_generate_aud 38 * ihevce_generate_eos 39 * ihevce_generate_vps 40 * ihevce_generate_sps 41 * ihevce_generate_pps 42 * ihevce_generate_slice_header 43 * ihevce_populate_vps 44 * ihevce_populate_sps 45 * ihevce_populate_pps 46 * ihevce_populate_slice_header 47 * ihevce_insert_entry_offset_slice_header 48 * 49 ****************************************************************************** 50 */ 51 52 /*****************************************************************************/ 53 /* File Includes */ 54 /*****************************************************************************/ 55 /* System include files */ 56 #include <stdio.h> 57 #include <string.h> 58 #include <stdlib.h> 59 #include <assert.h> 60 #include <stdarg.h> 61 #include <math.h> 62 63 /* User include files */ 64 #include "ihevc_typedefs.h" 65 #include "itt_video_api.h" 66 #include "ihevce_api.h" 67 68 #include "rc_cntrl_param.h" 69 #include "rc_frame_info_collector.h" 70 #include "rc_look_ahead_params.h" 71 72 #include "ihevc_defs.h" 73 #include "ihevc_macros.h" 74 #include "ihevc_debug.h" 75 #include "ihevc_structs.h" 76 #include "ihevc_platform_macros.h" 77 #include "ihevc_deblk.h" 78 #include "ihevc_itrans_recon.h" 79 #include "ihevc_chroma_itrans_recon.h" 80 #include "ihevc_chroma_intra_pred.h" 81 #include "ihevc_intra_pred.h" 82 #include "ihevc_inter_pred.h" 83 #include "ihevc_mem_fns.h" 84 #include "ihevc_padding.h" 85 #include "ihevc_weighted_pred.h" 86 #include "ihevc_sao.h" 87 #include "ihevc_resi_trans.h" 88 #include "ihevc_quant_iquant_ssd.h" 89 #include "ihevc_cabac_tables.h" 90 #include "ihevc_trans_tables.h" 91 #include "ihevc_trans_macros.h" 92 93 #include "ihevce_defs.h" 94 #include "ihevce_lap_enc_structs.h" 95 #include "ihevce_multi_thrd_structs.h" 96 #include "ihevce_multi_thrd_funcs.h" 97 #include "ihevce_me_common_defs.h" 98 #include "ihevce_had_satd.h" 99 #include "ihevce_error_codes.h" 100 #include "ihevce_error_checks.h" 101 #include "ihevce_bitstream.h" 102 #include "ihevce_cabac.h" 103 #include "ihevce_rdoq_macros.h" 104 #include "ihevce_function_selector.h" 105 #include "ihevce_enc_structs.h" 106 #include "ihevce_global_tables.h" 107 #include "ihevce_encode_header.h" 108 #include "ihevce_encode_header_sei_vui.h" 109 #include "ihevce_trace.h" 110 111 /*****************************************************************************/ 112 /* Constant Macros */ 113 /*****************************************************************************/ 114 #define CU_LEVEL_QP_LIMIT_8x8 3 115 #define CU_LEVEL_QP_LIMIT_16x16 2 116 #define CU_LEVEL_QP_LIMIT_32x32 1 117 118 /*****************************************************************************/ 119 /* Function Definitions */ 120 /*****************************************************************************/ 121 122 /** 123 ****************************************************************************** 124 * 125 * @brief Generate nal unit header in the stream as per section 7.3.1.2 126 * 127 * @par Description 128 * Inserts the nal type and temporal id plus 1 as per section 7.3.1.2 Nal unit 129 * header syntax 130 * 131 * @param[inout] ps_bitstrm 132 * pointer to bitstream context (handle) 133 * 134 * @param[in] nal_unit_type 135 * nal type to be inserted 136 * 137 * @param[in] temporal id 138 * temporal id to be inserted 139 * 140 * @return success or failure error code 141 * 142 ****************************************************************************** 143 */ 144 WORD32 ihevce_generate_nal_unit_header( 145 bitstrm_t *ps_bitstrm, WORD32 nal_unit_type, WORD32 nuh_temporal_id) 146 { 147 WORD32 return_status = IHEVCE_SUCCESS; 148 149 /* sanity checks */ 150 ASSERT((nal_unit_type >= 0) && (nal_unit_type < 64)); 151 ASSERT((nuh_temporal_id >= 0) && (nuh_temporal_id < 7)); 152 153 /* forbidden_zero_bit + nal_unit_type */ 154 PUT_BITS( 155 ps_bitstrm, 156 nal_unit_type, 157 (1 + 6), /*extra 1 is for forbidden zero bit */ 158 return_status); 159 160 /* nuh_reserved_zero_6bits */ 161 PUT_BITS(ps_bitstrm, 0, 6, return_status); 162 163 /* nuh_temporal_id_plus1 */ 164 PUT_BITS(ps_bitstrm, (nuh_temporal_id + 1), 3, return_status); 165 166 return (return_status); 167 } 168 169 /** 170 ****************************************************************************** 171 * 172 * @brief Generates fields related to Profile, Tier and Level data. 173 * 174 * @par Description 175 * Generates fields related to Profile, Tier and Level data. 176 * Called when profile_present flag is 1 177 * 178 * @param[in] ps_bitstrm 179 * pointer to bitstream context (handle) 180 * 181 * @param[in] ps_ptl 182 * pointer to structure containing Profile, Tier and Level data data 183 * 184 * @return success or failure error code 185 * 186 ****************************************************************************** 187 */ 188 static WORD32 189 ihevce_generate_when_profile_present(bitstrm_t *ps_bitstrm, profile_tier_lvl_t *ps_ptl) 190 { 191 WORD32 return_status = IHEVCE_SUCCESS; 192 WORD32 i; 193 194 /* XXX_profile_space[] */ 195 PUT_BITS(ps_bitstrm, ps_ptl->i1_profile_space, 2, return_status); 196 ENTROPY_TRACE("XXX_profile_space[]", ps_ptl->i1_profile_space); 197 198 /* XXX_tier_flag[] */ 199 PUT_BITS(ps_bitstrm, ps_ptl->i1_tier_flag, 1, return_status); 200 ENTROPY_TRACE("XXX_tier_flag[]", ps_ptl->i1_tier_flag); 201 202 /* XXX_profile_idc[] */ 203 PUT_BITS(ps_bitstrm, ps_ptl->i1_profile_idc, 5, return_status); 204 ENTROPY_TRACE("XXX_profile_idc[]", ps_ptl->i1_profile_idc); 205 206 for(i = 0; i < MAX_PROFILE_COMPATBLTY; i++) 207 { 208 /* XXX_profile_compatibility_flag[][j] */ 209 PUT_BITS(ps_bitstrm, ps_ptl->ai1_profile_compatibility_flag[i], 1, return_status); 210 ENTROPY_TRACE( 211 "XXX_profile_compatibility_flag[][j]", ps_ptl->ai1_profile_compatibility_flag[i]); 212 } 213 214 /* XXX_progressive_source_flag[] */ 215 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_progressive_source_flag, 1, return_status); 216 ENTROPY_TRACE("XXX_progressive_source_flag[]", ps_ptl->i1_general_progressive_source_flag); 217 218 /* XXX_interlaced_source_flag[] */ 219 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_interlaced_source_flag, 1, return_status); 220 ENTROPY_TRACE("XXX_interlaced_source_flag[]", ps_ptl->i1_general_interlaced_source_flag); 221 222 /* XXX_non_packed_constraint_flag[] */ 223 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_non_packed_constraint_flag, 1, return_status); 224 ENTROPY_TRACE( 225 "XXX_non_packed_constraint_flag[]", ps_ptl->i1_general_non_packed_constraint_flag); 226 227 /* XXX_frame_only_constraint_flag[] */ 228 PUT_BITS(ps_bitstrm, ps_ptl->i1_frame_only_constraint_flag, 1, return_status); 229 ENTROPY_TRACE("XXX_frame_only_constraint_flag[]", ps_ptl->i1_frame_only_constraint_flag); 230 231 /* XXX_general_max_12bit_constraint_flag[] */ 232 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_12bit_constraint_flag, 1, return_status); 233 ENTROPY_TRACE( 234 "XXX_general_max_12bit_constraint_flag[]", ps_ptl->i1_general_max_12bit_constraint_flag); 235 236 /* XXX_general_max_10bit_constraint_flag[] */ 237 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_10bit_constraint_flag, 1, return_status); 238 ENTROPY_TRACE( 239 "XXX_general_max_10bit_constraint_flag[]", ps_ptl->i1_general_max_10bit_constraint_flag); 240 241 /* XXX_general_max_8bit_constraint_flag[] */ 242 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_8bit_constraint_flag, 1, return_status); 243 ENTROPY_TRACE( 244 "XXX_general_max_8bit_constraint_flag[]", ps_ptl->i1_general_max_8bit_constraint_flag); 245 246 /* XXX_general_max_422chroma_constraint_flag[] */ 247 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_422chroma_constraint_flag, 1, return_status); 248 ENTROPY_TRACE( 249 "XXX_general_max_422chroma_constraint_flag[]", 250 ps_ptl->i1_general_max_422chroma_constraint_flag); 251 252 /* XXX_general_max_420chroma_constraint_flag[] */ 253 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_420chroma_constraint_flag, 1, return_status); 254 ENTROPY_TRACE( 255 "XXX_general_max_420chroma_constraint_flag[]", 256 ps_ptl->i1_general_max_420chroma_constraint_flag); 257 258 /* XXX_general_max_monochrome_constraint_flag[] */ 259 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_monochrome_constraint_flag, 1, return_status); 260 ENTROPY_TRACE( 261 "XXX_general_max_monochrome_constraint_flag[]", 262 ps_ptl->i1_general_max_monochrome_constraint_flag); 263 264 /* XXX_general_intra_constraint_flag[] */ 265 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_intra_constraint_flag, 1, return_status); 266 ENTROPY_TRACE("XXX_general_intra_constraint_flag[]", ps_ptl->i1_general_intra_constraint_flag); 267 268 /* XXX_general_one_picture_only_constraint_flag[] */ 269 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_one_picture_only_constraint_flag, 1, return_status); 270 ENTROPY_TRACE( 271 "XXX_general_one_picture_only_constraint_flag[]", 272 ps_ptl->i1_general_one_picture_only_constraint_flag); 273 274 /* XXX_general_lower_bit_rate_constraint_flag[] */ 275 PUT_BITS(ps_bitstrm, ps_ptl->i1_general_lower_bit_rate_constraint_flag, 1, return_status); 276 ENTROPY_TRACE( 277 "XXX_general_lower_bit_rate_constraint_flag[]", 278 ps_ptl->i1_general_lower_bit_rate_constraint_flag); 279 280 /* XXX_reserved_zero_35bits[] */ 281 PUT_BITS(ps_bitstrm, 0, 16, return_status); 282 PUT_BITS(ps_bitstrm, 0, 16, return_status); 283 PUT_BITS(ps_bitstrm, 0, 3, return_status); 284 ENTROPY_TRACE("XXX_reserved_zero_35bits[]", 0); 285 286 return return_status; 287 } 288 289 /** 290 ****************************************************************************** 291 * 292 * @brief Generates Profile, Tier and Level data 293 * 294 * @par Description 295 * Generates Profile, Tier and Level data as per Section 7.3.3 296 * 297 * @param[in] ps_bitstrm 298 * pointer to bitstream context (handle) 299 * 300 * @param[in] ps_ptl 301 * pointer to structure containing Profile, Tier and Level data data 302 * 303 * @param[in] i1_profile_present_flag 304 * flag that indicates whether profile-related data is present 305 * 306 * @param[in] i1_vps_max_sub_layers_minus1 307 * (Maximum number of sub_layers present) minus 1 308 * 309 * @return success or failure error code 310 * 311 ****************************************************************************** 312 */ 313 static WORD32 ihevce_generate_profile_tier_level( 314 bitstrm_t *ps_bitstrm, 315 profile_tier_lvl_info_t *ps_ptl, 316 WORD8 i1_profile_present_flag, 317 WORD8 i1_max_sub_layers_minus1) 318 { 319 WORD32 i; 320 WORD32 return_status = IHEVCE_SUCCESS; 321 322 if(i1_profile_present_flag) 323 { 324 ihevce_generate_when_profile_present(ps_bitstrm, &ps_ptl->s_ptl_gen); 325 } 326 327 /* general_level_idc */ 328 PUT_BITS(ps_bitstrm, ps_ptl->s_ptl_gen.u1_level_idc, 8, return_status); 329 ENTROPY_TRACE("general_level_idc", ps_ptl->s_ptl_gen.u1_level_idc); 330 331 for(i = 0; i < i1_max_sub_layers_minus1; i++) 332 { 333 /* sub_layer_profile_present_flag[i] */ 334 PUT_BITS(ps_bitstrm, ps_ptl->ai1_sub_layer_profile_present_flag[i], 1, return_status); 335 ENTROPY_TRACE( 336 "sub_layer_profile_present_flag[i]", ps_ptl->ai1_sub_layer_profile_present_flag[i]); 337 338 /* sub_layer_level_present_flag[i] */ 339 PUT_BITS(ps_bitstrm, ps_ptl->ai1_sub_layer_level_present_flag[i], 1, return_status); 340 ENTROPY_TRACE( 341 "sub_layer_level_present_flag[i]", ps_ptl->ai1_sub_layer_level_present_flag[i]); 342 } 343 344 if(i1_max_sub_layers_minus1 > 0) 345 { 346 for(i = i1_max_sub_layers_minus1; i < 8; i++) 347 { 348 /* reserved_zero_2bits[i] */ 349 PUT_BITS(ps_bitstrm, 0, 2, return_status); 350 ENTROPY_TRACE("reserved_zero_2bits[i]", 0); 351 } 352 } 353 354 for(i = 0; i < i1_max_sub_layers_minus1; i++) 355 { 356 if(ps_ptl->ai1_sub_layer_profile_present_flag[i]) 357 { 358 ihevce_generate_when_profile_present(ps_bitstrm, &ps_ptl->as_ptl_sub[i]); 359 } 360 361 if(ps_ptl->ai1_sub_layer_level_present_flag[i]) //TEMPORALA_SCALABILITY CHANGES BUG_FIX 362 { 363 /* sub_layer_level_idc[i] */ 364 PUT_BITS(ps_bitstrm, ps_ptl->as_ptl_sub[i].u1_level_idc, 8, return_status); 365 ENTROPY_TRACE("sub_layer_level_idc[i]", ps_ptl->as_ptl_sub[i].u1_level_idc); 366 } 367 } 368 369 return return_status; 370 } 371 372 /** 373 ******************************************************************************* 374 * 375 * @brief 376 * Generates short term reference picture set 377 * 378 * @par Description 379 * Generates short term reference picture set as per section 7.3.5.2. 380 * Can be called by either SPS or Slice header parsing modules. 381 * 382 * @param[in] ps_bitstrm 383 * Pointer to bitstream structure 384 * 385 * @param[out] ps_stref_picset_base 386 * Pointer to first short term ref pic set structure 387 * 388 * @param[in] num_short_term_ref_pic_sets 389 * Number of short term reference pic sets 390 * 391 * @param[in] idx 392 * Current short term ref pic set id 393 * 394 * @returns Error code from WORD32 395 * 396 * 397 ******************************************************************************* 398 */ 399 static WORD32 ihevce_short_term_ref_pic_set( 400 bitstrm_t *ps_bitstrm, 401 stref_picset_t *ps_stref_picset_base, 402 WORD32 num_short_term_ref_pic_sets, 403 WORD32 idx, 404 WORD32 *pi4_NumPocTotalCurr) 405 { 406 WORD32 i; 407 WORD32 return_status = IHEVCE_SUCCESS; 408 stref_picset_t *ps_stref_picset = ps_stref_picset_base + idx; 409 410 (void)num_short_term_ref_pic_sets; 411 if(idx > 0) 412 { 413 /* inter_ref_pic_set_prediction_flag */ 414 PUT_BITS( 415 ps_bitstrm, ps_stref_picset->i1_inter_ref_pic_set_prediction_flag, 1, return_status); 416 ENTROPY_TRACE( 417 "inter_ref_pic_set_prediction_flag", 418 ps_stref_picset->i1_inter_ref_pic_set_prediction_flag); 419 } 420 421 /* This flag is assumed to be 0 for now */ 422 ASSERT(0 == ps_stref_picset->i1_inter_ref_pic_set_prediction_flag); 423 424 /* num_negative_pics */ 425 PUT_BITS_UEV(ps_bitstrm, ps_stref_picset->i1_num_neg_pics, return_status); 426 ENTROPY_TRACE("num_negative_pics", ps_stref_picset->i1_num_neg_pics); 427 428 /* num_positive_pics */ 429 PUT_BITS_UEV(ps_bitstrm, ps_stref_picset->i1_num_pos_pics, return_status); 430 ENTROPY_TRACE("num_positive_pics", ps_stref_picset->i1_num_pos_pics); 431 432 for(i = 0; i < ps_stref_picset->i1_num_neg_pics; i++) 433 { 434 /* delta_poc_s0_minus1 */ 435 PUT_BITS_UEV(ps_bitstrm, ps_stref_picset->ai2_delta_poc[i] - 1, return_status); 436 ENTROPY_TRACE("delta_poc_s0_minus1", ps_stref_picset->ai2_delta_poc[i] - 1); 437 438 /* used_by_curr_pic_s0_flag */ 439 PUT_BITS(ps_bitstrm, ps_stref_picset->ai1_used[i], 1, return_status); 440 ENTROPY_TRACE("used_by_curr_pic_s0_flag", ps_stref_picset->ai1_used[i]); 441 /*get the num pocs used for cur pic*/ 442 if(ps_stref_picset->ai1_used[i]) 443 { 444 *pi4_NumPocTotalCurr += 1; 445 } 446 } 447 448 for(; i < (ps_stref_picset->i1_num_pos_pics + ps_stref_picset->i1_num_neg_pics); i++) 449 { 450 /* delta_poc_s1_minus1 */ 451 PUT_BITS_UEV(ps_bitstrm, ps_stref_picset->ai2_delta_poc[i] - 1, return_status); 452 ENTROPY_TRACE("delta_poc_s1_minus1", ps_stref_picset->ai2_delta_poc[i] - 1); 453 454 /* used_by_curr_pic_s1_flag */ 455 PUT_BITS(ps_bitstrm, ps_stref_picset->ai1_used[i], 1, return_status); 456 ENTROPY_TRACE("used_by_curr_pic_s1_flag", ps_stref_picset->ai1_used[i]); 457 /*get the num pocs used for cur pic*/ 458 if(ps_stref_picset->ai1_used[i]) 459 { 460 *pi4_NumPocTotalCurr += 1; 461 } 462 } 463 464 return return_status; 465 } 466 467 /** 468 ****************************************************************************** 469 * 470 * @brief Generates ref pic list modification 471 * 472 * @par Description 473 * Generate ref pic list modification syntax as per Section 7.3.6.2 474 * 475 * @param[in] ps_bitstrm 476 * pointer to bitstream context (handle) 477 * 478 * @param[in] ps_slice_hdr 479 * pointer to structure containing slice header 480 * 481 * @return success or failure error code 482 * 483 ****************************************************************************** 484 */ 485 static WORD32 ref_pic_list_modification( 486 bitstrm_t *ps_bitstrm, slice_header_t *ps_slice_hdr, WORD32 i4_NumPocTotalCurr) 487 { 488 WORD32 return_status = IHEVCE_SUCCESS; 489 WORD32 i; 490 491 /* ref_pic_list_modification_flag_l0 */ 492 PUT_BITS( 493 ps_bitstrm, ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0, 1, return_status); 494 ENTROPY_TRACE( 495 "ref_pic_list_modification_flag_l0", 496 ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0); 497 498 if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0) 499 { 500 for(i = 0; i <= (ps_slice_hdr->i1_num_ref_idx_l0_active - 1); i++) 501 { 502 WORD32 num_bits = 32 - CLZ(i4_NumPocTotalCurr - 1); 503 504 /* list_entry_l0[ i ] */ 505 PUT_BITS(ps_bitstrm, ps_slice_hdr->s_rplm.i1_list_entry_l0[i], num_bits, return_status); 506 ENTROPY_TRACE("list_entry_l0", ps_slice_hdr->s_rplm.i1_list_entry_l0[i]); 507 } 508 } 509 510 if((BSLICE == ps_slice_hdr->i1_slice_type)) 511 { 512 /* ref_pic_list_modification_flag_l1 */ 513 PUT_BITS( 514 ps_bitstrm, ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1, 1, return_status); 515 ENTROPY_TRACE( 516 "ref_pic_list_modification_flag_l1", 517 ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1); 518 519 if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1) 520 { 521 for(i = 0; i <= (ps_slice_hdr->i1_num_ref_idx_l1_active - 1); i++) 522 { 523 WORD32 num_bits = 32 - CLZ(i4_NumPocTotalCurr - 1); 524 525 /* list_entry_l1[ i ] */ 526 PUT_BITS( 527 ps_bitstrm, ps_slice_hdr->s_rplm.i1_list_entry_l1[i], num_bits, return_status); 528 ENTROPY_TRACE("list_entry_l1", ps_slice_hdr->s_rplm.i1_list_entry_l1[i]); 529 } 530 } 531 } /*end of B slice check*/ 532 533 return return_status; 534 } 535 536 /** 537 ****************************************************************************** 538 * 539 * @brief Generates Pred Weight Table 540 * 541 * @par Description 542 * Generate Pred Weight Table as per Section 7.3.5.4 543 * 544 * @param[in] ps_bitstrm 545 * pointer to bitstream context (handle) 546 * 547 * @param[in] ps_sps 548 * pointer to structure containing SPS data 549 * 550 * @param[in] ps_pps 551 * pointer to structure containing PPS data 552 * 553 * @param[in] ps_slice_hdr 554 * pointer to structure containing slice header 555 * 556 * @return success or failure error code 557 * 558 ****************************************************************************** 559 */ 560 static WORD32 ihevce_generate_pred_weight_table( 561 bitstrm_t *ps_bitstrm, sps_t *ps_sps, pps_t *ps_pps, slice_header_t *ps_slice_hdr) 562 { 563 WORD32 i; 564 WORD32 delta_luma_weight; 565 WORD32 delta_chroma_weight; 566 WORD32 return_status = IHEVCE_SUCCESS; 567 pred_wt_ofst_t *ps_wt_ofst = &ps_slice_hdr->s_wt_ofst; 568 UWORD32 u4_luma_log2_weight_denom = ps_wt_ofst->i1_luma_log2_weight_denom; 569 WORD32 chroma_log2_weight_denom = (ps_wt_ofst->i1_chroma_log2_weight_denom); 570 WORD32 i4_wght_count = 0; 571 572 (void)ps_pps; 573 /* luma_log2_weight_denom */ 574 PUT_BITS_UEV(ps_bitstrm, u4_luma_log2_weight_denom, return_status); 575 ENTROPY_TRACE("luma_log2_weight_denom", u4_luma_log2_weight_denom); 576 577 if(ps_sps->i1_chroma_format_idc != 0) 578 { 579 /* delta_chroma_log2_weight_denom */ 580 PUT_BITS_SEV( 581 ps_bitstrm, chroma_log2_weight_denom - u4_luma_log2_weight_denom, return_status); 582 ENTROPY_TRACE( 583 "delta_chroma_log2_weight_denom", chroma_log2_weight_denom - u4_luma_log2_weight_denom); 584 } 585 586 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) 587 { 588 /* luma_weight_l0_flag[ i ] */ 589 PUT_BITS(ps_bitstrm, ps_wt_ofst->i1_luma_weight_l0_flag[i], 1, return_status); 590 i4_wght_count += ps_wt_ofst->i1_luma_weight_l0_flag[i]; 591 assert(i4_wght_count <= 24); 592 ENTROPY_TRACE("luma_weight_l0_flag[ i ]", ps_wt_ofst->i1_luma_weight_l0_flag[i]); 593 } 594 595 if(ps_sps->i1_chroma_format_idc != 0) 596 { 597 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) 598 { 599 /* chroma_weight_l0_flag[ i ] */ 600 PUT_BITS(ps_bitstrm, ps_wt_ofst->i1_chroma_weight_l0_flag[i], 1, return_status); 601 i4_wght_count += 2 * ps_wt_ofst->i1_chroma_weight_l0_flag[i]; 602 assert(i4_wght_count <= 24); 603 ENTROPY_TRACE("chroma_weight_l0_flag[ i ]", ps_wt_ofst->i1_chroma_weight_l0_flag[i]); 604 } 605 } 606 607 delta_luma_weight = (1 << u4_luma_log2_weight_denom); 608 delta_chroma_weight = (1 << chroma_log2_weight_denom); 609 610 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) 611 { 612 if(ps_wt_ofst->i1_luma_weight_l0_flag[i]) 613 { 614 /* delta_luma_weight_l0[ i ] */ 615 PUT_BITS_SEV( 616 ps_bitstrm, ps_wt_ofst->i2_luma_weight_l0[i] - delta_luma_weight, return_status); 617 ENTROPY_TRACE( 618 "delta_luma_weight_l0[ i ]", ps_wt_ofst->i2_luma_weight_l0[i] - delta_luma_weight); 619 620 /* luma_offset_l0[ i ] */ 621 PUT_BITS_SEV(ps_bitstrm, ps_wt_ofst->i2_luma_offset_l0[i], return_status); 622 ENTROPY_TRACE("luma_offset_l0[ i ]", ps_wt_ofst->i2_luma_offset_l0[i]); 623 } 624 625 if(ps_wt_ofst->i1_chroma_weight_l0_flag[i]) 626 { 627 WORD32 shift = (1 << (BIT_DEPTH_CHROMA - 1)); 628 WORD32 delta_chroma_weight_l0[2]; 629 WORD32 delta_chroma_offset_l0[2]; 630 631 delta_chroma_weight_l0[0] = ps_wt_ofst->i2_chroma_weight_l0_cb[i] - delta_chroma_weight; 632 delta_chroma_weight_l0[1] = ps_wt_ofst->i2_chroma_weight_l0_cr[i] - delta_chroma_weight; 633 634 delta_chroma_offset_l0[0] = 635 ps_wt_ofst->i2_chroma_offset_l0_cb[i] + 636 ((shift * ps_wt_ofst->i2_chroma_weight_l0_cb[i]) >> chroma_log2_weight_denom) - 637 shift; 638 delta_chroma_offset_l0[1] = 639 ps_wt_ofst->i2_chroma_offset_l0_cr[i] + 640 ((shift * ps_wt_ofst->i2_chroma_weight_l0_cr[i]) >> chroma_log2_weight_denom) - 641 shift; 642 643 /* delta_chroma_weight_l0[ i ][j] */ 644 PUT_BITS_SEV(ps_bitstrm, delta_chroma_weight_l0[0], return_status); 645 ENTROPY_TRACE("delta_chroma_weight_l0[ i ]", delta_chroma_weight_l0[0]); 646 647 /* delta_chroma_offset_l0[ i ][j] */ 648 PUT_BITS_SEV(ps_bitstrm, delta_chroma_offset_l0[0], return_status); 649 ENTROPY_TRACE("delta_chroma_offset_l0[ i ]", delta_chroma_offset_l0[0]); 650 651 /* delta_chroma_weight_l0[ i ][j] */ 652 PUT_BITS_SEV(ps_bitstrm, delta_chroma_weight_l0[1], return_status); 653 ENTROPY_TRACE("delta_chroma_weight_l0[ i ]", delta_chroma_weight_l0[1]); 654 655 /* delta_chroma_offset_l0[ i ][j] */ 656 PUT_BITS_SEV(ps_bitstrm, delta_chroma_offset_l0[1], return_status); 657 ENTROPY_TRACE("delta_chroma_offset_l0[ i ]", delta_chroma_offset_l0[1]); 658 } 659 } 660 661 if(BSLICE == ps_slice_hdr->i1_slice_type) 662 { 663 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) 664 { 665 /* luma_weight_l1_flag[ i ] */ 666 PUT_BITS(ps_bitstrm, ps_wt_ofst->i1_luma_weight_l1_flag[i], 1, return_status); 667 i4_wght_count += ps_wt_ofst->i1_luma_weight_l1_flag[i]; 668 assert(i4_wght_count <= 24); 669 ENTROPY_TRACE("luma_weight_l1_flag[ i ]", ps_wt_ofst->i1_luma_weight_l1_flag[i]); 670 } 671 672 if(ps_sps->i1_chroma_format_idc != 0) 673 { 674 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) 675 { 676 /* chroma_weight_l1_flag[ i ] */ 677 PUT_BITS(ps_bitstrm, ps_wt_ofst->i1_chroma_weight_l1_flag[i], 1, return_status); 678 i4_wght_count += ps_wt_ofst->i1_chroma_weight_l1_flag[i]; 679 assert(i4_wght_count <= 24); 680 ENTROPY_TRACE( 681 "chroma_weight_l1_flag[ i ]", ps_wt_ofst->i1_chroma_weight_l1_flag[i]); 682 } 683 } 684 685 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) 686 { 687 if(ps_wt_ofst->i1_luma_weight_l1_flag[i]) 688 { 689 /* delta_luma_weight_l1[ i ] */ 690 PUT_BITS_SEV( 691 ps_bitstrm, 692 ps_wt_ofst->i2_luma_weight_l1[i] - delta_luma_weight, 693 return_status); 694 ENTROPY_TRACE( 695 "delta_luma_weight_l1[ i ]", 696 ps_wt_ofst->i2_luma_weight_l1[i] - delta_luma_weight); 697 698 /* luma_offset_l1[ i ] */ 699 PUT_BITS_SEV(ps_bitstrm, ps_wt_ofst->i2_luma_offset_l1[i], return_status); 700 ENTROPY_TRACE("luma_offset_l1[ i ]", ps_wt_ofst->i2_luma_offset_l1[i]); 701 } 702 703 if(ps_wt_ofst->i1_chroma_weight_l1_flag[i]) 704 { 705 WORD32 shift = (1 << (BIT_DEPTH_CHROMA - 1)); 706 WORD32 delta_chroma_weight_l1[2]; 707 WORD32 delta_chroma_offset_l1[2]; 708 709 delta_chroma_weight_l1[0] = 710 ps_wt_ofst->i2_chroma_weight_l1_cb[i] - delta_chroma_weight; 711 delta_chroma_weight_l1[1] = 712 ps_wt_ofst->i2_chroma_weight_l1_cr[i] - delta_chroma_weight; 713 714 delta_chroma_offset_l1[0] = 715 ps_wt_ofst->i2_chroma_offset_l1_cb[i] + 716 ((shift * ps_wt_ofst->i2_chroma_weight_l1_cb[i]) >> chroma_log2_weight_denom) - 717 shift; 718 delta_chroma_offset_l1[1] = 719 ps_wt_ofst->i2_chroma_offset_l1_cr[i] + 720 ((shift * ps_wt_ofst->i2_chroma_weight_l1_cr[i]) >> chroma_log2_weight_denom) - 721 shift; 722 723 /* delta_chroma_weight_l1[ i ][j] */ 724 PUT_BITS_SEV(ps_bitstrm, delta_chroma_weight_l1[0], return_status); 725 ENTROPY_TRACE("delta_chroma_weight_l1[ i ]", delta_chroma_weight_l1[0]); 726 727 /* delta_chroma_offset_l1[ i ][j] */ 728 PUT_BITS_SEV(ps_bitstrm, delta_chroma_offset_l1[0], return_status); 729 ENTROPY_TRACE("delta_chroma_offset_l1[ i ]", delta_chroma_offset_l1[0]); 730 731 /* delta_chroma_weight_l1[ i ][j] */ 732 PUT_BITS_SEV(ps_bitstrm, delta_chroma_weight_l1[1], return_status); 733 ENTROPY_TRACE("delta_chroma_weight_l1[ i ]", delta_chroma_weight_l1[1]); 734 735 /* delta_chroma_offset_l1[ i ][j] */ 736 PUT_BITS_SEV(ps_bitstrm, delta_chroma_offset_l1[1], return_status); 737 ENTROPY_TRACE("delta_chroma_offset_l1[ i ]", delta_chroma_offset_l1[1]); 738 } 739 } 740 } 741 742 return return_status; 743 } 744 745 /** 746 ****************************************************************************** 747 * 748 * @brief Generates AUD (Access Unit Delimiter) 749 * 750 * @par Description 751 * Generate Access Unit Delimiter as per Section 7.3.2.5 752 * 753 * @param[in] ps_bitstrm 754 * pointer to bitstream context (handle) 755 * 756 * @param[in] pic_type 757 * picture type 758 * 759 * @return success or failure error code 760 * 761 ****************************************************************************** 762 */ 763 WORD32 ihevce_generate_aud(bitstrm_t *ps_bitstrm, WORD32 pic_type) 764 { 765 WORD32 return_status = IHEVCE_SUCCESS; 766 767 /* Insert the NAL start code */ 768 return_status = ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); 769 770 /* Insert Nal Unit Header */ 771 return_status |= ihevce_generate_nal_unit_header(ps_bitstrm, NAL_AUD, 0); 772 773 /* pic_type */ 774 PUT_BITS(ps_bitstrm, pic_type, 3, return_status); 775 ENTROPY_TRACE("pic type", pic_type); 776 777 ihevce_put_rbsp_trailing_bits(ps_bitstrm); 778 779 return return_status; 780 } 781 782 /** 783 ****************************************************************************** 784 * 785 * @brief Generates EOS (End of Sequence) 786 * 787 * @par Description 788 * Generate End of sequence as per Section 7.3.2.6 789 * 790 * @param[in] ps_bitstrm 791 * pointer to bitstream context (handle) 792 * 793 * @return success or failure error code 794 * 795 ****************************************************************************** 796 */ 797 WORD32 ihevce_generate_eos(bitstrm_t *ps_bitstrm) 798 { 799 WORD32 return_status = IHEVCE_SUCCESS; 800 801 /* Insert the NAL start code */ 802 return_status = ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); 803 804 /* Insert Nal Unit Header */ 805 return_status |= ihevce_generate_nal_unit_header(ps_bitstrm, NAL_EOS, 0); 806 807 ihevce_put_rbsp_trailing_bits(ps_bitstrm); 808 809 return return_status; 810 } 811 812 /** 813 ****************************************************************************** 814 * 815 * @brief Generates VPS (Video Parameter Set) 816 * 817 * @par Description 818 * Generate Video Parameter Set as per Section 7.3.2.1 819 * 820 * @param[in] ps_bitstrm 821 * pointer to bitstream context (handle) 822 * 823 * @param[in] ps_vps 824 * pointer to structure containing VPS data 825 * 826 * @return success or failure error code 827 * 828 ****************************************************************************** 829 */ 830 WORD32 ihevce_generate_vps(bitstrm_t *ps_bitstrm, vps_t *ps_vps) 831 { 832 WORD32 i; 833 WORD8 i1_vps_max_sub_layers_minus1 = ps_vps->i1_vps_max_sub_layers - 1; 834 WORD32 return_status = IHEVCE_SUCCESS; 835 836 /* Insert Start Code */ 837 ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); 838 839 /* Insert Nal Unit Header */ 840 ihevce_generate_nal_unit_header(ps_bitstrm, NAL_VPS, 0); 841 842 /* video_parameter_set_id */ 843 PUT_BITS(ps_bitstrm, ps_vps->i1_vps_id, 4, return_status); 844 ENTROPY_TRACE("video_parameter_set_id", ps_vps->i1_vps_id); 845 846 /* vps_reserved_three_2bits */ 847 PUT_BITS(ps_bitstrm, 3, 2, return_status); 848 ENTROPY_TRACE("vps_reserved_three_2bits", 3); 849 850 /* vps_max_layers_minus1 */ 851 PUT_BITS(ps_bitstrm, 0, 6, return_status); 852 ENTROPY_TRACE("vps_max_layers_minus1 ", 3); 853 854 /* vps_max_sub_layers_minus1 */ 855 PUT_BITS(ps_bitstrm, i1_vps_max_sub_layers_minus1, 3, return_status); 856 ENTROPY_TRACE("vps_max_sub_layers_minus1", i1_vps_max_sub_layers_minus1); 857 858 /* vps_temporal_id_nesting_flag */ 859 PUT_BITS(ps_bitstrm, ps_vps->i1_vps_temporal_id_nesting_flag, 1, return_status); 860 ENTROPY_TRACE("vps_temporal_id_nesting_flag", ps_vps->i1_vps_temporal_id_nesting_flag); 861 862 /* vps_reserved_0xffff_16bits */ 863 PUT_BITS(ps_bitstrm, 0xffff, 16, return_status); 864 ENTROPY_TRACE("vps_reserved_0xffff_16bits", 0xffff); 865 866 /* profile-tier and level info */ 867 ihevce_generate_profile_tier_level(ps_bitstrm, &ps_vps->s_ptl, 1, i1_vps_max_sub_layers_minus1); 868 869 /* vps_sub_layer_ordering_info_present_flag */ 870 PUT_BITS(ps_bitstrm, ps_vps->i1_sub_layer_ordering_info_present_flag, 1, return_status); 871 ENTROPY_TRACE( 872 "vps_sub_layer_ordering_info_present_flag", 873 ps_vps->i1_sub_layer_ordering_info_present_flag); 874 875 i = ps_vps->i1_sub_layer_ordering_info_present_flag ? 0 : i1_vps_max_sub_layers_minus1; 876 877 for(; i <= i1_vps_max_sub_layers_minus1; i++) 878 { 879 /* vps_max_dec_pic_buffering[i] */ 880 PUT_BITS_UEV(ps_bitstrm, ps_vps->ai1_vps_max_dec_pic_buffering[i], return_status); 881 ENTROPY_TRACE( 882 "vps_max_dec_pic_buffering_minus1[i]", ps_vps->ai1_vps_max_dec_pic_buffering[i]); 883 884 /* vps_num_reorder_pics[i] */ 885 PUT_BITS_UEV(ps_bitstrm, ps_vps->ai1_vps_max_num_reorder_pics[i], return_status); 886 ENTROPY_TRACE("ai1_vps_max_num_reorder_pics[i]", ps_vps->ai1_vps_max_num_reorder_pics[i]); 887 888 /* vps_max_latency_increase[i] */ 889 PUT_BITS_UEV(ps_bitstrm, ps_vps->ai1_vps_max_latency_increase[i], return_status); 890 ENTROPY_TRACE("ai1_vps_max_latency_increase[i]", ps_vps->ai1_vps_max_latency_increase[i]); 891 } 892 893 /* vps_max_layer_id */ 894 PUT_BITS(ps_bitstrm, ps_vps->i1_vps_max_nuh_reserved_zero_layer_id, 6, return_status); 895 ENTROPY_TRACE("vps_max_layer_id", ps_vps->i1_vps_max_nuh_reserved_zero_layer_id); 896 897 /* vps_num_layer_sets_minus1 */ 898 PUT_BITS_UEV(ps_bitstrm, 0, return_status); 899 ENTROPY_TRACE("vps_num_layer_sets_minus1", 0); 900 901 /* vps_timing_info_present_flag */ 902 PUT_BITS(ps_bitstrm, 0, 1, return_status); 903 ENTROPY_TRACE("vps_timing_info_present_flag", 0); 904 905 /* vps_extension_flag */ 906 PUT_BITS(ps_bitstrm, 0, 1, return_status); 907 ENTROPY_TRACE("vps_extension_flag", 0); 908 909 /* rbsp trailing bits */ 910 ihevce_put_rbsp_trailing_bits(ps_bitstrm); 911 912 return return_status; 913 } 914 915 /** 916 ****************************************************************************** 917 * 918 * @brief Generates SPS (Video Parameter Set) 919 * 920 * @par Description 921 * Parse Video Parameter Set as per Section 7.3.2.2 922 * 923 * @param[in] ps_bitstrm 924 * pointer to bitstream context (handle) 925 * 926 * @param[in] ps_sps 927 * pointer to structure containing SPS data 928 * 929 * @return success or failure error code 930 * 931 ****************************************************************************** 932 */ 933 WORD32 ihevce_generate_sps(bitstrm_t *ps_bitstrm, sps_t *ps_sps) 934 { 935 WORD32 i; 936 WORD32 return_status = IHEVCE_SUCCESS; 937 WORD8 i1_max_sub_layers_minus1 = ps_sps->i1_sps_max_sub_layers - 1; 938 939 UWORD32 u4_log2_max_pic_order_cnt_lsb = (UWORD32)(ps_sps->i1_log2_max_pic_order_cnt_lsb); 940 941 UWORD32 u4_log2_min_coding_block_size_minus3 = 942 (UWORD32)(ps_sps->i1_log2_min_coding_block_size) - 3; 943 944 UWORD32 u4_log2_diff_max_min_coding_block_size = 945 (UWORD32)(ps_sps->i1_log2_diff_max_min_coding_block_size); 946 947 UWORD32 u4_log2_min_transform_block_size_minus2 = 948 (UWORD32)(ps_sps->i1_log2_min_transform_block_size) - 2; 949 950 UWORD32 u4_log2_diff_max_min_transform_block_size = 951 (UWORD32)(ps_sps->i1_log2_diff_max_min_transform_block_size); 952 953 /* Insert Start Code */ 954 return_status = ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); 955 956 /* Insert Nal Unit Header */ 957 return_status |= ihevce_generate_nal_unit_header(ps_bitstrm, NAL_SPS, 0); 958 959 /* video_parameter_set_id */ 960 PUT_BITS(ps_bitstrm, ps_sps->i1_vps_id, 4, return_status); 961 ENTROPY_TRACE("video_parameter_set_id", ps_sps->i1_vps_id); 962 963 /* sps_max_sub_layers_minus1 */ 964 PUT_BITS(ps_bitstrm, i1_max_sub_layers_minus1, 3, return_status); 965 ENTROPY_TRACE("sps_max_sub_layers_minus1", i1_max_sub_layers_minus1); 966 967 /* sps_temporal_id_nesting_flag */ 968 PUT_BITS(ps_bitstrm, ps_sps->i1_sps_temporal_id_nesting_flag, 1, return_status); 969 ENTROPY_TRACE("sps_temporal_id_nesting_flag", ps_sps->i1_sps_temporal_id_nesting_flag); 970 971 /* profile-tier and level info */ 972 ihevce_generate_profile_tier_level(ps_bitstrm, &ps_sps->s_ptl, 1, i1_max_sub_layers_minus1); 973 974 /* seq_parameter_set_id */ 975 PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_sps_id, return_status); 976 ENTROPY_TRACE("seq_parameter_set_id", ps_sps->i1_sps_id); 977 978 /* chroma_format_idc */ 979 PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_chroma_format_idc, return_status); 980 ENTROPY_TRACE("chroma_format_idc", ps_sps->i1_chroma_format_idc); 981 982 if(CHROMA_FMT_IDC_YUV444 == ps_sps->i1_chroma_format_idc) 983 { 984 /* separate_colour_plane_flag */ 985 PUT_BITS(ps_bitstrm, 1, 1, return_status); 986 ENTROPY_TRACE("separate_colour_plane_flag", 1); 987 } 988 989 /* pic_width_in_luma_samples */ 990 PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_width_in_luma_samples, return_status); 991 ENTROPY_TRACE("pic_width_in_luma_samples", ps_sps->i2_pic_width_in_luma_samples); 992 993 /* pic_height_in_luma_samples */ 994 PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_height_in_luma_samples, return_status); 995 ENTROPY_TRACE("pic_height_in_luma_samples", ps_sps->i2_pic_height_in_luma_samples); 996 997 /* pic_cropping_flag */ 998 PUT_BITS(ps_bitstrm, ps_sps->i1_pic_cropping_flag, 1, return_status); 999 ENTROPY_TRACE("pic_cropping_flag", ps_sps->i1_pic_cropping_flag); 1000 1001 if(ps_sps->i1_pic_cropping_flag) 1002 { 1003 /* pic_crop_left_offset */ 1004 PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_crop_left_offset, return_status); 1005 ENTROPY_TRACE("pic_crop_left_offset", ps_sps->i2_pic_crop_left_offset); 1006 1007 /* pic_crop_right_offset */ 1008 PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_crop_right_offset, return_status); 1009 ENTROPY_TRACE("pic_crop_right_offset", ps_sps->i2_pic_crop_right_offset); 1010 1011 /* pic_crop_top_offset */ 1012 PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_crop_top_offset, return_status); 1013 ENTROPY_TRACE("pic_crop_top_offset", ps_sps->i2_pic_crop_top_offset); 1014 1015 /* pic_crop_bottom_offset */ 1016 PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_crop_bottom_offset, return_status); 1017 ENTROPY_TRACE("pic_crop_bottom_offset", ps_sps->i2_pic_crop_bottom_offset); 1018 } 1019 1020 /* bit_depth_luma_minus8 */ 1021 PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_bit_depth_luma_minus8, return_status); 1022 ENTROPY_TRACE("bit_depth_luma_minus8", ps_sps->i1_bit_depth_luma_minus8); 1023 1024 /* bit_depth_chroma_minus8 */ 1025 PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_bit_depth_chroma_minus8, return_status); 1026 ENTROPY_TRACE("i1_bit_depth_chroma_minus8", ps_sps->i1_bit_depth_chroma_minus8); 1027 1028 /* log2_max_pic_order_cnt_lsb_minus4 */ 1029 PUT_BITS_UEV(ps_bitstrm, u4_log2_max_pic_order_cnt_lsb - 4, return_status); 1030 ENTROPY_TRACE("log2_max_pic_order_cnt_lsb_minus4", u4_log2_max_pic_order_cnt_lsb - 4); 1031 1032 /* sps_sub_layer_ordering_info_present_flag */ 1033 PUT_BITS(ps_bitstrm, ps_sps->i1_sps_sub_layer_ordering_info_present_flag, 1, return_status); 1034 ENTROPY_TRACE( 1035 "sps_sub_layer_ordering_info_present_flag", 1036 ps_sps->i1_sps_sub_layer_ordering_info_present_flag); 1037 1038 i = ps_sps->i1_sps_sub_layer_ordering_info_present_flag ? 0 : i1_max_sub_layers_minus1; 1039 1040 for(; i <= i1_max_sub_layers_minus1; i++) 1041 { 1042 /* max_dec_pic_buffering */ 1043 PUT_BITS_UEV(ps_bitstrm, ps_sps->ai1_sps_max_dec_pic_buffering[i], return_status); 1044 ENTROPY_TRACE("max_dec_pic_buffering_minus1", ps_sps->ai1_sps_max_dec_pic_buffering[i]); 1045 1046 /* num_reorder_pics */ 1047 PUT_BITS_UEV(ps_bitstrm, ps_sps->ai1_sps_max_num_reorder_pics[i], return_status); 1048 ENTROPY_TRACE("num_reorder_pics", ps_sps->ai1_sps_max_num_reorder_pics[i]); 1049 1050 /* max_latency_increase */ 1051 PUT_BITS_UEV(ps_bitstrm, ps_sps->ai1_sps_max_latency_increase[i], return_status); 1052 ENTROPY_TRACE("max_latency_increase", ps_sps->ai1_sps_max_latency_increase[i]); 1053 } 1054 1055 /* log2_min_coding_block_size_minus3 */ 1056 PUT_BITS_UEV(ps_bitstrm, u4_log2_min_coding_block_size_minus3, return_status); 1057 ENTROPY_TRACE("log2_min_coding_block_size_minus3", u4_log2_min_coding_block_size_minus3); 1058 1059 /* log2_diff_max_min_coding_block_size */ 1060 PUT_BITS_UEV(ps_bitstrm, u4_log2_diff_max_min_coding_block_size, return_status); 1061 ENTROPY_TRACE("log2_diff_max_min_coding_block_size", u4_log2_diff_max_min_coding_block_size); 1062 1063 /* log2_min_transform_block_size_minus2 */ 1064 PUT_BITS_UEV(ps_bitstrm, u4_log2_min_transform_block_size_minus2, return_status); 1065 ENTROPY_TRACE("log2_min_transform_block_size_minus2", u4_log2_min_transform_block_size_minus2); 1066 1067 /* log2_diff_max_min_transform_block_size */ 1068 PUT_BITS_UEV(ps_bitstrm, u4_log2_diff_max_min_transform_block_size, return_status); 1069 ENTROPY_TRACE( 1070 "log2_diff_max_min_transform_block_size", u4_log2_diff_max_min_transform_block_size); 1071 1072 /* max_transform_hierarchy_depth_inter */ 1073 PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_max_transform_hierarchy_depth_inter, return_status); 1074 ENTROPY_TRACE( 1075 "max_transform_hierarchy_depth_inter", ps_sps->i1_max_transform_hierarchy_depth_inter); 1076 1077 /* max_transform_hierarchy_depth_intra */ 1078 PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_max_transform_hierarchy_depth_intra, return_status); 1079 ENTROPY_TRACE( 1080 "max_transform_hierarchy_depth_intra", ps_sps->i1_max_transform_hierarchy_depth_intra); 1081 1082 /* scaling_list_enabled_flag */ 1083 PUT_BITS(ps_bitstrm, ps_sps->i1_scaling_list_enable_flag, 1, return_status); 1084 ENTROPY_TRACE("scaling_list_enabled_flag", ps_sps->i1_scaling_list_enable_flag); 1085 1086 if(ps_sps->i1_scaling_list_enable_flag) 1087 { 1088 /* sps_scaling_list_data_present_flag */ 1089 PUT_BITS(ps_bitstrm, ps_sps->i1_sps_scaling_list_data_present_flag, 1, return_status); 1090 ENTROPY_TRACE( 1091 "sps_scaling_list_data_present_flag", ps_sps->i1_sps_scaling_list_data_present_flag); 1092 1093 #if 0 /* TODO: Will be enabled once scaling list support is added */ 1094 if(ps_sps->i1_sps_scaling_list_data_present_flag) 1095 { 1096 //TODO 1097 ihevce_generate_scaling_list_data(ps_bitstrm); 1098 } 1099 #endif 1100 } 1101 1102 /* asymmetric_motion_partitions_enabled_flag */ 1103 PUT_BITS(ps_bitstrm, ps_sps->i1_amp_enabled_flag, 1, return_status); 1104 ENTROPY_TRACE("asymmetric_motion_partitions_enabled_flag", ps_sps->i1_amp_enabled_flag); 1105 1106 /* sample_adaptive_offset_enabled_flag */ 1107 PUT_BITS(ps_bitstrm, ps_sps->i1_sample_adaptive_offset_enabled_flag, 1, return_status); 1108 ENTROPY_TRACE( 1109 "sample_adaptive_offset_enabled_flag", ps_sps->i1_sample_adaptive_offset_enabled_flag); 1110 1111 /* pcm_enabled_flag */ 1112 PUT_BITS(ps_bitstrm, ps_sps->i1_pcm_enabled_flag, 1, return_status); 1113 ENTROPY_TRACE("pcm_enabled_flag", ps_sps->i1_pcm_enabled_flag); 1114 if(ps_sps->i1_pcm_enabled_flag) 1115 { 1116 UWORD32 u4_log2_min_pcm_coding_block_size = (ps_sps->i1_log2_min_pcm_coding_block_size); 1117 UWORD32 u4_log2_diff_max_min_pcm_coding_block_size = 1118 (ps_sps->i1_log2_diff_max_min_pcm_coding_block_size); 1119 1120 /* pcm_sample_bit_depth_luma_minus1 */ 1121 PUT_BITS(ps_bitstrm, ps_sps->i1_pcm_sample_bit_depth_luma - 1, 4, return_status); 1122 ENTROPY_TRACE("pcm_sample_bit_depth_luma", ps_sps->i1_pcm_sample_bit_depth_luma - 1); 1123 1124 /* pcm_sample_bit_depth_chroma_minus1 */ 1125 PUT_BITS(ps_bitstrm, ps_sps->i1_pcm_sample_bit_depth_chroma - 1, 4, return_status); 1126 ENTROPY_TRACE("pcm_sample_bit_depth_chroma", ps_sps->i1_pcm_sample_bit_depth_chroma - 1); 1127 1128 /* log2_min_pcm_coding_block_size_minus3 */ 1129 PUT_BITS_UEV(ps_bitstrm, u4_log2_min_pcm_coding_block_size - 3, return_status); 1130 ENTROPY_TRACE( 1131 "log2_min_pcm_coding_block_size_minus3", u4_log2_min_pcm_coding_block_size - 3); 1132 1133 /* log2_diff_max_min_pcm_coding_block_size */ 1134 PUT_BITS_UEV(ps_bitstrm, u4_log2_diff_max_min_pcm_coding_block_size, return_status); 1135 ENTROPY_TRACE( 1136 "log2_diff_max_min_pcm_coding_block_size", u4_log2_diff_max_min_pcm_coding_block_size); 1137 1138 /* pcm_loop_filter_disable_flag */ 1139 PUT_BITS(ps_bitstrm, ps_sps->i1_pcm_loop_filter_disable_flag, 1, return_status); 1140 ENTROPY_TRACE("pcm_loop_filter_disable_flag", ps_sps->i1_pcm_loop_filter_disable_flag); 1141 } 1142 1143 /* num_short_term_ref_pic_sets */ 1144 PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_num_short_term_ref_pic_sets, return_status); 1145 ENTROPY_TRACE("num_short_term_ref_pic_sets", ps_sps->i1_num_short_term_ref_pic_sets); 1146 1147 for(i = 0; i < ps_sps->i1_num_short_term_ref_pic_sets; i++) 1148 { 1149 WORD32 i4_NumPocTotalCurr = 0; 1150 ihevce_short_term_ref_pic_set( 1151 ps_bitstrm, 1152 &ps_sps->as_stref_picset[0], 1153 ps_sps->i1_num_short_term_ref_pic_sets, 1154 i, 1155 &i4_NumPocTotalCurr); 1156 } 1157 1158 /* long_term_ref_pics_present_flag */ 1159 PUT_BITS(ps_bitstrm, ps_sps->i1_long_term_ref_pics_present_flag, 1, return_status); 1160 ENTROPY_TRACE("long_term_ref_pics_present_flag", ps_sps->i1_long_term_ref_pics_present_flag); 1161 1162 if(ps_sps->i1_long_term_ref_pics_present_flag) 1163 { 1164 /* num_long_term_ref_pics_sps */ 1165 PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_num_long_term_ref_pics_sps, return_status); 1166 ENTROPY_TRACE("num_long_term_ref_pics_sps", ps_sps->i1_num_long_term_ref_pics_sps); 1167 1168 for(i = 0; i < ps_sps->i1_num_long_term_ref_pics_sps; i++) 1169 { 1170 /* lt_ref_pic_poc_lsb_sps[i] */ 1171 PUT_BITS( 1172 ps_bitstrm, 1173 ps_sps->au2_lt_ref_pic_poc_lsb_sps[i], 1174 u4_log2_max_pic_order_cnt_lsb, 1175 return_status); 1176 ENTROPY_TRACE("lt_ref_pic_poc_lsb_sps[i]", ps_sps->au2_lt_ref_pic_poc_lsb_sps[i]); 1177 1178 /* used_by_curr_pic_lt_sps_flag[i] */ 1179 PUT_BITS(ps_bitstrm, ps_sps->ai1_used_by_curr_pic_lt_sps_flag[i], 1, return_status); 1180 ENTROPY_TRACE( 1181 "used_by_curr_pic_lt_sps_flag[i]", ps_sps->ai1_used_by_curr_pic_lt_sps_flag[i]); 1182 } 1183 } 1184 1185 /* sps_temporal_mvp_enable_flag */ 1186 PUT_BITS(ps_bitstrm, ps_sps->i1_sps_temporal_mvp_enable_flag, 1, return_status); 1187 ENTROPY_TRACE("sps_temporal_mvp_enable_flag", ps_sps->i1_sps_temporal_mvp_enable_flag); 1188 1189 #if !HM_8DOT1_SYNTAX 1190 /* strong_intra_smoothing_enable_flag */ 1191 PUT_BITS(ps_bitstrm, ps_sps->i1_strong_intra_smoothing_enable_flag, 1, return_status); 1192 ENTROPY_TRACE( 1193 "sps_strong_intra_smoothing_enable_flag", ps_sps->i1_strong_intra_smoothing_enable_flag); 1194 #endif 1195 1196 /* vui_parameters_present_flag */ 1197 PUT_BITS(ps_bitstrm, ps_sps->i1_vui_parameters_present_flag, 1, return_status); 1198 ENTROPY_TRACE("vui_parameters_present_flag", ps_sps->i1_vui_parameters_present_flag); 1199 1200 ENTROPY_TRACE("----------- vui_parameters -----------", 0); 1201 1202 if(ps_sps->i1_vui_parameters_present_flag) 1203 { 1204 /* Add vui parameters to the bitstream */ 1205 ihevce_generate_vui(ps_bitstrm, ps_sps, ps_sps->s_vui_parameters); 1206 } 1207 1208 /* sps_extension_flag */ 1209 PUT_BITS(ps_bitstrm, 0, 1, return_status); 1210 ENTROPY_TRACE("sps_extension_flag", 0); 1211 1212 /* rbsp trailing bits */ 1213 ihevce_put_rbsp_trailing_bits(ps_bitstrm); 1214 1215 return return_status; 1216 } 1217 1218 /** 1219 ****************************************************************************** 1220 * 1221 * @brief Generates PPS (Picture Parameter Set) 1222 * 1223 * @par Description 1224 * Generate Picture Parameter Set as per Section 7.3.2.3 1225 * 1226 * @param[in] ps_bitstrm 1227 * pointer to bitstream context (handle) 1228 * 1229 * @param[in] ps_pps 1230 * pointer to structure containing PPS data 1231 * 1232 * @return success or failure error code 1233 * 1234 ****************************************************************************** 1235 */ 1236 WORD32 ihevce_generate_pps(bitstrm_t *ps_bitstrm, pps_t *ps_pps) 1237 { 1238 WORD32 i; 1239 WORD32 return_status = IHEVCE_SUCCESS; 1240 1241 /* Insert the NAL start code */ 1242 return_status = ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); 1243 1244 /* Insert Nal Unit Header */ 1245 return_status |= ihevce_generate_nal_unit_header(ps_bitstrm, NAL_PPS, 0); 1246 1247 /* pic_parameter_set_id */ 1248 PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_pps_id, return_status); 1249 ENTROPY_TRACE("pic_parameter_set_id", ps_pps->i1_pps_id); 1250 1251 /* seq_parameter_set_id */ 1252 PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_sps_id, return_status); 1253 ENTROPY_TRACE("seq_parameter_set_id", ps_pps->i1_sps_id); 1254 1255 /* dependent_slices_enabled_flag */ 1256 PUT_BITS(ps_bitstrm, ps_pps->i1_dependent_slice_enabled_flag, 1, return_status); 1257 ENTROPY_TRACE("dependent_slices_enabled_flag", ps_pps->i1_dependent_slice_enabled_flag); 1258 1259 /* output_flag_present_flag */ 1260 PUT_BITS(ps_bitstrm, ps_pps->i1_output_flag_present_flag, 1, return_status); 1261 ENTROPY_TRACE("output_flag_present_flag", ps_pps->i1_output_flag_present_flag); 1262 1263 /* num_extra_slice_header_bits */ 1264 PUT_BITS(ps_bitstrm, ps_pps->i1_num_extra_slice_header_bits, 3, return_status); 1265 ENTROPY_TRACE("num_extra_slice_header_bits", ps_pps->i1_num_extra_slice_header_bits); 1266 1267 /* sign_data_hiding_flag */ 1268 PUT_BITS(ps_bitstrm, ps_pps->i1_sign_data_hiding_flag, 1, return_status); 1269 ENTROPY_TRACE("sign_data_hiding_flag", ps_pps->i1_sign_data_hiding_flag); 1270 1271 /* cabac_init_present_flag */ 1272 PUT_BITS(ps_bitstrm, ps_pps->i1_cabac_init_present_flag, 1, return_status); 1273 ENTROPY_TRACE("cabac_init_present_flag", ps_pps->i1_cabac_init_present_flag); 1274 1275 /* num_ref_idx_l0_default_active_minus1 */ 1276 PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_ref_idx_l0_default_active - 1, return_status); 1277 ENTROPY_TRACE( 1278 "num_ref_idx_l0_default_active_minus1", ps_pps->i1_num_ref_idx_l0_default_active - 1); 1279 1280 /* num_ref_idx_l1_default_active_minus1 */ 1281 PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_ref_idx_l1_default_active - 1, return_status); 1282 ENTROPY_TRACE( 1283 "num_ref_idx_l1_default_active_minus1", ps_pps->i1_num_ref_idx_l1_default_active - 1); 1284 1285 /* pic_init_qp_minus26 */ 1286 PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_pic_init_qp - 26, return_status); 1287 ENTROPY_TRACE("pic_init_qp_minus26", ps_pps->i1_pic_init_qp - 26); 1288 1289 /* constrained_intra_pred_flag */ 1290 PUT_BITS(ps_bitstrm, ps_pps->i1_constrained_intra_pred_flag, 1, return_status); 1291 ENTROPY_TRACE("constrained_intra_pred_flag", ps_pps->i1_constrained_intra_pred_flag); 1292 1293 /* transform_skip_enabled_flag */ 1294 PUT_BITS(ps_bitstrm, ps_pps->i1_transform_skip_enabled_flag, 1, return_status); 1295 ENTROPY_TRACE("transform_skip_enabled_flag", ps_pps->i1_transform_skip_enabled_flag); 1296 1297 /* cu_qp_delta_enabled_flag */ 1298 PUT_BITS(ps_bitstrm, ps_pps->i1_cu_qp_delta_enabled_flag, 1, return_status); 1299 ENTROPY_TRACE("cu_qp_delta_enabled_flag", ps_pps->i1_cu_qp_delta_enabled_flag); 1300 1301 if(ps_pps->i1_cu_qp_delta_enabled_flag) 1302 { 1303 /* diff_cu_qp_delta_depth */ 1304 PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_diff_cu_qp_delta_depth, return_status); 1305 ENTROPY_TRACE("diff_cu_qp_delta_depth", ps_pps->i1_diff_cu_qp_delta_depth); 1306 } 1307 1308 /* cb_qp_offset */ 1309 PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_pic_cb_qp_offset, return_status); 1310 ENTROPY_TRACE("cb_qp_offset", ps_pps->i1_pic_cb_qp_offset); 1311 1312 /* cr_qp_offset */ 1313 PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_pic_cr_qp_offset, return_status); 1314 ENTROPY_TRACE("cr_qp_offset", ps_pps->i1_pic_cr_qp_offset); 1315 1316 /* slicelevel_chroma_qp_flag */ 1317 PUT_BITS( 1318 ps_bitstrm, ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag, 1, return_status); 1319 ENTROPY_TRACE( 1320 "slicelevel_chroma_qp_flag", ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag); 1321 1322 /* weighted_pred_flag */ 1323 PUT_BITS(ps_bitstrm, ps_pps->i1_weighted_pred_flag, 1, return_status); 1324 ENTROPY_TRACE("weighted_pred_flag", ps_pps->i1_weighted_pred_flag); 1325 1326 /* weighted_bipred_flag */ 1327 PUT_BITS(ps_bitstrm, ps_pps->i1_weighted_bipred_flag, 1, return_status); 1328 ENTROPY_TRACE("weighted_bipred_flag", ps_pps->i1_weighted_bipred_flag); 1329 1330 /* transquant_bypass_enable_flag */ 1331 PUT_BITS(ps_bitstrm, ps_pps->i1_transquant_bypass_enable_flag, 1, return_status); 1332 ENTROPY_TRACE("transquant_bypass_enable_flag", ps_pps->i1_transquant_bypass_enable_flag); 1333 1334 /* tiles_enabled_flag */ 1335 PUT_BITS(ps_bitstrm, ps_pps->i1_tiles_enabled_flag, 1, return_status); 1336 ENTROPY_TRACE("tiles_enabled_flag", ps_pps->i1_tiles_enabled_flag); 1337 1338 /* entropy_coding_sync_enabled_flag */ 1339 PUT_BITS(ps_bitstrm, ps_pps->i1_entropy_coding_sync_enabled_flag, 1, return_status); 1340 ENTROPY_TRACE("entropy_coding_sync_enabled_flag", ps_pps->i1_entropy_coding_sync_enabled_flag); 1341 1342 if(ps_pps->i1_tiles_enabled_flag) 1343 { 1344 /* num_tile_columns_minus1 */ 1345 PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_tile_columns - 1, return_status); 1346 ENTROPY_TRACE("num_tile_columns_minus1", ps_pps->i1_num_tile_columns - 1); 1347 1348 /* num_tile_rows_minus1 */ 1349 PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_tile_rows - 1, return_status); 1350 ENTROPY_TRACE("num_tile_rows_minus1", ps_pps->i1_num_tile_rows - 1); 1351 1352 /* uniform_spacing_flag */ 1353 PUT_BITS(ps_bitstrm, ps_pps->i1_uniform_spacing_flag, 1, return_status); 1354 ENTROPY_TRACE("uniform_spacing_flag", ps_pps->i1_uniform_spacing_flag); 1355 1356 if(!ps_pps->i1_uniform_spacing_flag) 1357 { 1358 for(i = 0; i < ps_pps->i1_num_tile_columns - 1; i++) 1359 { 1360 /* column_width_minus1[i] */ 1361 PUT_BITS_UEV(ps_bitstrm, ps_pps->ps_tile[i].u2_wd - 1, return_status); 1362 ENTROPY_TRACE("column_width_minus1[i]", ps_pps->ps_tile[i].u2_wd - 1); 1363 } 1364 for(i = 0; i < ps_pps->i1_num_tile_rows - 1; i++) 1365 { 1366 /* row_height_minus1[i] */ 1367 PUT_BITS_UEV(ps_bitstrm, ps_pps->ps_tile[i].u2_ht - 1, return_status); 1368 ENTROPY_TRACE("row_height_minus1[i]", ps_pps->ps_tile[i].u2_ht - 1); 1369 } 1370 } 1371 1372 /* loop_filter_across_tiles_enabled_flag */ 1373 PUT_BITS(ps_bitstrm, ps_pps->i1_loop_filter_across_tiles_enabled_flag, 1, return_status); 1374 ENTROPY_TRACE( 1375 "loop_filter_across_tiles_enabled_flag", 1376 ps_pps->i1_loop_filter_across_tiles_enabled_flag); 1377 } 1378 1379 /* loop_filter_across_slices_enabled_flag */ 1380 PUT_BITS(ps_bitstrm, ps_pps->i1_loop_filter_across_slices_enabled_flag, 1, return_status); 1381 ENTROPY_TRACE( 1382 "loop_filter_across_slices_enabled_flag", 1383 ps_pps->i1_loop_filter_across_slices_enabled_flag); 1384 1385 /* deblocking_filter_control_present_flag */ 1386 PUT_BITS(ps_bitstrm, ps_pps->i1_deblocking_filter_control_present_flag, 1, return_status); 1387 ENTROPY_TRACE( 1388 "deblocking_filter_control_present_flag", 1389 ps_pps->i1_deblocking_filter_control_present_flag); 1390 1391 if(ps_pps->i1_deblocking_filter_control_present_flag) 1392 { 1393 /* deblocking_filter_override_enabled_flag */ 1394 PUT_BITS(ps_bitstrm, ps_pps->i1_deblocking_filter_override_enabled_flag, 1, return_status); 1395 ENTROPY_TRACE( 1396 "deblocking_filter_override_enabled_flag", 1397 ps_pps->i1_deblocking_filter_override_enabled_flag); 1398 1399 /* pic_disable_deblocking_filter_flag */ 1400 PUT_BITS(ps_bitstrm, ps_pps->i1_pic_disable_deblocking_filter_flag, 1, return_status); 1401 ENTROPY_TRACE( 1402 "pic_disable_deblocking_filter_flag", ps_pps->i1_pic_disable_deblocking_filter_flag); 1403 1404 if(!ps_pps->i1_pic_disable_deblocking_filter_flag) 1405 { 1406 /* beta_offset_div2 */ 1407 PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_beta_offset_div2 >> 1, return_status); 1408 ENTROPY_TRACE("beta_offset_div2", ps_pps->i1_beta_offset_div2 >> 1); 1409 1410 /* tc_offset_div2 */ 1411 PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_tc_offset_div2 >> 1, return_status); 1412 ENTROPY_TRACE("tc_offset_div2", ps_pps->i1_tc_offset_div2 >> 1); 1413 } 1414 } 1415 1416 /* pps_scaling_list_data_present_flag */ 1417 PUT_BITS(ps_bitstrm, ps_pps->i1_pps_scaling_list_data_present_flag, 1, return_status); 1418 ENTROPY_TRACE( 1419 "pps_scaling_list_data_present_flag", ps_pps->i1_pps_scaling_list_data_present_flag); 1420 1421 #if 0 /* TODO: Will be enabled once scaling list support is added */ 1422 if(ps_pps->i1_pps_scaling_list_data_present_flag ) 1423 { 1424 //TODO 1425 ihevce_scaling_list_data(); 1426 } 1427 #endif 1428 1429 /* lists_modification_present_flag */ 1430 PUT_BITS(ps_bitstrm, ps_pps->i1_lists_modification_present_flag, 1, return_status); 1431 ENTROPY_TRACE("lists_modification_present_flag", ps_pps->i1_lists_modification_present_flag); 1432 1433 { 1434 UWORD32 u4_log2_parallel_merge_level_minus2 = ps_pps->i1_log2_parallel_merge_level; 1435 1436 u4_log2_parallel_merge_level_minus2 -= 2; 1437 1438 /* log2_parallel_merge_level_minus2 */ 1439 PUT_BITS_UEV(ps_bitstrm, u4_log2_parallel_merge_level_minus2, return_status); 1440 ENTROPY_TRACE("log2_parallel_merge_level_minus2", u4_log2_parallel_merge_level_minus2); 1441 } 1442 1443 /* slice_header_extension_present_flag */ 1444 PUT_BITS(ps_bitstrm, ps_pps->i1_slice_header_extension_present_flag, 1, return_status); 1445 ENTROPY_TRACE( 1446 "slice_header_extension_present_flag", ps_pps->i1_slice_header_extension_present_flag); 1447 1448 /* pps_extension_flag */ 1449 PUT_BITS(ps_bitstrm, 0, 1, return_status); 1450 ENTROPY_TRACE("pps_extension_flag", 0); 1451 1452 ihevce_put_rbsp_trailing_bits(ps_bitstrm); 1453 1454 return return_status; 1455 } 1456 1457 /** 1458 ****************************************************************************** 1459 * 1460 * @brief Generates Slice Header 1461 * 1462 * @par Description 1463 * Generate Slice Header as per Section 7.3.5.1 1464 * 1465 * @param[inout] ps_bitstrm 1466 * pointer to bitstream context for generating slice header 1467 * 1468 * @param[in] i1_nal_unit_type 1469 * nal unit type 1470 * 1471 * @param[in] ps_slice_hdr 1472 * pointer to slice header params 1473 * 1474 * @param[in] ps_pps 1475 * pointer to pps params referred by slice 1476 * 1477 * @param[in] ps_sps 1478 * pointer to sps params referred by slice 1479 * 1480 * @return success or failure error code 1481 * 1482 ****************************************************************************** 1483 */ 1484 WORD32 ihevce_generate_slice_header( 1485 bitstrm_t *ps_bitstrm, 1486 WORD8 i1_nal_unit_type, 1487 slice_header_t *ps_slice_hdr, 1488 pps_t *ps_pps, 1489 sps_t *ps_sps, 1490 bitstrm_t *ps_dup_bit_strm_ent_offset, 1491 UWORD32 *pu4_first_slice_start_offset, 1492 ihevce_tile_params_t *ps_tile_params, 1493 WORD32 i4_next_slice_seg_x, 1494 WORD32 i4_next_slice_seg_y) 1495 { 1496 WORD32 i; 1497 WORD32 return_status = IHEVCE_SUCCESS; 1498 1499 WORD32 RapPicFlag = (i1_nal_unit_type >= NAL_BLA_W_LP) && 1500 (i1_nal_unit_type <= NAL_RSV_RAP_VCL23); 1501 WORD32 idr_pic_flag = (NAL_IDR_W_LP == i1_nal_unit_type) || (NAL_IDR_N_LP == i1_nal_unit_type); 1502 1503 WORD32 disable_deblocking_filter_flag; 1504 1505 WORD32 i4_NumPocTotalCurr = 0; 1506 /* Initialize the pic width and pic height from sps parameters */ 1507 WORD32 pic_width = ps_sps->i2_pic_width_in_luma_samples; 1508 WORD32 pic_height = ps_sps->i2_pic_height_in_luma_samples; 1509 1510 /* Initialize the CTB size from sps parameters */ 1511 WORD32 log2_ctb_size = 1512 ps_sps->i1_log2_min_coding_block_size + ps_sps->i1_log2_diff_max_min_coding_block_size; 1513 WORD32 ctb_size = (1 << log2_ctb_size); 1514 1515 /* Update ps_slice_hdr->i2_slice_address based on tile position in frame */ 1516 WORD32 num_ctb_in_row = (pic_width + ctb_size - 1) >> log2_ctb_size; 1517 1518 /* Overwrite i2_slice_address here as pre-enc didn't had tile structure 1519 available in it's scope. Otherwise i2_slice_address would be set in 1520 populate_slice_header() itself */ 1521 if(1 == ps_tile_params->i4_tiles_enabled_flag) 1522 { 1523 ps_slice_hdr->i2_slice_address = 1524 ps_tile_params->i4_first_ctb_y * num_ctb_in_row + ps_tile_params->i4_first_ctb_x; 1525 } 1526 else 1527 { 1528 ps_slice_hdr->i2_slice_address = i4_next_slice_seg_x + i4_next_slice_seg_y * num_ctb_in_row; 1529 } 1530 1531 /* Overwrite i1_first_slice_in_pic_flag here as pre-enc didn't had tile structure 1532 available in it's scope. Otherwise i1_first_slice_in_pic_flag would be set in 1533 populate_slice_header() itself */ 1534 ps_slice_hdr->i1_first_slice_in_pic_flag = (ps_slice_hdr->i2_slice_address == 0); 1535 1536 /* Currently if dependent slices are enabled, then all slices 1537 after first slice of picture, are made dependent slices */ 1538 if((1 == ps_pps->i1_dependent_slice_enabled_flag) && 1539 (0 == ps_slice_hdr->i1_first_slice_in_pic_flag)) 1540 { 1541 ps_slice_hdr->i1_dependent_slice_flag = 1; 1542 } 1543 else 1544 { 1545 ps_slice_hdr->i1_dependent_slice_flag = 0; 1546 } 1547 1548 /* Insert start code */ 1549 return_status |= ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); 1550 1551 /* Insert Nal Unit Header */ 1552 return_status |= ihevce_generate_nal_unit_header( 1553 ps_bitstrm, 1554 i1_nal_unit_type, 1555 ps_slice_hdr->u4_nuh_temporal_id); //TEMPORALA_SCALABILITY CHANGES 1556 1557 /* first_slice_in_pic_flag */ 1558 PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_first_slice_in_pic_flag, 1, return_status); 1559 ENTROPY_TRACE("first_slice_in_pic_flag", ps_slice_hdr->i1_first_slice_in_pic_flag); 1560 1561 if(RapPicFlag) 1562 { 1563 /* no_output_of_prior_pics_flag */ 1564 PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_no_output_of_prior_pics_flag, 1, return_status); 1565 ENTROPY_TRACE( 1566 "no_output_of_prior_pics_flag", ps_slice_hdr->i1_no_output_of_prior_pics_flag); 1567 } 1568 1569 /* pic_parameter_set_id */ 1570 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_pps_id, return_status); 1571 ENTROPY_TRACE("pic_parameter_set_id", ps_slice_hdr->i1_pps_id); 1572 1573 /* If ps_pps->i1_dependent_slice_enabled_flag is enabled and 1574 curent slice is not the first slice of picture then put 1575 i1_dependent_slice_flag into the bitstream */ 1576 if((ps_pps->i1_dependent_slice_enabled_flag) && (!ps_slice_hdr->i1_first_slice_in_pic_flag)) 1577 { 1578 /* dependent_slice_flag */ 1579 PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_dependent_slice_flag, 1, return_status); 1580 ENTROPY_TRACE("dependent_slice_flag", ps_slice_hdr->i1_dependent_slice_flag); 1581 } 1582 1583 if(!ps_slice_hdr->i1_first_slice_in_pic_flag) 1584 { 1585 WORD32 num_bits; 1586 WORD32 num_ctb_in_pic; 1587 1588 /* ctbs in frame ceiled for width / height not multiple of ctb size */ 1589 num_ctb_in_pic = ((pic_width + (ctb_size - 1)) >> log2_ctb_size) * 1590 ((pic_height + (ctb_size - 1)) >> log2_ctb_size); 1591 1592 /* Use CLZ to compute Ceil( Log2( PicSizeInCtbsY ) ) */ 1593 num_bits = 32 - CLZ(num_ctb_in_pic - 1); 1594 1595 /* slice_address */ 1596 PUT_BITS(ps_bitstrm, ps_slice_hdr->i2_slice_address, num_bits, return_status); 1597 ENTROPY_TRACE("slice_address", ps_slice_hdr->i2_slice_address); 1598 } 1599 1600 if(!ps_slice_hdr->i1_dependent_slice_flag) 1601 { 1602 for(i = 0; i < ps_pps->i1_num_extra_slice_header_bits; i++) 1603 { 1604 /* slice_reserved_undetermined_flag */ 1605 PUT_BITS(ps_bitstrm, 0, 1, return_status); 1606 ENTROPY_TRACE("slice_reserved_undetermined_flag", 0); 1607 } 1608 /* slice_type */ 1609 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_slice_type, return_status); 1610 ENTROPY_TRACE("slice_type", ps_slice_hdr->i1_slice_type); 1611 1612 if(ps_pps->i1_output_flag_present_flag) 1613 { 1614 /* pic_output_flag */ 1615 PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_pic_output_flag, 1, return_status); 1616 ENTROPY_TRACE("pic_output_flag", ps_slice_hdr->i1_pic_output_flag); 1617 } 1618 1619 if(!idr_pic_flag) 1620 { 1621 /* pic_order_cnt_lsb */ 1622 PUT_BITS( 1623 ps_bitstrm, 1624 ps_slice_hdr->i4_pic_order_cnt_lsb, 1625 ps_sps->i1_log2_max_pic_order_cnt_lsb, 1626 return_status); 1627 ENTROPY_TRACE("pic_order_cnt_lsb", ps_slice_hdr->i4_pic_order_cnt_lsb); 1628 1629 /* short_term_ref_pic_set_sps_flag */ 1630 PUT_BITS( 1631 ps_bitstrm, ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag, 1, return_status); 1632 ENTROPY_TRACE( 1633 "short_term_ref_pic_set_sps_flag", 1634 ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag); 1635 1636 if(!ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag) 1637 { 1638 ihevce_short_term_ref_pic_set( 1639 ps_bitstrm, &ps_slice_hdr->s_stref_picset, 1, 0, &i4_NumPocTotalCurr); 1640 } 1641 else 1642 { 1643 WORD32 num_bits = 32 - CLZ(ps_sps->i1_num_short_term_ref_pic_sets); 1644 1645 /* short_term_ref_pic_set_idx */ 1646 PUT_BITS( 1647 ps_bitstrm, 1648 ps_slice_hdr->i1_short_term_ref_pic_set_idx, 1649 num_bits, 1650 return_status); 1651 ENTROPY_TRACE( 1652 "short_term_ref_pic_set_idx", ps_slice_hdr->i1_short_term_ref_pic_set_idx); 1653 } 1654 1655 if(ps_sps->i1_long_term_ref_pics_present_flag) 1656 { 1657 if(ps_sps->i1_num_long_term_ref_pics_sps > 0) 1658 { 1659 /* num_long_term_sps */ 1660 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_long_term_sps, return_status); 1661 ENTROPY_TRACE("num_long_term_sps", ps_slice_hdr->i1_num_long_term_sps); 1662 } 1663 1664 /* num_long_term_pics */ 1665 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_long_term_pics, return_status); 1666 ENTROPY_TRACE("num_long_term_pics", ps_slice_hdr->i1_num_long_term_pics); 1667 1668 for(i = 0; 1669 i < (ps_slice_hdr->i1_num_long_term_sps + ps_slice_hdr->i1_num_long_term_pics); 1670 i++) 1671 { 1672 if(i < ps_slice_hdr->i1_num_long_term_sps) 1673 { 1674 /* Use CLZ to compute Ceil( Log2 1675 ( num_long_term_ref_pics_sps ) ) */ 1676 WORD32 num_bits = 32 - CLZ(ps_sps->i1_num_long_term_ref_pics_sps); 1677 1678 /* lt_idx_sps[i] */ 1679 PUT_BITS( 1680 ps_bitstrm, ps_slice_hdr->ai1_lt_idx_sps[i], num_bits, return_status); 1681 ENTROPY_TRACE("lt_idx_sps[i]", ps_slice_hdr->ai1_lt_idx_sps[i]); 1682 } 1683 else 1684 { 1685 /* poc_lsb_lt[i] */ 1686 PUT_BITS( 1687 ps_bitstrm, 1688 ps_slice_hdr->ai4_poc_lsb_lt[i], 1689 ps_sps->i1_log2_max_pic_order_cnt_lsb, 1690 return_status); 1691 ENTROPY_TRACE("poc_lsb_lt[i]", ps_slice_hdr->ai4_poc_lsb_lt[i]); 1692 1693 /* used_by_curr_pic_lt_flag[i] */ 1694 PUT_BITS( 1695 ps_bitstrm, 1696 ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i], 1697 1, 1698 return_status); 1699 ENTROPY_TRACE( 1700 "used_by_curr_pic_lt_flag[i]", 1701 ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i]); 1702 } 1703 1704 /* delta_poc_msb_present_flag[i] */ 1705 PUT_BITS( 1706 ps_bitstrm, 1707 ps_slice_hdr->ai1_delta_poc_msb_present_flag[i], 1708 1, 1709 return_status); 1710 ENTROPY_TRACE( 1711 "delta_poc_msb_present_flag[i]", 1712 ps_slice_hdr->ai1_delta_poc_msb_present_flag[i]); 1713 1714 if(ps_slice_hdr->ai1_delta_poc_msb_present_flag[i]) 1715 { 1716 /* delata_poc_msb_cycle_lt[i] */ 1717 PUT_BITS_UEV( 1718 ps_bitstrm, ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i], return_status); 1719 ENTROPY_TRACE( 1720 "delata_poc_msb_cycle_lt", ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i]); 1721 } 1722 } 1723 } 1724 1725 if(ps_sps->i1_sps_temporal_mvp_enable_flag) 1726 { 1727 /* slice_temporal_mvp_enable_flag */ 1728 PUT_BITS( 1729 ps_bitstrm, ps_slice_hdr->i1_slice_temporal_mvp_enable_flag, 1, return_status); 1730 ENTROPY_TRACE( 1731 "slice_temporal_mvp_enable_flag", 1732 ps_slice_hdr->i1_slice_temporal_mvp_enable_flag); 1733 } 1734 } 1735 1736 if(ps_sps->i1_sample_adaptive_offset_enabled_flag) 1737 { 1738 /* slice_sao_luma_flag */ 1739 PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_slice_sao_luma_flag, 1, return_status); 1740 ENTROPY_TRACE("slice_sao_luma_flag", ps_slice_hdr->i1_slice_sao_luma_flag); 1741 1742 /* slice_sao_chroma_flag */ 1743 PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_slice_sao_chroma_flag, 1, return_status); 1744 ENTROPY_TRACE("slice_sao_chroma_flag", ps_slice_hdr->i1_slice_sao_chroma_flag); 1745 } 1746 if((PSLICE == ps_slice_hdr->i1_slice_type) || (BSLICE == ps_slice_hdr->i1_slice_type)) 1747 { 1748 /* num_ref_idx_active_override_flag */ 1749 PUT_BITS( 1750 ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_active_override_flag, 1, return_status); 1751 ENTROPY_TRACE( 1752 "num_ref_idx_active_override_flag", 1753 ps_slice_hdr->i1_num_ref_idx_active_override_flag); 1754 1755 if(ps_slice_hdr->i1_num_ref_idx_active_override_flag) 1756 { 1757 /* i1_num_ref_idx_l0_active_minus1 */ 1758 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_l0_active - 1, return_status); 1759 ENTROPY_TRACE( 1760 "i1_num_ref_idx_l0_active_minus1", ps_slice_hdr->i1_num_ref_idx_l0_active - 1); 1761 1762 if(BSLICE == ps_slice_hdr->i1_slice_type) 1763 { 1764 /* i1_num_ref_idx_l1_active */ 1765 PUT_BITS_UEV( 1766 ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_l1_active - 1, return_status); 1767 ENTROPY_TRACE( 1768 "i1_num_ref_idx_l1_active", ps_slice_hdr->i1_num_ref_idx_l1_active - 1); 1769 } 1770 } 1771 1772 if(ps_pps->i1_lists_modification_present_flag && i4_NumPocTotalCurr > 1) 1773 { 1774 ref_pic_list_modification(ps_bitstrm, ps_slice_hdr, i4_NumPocTotalCurr); 1775 } 1776 1777 if(BSLICE == ps_slice_hdr->i1_slice_type) 1778 { 1779 /* mvd_l1_zero_flag */ 1780 PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_mvd_l1_zero_flag, 1, return_status); 1781 ENTROPY_TRACE("mvd_l1_zero_flag", ps_slice_hdr->i1_mvd_l1_zero_flag); 1782 } 1783 1784 if(ps_pps->i1_cabac_init_present_flag) 1785 { 1786 /* cabac_init_flag */ 1787 PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_cabac_init_flag, 1, return_status); 1788 ENTROPY_TRACE("cabac_init_flag", ps_slice_hdr->i1_cabac_init_flag); 1789 } 1790 1791 if(ps_slice_hdr->i1_slice_temporal_mvp_enable_flag) 1792 { 1793 if(BSLICE == ps_slice_hdr->i1_slice_type) 1794 { 1795 /* collocated_from_l0_flag */ 1796 PUT_BITS( 1797 ps_bitstrm, ps_slice_hdr->i1_collocated_from_l0_flag, 1, return_status); 1798 ENTROPY_TRACE( 1799 "collocated_from_l0_flag", ps_slice_hdr->i1_collocated_from_l0_flag); 1800 } 1801 if((ps_slice_hdr->i1_collocated_from_l0_flag && 1802 (ps_slice_hdr->i1_num_ref_idx_l0_active > 1)) || 1803 (!ps_slice_hdr->i1_collocated_from_l0_flag && 1804 (ps_slice_hdr->i1_num_ref_idx_l1_active > 1))) 1805 { 1806 /* collocated_ref_idx */ 1807 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_collocated_ref_idx, return_status); 1808 ENTROPY_TRACE("collocated_ref_idx", ps_slice_hdr->i1_collocated_ref_idx); 1809 } 1810 } 1811 1812 if((ps_pps->i1_weighted_pred_flag && (PSLICE == ps_slice_hdr->i1_slice_type)) || 1813 (ps_pps->i1_weighted_bipred_flag && (BSLICE == ps_slice_hdr->i1_slice_type))) 1814 { 1815 ihevce_generate_pred_weight_table(ps_bitstrm, ps_sps, ps_pps, ps_slice_hdr); 1816 } 1817 1818 #if !HM_8DOT1_SYNTAX 1819 /* five_minus_max_num_merge_cand */ 1820 PUT_BITS_UEV(ps_bitstrm, 5 - ps_slice_hdr->i1_max_num_merge_cand, return_status); 1821 ENTROPY_TRACE("five_minus_max_num_merge_cand", 5 - ps_slice_hdr->i1_max_num_merge_cand); 1822 #endif 1823 } 1824 #if HM_8DOT1_SYNTAX 1825 /* five_minus_max_num_merge_cand */ 1826 PUT_BITS_UEV(ps_bitstrm, 5 - ps_slice_hdr->i1_max_num_merge_cand, return_status); 1827 ENTROPY_TRACE("five_minus_max_num_merge_cand", 5 - ps_slice_hdr->i1_max_num_merge_cand); 1828 #endif 1829 1830 /* slice_qp_delta */ 1831 PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_qp_delta, return_status); 1832 ENTROPY_TRACE("slice_qp_delta", ps_slice_hdr->i1_slice_qp_delta); 1833 1834 if(ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag) 1835 { 1836 /* slice_cb_qp_offset */ 1837 PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_cb_qp_offset, return_status); 1838 ENTROPY_TRACE("slice_cb_qp_offset", ps_slice_hdr->i1_slice_cb_qp_offset); 1839 1840 /* slice_cr_qp_offset */ 1841 PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_cr_qp_offset, return_status); 1842 ENTROPY_TRACE("slice_cr_qp_offset", ps_slice_hdr->i1_slice_cr_qp_offset); 1843 } 1844 1845 if(ps_pps->i1_deblocking_filter_control_present_flag) 1846 { 1847 if(ps_pps->i1_deblocking_filter_override_enabled_flag) 1848 { 1849 /* deblocking_filter_override_flag */ 1850 PUT_BITS( 1851 ps_bitstrm, ps_slice_hdr->i1_deblocking_filter_override_flag, 1, return_status); 1852 ENTROPY_TRACE( 1853 "deblocking_filter_override_flag", 1854 ps_slice_hdr->i1_deblocking_filter_override_flag); 1855 } 1856 1857 if(ps_slice_hdr->i1_deblocking_filter_override_flag) 1858 { 1859 /* slice_disable_deblocking_filter_flag */ 1860 PUT_BITS( 1861 ps_bitstrm, 1862 ps_slice_hdr->i1_slice_disable_deblocking_filter_flag, 1863 1, 1864 return_status); 1865 ENTROPY_TRACE( 1866 "slice_disable_deblocking_filter_flag", 1867 ps_slice_hdr->i1_slice_disable_deblocking_filter_flag); 1868 1869 if(!ps_slice_hdr->i1_slice_disable_deblocking_filter_flag) 1870 { 1871 /* beta_offset_div2 */ 1872 PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_beta_offset_div2 >> 1, return_status); 1873 ENTROPY_TRACE("beta_offset_div2", ps_slice_hdr->i1_beta_offset_div2 >> 1); 1874 1875 /* tc_offset_div2 */ 1876 PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_tc_offset_div2 >> 1, return_status); 1877 ENTROPY_TRACE("tc_offset_div2", ps_slice_hdr->i1_tc_offset_div2 >> 1); 1878 } 1879 } 1880 } 1881 1882 disable_deblocking_filter_flag = ps_slice_hdr->i1_slice_disable_deblocking_filter_flag | 1883 ps_pps->i1_pic_disable_deblocking_filter_flag; 1884 1885 if(ps_pps->i1_loop_filter_across_slices_enabled_flag && 1886 (ps_slice_hdr->i1_slice_sao_luma_flag || ps_slice_hdr->i1_slice_sao_chroma_flag || 1887 !disable_deblocking_filter_flag)) 1888 { 1889 /* slice_loop_filter_across_slices_enabled_flag */ 1890 PUT_BITS( 1891 ps_bitstrm, 1892 ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag, 1893 1, 1894 return_status); 1895 ENTROPY_TRACE( 1896 "slice_loop_filter_across_slices_enabled_flag", 1897 ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag); 1898 } 1899 } 1900 1901 if((ps_pps->i1_tiles_enabled_flag) || (ps_pps->i1_entropy_coding_sync_enabled_flag)) 1902 { 1903 /* num_entry_point_offsets */ 1904 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i4_num_entry_point_offsets, return_status); 1905 ENTROPY_TRACE("num_entry_point_offsets", ps_slice_hdr->i4_num_entry_point_offsets); 1906 1907 /*copy the bitstream state at this stage, later once all the offset are known the duplicated state is used to write offset in bitstream*/ 1908 memcpy(ps_dup_bit_strm_ent_offset, ps_bitstrm, sizeof(bitstrm_t)); 1909 1910 if(ps_slice_hdr->i4_num_entry_point_offsets > 0) 1911 { 1912 /* offset_len_minus1 */ 1913 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_offset_len - 1, return_status); 1914 ENTROPY_TRACE("offset_len_minus1", ps_slice_hdr->i1_offset_len - 1); 1915 1916 /*check the bitstream offset here, the first offset will be fixed here based on num_entry_offset and maximum possible emulaiton prevention bytes*/ 1917 /*This offset is used to generate bitstream, In the end of frame processing actual offset are updated and if there was no emulation bits the extra bytes 1918 shall be filled with 0xFF so that decoder discards it as part of slice header extension*/ 1919 1920 /*assume one byte of emulation preention for every offset we signal*/ 1921 /*considering emulation prevention bytes and assuming incomplete word(4 bytes) that is yet to filled and offset length(4 bytes) that will be calc 1922 based on max offset length after frame is encoded*/ 1923 pu4_first_slice_start_offset[0] = 1924 ps_bitstrm->u4_strm_buf_offset + 1925 ((ps_slice_hdr->i4_num_entry_point_offsets * ps_slice_hdr->i1_offset_len) >> 3) + 1926 ps_slice_hdr->i4_num_entry_point_offsets + 4 + 4; 1927 1928 ps_slice_hdr->pu4_entry_point_offset[0] = (*pu4_first_slice_start_offset); 1929 1930 for(i = 0; i < ps_slice_hdr->i4_num_entry_point_offsets; i++) 1931 { 1932 /* entry_point_offset[i] */ 1933 PUT_BITS( 1934 ps_bitstrm, 1935 ps_slice_hdr->pu4_entry_point_offset[i], 1936 ps_slice_hdr->i1_offset_len, 1937 return_status); 1938 ENTROPY_TRACE("entry_point_offset[i]", ps_slice_hdr->pu4_entry_point_offset[i]); 1939 } 1940 } 1941 } 1942 1943 if(ps_pps->i1_slice_header_extension_present_flag) 1944 { 1945 /* slice_header_extension_length */ 1946 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i2_slice_header_extension_length, return_status); 1947 ENTROPY_TRACE( 1948 "slice_header_extension_length", ps_slice_hdr->i2_slice_header_extension_length); 1949 1950 for(i = 0; i < ps_slice_hdr->i2_slice_header_extension_length; i++) 1951 { 1952 /* slice_header_extension_data_byte[i] */ 1953 PUT_BITS(ps_bitstrm, 0, 8, return_status); 1954 ENTROPY_TRACE("slice_header_extension_data_byte[i]", 0); 1955 } 1956 } 1957 1958 BYTE_ALIGNMENT(ps_bitstrm); 1959 1960 return return_status; 1961 } 1962 1963 /** 1964 ****************************************************************************** 1965 * 1966 * @brief Populates vps structure 1967 * 1968 * @par Description 1969 * All the parameters in vps are currently hard coded 1970 * 1971 * @param[out] ps_vps 1972 * pointer to vps params that needs to be populated 1973 * 1974 * @param[in] ps_src_params 1975 * pointer to source config params; resolution, frame rate etc 1976 * 1977 * @param[in] ps_out_strm_params 1978 * pointer to output stream config params 1979 * 1980 * @param[in] ps_coding_params 1981 * pointer to coding params; to enable/disable various toolsets in pps 1982 * 1983 * @param[in] ps_config_prms 1984 * pointer to configuration params like bitrate, HRD buffer sizes, cu, tu sizes 1985 * 1986 * 1987 * @return success or failure error code 1988 * 1989 ****************************************************************************** 1990 */ 1991 WORD32 ihevce_populate_vps( 1992 enc_ctxt_t *ps_enc_ctxt, 1993 vps_t *ps_vps, 1994 ihevce_src_params_t *ps_src_params, 1995 ihevce_out_strm_params_t *ps_out_strm_params, 1996 ihevce_coding_params_t *ps_coding_params, 1997 ihevce_config_prms_t *ps_config_prms, 1998 ihevce_static_cfg_params_t *ps_stat_cfg_prms, 1999 WORD32 i4_resolution_id) 2000 { 2001 WORD8 *pi1_profile_compatiblity_flags; 2002 WORD32 i; 2003 WORD32 i4_field_pic = ps_src_params->i4_field_pic; 2004 WORD32 i4_codec_level_index; 2005 ps_vps->i1_vps_id = DEFAULT_VPS_ID; 2006 2007 (void)ps_config_prms; 2008 /* default sub layers is 1 */ 2009 ps_vps->i1_vps_max_sub_layers = 1; 2010 if(1 == ps_stat_cfg_prms->s_tgt_lyr_prms.i4_enable_temporal_scalability) 2011 { 2012 ps_vps->i1_vps_max_sub_layers = 2; 2013 } 2014 2015 for(i = 0; i < ps_vps->i1_vps_max_sub_layers; i++) 2016 { 2017 /* currently bit rate and pic rate signalling is disabled */ 2018 ps_vps->ai1_bit_rate_info_present_flag[i] = 0; 2019 ps_vps->ai1_pic_rate_info_present_flag[i] = 0; 2020 2021 if(ps_vps->ai1_bit_rate_info_present_flag[i]) 2022 { 2023 /* TODO: Add support for bitrate and max bitrate */ 2024 ps_vps->au2_avg_bit_rate[i] = 0; 2025 ps_vps->au2_max_bit_rate[i] = 0; 2026 } 2027 2028 if(ps_vps->ai1_pic_rate_info_present_flag[i]) 2029 { 2030 /* TODO: Add support for pic rate idc and avg pic rate */ 2031 } 2032 } 2033 2034 /* default sub layer ordering info present flag */ 2035 ps_vps->i1_sub_layer_ordering_info_present_flag = VPS_SUB_LAYER_ORDERING_INFO_ABSENT; 2036 2037 /* hrd and temporal id nesting not supported for now */ 2038 ps_vps->i1_vps_num_hrd_parameters = 0; 2039 2040 if(ps_vps->i1_vps_max_sub_layers == 1) 2041 { 2042 ps_vps->i1_vps_temporal_id_nesting_flag = 1; 2043 } 2044 else 2045 { 2046 ps_vps->i1_vps_temporal_id_nesting_flag = 0; 2047 } 2048 2049 /* populate the general profile, tier and level information */ 2050 ps_vps->s_ptl.s_ptl_gen.i1_profile_space = 0; // BLU_RAY specific change is default 2051 2052 /* set the profile according to user input */ 2053 ps_vps->s_ptl.s_ptl_gen.i1_profile_idc = ps_out_strm_params->i4_codec_profile; 2054 2055 /***************************************************************/ 2056 /* set the profile compatibility flag for current profile to 1 */ 2057 /* the rest of the flags are set to 0 */ 2058 /***************************************************************/ 2059 pi1_profile_compatiblity_flags = &ps_vps->s_ptl.s_ptl_gen.ai1_profile_compatibility_flag[0]; 2060 2061 for(i = 0; i < ps_vps->i1_vps_max_sub_layers; i++) //TEMPORALA_SCALABILITY CHANGES 2062 { 2063 ps_vps->ai1_vps_max_dec_pic_buffering[i] = 2064 ps_coding_params->i4_max_reference_frames + (2 << i4_field_pic) - 1; 2065 2066 ps_vps->ai1_vps_max_num_reorder_pics[i] = ps_coding_params->i4_max_temporal_layers 2067 << i4_field_pic; 2068 2069 ps_vps->ai1_vps_max_latency_increase[i] = 0; 2070 2071 ps_vps->s_ptl.ai1_sub_layer_level_present_flag[i] = 1; //TEMPORALA_SCALABILITY CHANGES 2072 2073 ps_vps->s_ptl.ai1_sub_layer_profile_present_flag[i] = 0; //TEMPORALA_SCALABILITY CHANGES 2074 2075 ps_vps->s_ptl.as_ptl_sub[i].i1_profile_space = 0; // BLU_RAY specific change is default 2076 2077 ps_vps->s_ptl.as_ptl_sub[i].i1_profile_idc = ps_out_strm_params->i4_codec_profile; 2078 2079 memset( 2080 ps_vps->s_ptl.as_ptl_sub[i].ai1_profile_compatibility_flag, 2081 0, 2082 MAX_PROFILE_COMPATBLTY * sizeof(WORD8)); 2083 2084 ps_vps->s_ptl.as_ptl_sub[i] 2085 .ai1_profile_compatibility_flag[ps_out_strm_params->i4_codec_profile] = 1; 2086 2087 ps_vps->s_ptl.as_ptl_sub[i].u1_level_idc = 2088 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level; 2089 2090 if(0 == i) // Only one level temporal scalability suport has been added. 2091 { 2092 i4_codec_level_index = ihevce_get_level_index( 2093 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level); 2094 2095 if(i4_codec_level_index) 2096 i4_codec_level_index -= 1; 2097 2098 ps_vps->s_ptl.as_ptl_sub[i].u1_level_idc = 2099 (WORD32)g_as_level_data[i4_codec_level_index].e_level; 2100 } 2101 2102 ps_vps->s_ptl.as_ptl_sub[i].i1_tier_flag = ps_out_strm_params->i4_codec_tier; 2103 2104 if(ps_src_params->i4_field_pic == IV_PROGRESSIVE) 2105 { 2106 ps_vps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 1; 2107 2108 ps_vps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 0; 2109 } 2110 else if(ps_src_params->i4_field_pic == IV_INTERLACED) 2111 { 2112 ps_vps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 0; 2113 2114 ps_vps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 1; 2115 } 2116 else if(ps_src_params->i4_field_pic == IV_CONTENTTYPE_NA) 2117 { 2118 ps_vps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 0; 2119 2120 ps_vps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 0; 2121 } 2122 2123 ps_vps->s_ptl.as_ptl_sub[i].i1_general_non_packed_constraint_flag = 2124 DEFAULT_NON_PACKED_CONSTRAINT_FLAG; 2125 2126 if(ps_enc_ctxt->i4_blu_ray_spec == 1) 2127 { 2128 ps_vps->s_ptl.as_ptl_sub[i].i1_frame_only_constraint_flag = 1; 2129 } 2130 else 2131 { 2132 ps_vps->s_ptl.as_ptl_sub[i].i1_frame_only_constraint_flag = 2133 DEFAULT_FRAME_ONLY_CONSTRAINT_FLAG; 2134 } 2135 } 2136 2137 memset(pi1_profile_compatiblity_flags, 0, MAX_PROFILE_COMPATBLTY); 2138 pi1_profile_compatiblity_flags[ps_out_strm_params->i4_codec_profile] = 1; 2139 2140 /* set the level idc according to user input */ 2141 ps_vps->s_ptl.s_ptl_gen.u1_level_idc = 2142 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level; 2143 2144 ps_vps->s_ptl.s_ptl_gen.i1_tier_flag = ps_out_strm_params->i4_codec_tier; 2145 2146 if(ps_src_params->i4_field_pic == IV_PROGRESSIVE) 2147 { 2148 ps_vps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 1; 2149 2150 ps_vps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 0; 2151 } 2152 else if(ps_src_params->i4_field_pic == IV_INTERLACED) 2153 { 2154 ps_vps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 0; 2155 2156 ps_vps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 1; 2157 } 2158 else if(ps_src_params->i4_field_pic == IV_CONTENTTYPE_NA) 2159 { 2160 ps_vps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 0; 2161 2162 ps_vps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 0; 2163 } 2164 2165 ps_vps->s_ptl.s_ptl_gen.i1_general_non_packed_constraint_flag = 2166 DEFAULT_NON_PACKED_CONSTRAINT_FLAG; 2167 2168 if(ps_enc_ctxt->i4_blu_ray_spec == 1) 2169 { 2170 ps_vps->s_ptl.s_ptl_gen.i1_frame_only_constraint_flag = 1; 2171 } 2172 else 2173 { 2174 ps_vps->s_ptl.s_ptl_gen.i1_frame_only_constraint_flag = DEFAULT_FRAME_ONLY_CONSTRAINT_FLAG; 2175 } 2176 if((ps_out_strm_params->i4_codec_profile == 4) && 2177 (ps_src_params->i4_chr_format == IV_YUV_420SP_UV)) 2178 { 2179 ps_vps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 1; 2180 2181 ps_vps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; 2182 2183 ps_vps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; 2184 2185 ps_vps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 1; 2186 2187 ps_vps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 1; 2188 2189 ps_vps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; 2190 2191 ps_vps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; 2192 2193 ps_vps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; 2194 2195 ps_vps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 1; 2196 } 2197 else if( 2198 (ps_out_strm_params->i4_codec_profile == 4) && 2199 (ps_src_params->i4_chr_format == IV_YUV_422SP_UV)) 2200 { 2201 ps_vps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 1; 2202 2203 ps_vps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; 2204 2205 ps_vps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; 2206 2207 ps_vps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 1; 2208 2209 ps_vps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 0; 2210 2211 ps_vps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; 2212 2213 ps_vps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; 2214 2215 ps_vps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; 2216 2217 ps_vps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 1; 2218 } 2219 else 2220 { 2221 ps_vps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 0; 2222 2223 ps_vps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; 2224 2225 ps_vps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; 2226 2227 ps_vps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 0; 2228 2229 ps_vps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 0; 2230 2231 ps_vps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; 2232 2233 ps_vps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; 2234 2235 ps_vps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; 2236 2237 ps_vps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 0; 2238 } 2239 2240 ps_vps->i1_vps_max_nuh_reserved_zero_layer_id = 0; 2241 2242 return IHEVCE_SUCCESS; 2243 } 2244 2245 /** 2246 ****************************************************************************** 2247 * 2248 * @brief Populates sps structure 2249 * 2250 * @par Description 2251 * Populates sps structure for its use in header generation 2252 * 2253 * @param[out] ps_sps 2254 * pointer to sps params that needs to be populated 2255 * 2256 * @param[in] ps_vps 2257 * pointer to vps params referred by the sps 2258 * 2259 * @param[in] ps_src_params 2260 * pointer to source config params; resolution, frame rate etc 2261 * 2262 * @param[in] ps_out_strm_params 2263 * pointer to output stream config params 2264 * 2265 * @param[in] ps_coding_params 2266 * pointer to coding params; to enable/disable various toolsets in pps 2267 * 2268 * @param[in] ps_config_prms 2269 * pointer to configuration params like bitrate, HRD buffer sizes, cu, tu sizes 2270 * 2271 * @return success or failure error code 2272 * 2273 ****************************************************************************** 2274 */ 2275 WORD32 ihevce_populate_sps( 2276 enc_ctxt_t *ps_enc_ctxt, 2277 sps_t *ps_sps, 2278 vps_t *ps_vps, 2279 ihevce_src_params_t *ps_src_params, 2280 ihevce_out_strm_params_t *ps_out_strm_params, 2281 ihevce_coding_params_t *ps_coding_params, 2282 ihevce_config_prms_t *ps_config_prms, 2283 frm_ctb_ctxt_t *ps_frm_ctb_prms, 2284 ihevce_static_cfg_params_t *ps_stat_cfg_prms, 2285 WORD32 i4_resolution_id) 2286 { 2287 WORD32 i; 2288 WORD32 i4_field_pic = ps_src_params->i4_field_pic; 2289 WORD32 i4_quality_preset = 2290 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset; 2291 WORD32 i4_codec_level_index; 2292 2293 if(i4_quality_preset == IHEVCE_QUALITY_P7) 2294 { 2295 i4_quality_preset = IHEVCE_QUALITY_P6; 2296 } 2297 2298 ps_sps->i1_sps_id = DEFAULT_SPS_ID; 2299 2300 if(1 == ps_stat_cfg_prms->s_tgt_lyr_prms.i4_mres_single_out) 2301 { 2302 ps_sps->i1_sps_id = i4_resolution_id; 2303 } 2304 2305 ps_sps->i1_vps_id = ps_vps->i1_vps_id; 2306 2307 ps_sps->i2_pic_height_in_luma_samples = ps_frm_ctb_prms->i4_cu_aligned_pic_ht; 2308 2309 ps_sps->i2_pic_width_in_luma_samples = ps_frm_ctb_prms->i4_cu_aligned_pic_wd; 2310 2311 ps_sps->i1_amp_enabled_flag = AMP_ENABLED; 2312 2313 ps_sps->i1_chroma_format_idc = (ps_src_params->i4_chr_format == IV_YUV_422SP_UV) ? 2 : 1; 2314 2315 ps_sps->i1_separate_colour_plane_flag = 0; 2316 2317 ps_sps->i1_bit_depth_luma_minus8 = ps_stat_cfg_prms->s_tgt_lyr_prms.i4_internal_bit_depth - 8; 2318 2319 ps_sps->i1_bit_depth_chroma_minus8 = ps_stat_cfg_prms->s_tgt_lyr_prms.i4_internal_bit_depth - 8; 2320 2321 ps_sps->i1_log2_min_coding_block_size = ps_config_prms->i4_min_log2_cu_size; 2322 2323 ps_sps->i1_log2_diff_max_min_coding_block_size = 2324 ps_config_prms->i4_max_log2_cu_size - ps_config_prms->i4_min_log2_cu_size; 2325 2326 ps_sps->i1_log2_ctb_size = 2327 ps_sps->i1_log2_min_coding_block_size + ps_sps->i1_log2_diff_max_min_coding_block_size; 2328 2329 ps_sps->i1_log2_diff_max_min_transform_block_size = 2330 ps_config_prms->i4_max_log2_tu_size - ps_config_prms->i4_min_log2_tu_size; 2331 2332 ps_sps->i1_log2_min_transform_block_size = ps_config_prms->i4_min_log2_tu_size; 2333 2334 ps_sps->i1_long_term_ref_pics_present_flag = LONG_TERM_REF_PICS_ABSENT; 2335 2336 ps_sps->i1_max_transform_hierarchy_depth_inter = ps_config_prms->i4_max_tr_tree_depth_nI; 2337 2338 ps_sps->i1_max_transform_hierarchy_depth_intra = ps_config_prms->i4_max_tr_tree_depth_I; 2339 2340 ps_sps->i1_pcm_enabled_flag = PCM_DISABLED; 2341 2342 ps_sps->i1_pcm_loop_filter_disable_flag = PCM_LOOP_FILTER_DISABLED; 2343 2344 ps_sps->i1_pic_cropping_flag = !!ps_coding_params->i4_cropping_mode; 2345 2346 if(i4_quality_preset < IHEVCE_QUALITY_P4) 2347 { 2348 /*** Enable SAO for PQ,HQ,MS presets **/ 2349 ps_sps->i1_sample_adaptive_offset_enabled_flag = SAO_ENABLED; 2350 } 2351 else 2352 { 2353 ps_sps->i1_sample_adaptive_offset_enabled_flag = SAO_DISABLED; 2354 } 2355 #if DISABLE_SAO 2356 ps_sps->i1_sample_adaptive_offset_enabled_flag = SAO_DISABLED; 2357 #endif 2358 2359 if(ps_coding_params->i4_use_default_sc_mtx == 1) 2360 { 2361 ps_sps->i1_scaling_list_enable_flag = SCALING_LIST_ENABLED; 2362 } 2363 else 2364 { 2365 ps_sps->i1_scaling_list_enable_flag = SCALING_LIST_DISABLED; 2366 } 2367 2368 ps_sps->i1_sps_max_sub_layers = DEFAULT_SPS_MAX_SUB_LAYERS; 2369 2370 if(1 == ps_stat_cfg_prms->s_tgt_lyr_prms.i4_enable_temporal_scalability) 2371 { 2372 ps_sps->i1_sps_max_sub_layers = DEFAULT_SPS_MAX_SUB_LAYERS + 1; 2373 } 2374 2375 ps_sps->i1_sps_sub_layer_ordering_info_present_flag = SPS_SUB_LAYER_ORDERING_INFO_ABSENT; 2376 2377 ps_sps->i1_sps_scaling_list_data_present_flag = SCALING_LIST_DATA_ABSENT; 2378 2379 if(ps_sps->i1_sps_max_sub_layers == 1) 2380 { 2381 ps_sps->i1_sps_temporal_id_nesting_flag = 1; //NO_SPS_TEMPORAL_ID_NESTING_DONE; 2382 } 2383 else 2384 { 2385 ps_sps->i1_sps_temporal_id_nesting_flag = 0; //NO_SPS_TEMPORAL_ID_NESTING_DONE; 2386 } 2387 2388 /* short term and long term ref pic set not signalled in sps */ 2389 ps_sps->i1_num_short_term_ref_pic_sets = 0; 2390 ps_sps->i1_long_term_ref_pics_present_flag = 0; 2391 2392 ps_sps->i1_num_long_term_ref_pics_sps = 0; 2393 ps_sps->i1_sps_temporal_mvp_enable_flag = !DISABLE_TMVP; 2394 2395 ps_sps->i1_strong_intra_smoothing_enable_flag = STRONG_INTRA_SMOOTHING_FLAG_ENABLE; 2396 2397 ps_sps->i1_vui_parameters_present_flag = ps_out_strm_params->i4_vui_enable; 2398 2399 /*required in generation of slice header*/ 2400 ps_sps->i2_pic_ht_in_ctb = ps_frm_ctb_prms->i4_num_ctbs_vert; 2401 2402 ps_sps->i2_pic_wd_in_ctb = ps_frm_ctb_prms->i4_num_ctbs_horz; 2403 2404 ps_sps->i1_log2_max_pic_order_cnt_lsb = DEFAULT_LOG2_MAX_POC_LSB; 2405 2406 if(ps_sps->i1_pic_cropping_flag) 2407 { 2408 WORD32 num_rows_to_pad_bottom = 2409 ps_sps->i2_pic_height_in_luma_samples - ps_stat_cfg_prms->s_src_prms.i4_orig_height; 2410 WORD32 num_rows_to_pad_right = 2411 ps_sps->i2_pic_width_in_luma_samples - ps_stat_cfg_prms->s_src_prms.i4_orig_width; 2412 2413 ps_sps->i2_pic_crop_top_offset = DEFAULT_PIC_CROP_TOP_OFFSET; 2414 2415 ps_sps->i2_pic_crop_left_offset = DEFAULT_PIC_CROP_LEFT_OFFSET; 2416 2417 /* picture offsets should be signalled in terms of chroma unit */ 2418 ps_sps->i2_pic_crop_bottom_offset = num_rows_to_pad_bottom >> 1; 2419 2420 /* picture offsets should be signalled in terms of chroma unit */ 2421 ps_sps->i2_pic_crop_right_offset = num_rows_to_pad_right >> 1; 2422 } 2423 2424 for(i = 0; i < (ps_sps->i1_sps_max_sub_layers); i++) 2425 { 2426 ps_sps->ai1_sps_max_dec_pic_buffering[i] = 2427 ps_coding_params->i4_max_reference_frames + (2 << i4_field_pic) - 1; 2428 2429 ps_sps->ai1_sps_max_num_reorder_pics[i] = ps_coding_params->i4_max_temporal_layers 2430 << i4_field_pic; 2431 2432 ps_sps->ai1_sps_max_latency_increase[i] = 0; 2433 2434 ps_sps->s_ptl.ai1_sub_layer_level_present_flag[i] = 1; //TEMPORALA_SCALABILITY CHANGES 2435 2436 ps_sps->s_ptl.ai1_sub_layer_profile_present_flag[i] = 0; //TEMPORALA_SCALABILITY CHANGES 2437 2438 ps_sps->s_ptl.as_ptl_sub[i].i1_profile_space = 0; // BLU_RAY specific change is default 2439 2440 ps_sps->s_ptl.as_ptl_sub[i].i1_profile_idc = ps_out_strm_params->i4_codec_profile; 2441 2442 memset( 2443 ps_sps->s_ptl.as_ptl_sub[i].ai1_profile_compatibility_flag, 2444 0, 2445 MAX_PROFILE_COMPATBLTY * sizeof(WORD8)); 2446 2447 ps_sps->s_ptl.as_ptl_sub[i] 2448 .ai1_profile_compatibility_flag[ps_out_strm_params->i4_codec_profile] = 1; 2449 2450 ps_sps->s_ptl.as_ptl_sub[i].u1_level_idc = 2451 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level; 2452 2453 if(0 == i) // Only one level temporal scalability suport has been added. 2454 { 2455 i4_codec_level_index = ihevce_get_level_index( 2456 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level); 2457 2458 if(i4_codec_level_index) 2459 i4_codec_level_index -= 1; 2460 2461 ps_sps->s_ptl.as_ptl_sub[i].u1_level_idc = 2462 (WORD32)g_as_level_data[i4_codec_level_index].e_level; 2463 } 2464 ps_sps->s_ptl.as_ptl_sub[i].i1_tier_flag = ps_out_strm_params->i4_codec_tier; 2465 2466 if(ps_src_params->i4_field_pic == IV_PROGRESSIVE) 2467 { 2468 ps_sps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 1; 2469 2470 ps_sps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 0; 2471 } 2472 else if(ps_src_params->i4_field_pic == IV_INTERLACED) 2473 { 2474 ps_sps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 0; 2475 2476 ps_sps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 1; 2477 } 2478 else if(ps_src_params->i4_field_pic == IV_CONTENTTYPE_NA) 2479 { 2480 ps_sps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 0; 2481 2482 ps_sps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 0; 2483 } 2484 2485 ps_sps->s_ptl.as_ptl_sub[i].i1_general_non_packed_constraint_flag = 2486 DEFAULT_NON_PACKED_CONSTRAINT_FLAG; 2487 2488 if(ps_enc_ctxt->i4_blu_ray_spec == 1) 2489 { 2490 ps_sps->s_ptl.as_ptl_sub[i].i1_frame_only_constraint_flag = 1; 2491 } 2492 else 2493 { 2494 ps_sps->s_ptl.as_ptl_sub[i].i1_frame_only_constraint_flag = 2495 DEFAULT_FRAME_ONLY_CONSTRAINT_FLAG; 2496 } 2497 if((ps_out_strm_params->i4_codec_profile == 4) && (ps_sps->i1_chroma_format_idc == 1)) 2498 { 2499 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_12bit_constraint_flag = 1; 2500 2501 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_10bit_constraint_flag = 0; 2502 2503 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_8bit_constraint_flag = 0; 2504 2505 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_422chroma_constraint_flag = 1; 2506 2507 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_420chroma_constraint_flag = 1; 2508 2509 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_monochrome_constraint_flag = 0; 2510 2511 ps_sps->s_ptl.as_ptl_sub[i].i1_general_intra_constraint_flag = 0; 2512 2513 ps_sps->s_ptl.as_ptl_sub[i].i1_general_one_picture_only_constraint_flag = 0; 2514 2515 ps_sps->s_ptl.as_ptl_sub[i].i1_general_lower_bit_rate_constraint_flag = 1; 2516 } 2517 else if((ps_out_strm_params->i4_codec_profile == 4) && (ps_sps->i1_chroma_format_idc == 2)) 2518 { 2519 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_12bit_constraint_flag = 1; 2520 2521 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_10bit_constraint_flag = 0; 2522 2523 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_8bit_constraint_flag = 0; 2524 2525 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_422chroma_constraint_flag = 1; 2526 2527 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_420chroma_constraint_flag = 0; 2528 2529 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_monochrome_constraint_flag = 0; 2530 2531 ps_sps->s_ptl.as_ptl_sub[i].i1_general_intra_constraint_flag = 0; 2532 2533 ps_sps->s_ptl.as_ptl_sub[i].i1_general_one_picture_only_constraint_flag = 0; 2534 2535 ps_sps->s_ptl.as_ptl_sub[i].i1_general_lower_bit_rate_constraint_flag = 1; 2536 } 2537 else 2538 { 2539 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_12bit_constraint_flag = 0; 2540 2541 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_10bit_constraint_flag = 0; 2542 2543 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_8bit_constraint_flag = 0; 2544 2545 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_422chroma_constraint_flag = 0; 2546 2547 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_420chroma_constraint_flag = 0; 2548 2549 ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_monochrome_constraint_flag = 0; 2550 2551 ps_sps->s_ptl.as_ptl_sub[i].i1_general_intra_constraint_flag = 0; 2552 2553 ps_sps->s_ptl.as_ptl_sub[i].i1_general_one_picture_only_constraint_flag = 0; 2554 2555 ps_sps->s_ptl.as_ptl_sub[i].i1_general_lower_bit_rate_constraint_flag = 0; 2556 } 2557 } 2558 2559 memset( 2560 ps_sps->s_ptl.s_ptl_gen.ai1_profile_compatibility_flag, 2561 0, 2562 MAX_PROFILE_COMPATBLTY * sizeof(WORD8)); 2563 2564 /* populate the general profile, tier and level information */ 2565 ps_sps->s_ptl.s_ptl_gen.i1_profile_space = 0; // BLU_RAY specific change is default 2566 2567 ps_sps->s_ptl.s_ptl_gen.i1_profile_idc = ps_out_strm_params->i4_codec_profile; 2568 2569 ps_sps->s_ptl.s_ptl_gen.ai1_profile_compatibility_flag[ps_out_strm_params->i4_codec_profile] = 2570 1; 2571 2572 ps_sps->s_ptl.s_ptl_gen.u1_level_idc = 2573 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level; 2574 2575 ps_sps->s_ptl.s_ptl_gen.i1_tier_flag = ps_out_strm_params->i4_codec_tier; 2576 2577 if(ps_src_params->i4_field_pic == IV_PROGRESSIVE) 2578 { 2579 ps_sps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 1; 2580 2581 ps_sps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 0; 2582 } 2583 else if(ps_src_params->i4_field_pic == IV_INTERLACED) 2584 { 2585 ps_sps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 0; 2586 2587 ps_sps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 1; 2588 } 2589 else if(ps_src_params->i4_field_pic == IV_CONTENTTYPE_NA) 2590 { 2591 ps_sps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 0; 2592 2593 ps_sps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 0; 2594 } 2595 2596 ps_sps->s_ptl.s_ptl_gen.i1_general_non_packed_constraint_flag = 2597 DEFAULT_NON_PACKED_CONSTRAINT_FLAG; 2598 2599 if(ps_enc_ctxt->i4_blu_ray_spec == 1) 2600 { 2601 ps_sps->s_ptl.s_ptl_gen.i1_frame_only_constraint_flag = 1; 2602 } 2603 else 2604 { 2605 ps_sps->s_ptl.s_ptl_gen.i1_frame_only_constraint_flag = DEFAULT_FRAME_ONLY_CONSTRAINT_FLAG; 2606 } 2607 if((ps_out_strm_params->i4_codec_profile == 4) && (ps_sps->i1_chroma_format_idc == 1)) 2608 { 2609 ps_sps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 1; 2610 2611 ps_sps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; 2612 2613 ps_sps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; 2614 2615 ps_sps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 1; 2616 2617 ps_sps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 1; 2618 2619 ps_sps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; 2620 2621 ps_sps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; 2622 2623 ps_sps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; 2624 2625 ps_sps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 1; 2626 } 2627 else if((ps_out_strm_params->i4_codec_profile == 4) && (ps_sps->i1_chroma_format_idc == 2)) 2628 { 2629 ps_sps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 1; 2630 2631 ps_sps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; 2632 2633 ps_sps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; 2634 2635 ps_sps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 1; 2636 2637 ps_sps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 0; 2638 2639 ps_sps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; 2640 2641 ps_sps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; 2642 2643 ps_sps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; 2644 2645 ps_sps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 1; 2646 } 2647 else 2648 { 2649 ps_sps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 0; 2650 2651 ps_sps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; 2652 2653 ps_sps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; 2654 2655 ps_sps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 0; 2656 2657 ps_sps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 0; 2658 2659 ps_sps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; 2660 2661 ps_sps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; 2662 2663 ps_sps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; 2664 2665 ps_sps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 0; 2666 } 2667 2668 return IHEVCE_SUCCESS; 2669 } 2670 2671 /** 2672 ****************************************************************************** 2673 * 2674 * @brief Populates pps structure based on input cofiguration params 2675 * 2676 * @par Description 2677 * Populates pps structure for its use in header generation 2678 * 2679 * @param[out] ps_pps 2680 * pointer to pps params structure which needs to be populated 2681 * 2682 * @param[in] ps_sps 2683 * pointer to sps params refered by the pps 2684 * 2685 * @param[in] ps_src_params 2686 * pointer to source config params; resolution, frame rate etc 2687 * 2688 * @param[in] ps_out_strm_params 2689 * pointer to output stream config params 2690 * 2691 * @param[in] ps_coding_params 2692 * pointer to coding params; to enable/disable various toolsets in pps 2693 * 2694 * @param[in] ps_config_prms 2695 * pointer to configuration params like bitrate, HRD buffer sizes, cu, tu sizes 2696 * 2697 * @return success or failure error code 2698 * 2699 ****************************************************************************** 2700 */ 2701 WORD32 ihevce_populate_pps( 2702 pps_t *ps_pps, 2703 sps_t *ps_sps, 2704 ihevce_src_params_t *ps_src_params, 2705 ihevce_out_strm_params_t *ps_out_strm_params, 2706 ihevce_coding_params_t *ps_coding_params, 2707 ihevce_config_prms_t *ps_config_prms, 2708 ihevce_static_cfg_params_t *ps_stat_cfg_prms, 2709 WORD32 i4_bitrate_instance_id, 2710 WORD32 i4_resolution_id, 2711 ihevce_tile_params_t *ps_tile_params_base, 2712 WORD32 *pi4_column_width_array, 2713 WORD32 *pi4_row_height_array) 2714 { 2715 (void)ps_src_params; 2716 (void)ps_out_strm_params; 2717 2718 ps_pps->i1_beta_offset_div2 = DEFAULT_BETA_OFFSET; 2719 2720 ps_pps->i1_cabac_init_present_flag = CABAC_INIT_ABSENT; 2721 2722 ps_pps->i1_constrained_intra_pred_flag = CONSTR_IPRED_DISABLED; 2723 /*delta qp can be disabled for constant qp mode to save on qp signalling bits*/ 2724 ps_pps->i1_cu_qp_delta_enabled_flag = ps_config_prms->i4_cu_level_rc; 2725 2726 ps_pps->i1_deblocking_filter_control_present_flag = DEBLOCKING_FILTER_CONTROL_PRESENT; 2727 2728 ps_pps->i1_deblocking_filter_override_enabled_flag = DEBLOCKING_FILTER_OVERRIDE_DISABLED; 2729 2730 ps_pps->i1_pic_disable_deblocking_filter_flag = ps_coding_params->i4_deblocking_type; 2731 2732 if(0 != ps_stat_cfg_prms->s_slice_params.i4_slice_segment_mode) 2733 { 2734 ps_pps->i1_dependent_slice_enabled_flag = DEPENDENT_SLICE_ENABLED; 2735 } 2736 else 2737 { 2738 ps_pps->i1_dependent_slice_enabled_flag = DEPENDENT_SLICE_DISABLED; 2739 } 2740 2741 /* Assign the diff_cu_qp_delta_depth with 3,2,1 for making 2742 CU_LEVEL_QP_MODULATION limited to 8x8, 16x16, 32x32 respectively : Lokesh */ 2743 ps_pps->i1_diff_cu_qp_delta_depth = CU_LEVEL_QP_LIMIT_8x8; 2744 2745 if(1 == ps_coding_params->i4_enable_entropy_sync) 2746 { 2747 ps_pps->i1_entropy_coding_sync_enabled_flag = ENTROPY_CODING_SYNC_ENABLED; 2748 } 2749 else 2750 { 2751 ps_pps->i1_entropy_coding_sync_enabled_flag = ENTROPY_CODING_SYNC_DISABLED; 2752 } 2753 2754 ps_pps->i1_entropy_slice_enabled_flag = ENTROPY_SLICE_DISABLED; 2755 2756 ps_pps->i1_lists_modification_present_flag = ps_coding_params->i4_weighted_pred_enable; 2757 2758 ps_pps->i1_log2_parallel_merge_level = DEFAULT_PARALLEL_MERGE_LEVEL; 2759 2760 ps_pps->i1_num_extra_slice_header_bits = 0; 2761 2762 /* SAO_note_01: Currently SAO is implemented is such a way that the 2763 loop-filter has to be enabled across syntatical-tiles and slices. 2764 Search for <SAO_note_01> in workspace to know more */ 2765 ps_pps->i1_loop_filter_across_slices_enabled_flag = LF_ACROSS_SLICES_ENABLED; 2766 2767 ps_pps->i1_num_ref_idx_l0_default_active = DEFAULT_NUM_REF_IDX_L0_DEFAULT_ACTIVE; 2768 2769 ps_pps->i1_num_ref_idx_l1_default_active = DEFAULT_NUM_REF_IDX_L1_DEFAULT_ACTIVE; 2770 2771 if(0 == ps_tile_params_base->i4_tiles_enabled_flag) 2772 { 2773 ps_pps->i1_num_tile_columns = NUM_TILES_COLS; 2774 2775 ps_pps->i1_num_tile_rows = NUM_TILES_ROWS; 2776 2777 ps_pps->i1_tiles_enabled_flag = TILES_DISABLED; 2778 2779 ps_pps->i1_uniform_spacing_flag = SPACING_IS_UNIFORM; 2780 } 2781 else 2782 { 2783 ps_pps->i1_num_tile_columns = ps_tile_params_base->i4_num_tile_cols; 2784 2785 ps_pps->i1_num_tile_rows = ps_tile_params_base->i4_num_tile_rows; 2786 2787 ps_pps->i1_tiles_enabled_flag = TILES_ENABLED; 2788 2789 ps_pps->i1_uniform_spacing_flag = ps_tile_params_base->i4_uniform_spacing_flag; 2790 2791 if(SPACING_IS_NONUNIFORM == ps_pps->i1_uniform_spacing_flag) 2792 { 2793 WORD32 i4_i; 2794 for(i4_i = 0; i4_i < ps_tile_params_base->i4_num_tile_cols; i4_i++) 2795 { 2796 ps_pps->ps_tile[i4_i].u2_wd = pi4_column_width_array[i4_i] >> 2797 ps_config_prms->i4_max_log2_cu_size; 2798 } 2799 for(i4_i = 0; i4_i < ps_tile_params_base->i4_num_tile_rows; i4_i++) 2800 { 2801 ps_pps->ps_tile[i4_i].u2_ht = pi4_row_height_array[i4_i] >> 2802 ps_config_prms->i4_max_log2_cu_size; 2803 } 2804 } 2805 } 2806 2807 /* SAO_note_01: Currently SAO is implemented is such a way that the 2808 loop-filter has to be enabled across syntatical-tiles and slices. 2809 Search for <SAO_note_01> in workspace to know more */ 2810 if(0 == ps_tile_params_base->i4_tiles_enabled_flag) 2811 { 2812 ps_pps->i1_loop_filter_across_tiles_enabled_flag = 1; 2813 } 2814 else 2815 { 2816 ps_pps->i1_loop_filter_across_tiles_enabled_flag = 0; 2817 } 2818 2819 ps_pps->i1_output_flag_present_flag = OUTPUT_FLAG_ABSENT; 2820 2821 ps_pps->i1_pic_cb_qp_offset = DEFAULT_PIC_CB_QP_OFFSET; 2822 2823 ps_pps->i1_pic_cr_qp_offset = DEFAULT_PIC_CR_QP_OFFSET; 2824 2825 /*init qp is different for each bit-rate instance */ 2826 ps_pps->i1_pic_init_qp = CLIP3( 2827 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id] 2828 .ai4_frame_qp[i4_bitrate_instance_id], 2829 ps_config_prms->i4_min_frame_qp, 2830 ps_config_prms->i4_max_frame_qp); 2831 2832 /* enable chroma QP offset only if stasino or psy rd is present */ 2833 if(((ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_CONTROL_TOGGLER)) && 2834 ((ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_NOISE_PRESERVATION)) || 2835 (ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_1)) || 2836 (ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_2)) || 2837 (ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_3))))) 2838 { 2839 ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag = 2840 SLICE_LEVEL_CHROMA_QP_OFFSETS_PRESENT; 2841 } 2842 else 2843 { 2844 ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag = 2845 SLICE_LEVEL_CHROMA_QP_OFFSETS_ABSENT; 2846 } 2847 2848 ps_pps->i1_pps_id = DEFAULT_PPS_ID; 2849 2850 if(1 == ps_stat_cfg_prms->s_tgt_lyr_prms.i4_mres_single_out) 2851 { 2852 ps_pps->i1_pps_id = i4_resolution_id; 2853 } 2854 2855 ps_pps->i1_pps_scaling_list_data_present_flag = SCALING_LIST_DATA_ABSENT; 2856 2857 if(ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset < 2858 IHEVCE_QUALITY_P3) 2859 { 2860 ps_pps->i1_sign_data_hiding_flag = SIGN_DATA_HIDDEN; 2861 } 2862 else if( 2863 ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset == 2864 IHEVCE_QUALITY_P3) 2865 { 2866 ps_pps->i1_sign_data_hiding_flag = SIGN_DATA_UNHIDDEN; 2867 } 2868 else 2869 { 2870 ps_pps->i1_sign_data_hiding_flag = SIGN_DATA_UNHIDDEN; 2871 } 2872 2873 #if DISABLE_SBH 2874 ps_pps->i1_sign_data_hiding_flag = SIGN_DATA_UNHIDDEN; 2875 #endif 2876 2877 ps_pps->i1_slice_extension_present_flag = SLICE_EXTENSION_ABSENT; 2878 2879 ps_pps->i1_slice_header_extension_present_flag = SLICE_HEADER_EXTENSION_ABSENT; 2880 2881 ps_pps->i1_sps_id = ps_sps->i1_sps_id; 2882 2883 ps_pps->i1_tc_offset_div2 = DEFAULT_TC_OFFSET; 2884 2885 ps_pps->i1_transform_skip_enabled_flag = TRANSFORM_SKIP_DISABLED; 2886 2887 ps_pps->i1_transquant_bypass_enable_flag = TRANSFORM_BYPASS_DISABLED; 2888 2889 ps_pps->i1_weighted_bipred_flag = ps_coding_params->i4_weighted_pred_enable; 2890 2891 ps_pps->i1_weighted_pred_flag = ps_coding_params->i4_weighted_pred_enable; 2892 2893 return IHEVCE_SUCCESS; 2894 } 2895 2896 /** 2897 ****************************************************************************** 2898 * 2899 * @brief Populates slice header structure 2900 * 2901 * @par Description 2902 * Populates slice header structure for its use in header generation 2903 * 2904 * @param[out] ps_slice_hdr 2905 * pointer to slice header structure that needs to be populated 2906 * 2907 * @param[in] ps_pps 2908 * pointer to pps params structure refered by the slice 2909 * 2910 * @param[in] ps_sps 2911 * pointer to sps params refered by the pps 2912 * 2913 * @param[in] nal_unit_type 2914 * nal unit type for current slice 2915 * 2916 * @param[in] slice_type 2917 * current slice type 2918 * 2919 * @param[in] ctb_x 2920 * x offset of first ctb in current slice (ctb units) 2921 * 2922 * @param[in] ctb_y 2923 * y offset of first ctb in current slice (ctb units) 2924 * 2925 * @param[in] poc 2926 * pic order count for current slice (shall be 0 for IDR pics) 2927 * 2928 * @param[in] cur_slice_qp 2929 * qp for the current slice 2930 * 2931 * @return success or failure error code 2932 * 2933 ****************************************************************************** 2934 */ 2935 WORD32 ihevce_populate_slice_header( 2936 slice_header_t *ps_slice_hdr, 2937 pps_t *ps_pps, 2938 sps_t *ps_sps, 2939 WORD32 nal_unit_type, 2940 WORD32 slice_type, 2941 WORD32 ctb_x, 2942 WORD32 ctb_y, 2943 WORD32 poc, 2944 WORD32 cur_slice_qp, 2945 WORD32 max_merge_candidates, 2946 WORD32 i4_rc_pass_num, 2947 WORD32 i4_quality_preset, 2948 WORD32 stasino_enabled) 2949 { 2950 WORD32 i; 2951 WORD32 return_status = IHEVCE_SUCCESS; 2952 WORD32 RapPicFlag = (nal_unit_type >= NAL_BLA_W_LP) && (nal_unit_type <= NAL_RSV_RAP_VCL23); 2953 2954 WORD32 idr_pic_flag = (NAL_IDR_W_LP == nal_unit_type) || (NAL_IDR_N_LP == nal_unit_type); 2955 2956 WORD32 disable_deblocking_filter_flag; 2957 2958 (void)ctb_x; 2959 (void)ctb_y; 2960 /* first_slice_in_pic_flag */ 2961 if(i4_quality_preset == IHEVCE_QUALITY_P7) 2962 { 2963 i4_quality_preset = IHEVCE_QUALITY_P6; 2964 } 2965 2966 if(RapPicFlag) 2967 { 2968 /* no_output_of_prior_pics_flag */ /* TODO:revisit this */ 2969 ps_slice_hdr->i1_no_output_of_prior_pics_flag = 0; //BLU_RAY specific already done 2970 } 2971 2972 /* pic_parameter_set_id */ 2973 ps_slice_hdr->i1_pps_id = ps_pps->i1_pps_id; 2974 2975 { 2976 /* This i1_dependent_slice_flag will further be updated in generate_slice_header() function */ 2977 ps_slice_hdr->i1_dependent_slice_flag = 0; 2978 } 2979 2980 if(!ps_slice_hdr->i1_dependent_slice_flag) 2981 { 2982 /* slice_type */ 2983 ps_slice_hdr->i1_slice_type = (WORD8)slice_type; 2984 2985 if(ps_pps->i1_output_flag_present_flag) 2986 { 2987 /* pic_output_flag */ /* TODO:revisit this */ 2988 ps_slice_hdr->i1_pic_output_flag = 0; 2989 } 2990 2991 /* separate colour plane flag not supported in this encoder */ 2992 ASSERT(0 == ps_sps->i1_separate_colour_plane_flag); 2993 2994 if(!idr_pic_flag) 2995 { 2996 WORD32 log2_max_poc_lsb = ps_sps->i1_log2_max_pic_order_cnt_lsb; 2997 2998 /* pic_order_cnt_lsb */ 2999 ps_slice_hdr->i4_pic_order_cnt_lsb = poc & ((1 << log2_max_poc_lsb) - 1); 3000 3001 /* short_term_ref_pic_set_sps_flag */ 3002 /* TODO : revisit this */ 3003 ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag = 0; 3004 3005 if(!ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag) 3006 { 3007 /* TODO: To populate short term ref pic set for this slice */ 3008 } 3009 3010 /* long term ref pic flag not supported */ 3011 ASSERT(0 == ps_sps->i1_long_term_ref_pics_present_flag); 3012 if(ps_sps->i1_long_term_ref_pics_present_flag) 3013 { 3014 /* TODO : not supported */ 3015 } 3016 } 3017 3018 //ASSERT(0 == ps_sps->i1_sample_adaptive_offset_enabled_flag); 3019 if(ps_sps->i1_sample_adaptive_offset_enabled_flag) 3020 { 3021 /* slice_sao_luma_flag */ 3022 ps_slice_hdr->i1_slice_sao_luma_flag = 1; 3023 ps_slice_hdr->i1_slice_sao_chroma_flag = 1; 3024 } 3025 3026 #if DISABLE_LUMA_SAO 3027 ps_slice_hdr->i1_slice_sao_luma_flag = 0; 3028 #endif 3029 3030 #if DISABLE_CHROMA_SAO 3031 ps_slice_hdr->i1_slice_sao_chroma_flag = 0; 3032 #endif 3033 if((PSLICE == ps_slice_hdr->i1_slice_type) || (BSLICE == ps_slice_hdr->i1_slice_type)) 3034 { 3035 /* TODO: currently temporal mvp disabled, need to enable later */ 3036 if(1 == ps_sps->i1_sps_temporal_mvp_enable_flag) 3037 { 3038 ps_slice_hdr->i1_slice_temporal_mvp_enable_flag = 1; 3039 } 3040 else 3041 { 3042 ps_slice_hdr->i1_slice_temporal_mvp_enable_flag = 0; 3043 } 3044 3045 /* num_ref_idx_active_override_flag */ 3046 ps_slice_hdr->i1_num_ref_idx_active_override_flag = 0; 3047 3048 if(ps_slice_hdr->i1_num_ref_idx_active_override_flag) 3049 { 3050 /* TODO revisit this*/ 3051 /* i1_num_ref_idx_l0_active_minus1 */ 3052 ps_slice_hdr->i1_num_ref_idx_l0_active = 1; 3053 3054 if(BSLICE == ps_slice_hdr->i1_slice_type) 3055 { 3056 /* i1_num_ref_idx_l1_active */ 3057 /* TODO revisit this*/ 3058 ps_slice_hdr->i1_num_ref_idx_l1_active = 1; 3059 } 3060 } 3061 3062 if(BSLICE == ps_slice_hdr->i1_slice_type) 3063 { 3064 /* mvd_l1_zero_flag */ 3065 ps_slice_hdr->i1_mvd_l1_zero_flag = 0; 3066 } 3067 3068 { 3069 /* cabac_init_flag curently set to 0 */ 3070 ps_slice_hdr->i1_cabac_init_flag = ps_pps->i1_cabac_init_present_flag ? 1 : 0; 3071 } 3072 3073 if(ps_slice_hdr->i1_slice_temporal_mvp_enable_flag) 3074 { 3075 if(BSLICE == ps_slice_hdr->i1_slice_type) 3076 { 3077 /* collocated_from_l0_flag */ 3078 ps_slice_hdr->i1_collocated_from_l0_flag = 0; 3079 } 3080 else if(PSLICE == ps_slice_hdr->i1_slice_type) 3081 { 3082 ps_slice_hdr->i1_collocated_from_l0_flag = 1; 3083 } 3084 3085 if((ps_slice_hdr->i1_collocated_from_l0_flag && 3086 (ps_slice_hdr->i1_num_ref_idx_l0_active > 1)) || 3087 (!ps_slice_hdr->i1_collocated_from_l0_flag && 3088 (ps_slice_hdr->i1_num_ref_idx_l1_active > 1))) 3089 { 3090 /* collocated_ref_idx */ 3091 /* TODO revisit this*/ 3092 ps_slice_hdr->i1_collocated_ref_idx = 0; 3093 //ps_slice_hdr->i1_num_ref_idx_l1_active - 1; 3094 } 3095 } 3096 } 3097 ps_slice_hdr->i1_max_num_merge_cand = max_merge_candidates; 3098 3099 /* TODO : revisit this */ 3100 ps_slice_hdr->i1_slice_qp_delta = (WORD8)cur_slice_qp - ps_pps->i1_pic_init_qp; 3101 3102 if(!ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag || !stasino_enabled) 3103 { 3104 /* slice_cb_qp_offset */ 3105 ps_slice_hdr->i1_slice_cb_qp_offset = 0; 3106 3107 /* slice_cr_qp_offset */ 3108 ps_slice_hdr->i1_slice_cr_qp_offset = 0; 3109 } 3110 else /* only noisy regions have lower Chroma QP rating */ 3111 { 3112 ps_slice_hdr->i1_slice_cb_qp_offset = -2; 3113 ps_slice_hdr->i1_slice_cr_qp_offset = -2; 3114 } 3115 3116 if(ps_pps->i1_deblocking_filter_control_present_flag) 3117 { 3118 ps_slice_hdr->i1_deblocking_filter_override_flag = 0; 3119 3120 if(ps_pps->i1_deblocking_filter_override_enabled_flag) 3121 { 3122 /* deblocking_filter_override_flag */ 3123 ps_slice_hdr->i1_deblocking_filter_override_flag = 0; 3124 } 3125 3126 if(ps_slice_hdr->i1_deblocking_filter_override_flag) 3127 { 3128 /* slice_disable_deblocking_filter_flag */ 3129 ps_slice_hdr->i1_slice_disable_deblocking_filter_flag = DISABLE_DEBLOCKING_FLAG; 3130 3131 if(!ps_slice_hdr->i1_slice_disable_deblocking_filter_flag) 3132 { 3133 /* beta_offset_div2 */ 3134 ps_slice_hdr->i1_beta_offset_div2 = 0; 3135 3136 /* tc_offset_div2 */ 3137 ps_slice_hdr->i1_tc_offset_div2 = 0; 3138 } 3139 } 3140 } 3141 3142 disable_deblocking_filter_flag = ps_slice_hdr->i1_slice_disable_deblocking_filter_flag | 3143 ps_pps->i1_pic_disable_deblocking_filter_flag; 3144 3145 if(ps_pps->i1_loop_filter_across_slices_enabled_flag && 3146 (ps_slice_hdr->i1_slice_sao_luma_flag || ps_slice_hdr->i1_slice_sao_chroma_flag || 3147 !disable_deblocking_filter_flag)) 3148 { 3149 /* slice_loop_filter_across_slices_enabled_flag */ 3150 ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag = 1; 3151 } 3152 } 3153 3154 if(1 == ps_pps->i1_entropy_coding_sync_enabled_flag) 3155 { 3156 /* num_entry_point_offsets, same as NUM of ctb rows to enable entropy sync at start of every CTB */ 3157 ps_slice_hdr->i4_num_entry_point_offsets = ps_sps->i2_pic_ht_in_ctb - 1; 3158 3159 if(ps_slice_hdr->i4_num_entry_point_offsets > 0) 3160 { 3161 /* generate offset_len here */ 3162 /* fixing the offset lenght assuming 4kx2k is log2(w * h / num_ctb_row) = 20*/ 3163 ps_slice_hdr->i1_offset_len = 24; 3164 } 3165 } 3166 else 3167 { 3168 ps_slice_hdr->i4_num_entry_point_offsets = 0; 3169 ps_slice_hdr->i1_offset_len = 0; 3170 } 3171 3172 /* slice_header_extension_present_flag not supported */ 3173 //if(ps_pps->i1_slice_header_extension_present_flag) 3174 { 3175 /* slice_header_extension_length */ 3176 ps_slice_hdr->i2_slice_header_extension_length = 0; 3177 3178 for(i = 0; i < ps_slice_hdr->i2_slice_header_extension_length; i++) 3179 { 3180 /* slice_header_extension_data_byte[i] */ 3181 } 3182 } 3183 3184 /* TODO : hard coding ref pix set for now */ 3185 /* Need to update this once the ref pics are known from lap output */ 3186 3187 /* NOTE */ 3188 /* inter ref pic prediction is too much of logic for few bit savings*/ 3189 /* at slice header level this is not supported by the encoder */ 3190 ps_slice_hdr->s_stref_picset.i1_inter_ref_pic_set_prediction_flag = 0; 3191 3192 /* hardcoding 1 ref pic for now ..... will be updated base on lap output */ 3193 ps_slice_hdr->s_stref_picset.i1_num_delta_pocs = 1; 3194 ps_slice_hdr->s_stref_picset.i1_num_neg_pics = 1; 3195 ps_slice_hdr->s_stref_picset.i1_num_pos_pics = 0; 3196 3197 memset( 3198 ps_slice_hdr->s_stref_picset.ai2_delta_poc, 3199 0, 3200 MAX_DPB_SIZE * sizeof(*ps_slice_hdr->s_stref_picset.ai2_delta_poc)); 3201 ps_slice_hdr->s_stref_picset.ai2_delta_poc[0] = 1; 3202 3203 return return_status; 3204 } 3205 3206 /** 3207 ****************************************************************************** 3208 * 3209 * @brief Insert entry point offset 3210 * 3211 * @par Description 3212 * Insert entry point offset in slice header after frame processing is done 7.3.5.1 3213 * 3214 * @param[inout] ps_bitstrm 3215 * pointer to bitstream context for generating slice header 3216 * 3217 * @param[in] i1_nal_unit_type 3218 * nal unit type 3219 * 3220 * @param[in] ps_slice_hdr 3221 * pointer to slice header params 3222 * 3223 * @param[in] ps_pps 3224 * pointer to pps params referred by slice 3225 * 3226 * @param[in] ps_sps 3227 * pointer to sps params referred by slice 3228 * 3229 * @return success or failure error code 3230 * 3231 ****************************************************************************** 3232 */ 3233 WORD32 ihevce_insert_entry_offset_slice_header( 3234 bitstrm_t *ps_bitstrm, 3235 slice_header_t *ps_slice_hdr, 3236 pps_t *ps_pps, 3237 UWORD32 u4_first_slice_start_offset) 3238 { 3239 WORD32 i; 3240 WORD32 return_status = IHEVCE_SUCCESS; 3241 UWORD32 max_offset = 0, offset_len = 0, num_bytes_shift = 0; 3242 /*entire slice data has to be shifted*/ 3243 num_bytes_shift = 3244 ps_slice_hdr->pu4_entry_point_offset[ps_slice_hdr->i4_num_entry_point_offsets + 1] - 3245 ps_slice_hdr->pu4_entry_point_offset[0]; 3246 /*generate relative offset*/ 3247 for(i = 0; i < ps_slice_hdr->i4_num_entry_point_offsets; i++) 3248 { 3249 ps_slice_hdr->pu4_entry_point_offset[i] = 3250 ps_slice_hdr->pu4_entry_point_offset[i + 1] - ps_slice_hdr->pu4_entry_point_offset[i]; 3251 if(ps_slice_hdr->pu4_entry_point_offset[i] > (WORD32)max_offset) 3252 { 3253 max_offset = ps_slice_hdr->pu4_entry_point_offset[i]; 3254 } 3255 } 3256 while(1) 3257 { 3258 if(max_offset & 0x80000000) 3259 { 3260 break; 3261 } 3262 max_offset <<= 1; 3263 offset_len++; 3264 } 3265 offset_len = 32 - offset_len; 3266 ps_slice_hdr->i1_offset_len = offset_len; 3267 3268 if(ps_slice_hdr->i4_num_entry_point_offsets > 0) 3269 { 3270 /* offset_len_minus1 */ 3271 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_offset_len - 1, return_status); 3272 ENTROPY_TRACE("offset_len_minus1", ps_slice_hdr->i1_offset_len - 1); 3273 } 3274 3275 for(i = 0; i < ps_slice_hdr->i4_num_entry_point_offsets; i++) 3276 { 3277 /* entry_point_offset[i] */ 3278 /* entry point offset minus1 is indicated in 10.0 */ 3279 PUT_BITS( 3280 ps_bitstrm, 3281 ps_slice_hdr->pu4_entry_point_offset[i] - 1, 3282 ps_slice_hdr->i1_offset_len, 3283 return_status); 3284 ENTROPY_TRACE("entry_point_offset[i]", ps_slice_hdr->pu4_entry_point_offset[i]); 3285 } 3286 3287 if(ps_pps->i1_slice_header_extension_present_flag) 3288 { 3289 /* slice_header_extension_length */ 3290 PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i2_slice_header_extension_length, return_status); 3291 ENTROPY_TRACE( 3292 "slice_header_extension_length", ps_slice_hdr->i2_slice_header_extension_length); 3293 /*calculate slice header extension length to fill in the gap*/ 3294 3295 for(i = 0; i < ps_slice_hdr->i2_slice_header_extension_length; i++) 3296 { 3297 /* slice_header_extension_data_byte[i] */ 3298 PUT_BITS(ps_bitstrm, 0xFF, 8, return_status); 3299 ENTROPY_TRACE("slice_header_extension_data_byte[i]", 0); 3300 } 3301 } 3302 3303 BYTE_ALIGNMENT(ps_bitstrm); 3304 3305 ASSERT(num_bytes_shift > 0); 3306 /* copy the bitstream to point where header data has ended*/ 3307 memmove( 3308 (UWORD8 *)(ps_bitstrm->pu1_strm_buffer + ps_bitstrm->u4_strm_buf_offset), 3309 (UWORD8 *)(ps_bitstrm->pu1_strm_buffer + u4_first_slice_start_offset), 3310 num_bytes_shift); 3311 3312 /*send feedback of actual bytes generated*/ 3313 ps_bitstrm->u4_strm_buf_offset += num_bytes_shift; 3314 3315 //ASSERT(ps_bitstrm->u4_strm_buf_offset == u4_first_slice_start_offset); 3316 return return_status; 3317 } 3318
