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 * \file ihevce_enc_structs.h 23 * 24 * \brief 25 * This file contains structure definations of Encoder 26 * 27 * \date 28 * 18/09/2012 29 * 30 * \author 31 * Ittiam 32 * 33 ****************************************************************************** 34 */ 35 36 #ifndef _IHEVCE_ENC_STRUCTS_H_ 37 #define _IHEVCE_ENC_STRUCTS_H_ 38 39 /*****************************************************************************/ 40 /* Constant Macros */ 41 /*****************************************************************************/ 42 #define HEVCE_MAX_WIDTH 1920 43 #define HEVCE_MAX_HEIGHT 1088 44 45 #define HEVCE_MIN_WIDTH 64 46 #define HEVCE_MIN_HEIGHT 64 47 48 #define MAX_CTBS_IN_FRAME (HEVCE_MAX_WIDTH * HEVCE_MAX_HEIGHT) / (MIN_CTB_SIZE * MIN_CTB_SIZE) 49 #define MAX_NUM_CTB_ROWS_FRM (HEVCE_MAX_HEIGHT) / (MIN_CTB_SIZE) 50 51 #define MIN_VERT_PROC_UNIT (8) 52 #define MAX_NUM_VERT_UNITS_FRM (HEVCE_MAX_HEIGHT) / (MIN_VERT_PROC_UNIT) 53 54 #define HEVCE_MAX_REF_PICS 8 55 #define HEVCE_MAX_DPB_PICS (HEVCE_MAX_REF_PICS + 1) 56 57 #define PAD_HORZ 80 58 #define PAD_VERT 80 59 60 #define DEFAULT_MAX_REFERENCE_PICS 4 61 62 #define BLU_RAY_SUPPORT 231457 63 64 /** @brief max number of parts in minCU : max 4 for NxN */ 65 #define NUM_PU_PARTS 4 66 /** @brief max number of parts in Inter CU */ 67 #define NUM_INTER_PU_PARTS (MAX_NUM_INTER_PARTS) 68 #define SEND_BI_RDOPT 69 #ifdef SEND_BI_RDOPT 70 /** @brief */ 71 #define MAX_INTER_CU_CANDIDATES 4 72 #else 73 /** @brief */ 74 #define MAX_INTER_CU_CANDIDATES 3 75 #endif 76 /** @brief */ 77 #define MAX_INTRA_CU_CANDIDATES 3 78 79 #define MAX_INTRA_CANDIDATES 35 80 81 /** For each resolution & bit-rate instance, one entropy thread is created */ 82 #define NUM_ENTROPY_THREADS (IHEVCE_MAX_NUM_RESOLUTIONS * IHEVCE_MAX_NUM_BITRATES) 83 84 /* Number of buffers between Decomp and HME layers 1 : Seq mode >1 parallel mode */ 85 #define NUM_BUFS_DECOMP_HME 1 86 87 /** Macro to indicate pre me and L0 ipe stagger in pre enc*/ 88 /** Implies MAX_PRE_ENC_STAGGER - 1 max stagger*/ 89 #define MAX_PRE_ENC_STAGGER (NUM_LAP2_LOOK_AHEAD + 1 + MIN_L1_L0_STAGGER_NON_SEQ) 90 91 #define NUM_ME_ENC_BUFS (MAX_NUM_ENC_LOOP_PARALLEL) 92 93 #define MIN_L0_IPE_ENC_STAGGER 1 94 95 /*stagger between L0 IPE and enc*/ 96 #define MAX_L0_IPE_ENC_STAGGER (NUM_ME_ENC_BUFS + (MIN_L0_IPE_ENC_STAGGER)) 97 98 #define MAX_PRE_ENC_RC_DELAY (MAX_L0_IPE_ENC_STAGGER + 1 + NUM_BUFS_DECOMP_HME) 99 100 #define MIN_PRE_ENC_RC_DELAY (MIN_L0_IPE_ENC_STAGGER + 1 + NUM_BUFS_DECOMP_HME) 101 102 /** @brief number of contexts buffers maintained at frame level b/w pre-encode : encode */ 103 /*Explaination for minus 1: eg: MAX_PRE_ENC_STAGGER = 31 and MAX_L0_IPE_ENC_STAGGER = 5, In this case L1 produce 30 buffer, 104 l0 will start off with 30th buffer and enc will work on 33nd and 34rd frame.*/ 105 /* NUM_BUFS_DECOMP_HME is added to take care of pipeline between Decomp-preintra and HME */ 106 #define MAX_NUM_PREENC_ENC_BUFS \ 107 (MAX_PRE_ENC_STAGGER + MAX_L0_IPE_ENC_STAGGER + NUM_BUFS_DECOMP_HME - 1) //22//5 108 109 #define MIN_NUM_PREENC_ENC_BUFS \ 110 (MAX_PRE_ENC_STAGGER + MIN_L0_IPE_ENC_STAGGER + NUM_BUFS_DECOMP_HME - 1) 111 112 /** @brief number of ctb contexts maintained at frame level b/w encode : entropy */ 113 #define NUM_FRMPROC_ENTCOD_BUFS 8 114 115 /** @brief number of extra recon buffs required for stagger design*/ 116 #define NUM_EXTRA_RECON_BUFS 0 117 118 /** recon picture buffer size need to be increased to support EncLoop Parallelism **/ 119 #define NUM_EXTRA_RECON_BUFS_FOR_ELP 0 120 121 /** @brief maximum number of bytes in 4x4 afetr scanning */ 122 #define MAX_SCAN_COEFFS_BYTES_4x4 (48) 123 124 /** @brief maximum number of luma coeffs bytes after scan at CTB level */ 125 #define MAX_LUMA_COEFFS_CTB ((MAX_SCAN_COEFFS_BYTES_4x4) * (MAX_TU_IN_CTB)*4) 126 127 /** @brief maximum number of chroma coeffs bytes after scan at CTB level */ 128 #define MAX_CHRM_COEFFS_CTB ((MAX_SCAN_COEFFS_BYTES_4x4) * ((MAX_TU_IN_CTB >> 1)) * 4) 129 130 /** @brief maximum number of coeffs bytes after scan at CTB level */ 131 #define MAX_SCAN_COEFFS_CTB ((MAX_LUMA_COEFFS_CTB) + (MAX_CHRM_COEFFS_CTB)) 132 133 /** @breif PU map CTB buffer buyes for neighbour availibility */ 134 #define MUN_PU_MAP_BYTES_PER_CTB (MAX_PU_IN_CTB_ROW * MAX_PU_IN_CTB_ROW) 135 136 /** @brief tottal system memory records */ 137 #define TOTAL_SYSTEM_MEM_RECS 120 138 139 /** @brief number of input async command buffers */ 140 #define NUM_AYSNC_CMD_BUFS 4 141 142 /** @brief Comand buffers size */ 143 #define ENC_COMMAND_BUFF_SIZE 512 /* 512 bytes */ 144 145 /** @brief Number of output buffers */ 146 #define NUM_OUTPUT_BUFS 4 147 148 /** @brief Lamda for SATD cost estimation */ 149 #define LAMDA_SATD 1 150 151 /** @brief Maximum number of 1s in u2_sig_coeff_abs_gt1_flags */ 152 #define MAX_GT_ONE 8 153 154 /** MAX num ipntra pred modes */ 155 #define MAX_NUM_IP_MODES 35 156 157 /** Number of best intra modes used for intra mode refinement */ 158 #define NUM_BEST_MODES 3 159 160 /** Maximim number of parallel frame processing threads in pre enocde group */ 161 #define MAX_NUM_FRM_PROC_THRDS_PRE_ENC MAX_NUM_CORES 162 163 /** Maximim number of parallel frame processing threads in encode group */ 164 #define MAX_NUM_FRM_PROC_THRDS_ENC MAX_NUM_CORES 165 166 /** Macro to indicate teh PING_PONG buffers for stagger*/ 167 #define PING_PONG_BUF 2 168 169 /** Max number of layers in Motion estimation 170 * should be greater than or equal to MAX_NUM_LAYERS defined in hme_interface.h 171 */ 172 173 #define MAX_NUM_HME_LAYERS 5 174 /** 175 ****************************************************************************** 176 * @brief Maximum number of layers allowed 177 ****************************************************************************** 178 */ 179 #define MAX_NUM_LAYERS 4 180 181 #define NUM_RC_PIC_TYPE 9 182 183 #define MAX_NUM_NODES_CU_TREE (85) 184 185 /* macros to control Dynamic load balance */ 186 #define DYN_LOAD_BAL_UPPER_LIMIT 0.80 187 188 #define DYN_LOAD_BAL_LOWER_LIMIT 0.20 189 190 #define NUM_SUB_GOP_DYN_BAL 1 191 192 #define MIN_NUM_FRMS_DYN_BAL 4 193 194 #define CORES_SRES_OR_MRES 2 195 196 #define HME_HIGH_SAD_BLK_THRESH 35 197 198 /* Enable to compare cabac states of final entropy thread with enc loop states */ 199 #define VERIFY_ENCLOOP_CABAC_STATES 0 200 201 #define MAX_NUM_BLKS_IN_MAX_CU 64 /* max cu size is 64x64 */ 202 203 /*****************************************************************************/ 204 /* Function Macros */ 205 /*****************************************************************************/ 206 207 /*****************************************************************************/ 208 /* Typedefs */ 209 /*****************************************************************************/ 210 typedef void (*pf_iq_it_rec)( 211 WORD16 *pi2_src, 212 WORD16 *pi2_tmp, 213 UWORD8 *pu1_pred, 214 WORD16 *pi2_dequant_coeff, 215 UWORD8 *pu1_dst, 216 WORD32 qp_div, /* qpscaled / 6 */ 217 WORD32 qp_rem, /* qpscaled % 6 */ 218 WORD32 src_strd, 219 WORD32 pred_strd, 220 WORD32 dst_strd, 221 WORD32 zero_cols, 222 WORD32 zero_rows); 223 224 typedef void (*pf_intra_pred)( 225 UWORD8 *pu1_ref, WORD32 src_strd, UWORD8 *pu1_dst, WORD32 dst_strd, WORD32 nt, WORD32 mode); 226 227 typedef UWORD32 (*pf_res_trans_luma)( 228 UWORD8 *pu1_src, 229 UWORD8 *pu1_pred, 230 WORD32 *pi4_tmp, 231 WORD16 *pi2_dst, 232 WORD32 src_strd, 233 WORD32 pred_strd, 234 WORD32 dst_strd_chr_flag); 235 236 typedef WORD32 (*pf_quant)( 237 WORD16 *pi2_coeffs, 238 WORD16 *pi2_quant_coeff, 239 WORD16 *pi2_dst, 240 WORD32 qp_div, /* qpscaled / 6 */ 241 WORD32 qp_rem, /* qpscaled % 6 */ 242 WORD32 q_add, 243 WORD32 src_strd, 244 WORD32 dst_strd, 245 UWORD8 *pu1_csbf_buf, 246 WORD32 csbf_strd, 247 WORD32 *zero_cols, 248 WORD32 *zero_row); 249 250 /*****************************************************************************/ 251 /* Enums */ 252 /*****************************************************************************/ 253 /// supported partition shape 254 typedef enum 255 { 256 SIZE_2Nx2N = 0, ///< symmetric motion partition, 2Nx2N 257 SIZE_2NxN = 1, ///< symmetric motion partition, 2Nx N 258 SIZE_Nx2N = 2, ///< symmetric motion partition, Nx2N 259 SIZE_NxN = 3, ///< symmetric motion partition, Nx N 260 SIZE_2NxnU = 4, ///< asymmetric motion partition, 2Nx( N/2) + 2Nx(3N/2) 261 SIZE_2NxnD = 5, ///< asymmetric motion partition, 2Nx(3N/2) + 2Nx( N/2) 262 SIZE_nLx2N = 6, ///< asymmetric motion partition, ( N/2)x2N + (3N/2)x2N 263 SIZE_nRx2N = 7 ///< asymmetric motion partition, (3N/2)x2N + ( N/2)x2N 264 } PART_SIZE_E; 265 266 /** @brief Interface level Queues of Encoder */ 267 268 typedef enum 269 { 270 IHEVCE_INPUT_DATA_CTRL_Q = 0, 271 IHEVCE_ENC_INPUT_Q, 272 IHEVCE_INPUT_ASYNCH_CTRL_Q, 273 IHEVCE_OUTPUT_DATA_Q, 274 IHEVCE_OUTPUT_STATUS_Q, 275 IHEVCE_RECON_DATA_Q, // /*que for holding recon buffer */ 276 277 IHEVCE_FRM_PRS_ENT_COD_Q, /*que for holding output buffer of enc_loop |input buffer of entropy */ 278 279 IHEVCE_PRE_ENC_ME_Q, /*que for holding input buffer to ME | output of pre-enc */ 280 281 IHEVCE_ME_ENC_RDOPT_Q, /* que for holding output buffer of ME or input buffer of Enc-RDopt */ 282 283 IHEVCE_L0_IPE_ENC_Q, /* Queue for holding L0 ipe data to enc loop*/ 284 285 /* should be last entry */ 286 IHEVCE_MAX_NUM_QUEUES 287 288 } IHEVCE_Q_DESC_T; 289 290 /*****************************************************************************/ 291 /* Structure */ 292 /*****************************************************************************/ 293 294 /** 295 RC_QP_QSCALE conversion structures 296 **/ 297 typedef struct 298 { 299 WORD16 i2_min_qp; 300 301 WORD16 i2_max_qp; 302 303 WORD16 i2_min_qscale; 304 305 WORD16 i2_max_qscale; 306 307 WORD32 *pi4_qscale_to_qp; 308 309 WORD32 *pi4_qp_to_qscale_q_factor; 310 311 WORD32 *pi4_qp_to_qscale; 312 313 WORD8 i1_qp_offset; 314 315 } rc_quant_t; 316 317 /** 318 ****************************************************************************** 319 * @brief 4x4 level structure which contains all the parameters 320 * for neighbour prediction puopose 321 ****************************************************************************** 322 */ 323 typedef struct 324 { 325 /** PU motion vectors */ 326 pu_mv_t mv; 327 /** Intra or Inter flag for each partition - 0 or 1 */ 328 UWORD16 b1_intra_flag : 1; 329 /** CU skip flag - 0 or 1 */ 330 UWORD16 b1_skip_flag : 1; 331 /** CU depth in CTB tree (0-3) */ 332 UWORD16 b2_cu_depth : 2; 333 334 /** Y Qp for loop filter */ 335 WORD16 b8_qp : 8; 336 337 /** Luma Intra Mode 0 - 34 */ 338 UWORD16 b6_luma_intra_mode : 6; 339 340 /** Y CBF for BS compute */ 341 UWORD16 b1_y_cbf : 1; 342 /** Pred L0 flag of current 4x4 */ 343 UWORD16 b1_pred_l0_flag : 1; 344 345 /** Pred L0 flag of current 4x4 */ 346 UWORD16 b1_pred_l1_flag : 1; 347 } nbr_4x4_t; 348 349 typedef struct 350 { 351 /** Bottom Left availability flag */ 352 UWORD8 u1_bot_lt_avail; 353 354 /** Left availability flag */ 355 UWORD8 u1_left_avail; 356 357 /** Top availability flag */ 358 UWORD8 u1_top_avail; 359 360 /** Top Right availability flag */ 361 UWORD8 u1_top_rt_avail; 362 363 /** Top Left availability flag */ 364 UWORD8 u1_top_lt_avail; 365 366 } nbr_avail_flags_t; 367 368 typedef struct 369 { 370 /** prev intra flag*/ 371 UWORD8 b1_prev_intra_luma_pred_flag : 1; 372 373 /** mpm_idx */ 374 UWORD8 b2_mpm_idx : 2; 375 376 /** reminder pred mode */ 377 UWORD8 b5_rem_intra_pred_mode : 5; 378 379 } intra_prev_rem_flags_t; 380 381 /** 382 ****************************************************************************** 383 * @brief calc (T+Q+RDOQ) output TU structure; entropy input TU structure 384 ****************************************************************************** 385 */ 386 typedef struct 387 { 388 /** base tu structure */ 389 tu_t s_tu; 390 391 /** offset of luma data in ecd buffer */ 392 WORD32 i4_luma_coeff_offset; 393 394 /** offset of cb data in ecd buffer */ 395 WORD32 ai4_cb_coeff_offset[2]; 396 397 /** offset of cr data in ecd buffer */ 398 WORD32 ai4_cr_coeff_offset[2]; 399 400 } tu_enc_loop_out_t; 401 402 typedef struct 403 { 404 /* L0 Motion Vector */ 405 mv_t s_l0_mv; 406 407 /* L1 Motion Vector */ 408 mv_t s_l1_mv; 409 410 /* L0 Ref index */ 411 WORD8 i1_l0_ref_idx; 412 413 /* L1 Ref index */ 414 WORD8 i1_l1_ref_idx; 415 416 /* L0 Ref Pic Buf ID */ 417 WORD8 i1_l0_pic_buf_id; 418 419 /* L1 Ref Pic Buf ID */ 420 WORD8 i1_l1_pic_buf_id; 421 422 /** intra flag */ 423 UWORD8 b1_intra_flag : 1; 424 425 /* Pred mode */ 426 UWORD8 b2_pred_mode : 2; 427 428 /* reserved flag can be used for something later */ 429 UWORD8 u1_reserved; 430 431 } pu_col_mv_t; 432 433 /*****************************************************************************/ 434 /* Encoder uses same structure as pu_t for prediction unit */ 435 /*****************************************************************************/ 436 437 /** 438 ****************************************************************************** 439 * @brief Encode loop (T+Q+RDOQ) output CU structure; entropy input CU structure 440 ****************************************************************************** 441 */ 442 typedef struct 443 { 444 /* CU X position in terms of min CU (8x8) units */ 445 UWORD32 b3_cu_pos_x : 3; 446 447 /* CU Y position in terms of min CU (8x8) units */ 448 UWORD32 b3_cu_pos_y : 3; 449 450 /** CU size in terms of min CU (8x8) units */ 451 UWORD32 b4_cu_size : 4; 452 453 /** transquant bypass flag ; 0 for this encoder */ 454 UWORD32 b1_tq_bypass_flag : 1; 455 456 /** cu skip flag */ 457 UWORD32 b1_skip_flag : 1; 458 459 /** intra / inter CU flag */ 460 UWORD32 b1_pred_mode_flag : 1; 461 462 /** indicates partition information for CU 463 * For intra 0 : for 2Nx2N / 1 for NxN iff CU=minCBsize 464 * For inter 0 : @sa PART_SIZE_E 465 */ 466 UWORD32 b3_part_mode : 3; 467 468 /** 0 for this encoder */ 469 UWORD32 b1_pcm_flag : 1; 470 471 /** only applicable for intra cu */ 472 UWORD32 b3_chroma_intra_pred_mode : 3; 473 474 /** no residue flag for cu */ 475 UWORD32 b1_no_residual_syntax_flag : 1; 476 477 /* flag to indicate if current CU is the first 478 CU of the Quantisation group*/ 479 UWORD32 b1_first_cu_in_qg : 1; 480 481 /** Intra prev and reminder flags 482 * if part is NxN the tntries 1,2,3 will be valid 483 * other wise only enry 0 will be set. 484 */ 485 intra_prev_rem_flags_t as_prev_rem[NUM_PU_PARTS]; 486 487 /** 488 * Access valid number of pus in this array based on u1_part_mode 489 * Moiton vector differentials and reference idx should be 490 * populated in this structure 491 * @remarks shall be accessed only for inter pus 492 */ 493 pu_t *ps_pu; 494 495 /** 496 * pointer to first tu of this cu. Each TU need to be populated 497 * in TU order by calc. Total TUs in CU is given by u2_num_tus_in_cu 498 */ 499 tu_enc_loop_out_t *ps_enc_tu; 500 501 /** total TUs in this CU; shall be 0 if b1_no_residual_syntax_flag = 1 */ 502 UWORD16 u2_num_tus_in_cu; 503 504 /** Coeff bufer pointer */ 505 /* Pointer to transform coeff data */ 506 /*************************************************************************/ 507 /* Following format is repeated for every coded TU */ 508 /* Luma Block */ 509 /* num_coeffs : 16 bits */ 510 /* zero_cols : 8 bits ( 1 bit per 4 columns) */ 511 /* sig_coeff_map : ((TU Size * TU Size) + 31) >> 5 number of WORD32s */ 512 /* coeff_data : Non zero coefficients */ 513 /* Cb Block (only for last TU in 4x4 case else for every luma TU) */ 514 /* num_coeffs : 16 bits */ 515 /* zero_cols : 8 bits ( 1 bit per 4 columns) */ 516 /* sig_coeff_map : ((TU Size * TU Size) + 31) >> 5 number of WORD32s */ 517 /* coeff_data : Non zero coefficients */ 518 /* Cr Block (only for last TU in 4x4 case else for every luma TU) */ 519 /* num_coeffs : 16 bits */ 520 /* zero_cols : 8 bits ( 1 bit per 4 columns) */ 521 /* sig_coeff_map : ((TU Size * TU Size) + 31) >> 5 number of WORD32s */ 522 /* coeff_data : Non zero coefficients */ 523 /*************************************************************************/ 524 void *pv_coeff; 525 526 /** qp used during for CU 527 * @remarks : 528 */ 529 WORD8 i1_cu_qp; 530 531 } cu_enc_loop_out_t; 532 533 /** 534 * SAO 535 */ 536 typedef struct 537 { 538 /** 539 * sao_type_idx_luma 540 */ 541 UWORD32 b3_y_type_idx : 3; 542 543 /** 544 * luma sao_band_position 545 */ 546 UWORD32 b5_y_band_pos : 5; 547 548 /** 549 * sao_type_idx_chroma 550 */ 551 UWORD32 b3_cb_type_idx : 3; 552 553 /** 554 * cb sao_band_position 555 */ 556 UWORD32 b5_cb_band_pos : 5; 557 558 /** 559 * sao_type_idx_chroma 560 */ 561 UWORD32 b3_cr_type_idx : 3; 562 563 /** 564 * cb sao_band_position 565 */ 566 UWORD32 b5_cr_band_pos : 5; 567 568 /*SAO Offsets 569 * In all these offsets, 0th element is not used 570 */ 571 /** 572 * luma SaoOffsetVal[i] 573 */ 574 WORD8 u1_y_offset[5]; 575 576 /** 577 * chroma cb SaoOffsetVal[i] 578 */ 579 WORD8 u1_cb_offset[5]; 580 581 /** 582 * chroma cr SaoOffsetVal[i] 583 */ 584 WORD8 u1_cr_offset[5]; 585 586 /** 587 * sao_merge_left_flag common for y,cb,cr 588 */ 589 UWORD32 b1_sao_merge_left_flag : 1; 590 591 /** 592 * sao_merge_up_flag common for y,cb,cr 593 */ 594 UWORD32 b1_sao_merge_up_flag : 1; 595 596 } sao_enc_t; 597 598 /** 599 ****************************************************************************** 600 * @brief ctb output structure; output of Encode loop, input to entropy 601 ****************************************************************************** 602 */ 603 typedef struct 604 { 605 /** 606 * bit0 : depth0 split flag, (64x64 splits) 607 * bits 1-3 : not used 608 * bits 4-7 : depth1 split flags; valid iff depth0 split=1 (32x32 splits) 609 * bits 8-23: depth2 split flags; (if 0 16x16 is cu else 8x8 min cu) 610 611 * if a split flag of n is set for depth 1, check the following split flags 612 * of [(8 + 4*(n-4)): (8 + 4*(n-4)+ 3)] for depth 2: 613 * 614 */ 615 UWORD32 u4_cu_split_flags; 616 617 /*************************************************************** 618 * For any given CU position CU_posx, CU_posy access 619 * au4_packed_tu_split_flags[(CU_posx >> 5)[(CU_posy >> 5)] 620 * Note : For CTB size smaller than 64x64 only use u4_packed_tu_split_flags[0] 621 ****************************************************************/ 622 623 /** 624 * access bits corresponding to actual CU size till leaf nodes 625 * bit0 : (32x32 TU split flag) 626 * bits 1-3 : not used 627 * bits 4-7 : (16x16 TUsplit flags) 628 * bits 8-23: (8x8 TU split flags) 629 630 * if a split flag of n is set for depth 1, check the following split flags 631 * of [(8 + 4*(n-4)): (8 + 4*(n-4)+ 3)] for depth 2: 632 * 633 * @remarks As tu sizes are relative to CU sizes the producer has to 634 * make sure the correctness of u4_packed_tu_split_flags. 635 * 636 * @remarks au4_packed_tu_split_flags_cu[1]/[2]/[3] to be used only 637 * for 64x64 ctb. 638 */ 639 UWORD32 au4_packed_tu_split_flags_cu[4]; 640 641 /** 642 * pointer to first CU of CTB. Each CU need to be populated 643 * in CU order by calc. Total CUs in CTB is given by u1_num_cus_in_ctb 644 */ 645 cu_enc_loop_out_t *ps_enc_cu; 646 647 /** total TUs in this CU; shall be 0 if b1_no_residual_syntax_flag = 1 */ 648 UWORD8 u1_num_cus_in_ctb; 649 650 /** CTB neighbour availability flags */ 651 nbr_avail_flags_t s_ctb_nbr_avail_flags; 652 653 /* SAO parameters of the CTB */ 654 sao_enc_t s_sao; 655 656 } ctb_enc_loop_out_t; 657 658 /** 659 ****************************************************************************** 660 * @brief cu inter candidate for encoder 661 ****************************************************************************** 662 */ 663 typedef struct 664 { 665 /** base pu structure 666 * access valid number of entries in this array based on u1_part_size 667 */ 668 pu_t as_inter_pu[NUM_INTER_PU_PARTS]; 669 670 /* TU split flag : tu_split_flag[0] represents the transform splits 671 * for CU size <= 32, for 64x64 each ai4_tu_split_flag corresponds 672 * to respective 32x32 */ 673 /* For a 8x8 TU - 1 bit used to indicate split */ 674 /* For a 16x16 TU - LSB used to indicate winner between 16 and 8 TU's. 4 other bits used to indicate split in each 8x8 quadrant */ 675 /* For a 32x32 TU - See above */ 676 WORD32 ai4_tu_split_flag[4]; 677 678 /* TU split flag : tu_split_flag[0] represents the transform splits 679 * for CU size <= 32, for 64x64 each ai4_tu_split_flag corresponds 680 * to respective 32x32 */ 681 /* For a 8x8 TU - 1 bit used to indicate split */ 682 /* For a 16x16 TU - LSB used to indicate winner between 16 and 8 TU's. 4 other bits used to indicate split in each 8x8 quadrant */ 683 /* For a 32x32 TU - See above */ 684 WORD32 ai4_tu_early_cbf[4]; 685 686 /**Pointer to the buffer having predicted data after mc in SATD stage 687 * Since we have 2 buffers for each candidate pred data for best merge candidate 688 * can be in one of the 2 buffers. 689 */ 690 UWORD8 *pu1_pred_data; 691 692 UWORD16 *pu2_pred_data; 693 694 UWORD8 *pu1_pred_data_scr; 695 696 UWORD16 *pu2_pred_data_src; 697 698 /* Total cost: SATD cost + MV cost */ 699 WORD32 i4_total_cost; 700 701 /** Stride for predicted data*/ 702 WORD32 i4_pred_data_stride; 703 704 /** @remarks u1_part_size can be non square only for Inter */ 705 UWORD8 b3_part_size : 3; /* @sa: PART_SIZE_E */ 706 707 /** evaluate transform for cusize iff this flag is 1 */ 708 /** this flag should be set 0 if CU is 64x64 */ 709 UWORD8 b1_eval_tx_cusize : 1; 710 711 /** evaluate transform for cusize/2 iff this flag is 1 */ 712 UWORD8 b1_eval_tx_cusize_by2 : 1; 713 714 /** Skip Flag : ME should always set this 0 for the candidates */ 715 UWORD8 b1_skip_flag : 1; 716 717 UWORD8 b1_intra_has_won : 1; 718 719 /* used to mark if this mode needs to be evaluated in auxiliary mode */ 720 /* if 1, this mode will be evaluated otherwise not.*/ 721 UWORD8 b1_eval_mark : 1; 722 723 } cu_inter_cand_t; 724 725 /** 726 ****************************************************************************** 727 * @brief cu intra candidate for encoder 728 ****************************************************************************** 729 */ 730 typedef struct 731 { 732 UWORD8 au1_intra_luma_mode_nxn_hash[NUM_PU_PARTS][MAX_INTRA_CANDIDATES]; 733 734 /** 735 * List of NxN PU candidates in CU for each partition 736 * valid only of if current cusize = mincusize 737 * +1 to signal the last flag invalid value of 255 needs to be stored 738 */ 739 UWORD8 au1_intra_luma_modes_nxn[NUM_PU_PARTS][(MAX_INTRA_CU_CANDIDATES * (4)) + 2 + 1]; 740 741 /* used to mark if this mode needs to be evaluated in auxiliary mode */ 742 /* if 1, this mode will be evaluated otherwise not.*/ 743 UWORD8 au1_nxn_eval_mark[NUM_PU_PARTS][MAX_INTRA_CU_CANDIDATES + 1]; 744 745 /** 746 * List of 2Nx2N PU candidates in CU 747 * +1 to signal the last flag invalid value of 255 needs to be stored 748 */ 749 UWORD8 au1_intra_luma_modes_2nx2n_tu_eq_cu[MAX_INTRA_CU_CANDIDATES + 1]; 750 751 /** 752 * List of 2Nx2N PU candidates in CU 753 * +1 to signal the last flag invalid value of 255 needs to be stored 754 */ 755 UWORD8 au1_intra_luma_modes_2nx2n_tu_eq_cu_by_2[MAX_INTRA_CU_CANDIDATES + 1]; 756 757 /* used to mark if this mode needs to be evaluated in auxiliary mode */ 758 /* if 1, this mode will be evaluated otherwise not.*/ 759 UWORD8 au1_2nx2n_tu_eq_cu_eval_mark[MAX_INTRA_CU_CANDIDATES + 1]; 760 761 /* used to mark if this mode needs to be evaluated in auxiliary mode */ 762 /* if 1, this mode will be evaluated otherwise not.*/ 763 UWORD8 au1_2nx2n_tu_eq_cu_by_2_eval_mark[MAX_INTRA_CU_CANDIDATES + 1]; 764 765 UWORD8 au1_num_modes_added[NUM_PU_PARTS]; 766 767 /** evaluate transform for cusize iff this flag is 1 */ 768 /** this flag should be set 0 if CU is 64x64 */ 769 UWORD8 b1_eval_tx_cusize : 1; 770 771 /** evaluate transform for cusize/2 iff this flag is 1 */ 772 UWORD8 b1_eval_tx_cusize_by2 : 1; 773 774 /** number of intra candidates for SATD evaluation in */ 775 UWORD8 b6_num_intra_cands : 6; 776 777 } cu_intra_cand_t; 778 779 /** 780 ****************************************************************************** 781 * @brief cu structure for mode analysis/evaluation 782 ****************************************************************************** 783 */ 784 typedef struct 785 { 786 /** CU X position in terms of min CU (8x8) units */ 787 UWORD8 b3_cu_pos_x : 3; 788 789 /** CU Y position in terms of min CU (8x8) units */ 790 UWORD8 b3_cu_pos_y : 3; 791 792 /** reserved bytes */ 793 UWORD8 b2_reserved : 2; 794 795 /** CU size 2N (width or height) in pixels */ 796 UWORD8 u1_cu_size; 797 798 /** Intra CU candidates after FAST CU decision (output of IPE) 799 * 8421 algo along with transform size evalution will 800 * be done for these modes in Encode loop pass. 801 */ 802 cu_intra_cand_t s_cu_intra_cand; 803 804 /** indicates the angular mode (0 - 34) for chroma, 805 * Note : No provision currently to take chroma through RDOPT or SATD 806 */ 807 UWORD8 u1_chroma_intra_pred_mode; 808 809 /** number of inter candidates in as_cu_inter_cand[] 810 * shall be 0 for intra frames. 811 * These inters are evaluated for RDOPT apart from merge/skip candidates 812 */ 813 UWORD8 u1_num_inter_cands; 814 815 /** List of candidates to be evalauted (SATD/RDOPT) for this CU 816 * @remarks : all merge/skip candidates not a part of this list 817 */ 818 cu_inter_cand_t as_cu_inter_cand[MAX_INTER_CU_CANDIDATES]; 819 820 WORD32 ai4_mv_cost[MAX_INTER_CU_CANDIDATES][NUM_INTER_PU_PARTS]; 821 822 #if REUSE_ME_COMPUTED_ERROR_FOR_INTER_CAND_SIFTING 823 WORD32 ai4_err_metric[MAX_INTER_CU_CANDIDATES][NUM_INTER_PU_PARTS]; 824 #endif 825 826 /* Flag to convey if Inta or Inter is the best candidate among the 827 candidates populated 828 0: If inter is the winner and 1: if Intra is winner*/ 829 UWORD8 u1_best_is_intra; 830 831 /** number of intra rdopt candidates 832 * @remarks : shall be <= u1_num_intra_cands 833 */ 834 UWORD8 u1_num_intra_rdopt_cands; 835 /** qp used during for CU 836 * @remarks : 837 */ 838 WORD8 i1_cu_qp; 839 /** Activity factor used in pre enc thread for deriving the Qp 840 * @remarks : This is in Q format 841 */ 842 WORD32 i4_act_factor[4][2]; 843 844 } cu_analyse_t; 845 846 /** 847 ****************************************************************************** 848 * @brief Structure for CU recursion 849 ****************************************************************************** 850 */ 851 typedef struct cur_ctb_cu_tree_t 852 { 853 /** CU X position in terms of min CU (8x8) units */ 854 UWORD8 b3_cu_pos_x : 3; 855 856 /** CU X position in terms of min CU (8x8) units */ 857 UWORD8 b3_cu_pos_y : 3; 858 859 /** reserved bytes */ 860 UWORD8 b2_reserved : 2; 861 862 UWORD8 u1_cu_size; 863 864 UWORD8 u1_intra_eval_enable; 865 866 UWORD8 u1_inter_eval_enable; 867 868 /* Flag that indicates whether to evaluate this node */ 869 /* during RDOPT evaluation. This does not mean that */ 870 /* evaluation of the children need to be abandoned */ 871 UWORD8 is_node_valid; 872 873 LWORD64 i8_best_rdopt_cost; 874 875 struct cur_ctb_cu_tree_t *ps_child_node_tl; 876 877 struct cur_ctb_cu_tree_t *ps_child_node_tr; 878 879 struct cur_ctb_cu_tree_t *ps_child_node_bl; 880 881 struct cur_ctb_cu_tree_t *ps_child_node_br; 882 883 } cur_ctb_cu_tree_t; 884 885 typedef struct 886 { 887 WORD32 num_best_results; 888 889 part_type_results_t as_best_results[NUM_BEST_ME_OUTPUTS]; 890 891 } block_data_32x32_t; 892 893 /** 894 ****************************************************************************** 895 * @brief Structure for storing data about all the 64x64 896 * block in a 64x64 CTB 897 ****************************************************************************** 898 */ 899 typedef block_data_32x32_t block_data_64x64_t; 900 901 /** 902 ****************************************************************************** 903 * @brief Structure for storing data about all 16 16x16 904 * blocks in a 64x64 CTB and each of their partitions 905 ****************************************************************************** 906 */ 907 typedef struct 908 { 909 WORD32 num_best_results; 910 911 /** 912 * mask of active partitions, Totally 17 bits. For a given partition 913 * id, as per PART_ID_T enum the corresponding bit position is 1/0 914 * indicating that partition is active or inactive 915 */ 916 /*WORD32 i4_part_mask;*/ 917 918 part_type_results_t as_best_results[NUM_BEST_ME_OUTPUTS]; 919 920 } block_data_16x16_t; 921 922 typedef struct 923 { 924 WORD32 num_best_results; 925 926 part_type_results_t as_best_results[NUM_BEST_ME_OUTPUTS]; 927 } block_data_8x8_t; 928 929 /** 930 ****************************************************************************** 931 * @brief Structure for data export from ME to Enc_Loop 932 ****************************************************************************** 933 */ 934 typedef struct 935 { 936 block_data_8x8_t as_8x8_block_data[64]; 937 938 block_data_16x16_t as_block_data[16]; 939 940 block_data_32x32_t as_32x32_block_data[4]; 941 942 block_data_64x64_t s_64x64_block_data; 943 944 } me_ctb_data_t; 945 946 /** 947 ****************************************************************************** 948 * @brief noise detection related structure 949 * 950 ****************************************************************************** 951 */ 952 953 typedef struct 954 { 955 WORD32 i4_noise_present; 956 957 UWORD8 au1_is_8x8Blk_noisy[MAX_CU_IN_CTB]; 958 959 UWORD32 au4_variance_src_16x16[MAX_CU_IN_CTB]; 960 } ihevce_ctb_noise_params; 961 962 /** 963 ****************************************************************************** 964 * @brief ctb structure for mode analysis/evaluation 965 ****************************************************************************** 966 */ 967 typedef struct 968 { 969 /** 970 * CU decision in a ctb is frozen by ME/IPE and populated in 971 * u4_packed_cu_split_flags. 972 * @remarks 973 * TODO:review comment 974 * bit0 : 64x64 split flag, (depth0 flag for 64x64 ctb unused for smaller ctb) 975 * bits 1-3 : not used 976 * bits 4-7 : 32x32 split flags; (depth1 flags for 64x64ctb / only bit4 used for 32x32ctb) 977 * bits 8-23: 16x16 split flags; (depth2 flags for 64x64 / depth1[bits8-11] for 32x32 [bit8 for ctb 16x16] ) 978 979 * if a split flag of n is set for depth 1, check the following split flags 980 * of [(8 + 4*(n-4)): (8 + 4*(n-4)+ 3)] for depth 2: 981 * 982 */ 983 UWORD32 u4_cu_split_flags; 984 985 UWORD8 u1_num_cus_in_ctb; 986 987 cur_ctb_cu_tree_t *ps_cu_tree; 988 989 me_ctb_data_t *ps_me_ctb_data; 990 991 ihevce_ctb_noise_params s_ctb_noise_params; 992 993 } ctb_analyse_t; 994 /** 995 ****************************************************************************** 996 * @brief Structures for tapping ssd and bit-estimate information for all CUs 997 ****************************************************************************** 998 */ 999 1000 typedef struct 1001 { 1002 LWORD64 i8_cost; 1003 WORD32 i4_idx; 1004 } cost_idx_t; 1005 1006 /** 1007 ****************************************************************************** 1008 * @brief reference/non reference pic context for encoder 1009 ****************************************************************************** 1010 */ 1011 typedef struct 1012 1013 { 1014 /** 1015 * YUV buffer discriptor for the recon 1016 * Allocation per frame for Y = ((ALIGN(frame width, MAX_CTB_SIZE)) + 2 * PAD_HORZ)* 1017 * ((ALIGN(frame height, MAX_CTB_SIZE)) + 2 * PAD_VERT) 1018 */ 1019 iv_enc_yuv_buf_t s_yuv_buf_desc; 1020 1021 iv_enc_yuv_buf_src_t s_yuv_buf_desc_src; 1022 1023 /* Pointer to Luma (Y) sub plane buffers Horz/ Vert / HV grid */ 1024 /* When (L0ME_IN_OPENLOOP_MODE == 1), additional buffer required to store */ 1025 /* the fullpel plane for use as reference */ 1026 UWORD8 *apu1_y_sub_pel_planes[3 + L0ME_IN_OPENLOOP_MODE]; 1027 1028 /** 1029 * frm level pointer to pu bank for colocated mv access 1030 * Allocation per frame = (ALIGN(frame width, MAX_CTB_SIZE) / MIN_PU_SIZE) * 1031 * (ALIGN(frame height, MAX_CTB_SIZE) / MIN_PU_SIZE) 1032 */ 1033 pu_col_mv_t *ps_frm_col_mv; 1034 /** 1035 ************************************************************************ 1036 * Pointer to a PU map stored at frame level, 1037 * It contains a 7 bit pu index in encoder order w.r.t to a ctb at a min 1038 * granularirty of MIN_PU_SIZE size. 1039 ************************************************************************ 1040 */ 1041 UWORD8 *pu1_frm_pu_map; 1042 1043 /** CTB level frame buffer to store the accumulated sum of 1044 * number of PUs for every row */ 1045 UWORD16 *pu2_num_pu_map; 1046 1047 /** Offsets in the PU buffer at every CTB level */ 1048 UWORD32 *pu4_pu_off; 1049 1050 /** Collocated POC for reference list 0 1051 * ToDo: Change the array size when multiple slices are to be supported */ 1052 WORD32 ai4_col_l0_poc[HEVCE_MAX_REF_PICS]; 1053 1054 /** Collocated POC for reference list 1 */ 1055 WORD32 ai4_col_l1_poc[HEVCE_MAX_REF_PICS]; 1056 1057 /** 0 = top field, 1 = bottom field */ 1058 WORD32 i4_bottom_field; 1059 1060 /** top field first input in case of interlaced case */ 1061 WORD32 i4_topfield_first; 1062 1063 /** top field first input in case of interlaced case */ 1064 WORD32 i4_poc; 1065 1066 /** unique buffer id */ 1067 WORD32 i4_buf_id; 1068 1069 /** is this reference frame or not */ 1070 WORD32 i4_is_reference; 1071 1072 /** Picture type of current picture */ 1073 WORD32 i4_pic_type; 1074 1075 /** Flag to indicate whether current pictute is free or in use */ 1076 WORD32 i4_is_free; 1077 1078 /** Bit0 - of this Flag to indicate whether current pictute needs to be deblocked, 1079 padded and hpel planes need to be generated. 1080 These are turned off typically in non referecne pictures when psnr 1081 and recon dump is disabled. 1082 1083 Bit1 - of this flag set to 1 if sao is enabled. This is to enable deblocking when sao is enabled 1084 */ 1085 WORD32 i4_deblk_pad_hpel_cur_pic; 1086 1087 /** 1088 * weight and offset for this ref pic. To be initialized for every pic 1089 * based on the lap output 1090 */ 1091 ihevce_wght_offst_t s_weight_offset; 1092 1093 /** 1094 * Reciprocal of the lumaweight in q15 format 1095 */ 1096 WORD32 i4_inv_luma_wt; 1097 1098 /** 1099 * Log to base 2 of the common denominator used for luma weights across all ref pics 1100 */ 1101 WORD32 i4_log2_wt_denom; 1102 1103 /** 1104 * Used as Reference for encoding current picture flag 1105 */ 1106 WORD32 i4_used_by_cur_pic_flag; 1107 1108 #if ADAPT_COLOCATED_FROM_L0_FLAG 1109 WORD32 i4_frame_qp; 1110 #endif 1111 /* 1112 * IDR GOP number 1113 */ 1114 1115 WORD32 i4_idr_gop_num; 1116 1117 /* 1118 * non-ref-free_flag 1119 */ 1120 WORD32 i4_non_ref_free_flag; 1121 /** 1122 * Dependency manager instance for ME - Prev recon dep 1123 */ 1124 void *pv_dep_mngr_recon; 1125 1126 /*display num*/ 1127 WORD32 i4_display_num; 1128 } recon_pic_buf_t; 1129 1130 /** 1131 ****************************************************************************** 1132 * @brief Lambda values used for various cost computations 1133 ****************************************************************************** 1134 */ 1135 typedef struct 1136 { 1137 /************************************************************************/ 1138 /* The fields with the string 'type2' in their names are required */ 1139 /* when both 8bit and hbd lambdas are needed. The lambdas corresponding */ 1140 /* to the bit_depth != internal_bit_depth are stored in these fields */ 1141 /************************************************************************/ 1142 1143 /** 1144 * Closed loop SSD Lambda 1145 * This is multiplied with bits for RD cost computations in SSD mode 1146 * This is represented in q format with shift of LAMBDA_Q_SHIFT 1147 */ 1148 LWORD64 i8_cl_ssd_lambda_qf; 1149 1150 LWORD64 i8_cl_ssd_type2_lambda_qf; 1151 1152 /** 1153 * Closed loop SSD Lambda for chroma residue (chroma qp is different from luma qp) 1154 * This is multiplied with bits for RD cost computations in SSD mode 1155 * This is represented in q format with shift of LAMBDA_Q_SHIFT 1156 */ 1157 LWORD64 i8_cl_ssd_lambda_chroma_qf; 1158 1159 LWORD64 i8_cl_ssd_type2_lambda_chroma_qf; 1160 1161 /** 1162 * Closed loop SAD Lambda 1163 * This is multiplied with bits for RD cost computations in SAD mode 1164 * This is represented in q format with shift of LAMBDA_Q_SHIFT 1165 */ 1166 WORD32 i4_cl_sad_lambda_qf; 1167 1168 WORD32 i4_cl_sad_type2_lambda_qf; 1169 1170 /** 1171 * Open loop SAD Lambda 1172 * This is multiplied with bits for RD cost computations in SAD mode 1173 * This is represented in q format with shift of LAMBDA_Q_SHIFT 1174 */ 1175 WORD32 i4_ol_sad_lambda_qf; 1176 1177 WORD32 i4_ol_sad_type2_lambda_qf; 1178 1179 /** 1180 * Closed loop SATD Lambda 1181 * This is multiplied with bits for RD cost computations in SATD mode 1182 * This is represented in q format with shift of LAMBDA_Q_SHIFT 1183 */ 1184 WORD32 i4_cl_satd_lambda_qf; 1185 1186 WORD32 i4_cl_satd_type2_lambda_qf; 1187 1188 /** 1189 * Open loop SATD Lambda 1190 * This is multiplied with bits for RD cost computations in SATD mode 1191 * This is represented in q format with shift of LAMBDA_Q_SHIFT 1192 */ 1193 WORD32 i4_ol_satd_lambda_qf; 1194 1195 WORD32 i4_ol_satd_type2_lambda_qf; 1196 1197 double lambda_modifier; 1198 1199 double lambda_uv_modifier; 1200 1201 UWORD32 u4_chroma_cost_weighing_factor; 1202 1203 } frm_lambda_ctxt_t; 1204 /** 1205 ****************************************************************************** 1206 * @brief Mode attributes for 4x4 block populated by early decision 1207 ****************************************************************************** 1208 */ 1209 typedef struct 1210 { 1211 /* If best mode is present or not */ 1212 UWORD8 mode_present; 1213 1214 /** Best mode for the current 4x4 prediction block */ 1215 UWORD8 best_mode; 1216 1217 /** sad for the best mode for the current 4x4 prediction block */ 1218 UWORD16 sad; 1219 1220 /** cost for the best mode for the current 4x4 prediction block */ 1221 UWORD16 sad_cost; 1222 1223 } ihevce_ed_mode_attr_t; //early decision 1224 /** 1225 ****************************************************************************** 1226 * @brief Structure at 8x8 block level which has parameters such as cur satd 1227 * for QP mod @ L0 level 1228 ****************************************************************************** 1229 */ 1230 typedef struct 1231 { 1232 /*Store SATD of current data at 8*8 level for current layer (L0)*/ 1233 WORD32 i4_8x8_cur_satd; 1234 } ihevce_8x8_L0_satd_t; 1235 /** 1236 ****************************************************************************** 1237 * @brief Structure at 8x8 block level mean for MEAN based QP mod 1238 ****************************************************************************** 1239 */ 1240 typedef struct 1241 { 1242 /*Store SATD of current data at 8*8 level for current layer (L0)*/ 1243 WORD16 i2_8x8_cur_mean; 1244 } ihevce_8x8_L0_mean_t; 1245 1246 //#define DEBUG_ED_CTB_POS 1247 /** 1248 ****************************************************************************** 1249 * @brief Structure at 4x4 block level which has parameters about early 1250 * intra or inter decision 1251 ****************************************************************************** 1252 */ 1253 typedef struct 1254 { 1255 /** 1256 * Final parameter of Intra-Inter early decision for the current 4x4. 1257 * 0 - invalid decision 1258 * 1 - eval intra only 1259 * 2 - eval inter only 1260 * 3 - eval both intra and inter 1261 */ 1262 UWORD8 intra_or_inter : 2; 1263 1264 UWORD8 merge_success : 1; 1265 1266 /** Best mode for the current 4x4 prediction block */ 1267 UWORD8 best_mode; 1268 1269 /* sad cost for the best prediction mode */ 1270 //UWORD16 best_sad_cost; 1271 1272 /** Best mode for the current 4x4 prediction block */ 1273 UWORD8 best_merge_mode; 1274 1275 /*Store SATD at 4*4 level for current layer (L1)*/ 1276 WORD32 i4_4x4_satd; 1277 1278 /*Store SATD of current data at 4*4 level for current layer (L1)*/ 1279 WORD32 i4_4x4_cur_satd; 1280 1281 } ihevce_ed_blk_t; //early decision 1282 1283 /* l1 ipe ctb analyze structure */ 1284 /* Contains cu level qp mod related information for all possible cu 1285 sizes (16,32,64 in L0) in a CTB*/ 1286 typedef struct 1287 { 1288 WORD32 i4_sum_4x4_satd[16]; 1289 WORD32 i4_min_4x4_satd[16]; 1290 1291 /*satd for L1_8x8 blocks in L1_32x32 1292 16 - num L1_8x8 in L1_32x32 1293 2 => 1294 0 - sum of L1_4x4 @ L1_8x8 1295 - equivalent to transform size of 16x16 @ L0 1296 1 - min/median of L1_4x4 @ L1_8x8 1297 - equivalent to transform size of 8x8 @ L0 1298 */ 1299 WORD32 i4_8x8_satd[16][2]; 1300 1301 /*satd for L1_16x16 blocks in L1_32x32 1302 4 - num L1_16x16 in L1_32x32 1303 3 => 1304 0 - sum of (sum of L1_4x4 @ L1_8x8) @ L1_16x16 1305 - equivalent to transform size of 32x32 @ L0 1306 1 - min/median of (sum of L1_4x4 @ L1_8x8) @ L1_16x16 1307 - equivalent to transform size of 16x16 @ L0 1308 2 - min/median of (min/median of L1_4x4 @ L1_8x8) @ L1_16x16 1309 - equivalent to transform size of 8x8 @ L0 1310 */ 1311 WORD32 i4_16x16_satd[4][3]; 1312 1313 /*satd for 32x32 block in L1*/ 1314 /*Please note that i4_32x32_satd[0][3] contains sum of all 32x32 */ 1315 /*satd for L1_32x32 blocks in L1_32x32 1316 1 - num L1_32x32 in L1_32x32 1317 4 => 1318 0 - min/median of (sum of (sum of L1_4x4 @ L1_8x8) @ L1_16x16) @ L1_32x32 1319 - equivalent to transform size of 32x32 @ L0 1320 1 - min/median of (sum of L1_4x4 @ L1_8x8) @ L1_32x32 1321 - equivalent to transform size of 16x16 @ L0 1322 2 - min/median of (min/median of L1_4x4 @ L1_8x8) @ L1_32x32 1323 - equivalent to transform size of 8x8 @ L0 1324 3 - sum of (sum of (sum of L1_4x4 @ L1_8x8) @ L1_16x16) @ L1_32x32 1325 */ 1326 WORD32 i4_32x32_satd[1][4]; 1327 1328 /*Store SATD at 8x8 level for current layer (L1)*/ 1329 WORD32 i4_best_satd_8x8[16]; 1330 1331 /* EIID: This will be used for early inter intra decisions */ 1332 /*SAD at 8x8 level for current layer (l1) */ 1333 /*Cost based on sad at 8x8 level for current layer (l1) */ 1334 WORD32 i4_best_sad_cost_8x8_l1_ipe[16]; 1335 1336 WORD32 i4_best_sad_8x8_l1_ipe[16]; 1337 /* SAD at 8x8 level for ME. All other cost are IPE cost */ 1338 WORD32 i4_best_sad_cost_8x8_l1_me[16]; 1339 1340 /* SAD at 8x8 level for ME. for given reference */ 1341 WORD32 i4_sad_cost_me_for_ref[16]; 1342 1343 /* SAD at 8x8 level for ME. for given reference */ 1344 WORD32 i4_sad_me_for_ref[16]; 1345 1346 /* SAD at 8x8 level for ME. All other cost are IPE cost */ 1347 WORD32 i4_best_sad_8x8_l1_me[16]; 1348 1349 WORD32 i4_best_sad_8x8_l1_me_for_decide[16]; 1350 1351 /*Mean @ L0 16x16*/ 1352 WORD32 ai4_16x16_mean[16]; 1353 1354 /*Mean @ L0 32x32*/ 1355 WORD32 ai4_32x32_mean[4]; 1356 1357 /*Mean @ L0 64x64*/ 1358 WORD32 i4_64x64_mean; 1359 1360 } ihevce_ed_ctb_l1_t; //early decision 1361 1362 /** 1363 ****************************************************************************** 1364 * @brief 8x8 Intra analyze structure 1365 ****************************************************************************** 1366 */ 1367 typedef struct 1368 { 1369 /** Best intra modes for 8x8 transform. 1370 * Insert 255 in the end to limit number of modes 1371 */ 1372 UWORD8 au1_best_modes_8x8_tu[MAX_INTRA_CU_CANDIDATES + 1]; 1373 1374 /** Best 8x8 intra modes for 4x4 transform 1375 * Insert 255 in the end to limit number of modes 1376 */ 1377 UWORD8 au1_best_modes_4x4_tu[MAX_INTRA_CU_CANDIDATES + 1]; 1378 1379 /** Best 4x4 intra modes 1380 * Insert 255 in the end to limit number of modes 1381 */ 1382 UWORD8 au1_4x4_best_modes[4][MAX_INTRA_CU_CANDIDATES + 1]; 1383 1384 /** best 8x8 intra sad/SATD cost */ 1385 WORD32 i4_best_intra_cost; 1386 1387 /** flag to indicate if nxn pu mode (different pu at 4x4 level) is enabled */ 1388 UWORD8 b1_enable_nxn : 1; 1389 1390 /** valid cu flag : required for incomplete ctbs at frame boundaries */ 1391 UWORD8 b1_valid_cu : 1; 1392 1393 /** dummy bits */ 1394 UWORD8 b6_reserved : 6; 1395 1396 } intra8_analyse_t; 1397 1398 /** 1399 ****************************************************************************** 1400 * @brief 16x16 Intra analyze structure 1401 ****************************************************************************** 1402 */ 1403 typedef struct 1404 { 1405 /** Best intra modes for 16x16 transform. 1406 * Insert 255 in the end to limit number of modes 1407 */ 1408 UWORD8 au1_best_modes_16x16_tu[MAX_INTRA_CU_CANDIDATES + 1]; 1409 1410 /** Best 16x16 intra modes for 8x8 transform 1411 * Insert 255 in the end to limit number of modes 1412 */ 1413 UWORD8 au1_best_modes_8x8_tu[MAX_INTRA_CU_CANDIDATES + 1]; 1414 1415 /** 8x8 children intra analyze for this 16x16 */ 1416 intra8_analyse_t as_intra8_analyse[4]; 1417 1418 /* best 16x16 intra sad/SATD cost */ 1419 WORD32 i4_best_intra_cost; 1420 1421 /* indicates if 16x16 is best cu or 8x8 cu */ 1422 UWORD8 b1_split_flag : 1; 1423 1424 /* indicates if 8x8 vs 16x16 rdo evaluation needed */ 1425 /* or only 8x8's rdo evaluation needed */ 1426 UWORD8 b1_merge_flag : 1; 1427 1428 /** 1429 * valid cu flag : required for incomplete ctbs at frame boundaries 1430 * or if CTB size is lower than 32 1431 */ 1432 UWORD8 b1_valid_cu : 1; 1433 1434 /** dummy bits */ 1435 UWORD8 b6_reserved : 5; 1436 1437 } intra16_analyse_t; 1438 1439 /** 1440 ****************************************************************************** 1441 * @brief 32x32 Intra analyze structure 1442 ****************************************************************************** 1443 */ 1444 typedef struct 1445 { 1446 /** Best intra modes for 32x32 transform. 1447 * Insert 255 in the end to limit number of modes 1448 */ 1449 UWORD8 au1_best_modes_32x32_tu[MAX_INTRA_CU_CANDIDATES + 1]; 1450 1451 /** Best 32x32 intra modes for 16x16 transform 1452 * Insert 255 in the end to limit number of modes 1453 */ 1454 UWORD8 au1_best_modes_16x16_tu[MAX_INTRA_CU_CANDIDATES + 1]; 1455 1456 /** 16x16 children intra analyze for this 32x32 */ 1457 intra16_analyse_t as_intra16_analyse[4]; 1458 1459 /* best 32x32 intra sad/SATD cost */ 1460 WORD32 i4_best_intra_cost; 1461 1462 /* indicates if 32x32 is best cu or 16x16 cu */ 1463 UWORD8 b1_split_flag : 1; 1464 1465 /* indicates if 32x32 vs 16x16 rdo evaluation needed */ 1466 /* or 16x16 vs 8x8 evaluation is needed */ 1467 UWORD8 b1_merge_flag : 1; 1468 1469 /** 1470 * valid cu flag : required for incomplete ctbs at frame boundaries 1471 * or if CTB size is lower than 64 1472 */ 1473 UWORD8 b1_valid_cu : 1; 1474 1475 /** dummy bits */ 1476 UWORD8 b6_reserved : 5; 1477 1478 } intra32_analyse_t; 1479 1480 /** 1481 ****************************************************************************** 1482 * @brief IPE L0 analyze structure for L0 ME to do intra/inter CU decisions 1483 * This is a CTB level structure encapsulating IPE modes, cost at all 1484 * level. IPE also recommemds max intra CU sizes which is required 1485 * by ME for CU size determination in intra dominant CTB 1486 ****************************************************************************** 1487 */ 1488 typedef struct 1489 { 1490 /** Best 64x64 intra modes for 32x32 transform. 1491 * Insert 255 in the end to limit number of modes 1492 */ 1493 UWORD8 au1_best_modes_32x32_tu[MAX_INTRA_CU_CANDIDATES + 1]; 1494 1495 /** 32x32 children intra analyze for this 32x32 */ 1496 intra32_analyse_t as_intra32_analyse[4]; 1497 1498 /* indicates if 64x64 is best CUs or 32x32 CUs */ 1499 UWORD8 u1_split_flag; 1500 1501 /* CTB level best 8x8 intra costs */ 1502 WORD32 ai4_best8x8_intra_cost[MAX_CU_IN_CTB]; 1503 1504 /* CTB level best 16x16 intra costs */ 1505 WORD32 ai4_best16x16_intra_cost[MAX_CU_IN_CTB >> 2]; 1506 1507 /* CTB level best 32x32 intra costs */ 1508 WORD32 ai4_best32x32_intra_cost[MAX_CU_IN_CTB >> 4]; 1509 1510 /* best 64x64 intra cost */ 1511 WORD32 i4_best64x64_intra_cost; 1512 1513 /** 1514 * CTB level early intra / inter decision at 8x8 block level 1515 * 0 - invalid decision 1516 * 1 - eval intra only 1517 * 2 - eval inter only 1518 * 3 - eval both intra and inter 1519 */ 1520 /* Z scan format */ 1521 WORD8 ai1_early_intra_inter_decision[MAX_CU_IN_CTB]; 1522 1523 /* 1524 @L0 level 1525 4 => 0 - 32x32 TU in 64x64 CU 1526 1 - 16x16 TU in 64x64 CU 1527 2 - 8x8 TU in 64x64 CU 1528 3 - 64x64 CU 1529 2 => Intra/Inter */ 1530 WORD32 i4_64x64_act_factor[4][2]; 1531 1532 /* 1533 @L0 level 1534 4 => num 32x32 in CTB 1535 3 => 0 - 32x32 TU in 64x64 CU 1536 1 - 16x16 TU in 64x64 CU 1537 2 - 8x8 TU in 64x64 CU 1538 2 => Intra/Inter */ 1539 WORD32 i4_32x32_act_factor[4][3][2]; 1540 1541 /* 1542 @L0 level 1543 16 => num 16x16 in CTB 1544 2 => 0 - 16x16 TU in 64x64 CU 1545 1 - 8x8 TU in 64x64 CU 1546 2 => Intra/Inter */ 1547 WORD32 i4_16x16_act_factor[16][2][2]; 1548 1549 WORD32 nodes_created_in_cu_tree; 1550 1551 cur_ctb_cu_tree_t *ps_cu_tree_root; 1552 1553 WORD32 ai4_8x8_act_factor[16]; 1554 WORD32 ai4_best_sad_8x8_l1_me[MAX_CU_IN_CTB]; 1555 WORD32 ai4_best_sad_8x8_l1_ipe[MAX_CU_IN_CTB]; 1556 WORD32 ai4_best_sad_cost_8x8_l1_me[MAX_CU_IN_CTB]; 1557 WORD32 ai4_best_sad_cost_8x8_l1_ipe[MAX_CU_IN_CTB]; 1558 1559 /*Ctb level accumalated satd*/ 1560 WORD32 i4_ctb_acc_satd; 1561 1562 /*Ctb level accumalated mpm bits*/ 1563 WORD32 i4_ctb_acc_mpm_bits; 1564 1565 } ipe_l0_ctb_analyse_for_me_t; 1566 1567 typedef struct 1568 { 1569 WORD16 i2_mv_x; 1570 WORD16 i2_mv_y; 1571 } global_mv_t; 1572 1573 /** 1574 ****************************************************************************** 1575 * @brief Pre Encode pass and ME pass shared variables and buffers 1576 ****************************************************************************** 1577 */ 1578 typedef struct 1579 { 1580 /** 1581 * Buffer id 1582 */ 1583 WORD32 i4_buf_id; 1584 1585 /** 1586 * Flag will be set to 1 by frame processing thread after receiving flush 1587 * command from application 1588 */ 1589 WORD32 i4_end_flag; 1590 1591 /** frame leve ctb analyse buffer pointer */ 1592 ctb_analyse_t *ps_ctb_analyse; 1593 1594 /** frame level cu analyse buffer pointer for IPE */ 1595 //cu_analyse_t *ps_cu_analyse; 1596 1597 /** current input pointer */ 1598 ihevce_lap_enc_buf_t *ps_curr_inp; 1599 1600 /** current inp buffer id */ 1601 WORD32 curr_inp_buf_id; 1602 1603 /** Slice header parameters */ 1604 slice_header_t s_slice_hdr; 1605 1606 /** sps parameters activated by current slice */ 1607 sps_t *ps_sps; 1608 1609 /** pps parameters activated by current slice */ 1610 pps_t *ps_pps; 1611 1612 /** vps parameters activated by current slice */ 1613 vps_t *ps_vps; 1614 /** Pointer to Penultilate Layer context memory internally has MV bank buff and related params */ 1615 void *pv_me_lyr_ctxt; 1616 1617 /** Pointer to Penultilate Layer NV bank context memory */ 1618 void *pv_me_lyr_bnk_ctxt; 1619 1620 /** Pointer to Penultilate Layer MV bank buff */ 1621 void *pv_me_mv_bank; 1622 1623 /** Pointer to Penultilate Layer reference idx buffer */ 1624 void *pv_me_ref_idx; 1625 /** 1626 * Array to store 8x8 cost (partial 8x8 sad + level adjusted cost) 1627 * The order of storing is raster scan order within CTB and 1628 * CTB order is raster scan within frame. 1629 */ 1630 double *plf_intra_8x8_cost; 1631 1632 /** 1633 * L0 layer ctb anaylse frame level buffer. 1634 * IPE wil populate the cost and best modes at all levels in this buffer 1635 * for every CTB in a frame 1636 */ 1637 // moved to shorter buffer queue 1638 //ipe_l0_ctb_analyse_for_me_t *ps_ipe_analyse_ctb; 1639 1640 /** Layer L1 buffer pointer */ 1641 ihevce_ed_blk_t *ps_layer1_buf; 1642 1643 /** Layer L2 buffer pointer */ 1644 ihevce_ed_blk_t *ps_layer2_buf; 1645 1646 /*ME reverse map info*/ 1647 UWORD8 *pu1_me_reverse_map_info; 1648 1649 /** Buffer pointer for CTB level information in pre intra pass*/ 1650 ihevce_ed_ctb_l1_t *ps_ed_ctb_l1; 1651 1652 /* L0 cur 8x8 satd for QP mod*/ 1653 ihevce_8x8_L0_satd_t *ps_layer0_cur_satd; 1654 1655 /* L0 cur 8x8 mean for QP mod*/ 1656 ihevce_8x8_L0_mean_t *ps_layer0_cur_mean; 1657 1658 /** vps parameters activated by current slice */ 1659 sei_params_t s_sei; 1660 1661 /** nal_type for the slice to be encoded */ 1662 WORD32 i4_slice_nal_type; 1663 1664 /** input time stamp in terms of ticks: lower 32 */ 1665 WORD32 i4_inp_timestamp_low; 1666 1667 /** input time stamp in terms of ticks: higher 32 */ 1668 WORD32 i4_inp_timestamp_high; 1669 1670 /** input frame ctxt of app to be retured in output buffer */ 1671 void *pv_app_frm_ctxt; 1672 1673 /** current frm valid flag : 1674 * will be 1 if valid input was processed by frame proc thrd 1675 */ 1676 WORD32 i4_frm_proc_valid_flag; 1677 1678 /** 1679 * Qp to be used for current frame 1680 */ 1681 WORD32 i4_curr_frm_qp; 1682 1683 /** 1684 * Frame level Lambda parameters 1685 */ 1686 frm_lambda_ctxt_t as_lambda_prms[IHEVCE_MAX_NUM_BITRATES]; 1687 1688 /** Frame-levelSATDcost accumalator */ 1689 LWORD64 i8_frame_acc_satd_cost; 1690 1691 /** Frame - L1 coarse me cost accumulated */ 1692 LWORD64 i8_acc_frame_coarse_me_cost; 1693 /** Frame - L1 coarse me cost accumulated */ 1694 //LWORD64 i8_acc_frame_coarse_me_cost_for_ref; 1695 1696 /** Frame - L1 coarse me sad accumulated */ 1697 LWORD64 i8_acc_frame_coarse_me_sad; 1698 1699 /* Averge activity of 4x4 blocks from previous frame 1700 * If L1, maps to 8*8 in L0 1701 */ 1702 WORD32 i4_curr_frame_4x4_avg_act; 1703 1704 WORD32 ai4_mod_factor_derived_by_variance[2]; 1705 1706 float f_strength; 1707 1708 /* Averge activity of 8x8 blocks from previous frame 1709 * If L1, maps to 16*16 in L0 1710 */ 1711 1712 long double ld_curr_frame_8x8_log_avg[2]; 1713 1714 LWORD64 i8_curr_frame_8x8_avg_act[2]; 1715 1716 LWORD64 i8_curr_frame_8x8_sum_act[2]; 1717 1718 WORD32 i4_curr_frame_8x8_sum_act_for_strength[2]; 1719 1720 ULWORD64 u8_curr_frame_8x8_sum_act_sqr; 1721 1722 WORD32 i4_curr_frame_8x8_num_blks[2]; 1723 1724 LWORD64 i8_acc_frame_8x8_sum_act[2]; 1725 LWORD64 i8_acc_frame_8x8_sum_act_sqr; 1726 WORD32 i4_acc_frame_8x8_num_blks[2]; 1727 LWORD64 i8_acc_frame_8x8_sum_act_for_strength; 1728 LWORD64 i8_curr_frame_8x8_sum_act_for_strength; 1729 1730 /* Averge activity of 16x16 blocks from previous frame 1731 * If L1, maps to 32*32 in L0 1732 */ 1733 1734 long double ld_curr_frame_16x16_log_avg[3]; 1735 1736 LWORD64 i8_curr_frame_16x16_avg_act[3]; 1737 1738 LWORD64 i8_curr_frame_16x16_sum_act[3]; 1739 1740 WORD32 i4_curr_frame_16x16_num_blks[3]; 1741 1742 LWORD64 i8_acc_frame_16x16_sum_act[3]; 1743 WORD32 i4_acc_frame_16x16_num_blks[3]; 1744 1745 /* Averge activity of 32x32 blocks from previous frame 1746 * If L1, maps to 64*64 in L0 1747 */ 1748 1749 long double ld_curr_frame_32x32_log_avg[3]; 1750 1751 LWORD64 i8_curr_frame_32x32_avg_act[3]; 1752 1753 global_mv_t s_global_mv[MAX_NUM_REF]; 1754 LWORD64 i8_curr_frame_32x32_sum_act[3]; 1755 1756 WORD32 i4_curr_frame_32x32_num_blks[3]; 1757 1758 LWORD64 i8_acc_frame_32x32_sum_act[3]; 1759 WORD32 i4_acc_frame_32x32_num_blks[3]; 1760 1761 LWORD64 i8_acc_num_blks_high_sad; 1762 1763 LWORD64 i8_total_blks; 1764 1765 WORD32 i4_complexity_percentage; 1766 1767 WORD32 i4_is_high_complex_region; 1768 1769 WORD32 i4_avg_noise_thrshld_4x4; 1770 1771 LWORD64 i8_curr_frame_mean_sum; 1772 WORD32 i4_curr_frame_mean_num_blks; 1773 LWORD64 i8_curr_frame_avg_mean_act; 1774 1775 } pre_enc_me_ctxt_t; 1776 1777 /** 1778 ****************************************************************************** 1779 * @brief buffers from L0 IPE to ME and enc loop 1780 ****************************************************************************** 1781 */ 1782 typedef struct 1783 { 1784 WORD32 i4_size; 1785 1786 ipe_l0_ctb_analyse_for_me_t *ps_ipe_analyse_ctb; 1787 } pre_enc_L0_ipe_encloop_ctxt_t; 1788 /** 1789 ****************************************************************************** 1790 * @brief Frame process and Entropy coding pass shared variables and buffers 1791 ****************************************************************************** 1792 */ 1793 1794 typedef struct 1795 { 1796 /*PIC level Info*/ 1797 ULWORD64 i8_total_cu; 1798 ULWORD64 i8_total_cu_min_8x8; 1799 ULWORD64 i8_total_pu; 1800 ULWORD64 i8_total_intra_cu; 1801 ULWORD64 i8_total_inter_cu; 1802 ULWORD64 i8_total_skip_cu; 1803 ULWORD64 i8_total_cu_based_on_size[4]; 1804 1805 ULWORD64 i8_total_intra_pu; 1806 ULWORD64 i8_total_merge_pu; 1807 ULWORD64 i8_total_non_skipped_inter_pu; 1808 1809 ULWORD64 i8_total_2nx2n_intra_pu[4]; 1810 ULWORD64 i8_total_nxn_intra_pu; 1811 ULWORD64 i8_total_2nx2n_inter_pu[4]; 1812 ULWORD64 i8_total_smp_inter_pu[4]; 1813 ULWORD64 i8_total_amp_inter_pu[3]; 1814 ULWORD64 i8_total_nxn_inter_pu[3]; 1815 1816 ULWORD64 i8_total_L0_mode; 1817 ULWORD64 i8_total_L1_mode; 1818 ULWORD64 i8_total_BI_mode; 1819 1820 ULWORD64 i8_total_L0_ref_idx[MAX_DPB_SIZE]; 1821 ULWORD64 i8_total_L1_ref_idx[MAX_DPB_SIZE]; 1822 1823 ULWORD64 i8_total_tu; 1824 ULWORD64 i8_total_non_coded_tu; 1825 ULWORD64 i8_total_inter_coded_tu; 1826 ULWORD64 i8_total_intra_coded_tu; 1827 1828 ULWORD64 i8_total_tu_based_on_size[4]; 1829 ULWORD64 i8_total_tu_cu64[4]; 1830 ULWORD64 i8_total_tu_cu32[4]; 1831 ULWORD64 i8_total_tu_cu16[3]; 1832 ULWORD64 i8_total_tu_cu8[2]; 1833 1834 LWORD64 i8_total_qp; 1835 LWORD64 i8_total_qp_min_cu; 1836 WORD32 i4_min_qp; 1837 WORD32 i4_max_qp; 1838 LWORD64 i8_sum_squared_frame_qp; 1839 LWORD64 i8_total_frame_qp; 1840 WORD32 i4_max_frame_qp; 1841 float f_total_buffer_underflow; 1842 float f_total_buffer_overflow; 1843 float f_max_buffer_underflow; 1844 float f_max_buffer_overflow; 1845 1846 UWORD8 i1_num_ref_idx_l0_active; 1847 UWORD8 i1_num_ref_idx_l1_active; 1848 1849 WORD32 i4_ref_poc_l0[MAX_DPB_SIZE]; 1850 WORD32 i4_ref_poc_l1[MAX_DPB_SIZE]; 1851 1852 WORD8 i1_list_entry_l0[MAX_DPB_SIZE]; 1853 DOUBLE i2_luma_weight_l0[MAX_DPB_SIZE]; 1854 WORD16 i2_luma_offset_l0[MAX_DPB_SIZE]; 1855 WORD8 i1_list_entry_l1[MAX_DPB_SIZE]; 1856 DOUBLE i2_luma_weight_l1[MAX_DPB_SIZE]; 1857 WORD16 i2_luma_offset_l1[MAX_DPB_SIZE]; 1858 1859 ULWORD64 u8_bits_estimated_intra; 1860 ULWORD64 u8_bits_estimated_inter; 1861 ULWORD64 u8_bits_estimated_slice_header; 1862 ULWORD64 u8_bits_estimated_sao; 1863 ULWORD64 u8_bits_estimated_split_cu_flag; 1864 ULWORD64 u8_bits_estimated_cu_hdr_bits; 1865 ULWORD64 u8_bits_estimated_split_tu_flag; 1866 ULWORD64 u8_bits_estimated_qp_delta_bits; 1867 ULWORD64 u8_bits_estimated_cbf_luma_bits; 1868 ULWORD64 u8_bits_estimated_cbf_chroma_bits; 1869 1870 ULWORD64 u8_bits_estimated_res_luma_bits; 1871 ULWORD64 u8_bits_estimated_res_chroma_bits; 1872 1873 ULWORD64 u8_bits_estimated_ref_id; 1874 ULWORD64 u8_bits_estimated_mvd; 1875 ULWORD64 u8_bits_estimated_merge_flag; 1876 ULWORD64 u8_bits_estimated_mpm_luma; 1877 ULWORD64 u8_bits_estimated_mpm_chroma; 1878 1879 ULWORD64 u8_total_bits_generated; 1880 ULWORD64 u8_total_bits_vbv; 1881 1882 ULWORD64 u8_total_I_bits_generated; 1883 ULWORD64 u8_total_P_bits_generated; 1884 ULWORD64 u8_total_B_bits_generated; 1885 1886 UWORD32 u4_frame_sad; 1887 UWORD32 u4_frame_intra_sad; 1888 UWORD32 u4_frame_inter_sad; 1889 1890 ULWORD64 i8_frame_cost; 1891 ULWORD64 i8_frame_intra_cost; 1892 ULWORD64 i8_frame_inter_cost; 1893 } s_pic_level_acc_info_t; 1894 1895 typedef struct 1896 { 1897 UWORD32 u4_target_bit_rate_sei_entropy; 1898 UWORD32 u4_buffer_size_sei_entropy; 1899 UWORD32 u4_dbf_entropy; 1900 1901 } s_pic_level_sei_info_t; 1902 /** 1903 ****************************************************************************** 1904 * @brief ME pass and Main enocde pass shared variables and buffers 1905 ****************************************************************************** 1906 */ 1907 typedef struct 1908 { 1909 /** 1910 * Buffer id 1911 */ 1912 WORD32 i4_buf_id; 1913 1914 /** 1915 * Flag will be set to 1 by frame processing thread after receiving flush 1916 * command from application 1917 */ 1918 WORD32 i4_end_flag; 1919 1920 /** current input pointer */ 1921 ihevce_lap_enc_buf_t *ps_curr_inp; 1922 1923 /** current inp buffer id */ 1924 WORD32 curr_inp_buf_id; 1925 1926 /** current input buffers from ME */ 1927 pre_enc_me_ctxt_t *ps_curr_inp_from_me_prms; 1928 1929 /** current inp buffer id from ME */ 1930 WORD32 curr_inp_from_me_buf_id; 1931 1932 /** current input buffers from L0 IPE */ 1933 pre_enc_L0_ipe_encloop_ctxt_t *ps_curr_inp_from_l0_ipe_prms; 1934 1935 /** current inp buffer id from L0 IPE */ 1936 WORD32 curr_inp_from_l0_ipe_buf_id; 1937 1938 /** Slice header parameters */ 1939 slice_header_t s_slice_hdr; 1940 1941 /** current frm valid flag : 1942 * will be 1 if valid input was processed by frame proc thrd 1943 */ 1944 WORD32 i4_frm_proc_valid_flag; 1945 1946 /** 1947 * Array of reference picture list for ping instance 1948 * 2=> ref_pic_list0 and ref_pic_list1 1949 */ 1950 recon_pic_buf_t as_ref_list[IHEVCE_MAX_NUM_BITRATES][2][HEVCE_MAX_REF_PICS * 2]; 1951 1952 /** 1953 * Array of reference picture list 1954 * 2=> ref_pic_list0 and ref_pic_list1 1955 */ 1956 recon_pic_buf_t *aps_ref_list[IHEVCE_MAX_NUM_BITRATES][2][HEVCE_MAX_REF_PICS * 2]; 1957 1958 /** Job Queue Memory encode */ 1959 job_queue_t *ps_job_q_enc; 1960 1961 /** Array of Job Queue handles of enc group for ping and pong instance*/ 1962 job_queue_handle_t as_job_que_enc_hdls[NUM_ENC_JOBS_QUES]; 1963 1964 /** Array of Job Queue handles of enc group for re-encode*/ 1965 job_queue_handle_t as_job_que_enc_hdls_reenc[NUM_ENC_JOBS_QUES]; 1966 /** frame level me_ctb_data_t buffer pointer 1967 */ 1968 me_ctb_data_t *ps_cur_ctb_me_data; 1969 1970 /** frame level cur_ctb_cu_tree_t buffer pointer for ME 1971 */ 1972 cur_ctb_cu_tree_t *ps_cur_ctb_cu_tree; 1973 1974 /** Pointer to Dep. Mngr for CTBs processed in every row of a frame. 1975 * ME is producer, EncLoop is the consumer 1976 */ 1977 void *pv_dep_mngr_encloop_dep_me; 1978 1979 } me_enc_rdopt_ctxt_t; 1980 1981 typedef struct 1982 { 1983 UWORD32 u4_payload_type; 1984 UWORD32 u4_payload_length; 1985 UWORD8 *pu1_sei_payload; 1986 } sei_payload_t; 1987 1988 typedef struct 1989 { 1990 /** 1991 * Flag will be set to 1 by frame processing thread after receiving flush 1992 * command from application 1993 */ 1994 WORD32 i4_end_flag; 1995 1996 /** frame level ctb allocation for ctb after aligning to max cu size */ 1997 ctb_enc_loop_out_t *ps_frm_ctb_data; 1998 1999 /** frame level cu allocation for ctb after aligning to max cu size */ 2000 cu_enc_loop_out_t *ps_frm_cu_data; 2001 2002 /** frame level tu allocation for ctb after aligning to max cu size */ 2003 tu_enc_loop_out_t *ps_frm_tu_data; 2004 2005 /** frame level pu allocation for ctb after aligning to max cu size */ 2006 pu_t *ps_frm_pu_data; 2007 2008 /** frame level coeff allocation for ctb after aligning to max cu size */ 2009 void *pv_coeff_data; 2010 2011 /** Slice header parameters */ 2012 slice_header_t s_slice_hdr; 2013 2014 /** sps parameters activated by current slice */ 2015 sps_t *ps_sps; 2016 2017 /** pps parameters activated by current slice */ 2018 pps_t *ps_pps; 2019 2020 /** vps parameters activated by current slice */ 2021 vps_t *ps_vps; 2022 2023 /** vps parameters activated by current slice */ 2024 sei_params_t s_sei; 2025 2026 /* Flag to indicate if AUD NAL is present */ 2027 WORD8 i1_aud_present_flag; 2028 2029 /* Flag to indicate if EOS NAL is present */ 2030 WORD8 i1_eos_present_flag; 2031 2032 /** nal_type for the slice to be encoded */ 2033 WORD32 i4_slice_nal_type; 2034 2035 /** input time stamp in terms of ticks: lower 32 */ 2036 WORD32 i4_inp_timestamp_low; 2037 2038 /** input time stamp in terms of ticks: higher 32 */ 2039 WORD32 i4_inp_timestamp_high; 2040 2041 /** input frame ctxt of app to be retured in output buffer */ 2042 void *pv_app_frm_ctxt; 2043 2044 /** current frm valid flag : 2045 * will be 1 if valid input was processed by frame proc thrd 2046 */ 2047 WORD32 i4_frm_proc_valid_flag; 2048 2049 /** To support entropy sync the bitstream offset of each CTB row 2050 * is populated in this array any put in slice header in the end 2051 */ 2052 WORD32 ai4_entry_point_offset[MAX_NUM_CTB_ROWS_FRM]; 2053 2054 /** RDopt estimation of bytes generated based on which rc update happens 2055 * 2056 */ 2057 WORD32 i4_rdopt_bits_generated_estimate; 2058 2059 /* These params are passed from enc-threads to entropy thread for 2060 passing params needed for PSNR caclulation and encoding 2061 summary prints */ 2062 DOUBLE lf_luma_mse; 2063 DOUBLE lf_cb_mse; 2064 DOUBLE lf_cr_mse; 2065 2066 DOUBLE lf_luma_ssim; 2067 DOUBLE lf_cb_ssim; 2068 DOUBLE lf_cr_ssim; 2069 2070 WORD32 i4_qp; 2071 WORD32 i4_poc; 2072 WORD32 i4_display_num; 2073 WORD32 i4_pic_type; 2074 2075 /** I-only SCD */ 2076 WORD32 i4_is_I_scenecut; 2077 2078 WORD32 i4_is_non_I_scenecut; 2079 WORD32 i4_sub_pic_level_rc; 2080 2081 WORD32 ai4_frame_bits_estimated; 2082 s_pic_level_acc_info_t s_pic_level_info; 2083 2084 LWORD64 i8_buf_level_bitrate_change; 2085 2086 WORD32 i4_is_end_of_idr_gop; 2087 2088 sei_payload_t as_sei_payload[MAX_NUMBER_OF_SEI_PAYLOAD]; 2089 2090 UWORD32 u4_num_sei_payload; 2091 /* Flag used only in mres single output case to flush out one res and start with next */ 2092 WORD32 i4_out_flush_flag; 2093 2094 } frm_proc_ent_cod_ctxt_t; 2095 2096 /** 2097 ****************************************************************************** 2098 * @brief ME pass and Main enocde pass shared variables and buffers 2099 ****************************************************************************** 2100 */ 2101 typedef struct 2102 { 2103 /*BitRate ID*/ 2104 WORD32 i4_br_id; 2105 2106 /*Frame ID*/ 2107 WORD32 i4_frm_id; 2108 2109 /*Number of CTB, after ich data is populated*/ 2110 WORD32 i4_ctb_count_in_data; 2111 2112 /*Number of CTB, after ich scale is computed*/ 2113 WORD32 i4_ctb_count_out_scale; 2114 2115 /*Bits estimated for the frame */ 2116 /* For NON-I SCD max buf bits*/ 2117 LWORD64 i8_frame_bits_estimated; 2118 2119 /* Bits consumed till the nctb*/ 2120 LWORD64 i8_nctb_bits_consumed; 2121 2122 /* Bits consumed till the nctb*/ 2123 LWORD64 i8_acc_bits_consumed; 2124 2125 /*Frame level Best of Ipe and ME sad*/ 2126 LWORD64 i8_frame_l1_me_sad; 2127 2128 /*SAD accumalted till NCTB*/ 2129 LWORD64 i8_nctb_l1_me_sad; 2130 2131 /*Frame level IPE sad*/ 2132 LWORD64 i8_frame_l1_ipe_sad; 2133 2134 /*SAD accumalted till NCTB*/ 2135 LWORD64 i8_nctb_l1_ipe_sad; 2136 2137 /*Frame level L0 IPE satd*/ 2138 LWORD64 i8_frame_l0_ipe_satd; 2139 2140 /*L0 SATD accumalted till NCTB*/ 2141 LWORD64 i8_nctb_l0_ipe_satd; 2142 2143 /*Frame level Activity factor acc at 8x8 level */ 2144 LWORD64 i8_frame_l1_activity_fact; 2145 2146 /*NCTB Activity factor acc at 8x8 level */ 2147 LWORD64 i8_nctb_l1_activity_fact; 2148 2149 /*L0 MPM bits accumalted till NCTB*/ 2150 LWORD64 i8_nctb_l0_mpm_bits; 2151 2152 /*Encoder hdr accumalted till NCTB*/ 2153 LWORD64 i8_nctb_hdr_bits_consumed; 2154 2155 } ihevce_sub_pic_rc_ctxt_t; 2156 2157 /** 2158 ****************************************************************************** 2159 * @brief Memoery manager context (stores the memory tables allcoated) 2160 ****************************************************************************** 2161 */ 2162 typedef struct 2163 { 2164 /** 2165 * Total number of memtabs (Modules and system) 2166 * during create time 2167 */ 2168 WORD32 i4_num_create_memtabs; 2169 2170 /** 2171 * Pointer to the mem tabs 2172 * of crate time 2173 */ 2174 iv_mem_rec_t *ps_create_memtab; 2175 2176 /** 2177 * Total number of memtabs Data and control Ques 2178 * during Ques create time 2179 */ 2180 WORD32 i4_num_q_memtabs; 2181 2182 /** 2183 * Pointer to the mem tabs 2184 * of crate time 2185 */ 2186 iv_mem_rec_t *ps_q_memtab; 2187 2188 } enc_mem_mngr_ctxt; 2189 2190 /** 2191 ****************************************************************************** 2192 * @brief Encoder Interafce Queues Context 2193 ****************************************************************************** 2194 */ 2195 typedef struct 2196 { 2197 /** Number of Queues at interface context level */ 2198 WORD32 i4_num_queues; 2199 2200 /** Array of Queues handle */ 2201 void *apv_q_hdl[IHEVCE_MAX_NUM_QUEUES]; 2202 2203 /** Mutex for encuring thread safety of the access of the queues */ 2204 void *pv_q_mutex_hdl; 2205 2206 } enc_q_ctxt_t; 2207 2208 /** 2209 ****************************************************************************** 2210 * @brief Module context of different modules in encoder 2211 ****************************************************************************** 2212 */ 2213 2214 typedef struct 2215 { 2216 /** Motion estimation context pointer */ 2217 void *pv_me_ctxt; 2218 /** Coarse Motion estimation context pointer */ 2219 void *pv_coarse_me_ctxt; 2220 2221 /** Intra Prediction context pointer */ 2222 void *pv_ipe_ctxt; 2223 2224 /** Encode Loop context pointer */ 2225 void *pv_enc_loop_ctxt; 2226 2227 /** Entropy Coding context pointer */ 2228 void *apv_ent_cod_ctxt[IHEVCE_MAX_NUM_BITRATES]; 2229 2230 /** Look Ahead Processing context pointer */ 2231 void *pv_lap_ctxt; 2232 /** Rate control context pointer */ 2233 void *apv_rc_ctxt[IHEVCE_MAX_NUM_BITRATES]; 2234 /** Decomposition pre intra context pointer */ 2235 void *pv_decomp_pre_intra_ctxt; 2236 2237 } module_ctxt_t; 2238 2239 /** 2240 ****************************************************************************** 2241 * @brief Threads semaphore handles 2242 ****************************************************************************** 2243 */ 2244 typedef struct 2245 { 2246 /** LAP semaphore handle */ 2247 void *pv_lap_sem_handle; 2248 2249 /** Encode frame Process semaphore handle */ 2250 void *pv_enc_frm_proc_sem_handle; 2251 2252 /** Pre Encode frame Process semaphore handle */ 2253 void *pv_pre_enc_frm_proc_sem_handle; 2254 2255 /** Entropy coding semaphore handle 2256 One semaphore for each entropy thread, i.e. for each bit-rate instance*/ 2257 void *apv_ent_cod_sem_handle[IHEVCE_MAX_NUM_BITRATES]; 2258 2259 /** 2260 * Semaphore handle corresponding to get free inp frame buff 2261 * function call from app if called in blocking mode 2262 */ 2263 void *pv_inp_data_sem_handle; 2264 2265 /** 2266 * Semaphore handle corresponding to get free inp control command buff 2267 * function call from app if called in blocking mode 2268 */ 2269 void *pv_inp_ctrl_sem_handle; 2270 2271 /** 2272 * Semaphore handle corresponding to get filled out bitstream buff 2273 * function call from app if called in blocking mode 2274 */ 2275 void *apv_out_strm_sem_handle[IHEVCE_MAX_NUM_BITRATES]; 2276 2277 /** 2278 * Semaphore handle corresponding to get filled out recon buff 2279 * function call from app if called in blocking mode 2280 */ 2281 void *apv_out_recon_sem_handle[IHEVCE_MAX_NUM_BITRATES]; 2282 2283 /** 2284 * Semaphore handle corresponding to get filled out control status buff 2285 * function call from app if called in blocking mode 2286 */ 2287 void *pv_out_ctrl_sem_handle; 2288 2289 /** 2290 * Semaphore handle corresponding to get filled out control status buff 2291 * function call from app if called in blocking mode 2292 */ 2293 void *pv_lap_inp_data_sem_hdl; 2294 2295 /** 2296 * Semaphore handle corresponding to get filled out control status buff 2297 * function call from app if called in blocking mode 2298 */ 2299 void *pv_preenc_inp_data_sem_hdl; 2300 2301 /** 2302 * Semaphore handle corresponding to Multi Res Single output case 2303 */ 2304 void *pv_ent_common_mres_sem_hdl; 2305 void *pv_out_common_mres_sem_hdl; 2306 2307 } thrd_que_sem_hdl_t; 2308 2309 /** 2310 ****************************************************************************** 2311 * @brief Frame level structure which has parameters about CTBs 2312 ****************************************************************************** 2313 */ 2314 typedef struct 2315 { 2316 /** CTB size of all CTB in a frame in pixels 2317 * this will be create time value, 2318 * run time change in this value is not supported 2319 */ 2320 WORD32 i4_ctb_size; 2321 2322 /** Minimum CU size of CTB in a frame in pixels 2323 * this will be create time value, 2324 * run time change in this value is not supported 2325 */ 2326 WORD32 i4_min_cu_size; 2327 2328 /** Worst case num CUs in CTB based on i4_ctb_size */ 2329 WORD32 i4_num_cus_in_ctb; 2330 2331 /** Worst case num PUs in CTB based on i4_ctb_size */ 2332 WORD32 i4_num_pus_in_ctb; 2333 2334 /** Worst case num TUs in CTB based on i4_ctb_size */ 2335 WORD32 i4_num_tus_in_ctb; 2336 2337 /** Number of CTBs in horizontal direction 2338 * this is based on run time source width and i4_ctb_size 2339 */ 2340 WORD32 i4_num_ctbs_horz; 2341 2342 /** Number of CTBs in vertical direction 2343 * this is based on run time source height and i4_ctb_size 2344 */ 2345 WORD32 i4_num_ctbs_vert; 2346 2347 /** MAX CUs in horizontal direction 2348 * this is based on run time source width, i4_ctb_size and i4_num_cus_in_ctb 2349 */ 2350 WORD32 i4_max_cus_in_row; 2351 2352 /** MAX PUs in horizontal direction 2353 * this is based on run time source width, i4_ctb_size and i4_num_pus_in_ctb 2354 */ 2355 WORD32 i4_max_pus_in_row; 2356 2357 /** MAX TUs in horizontal direction 2358 * this is based on run time source width, i4_ctb_size and i4_num_tus_in_ctb 2359 */ 2360 WORD32 i4_max_tus_in_row; 2361 2362 /** 2363 * CU aligned picture width (currently aligned to MAX CU size) 2364 * should be modified to be aligned to MIN CU size 2365 */ 2366 2367 WORD32 i4_cu_aligned_pic_wd; 2368 2369 /** 2370 * CU aligned picture height (currently aligned to MAX CU size) 2371 * should be modified to be aligned to MIN CU size 2372 */ 2373 2374 WORD32 i4_cu_aligned_pic_ht; 2375 2376 /* Pointer to a frame level memory, 2377 Stride is = 1 + (num ctbs in a ctb-row) + 1 2378 Hieght is = 1 + (num ctbs in a ctb-col) 2379 Contains tile-id of each ctb */ 2380 WORD32 *pi4_tile_id_map; 2381 2382 /* stride in units of ctb */ 2383 WORD32 i4_tile_id_ctb_map_stride; 2384 2385 } frm_ctb_ctxt_t; 2386 2387 /** 2388 ****************************************************************************** 2389 * @brief ME Job Queue desc 2390 ****************************************************************************** 2391 */ 2392 typedef struct 2393 { 2394 /** Number of output dependencies which need to be set after 2395 * current job is complete, 2396 * should be less than or equal to MAX_OUT_DEP defined in 2397 * ihevce_multi_thrd_structs.h 2398 */ 2399 WORD32 i4_num_output_dep; 2400 2401 /** Array of offsets from the start of output dependent layer's Job Ques 2402 * which are dependent on current Job to be complete 2403 */ 2404 WORD32 ai4_out_dep_unit_off[MAX_OUT_DEP]; 2405 2406 /** Number of input dependencies to be resolved for current job to start 2407 * these many jobs in lower layer should be complete to 2408 * start the current JOB 2409 */ 2410 WORD32 i4_num_inp_dep; 2411 2412 } multi_thrd_me_job_q_prms_t; 2413 2414 /** 2415 * @brief structure in which recon data 2416 * and related parameters are sent from Encoder 2417 */ 2418 typedef struct 2419 { 2420 /** Kept for maintaining backwards compatibility in future */ 2421 WORD32 i4_size; 2422 2423 /** Buffer id for the current buffer */ 2424 WORD32 i4_buf_id; 2425 2426 /** POC of the current buffer */ 2427 WORD32 i4_poc; 2428 2429 /** End flag to communicate this is last frame output from encoder */ 2430 WORD32 i4_end_flag; 2431 2432 /** End flag to communicate encoder that this is the last buffer from application 2433 1 - Last buf, 0 - Not last buffer. No other values are supported. 2434 Application has to set the appropriate value before queing in encoder queue */ 2435 2436 WORD32 i4_is_last_buf; 2437 2438 /** Recon luma buffer pointer */ 2439 void *pv_y_buf; 2440 2441 /** Recon cb buffer pointer */ 2442 void *pv_cb_buf; 2443 2444 /** Recon cr buffer pointer */ 2445 void *pv_cr_buf; 2446 2447 /** Luma size **/ 2448 WORD32 i4_y_pixels; 2449 2450 /** Chroma size **/ 2451 WORD32 i4_uv_pixels; 2452 2453 } iv_enc_recon_data_buffs_t; 2454 2455 /** 2456 ****************************************************************************** 2457 * @brief Multi Thread context structure 2458 ****************************************************************************** 2459 */ 2460 typedef struct 2461 { 2462 /* Flag to indicate to enc and pre-enc thrds that app has sent force end cmd*/ 2463 WORD32 i4_force_end_flag; 2464 2465 /** Force all active threads flag 2466 * This flag will be set to 1 if all Number of cores givento the encoder 2467 * is less than or Equal to MAX_NUM_CORES_SEQ_EXEC. In this mode 2468 * All pre enc threads and enc threads will run of the same cores with 2469 * time sharing ar frame level 2470 */ 2471 WORD32 i4_all_thrds_active_flag; 2472 2473 /** Flag to indicate that core manager has been configured to enable 2474 * sequential execution 2475 */ 2476 WORD32 i4_seq_mode_enabled_flag; 2477 /*-----------------------------------------------------------------------*/ 2478 /*--------- Params related to encode group -----------------------------*/ 2479 /*-----------------------------------------------------------------------*/ 2480 2481 /** Number of processing threads created runtime in encode group */ 2482 WORD32 i4_num_enc_proc_thrds; 2483 2484 /** Number of processing threads active for a given frame 2485 * This value will be monitored at frame level, so as to 2486 * have provsion for increasing / decreasing threads 2487 * based on Load balance b/w stage in encoder 2488 */ 2489 WORD32 i4_num_active_enc_thrds; 2490 /** Job Queue Memory encode */ 2491 job_queue_t *ps_job_q_enc[PING_PONG_BUF]; 2492 2493 /** Array of Job Queue handles of enc group for ping and pong instance*/ 2494 job_queue_handle_t as_job_que_enc_hdls[NUM_ENC_JOBS_QUES][PING_PONG_BUF]; 2495 2496 /** Mutex for ensuring thread safety of the access of Job queues in encode group */ 2497 void *pv_job_q_mutex_hdl_enc_grp_me; 2498 2499 /** Mutex for ensuring thread safety of the access of Job queues in encode group */ 2500 void *pv_job_q_mutex_hdl_enc_grp_enc_loop; 2501 2502 /** Array of Semaphore handles (for each frame processing threads ) */ 2503 void *apv_enc_thrd_sem_handle[MAX_NUM_FRM_PROC_THRDS_ENC]; 2504 2505 /** Array for communcating start processing from master thread to indivisual 2506 * threads in Enocde group of threads 2507 * till 0 : wait 2508 * 1 : start 2509 * After reading the start signal, corresponding thread hould reset it to 0 2510 */ 2511 WORD32 ai4_enc_frm_proc_start[MAX_NUM_FRM_PROC_THRDS_ENC]; 2512 2513 /** Note: For Enc loop pass similar memory is used whihc is part of frm_proc_ent_cod_ctxt_t 2514 * for Row level Sync hence not explicitly declared here 2515 */ 2516 2517 /** Array for ME to export the Job que dependency for all layers */ 2518 multi_thrd_me_job_q_prms_t as_me_job_q_prms[MAX_NUM_HME_LAYERS][MAX_NUM_VERT_UNITS_FRM]; 2519 2520 /* pointer to the mutex handle*/ 2521 void *apv_mutex_handle[MAX_NUM_ME_PARALLEL]; 2522 2523 /* pointer to the mutex handle for frame init*/ 2524 void *apv_mutex_handle_me_end[MAX_NUM_ME_PARALLEL]; 2525 2526 /* pointer to the mutex handle for frame init*/ 2527 void *apv_mutex_handle_frame_init[MAX_NUM_ENC_LOOP_PARALLEL]; 2528 2529 /*pointer to the mutex handle*/ 2530 void *apv_post_enc_mutex_handle[MAX_NUM_ENC_LOOP_PARALLEL]; 2531 2532 /* Flag to indicate that master has done ME init*/ 2533 WORD32 ai4_me_master_done_flag[MAX_NUM_ME_PARALLEL]; 2534 2535 /* Counter to keep track of me num of thrds exiting critical section*/ 2536 WORD32 me_num_thrds_exited[MAX_NUM_ME_PARALLEL]; 2537 2538 /* Flag to indicate that master has done the frame init*/ 2539 WORD32 enc_master_done_frame_init[MAX_NUM_ENC_LOOP_PARALLEL]; 2540 2541 /* Counter to keep track of num of thrds exiting critical section*/ 2542 WORD32 num_thrds_exited[MAX_NUM_ENC_LOOP_PARALLEL]; 2543 2544 /* Counter to keep track of num of thrds exiting critical section for re-encode*/ 2545 WORD32 num_thrds_exited_for_reenc; 2546 2547 /* Array to store the curr qp for ping and pong instance*/ 2548 WORD32 cur_qp[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2549 2550 /* Pointers to store output buffers for ping and pong instance*/ 2551 frm_proc_ent_cod_ctxt_t *ps_curr_out_enc_grp[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2552 2553 /* Pointer to store input buffers for me*/ 2554 pre_enc_me_ctxt_t *aps_cur_inp_me_prms[MAX_NUM_ME_PARALLEL]; 2555 2556 /*pointers to store output buffers from me */ 2557 me_enc_rdopt_ctxt_t *aps_cur_out_me_prms[NUM_ME_ENC_BUFS]; 2558 2559 /*pointers to store input buffers to enc-rdopt */ 2560 me_enc_rdopt_ctxt_t *aps_cur_inp_enc_prms[NUM_ME_ENC_BUFS]; 2561 2562 /*Shared memory for Sub Pic rc */ 2563 /*Qscale calulated by sub pic rc bit control for Intra Pic*/ 2564 WORD32 ai4_curr_qp_estimated[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2565 2566 /*Header bits error by sub pic rc bit control*/ 2567 float af_acc_hdr_bits_scale_err[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2568 2569 /*Accumalated ME SAD for NCTB*/ 2570 LWORD64 ai8_nctb_me_sad[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2571 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2572 2573 /*Accumalated IPE SAD for NCTB*/ 2574 LWORD64 ai8_nctb_ipe_sad[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2575 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2576 2577 /*Accumalated L0 IPE SAD for NCTB*/ 2578 LWORD64 ai8_nctb_l0_ipe_sad[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2579 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2580 2581 /*Accumalated Activity Factor for NCTB*/ 2582 LWORD64 ai8_nctb_act_factor[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2583 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2584 2585 /*Accumalated Ctb counter across all threads*/ 2586 WORD32 ai4_ctb_ctr[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2587 2588 /*Bits threshold reached for across all threads*/ 2589 WORD32 ai4_threshold_reached[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2590 2591 /*To hold the Previous In-frame RC chunk QP*/ 2592 WORD32 ai4_prev_chunk_qp[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2593 2594 /*Accumalated Ctb counter across all threads*/ 2595 WORD32 ai4_acc_ctb_ctr[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2596 2597 /*Flag to check if thread is initialized */ 2598 WORD32 ai4_thrd_id_valid_flag[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2599 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2600 2601 /*Accumalated Ctb counter across all threads*/ 2602 //WORD32 ai4_acc_qp[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES][MAX_NUM_FRM_PROC_THRDS_ENC]; 2603 2604 /*Accumalated bits consumed for nctbs across all threads*/ 2605 LWORD64 ai8_nctb_bits_consumed[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2606 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2607 2608 /*Accumalated hdr bits consumed for nctbs across all threads*/ 2609 LWORD64 ai8_nctb_hdr_bits_consumed[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2610 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2611 2612 /*Accumalated l0 mpm bits consumed for nctbs across all threads*/ 2613 LWORD64 ai8_nctb_mpm_bits_consumed[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2614 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2615 2616 /*Accumalated bits consumed for total ctbs across all threads*/ 2617 LWORD64 ai8_acc_bits_consumed[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2618 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2619 2620 /*Accumalated bits consumed for total ctbs across all threads*/ 2621 LWORD64 ai8_acc_bits_mul_qs_consumed[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES] 2622 [MAX_NUM_FRM_PROC_THRDS_ENC]; 2623 2624 /*Qscale calulated by sub pic rc bit control */ 2625 WORD32 ai4_curr_qp_acc[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2626 /* End of Sub pic rc variables */ 2627 2628 /* Pointers to store input (only L0 IPE)*/ 2629 pre_enc_L0_ipe_encloop_ctxt_t *aps_cur_L0_ipe_inp_prms[MAX_NUM_ME_PARALLEL]; 2630 2631 /** Slice header parameters */ 2632 /** temporarily store the slice header parameters in enc-loop thread 2633 which will be copied to curr_out when buffer is aquired */ 2634 //slice_header_t as_slice_hdr[PING_PONG_BUF]; 2635 2636 /* Array to store input buffer ids for ping and pong instances*/ 2637 //WORD32 in_buf_id[PING_PONG_BUF]; 2638 2639 /* Array tp store L0 IPE input buf ids*/ 2640 WORD32 ai4_in_frm_l0_ipe_id[MAX_NUM_ME_PARALLEL]; 2641 2642 /* Array to store output buffer ids for ping and pong instances*/ 2643 WORD32 out_buf_id[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; //[PING_PONG_BUF]; 2644 2645 /* Variable to indicate ping and pong instance for each thread*/ 2646 WORD32 ping_pong[MAX_NUM_FRM_PROC_THRDS_ENC]; 2647 2648 /* Array of pointers to store the recon buf pointers*/ 2649 iv_enc_recon_data_buffs_t 2650 *ps_recon_out[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; //[PING_PONG_BUF]; 2651 2652 /* Array of pointers to frame recon for ping and pong instances*/ 2653 recon_pic_buf_t *ps_frm_recon[NUM_ME_ENC_BUFS][IHEVCE_MAX_NUM_BITRATES]; 2654 2655 /* Array of recon buffer ids for ping and pong instance*/ 2656 WORD32 recon_buf_id[NUM_ME_ENC_BUFS][IHEVCE_MAX_NUM_BITRATES]; //[PING_PONG_BUF]; 2657 2658 /* End flag to signal end of all the frames in me*/ 2659 WORD32 me_end_flag; 2660 2661 /* End flag to signal end of all the frames in enc*/ 2662 WORD32 enc_end_flag; 2663 2664 /* Counter to keep track of num thrds done*/ 2665 WORD32 num_thrds_done; 2666 2667 /* Flags to keep track of dumped ping pong recon buffer*/ 2668 WORD32 is_recon_dumped[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; //[PING_PONG_BUF]; 2669 2670 /* Flags to keep track of dumped ping pong output buffer*/ 2671 WORD32 is_out_buf_freed[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; //[PING_PONG_BUF]; 2672 2673 /* flag to produce output buffer by the thread who ever is finishing 2674 enc-loop processing first, so that the entropy thread can start processing */ 2675 WORD32 ai4_produce_outbuf[MAX_NUM_ENC_LOOP_PARALLEL][IHEVCE_MAX_NUM_BITRATES]; 2676 2677 /* Flags to keep track of dumped ping pong input buffer*/ 2678 WORD32 is_in_buf_freed[MAX_NUM_ENC_LOOP_PARALLEL]; 2679 2680 /* Flags to keep track of dumped ping pong L0 IPE to enc buffer*/ 2681 WORD32 is_L0_ipe_in_buf_freed[MAX_NUM_ENC_LOOP_PARALLEL]; 2682 2683 /** Dependency manager for checking whether prev. EncLoop done before 2684 current frame EncLoop starts */ 2685 void *apv_dep_mngr_prev_frame_done[MAX_NUM_ENC_LOOP_PARALLEL]; 2686 2687 /** Dependency manager for checking whether prev. EncLoop done before 2688 re-encode of the current frame */ 2689 void *pv_dep_mngr_prev_frame_enc_done_for_reenc; 2690 2691 /** Dependency manager for checking whether prev. me done before 2692 current frame me starts */ 2693 void *apv_dep_mngr_prev_frame_me_done[MAX_NUM_ME_PARALLEL]; 2694 2695 /** ME coarsest layer JOB queue type */ 2696 WORD32 i4_me_coarsest_lyr_type; 2697 2698 /** number of encloop frames running in parallel */ 2699 WORD32 i4_num_enc_loop_frm_pllel; 2700 2701 /** number of me frames running in parallel */ 2702 WORD32 i4_num_me_frm_pllel; 2703 2704 /*-----------------------------------------------------------------------*/ 2705 /*--------- Params related to pre-enc stage -----------------------------*/ 2706 /*-----------------------------------------------------------------------*/ 2707 2708 /** Number of processing threads created runtime in pre encode group */ 2709 WORD32 i4_num_pre_enc_proc_thrds; 2710 2711 /** Number of processing threads active for a given frame 2712 * This value will be monitored at frame level, so as to 2713 * have provsion for increasing / decreasing threads 2714 * based on Load balance b/w stage in encoder 2715 */ 2716 WORD32 i4_num_active_pre_enc_thrds; 2717 /** number of threads that have done processing the current frame 2718 Use to find out the last thread that is coming out of pre-enc processing 2719 so that the last thread can do de-init of pre-enc stage */ 2720 WORD32 ai4_num_thrds_processed_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2721 2722 /** number of threads that have done processing the current frame 2723 Use to find out the first thread and last inoder to get qp query. As the query 2724 is not read only , the quer should be done only once by thread that comes first 2725 and other threads should get same value*/ 2726 WORD32 ai4_num_thrds_processed_L0_ipe_qp_init[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2727 2728 /** number of threads that have done proessing decomp_intra 2729 Used to find out the last thread that is coming out so that 2730 the last thread can set flag for decomp_pre_intra_finish */ 2731 WORD32 ai4_num_thrds_processed_decomp[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2732 2733 /** number of threads that have done proessing coarse_me 2734 Used to find out the last thread that is coming out so that 2735 the last thread can set flag for coarse_me_finish */ 2736 WORD32 ai4_num_thrds_processed_coarse_me[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2737 2738 /*Flag to indicate if current instance (frame)'s Decomp_pre_intra and Coarse_ME is done. 2739 Used to check if previous frame is done proecessing decom_pre_intra and coarse_me */ 2740 WORD32 ai4_decomp_coarse_me_complete_flag[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2741 2742 /** Dependency manager for checking whether prev. frame decomp_intra 2743 done before current frame decomp_intra starts */ 2744 void *pv_dep_mngr_prev_frame_pre_enc_l1; 2745 2746 /** Dependency manager for checking whether prev. frame L0 IPE done before 2747 current frame L0 IPE starts */ 2748 void *pv_dep_mngr_prev_frame_pre_enc_l0; 2749 2750 /** Dependency manager for checking whether prev. frame coarse_me done before 2751 current frame coarse_me starts */ 2752 void *pv_dep_mngr_prev_frame_pre_enc_coarse_me; 2753 2754 /** flag to indicate if pre_enc_init is done for current frame */ 2755 WORD32 ai4_pre_enc_init_done[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2756 2757 /** flag to indicate if pre_enc_hme_init is done for current frame */ 2758 WORD32 ai4_pre_enc_hme_init_done[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2759 2760 /** flag to indicate if pre_enc_deinit is done for current frame */ 2761 WORD32 ai4_pre_enc_deinit_done[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2762 2763 /** Flag to indicate the end of processing when all the frames are done processing */ 2764 WORD32 ai4_end_flag_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2765 2766 /** Flag to indicate the control blocking mode indicating input command to pre-enc 2767 group should be blocking or unblocking */ 2768 WORD32 i4_ctrl_blocking_mode; 2769 2770 /** Current input pointer */ 2771 ihevce_lap_enc_buf_t *aps_curr_inp_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2772 2773 WORD32 i4_last_inp_buf; 2774 2775 /* buffer id for input buffer */ 2776 WORD32 ai4_in_buf_id_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2777 2778 /** Current output pointer */ 2779 pre_enc_me_ctxt_t *aps_curr_out_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2780 2781 /*Current L0 IPE to enc output pointer */ 2782 pre_enc_L0_ipe_encloop_ctxt_t *ps_L0_IPE_curr_out_pre_enc; 2783 2784 /** buffer id for output buffer */ 2785 WORD32 ai4_out_buf_id_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2786 2787 /** buffer id for L0 IPE enc buffer*/ 2788 WORD32 i4_L0_IPE_out_buf_id; 2789 2790 /** current frame recon pointer */ 2791 recon_pic_buf_t *aps_frm_recon_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2792 2793 /** Current picture Qp */ 2794 WORD32 ai4_cur_frame_qp_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2795 2796 /** Decomp layer buffers indicies */ 2797 WORD32 ai4_decomp_lyr_buf_idx[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2798 2799 /*since it is guranteed that cur frame ipe will not start unless prev frame ipe is completly done, 2800 an array of MAX_PRE_ENC_STAGGER might not be required*/ 2801 WORD32 i4_qp_update_l0_ipe; 2802 2803 /** Current picture encoded is the last picture to be encoded flag */ 2804 WORD32 i4_last_pic_flag; 2805 2806 /** Mutex for ensuring thread safety of the access of Job queues in decomp stage */ 2807 void *pv_job_q_mutex_hdl_pre_enc_decomp; 2808 2809 /** Mutex for ensuring thread safety of the access of Job queues in HME group */ 2810 void *pv_job_q_mutex_hdl_pre_enc_hme; 2811 2812 /** Mutex for ensuring thread safety of the access of Job queues in l0 ipe stage */ 2813 void *pv_job_q_mutex_hdl_pre_enc_l0ipe; 2814 2815 /** mutex handle for pre-enc init */ 2816 void *pv_mutex_hdl_pre_enc_init; 2817 2818 /** mutex handle for pre-enc decomp deinit */ 2819 void *pv_mutex_hdl_pre_enc_decomp_deinit; 2820 2821 /** mutex handle for pre enc hme init */ 2822 void *pv_mutex_hdl_pre_enc_hme_init; 2823 2824 /** mutex handle for pre-enc hme deinit */ 2825 void *pv_mutex_hdl_pre_enc_hme_deinit; 2826 2827 /*qp qurey before l0 ipe is done by multiple frame*/ 2828 /** mutex handle for L0 ipe(pre-enc init)*/ 2829 void *pv_mutex_hdl_l0_ipe_init; 2830 2831 /** mutex handle for pre-enc deinit */ 2832 void *pv_mutex_hdl_pre_enc_deinit; 2833 2834 /** Array of Semaphore handles (for each frame processing threads ) */ 2835 void *apv_pre_enc_thrd_sem_handle[MAX_NUM_FRM_PROC_THRDS_ENC]; 2836 /** array which will tell the number of CTB processed in each row, 2837 * used for Row level sync in IPE pass 2838 */ 2839 WORD32 ai4_ctbs_in_row_proc_ipe_pass[MAX_NUM_CTB_ROWS_FRM]; 2840 2841 /** Job Queue Memory pre encode */ 2842 job_queue_t *aps_job_q_pre_enc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME]; 2843 2844 /** Array of Job Queue handles enc group */ 2845 job_queue_handle_t as_job_que_preenc_hdls[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME] 2846 [NUM_PRE_ENC_JOBS_QUES]; 2847 2848 /* accumulate intra sad across all thread to get qp before L0 IPE*/ 2849 WORD32 ai4_intra_satd_acc[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME] 2850 [MAX_NUM_FRM_PROC_THRDS_PRE_ENC]; 2851 2852 WORD32 i4_delay_pre_me_btw_l0_ipe; 2853 2854 /*** This variable has the maximum delay between hme and l0ipe ***/ 2855 /*** This is used for wrapping around L0IPE index ***/ 2856 WORD32 i4_max_delay_pre_me_btw_l0_ipe; 2857 2858 /* This is to register the handles of Dep Mngr b/w EncLoop and ME */ 2859 /* This is used to delete the Mngr at the end */ 2860 void *apv_dep_mngr_encloop_dep_me[NUM_ME_ENC_BUFS]; 2861 /*flag to track buffer in me/enc que is produced or not*/ 2862 WORD32 ai4_me_enc_buff_prod_flag[NUM_ME_ENC_BUFS]; 2863 2864 /*out buf que id for me */ 2865 WORD32 ai4_me_out_buf_id[NUM_ME_ENC_BUFS]; 2866 2867 /*in buf que id for enc from me*/ 2868 WORD32 i4_enc_in_buf_id[NUM_ME_ENC_BUFS]; 2869 2870 /* This is used to tell whether the free of recon buffers are done or not */ 2871 WORD32 i4_is_recon_free_done; 2872 2873 /* index for DVSR population */ 2874 WORD32 i4_idx_dvsr_p; 2875 WORD32 aai4_l1_pre_intra_done[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME] 2876 [(HEVCE_MAX_HEIGHT >> 1) / 8]; 2877 2878 WORD32 i4_rc_l0_qp; 2879 2880 /* Used for mres single out cases. Checks whether a particular resolution is active or passive */ 2881 /* Only one resolution should be active for mres_single_out case */ 2882 WORD32 *pi4_active_res_id; 2883 2884 /** 2885 * Sub Pic bit control mutex lock handle 2886 */ 2887 void *pv_sub_pic_rc_mutex_lock_hdl; 2888 2889 void *pv_sub_pic_rc_for_qp_update_mutex_lock_hdl; 2890 2891 WORD32 i4_encode; 2892 WORD32 i4_in_frame_rc_enabled; 2893 WORD32 i4_num_re_enc; 2894 2895 } multi_thrd_ctxt_t; 2896 2897 /** 2898 * @brief Structure to describe tile params 2899 */ 2900 typedef struct 2901 { 2902 /* flag to indicate tile encoding enabled/disabled */ 2903 WORD32 i4_tiles_enabled_flag; 2904 2905 /* flag to indicate unifrom spacing of tiles */ 2906 WORD32 i4_uniform_spacing_flag; 2907 2908 /* num tiles in a tile-row. num tiles in tile-col */ 2909 WORD32 i4_num_tile_cols; 2910 WORD32 i4_num_tile_rows; 2911 2912 /* Curr tile width and height*/ 2913 WORD32 i4_curr_tile_width; 2914 WORD32 i4_curr_tile_height; 2915 2916 /* Curr tile width and heignt in CTB units*/ 2917 WORD32 i4_curr_tile_wd_in_ctb_unit; 2918 WORD32 i4_curr_tile_ht_in_ctb_unit; 2919 2920 /* frame resolution */ 2921 //WORD32 i4_frame_width; /* encode-width */ 2922 //WORD32 i4_frame_height; /* encode-height */ 2923 2924 /* total num of tiles "in frame" */ 2925 WORD32 i4_num_tiles; 2926 2927 /* Curr tile id. Assigned by raster scan order in a frame */ 2928 WORD32 i4_curr_tile_id; 2929 2930 /* x-pos of first ctb of the slice in ctb */ 2931 /* y-pos of first ctb of the slice in ctb */ 2932 WORD32 i4_first_ctb_x; 2933 WORD32 i4_first_ctb_y; 2934 2935 /* x-pos of first ctb of the slice in samples */ 2936 /* y-pos of first ctb of the slice in samples */ 2937 WORD32 i4_first_sample_x; 2938 WORD32 i4_first_sample_y; 2939 2940 } ihevce_tile_params_t; 2941 2942 /** 2943 ****************************************************************************** 2944 * @brief Encoder context structure 2945 ****************************************************************************** 2946 */ 2947 2948 typedef struct 2949 { 2950 /** 2951 * vps parameters 2952 */ 2953 vps_t as_vps[IHEVCE_MAX_NUM_BITRATES]; 2954 2955 /** 2956 * sps parameters 2957 */ 2958 sps_t as_sps[IHEVCE_MAX_NUM_BITRATES]; 2959 2960 /** 2961 * pps parameters 2962 * Required for each bitrate separately, mainly because 2963 * init qp etc parameters needs to be different for each instance 2964 */ 2965 pps_t as_pps[IHEVCE_MAX_NUM_BITRATES]; 2966 2967 /** 2968 * Rate control mutex lock handle 2969 */ 2970 void *pv_rc_mutex_lock_hdl; 2971 2972 /** frame level cu analyse buffer pointer for ME 2973 * ME will get ps_ctb_analyse structure populated with ps_cu pointers 2974 * pointing to ps_cu_analyse buffer from IPE. 2975 */ 2976 //cu_analyse_t *ps_cu_analyse_inter[PING_PONG_BUF]; 2977 2978 /** 2979 * CTB frame context between encoder (producer) and entropy (consumer) 2980 */ 2981 enc_q_ctxt_t s_enc_ques; 2982 2983 /** 2984 * Encoder memory manager ctxt 2985 */ 2986 enc_mem_mngr_ctxt s_mem_mngr; 2987 2988 /** 2989 * Semaphores of all the threads created in HLE 2990 * and Que handle for buffers b/w frame process and entropy 2991 */ 2992 thrd_que_sem_hdl_t s_thrd_sem_ctxt; 2993 2994 /** 2995 * Reference /recon buffer Que pointer 2996 */ 2997 recon_pic_buf_t **pps_recon_buf_q[IHEVCE_MAX_NUM_BITRATES]; 2998 2999 /** 3000 * Number of buffers in Recon buffer queue 3001 */ 3002 WORD32 ai4_num_buf_recon_q[IHEVCE_MAX_NUM_BITRATES]; 3003 3004 /** 3005 * Reference / recon buffer Que pointer for Pre Encode group 3006 * this will be just a container and no buffers will be allcoated 3007 */ 3008 recon_pic_buf_t **pps_pre_enc_recon_buf_q; 3009 3010 /** 3011 * Number of buffers in Recon buffer queue 3012 */ 3013 WORD32 i4_pre_enc_num_buf_recon_q; 3014 3015 /** 3016 * frame level CTB parameters and worst PU CU and TU in a CTB row 3017 */ 3018 frm_ctb_ctxt_t s_frm_ctb_prms; 3019 3020 /* 3021 * Moudle ctxt pointers of all modules 3022 */ 3023 module_ctxt_t s_module_ctxt; 3024 3025 /* 3026 * LAP static parameters 3027 */ 3028 ihevce_lap_static_params_t s_lap_stat_prms; 3029 3030 /* 3031 * Run time dynamic source params 3032 */ 3033 3034 ihevce_src_params_t s_runtime_src_prms; 3035 3036 /* 3037 *Target params 3038 */ 3039 ihevce_tgt_params_t s_runtime_tgt_params; 3040 3041 /* 3042 * Run time dynamic coding params 3043 */ 3044 ihevce_coding_params_t s_runtime_coding_prms; 3045 3046 /** 3047 * Pointer to static config params 3048 */ 3049 ihevce_static_cfg_params_t *ps_stat_prms; 3050 3051 /** 3052 * the following structure members used for copying recon buf info 3053 * in case of duplicate pics 3054 */ 3055 3056 /** 3057 * Array of reference picture list for pre enc group 3058 * Separate list for ping_pong instnaces 3059 * 2=> ref_pic_list0 and ref_pic_list1 3060 */ 3061 recon_pic_buf_t as_pre_enc_ref_lists[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME][2] 3062 [HEVCE_MAX_REF_PICS * 2]; 3063 3064 /** 3065 * Array of reference picture list for pre enc group 3066 * Separate list for ping_pong instnaces 3067 * 2=> ref_pic_list0 and ref_pic_list1 3068 */ 3069 recon_pic_buf_t *aps_pre_enc_ref_lists[MAX_PRE_ENC_STAGGER + NUM_BUFS_DECOMP_HME][2] 3070 [HEVCE_MAX_REF_PICS * 2]; 3071 3072 /** 3073 * Number of input frames per input queue 3074 */ 3075 WORD32 i4_num_input_buf_per_queue; 3076 3077 /** 3078 * poc of the Clean Random Access(CRA)Ipic 3079 */ 3080 WORD32 i4_cra_poc; 3081 3082 /** Number of ref pics in list 0 for any given frame */ 3083 WORD32 i4_num_ref_l0; 3084 3085 /** Number of ref pics in list 1 for any given frame */ 3086 WORD32 i4_num_ref_l1; 3087 3088 /** Number of active ref pics in list 0 for cur frame */ 3089 WORD32 i4_num_ref_l0_active; 3090 3091 /** Number of active ref pics in list 1 for cur frame */ 3092 WORD32 i4_num_ref_l1_active; 3093 3094 /** Number of ref pics in list 0 for any given frame pre encode stage */ 3095 WORD32 i4_pre_enc_num_ref_l0; 3096 3097 /** Number of ref pics in list 1 for any given frame pre encode stage */ 3098 WORD32 i4_pre_enc_num_ref_l1; 3099 3100 /** Number of active ref pics in list 0 for cur frame pre encode stage */ 3101 WORD32 i4_pre_enc_num_ref_l0_active; 3102 3103 /** Number of active ref pics in list 1 for cur frame pre encode stage */ 3104 WORD32 i4_pre_enc_num_ref_l1_active; 3105 3106 /** 3107 * working mem to be used for frm level activities 3108 * One example is interplation at frame level. This requires memory 3109 * of (max width + 16) * (max_height + 7 + 16 ) * 2 bytes. 3110 * This is so since we generate interp output for max_width + 16 x 3111 * max_height + 16, and then the intermediate output is 16 bit and 3112 * is max_height + 16 + 7 rows 3113 */ 3114 UWORD8 *pu1_frm_lvl_wkg_mem; 3115 3116 /** 3117 * Multi thread processing context 3118 * This memory contains the variables and pointers shared across threads 3119 * in enc-group and pre-enc-group 3120 */ 3121 multi_thrd_ctxt_t s_multi_thrd; 3122 3123 /** I/O Queues created status */ 3124 WORD32 i4_io_queues_created; 3125 3126 WORD32 i4_end_flag; 3127 3128 /** number of bit-rate instances running */ 3129 WORD32 i4_num_bitrates; 3130 3131 /** number of enc frames running in parallel */ 3132 WORD32 i4_num_enc_loop_frm_pllel; 3133 3134 /*ref bitrate id*/ 3135 WORD32 i4_ref_mbr_id; 3136 3137 /* Flag to indicate app, that end of processing has reached */ 3138 WORD32 i4_frame_limit_reached; 3139 3140 /*Structure to store the function selector 3141 * pointers for common and encoder */ 3142 func_selector_t s_func_selector; 3143 3144 /*ref resolution id*/ 3145 WORD32 i4_resolution_id; 3146 3147 /*hle context*/ 3148 void *pv_hle_ctxt; 3149 3150 rc_quant_t s_rc_quant; 3151 /*ME cost of P pic stored for the next ref B pic*/ 3152 //LWORD64 i8_acc_me_cost_of_p_pic_for_b_pic[2]; 3153 3154 UWORD32 u4_cur_pic_encode_cnt; 3155 UWORD32 u4_cur_pic_encode_cnt_dbp; 3156 /*past 2 p pics high complexity status*/ 3157 WORD32 ai4_is_past_pic_complex[2]; 3158 3159 WORD32 i4_is_I_reset_done; 3160 WORD32 i4_past_RC_reset_count; 3161 3162 WORD32 i4_future_RC_reset; 3163 3164 WORD32 i4_past_RC_scd_reset_count; 3165 3166 WORD32 i4_future_RC_scd_reset; 3167 WORD32 i4_poc_reset_values; 3168 3169 /*Place holder to store the length of LAP in first pass*/ 3170 /** Number of frames to look-ahead for RC by - 3171 * counts 2 fields as one frame for interlaced 3172 */ 3173 WORD32 i4_look_ahead_frames_in_first_pass; 3174 3175 WORD32 ai4_mod_factor_derived_by_variance[2]; 3176 float f_strength; 3177 3178 /*for B frames use the avg activity 3179 from the layer 0 (I or P) which is the average over 3180 Lap2 window*/ 3181 LWORD64 ai8_lap2_8x8_avg_act_from_T0[2]; 3182 3183 LWORD64 ai8_lap2_16x16_avg_act_from_T0[3]; 3184 3185 LWORD64 ai8_lap2_32x32_avg_act_from_T0[3]; 3186 3187 /*for B frames use the log of avg activity 3188 from the layer 0 (I or P) which is the average over 3189 Lap2 window*/ 3190 long double ald_lap2_8x8_log_avg_act_from_T0[2]; 3191 3192 long double ald_lap2_16x16_log_avg_act_from_T0[3]; 3193 3194 long double ald_lap2_32x32_log_avg_act_from_T0[3]; 3195 3196 ihevce_tile_params_t *ps_tile_params_base; 3197 3198 WORD32 ai4_column_width_array[MAX_TILE_COLUMNS]; 3199 3200 WORD32 ai4_row_height_array[MAX_TILE_ROWS]; 3201 3202 /* Architecture */ 3203 IV_ARCH_T e_arch_type; 3204 3205 UWORD8 u1_is_popcnt_available; 3206 3207 WORD32 i4_active_scene_num; 3208 3209 WORD32 i4_max_fr_enc_loop_parallel_rc; 3210 WORD32 ai4_rc_query[IHEVCE_MAX_NUM_BITRATES]; 3211 WORD32 i4_active_enc_frame_id; 3212 3213 /** 3214 * LAP interface ctxt pointer 3215 */ 3216 void *pv_lap_interface_ctxt; 3217 3218 /* If enable, enables blu ray compatibility of op*/ 3219 WORD32 i4_blu_ray_spec; 3220 3221 } enc_ctxt_t; 3222 3223 /** 3224 ****************************************************************************** 3225 * @brief This struct contains the inter CTB params needed for the decision 3226 * of the best inter CU results 3227 ****************************************************************************** 3228 */ 3229 typedef struct 3230 { 3231 hme_pred_buf_mngr_t s_pred_buf_mngr; 3232 3233 /** X and y offset of ctb w.r.t. start of pic */ 3234 WORD32 i4_ctb_x_off; 3235 WORD32 i4_ctb_y_off; 3236 3237 /** 3238 * Pred buffer ptr, updated inside subpel refinement process. This 3239 * location passed to the leaf fxn for copying the winner pred buf 3240 */ 3241 UWORD8 **ppu1_pred; 3242 3243 /** Working mem passed to leaf fxns */ 3244 UWORD8 *pu1_wkg_mem; 3245 3246 /** prediction buffer stride fo rleaf fxns to copy the pred winner buf */ 3247 WORD32 i4_pred_stride; 3248 3249 /** Stride of input buf, updated inside subpel fxn */ 3250 WORD32 i4_inp_stride; 3251 3252 /** stride of recon buffer */ 3253 WORD32 i4_rec_stride; 3254 3255 /** Indicates if bi dir is enabled or not */ 3256 WORD32 i4_bidir_enabled; 3257 3258 /** 3259 * Total number of references of current picture which is enocded 3260 */ 3261 UWORD8 u1_num_ref; 3262 3263 /** Recon Pic buffer pointers for L0 list */ 3264 recon_pic_buf_t **pps_rec_list_l0; 3265 3266 /** Recon Pic buffer pointers for L1 list */ 3267 recon_pic_buf_t **pps_rec_list_l1; 3268 3269 /** 3270 * These pointers point to modified input, one each for one ref idx. 3271 * Instead of weighting the reference, we weight the input with inverse 3272 * wt and offset for list 0 and list 1. 3273 */ 3274 UWORD8 *apu1_wt_inp[2][MAX_NUM_REF]; 3275 3276 /* Since ME uses weighted inputs, we use reciprocal of the actual weights */ 3277 /* that are signaled in the bitstream */ 3278 WORD32 *pi4_inv_wt; 3279 WORD32 *pi4_inv_wt_shift_val; 3280 3281 /* Map between L0 Reference indices and LC indices */ 3282 WORD8 *pi1_past_list; 3283 3284 /* Map between L1 Reference indices and LC indices */ 3285 WORD8 *pi1_future_list; 3286 3287 /** 3288 * Points to the non-weighted input data for the current CTB 3289 */ 3290 UWORD8 *pu1_non_wt_inp; 3291 3292 /** 3293 * Store the pred lambda and lamda_qshifts for all the reference indices 3294 */ 3295 WORD32 i4_lamda; 3296 3297 UWORD8 u1_lamda_qshift; 3298 3299 WORD32 wpred_log_wdc; 3300 3301 /** 3302 * Number of active references in l0 3303 */ 3304 UWORD8 u1_num_active_ref_l0; 3305 3306 /** 3307 * Number of active references in l1 3308 */ 3309 UWORD8 u1_num_active_ref_l1; 3310 3311 /** The max_depth for inter tu_tree */ 3312 UWORD8 u1_max_tr_depth; 3313 3314 /** Quality Preset */ 3315 WORD8 i1_quality_preset; 3316 3317 /** SATD or SAD */ 3318 UWORD8 u1_use_satd; 3319 3320 /* Frame level QP */ 3321 WORD32 i4_qstep_ls8; 3322 3323 /* Pointer to an array of PU level src variances */ 3324 UWORD32 *pu4_src_variance; 3325 3326 WORD32 i4_alpha_stim_multiplier; 3327 3328 UWORD8 u1_is_cu_noisy; 3329 3330 ULWORD64 *pu8_part_src_sigmaX; 3331 3332 ULWORD64 *pu8_part_src_sigmaXSquared; 3333 3334 UWORD8 u1_max_2nx2n_tu_recur_cands; 3335 3336 } inter_ctb_prms_t; 3337 3338 /*****************************************************************************/ 3339 /* Extern Variable Declarations */ 3340 /*****************************************************************************/ 3341 extern const double lamda_modifier_for_I_pic[8]; 3342 3343 /*****************************************************************************/ 3344 /* Extern Function Declarations */ 3345 /*****************************************************************************/ 3346 3347 #endif /* _IHEVCE_ENC_STRUCTS_H_ */ 3348
