1 /* 2 * Copyright (c) 2017, 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_vp8.h 24 //! \brief This file defines the base C++ class/interface for VP8 DualPipe encoding 25 //! to be used across CODECHAL components. 26 //! 27 28 #ifndef __CODECHAL_ENCODE_VP8_H__ 29 #define __CODECHAL_ENCODE_VP8_H__ 30 31 #include "codechal_encoder_base.h" 32 33 #define CODECHAL_NUM_VP8_ENC_SYNC_TAGS 36 34 #define CODECHAL_INIT_DSH_SIZE_VP8_ENC MHW_PAGE_SIZE * 2 35 36 #define CODECHAL_ENCODE_VP8_INVALID_PIC_ID CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8 37 38 #define VP8_NUM_COEFF_PLANES 4 39 #define VP8_NUM_COEFF_BANDS 8 40 #define VP8_NUM_LOCAL_COMPLEXITIES 3 41 #define VP8_NUM_COEFF_NODES 11 42 #define VP8_LAST_REF_FLAG 0x1 43 #define VP8_GOLDEN_REF_FLAG 0x2 44 #define VP8_ALT_REF_FLAG 0x4 45 46 #define INTERMEDIATE_PARTITION0_SIZE (64 * 1024) 47 #define TOKEN_STATISTICS_SIZE (304 * sizeof(uint32_t)) //270 tokens + 34 DWs for partition and segment info 48 #define COEFFS_PROPABILITIES_SIZE (VP8_NUM_COEFF_PLANES * VP8_NUM_COEFF_BANDS * VP8_NUM_LOCAL_COMPLEXITIES * VP8_NUM_COEFF_NODES) //1056 49 #define HISTOGRAM_SIZE (136 * sizeof(uint32_t)) 50 #define MODE_PROPABILITIES_SIZE 96 51 #define HEADER_METADATA_SIZE (32 * sizeof(uint32_t)) 52 #define PICTURE_STATE_CMD_SIZE (37 * sizeof(uint32_t)) 53 #define PICTURE_STATE_SIZE (PICTURE_STATE_CMD_SIZE + HEADER_METADATA_SIZE + (16 * sizeof(uint32_t))) // + Extra dws for NOOP and BB_End 54 #define HEADER_METADATA_OFFSET (PICTURE_STATE_CMD_SIZE + (3 * sizeof(uint32_t))) //Add one extra noop 55 #define MPU_BITSTREAM_SIZE 128 56 #define TPU_BITSTREAM_SIZE 1344 57 #define ENTROPY_COST_TABLE_SIZE (256 * sizeof(uint32_t)) 58 #define MPU_CURBE_SIZE (24 * sizeof(uint32_t)) 59 #define TOKEN_BITS_DATA_SIZE (16 * sizeof(uint32_t)) 60 #define VP8_KERNEL_DUMP_SIZE (600000 * sizeof(uint32_t)) 61 #define VP8_MODE_COST_UPDATE_SURFACE_SIZE 64 62 #define REPAK_DECISION_BUF_SIZE (4 * sizeof(uint32_t)) 63 64 #define VP8_ALL_DC_BIAS_DEFAULT 1500 65 #define CODECHAL_VP8_QP_MAX 127 66 #define CODECHAL_VP8_MODE_COST_SURFACE_SIZE 64 67 68 #define BRC_CONSTANTSURFACE_VP8 2880 69 #define CODECHAL_ENCODE_VP8_BRC_CONSTANTSURFACE_WIDTH 64 70 #define CODECHAL_ENCODE_VP8_BRC_CONSTANTSURFACE_HEIGHT 44 71 72 //*------------------------------------------------------------------------------ 73 //* Codec Definitions 74 //*------------------------------------------------------------------------------ 75 76 enum CodechalEncodeVp8MbencKernelStateIdx 77 { 78 CODECHAL_ENCODE_VP8_MBENC_IDX_I_CHROMA = 0, 79 CODECHAL_ENCODE_VP8_MBENC_IDX_I_LUMA, 80 CODECHAL_ENCODE_VP8_MBENC_IDX_P, 81 CODECHAL_ENCODE_VP8_MBENC_IDX_NUM 82 }; 83 84 enum CodechalEncodeVp8BrcKernelStateIdx 85 { 86 CODECHAL_ENCODE_VP8_BRC_IDX_IFRAMEDIST = 0, 87 CODECHAL_ENCODE_VP8_BRC_IDX_INIT, 88 CODECHAL_ENCODE_VP8_BRC_IDX_RESET, 89 CODECHAL_ENCODE_VP8_BRC_IDX_UPDATE, 90 CODECHAL_ENCODE_VP8_BRC_IDX_NUM, 91 }; 92 93 enum CodechalEncodeVp8MbpakKernelStateIdx 94 { 95 CODECHAL_ENCODE_VP8_MBPAK_IDX_PHASE1 = 0, 96 CODECHAL_ENCODE_VP8_MBPAK_IDX_PHASE2, 97 CODECHAL_ENCODE_VP8_MBPAK_IDX_NUM 98 }; 99 100 static const uint8_t CodecHal_TargetUsageToMode_VP8[NUM_TARGET_USAGE_MODES] = 101 { 102 encodeNormalMode, 103 encodeQualityMode, 104 encodeQualityMode, 105 encodeNormalMode, 106 encodeNormalMode, 107 encodeNormalMode, 108 encodePerformanceMode, 109 encodePerformanceMode 110 }; 111 112 struct CodechalVp8ModeCostUpdateSurface 113 { 114 union 115 { 116 struct 117 { 118 uint32_t : 16; 119 uint32_t Intra16x16 : 16; 120 }; 121 struct 122 { 123 uint32_t Value; 124 }; 125 } DW0; 126 127 union 128 { 129 struct 130 { 131 uint32_t : 16; 132 uint32_t Intra4x4 : 16; 133 }; 134 struct 135 { 136 uint32_t Value; 137 }; 138 } DW1; 139 140 union 141 { 142 struct 143 { 144 uint32_t Inter16x8 : 16; 145 uint32_t Inter8x8 : 16; 146 }; 147 struct 148 { 149 uint32_t Value; 150 }; 151 } DW2; 152 153 union 154 { 155 struct 156 { 157 uint32_t : 16; 158 uint32_t Inter4x4 : 16; 159 }; 160 struct 161 { 162 uint32_t Value; 163 }; 164 } DW3; 165 166 union 167 { 168 struct 169 { 170 uint32_t : 32; 171 }; 172 struct 173 { 174 uint32_t Value; 175 }; 176 } DW4; 177 178 union 179 { 180 struct 181 { 182 uint32_t : 32; 183 }; 184 struct 185 { 186 uint32_t Value; 187 }; 188 } DW5; 189 190 union 191 { 192 struct 193 { 194 uint32_t IntraNonDCPenalty16x16 : 16; 195 uint32_t IntraNonDCPenalty4x4 : 16; 196 }; 197 struct 198 { 199 uint32_t Value; 200 }; 201 } DW6; 202 203 union 204 { 205 struct 206 { 207 uint32_t RefFrameCostIntra : 16; 208 uint32_t RefFrameCostLast : 16; 209 }; 210 struct 211 { 212 uint32_t Value; 213 }; 214 } DW7; 215 216 union 217 { 218 struct 219 { 220 uint32_t RefFrameCostGold : 16; 221 uint32_t RefFrameCostAlt : 16; 222 }; 223 struct 224 { 225 uint32_t Value; 226 }; 227 } DW8; 228 229 }; 230 231 struct CodechalBindingTableVp8BrcUpdate 232 { 233 uint32_t dwBrcHistoryBuffer; 234 uint32_t dwBrcPakStatisticsOutputBuffer; 235 uint32_t dwBrcMSDKPakSurfaceBuffer; 236 uint32_t dwBrcEncoderCfgReadBuffer; 237 uint32_t dwBrcEncoderCfgWriteBuffer; 238 uint32_t dwBrcMbPak1CurbeWriteBuffer; 239 uint32_t dwBrcMbPak2CurbeWriteBuffer; 240 uint32_t dwBrcMbPakInputMSDKBuffer; 241 uint32_t dwBrcMbPakTableData; 242 uint32_t dwBrcMbEncCurbeReadBuffer; 243 uint32_t dwBrcMbEncCurbeWriteData; 244 uint32_t dwBrcMpuCurbeReadBuffer; 245 uint32_t dwBrcMpuCurbeWriteData; 246 uint32_t dwBrcTpuCurbeReadBuffer; 247 uint32_t dwBrcTpuCurbeWriteData; 248 uint32_t dwBrcDistortionBuffer; 249 uint32_t dwBrcConstantData; 250 uint32_t dwVp8BrcSegmentationMap; 251 uint32_t dwBindingTableStartOffset; 252 uint32_t dwNumBindingTableEntries; 253 }; 254 255 struct CodechalBindingTableVp8Mbenc 256 { 257 uint32_t dwVp8MBEncMBOut; 258 uint32_t dwVp8MBEncCurrY; 259 uint32_t dwVp8MBEncCurrUV; 260 uint32_t dwVp8MBEncMVDataFromME; 261 uint32_t dwVp8MBEncIndMVData; 262 uint32_t dwVp8MBEncCurrPic; 263 uint32_t dwVp8MBEncLastRefPic; 264 uint32_t dwVp8MBEncGoldenRefPic; 265 uint32_t dwVp8MBEncAlternateRefPic; 266 uint32_t dwVp8MBEncRef1Pic; 267 uint32_t dwVp8MBEncRef2Pic; 268 uint32_t dwVp8MBEncRef3Pic; 269 uint32_t dwVp8MBEncMBModeCostLuma; 270 uint32_t dwVp8MBEncBlockModeCost; 271 uint32_t dwVp8MBEncChromaRecon; 272 uint32_t dwVp8MBEncPerMBQuantDataI; 273 uint32_t dwVp8MBEncPerMBQuantDataP; 274 uint32_t dwVp8MBEncRefMBCount; 275 uint32_t dwVp8MBEncVMEInterPred; 276 uint32_t dwVp8MBEncVMEDebugStreamoutI; 277 uint32_t dwVp8MBEncVMEDebugStreamoutP; 278 uint32_t dwVp8MBEncSegmentationMap; 279 uint32_t dwVp8MBEncSegmentationMapP; 280 uint32_t dwVp8MBEncHistogram; 281 uint32_t dwVp8MBEncHistogramP; 282 uint32_t dwVp8MBEncVME; 283 uint32_t dwBindingTableStartOffset; 284 uint32_t dwNumBindingTableEntries; 285 uint32_t dwVp8InterPredDistortion; 286 uint32_t dwVp8PerMVDataSurface; 287 uint32_t dwVp8MBModeCostUpdateSurface; 288 uint32_t dwVp8MBEncBRCDist; 289 uint32_t dwVp8MBEncVMECoarseIntra; 290 uint32_t dwVp8MbEncCurrYDownscaled; 291 uint32_t dwVp8MbEncSwscoreboardI; 292 uint32_t dwVp8MbEncSwscoreboardP; 293 }; 294 295 struct CodechalBindingTableVp8Me 296 { 297 uint32_t dwVp8MEMVDataSurface; 298 uint32_t dwVp816xMEMVDataSurface; 299 uint32_t dwVp8MeDist; 300 uint32_t dwVp8MeBrcDist; 301 uint32_t dwVp8MeCurrPic; 302 uint32_t dwVp8MeRef1Pic; 303 uint32_t dwVp8MeRef2Pic; 304 uint32_t dwVp8MeRef3Pic; 305 uint32_t dwVp8MeLastRefPic; 306 uint32_t dwVp8MeGoldenRefPic; 307 uint32_t dwVp8MeAlternateRefPic; 308 uint32_t dwBindingTableStartOffset; 309 uint32_t dwNumBindingTableEntries; 310 }; 311 312 struct CodechalBindingTableVp8Mbpak 313 { 314 uint32_t dwVp8MBPakPerMBOut; 315 uint32_t dwVp8MBPakCurrY; 316 uint32_t dwVp8MBPakCurrUV; 317 uint32_t dwVp8MBPakLastRefY; 318 uint32_t dwVp8MBPakLastRefUV; 319 uint32_t dwVp8MBPakGoldenRefY; 320 uint32_t dwVp8MBPakGoldenRefUV; 321 uint32_t dwVp8MBPakAlternateRefY; 322 uint32_t dwVp8MBPakAlternateRefUV; 323 uint32_t dwVp8MBPakIndMVData; 324 uint32_t dwVp8MBPakCurrReconY; 325 uint32_t dwVp8MBPakCurrReconUV; 326 uint32_t dwVp8MBPakRowBuffY; 327 uint32_t dwVp8MBPakRowBuffUV; 328 uint32_t dwVp8MBPakColBuffY; 329 uint32_t dwVp8MBPakColBuffUV; 330 uint32_t dwVp8MBPakDebugStreamout; 331 uint32_t dwBindingTableStartOffset; 332 uint32_t dwNumBindingTableEntries; 333 }; 334 335 struct CodechalBindingTableVp8Mpu 336 { 337 uint32_t dwVp8MpuHistogram; 338 uint32_t dwVp8MpuReferenceModeProbability; 339 uint32_t dwVp8MpuModeProbability; 340 uint32_t dwVp8MpuReferenceTokenProbability; 341 uint32_t dwVp8MpuTokenProbability; 342 uint32_t dwVp8MpuFrameHeaderBitstream; 343 uint32_t dwVp8MpuHeaderMetaData; 344 uint32_t dwVp8MpuPictureState; 345 uint32_t dwVp8MpuMpuBitstream; 346 uint32_t dwVp8MpuKernelDebugDump; 347 uint32_t dwVp8MpuEntropyCost; 348 uint32_t dwVp8MpuTokenBitsData; 349 uint32_t dwBindingTableStartOffset; 350 uint32_t dwNumBindingTableEntries; 351 uint32_t dwVp8MpuModeCostUpdateSurface; 352 }; 353 354 struct CodechalBindingTableVp8Tpu 355 { 356 uint32_t dwVp8TpuPakTokenStatistics; 357 uint32_t dwVp8TpuTokenUpdateFlags; 358 uint32_t dwVp8TpuEntropyCost; 359 uint32_t dwVp8TpuFrameHeaderBitstream; 360 uint32_t dwVp8TpuDefaultTokenProbability; 361 uint32_t dwVp8TpuPictureState; 362 uint32_t dwVp8TpuMpuCurbeData; 363 uint32_t dwVp8TpuHeaderMetaData; 364 uint32_t dwVp8TpuTokenProbability; 365 uint32_t dwVp8TpuPakHardwareTokenProbabilityPass1; 366 uint32_t dwVp8TpuKeyFrameTokenProbability; 367 uint32_t dwVp8TpuUpdatedTokenProbability; 368 uint32_t dwVp8TpuPakHardwareTokenProbabilityPass2; 369 uint32_t dwVp8TpuKernelDebugDump; 370 uint32_t dwVp8TpuRepakDecision; 371 uint32_t dwBindingTableStartOffset; 372 uint32_t dwNumBindingTableEntries; 373 }; 374 375 struct CodechalVp8BrcInitResetCurbeParams 376 { 377 CODEC_PICTURE CurrPic; 378 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; 379 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; 380 uint32_t dwFrameWidth; 381 uint32_t dwFrameHeight; 382 uint32_t dwAVBRAccuracy; 383 uint32_t dwAVBRConvergence; 384 double *pdBrcInitCurrentTargetBufFullInBits; // Passed back to Render Interface 385 double *pdBrcInitResetInputBitsPerFrame; // Passed back to Render Interface 386 uint32_t *pdwBrcInitResetBufSizeInBits; // Passed back to Render Interface 387 bool bInitBrc; 388 bool bMbBrcEnabled; 389 uint32_t dwFramerate; 390 PMHW_KERNEL_STATE pKernelState; 391 }; 392 393 struct CodechalVp8BrcUpdateCurbeParams 394 { 395 CODEC_PICTURE CurrPic; 396 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; 397 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; 398 PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pSliceParams; 399 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; 400 uint16_t wPictureCodingType; 401 uint32_t dwAVBRAccuracy; 402 uint32_t dwAVBRConvergence; 403 uint32_t dwFrameWidthInMB; 404 uint32_t dwFrameHeightInMB; 405 uint32_t dwBrcInitResetBufSizeInBits; 406 double dBrcInitResetInputBitsPerFrame; 407 double *pdBrcInitCurrentTargetBufFullInBits; // Passed in and back 408 bool bHmeEnabled; 409 bool bInitBrc; 410 bool bUsedAsRef; 411 uint8_t ucKernelMode; // Normal/Quality/Performance 412 uint32_t dwVp8BrcNumPakPasses; 413 uint32_t dwHeaderBytesInserted; // dwHeaderBytesInserted is for WAAVCSWHeaderInsertion and is 0 otherwise 414 bool bMultiRefQpEnabled; 415 uint32_t wFrameNumber; 416 }; 417 418 struct CodechalVp8MeCurbeParams 419 { 420 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; 421 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; 422 uint32_t dwFrameWidth; 423 uint32_t dwFrameFieldHeight; 424 uint16_t wPictureCodingType; 425 bool b16xME; 426 bool b16xMeEnabled; 427 uint8_t ucKernelMode; 428 }; 429 430 struct CodechalVp8MbencCurbeParams 431 { 432 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; 433 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; 434 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; 435 PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pVp8SliceParams; 436 PCODEC_REF_LIST *ppRefList; 437 uint16_t wPicWidthInMb; 438 uint16_t wFieldFrameHeightInMb; 439 uint16_t wPictureCodingType; 440 bool bHmeEnabled; 441 bool bVmeKernelDump; 442 bool bMbEncIFrameDistEnabled; 443 bool bBrcEnabled; 444 uint8_t ucKernelMode; // normal, performance, quality. 445 bool bMbEncIFrameDistInUse; 446 PCODEC_PICTURE pCurrOriginalPic; 447 PCODEC_PICTURE pLastRefPic; 448 PCODEC_PICTURE pGoldenRefPic; 449 PCODEC_PICTURE pAlternateRefPic; 450 PMHW_KERNEL_STATE pKernelState; 451 }; 452 453 struct CodechalVp8MbpakCurbeParams 454 { 455 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; 456 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; 457 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; 458 PCODEC_REF_LIST *ppRefList; 459 uint16_t wPicWidthInMb; 460 uint16_t wFieldFrameHeightInMb; 461 uint16_t wPictureCodingType; 462 bool bHmeEnabled; 463 bool bVmeKernelDump; 464 uint8_t ucKernelMode; // normal, performance, quality. 465 CODECHAL_MEDIA_STATE_TYPE EncFunctionType; 466 PMHW_KERNEL_STATE pKernelState; 467 }; 468 469 struct CodechalVp8MpuCurbeParams 470 { 471 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; 472 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; 473 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; 474 uint16_t wPictureCodingType; 475 bool bVmeKernelDump; 476 uint8_t ucKernelMode; // normal, performance, quality. 477 CODECHAL_MEDIA_STATE_TYPE EncFunctionType; 478 }; 479 480 struct CodechalVp8TpuCurbeParams 481 { 482 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; 483 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; 484 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; 485 uint16_t wPictureCodingType; 486 uint16_t wPicWidthInMb; 487 uint16_t wFieldFrameHeightInMb; 488 bool bVmeKernelDump; 489 uint8_t ucKernelMode; // normal, performance, quality. 490 CODECHAL_MEDIA_STATE_TYPE EncFunctionType; 491 bool bRebinarizationFrameHdr; 492 bool bAdaptiveRePak; 493 }; 494 495 struct CodechalVp8BrcInitResetSurfaceParams 496 { 497 PMOS_RESOURCE presBrcHistoryBuffer; 498 PMOS_SURFACE psMeBrcDistortionBuffer; 499 uint32_t dwMeBrcDistortionBottomFieldOffset; 500 uint32_t dwDownscaledWidthInMb4x; 501 uint32_t dwDownscaledFrameHeightInMb4x; 502 PMHW_KERNEL_STATE pKernelState; 503 }; 504 505 struct CodechalVp8BrcUpdateSurfaceParams 506 { 507 PMHW_KERNEL_STATE pMbEncKernelState; 508 PMOS_RESOURCE presBrcHistoryBuffer; // BRC history buffer 509 PMOS_RESOURCE presBrcPakStatisticBuffer; // BRC PAKStatistic buffer 510 PMOS_RESOURCE presVp8BrcConstantDataBuffer; 511 PMOS_RESOURCE presVp8EncoderCfgCommandReadBuffer; 512 PMOS_RESOURCE presVp8EncoderCfgCommandWriteBuffer; 513 PMOS_RESOURCE presVp8PakQPInputTable; 514 PMOS_RESOURCE presMbCodeBuffer; 515 PMOS_SURFACE ps4xMeDistortionBuffer; 516 PMOS_SURFACE psMeBrcDistortionBuffer; 517 MOS_RESOURCE resMbBrcConstDataBuffer; 518 uint32_t dwDownscaledWidthInMb4x; 519 uint32_t dwDownscaledFrameFieldHeightInMb4x; 520 bool bMbBrcEnabled; 521 PMOS_SURFACE psSegmentationMap; 522 uint32_t dwEncoderCfgCommandOffset; 523 PMHW_KERNEL_STATE pKernelState; 524 uint16_t wPictureCodingType; // I, P frame 525 uint32_t dwBrcPakStatisticsSize; 526 }; 527 528 struct CodechalVp8MeSurfaceParams 529 { 530 PCODEC_REF_LIST *ppRefList; 531 PCODEC_PICTURE pLastRefPic; 532 PCODEC_PICTURE pGoldenRefPic; 533 PCODEC_PICTURE pAlternateRefPic; 534 PMOS_SURFACE ps4xMeMvDataBuffer; 535 PMOS_SURFACE ps16xMeMvDataBuffer; 536 PMOS_SURFACE psMeDistortionBuffer; 537 PMOS_SURFACE psMeBrcDistortionBuffer; 538 uint32_t dwDownscaledWidthInMb; 539 uint32_t dwDownscaledHeightInMb; 540 uint32_t dwVerticalLineStride; 541 uint32_t dwVerticalLineStrideOffset; 542 bool b16xMeInUse; 543 bool b16xMeEnabled; 544 uint32_t RefCtrl; 545 struct CodechalBindingTableVp8Me* pMeBindingTable; 546 PMHW_KERNEL_STATE pKernelState; 547 }; 548 549 struct CodechalVp8MbencSurfaceParams 550 { 551 CODECHAL_MEDIA_STATE_TYPE MediaStateType; 552 PCODEC_REF_LIST *ppRefList; 553 PCODEC_PICTURE pCurrReconstructedPic; 554 PCODEC_PICTURE pLastRefPic; 555 PCODEC_PICTURE pGoldenRefPic; 556 PCODEC_PICTURE pAlternateRefPic; 557 uint16_t wPictureCodingType; 558 PMOS_SURFACE psCurrPicSurface; 559 uint32_t dwCurrPicSurfaceOffset; 560 uint32_t dwMvOffset; 561 uint32_t dwHistogramSize; 562 PMOS_SURFACE ps4xMeMvDataBuffer; 563 PMOS_SURFACE ps4xMeDistortionBuffer; 564 PMOS_SURFACE psMeBrcDistortionBuffer; 565 uint32_t dwOriFrameWidth; 566 uint32_t dwOriFrameHeight; 567 uint32_t dwVerticalLineStride; 568 uint32_t dwVerticalLineStrideOffset; 569 uint32_t dwFrameWidthInMb; 570 uint32_t dwFrameFieldHeightInMb; 571 bool bHmeEnabled; 572 bool bVMEKernelDump; 573 bool bSegmentationEnabled; 574 bool bMbEncIFrameDistInUse; 575 uint32_t dwMbDataOffset; 576 uint32_t uiRefCtrl; 577 PMOS_RESOURCE presPerMB_MBCodeOpData; 578 PMOS_SURFACE psMBModeCostLumaBuffer; 579 PMOS_SURFACE psBlockModeCostBuffer; 580 PMOS_RESOURCE psChromaReconBuffer; //for FF Vp8 581 PMOS_SURFACE psPerMBQuantDataBuffer; 582 PMOS_RESOURCE presRefMbCountSurface; 583 PMOS_RESOURCE presVmeKernelDumpBuffer; 584 PMOS_SURFACE psSegmentationMap; 585 PMOS_RESOURCE presHistogram; 586 PMOS_SURFACE psInterPredictionDistortionSurface; 587 PMOS_RESOURCE presPerMVDataSurface; 588 PMOS_RESOURCE presModeCostUpdateSurface; 589 PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pVp8SliceParams; 590 struct CodechalBindingTableVp8Mbenc* pMbEncBindingTable; 591 PMHW_KERNEL_STATE pKernelState; 592 }; 593 594 struct CodechalVp8MbpakSurfaceParams 595 { 596 CODECHAL_MEDIA_STATE_TYPE MediaStateType; 597 PCODEC_REF_LIST *ppRefList; 598 PCODEC_PICTURE pCurrReconstructedPic; 599 PCODEC_PICTURE pLastRefPic; 600 PCODEC_PICTURE pGoldenRefPic; 601 PCODEC_PICTURE pAlternateRefPic; 602 uint16_t wPictureCodingType; 603 uint32_t dwCurrPicSurfaceOffset; 604 uint32_t dwMvOffset; 605 uint32_t dwOriFrameWidth; 606 uint32_t dwOriFrameHeight; 607 uint32_t dwVerticalLineStride; 608 uint32_t dwVerticalLineStrideOffset; 609 bool bVMEKernelDump; 610 uint32_t dwMbDataOffset; 611 PMOS_RESOURCE presPerMB_MBCodeOpData; 612 PMOS_RESOURCE presRowBuffY; 613 PMOS_RESOURCE presRowBuffUV; 614 PMOS_RESOURCE presColBuffY; 615 PMOS_RESOURCE presColBuffUV; 616 PMOS_RESOURCE presVmeKernelDumpBuffer; 617 struct CodechalBindingTableVp8Mbpak* pMbPakBindingTable; 618 PMHW_KERNEL_STATE pKernelState; 619 }; 620 621 struct CodechalVp8MpuSurfaceParams 622 { 623 CODECHAL_MEDIA_STATE_TYPE MediaStateType; 624 uint32_t dwHistogramSize; 625 uint32_t dwModeProbabilitySize; 626 uint32_t dwTokenProbabilitySize; 627 uint32_t dwFrameHeaderSize; 628 uint32_t dwPictureStateSize; 629 uint32_t dwHeaderMetadataSize; 630 uint32_t dwMpuBitstreamSize; 631 uint32_t dwTpuBitstreamSize; 632 uint32_t dwEntropyCostTableSize; 633 uint32_t dwHeaderMetaDataOffset; 634 uint32_t dwTokenBitsDataSize; 635 uint32_t dwKernelDumpSize; 636 bool bVMEKernelDump; 637 PMOS_RESOURCE presHistogram; 638 PMOS_RESOURCE presRefModeProbability; 639 PMOS_RESOURCE presModeProbability; 640 PMOS_RESOURCE presRefTokenProbability; 641 PMOS_RESOURCE presTokenProbability; 642 PMOS_RESOURCE presFrameHeader; 643 PMOS_RESOURCE presHeaderMetadata; 644 PMOS_RESOURCE presPictureState; 645 PMOS_RESOURCE presMpuBitstream; 646 PMOS_RESOURCE presTpuBitstream; 647 PMOS_RESOURCE presVmeKernelDumpBuffer; 648 PMOS_RESOURCE presEntropyCostTable; 649 PMOS_RESOURCE presTokenBitsData; 650 PMOS_RESOURCE presModeCostUpdateBuffer; 651 PMHW_KERNEL_STATE pKernelState; 652 }; 653 654 struct CodechalVp8TpuSurfaceParams 655 { 656 CODECHAL_MEDIA_STATE_TYPE MediaStateType; 657 uint32_t dwPakTokenStatsSize; 658 uint32_t dwTokenProbabilitySize; 659 uint32_t dwEntropyCostTableSize; 660 uint32_t dwFrameHeaderSize; 661 uint32_t dwPictureStateSize; 662 uint32_t dwMpuCurbeSize; 663 uint32_t dwHeaderMetadataSize; 664 uint32_t dwHeaderMetaDataOffset; 665 uint32_t dwKernelDumpSize; 666 uint32_t dwRepakDecision; 667 bool bVMEKernelDump; 668 PMOS_RESOURCE presPakTokenStatistics; 669 PMOS_RESOURCE presPakTokenUpdateFlags; 670 PMOS_RESOURCE presEntropyCostTable; 671 PMOS_RESOURCE presFrameHeader; 672 PMOS_RESOURCE presDefaultTokenProbability; 673 PMOS_RESOURCE presPictureState; 674 PMOS_RESOURCE presMpuCurbeData; 675 PMOS_RESOURCE presHeaderMetadata; 676 PMOS_RESOURCE presCurrFrameTokenProbability; 677 PMOS_RESOURCE presHwTokenProbabilityPass1; 678 PMOS_RESOURCE presKeyFrameTokenProbability; 679 PMOS_RESOURCE presUpdatedFrameTokenProbability; 680 PMOS_RESOURCE presHwTokenProbabilityPass2; 681 PMOS_RESOURCE presRepakDecisionSurface; 682 PMOS_RESOURCE presVmeKernelDumpBuffer; 683 PMHW_KERNEL_STATE pKernelState; 684 }; 685 686 struct CodechalResourcesBrcParams 687 { 688 bool bHWWalker; 689 uint32_t dwDownscaledWidthInMB4x; 690 uint32_t dwDownscaledHeightInMB4x; 691 uint32_t dwDownscaledFieldHeightInMB4x; 692 uint32_t dwFrameWidthInMB; 693 uint32_t dwFrameHeightInMB; 694 }; 695 696 struct CodechalVp8InitBrcConstantBufferParams 697 { 698 PMOS_INTERFACE pOsInterface; 699 PCODEC_PIC_ID pVp8PicIdx; 700 MOS_RESOURCE resBrcConstantDataBuffer; // sBrcConstantDataBuffer[uiCurrDSH] 701 uint32_t dwMbEncBlockBasedSkipEn; 702 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; // pAvcPicParams[ucPPSIdx] 703 uint16_t wPictureCodingType; 704 }; 705 706 struct CodechalVp8InitMbencConstantBufferParams 707 { 708 PMOS_INTERFACE pOsInterface; 709 MOS_SURFACE sMBModeCostLumaBuffer; 710 MOS_SURFACE sBlockModeCostBuffer; 711 PMOS_RESOURCE presHistogram; 712 }; 713 714 struct CodechalVp8InitPakBufferParams 715 { 716 PMOS_INTERFACE pOsInterface; 717 PMOS_RESOURCE presCoeffProbsBuffer; 718 PMOS_RESOURCE presFrameHeaderBuffer; 719 uint8_t *pHeader; 720 uint32_t dwHeaderSize; 721 }; 722 723 struct CodechalVp8UpdateMpuTpuBufferParams 724 { 725 PMOS_INTERFACE pOsInterface; 726 PMOS_RESOURCE presCurrFrameTokenProbability; 727 PMOS_RESOURCE presHwTokenProbabilityPass1; 728 PMOS_RESOURCE presKeyFrameTokenProbability; 729 PMOS_RESOURCE presHwTokenProbabilityPass2; 730 PMOS_RESOURCE presRepakDecisionSurface; 731 uint32_t dwCoeffProbsSize; 732 }; 733 734 struct CodechalVp8MpuTpuBuffers 735 { 736 MOS_RESOURCE resRefModeProbs; 737 MOS_RESOURCE resModeProbs; 738 MOS_RESOURCE resRefCoeffProbs; 739 MOS_RESOURCE resCoeffProbs; 740 MOS_RESOURCE resPictureState; 741 MOS_RESOURCE resMpuBitstream; 742 MOS_RESOURCE resEntropyCostTable; 743 MOS_RESOURCE resTokenBitsData; 744 MOS_RESOURCE resTpuBitstream; 745 MOS_RESOURCE resPakTokenStatistics; 746 MOS_RESOURCE resPakTokenUpdateFlags; 747 MOS_RESOURCE resDefaultTokenProbability; 748 MOS_RESOURCE resKeyFrameTokenProbability; 749 MOS_RESOURCE resUpdatedTokenProbability; 750 MOS_RESOURCE resHwTokenProbabilityPass2; 751 MOS_RESOURCE resRepakDecisionSurface; 752 }; 753 754 struct CodecEncodeVp8DumpState 755 { 756 MOS_SURFACE *sMbSegmentMapSurface; 757 MOS_SURFACE *s4xMEDistortionBuffer; 758 MHW_KERNEL_STATE *MpuKernelState; 759 MHW_KERNEL_STATE *TpuKernelState; 760 EncodeBrcBuffers *BrcBuffers; 761 struct CodechalVp8MpuTpuBuffers *MpuTpuBuffers; 762 MOS_RESOURCE *resFrameHeader; 763 bool *bBrcEnabled; 764 MOS_RESOURCE *resModeCostUpdateSurface; 765 MOS_RESOURCE *resHistogram; 766 }; 767 768 struct CodechalEncodeVp8InitKernelStateParams 769 { 770 PMHW_KERNEL_STATE pKernelState; 771 MhwRenderInterface *pRenderEngineInterface; 772 uint8_t* pui8Binary; 773 EncOperation Operation; 774 uint32_t dwKrnStateIdx; 775 uint32_t dwCombinedKernelSize; 776 int32_t iBtCount; 777 int32_t iCurbeCount; 778 }; 779 780 781 //! 782 //! \class CodechalEncodeVp8 783 //! \brief VP8 dual-pipe encoder base class 784 //! \details This class defines the base class for VP8 dual-pipe encoder, it includes 785 //! common member fields, functions, interfaces etc shared by all GENs. 786 //! Gen specific definitions, features should be put into their corresponding classes. 787 //! To create a VP8 dual-pipe encoder instance, client needs to call CodechalEncodeVp8::CreateVp8State() 788 //! 789 class CodechalEncodeVp8 : public CodechalEncoderState 790 { 791 public: 792 793 //! 794 //! \brief Destructor 795 //! 796 virtual ~CodechalEncodeVp8(); 797 798 //! 799 //! \brief Allocate resources for encoder instance 800 //! \details It is invoked when initializing encoder instance 801 //! 802 //! \return MOS_STATUS 803 //! MOS_STATUS_SUCCESS if success, else fail reason 804 //! 805 MOS_STATUS AllocateResources(); 806 807 //! 808 //! \brief Free encoder resources 809 //! \details It is invoked when destorying encoder instance and it would call 810 //! FreeEncResources(), FreeBrcResources() and FreePakResources() 811 //! 812 //! \return void 813 //! 814 void FreeResources(); 815 816 //! 817 //! \brief Resize buffers due to resoluton change. 818 //! \details Resize buffers due to resoluton change. 819 //! 820 //! \return void 821 //! 822 virtual void ResizeBuffer(); 823 824 //! 825 //! \brief Initialize encoder at picture level. Called by each frame. 826 //! 827 //! \param [in] params 828 //! Picture encoding parameters 829 //! 830 //! \return MOS_STATUS 831 //! MOS_STATUS_SUCCESS if success, else fail reason 832 //! 833 MOS_STATUS InitializePicture(const EncoderParams& params); 834 835 //! 836 //! \brief Encode kernel functions 837 //! 838 //! \return MOS_STATUS 839 //! MOS_STATUS_SUCCESS if success, else fail reason 840 //! 841 virtual MOS_STATUS ExecuteKernelFunctions(); 842 843 //! 844 //! \brief Encode command at picture level 845 //! 846 //! \return MOS_STATUS 847 //! MOS_STATUS_SUCCESS if success, else fail reason 848 //! 849 MOS_STATUS ExecutePictureLevel(); 850 851 //! 852 //! \brief Encode command at slice level 853 //! 854 //! \return MOS_STATUS 855 //! MOS_STATUS_SUCCESS if success, else fail reason 856 //! 857 MOS_STATUS ExecuteSliceLevel(); 858 859 //! 860 //! \brief Initialize encoder instance 861 //! \details When GEN specific derived class implements this function to do its own initialization, 862 // it is required that the derived class calls #CodechalEncodeMpeg2::Initialize() first 863 // which would do common initialization for all GENs 864 //! 865 //! \return MOS_STATUS 866 //! MOS_STATUS_SUCCESS if success, else fail reason 867 //! 868 virtual MOS_STATUS Initialize(CodechalSetting * codecHalSettings); 869 870 //! 871 //! \brief Read Image Status 872 //! 873 //! \param [out] cmdBuffer 874 //! Pointer to MOS_COMMAND_BUFFER 875 //! 876 //! \return MOS_STATUS 877 //! MOS_STATUS_SUCCESS if success, else fail reason 878 //! 879 MOS_STATUS ReadImageStatus(PMOS_COMMAND_BUFFER cmdBuffer); 880 881 //! 882 //! \brief Read Mfc image Status 883 //! 884 //! \param [out] cmdBuffer 885 //! Pointer to MOS_COMMAND_BUFFER 886 //! 887 //! \return MOS_STATUS 888 //! MOS_STATUS_SUCCESS if success, else fail reason 889 //! 890 MOS_STATUS ReadMfcStatus(PMOS_COMMAND_BUFFER cmdBuffer); 891 892 //! 893 //! \brief Read Pak Statistics 894 //! 895 //! \param [in] params 896 //! Pointer to CODECHAL_ENCODE_READ_BRC_PAK_STATS_PARAMS 897 //! \param [out] cmdBuffer 898 //! Pointer to MOS_COMMAND_BUFFER 899 //! 900 //! \return MOS_STATUS 901 //! MOS_STATUS_SUCCESS if success, else fail reason 902 //! 903 MOS_STATUS ReadBrcPakStatistics( 904 PMOS_COMMAND_BUFFER cmdBuffer, 905 EncodeReadBrcPakStatsParams* params); 906 907 //! 908 //! \brief Get Status Report 909 //! 910 //! \param [in] encodeStatus 911 //! Pointer to CODECHAL_ENCODE_STATUS 912 //! \param [out] pEncodeStatusReport 913 //! Pointer to CODECHAL_ENCODE_STATUS_REPORT 914 //! 915 //! \return MOS_STATUS 916 //! MOS_STATUS_SUCCESS if success, else fail reason 917 //! 918 MOS_STATUS GetStatusReport( 919 EncodeStatus *encodeStatus, 920 EncodeStatusReport *pEncodeStatusReport); 921 922 //! 923 //! \brief Initialize MMC state 924 //! 925 //! \return MOS_STATUS 926 //! MOS_STATUS_SUCCESS if success 927 //! 928 virtual MOS_STATUS InitMmcState(); 929 930 CODEC_VP8_ENCODE_PIC_PARAMS *m_vp8PicParams = nullptr; //<! Pointer to CodecVp8EncodePictureParams 931 932 #if USE_CODECHAL_DEBUG_TOOL 933 MOS_STATUS DumpMbEncPakOutput(PCODEC_REF_LIST currRefList, CodechalDebugInterface* debugInterface); 934 #endif // USE_CODECHAL_DEBUG_TOOL 935 936 protected: 937 938 //! 939 //! \brief Constructor 940 //! 941 CodechalEncodeVp8( 942 CodechalHwInterface* hwInterface, 943 CodechalDebugInterface* debugInterface, 944 PCODECHAL_STANDARD_INFO standardInfo); 945 946 //! 947 //! \brief Allocate Resource of BRC 948 //! 949 //! \param [in] params 950 //! Pointer to CODECHAL_RESOURCES_BRC_PARAMS 951 //! 952 //! \return MOS_STATUS 953 //! MOS_STATUS_SUCCESS if success, else fail reason 954 //! 955 MOS_STATUS AllocateBrcResources (struct CodechalResourcesBrcParams* params); 956 957 //! 958 //! \brief Help function to allocate a 1D buffer 959 //! 960 //! \param [in,out] buffer 961 //! Pointer to allocated buffer 962 //! \param [in] bufSize 963 //! Buffer size 964 //! \param [in] name 965 //! Buffer name 966 //! 967 //! \return MOS_STATUS 968 //! MOS_STATUS_SUCCESS if success, else fail reason 969 //! 970 MOS_STATUS AllocateBuffer( 971 PMOS_RESOURCE buffer, 972 uint32_t bufSize, 973 PCCHAR name); 974 975 //! 976 //! \brief Help function to allocate a generic 2D surface 977 //! 978 //! \param [in,out] surface 979 //! Pointer to allocated surface 980 //! \param [in] surfWidth 981 //! Surface width 982 //! \param [in] surfHeight 983 //! Surface height 984 //! \param [in] name 985 //! Surface name 986 //! 987 //! \return MOS_STATUS 988 //! MOS_STATUS_SUCCESS if success, else fail reason 989 //! 990 MOS_STATUS AllocateBuffer2D( 991 PMOS_SURFACE surface, 992 uint32_t surfWidth, 993 uint32_t surfHeight, 994 PCCHAR name); 995 996 //! 997 //! \brief Help function to allocate a batch buffer 998 //! 999 //! \param [in,out] batchBuffer 1000 //! Pointer to allocated batch buffer 1001 //! \param [in] bufSize 1002 //! Buffer size 1003 //! \param [in] name 1004 //! Batch buffer name 1005 //! 1006 //! \return MOS_STATUS 1007 //! MOS_STATUS_SUCCESS if success, else fail reason 1008 //! 1009 MOS_STATUS AllocateBatchBuffer( 1010 PMHW_BATCH_BUFFER batchBuffer, 1011 uint32_t bufSize, 1012 PCCHAR name); 1013 1014 //! 1015 //! \brief Free all Resources of BRC 1016 //! 1017 //! \return void 1018 //! 1019 void FreeBrcResources(); 1020 1021 //! 1022 //! \brief Initialize kernel state 1023 //! 1024 //! \return MOS_STATUS 1025 //! MOS_STATUS_SUCCESS if success, else fail reason 1026 //! 1027 virtual MOS_STATUS InitKernelState() = 0; 1028 1029 //! 1030 //! \brief Initialize Mpu Tpu Buffer 1031 //! 1032 //! \return MOS_STATUS 1033 //! MOS_STATUS_SUCCESS if success, else fail reason 1034 //! 1035 virtual MOS_STATUS InitMpuTpuBuffer() = 0; 1036 1037 //! 1038 //! \brief Set Curbe for BRC Init or Reset 1039 //! 1040 //! \param [in] params 1041 //! Pointer to CODECHAL_VP8_BRC_INIT_RESET_CURBE_PARAMS 1042 //! 1043 //! \return MOS_STATUS 1044 //! MOS_STATUS_SUCCESS if success, else fail reason 1045 //! 1046 virtual MOS_STATUS SetBrcInitResetCurbe(struct CodechalVp8BrcInitResetCurbeParams* params) = 0; 1047 1048 //! 1049 //! \brief Send Surface for BRC Init or Reset 1050 //! 1051 //! \param [in] cmdBuffer 1052 //! Pointer to MOS_COMMAND_BUFFER 1053 //! \param [in] params 1054 //! Pointer to CODECHAL_VP8_BRC_INIT_RESET_SURFACE_PARAMS 1055 //! 1056 //! \return MOS_STATUS 1057 //! MOS_STATUS_SUCCESS if success, else fail reason 1058 //! 1059 virtual MOS_STATUS SendBrcInitResetSurfaces( 1060 PMOS_COMMAND_BUFFER cmdBuffer, 1061 struct CodechalVp8BrcInitResetSurfaceParams* params) = 0; 1062 1063 //! 1064 //! \brief Set Curbe for BRC Update 1065 //! 1066 //! \param [in] params 1067 //! Pointer to CODECHAL_VP8_BRC_UPDATE_CURBE_PARAMS 1068 //! 1069 //! \return MOS_STATUS 1070 //! MOS_STATUS_SUCCESS if success, else fail reason 1071 //! 1072 virtual MOS_STATUS SetBrcUpdateCurbe(struct CodechalVp8BrcUpdateCurbeParams* params) = 0; 1073 1074 //! 1075 //! \brief Send Surface for BRC Update 1076 //! 1077 //! \param [in] cmdBuffer 1078 //! Pointer to MOS_COMMAND_BUFFER 1079 //! \param [in] params 1080 //! Pointer to CODECHAL_VP8_BRC_UPDATE_SURFACE_PARAMS 1081 //! 1082 //! \return MOS_STATUS 1083 //! MOS_STATUS_SUCCESS if success, else fail reason 1084 //! 1085 MOS_STATUS SendBrcUpdateSurfaces( 1086 PMOS_COMMAND_BUFFER cmdBuffer, 1087 struct CodechalVp8BrcUpdateSurfaceParams* params); 1088 1089 //! 1090 //! \brief Set Curbe for Mb Enc 1091 //! 1092 //! \param [in] params 1093 //! Pointer to CODECHAL_VP8_MBENC_CURBE_PARAMS 1094 //! 1095 //! \return MOS_STATUS 1096 //! MOS_STATUS_SUCCESS if success, else fail reason 1097 //! 1098 virtual MOS_STATUS SetMbEncCurbe(struct CodechalVp8MbencCurbeParams* params) = 0; 1099 1100 //! 1101 //! \brief Set Curbe for ME 1102 //! 1103 //! \param [in] params 1104 //! Pointer to CODECHAL_VP8_ME_CURBE_PARAMS 1105 //! 1106 //! \return MOS_STATUS 1107 //! MOS_STATUS_SUCCESS if success, else fail reason 1108 //! 1109 virtual MOS_STATUS SetMeCurbe(struct CodechalVp8MeCurbeParams* params) = 0; 1110 1111 //! 1112 //! \brief Set Curbe for Mpu 1113 //! 1114 //! \param [in] params 1115 //! Pointer to CODECHAL_VP8_MPU_CURBE_PARAMS 1116 //! 1117 //! \return MOS_STATUS 1118 //! MOS_STATUS_SUCCESS if success, else fail reason 1119 //! 1120 virtual MOS_STATUS SetMpuCurbe(struct CodechalVp8MpuCurbeParams* params) = 0; 1121 1122 //! 1123 //! \brief Set Curbe for Tpu 1124 //! 1125 //! \param [in] params 1126 //! Pointer to CODECHAL_VP8_TPU_CURBE_PARAMS 1127 //! 1128 //! \return MOS_STATUS 1129 //! MOS_STATUS_SUCCESS if success, else fail reason 1130 //! 1131 virtual MOS_STATUS SetTpuCurbe(struct CodechalVp8TpuCurbeParams* params) = 0; 1132 1133 //! 1134 //! \brief BRC Constant Buffer Initialize 1135 //! 1136 //! \param [in] params 1137 //! Pointer to CODECHAL_VP8_INIT_BRC_CONSTANT_BUFFER_PARAMS params 1138 //! 1139 //! \return MOS_STATUS 1140 //! MOS_STATUS_SUCCESS if success, else fail reason 1141 //! 1142 virtual MOS_STATUS InitBrcConstantBuffer(struct CodechalVp8InitBrcConstantBufferParams* params) = 0; 1143 1144 //! 1145 //! \brief BRC Distortion Buffer Initialize 1146 //! 1147 //! \return MOS_STATUS 1148 //! MOS_STATUS_SUCCESS if success, else fail reason 1149 //! 1150 virtual MOS_STATUS InitBrcDistortionBuffer() = 0; 1151 1152 //! 1153 //! \brief Send Surface for ME 1154 //! 1155 //! \param [in] cmdBuffer 1156 //! Pointer to MOS_COMMAND_BUFFER 1157 //! \param [in] params 1158 //! Pointer to CODECHAL_VP8_ME_SURFACE_PARAMS 1159 //! 1160 //! \return MOS_STATUS 1161 //! MOS_STATUS_SUCCESS if success, else fail reason 1162 //! 1163 MOS_STATUS SendMeSurfaces( 1164 PMOS_COMMAND_BUFFER cmdBuffer, 1165 struct CodechalVp8MeSurfaceParams* params); 1166 1167 //! 1168 //! \brief Update MpuTpu Buffer with Key Frame 1169 //! 1170 //! \param [in] params 1171 //! Pointer to CODECHAL_VP8_UPDATE_MPU_TPU_BUFFER_PARAMS 1172 //! 1173 //! \return MOS_STATUS 1174 //! MOS_STATUS_SUCCESS if success, else fail reason 1175 //! 1176 virtual MOS_STATUS KeyFrameUpdateMpuTpuBuffer(struct CodechalVp8UpdateMpuTpuBufferParams* params) = 0; 1177 1178 //! 1179 //! \brief Send Surface for Mpu 1180 //! 1181 //! \param [in] cmdBuffer 1182 //! Pointer to MOS_COMMAND_BUFFER 1183 //! \param [in] params 1184 //! Pointer to CODECHAL_VP8_MPU_SURFACE_PARAMS 1185 //! 1186 //! \return MOS_STATUS 1187 //! MOS_STATUS_SUCCESS if success, else fail reason 1188 //! 1189 virtual MOS_STATUS SendMpuSurfaces( 1190 PMOS_COMMAND_BUFFER cmdBuffer, 1191 struct CodechalVp8MpuSurfaceParams* params) = 0; 1192 1193 //! 1194 //! \brief Send Surface for Tpu 1195 //! 1196 //! \param [in] cmdBuffer 1197 //! Pointer to MOS_COMMAND_BUFFER 1198 //! \param [in] params 1199 //! Pointer to CODECHAL_VP8_TPU_SURFACE_PARAMS 1200 //! 1201 //! \return MOS_STATUS 1202 //! MOS_STATUS_SUCCESS if success, else fail reason 1203 //! 1204 MOS_STATUS SendTpuSurfaces( 1205 PMOS_COMMAND_BUFFER cmdBuffer, 1206 struct CodechalVp8TpuSurfaceParams* params); 1207 1208 //! 1209 //! \brief MBEnc Constant Buffer initialize 1210 //! 1211 //! \param [in] params 1212 //! Pointer to CODECHAL_VP8_INIT_MBENC_CONSTANT_BUFFER_PARAMS 1213 //! 1214 //! \return MOS_STATUS 1215 //! MOS_STATUS_SUCCESS if success, else fail reason 1216 //! 1217 virtual MOS_STATUS InitMBEncConstantBuffer(struct CodechalVp8InitMbencConstantBufferParams* params) = 0; 1218 1219 //! 1220 //! \brief Send Surface for Mb Enc 1221 //! 1222 //! \param [in] cmdBuffer 1223 //! Pointer to MOS_COMMAND_BUFFER 1224 //! \param [in] params 1225 //! Pointer to CODECHAL_VP8_MBENC_SURFACE_PARAMS 1226 //! 1227 //! \return MOS_STATUS 1228 //! MOS_STATUS_SUCCESS if success, else fail reason 1229 //! 1230 virtual MOS_STATUS SendMbEncSurfaces( 1231 PMOS_COMMAND_BUFFER cmdBuffer, 1232 struct CodechalVp8MbencSurfaceParams* params); 1233 1234 //! 1235 //! \brief Set Pak Stats In Tpu Curbe 1236 //! 1237 //! \param [in] cmdBuffer 1238 //! Pointer to MOS_COMMAND_BUFFER 1239 //! 1240 //! \return MOS_STATUS 1241 //! MOS_STATUS_SUCCESS if success, else fail reason 1242 //! 1243 MOS_STATUS SetPakStatsInTpuCurbe(PMOS_COMMAND_BUFFER cmdBuffer); 1244 1245 //! 1246 //! \brief Setup/configure encoder based on sequence parameter set 1247 //! \details It is invoked when the encoder receives a new sequence parameter set and it would 1248 //! set up and configure the encoder state that used for the sequence 1249 //! 1250 //! \return MOS_STATUS 1251 //! MOS_STATUS_SUCCESS if success, else fail reason 1252 //! 1253 MOS_STATUS SetSequenceStructs(); 1254 1255 //! 1256 //! \brief Setup/configure encoder based on picture parameter set 1257 //! \details It is invoked for every picture and it would set up and configure the 1258 //! encoder state that used for current picture 1259 //! 1260 //! \return MOS_STATUS 1261 //! MOS_STATUS_SUCCESS if success, else fail reason 1262 //! 1263 MOS_STATUS SetPictureStructs(); 1264 1265 //! 1266 //! \brief Invoke BRC Init/Reset kernel 1267 //! 1268 //! \return MOS_STATUS 1269 //! MOS_STATUS_SUCCESS if success, else fail reason 1270 //! 1271 MOS_STATUS BrcInitResetKernel(); 1272 1273 //! 1274 //! \brief Invoke BRC update kernel 1275 //! 1276 //! \return MOS_STATUS 1277 //! MOS_STATUS_SUCCESS if success, else fail reason 1278 //! 1279 MOS_STATUS BrcUpdateKernel(); 1280 1281 //! 1282 //! \brief Top level function for invoking MBenc kernel 1283 //! 1284 //! \param [in] isEncPhase1NotRun 1285 //! Indicate if MbEnc Phase 1 is not enabled 1286 //! \param [in] isEncPhase2 1287 //! Indicate if MbEnc Phase 2 is enabled 1288 //! \param [in] mbEncIFrameDistInUse 1289 //! Indicate if MbEnc I-Frame distortion is enabled 1290 //! 1291 //! \return MOS_STATUS 1292 //! MOS_STATUS_SUCCESS if success, else fail reason 1293 //! 1294 MOS_STATUS MbEncKernel( 1295 bool isEncPhase1NotRun, 1296 bool isEncPhase2, 1297 bool mbEncIFrameDistInUse); 1298 1299 //! 1300 //! \brief Invoke ME kernel 1301 //! 1302 //! \return MOS_STATUS 1303 //! MOS_STATUS_SUCCESS if success, else fail reason 1304 //! 1305 MOS_STATUS MeKernel(); 1306 1307 //! 1308 //! \brief Invoke MPU kernel 1309 //! 1310 //! \return MOS_STATUS 1311 //! MOS_STATUS_SUCCESS if success, else fail reason 1312 //! 1313 MOS_STATUS MpuKernel(); 1314 1315 //! 1316 //! \brief Invoke TPU kernel 1317 //! 1318 //! \return MOS_STATUS 1319 //! MOS_STATUS_SUCCESS if success, else fail reason 1320 //! 1321 MOS_STATUS TpuKernel(); 1322 1323 //! 1324 //! \brief Retrieves the MFC registers and stores them in the dump buffer 1325 //! 1326 //! \param [in] cmdBuffer 1327 //! Pointer to MOS_COMMAND_BUFFER 1328 //! \param [in] resource 1329 //! Pointer to MOS_RESOURCE 1330 //! \param [in] baseOffset 1331 //! Offset of base 1332 //! 1333 //! \return MOS_STATUS 1334 //! MOS_STATUS_SUCCESS if success, else fail reason 1335 //! 1336 MOS_STATUS SetPakStatsDebugBuffer( 1337 PMOS_COMMAND_BUFFER cmdBuffer, 1338 PMOS_RESOURCE resource, 1339 uint32_t baseOffset); 1340 1341 //! 1342 //! \brief Encode BRC command at slice level 1343 //! 1344 //! \param [in] cmdBuffer 1345 //! Pointer to MOS_COMMAND_BUFFER 1346 //! 1347 //! \return MOS_STATUS 1348 //! MOS_STATUS_SUCCESS if success, else fail reason 1349 //! 1350 MOS_STATUS EncodeSliceLevelBrc(PMOS_COMMAND_BUFFER cmdBuffer); 1351 1352 //! 1353 //! \brief Add Batch Buffer End to Picture State Command 1354 //! 1355 //! \return MOS_STATUS 1356 //! MOS_STATUS_SUCCESS if success, else fail reason 1357 //! 1358 MOS_STATUS AddBBEndToPicStateCmd(); 1359 1360 //! 1361 //! \brief Get maximum BT count 1362 //! 1363 //! \return uint32_t 1364 //! Maximum BT count 1365 //! 1366 uint32_t GetMaxBtCount(); 1367 1368 #if USE_CODECHAL_DEBUG_TOOL 1369 MOS_STATUS DumpVp8EncodePicParams(PCODEC_VP8_ENCODE_PIC_PARAMS picParams); 1370 1371 MOS_STATUS DumpVp8EncodeSeqParams(PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams); 1372 #endif // USE_CODECHAL_DEBUG_TOOL 1373 1374 MEDIA_FEATURE_TABLE * m_skuTable = nullptr; // SKU table 1375 MEDIA_WA_TABLE * m_waTable = nullptr; // SKU table 1376 1377 // Parameters passed by application 1378 CODEC_VP8_ENCODE_SEQUENCE_PARAMS * m_vp8SeqParams = nullptr; 1379 CODEC_VP8_ENCODE_QUANT_DATA * m_vp8QuantData = nullptr; 1380 CODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE *m_vp8SliceParams = nullptr; 1381 1382 uint8_t* m_kernelBinary = nullptr; //!< Pointer to the kernel binary 1383 uint32_t m_combinedKernelSize = 0; //!< Combined kernel binary size 1384 1385 CODEC_PIC_ID m_picIdx[CODEC_MAX_NUM_REF_FRAME_NON_AVC]; 1386 PCODEC_REF_LIST m_refList[CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8]; 1387 1388 bool m_hmeEnabled = false; 1389 bool m_b16XMeEnabled = false; 1390 bool m_hmeDone = false; 1391 bool m_b16XMeDone = false; 1392 bool m_refCtrlOptimizationDone = false; 1393 bool m_brcInit = false; 1394 bool m_brcReset = false; 1395 bool m_brcEnabled = false; 1396 bool m_mbBrcEnabled = false; 1397 bool m_mbEncIFrameDistEnabled = false; 1398 bool m_brcDistortionBufferSupported = false; 1399 bool m_initBrcDistortionBuffer = false; 1400 bool m_brcConstantBufferSupported = false; 1401 bool m_brcSegMapSupported = false; 1402 bool m_mbEncCurbeSetInBrcUpdate; 1403 bool m_mbPakCurbeSetInBrcUpdate = false; 1404 bool m_mpuCurbeSetInBrcUpdate; 1405 bool m_tpuCurbeSetInBrcUpdate; 1406 bool m_mfxEncoderConfigCommandInitialized = false; 1407 bool m_adaptiveRepakSupported = false; 1408 bool m_repakSupported = false; 1409 uint16_t m_usMinPakPasses = 0; 1410 uint16_t m_usRepakPassIterVal = 0; // n th pass when Repak is executed 1411 1412 // MB Enc 1413 MHW_KERNEL_STATE m_mbEncKernelStates[CODECHAL_ENCODE_VP8_MBENC_IDX_NUM] = {}; 1414 uint32_t m_numMbEncEncKrnStates = 0; 1415 uint32_t m_mbEncIFrameDshSize = 0; 1416 struct CodechalBindingTableVp8Mbenc m_mbEncBindingTable = {}; 1417 uint32_t m_mbEncBlockBasedSkipEn = 0; 1418 MOS_RESOURCE m_resRefMbCountSurface = {}; 1419 MOS_SURFACE m_mbModeCostLumaBuffer = {}; 1420 MOS_SURFACE m_blockModeCostBuffer = {}; 1421 MOS_RESOURCE m_chromaReconBuffer = {}; // for fixed function VP8 1422 MOS_SURFACE m_perMbQuantDataBuffer = {}; 1423 MOS_RESOURCE m_resPredMvDataSurface = {}; 1424 MOS_RESOURCE m_resHistogram = {}; 1425 MOS_RESOURCE m_resModeCostUpdateSurface = {}; 1426 // MBRC = 1: internal segment map (sInSegmentMapSurface) is provided from BRC update kernel 1427 // MBRC = 0: external segment map (sMbSegmentMapSurface) is provided from the app, ignore internal segment map 1428 MOS_SURFACE m_inSegmentMapSurface = {}; 1429 MOS_SURFACE m_mbSegmentMapSurface = {}; // var of type MOS_SURFACE of Mb segment map surface 1430 1431 // MPU & TPU Buffers 1432 struct CodechalVp8MpuTpuBuffers m_mpuTpuBuffers = {}; 1433 1434 // TPU 1435 MHW_KERNEL_STATE m_tpuKernelState = {}; 1436 struct CodechalBindingTableVp8Tpu m_tpuBindingTable = {}; 1437 1438 // MPU 1439 MHW_KERNEL_STATE m_mpuKernelState = {}; 1440 struct CodechalBindingTableVp8Mpu m_mpuBindingTable = {}; 1441 1442 // VME Scratch Buffers 1443 MOS_RESOURCE m_resVmeKernelDumpBuffer = {}; 1444 bool m_vmeKernelDump = false; 1445 1446 //HW pak 1447 MOS_RESOURCE m_resIntraRowStoreScratchBuffer = {}; 1448 MOS_RESOURCE m_resFrameHeader = {}; 1449 MOS_RESOURCE m_resPakIntermediateBuffer = {}; 1450 1451 // ME 1452 MHW_KERNEL_STATE m_meKernelState; 1453 struct CodechalBindingTableVp8Me m_meBindingTable = {}; 1454 MOS_SURFACE m_s4XMemvDataBuffer; 1455 MOS_SURFACE m_s16XMemvDataBuffer = {}; 1456 MOS_SURFACE m_s4XMeDistortionBuffer; 1457 1458 uint32_t m_averageKeyFrameQp = 0; 1459 uint32_t m_averagePFrameQp = 0; 1460 uint32_t m_pFramePositionInGop = 0; 1461 // BRC Params, these parameters not used for BDW 1462 MHW_KERNEL_STATE m_brcKernelStates[CODECHAL_ENCODE_VP8_BRC_IDX_NUM]; 1463 struct CodechalBindingTableVp8BrcUpdate m_brcUpdateBindingTable = {}; 1464 EncodeBrcBuffers m_brcBuffers; 1465 uint16_t m_usAvbrAccuracy = 0; 1466 uint16_t m_usAvbrConvergence = 0; 1467 double m_dBrcInitCurrentTargetBufFullInBits = 0; 1468 double m_dBrcInitResetInputBitsPerFrame = 0; 1469 uint32_t m_brcInitResetBufSizeInBits = 0; 1470 uint32_t m_brcConstantSurfaceWidth = 0; 1471 uint32_t m_brcConstantSurfaceHeight = 0; 1472 1473 uint32_t m_frameRate = 0; 1474 }; 1475 1476 #endif // __CODECHAL_ENCODER_VP8_H__ 1477