1 /* 2 * Copyright (c) 2017-2021, Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 //! 23 //! \file codechal_encode_avc_base.h 24 //! \brief Defines base class for AVC encoder. 25 //! 26 27 #ifndef __CODECHAL_ENCODE_AVC_BASE_H__ 28 #define __CODECHAL_ENCODE_AVC_BASE_H__ 29 30 #include "codechal_encoder_base.h" 31 #include "codechal_kernel_hme.h" 32 #if USE_CODECHAL_DEBUG_TOOL 33 #include "codechal_debug_encode_par.h" 34 #include "codechal_debug_kernel.h" 35 #endif 36 37 #define CODECHAL_ENCODE_AVC_INVALID_ROUNDING 0xFF 38 #define CODECHAL_ENCODE_AVC_NUM_SYNC_TAGS 64 39 #define CODECHAL_ENCODE_AVC_INIT_DSH_SIZE MHW_PAGE_SIZE * 3 40 #define CODECHAL_ENCODE_AVC_VDENC_MIN_ICQ_QUALITYFACTOR 11 41 #define CODECHAL_ENCODE_AVC_DEFAULT_AVBR_ACCURACY 30 42 #define CODECHAL_ENCODE_AVC_MIN_AVBR_CONVERGENCE 100 43 #define CODECHAL_ENCODE_AVC_DEFAULT_AVBR_CONVERGENCE 150 44 #define CODECHAL_ENCODE_AVC_REF_PIC_SELECT_ENTRIES (CODEC_AVC_MAX_NUM_REF_FRAME + 1) // one extra for current picture 45 // Invalid AVC PicID 46 #define CODECHAL_ENCODE_AVC_INVALID_PIC_ID CODEC_AVC_NUM_UNCOMPRESSED_SURFACE 47 48 #define CODECHAL_ENCODE_AVC_SFD_OUTPUT_BUFFER_SIZE_COMMON 128 49 50 #if USE_CODECHAL_DEBUG_TOOL 51 #define CODECHAL_DEBUG_ENCODE_AVC_NAL_START_CODE_SEI 0x00000106 52 #define CODECHAL_DEBUG_ENCODE_AVC_NAL_START_CODE_PPS 0x00000128 53 54 struct EncodeAvcPar 55 { 56 // DDI Params 57 uint8_t ProfileIDC; 58 uint8_t LevelIDC; 59 uint8_t CabacInitIDC; 60 uint8_t ChromaFormatIDC; 61 uint8_t PictureCodingType; 62 uint8_t MaxRefIdxL0; 63 uint8_t MaxRefIdxL1; 64 uint8_t MaxBRefIdxL0; 65 uint8_t BRCMethod; 66 uint8_t BRCType; 67 uint8_t DeblockingIDC; 68 uint8_t WeightedPred; 69 uint8_t WeightedBiPred; 70 char ChromaQpOffset; 71 char SecondChromaQpOffset; 72 char ISliceQP; 73 char PSliceQP; 74 char BSliceQP; 75 char DeblockingFilterAlpha; 76 char DeblockingFilterBeta; 77 bool EnableSEI; 78 bool DisableVUIHeader; 79 bool EnableWeightPredictionDetection; 80 bool EntropyCodingMode; 81 bool DirectInference; 82 bool Transform8x8Mode; 83 bool UseOrigAsRef; 84 bool BiSubMbPartMask; 85 uint16_t NumP; 86 uint16_t NumB; 87 uint16_t FrameRateM; 88 uint16_t FrameRateD; 89 uint16_t CRFQualityFactor; 90 uint32_t NumSlices; 91 uint32_t SliceHeight; 92 uint32_t NumSuperSlices; 93 uint32_t SuperSliceHeight[CODECHAL_ENCODE_AVC_MAX_SLICES_SUPPORTED]; 94 bool ConstrainedIntraPred; 95 uint8_t SliceMode; 96 int16_t hme0XOffset; 97 int16_t hme0YOffset; 98 int16_t hme1XOffset; 99 int16_t hme1YOffset; 100 101 // HME Params 102 uint8_t SuperCombineDist; 103 bool SuperHME; 104 bool UltraHME; 105 bool StreamInEnable; 106 uint8_t StreamInL0FromNewRef; 107 uint8_t StreamInL1FromNewRef; 108 109 // BRC init Params 110 bool MBBRCEnable; 111 bool MBRC; 112 uint16_t AvbrAccuracy; 113 uint16_t AvbrConvergence; 114 uint32_t BitRate; 115 uint32_t InitVbvFullnessInBit; 116 uint32_t MaxBitRate; 117 uint32_t VbvSzInBit; 118 uint32_t SlidingWindowEnable; 119 uint32_t SlidingWindowSize; 120 uint32_t SlidingWindowMaxRateRatio; 121 uint32_t LowDelayGoldenFrameBoost; 122 uint32_t TopQPDeltaThrforAdaptive2Pass; 123 uint32_t BotQPDeltaThrforAdaptive2Pass; 124 uint32_t TopFrmSzPctThrforAdaptive2Pass; 125 uint32_t BotFrmSzPctThrforAdaptive2Pass; 126 uint32_t MBHeaderCompensation; 127 uint32_t QPSelectMethodforFirstPass; 128 bool MBQpCtrl; 129 bool ICQReEncode; 130 bool AdaptiveCostAdjustEnable; 131 bool AdaptiveHMEExtension; 132 uint32_t QPMin; 133 uint32_t QPMax; 134 bool HrdConformanceCheckDisable; 135 uint8_t StreamInStaticRegion; 136 uint8_t ScenarioInfo; 137 bool SliceSizeWA; 138 uint32_t INumMbsLag; 139 uint32_t PNumMbsLag; 140 uint32_t LongTermInterval; 141 142 // BRC frame update Params 143 bool EnableMultipass; 144 uint8_t MaxNumPakPasses; 145 uint32_t UserMaxFrame; 146 uint32_t UserMaxFrameP; 147 bool FrameSkipEnable; 148 bool SceneChgDetectEn; 149 uint32_t SceneChgPrevIntraPctThresh; 150 uint32_t SceneChgCurIntraPctThresh; 151 uint32_t SceneChgWidth0; 152 uint32_t SceneChgWidth1; 153 bool Transform8x8PDisable; 154 uint32_t SliceSizeThr; 155 uint32_t SliceMaxSize; 156 157 // Enc Params 158 uint8_t SubPelMode; 159 uint8_t MaxLenSP; 160 uint8_t MEMethod; 161 uint8_t BMEMethod; 162 uint8_t HMECombineOverlap; 163 uint8_t SearchX; 164 uint8_t SearchY; 165 uint8_t BSearchX; 166 uint8_t BSearchY; 167 uint8_t SearchControl; 168 uint8_t BSearchControl; 169 uint8_t BiMixDisable; 170 uint32_t BiWeight; 171 bool DisableExtendedMvCostRange; 172 bool EnableAdaptiveSearch; 173 bool EnableFBRBypass; 174 bool BlockBasedSkip; 175 bool MADEnableFlag; 176 bool EnableMBFlatnessCheckOptimization; 177 bool EnableArbitrarySliceSize; 178 bool EnableWavefrontOptimization; 179 bool BSkipType; 180 bool EnableAdaptiveTxDecision; 181 bool EnablePerMBStaticCheck; 182 bool EnableAdaptiveSearchWindowSize; 183 bool EnableIntraCostScalingForStaticFrame; 184 uint32_t StaticFrameZMVPercent; 185 uint32_t StaticFrameIntraCostScalingRatioP; 186 uint32_t StaticFrameIntraCostScalingRatioB; 187 bool AdaptiveMvStreamIn; 188 uint32_t LargeMvThresh; 189 uint32_t LargeMvPctThreshold; 190 bool UniMixDisable; 191 bool DirectMode; 192 uint16_t RefThresh; 193 uint16_t MBTextureThreshold; 194 uint16_t TxDecisionThr; 195 uint32_t MRDisableQPCheck; 196 uint32_t AllFractional; 197 uint32_t DisableAllFractionalCheckForHighRes; 198 uint32_t HMECombineLen; 199 uint32_t HMEBCombineLen; 200 uint32_t FTQBasedSkip; 201 uint32_t MultiplePred; 202 uint32_t EnableAdaptiveIntraScaling; 203 uint32_t SurvivedSkipCost; 204 bool VDEncPerfMode; 205 bool VdencExtPakObjDisable; 206 bool PPMVDisable; 207 uint8_t LeftNbrPelMode; 208 uint8_t DisPSubPartMask; 209 uint8_t DisPSubMbMask; 210 uint8_t DisBSubPartMask; 211 uint8_t DisBSubMbMask; 212 uint8_t ImePredOverlapThr; 213 uint8_t MBSizeEstScalingRatioINTRA; 214 bool IntraMBHdrScaleFactor; 215 uint8_t MBSizeEstScalingRatioINTER; 216 bool InterMBHdrScaleFactor; 217 uint8_t PFrameMaxNumImePred; 218 uint8_t BFrameMaxNumImePred; 219 uint8_t HMERefWindowSize; 220 uint8_t IMELeftPredDep; 221 uint8_t NumFMECandCheck; 222 uint8_t PFrameImePredLargeSW; 223 uint8_t BFrameImePredLargeSW; 224 bool RdoChromaEnable; 225 uint16_t Intra4x4ModeMask; 226 uint16_t Intra8x8ModeMask; 227 bool RdoIntraChromaSearch; 228 uint8_t Intra16x16ModeMask; 229 uint8_t InitMBBudgetTr4x4; 230 bool ROIEnable; 231 uint8_t PFrameZeroCbfEn; 232 uint8_t BFrameZeroCbfEn; 233 uint8_t ForceIPCMMinQP; 234 uint8_t IntraTr4x4Percent; 235 bool MultiPassHmeEnable; 236 uint32_t IntraPredictionIFrame; 237 uint32_t IntraPrediction; 238 239 // PAK Params 240 uint8_t RoundingIntra; 241 bool RoundingIntraEnabled; 242 bool EnableAdaptiveRounding; 243 bool RoundingInterEnabled; 244 bool EnableAdaptiveTrellisQuantization; 245 bool TrellisQuantizationEnable; 246 bool TrellisQuantizationChromaDisable; 247 uint32_t RoundingInter; 248 uint32_t RoundingInterB; 249 uint32_t TrellisQuantizationRounding; 250 uint8_t FrmHdrEncodingFrequency; 251 bool ExtendedRhoDomainEn; 252 }; 253 #endif 254 255 static const uint8_t CodecHal_TargetUsageToMode_AVC[NUM_TARGET_USAGE_MODES] = 256 { encodeNormalMode, encodeQualityMode, encodeQualityMode, encodeNormalMode, 257 encodeNormalMode, encodeNormalMode, encodeNormalMode, encodePerformanceMode }; 258 259 typedef struct _CODEC_AVC_REF_PIC_SELECT_LIST 260 { 261 uint8_t FrameIdx; 262 MOS_SURFACE sBuffer; 263 } CODEC_AVC_REF_PIC_SELECT_LIST, *PCODEC_AVC_REF_PIC_SELECT_LIST; 264 265 typedef struct _CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS 266 { 267 PMOS_SURFACE psPreDeblockSurface; 268 PMOS_SURFACE psPostDeblockSurface; 269 PMOS_RESOURCE presMacroblockIldbStreamOutBuffer1; 270 PMOS_RESOURCE presMacroblockIldbStreamOutBuffer2; 271 272 bool bBrcEnabled; 273 PMHW_BATCH_BUFFER pImgStateBatchBuffer; 274 PMOS_RESOURCE presBrcHistoryBuffer; 275 276 bool bDeblockerStreamOutEnable; 277 bool bPostDeblockOutEnable; 278 bool bPreDeblockOutEnable; 279 bool bPerMBStreamOutEnable; 280 } CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS, *PCODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS; 281 282 typedef struct _CODECHAL_ENCODE_AVC_ME_CURBE 283 { 284 // DW0 285 union 286 { 287 struct 288 { 289 uint32_t SkipModeEn : MOS_BITFIELD_BIT( 0 ); 290 uint32_t AdaptiveEn : MOS_BITFIELD_BIT( 1 ); 291 uint32_t BiMixDis : MOS_BITFIELD_BIT( 2 ); 292 uint32_t : MOS_BITFIELD_RANGE( 3, 4 ); 293 uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT( 5 ); 294 uint32_t : MOS_BITFIELD_BIT( 6 ); 295 uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT( 7 ); 296 uint32_t : MOS_BITFIELD_RANGE( 8,23 ); 297 uint32_t EarlyImeStop : MOS_BITFIELD_RANGE( 24,31 ); 298 }; 299 struct 300 { 301 uint32_t Value; 302 }; 303 } DW0; 304 305 // DW1 306 union 307 { 308 struct 309 { 310 uint32_t MaxNumMVs : MOS_BITFIELD_RANGE( 0, 5 ); 311 uint32_t : MOS_BITFIELD_RANGE( 6,15 ); 312 uint32_t BiWeight : MOS_BITFIELD_RANGE( 16,21 ); 313 uint32_t : MOS_BITFIELD_RANGE( 22,27 ); 314 uint32_t UniMixDisable : MOS_BITFIELD_BIT( 28 ); 315 uint32_t : MOS_BITFIELD_RANGE( 29,31 ); 316 }; 317 struct 318 { 319 uint32_t Value; 320 }; 321 } DW1; 322 323 // DW2 324 union 325 { 326 struct 327 { 328 uint32_t MaxLenSP : MOS_BITFIELD_RANGE( 0, 7 ); 329 uint32_t MaxNumSU : MOS_BITFIELD_RANGE( 8,15 ); 330 uint32_t : MOS_BITFIELD_RANGE( 16,31 ); 331 }; 332 struct 333 { 334 uint32_t Value; 335 }; 336 } DW2; 337 338 // DW3 339 union 340 { 341 struct 342 { 343 uint32_t SrcSize : MOS_BITFIELD_RANGE( 0, 1 ); 344 uint32_t : MOS_BITFIELD_RANGE( 2, 3 ); 345 uint32_t MbTypeRemap : MOS_BITFIELD_RANGE( 4, 5 ); 346 uint32_t SrcAccess : MOS_BITFIELD_BIT( 6 ); 347 uint32_t RefAccess : MOS_BITFIELD_BIT( 7 ); 348 uint32_t SearchCtrl : MOS_BITFIELD_RANGE( 8,10 ); 349 uint32_t DualSearchPathOption : MOS_BITFIELD_BIT( 11 ); 350 uint32_t SubPelMode : MOS_BITFIELD_RANGE( 12,13 ); 351 uint32_t SkipType : MOS_BITFIELD_BIT( 14 ); 352 uint32_t DisableFieldCacheAlloc : MOS_BITFIELD_BIT( 15 ); 353 uint32_t InterChromaMode : MOS_BITFIELD_BIT( 16 ); 354 uint32_t FTEnable : MOS_BITFIELD_BIT( 17 ); 355 uint32_t BMEDisableFBR : MOS_BITFIELD_BIT( 18 ); 356 uint32_t BlockBasedSkipEnable : MOS_BITFIELD_BIT( 19 ); 357 uint32_t InterSAD : MOS_BITFIELD_RANGE( 20,21 ); 358 uint32_t IntraSAD : MOS_BITFIELD_RANGE( 22,23 ); 359 uint32_t SubMbPartMask : MOS_BITFIELD_RANGE( 24,30 ); 360 uint32_t : MOS_BITFIELD_BIT( 31 ); 361 }; 362 struct 363 { 364 uint32_t Value; 365 }; 366 } DW3; 367 368 // DW4 369 union 370 { 371 struct 372 { 373 uint32_t : MOS_BITFIELD_RANGE( 0, 7 ); 374 uint32_t PictureHeightMinus1 : MOS_BITFIELD_RANGE( 8,15 ); 375 uint32_t PictureWidth : MOS_BITFIELD_RANGE( 16,23 ); 376 uint32_t : MOS_BITFIELD_RANGE( 24,31 ); 377 }; 378 struct 379 { 380 uint32_t Value; 381 }; 382 } DW4; 383 384 // DW5 385 union 386 { 387 struct 388 { 389 uint32_t : MOS_BITFIELD_RANGE( 0, 7 ); 390 uint32_t QpPrimeY : MOS_BITFIELD_RANGE( 8,15 ); 391 uint32_t RefWidth : MOS_BITFIELD_RANGE( 16,23 ); 392 uint32_t RefHeight : MOS_BITFIELD_RANGE( 24,31 ); 393 }; 394 struct 395 { 396 uint32_t Value; 397 }; 398 } DW5; 399 400 // DW6 401 union 402 { 403 struct 404 { 405 uint32_t : MOS_BITFIELD_RANGE( 0, 2 ); 406 uint32_t WriteDistortions : MOS_BITFIELD_BIT( 3 ); 407 uint32_t UseMvFromPrevStep : MOS_BITFIELD_BIT( 4 ); 408 uint32_t : MOS_BITFIELD_RANGE( 5, 7 ); 409 uint32_t SuperCombineDist : MOS_BITFIELD_RANGE( 8,15 ); 410 uint32_t MaxVmvR : MOS_BITFIELD_RANGE( 16,31 ); 411 }; 412 struct 413 { 414 uint32_t Value; 415 }; 416 } DW6; 417 418 // DW7 419 union 420 { 421 struct 422 { 423 uint32_t : MOS_BITFIELD_RANGE( 0,15 ); 424 uint32_t MVCostScaleFactor : MOS_BITFIELD_RANGE( 16,17 ); 425 uint32_t BilinearEnable : MOS_BITFIELD_BIT( 18 ); 426 uint32_t SrcFieldPolarity : MOS_BITFIELD_BIT( 19 ); 427 uint32_t WeightedSADHAAR : MOS_BITFIELD_BIT( 20 ); 428 uint32_t AConlyHAAR : MOS_BITFIELD_BIT( 21 ); 429 uint32_t RefIDCostMode : MOS_BITFIELD_BIT( 22 ); 430 uint32_t : MOS_BITFIELD_BIT( 23 ); 431 uint32_t SkipCenterMask : MOS_BITFIELD_RANGE( 24,31 ); 432 }; 433 struct 434 { 435 uint32_t Value; 436 }; 437 } DW7; 438 439 // DW8 440 union 441 { 442 struct 443 { 444 uint32_t Mode0Cost : MOS_BITFIELD_RANGE( 0, 7 ); 445 uint32_t Mode1Cost : MOS_BITFIELD_RANGE( 8,15 ); 446 uint32_t Mode2Cost : MOS_BITFIELD_RANGE( 16,23 ); 447 uint32_t Mode3Cost : MOS_BITFIELD_RANGE( 24,31 ); 448 }; 449 struct 450 { 451 uint32_t Value; 452 }; 453 } DW8; 454 455 // DW9 456 union 457 { 458 struct 459 { 460 uint32_t Mode4Cost : MOS_BITFIELD_RANGE( 0, 7 ); 461 uint32_t Mode5Cost : MOS_BITFIELD_RANGE( 8,15 ); 462 uint32_t Mode6Cost : MOS_BITFIELD_RANGE( 16,23 ); 463 uint32_t Mode7Cost : MOS_BITFIELD_RANGE( 24,31 ); 464 }; 465 struct 466 { 467 uint32_t Value; 468 }; 469 } DW9; 470 471 // DW10 472 union 473 { 474 struct 475 { 476 uint32_t Mode8Cost : MOS_BITFIELD_RANGE( 0, 7 ); 477 uint32_t Mode9Cost : MOS_BITFIELD_RANGE( 8,15 ); 478 uint32_t RefIDCost : MOS_BITFIELD_RANGE( 16,23 ); 479 uint32_t ChromaIntraModeCost : MOS_BITFIELD_RANGE( 24,31 ); 480 }; 481 struct 482 { 483 uint32_t Value; 484 }; 485 } DW10; 486 487 // DW11 488 union 489 { 490 struct 491 { 492 uint32_t MV0Cost : MOS_BITFIELD_RANGE( 0, 7 ); 493 uint32_t MV1Cost : MOS_BITFIELD_RANGE( 8,15 ); 494 uint32_t MV2Cost : MOS_BITFIELD_RANGE( 16,23 ); 495 uint32_t MV3Cost : MOS_BITFIELD_RANGE( 24,31 ); 496 }; 497 struct 498 { 499 uint32_t Value; 500 }; 501 } DW11; 502 503 // DW12 504 union 505 { 506 struct 507 { 508 uint32_t MV4Cost : MOS_BITFIELD_RANGE( 0, 7 ); 509 uint32_t MV5Cost : MOS_BITFIELD_RANGE( 8,15 ); 510 uint32_t MV6Cost : MOS_BITFIELD_RANGE( 16,23 ); 511 uint32_t MV7Cost : MOS_BITFIELD_RANGE( 24,31 ); 512 }; 513 struct 514 { 515 uint32_t Value; 516 }; 517 } DW12; 518 519 // DW13 520 union 521 { 522 struct 523 { 524 uint32_t NumRefIdxL0MinusOne : MOS_BITFIELD_RANGE( 0, 7 ); 525 uint32_t NumRefIdxL1MinusOne : MOS_BITFIELD_RANGE( 8,15 ); 526 uint32_t RefStreaminCost : MOS_BITFIELD_RANGE( 16,23 ); 527 uint32_t ROIEnable : MOS_BITFIELD_RANGE( 24,26 ); 528 uint32_t : MOS_BITFIELD_RANGE( 27,31 ); 529 }; 530 struct 531 { 532 uint32_t Value; 533 }; 534 } DW13; 535 536 // DW14 537 union 538 { 539 struct 540 { 541 uint32_t List0RefID0FieldParity : MOS_BITFIELD_BIT( 0 ); 542 uint32_t List0RefID1FieldParity : MOS_BITFIELD_BIT( 1 ); 543 uint32_t List0RefID2FieldParity : MOS_BITFIELD_BIT( 2 ); 544 uint32_t List0RefID3FieldParity : MOS_BITFIELD_BIT( 3 ); 545 uint32_t List0RefID4FieldParity : MOS_BITFIELD_BIT( 4 ); 546 uint32_t List0RefID5FieldParity : MOS_BITFIELD_BIT( 5 ); 547 uint32_t List0RefID6FieldParity : MOS_BITFIELD_BIT( 6 ); 548 uint32_t List0RefID7FieldParity : MOS_BITFIELD_BIT( 7 ); 549 uint32_t List1RefID0FieldParity : MOS_BITFIELD_BIT( 8 ); 550 uint32_t List1RefID1FieldParity : MOS_BITFIELD_BIT( 9 ); 551 uint32_t : MOS_BITFIELD_RANGE( 10,31 ); 552 }; 553 struct 554 { 555 uint32_t Value; 556 }; 557 } DW14; 558 559 // DW15 560 union 561 { 562 struct 563 { 564 uint32_t PrevMvReadPosFactor : MOS_BITFIELD_RANGE( 0, 7 ); 565 uint32_t MvShiftFactor : MOS_BITFIELD_RANGE( 8,15 ); 566 uint32_t Reserved : MOS_BITFIELD_RANGE( 16,31 ); 567 }; 568 struct 569 { 570 uint32_t Value; 571 }; 572 } DW15; 573 574 struct 575 { 576 // DW16 577 union 578 { 579 struct 580 { 581 SearchPathDelta SPDelta_0; 582 SearchPathDelta SPDelta_1; 583 SearchPathDelta SPDelta_2; 584 SearchPathDelta SPDelta_3; 585 }; 586 struct 587 { 588 uint32_t Value; 589 }; 590 } DW16; 591 592 // DW17 593 union 594 { 595 struct 596 { 597 SearchPathDelta SPDelta_4; 598 SearchPathDelta SPDelta_5; 599 SearchPathDelta SPDelta_6; 600 SearchPathDelta SPDelta_7; 601 }; 602 struct 603 { 604 uint32_t Value; 605 }; 606 } DW17; 607 608 // DW18 609 union 610 { 611 struct 612 { 613 SearchPathDelta SPDelta_8; 614 SearchPathDelta SPDelta_9; 615 SearchPathDelta SPDelta_10; 616 SearchPathDelta SPDelta_11; 617 }; 618 struct 619 { 620 uint32_t Value; 621 }; 622 } DW18; 623 624 // DW19 625 union 626 { 627 struct 628 { 629 SearchPathDelta SPDelta_12; 630 SearchPathDelta SPDelta_13; 631 SearchPathDelta SPDelta_14; 632 SearchPathDelta SPDelta_15; 633 }; 634 struct 635 { 636 uint32_t Value; 637 }; 638 } DW19; 639 640 // DW20 641 union 642 { 643 struct 644 { 645 SearchPathDelta SPDelta_16; 646 SearchPathDelta SPDelta_17; 647 SearchPathDelta SPDelta_18; 648 SearchPathDelta SPDelta_19; 649 }; 650 struct 651 { 652 uint32_t Value; 653 }; 654 } DW20; 655 656 // DW21 657 union 658 { 659 struct 660 { 661 SearchPathDelta SPDelta_20; 662 SearchPathDelta SPDelta_21; 663 SearchPathDelta SPDelta_22; 664 SearchPathDelta SPDelta_23; 665 }; 666 struct 667 { 668 uint32_t Value; 669 }; 670 } DW21; 671 672 // DW22 673 union 674 { 675 struct 676 { 677 SearchPathDelta SPDelta_24; 678 SearchPathDelta SPDelta_25; 679 SearchPathDelta SPDelta_26; 680 SearchPathDelta SPDelta_27; 681 }; 682 struct 683 { 684 uint32_t Value; 685 }; 686 } DW22; 687 688 // DW23 689 union 690 { 691 struct 692 { 693 SearchPathDelta SPDelta_28; 694 SearchPathDelta SPDelta_29; 695 SearchPathDelta SPDelta_30; 696 SearchPathDelta SPDelta_31; 697 }; 698 struct 699 { 700 uint32_t Value; 701 }; 702 } DW23; 703 704 // DW24 705 union 706 { 707 struct 708 { 709 SearchPathDelta SPDelta_32; 710 SearchPathDelta SPDelta_33; 711 SearchPathDelta SPDelta_34; 712 SearchPathDelta SPDelta_35; 713 }; 714 struct 715 { 716 uint32_t Value; 717 }; 718 } DW24; 719 720 // DW25 721 union 722 { 723 struct 724 { 725 SearchPathDelta SPDelta_36; 726 SearchPathDelta SPDelta_37; 727 SearchPathDelta SPDelta_38; 728 SearchPathDelta SPDelta_39; 729 }; 730 struct 731 { 732 uint32_t Value; 733 }; 734 } DW25; 735 736 // DW26 737 union 738 { 739 struct 740 { 741 SearchPathDelta SPDelta_40; 742 SearchPathDelta SPDelta_41; 743 SearchPathDelta SPDelta_42; 744 SearchPathDelta SPDelta_43; 745 }; 746 struct 747 { 748 uint32_t Value; 749 }; 750 } DW26; 751 752 // DW27 753 union 754 { 755 struct 756 { 757 SearchPathDelta SPDelta_44; 758 SearchPathDelta SPDelta_45; 759 SearchPathDelta SPDelta_46; 760 SearchPathDelta SPDelta_47; 761 }; 762 struct 763 { 764 uint32_t Value; 765 }; 766 } DW27; 767 768 // DW28 769 union 770 { 771 struct 772 { 773 SearchPathDelta SPDelta_48; 774 SearchPathDelta SPDelta_49; 775 SearchPathDelta SPDelta_50; 776 SearchPathDelta SPDelta_51; 777 }; 778 struct 779 { 780 uint32_t Value; 781 }; 782 } DW28; 783 784 // DW29 785 union 786 { 787 struct 788 { 789 SearchPathDelta SPDelta_52; 790 SearchPathDelta SPDelta_53; 791 SearchPathDelta SPDelta_54; 792 SearchPathDelta SPDelta_55; 793 }; 794 struct 795 { 796 uint32_t Value; 797 }; 798 } DW29; 799 } SPDelta; 800 801 // DW30 802 union 803 { 804 struct 805 { 806 uint32_t ActualMBWidth : MOS_BITFIELD_RANGE( 0,15 ); 807 uint32_t ActualMBHeight : MOS_BITFIELD_RANGE( 16,31 ); 808 }; 809 struct 810 { 811 uint32_t Value; 812 }; 813 } DW30; 814 815 // DW31 816 union 817 { 818 struct 819 { 820 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 ); 821 }; 822 struct 823 { 824 uint32_t Value; 825 }; 826 } DW31; 827 828 // DW32 829 union 830 { 831 struct 832 { 833 uint32_t _4xMeMvOutputDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 ); 834 }; 835 struct 836 { 837 uint32_t Value; 838 }; 839 } DW32; 840 841 // DW33 842 union 843 { 844 struct 845 { 846 uint32_t _16xOr32xMeMvInputDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 ); 847 }; 848 struct 849 { 850 uint32_t Value; 851 }; 852 } DW33; 853 854 // DW34 855 union 856 { 857 struct 858 { 859 uint32_t _4xMeOutputDistSurfIndex : MOS_BITFIELD_RANGE( 0,31 ); 860 }; 861 struct 862 { 863 uint32_t Value; 864 }; 865 } DW34; 866 867 // DW35 868 union 869 { 870 struct 871 { 872 uint32_t _4xMeOutputBrcDistSurfIndex : MOS_BITFIELD_RANGE( 0,31 ); 873 }; 874 struct 875 { 876 uint32_t Value; 877 }; 878 } DW35; 879 880 // DW36 881 union 882 { 883 struct 884 { 885 uint32_t VMEFwdInterPredictionSurfIndex : MOS_BITFIELD_RANGE( 0,31 ); 886 }; 887 struct 888 { 889 uint32_t Value; 890 }; 891 } DW36; 892 893 // DW37 894 union 895 { 896 struct 897 { 898 uint32_t VMEBwdInterPredictionSurfIndex : MOS_BITFIELD_RANGE( 0,31 ); 899 }; 900 struct 901 { 902 uint32_t Value; 903 }; 904 } DW37; 905 906 // DW38 907 union 908 { 909 struct 910 { 911 uint32_t VDEncStreamInSurfIndex : MOS_BITFIELD_RANGE( 0,31 ); 912 }; 913 struct 914 { 915 uint32_t Value; 916 }; 917 } DW38; 918 919 } CODECHAL_ENCODE_AVC_ME_CURBE, *PCODECHAL_ENCODE_AVC_ME_CURBE; 920 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(CODECHAL_ENCODE_AVC_ME_CURBE)) == 39); 921 922 // AVC ME CURBE init data for G9 CM Kernel 923 static const uint32_t g_cInit_CODECHAL_ENCODE_AVC_ME_CURBE[39] = 924 { 925 0x00000000, 0x00200010, 0x00003939, 0x77a43000, 0x00000000, 0x28300000, 0x00000000, 0x00000000, 926 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 927 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 928 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 929 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff 930 }; 931 932 // CURBE for Static Frame Detection kernel 933 typedef struct _CODECHAL_ENCODE_AVC_SFD_CURBE_COMMON 934 { 935 union 936 { 937 struct 938 { 939 uint32_t VDEncModeDisable : MOS_BITFIELD_BIT( 0 ); 940 uint32_t BRCModeEnable : MOS_BITFIELD_BIT( 1 ); 941 uint32_t SliceType : MOS_BITFIELD_RANGE( 2, 3 ); 942 uint32_t : MOS_BITFIELD_BIT( 4 ); 943 uint32_t StreamInType : MOS_BITFIELD_RANGE( 5, 8 ); 944 uint32_t EnableAdaptiveMvStreamIn : MOS_BITFIELD_BIT( 9 ); 945 uint32_t : MOS_BITFIELD_BIT( 10 ); 946 uint32_t EnableIntraCostScalingForStaticFrame : MOS_BITFIELD_BIT( 11 ); 947 uint32_t Reserved : MOS_BITFIELD_RANGE( 12, 31 ); 948 }; 949 struct 950 { 951 uint32_t Value; 952 }; 953 } DW0; 954 955 union 956 { 957 struct 958 { 959 uint32_t QPValue : MOS_BITFIELD_RANGE( 0, 7 ); 960 uint32_t NumOfRefs : MOS_BITFIELD_RANGE( 8, 15 ); 961 uint32_t HMEStreamInRefCost : MOS_BITFIELD_RANGE( 16, 23 ); 962 uint32_t Reserved : MOS_BITFIELD_RANGE( 24, 31 ); 963 }; 964 struct 965 { 966 uint32_t Value; 967 }; 968 } DW1; 969 970 union 971 { 972 struct 973 { 974 uint32_t FrameWidthInMBs : MOS_BITFIELD_RANGE( 0, 15 ); // round-up to 4-MB aligned 975 uint32_t FrameHeightInMBs : MOS_BITFIELD_RANGE( 16, 31 ); // round-up to 4-MB aligned 976 }; 977 struct 978 { 979 uint32_t Value; 980 }; 981 } DW2; 982 983 union 984 { 985 struct 986 { 987 uint32_t LargeMvThresh : MOS_BITFIELD_RANGE( 0, 31 ); 988 }; 989 struct 990 { 991 uint32_t Value; 992 }; 993 } DW3; 994 995 union 996 { 997 struct 998 { 999 uint32_t TotalLargeMvThreshold : MOS_BITFIELD_RANGE( 0, 31 ); 1000 }; 1001 struct 1002 { 1003 uint32_t Value; 1004 }; 1005 } DW4; 1006 1007 union 1008 { 1009 struct 1010 { 1011 uint32_t ZMVThreshold : MOS_BITFIELD_RANGE( 0, 31 ); 1012 }; 1013 struct 1014 { 1015 uint32_t Value; 1016 }; 1017 } DW5; 1018 1019 union 1020 { 1021 struct 1022 { 1023 uint32_t TotalZMVThreshold : MOS_BITFIELD_RANGE( 0, 31 ); 1024 }; 1025 struct 1026 { 1027 uint32_t Value; 1028 }; 1029 } DW6; 1030 1031 union 1032 { 1033 struct 1034 { 1035 uint32_t MinDistThreshold : MOS_BITFIELD_RANGE( 0, 31 ); 1036 }; 1037 struct 1038 { 1039 uint32_t Value; 1040 }; 1041 } DW7; 1042 1043 uint8_t CostTable[52]; 1044 1045 union 1046 { 1047 struct 1048 { 1049 uint32_t ActualWidthInMB : MOS_BITFIELD_RANGE( 0, 15 ); 1050 uint32_t ActualHeightInMB : MOS_BITFIELD_RANGE( 16, 31 ); 1051 }; 1052 struct 1053 { 1054 uint32_t Value; 1055 }; 1056 } DW21; 1057 1058 union 1059 { 1060 struct 1061 { 1062 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 ); 1063 }; 1064 struct 1065 { 1066 uint32_t Value; 1067 }; 1068 } DW22; 1069 1070 union 1071 { 1072 struct 1073 { 1074 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 ); 1075 }; 1076 struct 1077 { 1078 uint32_t Value; 1079 }; 1080 } DW23; 1081 1082 union 1083 { 1084 struct 1085 { 1086 uint32_t VDEncInputImagStateIndex : MOS_BITFIELD_RANGE( 0, 31 ); // used in VDEnc CQP mode 1087 }; 1088 struct 1089 { 1090 uint32_t Value; 1091 }; 1092 } DW24; 1093 1094 union 1095 { 1096 struct 1097 { 1098 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 ); 1099 }; 1100 struct 1101 { 1102 uint32_t Value; 1103 }; 1104 } DW25; 1105 1106 union 1107 { 1108 struct 1109 { 1110 uint32_t MVDataSurfaceIndex : MOS_BITFIELD_RANGE( 0, 31 ); // contains HME MV Data generated by HME kernel 1111 }; 1112 struct 1113 { 1114 uint32_t Value; 1115 }; 1116 } DW26; 1117 1118 union 1119 { 1120 struct 1121 { 1122 uint32_t InterDistortionSurfaceIndex : MOS_BITFIELD_RANGE( 0, 31 ); // contains HME Inter Distortion generated by HME kernel 1123 }; 1124 struct 1125 { 1126 uint32_t Value; 1127 }; 1128 } DW27; 1129 1130 union 1131 { 1132 struct 1133 { 1134 uint32_t OutputDataSurfaceIndex : MOS_BITFIELD_RANGE( 0, 31 ); 1135 }; 1136 struct 1137 { 1138 uint32_t Value; 1139 }; 1140 } DW28; 1141 1142 union 1143 { 1144 struct 1145 { 1146 uint32_t VDEncOutputImagStateIndex : MOS_BITFIELD_RANGE( 0, 31 ); 1147 }; 1148 struct 1149 { 1150 uint32_t Value; 1151 }; 1152 } DW29; 1153 1154 } CODECHAL_ENCODE_AVC_SFD_CURBE_COMMON, *PCODECHAL_ENCODE_AVC_SFD_CURBE_COMMON; 1155 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(CODECHAL_ENCODE_AVC_SFD_CURBE_COMMON)) == 30); 1156 1157 typedef struct _CODECHAL_ENCODE_AVC_SFD_SURFACE_PARAMS 1158 { 1159 uint32_t dwDownscaledWidthInMb4x; 1160 uint32_t dwDownscaledHeightInMb4x; 1161 uint32_t dwMeMvBottomFieldOffset; 1162 uint32_t dwMeDistortionBottomFieldOffset; 1163 PMOS_RESOURCE presVDEncImageStateInputBuffer; 1164 PMOS_SURFACE psMeMvDataSurface; 1165 PMOS_SURFACE psMeDistortionSurface; 1166 PMOS_RESOURCE presOutputBuffer; 1167 PMOS_RESOURCE presVDEncImageStateOutputBuffer; 1168 PMHW_KERNEL_STATE pKernelState; 1169 bool bVdencActive; 1170 bool bVdencBrcEnabled; 1171 } CODECHAL_ENCODE_AVC_SFD_SURFACE_PARAMS, *PCODECHAL_ENCODE_AVC_SFD_SURFACE_PARAMS; 1172 1173 typedef struct _CODECHAL_ENCODE_AVC_SFD_CURBE_PARAMS 1174 { 1175 PMHW_KERNEL_STATE pKernelState; 1176 } CODECHAL_ENCODE_AVC_SFD_CURBE_PARAMS, *PCODECHAL_ENCODE_AVC_SFD_CURBE_PARAMS; 1177 1178 //! 1179 //! \brief Vertical MV component range based on levelIdc 1180 //! \details VDBOX private function to get vertical MV componet range 1181 //! \param [in] levelIdc 1182 //! AVC level 1183 //! \return uint32_t 1184 //! return the max vertical mv component base on input level 1185 //! 1186 uint32_t CodecHalAvcEncode_GetMaxVmvR(uint8_t levelIdc); 1187 1188 //! 1189 //! \brief Get MV component range based on levelIdc 1190 //! \details VDBOX private function to get MV componet range 1191 //! \param [in] levelIdc 1192 //! AVC level 1193 //! \return uint32_t 1194 //! return the max mv component base on input level 1195 //! 1196 uint32_t CodecHalAvcEncode_GetMaxMvLen(uint8_t levelIdc); 1197 1198 //! 1199 //! \brief Get the filed parity: Top filed or Bottom filed 1200 //! \details Client facing function to get the filed parity: Top filed or Bottom filed 1201 //! \param [in] params 1202 //! PCODEC_AVC_ENCODE_SLICE_PARAMS pSlcParams 1203 //! \param [list] list 1204 //! forword or backword reference 1205 //! \param [in] index 1206 //! reference frame index 1207 //! \return uint32_t 1208 //! Bottom field or Top field 1209 //! 1210 bool CodecHalAvcEncode_GetFieldParity( 1211 PCODEC_AVC_ENCODE_SLICE_PARAMS params, 1212 uint32_t list, 1213 uint32_t index); 1214 1215 //! 1216 //! \brief Get profile level max frame size 1217 //! \param [in] seqParams 1218 //! Encoder Sequence params 1219 //! \param [in] encoder 1220 //! Encoder structure 1221 //! \param [in] profileLevelMaxFrame 1222 //! Profile Level Max Frame 1223 //! \return MOS_STATUS 1224 //! MOS_STATUS_SUCCESS if success, else fail reason 1225 //! 1226 MOS_STATUS CodecHalAvcEncode_GetProfileLevelMaxFrameSize( 1227 PCODEC_AVC_ENCODE_SEQUENCE_PARAMS seqParams, 1228 CodechalEncoderState* encoder, 1229 uint32_t* profileLevelMaxFrame); 1230 1231 //! \brief Get the max number of allowed slice 1232 //! \param [in] profileIdc 1233 //! AVC profile idc 1234 //! \param [in] levelIdc 1235 //! AVC level idc 1236 //! \param [in] framesPer100Sec 1237 //! frame Per 100Sec 1238 //! \return uint16_t 1239 //! return uiMaxAllowedNumSlices 1240 //! 1241 uint16_t CodecHalAvcEncode_GetMaxNumSlicesAllowed( 1242 CODEC_AVC_PROFILE_IDC profileIdc, 1243 CODEC_AVC_LEVEL_IDC levelIdc, 1244 uint32_t framesPer100Sec); 1245 1246 //! 1247 //! \brief Use to pack picture header related params 1248 //! \param [in] params 1249 //! picture header pack params 1250 //! \return MOS_STATUS 1251 //! MOS_STATUS_SUCCESS if success, else fail reason 1252 //! 1253 MOS_STATUS CodecHalAvcEncode_PackPictureHeader( 1254 PCODECHAL_ENCODE_AVC_PACK_PIC_HEADER_PARAMS params); 1255 1256 //! 1257 //! \brief Use to pack slice header related params 1258 //! \param [in] params 1259 //! slice header pack params 1260 //! \return MOS_STATUS 1261 //! MOS_STATUS_SUCCESS if success, else fail reason 1262 //! 1263 MOS_STATUS CodecHalAvcEncode_PackSliceHeader( 1264 PCODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS params); 1265 1266 //! 1267 //! \brief Use to get picture num of slice header to be packed 1268 //! \param [in] params 1269 //! pack slice header pack params 1270 //! \param [in] list 1271 //! forword or backword reference 1272 //! \return void 1273 //! 1274 static void CodecHal_PackSliceHeader_GetPicNum ( 1275 PCODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS params, 1276 uint8_t list); 1277 1278 //! 1279 //! \class CodechalEncodeAvcBase 1280 //! \brief CodechalE encode Avc base 1281 //! 1282 class CodechalEncodeAvcBase : public CodechalEncoderState 1283 { 1284 public: 1285 // AvcState functions. 1286 //! 1287 //! \brief Constructor 1288 //! 1289 CodechalEncodeAvcBase( 1290 CodechalHwInterface * hwInterface, 1291 CodechalDebugInterface *debugInterface, 1292 PCODECHAL_STANDARD_INFO standardInfo); 1293 1294 //! 1295 //! \brief Copy constructor 1296 //! 1297 CodechalEncodeAvcBase(const CodechalEncodeAvcBase&) = delete; 1298 1299 //! 1300 //! \brief Copy assignment operator 1301 //! 1302 CodechalEncodeAvcBase& operator=(const CodechalEncodeAvcBase&) = delete; 1303 1304 //! 1305 //! \brief Destructor 1306 //! 1307 virtual ~CodechalEncodeAvcBase(); 1308 1309 //Encode interface definitions 1310 //! 1311 //! \brief Initialize standard related members. 1312 //! \details Initialize members, set proper value 1313 //! to involved variables, allocate resources. 1314 //! \param [in] settings 1315 //! Encode settings. 1316 //! 1317 //! \return MOS_STATUS 1318 //! MOS_STATUS_SUCCESS if success 1319 //! 1320 virtual MOS_STATUS Initialize(CodechalSetting * settings); 1321 1322 virtual MOS_STATUS GetStatusReport( 1323 EncodeStatus *encodeStatus, 1324 EncodeStatusReport *encodeStatusReport); 1325 1326 //! 1327 //! \brief Encode User Feature Key Report. 1328 //! \details Report user feature values set by encode. 1329 //! 1330 //! \return MOS_STATUS 1331 //! MOS_STATUS_SUCCESS if success 1332 //! 1333 virtual MOS_STATUS UserFeatureKeyReport(); 1334 1335 //! 1336 //! \brief Initialize Encode ME kernel state 1337 //! 1338 //! \return MOS_STATUS 1339 //! MOS_STATUS_SUCCESS if success 1340 //! 1341 virtual MOS_STATUS InitKernelStateMe() = 0; 1342 1343 //! 1344 //! \brief Set Encode ME kernel Curbe data. 1345 //! 1346 //! \param [in] params 1347 //! Pointer to the MeCurbeParams 1348 //! 1349 //! \return MOS_STATUS 1350 //! MOS_STATUS_SUCCESS if success 1351 //! 1352 virtual MOS_STATUS SetCurbeMe( MeCurbeParams* params ) = 0; 1353 1354 //! 1355 //! \brief Set Encode ME kernel Surfaces 1356 //! 1357 //! \param [in] cmdBuffer 1358 //! Pointer to the MOS_COMMAND_BUFFER 1359 //! \param [in] params 1360 //! Pointer to the CODECHAL_ME_SURFACE_PARAMS 1361 //! 1362 //! \return MOS_STATUS 1363 //! MOS_STATUS_SUCCESS if success 1364 //! 1365 virtual MOS_STATUS SendMeSurfaces( 1366 PMOS_COMMAND_BUFFER cmdBuffer, 1367 MeSurfaceParams* params) = 0; 1368 //! 1369 //! \brief AVC State Initialization. 1370 //! 1371 //! \return MOS_STATUS 1372 //! MOS_STATUS_SUCCESS if success 1373 //! 1374 virtual MOS_STATUS Initialize(); 1375 1376 1377 //! 1378 //! \brief AVC Resource Allocation for ENC. 1379 //! 1380 //! \return MOS_STATUS 1381 //! MOS_STATUS_SUCCESS if success 1382 //! 1383 virtual MOS_STATUS AllocateEncResources(); 1384 1385 //! 1386 //! \brief AVC Resource Allocation for Encoder. 1387 //! 1388 //! \return MOS_STATUS 1389 //! MOS_STATUS_SUCCESS if success 1390 //! 1391 virtual MOS_STATUS AllocateResources(); 1392 1393 //! 1394 //! \brief Set AVC Sequence Structs. 1395 //! 1396 //! \return MOS_STATUS 1397 //! MOS_STATUS_SUCCESS if success 1398 //! 1399 virtual MOS_STATUS SetSequenceStructs(); 1400 1401 //! 1402 //! \brief Set AVC Picture Structs. 1403 //! 1404 //! \return MOS_STATUS 1405 //! MOS_STATUS_SUCCESS if success 1406 //! 1407 virtual MOS_STATUS SetPictureStructs(); 1408 1409 //! 1410 //! \brief Set AVC Slice Structs. 1411 //! 1412 //! \return MOS_STATUS 1413 //! MOS_STATUS_SUCCESS if success 1414 //! 1415 virtual MOS_STATUS SetSliceStructs(); 1416 1417 //! 1418 //! \brief Run Encode ME kernel 1419 //! 1420 //! \param [in] brcBuffers 1421 //! Pointer to the EncodeBrcBuffers 1422 //! \param [in] hmeLevel 1423 //! Hme level 1424 //! 1425 //! \return MOS_STATUS 1426 //! MOS_STATUS_SUCCESS if success 1427 //! 1428 virtual MOS_STATUS EncodeMeKernel( 1429 EncodeBrcBuffers* brcBuffers, 1430 HmeLevel hmeLevel); 1431 1432 //! 1433 //! \brief Allocate Batch Buffer For PakSlice. 1434 //! 1435 //! \param [in] numSlices 1436 //! Number of Slice 1437 //! \param [in] numPakPasses 1438 //! Number of PAK pass. 1439 //! \param [in] currRecycledBufIdx 1440 //! Current Recycle Buffer Index. 1441 //! 1442 //! \return MOS_STATUS 1443 //! MOS_STATUS_SUCCESS if success 1444 //! 1445 virtual MOS_STATUS AllocateBatchBufferForPakSlices( 1446 uint32_t numSlices, 1447 uint8_t numPakPasses, 1448 uint8_t currRecycledBufIdx); 1449 1450 //! 1451 //! \brief Release Batch Buffer For PakSlice. 1452 //! 1453 //! \param [in] currRecycledBufIdx 1454 //! Current Recycle Buffer Index. 1455 //! 1456 //! \return MOS_STATUS 1457 //! MOS_STATUS_SUCCESS if success 1458 //! 1459 virtual MOS_STATUS ReleaseBatchBufferForPakSlices( uint8_t currRecycledBufIdx); 1460 1461 //! 1462 //! \brief Initialize kernel binary size info. 1463 //! 1464 //! \return MOS_STATUS 1465 //! MOS_STATUS_SUCCESS if success 1466 //! 1467 MOS_STATUS AddIshSize(uint32_t kuid, uint8_t* kernelBase); 1468 1469 //! 1470 //! \brief Calculate scaling list 1471 //! 1472 //! \return void 1473 //! 1474 void ScalingListFlat(); 1475 1476 //! 1477 //! \brief Calculate scaling list 1478 //! 1479 //! \return void 1480 //! 1481 void ScalingListFallbackRuleA(); 1482 1483 //! 1484 //! \brief Get Dist Scale factor 1485 //! 1486 //! \return void 1487 //! 1488 void GetDistScaleFactor(); 1489 1490 //! 1491 //! \brief Initialize MMC state 1492 //! 1493 //! \return MOS_STATUS 1494 //! MOS_STATUS_SUCCESS if success 1495 //! 1496 virtual MOS_STATUS InitMmcState(); 1497 1498 //! 1499 //! \brief Get bidirectional weight 1500 //! 1501 //! \param [in] distScaleFactorRefID0List0 1502 //! DistScaleFactorRefID0List0 1503 //! \param [in] weightedBiPredIdc 1504 //! Same as AVC syntax element. 1505 //! 1506 //! \return int32_t 1507 //! Bidirectional weight 1508 //! 1509 int32_t GetBiWeight( 1510 uint32_t distScaleFactorRefID0List0, 1511 uint16_t weightedBiPredIdc); 1512 1513 //! 1514 //! \brief Update the slice count according to the slice shutdown policy 1515 //! 1516 virtual void UpdateSSDSliceCount(); 1517 1518 //! 1519 //! \brief Build slices with header insertion 1520 //! \param [in] cmdBuffer 1521 //! command buffer 1522 //! \param [in] params 1523 //! VDBOX AVC slice state params 1524 //! \return MOS_STATUS 1525 //! MOS_STATUS_SUCCESS if success, else fail reason 1526 //! 1527 MOS_STATUS SendSlice( 1528 PMOS_COMMAND_BUFFER cmdBuffer, 1529 PMHW_VDBOX_AVC_SLICE_STATE params); 1530 1531 //! 1532 //! \brief Store number passes 1533 //! 1534 //! \param [in] encodeStatusBuf 1535 //! Encode status buffer 1536 //! \param [in] miInterface 1537 //! Mi interface 1538 //! \param [in] cmdBuffer 1539 //! Command buffer 1540 //! \param [in] currPass 1541 //! Curr pass 1542 //! 1543 //! \return MOS_STATUS 1544 //! MOS_STATUS_SUCCESS if success, else fail reason 1545 //! 1546 MOS_STATUS StoreNumPasses( 1547 EncodeStatusBuffer *encodeStatusBuf, 1548 MhwMiInterface *miInterface, 1549 PMOS_COMMAND_BUFFER cmdBuffer, 1550 uint32_t currPass); 1551 1552 virtual MOS_STATUS AddMfxAvcSlice( 1553 PMOS_COMMAND_BUFFER cmdBuffer, 1554 PMHW_BATCH_BUFFER batchBuffer, 1555 PMHW_VDBOX_AVC_SLICE_STATE avcSliceState); 1556 1557 virtual MOS_STATUS AddVdencSliceStateCmd( 1558 PMOS_COMMAND_BUFFER cmdBuffer, 1559 PMHW_VDBOX_AVC_SLICE_STATE params); 1560 1561 #if USE_CODECHAL_DEBUG_TOOL 1562 MOS_STATUS DumpSeqParams( 1563 PCODEC_AVC_ENCODE_SEQUENCE_PARAMS seqParams, 1564 PCODEC_AVC_IQ_MATRIX_PARAMS matrixParams); 1565 1566 MOS_STATUS DumpPicParams( 1567 PCODEC_AVC_ENCODE_PIC_PARAMS picParams, 1568 PCODEC_AVC_IQ_MATRIX_PARAMS matrixParams); 1569 1570 MOS_STATUS DumpFeiPicParams( 1571 CodecEncodeAvcFeiPicParams *feiPicParams); 1572 1573 MOS_STATUS DumpSliceParams( 1574 PCODEC_AVC_ENCODE_SLICE_PARAMS sliceParams, 1575 PCODEC_AVC_ENCODE_PIC_PARAMS picParams); 1576 1577 MOS_STATUS DumpVuiParams( 1578 PCODECHAL_ENCODE_AVC_VUI_PARAMS avcVuiParams); 1579 1580 #endif 1581 1582 protected: 1583 //! 1584 //! \brief Set MFX_PIPE_MODE_SELECT parameter 1585 //! 1586 //! \param [in] genericParam 1587 //! CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS 1588 //! \param [out] param 1589 //! reference to MHW_VDBOX_PIPE_MODE_SELECT_PARAMS 1590 //! 1591 //! \return void 1592 //! 1593 virtual void SetMfxPipeModeSelectParams( 1594 const CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS& genericParam, 1595 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS& param); 1596 1597 //! 1598 //! \brief set MFX_PIPE_BUF_ADDR_STATE parameter 1599 //! 1600 //! \param [in] genericParam 1601 //! CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS 1602 //! \param [out] param 1603 //! reference to MHW_VDBOX_PIPE_BUF_ADDR_PARAMS 1604 //! 1605 //! \return MOS_STATUS 1606 //! MOS_STATUS_SUCCESS if success 1607 //! 1608 virtual MOS_STATUS SetMfxPipeBufAddrStateParams( 1609 CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS genericParam, 1610 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS& param); 1611 1612 //! 1613 //! \brief Set MFX_IND_OBJ_BASE_ADDR_STATE parameter 1614 //! 1615 //! \param [out] param 1616 //! reference to MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS 1617 //! 1618 //! \return void 1619 //! 1620 virtual void SetMfxIndObjBaseAddrStateParams(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS& param); 1621 1622 //! 1623 //! \brief Set MHW_VDBOX_BSP_BUF_BASE_ADDR_STATE parameter 1624 //! 1625 //! \param [out] param 1626 //! reference to MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS 1627 //! 1628 //! \return void 1629 //! 1630 virtual void SetMfxBspBufBaseAddrStateParams(MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS& param); 1631 1632 //! 1633 //! \brief Set MHW_VDBOX_QM_STATE parameter 1634 //! 1635 //! \param [out] qmParams 1636 //! reference to MHW_VDBOX_QM_PARAMS 1637 //! \param [out] fqmParams 1638 //! reference to MHW_VDBOX_QM_PARAMS 1639 //! 1640 //! \return void 1641 //! 1642 virtual void SetMfxQmStateParams(MHW_VDBOX_QM_PARAMS& qmParams, MHW_VDBOX_QM_PARAMS & fqmParams); 1643 1644 //! 1645 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1646 //! 1647 //! \param [out] param 1648 //! reference to MHW_VDBOX_AVC_IMG_PARAMS 1649 //! 1650 //! \return void 1651 //! 1652 virtual void SetMfxAvcImgStateParams(MHW_VDBOX_AVC_IMG_PARAMS& param); 1653 1654 public: 1655 PMOS_INTERFACE m_origOsInterface = nullptr; //!< Os Interface 1656 CodechalHwInterface *m_origHwInterface = nullptr; //!< Hw Interface 1657 PMHW_STATE_HEAP_INTERFACE m_origStateHeapInterface = nullptr; //!< StateHeap Interface 1658 1659 // Parameters passed by application 1660 PCODEC_AVC_ENCODE_PIC_PARAMS m_avcPicParams[CODEC_AVC_MAX_PPS_NUM]; //!< Pointer to array of picture parameter, could be removed 1661 PCODEC_AVC_ENCODE_SEQUENCE_PARAMS m_avcSeqParams[CODEC_AVC_MAX_SPS_NUM]; //!< Pointer to array of sequence parameter, could be removed 1662 PCODEC_AVC_ENCODE_PIC_PARAMS m_avcPicParam = nullptr; //!< Pointer to AVC picture parameter 1663 PCODEC_AVC_ENCODE_SEQUENCE_PARAMS m_avcSeqParam = nullptr; //!< Pointer to AVC sequence parameter 1664 PCODECHAL_ENCODE_AVC_QUALITY_CTRL_PARAMS m_avcQCParams = nullptr; //!< Pointer to video quality control parameter 1665 PCODECHAL_ENCODE_AVC_ROUNDING_PARAMS m_avcRoundingParams = nullptr; //!< Pointer to AVC rounding parameter 1666 PCODECHAL_ENCODE_AVC_VUI_PARAMS m_avcVuiParams = nullptr; //!< Pointer to AVC Uvi parameter 1667 PCODEC_AVC_ENCODE_SLICE_PARAMS m_avcSliceParams = nullptr; //!< Pointer to AVC slice parameter 1668 CodecEncodeAvcFeiPicParams *m_avcFeiPicParams = nullptr; //!< Pointer to FEI picture parameter 1669 PCODEC_AVC_IQ_MATRIX_PARAMS m_avcIQMatrixParams = nullptr; //!< Pointer to IQMaxtrix parameter 1670 PCODEC_AVC_ENCODE_IQ_WEIGTHSCALE_LISTS m_avcIQWeightScaleLists = nullptr; //!< Pointer to IQWidght ScaleLists 1671 CODEC_AVC_ENCODE_USER_FLAGS m_userFlags; //!< Encoder user flag settings 1672 uint32_t m_reconFrameSurfaceId[CODEC_AVC_NUM_UNCOMPRESSED_SURFACE]; 1673 CODECHAL_ENCODE_AVC_ENCODER_USAGE m_encoderUsage = CODECHAL_ENCODE_AVC_SINGLE_PASS; 1674 1675 CODEC_PIC_ID m_picIdx[CODEC_AVC_MAX_NUM_REF_FRAME]; //!< Picture index 1676 PCODEC_REF_LIST m_refList[CODEC_AVC_NUM_UNCOMPRESSED_SURFACE]; //!< Pointer to reference list 1677 CODEC_AVC_FRAME_STORE_ID m_avcFrameStoreID[CODEC_AVC_MAX_NUM_REF_FRAME]; //!< Refer to CODEC_AVC_FRAME_STORE_ID 1678 CODECHAL_ENCODE_AVC_NAL_UNIT_TYPE m_nalUnitType; //!< Nal unit type 1679 PCODECHAL_NAL_UNIT_PARAMS *m_nalUnitParams = nullptr; //!< Pointers to NAL unit parameters array 1680 uint16_t m_sliceHeight = 0; //!< Slice height 1681 uint8_t m_biWeightNumB = 0; //!< Bi direction Weight B frames num 1682 bool m_deblockingEnabled = false; //!< Enable deblocking flag 1683 bool m_mbaffEnabled = false; //!< Enable MBAFF flag 1684 bool m_firstFieldIdrPic = false; //!< First field IDR flag 1685 bool m_hmeEnabled = false; //!< Enable HME flag 1686 bool m_16xMeEnabled = false; //!< Enable 16x ME flag 1687 bool m_32xMeEnabled = false; //!< Enable 32x ME flag 1688 bool m_skipBiasAdjustmentEnable = false;//!< Enable SkipBiasAdjustment flag 1689 bool m_staticFrameDetectionInUse = false;//!< Enable Static Frame Detection flag 1690 uint32_t m_sliceStructCaps = 0; //!< Slice struct 1691 1692 CODECHAL_ENCODE_AVC_TQ_PARAMS m_trellisQuantParams; //!< Trellis Quantization params 1693 1694 // B-frame 1695 uint32_t m_distScaleFactorList0[CODEC_AVC_MAX_NUM_REF_FRAME * 2]; //!< the DistScaleFactor used to derive temporal direct motion vector 1696 uint32_t m_biWeight = 0; //!< Bidirectional Weight 1697 1698 // Batch Buffers 1699 MHW_BATCH_BUFFER m_batchBufferForVdencImgStat[CODECHAL_ENCODE_RECYCLED_BUFFER_NUM]; //!< VDEnc image state batch buffers 1700 1701 // ME 1702 CodechalKernelHme *m_hmeKernel = nullptr; //!< ME kernel object 1703 MOS_SURFACE m_4xMeMvDataBuffer; //!< 4x motion estimation MV data buffer 1704 uint32_t m_meMvBottomFieldOffset = 0; //!< ME MV bottom filed offset 1705 MOS_SURFACE m_16xMeMvDataBuffer; //!< 16x motion estimation MV data buffer 1706 uint32_t m_meMv16xBottomFieldOffset = 0; //!< 16x motion estimation MV bottom filed offset 1707 MOS_SURFACE m_32xMeMvDataBuffer; //!< 32x motion estimation MV data buffer 1708 uint32_t m_meMv32xBottomFieldOffset = 0; //!< 32x motion estimation MV bottom filed offset 1709 MOS_SURFACE m_4xMeDistortionBuffer; //!< 4x ME distortion buffer 1710 uint32_t m_meDistortionBottomFieldOffset = 0; //!< ME distortion bottom field offset 1711 uint8_t *m_bmeMethodTable = nullptr; //!< Point to BME Method table 1712 uint8_t *m_meMethodTable = nullptr; //!< Pointer to ME Method table 1713 1714 // PAK Scratch Buffers 1715 MOS_RESOURCE m_intraRowStoreScratchBuffer; //!< Handle of intra row store surface 1716 MHW_BATCH_BUFFER m_batchBufferForPakSlices[CODECHAL_ENCODE_RECYCLED_BUFFER_NUM]; //!< PAK Slice batch buffers 1717 uint32_t m_pakSliceSize = 0; //!< PAK Slice Size 1718 uint32_t m_pakSlicePatchListSize = 0; //!< PAK Slice patch list size 1719 uint32_t m_currPakSliceIdx = 0; //!< Current PAK slice index 1720 1721 bool m_4xMeDistortionBufferSupported = false; //!< Generation Specific Support Flags & User Feature Key Reads 1722 1723 bool m_sliceSizeStreamoutSupported = false; //!< Enable PAK slice size streamout, valid for AVC VDEnc on KBL/CNL+ 1724 MOS_RESOURCE m_pakSliceSizeStreamoutBuffer; //!< PAK slice size streamout buffer 1725 1726 bool m_crePrefetchEnable = false; //!< Enable CRE prefetch flag 1727 bool m_tlbPrefetchEnable = false; //!< Enable TLB prefetch flag 1728 1729 const uint8_t m_codechalEncodeAvcSfdCostTablePFrame[CODEC_AVC_NUM_QP] = 1730 { 1731 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 60, 60, 60, 60, 73, 73, 73, 76, 76, 76, 88, 89, 89, 91, 92, 93, 104, 104, 106, 107, 108, 109, 120, 120, 122, 123, 124, 125, 136, 136, 138, 139, 140, 141, 143, 143}; 1732 1733 const uint8_t m_codechalEncodeAvcSfdCostTableBFrame[CODEC_AVC_NUM_QP] = 1734 { 1735 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 73, 73, 73, 73, 77, 77, 77, 89, 89, 89, 91, 93, 93, 95, 105, 106, 107, 108, 110, 111, 121, 122, 123, 124, 125, 127, 137, 138, 139, 140, 142, 143, 143, 143, 143, 143}; 1736 1737 const uint8_t m_codechalEncodeAvcSfdCostTableVdEnc[CODEC_AVC_NUM_QP] = 1738 { 1739 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47, 56, 57, 59, 44, 45, 47, 56, 44, 47, 47, 45, 47, 47, 47, 47, 45, 47, 47, 56, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47}; 1740 1741 #if USE_CODECHAL_DEBUG_TOOL 1742 protected: 1743 //! 1744 //! \brief Create AVC PAR 1745 //! 1746 //! \return MOS_STATUS 1747 //! MOS_STATUS_SUCCESS if success, else fail reason 1748 //! 1749 MOS_STATUS CreateAvcPar(); 1750 1751 //! 1752 //! \brief Destroy AVC PAR 1753 //! 1754 //! \return MOS_STATUS 1755 //! MOS_STATUS_SUCCESS if success, else fail reason 1756 //! 1757 MOS_STATUS DestroyAvcPar(); 1758 1759 //! 1760 //! \brief Dump sequence PAR file 1761 //! 1762 //! \return MOS_STATUS 1763 //! MOS_STATUS_SUCCESS if success, else fail reason 1764 //! DumpSeqParFile()1765 virtual MOS_STATUS DumpSeqParFile() { return MOS_STATUS_SUCCESS; } 1766 1767 //! 1768 //! \brief Dump frame PAR file 1769 //! 1770 //! \return MOS_STATUS 1771 //! MOS_STATUS_SUCCESS if success, else fail reason 1772 //! DumpFrameParFile()1773 virtual MOS_STATUS DumpFrameParFile() { return MOS_STATUS_SUCCESS; } 1774 1775 //! 1776 //! \brief Populate const parameters 1777 //! 1778 //! \return MOS_STATUS 1779 //! MOS_STATUS_SUCCESS if success, else fail reason 1780 //! 1781 MOS_STATUS PopulateConstParam(); 1782 1783 //! 1784 //! \brief Populate target usage as the first parameter of dumped par file 1785 //! 1786 //! \return MOS_STATUS 1787 //! MOS_STATUS_SUCCESS if success, else fail reason 1788 //! 1789 MOS_STATUS PopulateTargetUsage(); 1790 1791 //! 1792 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1793 //! 1794 //! \param [in] avcSeqParams 1795 //! pointer to AVC encode sequence parameters 1796 //! \param [in] avcPicParams 1797 //! pointer to AVC encode picture parameters 1798 //! \param [in] avcSlcParams 1799 //! pointer to AVC encode slice parameters 1800 //! 1801 //! \return MOS_STATUS 1802 //! MOS_STATUS_SUCCESS if success, else fail reason 1803 //! 1804 MOS_STATUS PopulateDdiParam( 1805 PCODEC_AVC_ENCODE_SEQUENCE_PARAMS avcSeqParams, 1806 PCODEC_AVC_ENCODE_PIC_PARAMS avcPicParams, 1807 PCODEC_AVC_ENCODE_SLICE_PARAMS avcSlcParams); 1808 1809 //! 1810 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1811 //! 1812 //! \param [in] adaptiveRoundingInterEnable 1813 //! adaptive rounding inter enable flag 1814 //! \param [in] sliceState 1815 //! pointer to slice state 1816 //! 1817 //! \return MOS_STATUS 1818 //! MOS_STATUS_SUCCESS if success, else fail reason 1819 //! 1820 MOS_STATUS PopulateSliceStateParam( 1821 bool adaptiveRoundingInterEnable, 1822 PMHW_VDBOX_AVC_SLICE_STATE sliceState); 1823 1824 //! 1825 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1826 //! 1827 //! \param [in] *cmd 1828 //! pointer to command 1829 //! 1830 //! \return MOS_STATUS 1831 //! MOS_STATUS_SUCCESS if success, else fail reason 1832 //! 1833 MOS_STATUS PopulateSfdParam( 1834 void *cmd); 1835 1836 //! 1837 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1838 //! 1839 //! \param [in] is16xMeEnabled 1840 //! 16x ME enabled flag 1841 //! \param [in] is32xMeEnabled 1842 //! 32x ME enabled flag 1843 //! \param [in] meMethod 1844 //! ME method 1845 //! \param [in] *cmd 1846 //! pointer to command 1847 //! 1848 //! \return MOS_STATUS 1849 //! MOS_STATUS_SUCCESS if success, else fail reason 1850 //! PopulateHmeParam(bool is16xMeEnabled,bool is32xMeEnabled,uint8_t meMethod,void * cmd)1851 virtual MOS_STATUS PopulateHmeParam( 1852 bool is16xMeEnabled, 1853 bool is32xMeEnabled, 1854 uint8_t meMethod, 1855 void *cmd) { return MOS_STATUS_SUCCESS; } 1856 1857 //! 1858 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1859 //! 1860 //! \param [in] *cmd 1861 //! pointer to command 1862 //! 1863 //! \return MOS_STATUS 1864 //! MOS_STATUS_SUCCESS if success, else fail reason 1865 //! PopulateBrcInitParam(void * cmd)1866 virtual MOS_STATUS PopulateBrcInitParam( 1867 void *cmd) { return MOS_STATUS_SUCCESS; } 1868 1869 //! 1870 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1871 //! 1872 //! \param [in] *cmd 1873 //! pointer to command 1874 //! 1875 //! \return MOS_STATUS 1876 //! MOS_STATUS_SUCCESS if success, else fail reason 1877 //! PopulateBrcUpdateParam(void * cmd)1878 virtual MOS_STATUS PopulateBrcUpdateParam( 1879 void *cmd) { return MOS_STATUS_SUCCESS; } 1880 1881 //! 1882 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1883 //! 1884 //! \param [in] meMethod 1885 //! ME method 1886 //! \param [in] *cmd 1887 //! pointer to command 1888 //! 1889 //! \return MOS_STATUS 1890 //! MOS_STATUS_SUCCESS if success, else fail reason 1891 //! PopulateEncParam(uint8_t meMethod,void * cmd)1892 virtual MOS_STATUS PopulateEncParam( 1893 uint8_t meMethod, 1894 void *cmd) { return MOS_STATUS_SUCCESS; } 1895 1896 //! 1897 //! \brief Set MHW_VDBOX_AVC_IMG_STATE parameter 1898 //! 1899 //! \param [in] cmdBuffer 1900 //! pointer to command buffer 1901 //! \param [in] secondLevelBatchBuffer 1902 //! pointer to second level batch buffer 1903 //! 1904 //! \return MOS_STATUS 1905 //! MOS_STATUS_SUCCESS if success, else fail reason 1906 //! PopulatePakParam(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER secondLevelBatchBuffer)1907 virtual MOS_STATUS PopulatePakParam( 1908 PMOS_COMMAND_BUFFER cmdBuffer, 1909 PMHW_BATCH_BUFFER secondLevelBatchBuffer) { return MOS_STATUS_SUCCESS; } 1910 1911 EncodeAvcPar *m_avcPar = nullptr; //!< AVC PAR parameters 1912 bool m_populateTargetUsage = false; 1913 #endif 1914 1915 //! 1916 //! \brief Set frame store Id for avc codec. 1917 //! \details 1918 //! \return frameIdx 1919 //! [in] frame index 1920 //! \return MOS_STATUS 1921 //! MOS_STATUS_SUCCESS if success, else fail reason 1922 //! 1923 MOS_STATUS SetFrameStoreIds(uint8_t frameIdx); 1924 1925 void fill_pad_with_value(PMOS_SURFACE psSurface, uint32_t real_height, uint32_t aligned_height); 1926 }; 1927 #endif // __CODECHAL_ENCODE_AVC_BASE_H__ 1928