| /* |
| * Copyright (c) 2017, Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included |
| * in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| * OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| //! |
| //! \file codechal_encode_vp8.h |
| //! \brief This file defines the base C++ class/interface for VP8 DualPipe encoding |
| //! to be used across CODECHAL components. |
| //! |
| |
| #ifndef __CODECHAL_ENCODE_VP8_H__ |
| #define __CODECHAL_ENCODE_VP8_H__ |
| |
| #include "codechal_encoder_base.h" |
| |
| #define CODECHAL_NUM_VP8_ENC_SYNC_TAGS 36 |
| #define CODECHAL_INIT_DSH_SIZE_VP8_ENC MHW_PAGE_SIZE * 2 |
| |
| #define CODECHAL_ENCODE_VP8_INVALID_PIC_ID CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8 |
| |
| #define VP8_NUM_COEFF_PLANES 4 |
| #define VP8_NUM_COEFF_BANDS 8 |
| #define VP8_NUM_LOCAL_COMPLEXITIES 3 |
| #define VP8_NUM_COEFF_NODES 11 |
| #define VP8_LAST_REF_FLAG 0x1 |
| #define VP8_GOLDEN_REF_FLAG 0x2 |
| #define VP8_ALT_REF_FLAG 0x4 |
| |
| #define INTERMEDIATE_PARTITION0_SIZE (64 * 1024) |
| #define TOKEN_STATISTICS_SIZE (304 * sizeof(uint32_t)) //270 tokens + 34 DWs for partition and segment info |
| #define COEFFS_PROPABILITIES_SIZE (VP8_NUM_COEFF_PLANES * VP8_NUM_COEFF_BANDS * VP8_NUM_LOCAL_COMPLEXITIES * VP8_NUM_COEFF_NODES) //1056 |
| #define HISTOGRAM_SIZE (136 * sizeof(uint32_t)) |
| #define MODE_PROPABILITIES_SIZE 96 |
| #define HEADER_METADATA_SIZE (32 * sizeof(uint32_t)) |
| #define PICTURE_STATE_CMD_SIZE (37 * sizeof(uint32_t)) |
| #define PICTURE_STATE_SIZE (PICTURE_STATE_CMD_SIZE + HEADER_METADATA_SIZE + (16 * sizeof(uint32_t))) // + Extra dws for NOOP and BB_End |
| #define HEADER_METADATA_OFFSET (PICTURE_STATE_CMD_SIZE + (3 * sizeof(uint32_t))) //Add one extra noop |
| #define MPU_BITSTREAM_SIZE 128 |
| #define TPU_BITSTREAM_SIZE 1344 |
| #define ENTROPY_COST_TABLE_SIZE (256 * sizeof(uint32_t)) |
| #define MPU_CURBE_SIZE (24 * sizeof(uint32_t)) |
| #define TOKEN_BITS_DATA_SIZE (16 * sizeof(uint32_t)) |
| #define VP8_KERNEL_DUMP_SIZE (600000 * sizeof(uint32_t)) |
| #define VP8_MODE_COST_UPDATE_SURFACE_SIZE 64 |
| #define REPAK_DECISION_BUF_SIZE (4 * sizeof(uint32_t)) |
| |
| #define VP8_ALL_DC_BIAS_DEFAULT 1500 |
| #define CODECHAL_VP8_QP_MAX 127 |
| #define CODECHAL_VP8_MODE_COST_SURFACE_SIZE 64 |
| |
| #define BRC_CONSTANTSURFACE_VP8 2880 |
| #define CODECHAL_ENCODE_VP8_BRC_CONSTANTSURFACE_WIDTH 64 |
| #define CODECHAL_ENCODE_VP8_BRC_CONSTANTSURFACE_HEIGHT 44 |
| |
| //*------------------------------------------------------------------------------ |
| //* Codec Definitions |
| //*------------------------------------------------------------------------------ |
| |
| enum CodechalEncodeVp8MbencKernelStateIdx |
| { |
| CODECHAL_ENCODE_VP8_MBENC_IDX_I_CHROMA = 0, |
| CODECHAL_ENCODE_VP8_MBENC_IDX_I_LUMA, |
| CODECHAL_ENCODE_VP8_MBENC_IDX_P, |
| CODECHAL_ENCODE_VP8_MBENC_IDX_NUM |
| }; |
| |
| enum CodechalEncodeVp8BrcKernelStateIdx |
| { |
| CODECHAL_ENCODE_VP8_BRC_IDX_IFRAMEDIST = 0, |
| CODECHAL_ENCODE_VP8_BRC_IDX_INIT, |
| CODECHAL_ENCODE_VP8_BRC_IDX_RESET, |
| CODECHAL_ENCODE_VP8_BRC_IDX_UPDATE, |
| CODECHAL_ENCODE_VP8_BRC_IDX_NUM, |
| }; |
| |
| enum CodechalEncodeVp8MbpakKernelStateIdx |
| { |
| CODECHAL_ENCODE_VP8_MBPAK_IDX_PHASE1 = 0, |
| CODECHAL_ENCODE_VP8_MBPAK_IDX_PHASE2, |
| CODECHAL_ENCODE_VP8_MBPAK_IDX_NUM |
| }; |
| |
| static const uint8_t CodecHal_TargetUsageToMode_VP8[NUM_TARGET_USAGE_MODES] = |
| { |
| encodeNormalMode, |
| encodeQualityMode, |
| encodeQualityMode, |
| encodeNormalMode, |
| encodeNormalMode, |
| encodeNormalMode, |
| encodePerformanceMode, |
| encodePerformanceMode |
| }; |
| |
| struct CodechalVp8ModeCostUpdateSurface |
| { |
| union |
| { |
| struct |
| { |
| uint32_t : 16; |
| uint32_t Intra16x16 : 16; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW0; |
| |
| union |
| { |
| struct |
| { |
| uint32_t : 16; |
| uint32_t Intra4x4 : 16; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW1; |
| |
| union |
| { |
| struct |
| { |
| uint32_t Inter16x8 : 16; |
| uint32_t Inter8x8 : 16; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW2; |
| |
| union |
| { |
| struct |
| { |
| uint32_t : 16; |
| uint32_t Inter4x4 : 16; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW3; |
| |
| union |
| { |
| struct |
| { |
| uint32_t : 32; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW4; |
| |
| union |
| { |
| struct |
| { |
| uint32_t : 32; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW5; |
| |
| union |
| { |
| struct |
| { |
| uint32_t IntraNonDCPenalty16x16 : 16; |
| uint32_t IntraNonDCPenalty4x4 : 16; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW6; |
| |
| union |
| { |
| struct |
| { |
| uint32_t RefFrameCostIntra : 16; |
| uint32_t RefFrameCostLast : 16; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW7; |
| |
| union |
| { |
| struct |
| { |
| uint32_t RefFrameCostGold : 16; |
| uint32_t RefFrameCostAlt : 16; |
| }; |
| struct |
| { |
| uint32_t Value; |
| }; |
| } DW8; |
| |
| }; |
| |
| struct CodechalBindingTableVp8BrcUpdate |
| { |
| uint32_t dwBrcHistoryBuffer; |
| uint32_t dwBrcPakStatisticsOutputBuffer; |
| uint32_t dwBrcMSDKPakSurfaceBuffer; |
| uint32_t dwBrcEncoderCfgReadBuffer; |
| uint32_t dwBrcEncoderCfgWriteBuffer; |
| uint32_t dwBrcMbPak1CurbeWriteBuffer; |
| uint32_t dwBrcMbPak2CurbeWriteBuffer; |
| uint32_t dwBrcMbPakInputMSDKBuffer; |
| uint32_t dwBrcMbPakTableData; |
| uint32_t dwBrcMbEncCurbeReadBuffer; |
| uint32_t dwBrcMbEncCurbeWriteData; |
| uint32_t dwBrcMpuCurbeReadBuffer; |
| uint32_t dwBrcMpuCurbeWriteData; |
| uint32_t dwBrcTpuCurbeReadBuffer; |
| uint32_t dwBrcTpuCurbeWriteData; |
| uint32_t dwBrcDistortionBuffer; |
| uint32_t dwBrcConstantData; |
| uint32_t dwVp8BrcSegmentationMap; |
| uint32_t dwBindingTableStartOffset; |
| uint32_t dwNumBindingTableEntries; |
| }; |
| |
| struct CodechalBindingTableVp8Mbenc |
| { |
| uint32_t dwVp8MBEncMBOut; |
| uint32_t dwVp8MBEncCurrY; |
| uint32_t dwVp8MBEncCurrUV; |
| uint32_t dwVp8MBEncMVDataFromME; |
| uint32_t dwVp8MBEncIndMVData; |
| uint32_t dwVp8MBEncCurrPic; |
| uint32_t dwVp8MBEncLastRefPic; |
| uint32_t dwVp8MBEncGoldenRefPic; |
| uint32_t dwVp8MBEncAlternateRefPic; |
| uint32_t dwVp8MBEncRef1Pic; |
| uint32_t dwVp8MBEncRef2Pic; |
| uint32_t dwVp8MBEncRef3Pic; |
| uint32_t dwVp8MBEncMBModeCostLuma; |
| uint32_t dwVp8MBEncBlockModeCost; |
| uint32_t dwVp8MBEncChromaRecon; |
| uint32_t dwVp8MBEncPerMBQuantDataI; |
| uint32_t dwVp8MBEncPerMBQuantDataP; |
| uint32_t dwVp8MBEncRefMBCount; |
| uint32_t dwVp8MBEncVMEInterPred; |
| uint32_t dwVp8MBEncVMEDebugStreamoutI; |
| uint32_t dwVp8MBEncVMEDebugStreamoutP; |
| uint32_t dwVp8MBEncSegmentationMap; |
| uint32_t dwVp8MBEncSegmentationMapP; |
| uint32_t dwVp8MBEncHistogram; |
| uint32_t dwVp8MBEncHistogramP; |
| uint32_t dwVp8MBEncVME; |
| uint32_t dwBindingTableStartOffset; |
| uint32_t dwNumBindingTableEntries; |
| uint32_t dwVp8InterPredDistortion; |
| uint32_t dwVp8PerMVDataSurface; |
| uint32_t dwVp8MBModeCostUpdateSurface; |
| uint32_t dwVp8MBEncBRCDist; |
| uint32_t dwVp8MBEncVMECoarseIntra; |
| uint32_t dwVp8MbEncCurrYDownscaled; |
| uint32_t dwVp8MbEncSwscoreboardI; |
| uint32_t dwVp8MbEncSwscoreboardP; |
| }; |
| |
| struct CodechalBindingTableVp8Me |
| { |
| uint32_t dwVp8MEMVDataSurface; |
| uint32_t dwVp816xMEMVDataSurface; |
| uint32_t dwVp8MeDist; |
| uint32_t dwVp8MeBrcDist; |
| uint32_t dwVp8MeCurrPic; |
| uint32_t dwVp8MeRef1Pic; |
| uint32_t dwVp8MeRef2Pic; |
| uint32_t dwVp8MeRef3Pic; |
| uint32_t dwVp8MeLastRefPic; |
| uint32_t dwVp8MeGoldenRefPic; |
| uint32_t dwVp8MeAlternateRefPic; |
| uint32_t dwBindingTableStartOffset; |
| uint32_t dwNumBindingTableEntries; |
| }; |
| |
| struct CodechalBindingTableVp8Mbpak |
| { |
| uint32_t dwVp8MBPakPerMBOut; |
| uint32_t dwVp8MBPakCurrY; |
| uint32_t dwVp8MBPakCurrUV; |
| uint32_t dwVp8MBPakLastRefY; |
| uint32_t dwVp8MBPakLastRefUV; |
| uint32_t dwVp8MBPakGoldenRefY; |
| uint32_t dwVp8MBPakGoldenRefUV; |
| uint32_t dwVp8MBPakAlternateRefY; |
| uint32_t dwVp8MBPakAlternateRefUV; |
| uint32_t dwVp8MBPakIndMVData; |
| uint32_t dwVp8MBPakCurrReconY; |
| uint32_t dwVp8MBPakCurrReconUV; |
| uint32_t dwVp8MBPakRowBuffY; |
| uint32_t dwVp8MBPakRowBuffUV; |
| uint32_t dwVp8MBPakColBuffY; |
| uint32_t dwVp8MBPakColBuffUV; |
| uint32_t dwVp8MBPakDebugStreamout; |
| uint32_t dwBindingTableStartOffset; |
| uint32_t dwNumBindingTableEntries; |
| }; |
| |
| struct CodechalBindingTableVp8Mpu |
| { |
| uint32_t dwVp8MpuHistogram; |
| uint32_t dwVp8MpuReferenceModeProbability; |
| uint32_t dwVp8MpuModeProbability; |
| uint32_t dwVp8MpuReferenceTokenProbability; |
| uint32_t dwVp8MpuTokenProbability; |
| uint32_t dwVp8MpuFrameHeaderBitstream; |
| uint32_t dwVp8MpuHeaderMetaData; |
| uint32_t dwVp8MpuPictureState; |
| uint32_t dwVp8MpuMpuBitstream; |
| uint32_t dwVp8MpuKernelDebugDump; |
| uint32_t dwVp8MpuEntropyCost; |
| uint32_t dwVp8MpuTokenBitsData; |
| uint32_t dwBindingTableStartOffset; |
| uint32_t dwNumBindingTableEntries; |
| uint32_t dwVp8MpuModeCostUpdateSurface; |
| }; |
| |
| struct CodechalBindingTableVp8Tpu |
| { |
| uint32_t dwVp8TpuPakTokenStatistics; |
| uint32_t dwVp8TpuTokenUpdateFlags; |
| uint32_t dwVp8TpuEntropyCost; |
| uint32_t dwVp8TpuFrameHeaderBitstream; |
| uint32_t dwVp8TpuDefaultTokenProbability; |
| uint32_t dwVp8TpuPictureState; |
| uint32_t dwVp8TpuMpuCurbeData; |
| uint32_t dwVp8TpuHeaderMetaData; |
| uint32_t dwVp8TpuTokenProbability; |
| uint32_t dwVp8TpuPakHardwareTokenProbabilityPass1; |
| uint32_t dwVp8TpuKeyFrameTokenProbability; |
| uint32_t dwVp8TpuUpdatedTokenProbability; |
| uint32_t dwVp8TpuPakHardwareTokenProbabilityPass2; |
| uint32_t dwVp8TpuKernelDebugDump; |
| uint32_t dwVp8TpuRepakDecision; |
| uint32_t dwBindingTableStartOffset; |
| uint32_t dwNumBindingTableEntries; |
| }; |
| |
| struct CodechalVp8BrcInitResetCurbeParams |
| { |
| CODEC_PICTURE CurrPic; |
| PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; |
| PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; |
| uint32_t dwFrameWidth; |
| uint32_t dwFrameHeight; |
| uint32_t dwAVBRAccuracy; |
| uint32_t dwAVBRConvergence; |
| double *pdBrcInitCurrentTargetBufFullInBits; // Passed back to Render Interface |
| double *pdBrcInitResetInputBitsPerFrame; // Passed back to Render Interface |
| uint32_t *pdwBrcInitResetBufSizeInBits; // Passed back to Render Interface |
| bool bInitBrc; |
| bool bMbBrcEnabled; |
| uint32_t dwFramerate; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalVp8BrcUpdateCurbeParams |
| { |
| CODEC_PICTURE CurrPic; |
| PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; |
| PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; |
| PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pSliceParams; |
| PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; |
| uint16_t wPictureCodingType; |
| uint32_t dwAVBRAccuracy; |
| uint32_t dwAVBRConvergence; |
| uint32_t dwFrameWidthInMB; |
| uint32_t dwFrameHeightInMB; |
| uint32_t dwBrcInitResetBufSizeInBits; |
| double dBrcInitResetInputBitsPerFrame; |
| double *pdBrcInitCurrentTargetBufFullInBits; // Passed in and back |
| bool bHmeEnabled; |
| bool bInitBrc; |
| bool bUsedAsRef; |
| uint8_t ucKernelMode; // Normal/Quality/Performance |
| uint32_t dwVp8BrcNumPakPasses; |
| uint32_t dwHeaderBytesInserted; // dwHeaderBytesInserted is for WAAVCSWHeaderInsertion and is 0 otherwise |
| bool bMultiRefQpEnabled; |
| uint32_t wFrameNumber; |
| }; |
| |
| struct CodechalVp8MeCurbeParams |
| { |
| PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; |
| PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; |
| uint32_t dwFrameWidth; |
| uint32_t dwFrameFieldHeight; |
| uint16_t wPictureCodingType; |
| bool b16xME; |
| bool b16xMeEnabled; |
| uint8_t ucKernelMode; |
| }; |
| |
| struct CodechalVp8MbencCurbeParams |
| { |
| PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; |
| PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; |
| PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; |
| PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pVp8SliceParams; |
| PCODEC_REF_LIST *ppRefList; |
| uint16_t wPicWidthInMb; |
| uint16_t wFieldFrameHeightInMb; |
| uint16_t wPictureCodingType; |
| bool bHmeEnabled; |
| bool bVmeKernelDump; |
| bool bMbEncIFrameDistEnabled; |
| bool bBrcEnabled; |
| uint8_t ucKernelMode; // normal, performance, quality. |
| bool bMbEncIFrameDistInUse; |
| PCODEC_PICTURE pCurrOriginalPic; |
| PCODEC_PICTURE pLastRefPic; |
| PCODEC_PICTURE pGoldenRefPic; |
| PCODEC_PICTURE pAlternateRefPic; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalVp8MbpakCurbeParams |
| { |
| PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; |
| PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; |
| PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; |
| PCODEC_REF_LIST *ppRefList; |
| uint16_t wPicWidthInMb; |
| uint16_t wFieldFrameHeightInMb; |
| uint16_t wPictureCodingType; |
| bool bHmeEnabled; |
| bool bVmeKernelDump; |
| uint8_t ucKernelMode; // normal, performance, quality. |
| CODECHAL_MEDIA_STATE_TYPE EncFunctionType; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalVp8MpuCurbeParams |
| { |
| PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; |
| PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; |
| PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; |
| uint16_t wPictureCodingType; |
| bool bVmeKernelDump; |
| uint8_t ucKernelMode; // normal, performance, quality. |
| CODECHAL_MEDIA_STATE_TYPE EncFunctionType; |
| }; |
| |
| struct CodechalVp8TpuCurbeParams |
| { |
| PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams; |
| PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; |
| PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData; |
| uint16_t wPictureCodingType; |
| uint16_t wPicWidthInMb; |
| uint16_t wFieldFrameHeightInMb; |
| bool bVmeKernelDump; |
| uint8_t ucKernelMode; // normal, performance, quality. |
| CODECHAL_MEDIA_STATE_TYPE EncFunctionType; |
| bool bRebinarizationFrameHdr; |
| bool bAdaptiveRePak; |
| }; |
| |
| struct CodechalVp8BrcInitResetSurfaceParams |
| { |
| PMOS_RESOURCE presBrcHistoryBuffer; |
| PMOS_SURFACE psMeBrcDistortionBuffer; |
| uint32_t dwMeBrcDistortionBottomFieldOffset; |
| uint32_t dwDownscaledWidthInMb4x; |
| uint32_t dwDownscaledFrameHeightInMb4x; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalVp8BrcUpdateSurfaceParams |
| { |
| PMHW_KERNEL_STATE pMbEncKernelState; |
| PMOS_RESOURCE presBrcHistoryBuffer; // BRC history buffer |
| PMOS_RESOURCE presBrcPakStatisticBuffer; // BRC PAKStatistic buffer |
| PMOS_RESOURCE presVp8BrcConstantDataBuffer; |
| PMOS_RESOURCE presVp8EncoderCfgCommandReadBuffer; |
| PMOS_RESOURCE presVp8EncoderCfgCommandWriteBuffer; |
| PMOS_RESOURCE presVp8PakQPInputTable; |
| PMOS_RESOURCE presMbCodeBuffer; |
| PMOS_SURFACE ps4xMeDistortionBuffer; |
| PMOS_SURFACE psMeBrcDistortionBuffer; |
| MOS_RESOURCE resMbBrcConstDataBuffer; |
| uint32_t dwDownscaledWidthInMb4x; |
| uint32_t dwDownscaledFrameFieldHeightInMb4x; |
| bool bMbBrcEnabled; |
| PMOS_SURFACE psSegmentationMap; |
| uint32_t dwEncoderCfgCommandOffset; |
| PMHW_KERNEL_STATE pKernelState; |
| uint16_t wPictureCodingType; // I, P frame |
| uint32_t dwBrcPakStatisticsSize; |
| }; |
| |
| struct CodechalVp8MeSurfaceParams |
| { |
| PCODEC_REF_LIST *ppRefList; |
| PCODEC_PICTURE pLastRefPic; |
| PCODEC_PICTURE pGoldenRefPic; |
| PCODEC_PICTURE pAlternateRefPic; |
| PMOS_SURFACE ps4xMeMvDataBuffer; |
| PMOS_SURFACE ps16xMeMvDataBuffer; |
| PMOS_SURFACE psMeDistortionBuffer; |
| PMOS_SURFACE psMeBrcDistortionBuffer; |
| uint32_t dwDownscaledWidthInMb; |
| uint32_t dwDownscaledHeightInMb; |
| uint32_t dwVerticalLineStride; |
| uint32_t dwVerticalLineStrideOffset; |
| bool b16xMeInUse; |
| bool b16xMeEnabled; |
| uint32_t RefCtrl; |
| struct CodechalBindingTableVp8Me* pMeBindingTable; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalVp8MbencSurfaceParams |
| { |
| CODECHAL_MEDIA_STATE_TYPE MediaStateType; |
| PCODEC_REF_LIST *ppRefList; |
| PCODEC_PICTURE pCurrReconstructedPic; |
| PCODEC_PICTURE pLastRefPic; |
| PCODEC_PICTURE pGoldenRefPic; |
| PCODEC_PICTURE pAlternateRefPic; |
| uint16_t wPictureCodingType; |
| PMOS_SURFACE psCurrPicSurface; |
| uint32_t dwCurrPicSurfaceOffset; |
| uint32_t dwMvOffset; |
| uint32_t dwHistogramSize; |
| PMOS_SURFACE ps4xMeMvDataBuffer; |
| PMOS_SURFACE ps4xMeDistortionBuffer; |
| PMOS_SURFACE psMeBrcDistortionBuffer; |
| uint32_t dwOriFrameWidth; |
| uint32_t dwOriFrameHeight; |
| uint32_t dwVerticalLineStride; |
| uint32_t dwVerticalLineStrideOffset; |
| uint32_t dwFrameWidthInMb; |
| uint32_t dwFrameFieldHeightInMb; |
| bool bHmeEnabled; |
| bool bVMEKernelDump; |
| bool bSegmentationEnabled; |
| bool bMbEncIFrameDistInUse; |
| uint32_t dwMbDataOffset; |
| uint32_t uiRefCtrl; |
| PMOS_RESOURCE presPerMB_MBCodeOpData; |
| PMOS_SURFACE psMBModeCostLumaBuffer; |
| PMOS_SURFACE psBlockModeCostBuffer; |
| PMOS_RESOURCE psChromaReconBuffer; //for FF Vp8 |
| PMOS_SURFACE psPerMBQuantDataBuffer; |
| PMOS_RESOURCE presRefMbCountSurface; |
| PMOS_RESOURCE presVmeKernelDumpBuffer; |
| PMOS_SURFACE psSegmentationMap; |
| PMOS_RESOURCE presHistogram; |
| PMOS_SURFACE psInterPredictionDistortionSurface; |
| PMOS_RESOURCE presPerMVDataSurface; |
| PMOS_RESOURCE presModeCostUpdateSurface; |
| PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pVp8SliceParams; |
| struct CodechalBindingTableVp8Mbenc* pMbEncBindingTable; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalVp8MbpakSurfaceParams |
| { |
| CODECHAL_MEDIA_STATE_TYPE MediaStateType; |
| PCODEC_REF_LIST *ppRefList; |
| PCODEC_PICTURE pCurrReconstructedPic; |
| PCODEC_PICTURE pLastRefPic; |
| PCODEC_PICTURE pGoldenRefPic; |
| PCODEC_PICTURE pAlternateRefPic; |
| uint16_t wPictureCodingType; |
| uint32_t dwCurrPicSurfaceOffset; |
| uint32_t dwMvOffset; |
| uint32_t dwOriFrameWidth; |
| uint32_t dwOriFrameHeight; |
| uint32_t dwVerticalLineStride; |
| uint32_t dwVerticalLineStrideOffset; |
| bool bVMEKernelDump; |
| uint32_t dwMbDataOffset; |
| PMOS_RESOURCE presPerMB_MBCodeOpData; |
| PMOS_RESOURCE presRowBuffY; |
| PMOS_RESOURCE presRowBuffUV; |
| PMOS_RESOURCE presColBuffY; |
| PMOS_RESOURCE presColBuffUV; |
| PMOS_RESOURCE presVmeKernelDumpBuffer; |
| struct CodechalBindingTableVp8Mbpak* pMbPakBindingTable; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalVp8MpuSurfaceParams |
| { |
| CODECHAL_MEDIA_STATE_TYPE MediaStateType; |
| uint32_t dwHistogramSize; |
| uint32_t dwModeProbabilitySize; |
| uint32_t dwTokenProbabilitySize; |
| uint32_t dwFrameHeaderSize; |
| uint32_t dwPictureStateSize; |
| uint32_t dwHeaderMetadataSize; |
| uint32_t dwMpuBitstreamSize; |
| uint32_t dwTpuBitstreamSize; |
| uint32_t dwEntropyCostTableSize; |
| uint32_t dwHeaderMetaDataOffset; |
| uint32_t dwTokenBitsDataSize; |
| uint32_t dwKernelDumpSize; |
| bool bVMEKernelDump; |
| PMOS_RESOURCE presHistogram; |
| PMOS_RESOURCE presRefModeProbability; |
| PMOS_RESOURCE presModeProbability; |
| PMOS_RESOURCE presRefTokenProbability; |
| PMOS_RESOURCE presTokenProbability; |
| PMOS_RESOURCE presFrameHeader; |
| PMOS_RESOURCE presHeaderMetadata; |
| PMOS_RESOURCE presPictureState; |
| PMOS_RESOURCE presMpuBitstream; |
| PMOS_RESOURCE presTpuBitstream; |
| PMOS_RESOURCE presVmeKernelDumpBuffer; |
| PMOS_RESOURCE presEntropyCostTable; |
| PMOS_RESOURCE presTokenBitsData; |
| PMOS_RESOURCE presModeCostUpdateBuffer; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalVp8TpuSurfaceParams |
| { |
| CODECHAL_MEDIA_STATE_TYPE MediaStateType; |
| uint32_t dwPakTokenStatsSize; |
| uint32_t dwTokenProbabilitySize; |
| uint32_t dwEntropyCostTableSize; |
| uint32_t dwFrameHeaderSize; |
| uint32_t dwPictureStateSize; |
| uint32_t dwMpuCurbeSize; |
| uint32_t dwHeaderMetadataSize; |
| uint32_t dwHeaderMetaDataOffset; |
| uint32_t dwKernelDumpSize; |
| uint32_t dwRepakDecision; |
| bool bVMEKernelDump; |
| PMOS_RESOURCE presPakTokenStatistics; |
| PMOS_RESOURCE presPakTokenUpdateFlags; |
| PMOS_RESOURCE presEntropyCostTable; |
| PMOS_RESOURCE presFrameHeader; |
| PMOS_RESOURCE presDefaultTokenProbability; |
| PMOS_RESOURCE presPictureState; |
| PMOS_RESOURCE presMpuCurbeData; |
| PMOS_RESOURCE presHeaderMetadata; |
| PMOS_RESOURCE presCurrFrameTokenProbability; |
| PMOS_RESOURCE presHwTokenProbabilityPass1; |
| PMOS_RESOURCE presKeyFrameTokenProbability; |
| PMOS_RESOURCE presUpdatedFrameTokenProbability; |
| PMOS_RESOURCE presHwTokenProbabilityPass2; |
| PMOS_RESOURCE presRepakDecisionSurface; |
| PMOS_RESOURCE presVmeKernelDumpBuffer; |
| PMHW_KERNEL_STATE pKernelState; |
| }; |
| |
| struct CodechalResourcesBrcParams |
| { |
| bool bHWWalker; |
| uint32_t dwDownscaledWidthInMB4x; |
| uint32_t dwDownscaledHeightInMB4x; |
| uint32_t dwDownscaledFieldHeightInMB4x; |
| uint32_t dwFrameWidthInMB; |
| uint32_t dwFrameHeightInMB; |
| }; |
| |
| struct CodechalVp8InitBrcConstantBufferParams |
| { |
| PMOS_INTERFACE pOsInterface; |
| PCODEC_PIC_ID pVp8PicIdx; |
| MOS_RESOURCE resBrcConstantDataBuffer; // sBrcConstantDataBuffer[uiCurrDSH] |
| uint32_t dwMbEncBlockBasedSkipEn; |
| PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; // pAvcPicParams[ucPPSIdx] |
| uint16_t wPictureCodingType; |
| }; |
| |
| struct CodechalVp8InitMbencConstantBufferParams |
| { |
| PMOS_INTERFACE pOsInterface; |
| MOS_SURFACE sMBModeCostLumaBuffer; |
| MOS_SURFACE sBlockModeCostBuffer; |
| PMOS_RESOURCE presHistogram; |
| }; |
| |
| struct CodechalVp8InitPakBufferParams |
| { |
| PMOS_INTERFACE pOsInterface; |
| PMOS_RESOURCE presCoeffProbsBuffer; |
| PMOS_RESOURCE presFrameHeaderBuffer; |
| uint8_t *pHeader; |
| uint32_t dwHeaderSize; |
| }; |
| |
| struct CodechalVp8UpdateMpuTpuBufferParams |
| { |
| PMOS_INTERFACE pOsInterface; |
| PMOS_RESOURCE presCurrFrameTokenProbability; |
| PMOS_RESOURCE presHwTokenProbabilityPass1; |
| PMOS_RESOURCE presKeyFrameTokenProbability; |
| PMOS_RESOURCE presHwTokenProbabilityPass2; |
| PMOS_RESOURCE presRepakDecisionSurface; |
| uint32_t dwCoeffProbsSize; |
| }; |
| |
| struct CodechalVp8MpuTpuBuffers |
| { |
| MOS_RESOURCE resRefModeProbs; |
| MOS_RESOURCE resModeProbs; |
| MOS_RESOURCE resRefCoeffProbs; |
| MOS_RESOURCE resCoeffProbs; |
| MOS_RESOURCE resPictureState; |
| MOS_RESOURCE resMpuBitstream; |
| MOS_RESOURCE resEntropyCostTable; |
| MOS_RESOURCE resTokenBitsData; |
| MOS_RESOURCE resTpuBitstream; |
| MOS_RESOURCE resPakTokenStatistics; |
| MOS_RESOURCE resPakTokenUpdateFlags; |
| MOS_RESOURCE resDefaultTokenProbability; |
| MOS_RESOURCE resKeyFrameTokenProbability; |
| MOS_RESOURCE resUpdatedTokenProbability; |
| MOS_RESOURCE resHwTokenProbabilityPass2; |
| MOS_RESOURCE resRepakDecisionSurface; |
| }; |
| |
| struct CodecEncodeVp8DumpState |
| { |
| MOS_SURFACE *sMbSegmentMapSurface; |
| MOS_SURFACE *s4xMEDistortionBuffer; |
| MHW_KERNEL_STATE *MpuKernelState; |
| MHW_KERNEL_STATE *TpuKernelState; |
| EncodeBrcBuffers *BrcBuffers; |
| struct CodechalVp8MpuTpuBuffers *MpuTpuBuffers; |
| MOS_RESOURCE *resFrameHeader; |
| bool *bBrcEnabled; |
| MOS_RESOURCE *resModeCostUpdateSurface; |
| MOS_RESOURCE *resHistogram; |
| }; |
| |
| struct CodechalEncodeVp8InitKernelStateParams |
| { |
| PMHW_KERNEL_STATE pKernelState; |
| MhwRenderInterface *pRenderEngineInterface; |
| uint8_t* pui8Binary; |
| EncOperation Operation; |
| uint32_t dwKrnStateIdx; |
| uint32_t dwCombinedKernelSize; |
| int32_t iBtCount; |
| int32_t iCurbeCount; |
| }; |
| |
| |
| //! |
| //! \class CodechalEncodeVp8 |
| //! \brief VP8 dual-pipe encoder base class |
| //! \details This class defines the base class for VP8 dual-pipe encoder, it includes |
| //! common member fields, functions, interfaces etc shared by all GENs. |
| //! Gen specific definitions, features should be put into their corresponding classes. |
| //! To create a VP8 dual-pipe encoder instance, client needs to call CodechalEncodeVp8::CreateVp8State() |
| //! |
| class CodechalEncodeVp8 : public CodechalEncoderState |
| { |
| public: |
| |
| //! |
| //! \brief Destructor |
| //! |
| virtual ~CodechalEncodeVp8(); |
| |
| //! |
| //! \brief Allocate resources for encoder instance |
| //! \details It is invoked when initializing encoder instance |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AllocateResources(); |
| |
| //! |
| //! \brief Free encoder resources |
| //! \details It is invoked when destorying encoder instance and it would call |
| //! FreeEncResources(), FreeBrcResources() and FreePakResources() |
| //! |
| //! \return void |
| //! |
| void FreeResources(); |
| |
| //! |
| //! \brief Resize buffers due to resoluton change. |
| //! \details Resize buffers due to resoluton change. |
| //! |
| //! \return void |
| //! |
| virtual void ResizeBuffer(); |
| |
| //! |
| //! \brief Initialize encoder at picture level. Called by each frame. |
| //! |
| //! \param [in] params |
| //! Picture encoding parameters |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS InitializePicture(const EncoderParams& params); |
| |
| //! |
| //! \brief Encode kernel functions |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS ExecuteKernelFunctions(); |
| |
| //! |
| //! \brief Encode command at picture level |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS ExecutePictureLevel(); |
| |
| //! |
| //! \brief Encode command at slice level |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS ExecuteSliceLevel(); |
| |
| //! |
| //! \brief Initialize encoder instance |
| //! \details When GEN specific derived class implements this function to do its own initialization, |
| // it is required that the derived class calls #CodechalEncodeMpeg2::Initialize() first |
| // which would do common initialization for all GENs |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS Initialize(CodechalSetting * codecHalSettings); |
| |
| //! |
| //! \brief Read Image Status |
| //! |
| //! \param [out] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS ReadImageStatus(PMOS_COMMAND_BUFFER cmdBuffer); |
| |
| //! |
| //! \brief Read Mfc image Status |
| //! |
| //! \param [out] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS ReadMfcStatus(PMOS_COMMAND_BUFFER cmdBuffer); |
| |
| //! |
| //! \brief Read Pak Statistics |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_ENCODE_READ_BRC_PAK_STATS_PARAMS |
| //! \param [out] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS ReadBrcPakStatistics( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| EncodeReadBrcPakStatsParams* params); |
| |
| //! |
| //! \brief Get Status Report |
| //! |
| //! \param [in] encodeStatus |
| //! Pointer to CODECHAL_ENCODE_STATUS |
| //! \param [out] pEncodeStatusReport |
| //! Pointer to CODECHAL_ENCODE_STATUS_REPORT |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS GetStatusReport( |
| EncodeStatus *encodeStatus, |
| EncodeStatusReport *pEncodeStatusReport); |
| |
| //! |
| //! \brief Initialize MMC state |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success |
| //! |
| virtual MOS_STATUS InitMmcState(); |
| |
| CODEC_VP8_ENCODE_PIC_PARAMS *m_vp8PicParams = nullptr; //<! Pointer to CodecVp8EncodePictureParams |
| |
| #if USE_CODECHAL_DEBUG_TOOL |
| MOS_STATUS DumpMbEncPakOutput(PCODEC_REF_LIST currRefList, CodechalDebugInterface* debugInterface); |
| #endif // USE_CODECHAL_DEBUG_TOOL |
| |
| protected: |
| |
| //! |
| //! \brief Constructor |
| //! |
| CodechalEncodeVp8( |
| CodechalHwInterface* hwInterface, |
| CodechalDebugInterface* debugInterface, |
| PCODECHAL_STANDARD_INFO standardInfo); |
| |
| //! |
| //! \brief Allocate Resource of BRC |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_RESOURCES_BRC_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AllocateBrcResources (struct CodechalResourcesBrcParams* params); |
| |
| //! |
| //! \brief Help function to allocate a 1D buffer |
| //! |
| //! \param [in,out] buffer |
| //! Pointer to allocated buffer |
| //! \param [in] bufSize |
| //! Buffer size |
| //! \param [in] name |
| //! Buffer name |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AllocateBuffer( |
| PMOS_RESOURCE buffer, |
| uint32_t bufSize, |
| PCCHAR name); |
| |
| //! |
| //! \brief Help function to allocate a generic 2D surface |
| //! |
| //! \param [in,out] surface |
| //! Pointer to allocated surface |
| //! \param [in] surfWidth |
| //! Surface width |
| //! \param [in] surfHeight |
| //! Surface height |
| //! \param [in] name |
| //! Surface name |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AllocateBuffer2D( |
| PMOS_SURFACE surface, |
| uint32_t surfWidth, |
| uint32_t surfHeight, |
| PCCHAR name); |
| |
| //! |
| //! \brief Help function to allocate a batch buffer |
| //! |
| //! \param [in,out] batchBuffer |
| //! Pointer to allocated batch buffer |
| //! \param [in] bufSize |
| //! Buffer size |
| //! \param [in] name |
| //! Batch buffer name |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AllocateBatchBuffer( |
| PMHW_BATCH_BUFFER batchBuffer, |
| uint32_t bufSize, |
| PCCHAR name); |
| |
| //! |
| //! \brief Free all Resources of BRC |
| //! |
| //! \return void |
| //! |
| void FreeBrcResources(); |
| |
| //! |
| //! \brief Initialize kernel state |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS InitKernelState() = 0; |
| |
| //! |
| //! \brief Initialize Mpu Tpu Buffer |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS InitMpuTpuBuffer() = 0; |
| |
| //! |
| //! \brief Set Curbe for BRC Init or Reset |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_BRC_INIT_RESET_CURBE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SetBrcInitResetCurbe(struct CodechalVp8BrcInitResetCurbeParams* params) = 0; |
| |
| //! |
| //! \brief Send Surface for BRC Init or Reset |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_BRC_INIT_RESET_SURFACE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SendBrcInitResetSurfaces( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| struct CodechalVp8BrcInitResetSurfaceParams* params) = 0; |
| |
| //! |
| //! \brief Set Curbe for BRC Update |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_BRC_UPDATE_CURBE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SetBrcUpdateCurbe(struct CodechalVp8BrcUpdateCurbeParams* params) = 0; |
| |
| //! |
| //! \brief Send Surface for BRC Update |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_BRC_UPDATE_SURFACE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS SendBrcUpdateSurfaces( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| struct CodechalVp8BrcUpdateSurfaceParams* params); |
| |
| //! |
| //! \brief Set Curbe for Mb Enc |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_MBENC_CURBE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SetMbEncCurbe(struct CodechalVp8MbencCurbeParams* params) = 0; |
| |
| //! |
| //! \brief Set Curbe for ME |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_ME_CURBE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SetMeCurbe(struct CodechalVp8MeCurbeParams* params) = 0; |
| |
| //! |
| //! \brief Set Curbe for Mpu |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_MPU_CURBE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SetMpuCurbe(struct CodechalVp8MpuCurbeParams* params) = 0; |
| |
| //! |
| //! \brief Set Curbe for Tpu |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_TPU_CURBE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SetTpuCurbe(struct CodechalVp8TpuCurbeParams* params) = 0; |
| |
| //! |
| //! \brief BRC Constant Buffer Initialize |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_INIT_BRC_CONSTANT_BUFFER_PARAMS params |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS InitBrcConstantBuffer(struct CodechalVp8InitBrcConstantBufferParams* params) = 0; |
| |
| //! |
| //! \brief BRC Distortion Buffer Initialize |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS InitBrcDistortionBuffer() = 0; |
| |
| //! |
| //! \brief Send Surface for ME |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_ME_SURFACE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS SendMeSurfaces( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| struct CodechalVp8MeSurfaceParams* params); |
| |
| //! |
| //! \brief Update MpuTpu Buffer with Key Frame |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_UPDATE_MPU_TPU_BUFFER_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS KeyFrameUpdateMpuTpuBuffer(struct CodechalVp8UpdateMpuTpuBufferParams* params) = 0; |
| |
| //! |
| //! \brief Send Surface for Mpu |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_MPU_SURFACE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SendMpuSurfaces( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| struct CodechalVp8MpuSurfaceParams* params) = 0; |
| |
| //! |
| //! \brief Send Surface for Tpu |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_TPU_SURFACE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS SendTpuSurfaces( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| struct CodechalVp8TpuSurfaceParams* params); |
| |
| //! |
| //! \brief MBEnc Constant Buffer initialize |
| //! |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_INIT_MBENC_CONSTANT_BUFFER_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS InitMBEncConstantBuffer(struct CodechalVp8InitMbencConstantBufferParams* params) = 0; |
| |
| //! |
| //! \brief Send Surface for Mb Enc |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! \param [in] params |
| //! Pointer to CODECHAL_VP8_MBENC_SURFACE_PARAMS |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS SendMbEncSurfaces( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| struct CodechalVp8MbencSurfaceParams* params); |
| |
| //! |
| //! \brief Set Pak Stats In Tpu Curbe |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS SetPakStatsInTpuCurbe(PMOS_COMMAND_BUFFER cmdBuffer); |
| |
| //! |
| //! \brief Setup/configure encoder based on sequence parameter set |
| //! \details It is invoked when the encoder receives a new sequence parameter set and it would |
| //! set up and configure the encoder state that used for the sequence |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS SetSequenceStructs(); |
| |
| //! |
| //! \brief Setup/configure encoder based on picture parameter set |
| //! \details It is invoked for every picture and it would set up and configure the |
| //! encoder state that used for current picture |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS SetPictureStructs(); |
| |
| //! |
| //! \brief Invoke BRC Init/Reset kernel |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS BrcInitResetKernel(); |
| |
| //! |
| //! \brief Invoke BRC update kernel |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS BrcUpdateKernel(); |
| |
| //! |
| //! \brief Top level function for invoking MBenc kernel |
| //! |
| //! \param [in] isEncPhase1NotRun |
| //! Indicate if MbEnc Phase 1 is not enabled |
| //! \param [in] isEncPhase2 |
| //! Indicate if MbEnc Phase 2 is enabled |
| //! \param [in] mbEncIFrameDistInUse |
| //! Indicate if MbEnc I-Frame distortion is enabled |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS MbEncKernel( |
| bool isEncPhase1NotRun, |
| bool isEncPhase2, |
| bool mbEncIFrameDistInUse); |
| |
| //! |
| //! \brief Invoke ME kernel |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS MeKernel(); |
| |
| //! |
| //! \brief Invoke MPU kernel |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS MpuKernel(); |
| |
| //! |
| //! \brief Invoke TPU kernel |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS TpuKernel(); |
| |
| //! |
| //! \brief Retrieves the MFC registers and stores them in the dump buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! \param [in] resource |
| //! Pointer to MOS_RESOURCE |
| //! \param [in] baseOffset |
| //! Offset of base |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS SetPakStatsDebugBuffer( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMOS_RESOURCE resource, |
| uint32_t baseOffset); |
| |
| //! |
| //! \brief Encode BRC command at slice level |
| //! |
| //! \param [in] cmdBuffer |
| //! Pointer to MOS_COMMAND_BUFFER |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS EncodeSliceLevelBrc(PMOS_COMMAND_BUFFER cmdBuffer); |
| |
| //! |
| //! \brief Add Batch Buffer End to Picture State Command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AddBBEndToPicStateCmd(); |
| |
| //! |
| //! \brief Get maximum BT count |
| //! |
| //! \return uint32_t |
| //! Maximum BT count |
| //! |
| uint32_t GetMaxBtCount(); |
| |
| #if USE_CODECHAL_DEBUG_TOOL |
| MOS_STATUS DumpVp8EncodePicParams(PCODEC_VP8_ENCODE_PIC_PARAMS picParams); |
| |
| MOS_STATUS DumpVp8EncodeSeqParams(PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams); |
| #endif // USE_CODECHAL_DEBUG_TOOL |
| |
| MEDIA_FEATURE_TABLE * m_skuTable = nullptr; // SKU table |
| MEDIA_WA_TABLE * m_waTable = nullptr; // SKU table |
| |
| // Parameters passed by application |
| CODEC_VP8_ENCODE_SEQUENCE_PARAMS * m_vp8SeqParams = nullptr; |
| CODEC_VP8_ENCODE_QUANT_DATA * m_vp8QuantData = nullptr; |
| CODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE *m_vp8SliceParams = nullptr; |
| |
| uint8_t* m_kernelBinary = nullptr; //!< Pointer to the kernel binary |
| uint32_t m_combinedKernelSize = 0; //!< Combined kernel binary size |
| |
| CODEC_PIC_ID m_picIdx[CODEC_MAX_NUM_REF_FRAME_NON_AVC]; |
| PCODEC_REF_LIST m_refList[CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8]; |
| |
| bool m_hmeEnabled = false; |
| bool m_b16XMeEnabled = false; |
| bool m_hmeDone = false; |
| bool m_b16XMeDone = false; |
| bool m_refCtrlOptimizationDone = false; |
| bool m_brcInit = false; |
| bool m_brcReset = false; |
| bool m_brcEnabled = false; |
| bool m_mbBrcEnabled = false; |
| bool m_mbEncIFrameDistEnabled = false; |
| bool m_brcDistortionBufferSupported = false; |
| bool m_initBrcDistortionBuffer = false; |
| bool m_brcConstantBufferSupported = false; |
| bool m_brcSegMapSupported = false; |
| bool m_mbEncCurbeSetInBrcUpdate; |
| bool m_mbPakCurbeSetInBrcUpdate = false; |
| bool m_mpuCurbeSetInBrcUpdate; |
| bool m_tpuCurbeSetInBrcUpdate; |
| bool m_mfxEncoderConfigCommandInitialized = false; |
| bool m_adaptiveRepakSupported = false; |
| bool m_repakSupported = false; |
| uint16_t m_usMinPakPasses = 0; |
| uint16_t m_usRepakPassIterVal = 0; // n th pass when Repak is executed |
| |
| // MB Enc |
| MHW_KERNEL_STATE m_mbEncKernelStates[CODECHAL_ENCODE_VP8_MBENC_IDX_NUM]; |
| uint32_t m_numMbEncEncKrnStates = 0; |
| uint32_t m_mbEncIFrameDshSize = 0; |
| struct CodechalBindingTableVp8Mbenc m_mbEncBindingTable; |
| uint32_t m_mbEncBlockBasedSkipEn = 0; |
| MOS_RESOURCE m_resRefMbCountSurface; |
| MOS_SURFACE m_mbModeCostLumaBuffer = {}; |
| MOS_SURFACE m_blockModeCostBuffer = {}; |
| MOS_RESOURCE m_chromaReconBuffer; // for fixed function VP8 |
| MOS_SURFACE m_perMbQuantDataBuffer = {}; |
| MOS_RESOURCE m_resPredMvDataSurface; |
| MOS_RESOURCE m_resHistogram; |
| MOS_RESOURCE m_resModeCostUpdateSurface; |
| // MBRC = 1: internal segment map (sInSegmentMapSurface) is provided from BRC update kernel |
| // MBRC = 0: external segment map (sMbSegmentMapSurface) is provided from the app, ignore internal segment map |
| MOS_SURFACE m_inSegmentMapSurface = {}; |
| MOS_SURFACE m_mbSegmentMapSurface = {}; // var of type MOS_SURFACE of Mb segment map surface |
| |
| // MPU & TPU Buffers |
| struct CodechalVp8MpuTpuBuffers m_mpuTpuBuffers; |
| |
| // TPU |
| MHW_KERNEL_STATE m_tpuKernelState; |
| struct CodechalBindingTableVp8Tpu m_tpuBindingTable = {}; |
| |
| // MPU |
| MHW_KERNEL_STATE m_mpuKernelState; |
| struct CodechalBindingTableVp8Mpu m_mpuBindingTable = {}; |
| |
| // VME Scratch Buffers |
| MOS_RESOURCE m_resVmeKernelDumpBuffer; |
| bool m_vmeKernelDump; |
| |
| //HW pak |
| MOS_RESOURCE m_resIntraRowStoreScratchBuffer; |
| MOS_RESOURCE m_resFrameHeader; |
| MOS_RESOURCE m_resPakIntermediateBuffer; |
| |
| // ME |
| MHW_KERNEL_STATE m_meKernelState; |
| struct CodechalBindingTableVp8Me m_meBindingTable = {}; |
| MOS_SURFACE m_s4XMemvDataBuffer; |
| MOS_SURFACE m_s16XMemvDataBuffer = {}; |
| MOS_SURFACE m_s4XMeDistortionBuffer; |
| |
| uint32_t m_averageKeyFrameQp = 0; |
| uint32_t m_averagePFrameQp = 0; |
| uint32_t m_pFramePositionInGop = 0; |
| // BRC Params, these parameters not used for BDW |
| MHW_KERNEL_STATE m_brcKernelStates[CODECHAL_ENCODE_VP8_BRC_IDX_NUM]; |
| struct CodechalBindingTableVp8BrcUpdate m_brcUpdateBindingTable = {}; |
| EncodeBrcBuffers m_brcBuffers; |
| uint16_t m_usAvbrAccuracy = 0; |
| uint16_t m_usAvbrConvergence = 0; |
| double m_dBrcInitCurrentTargetBufFullInBits = 0; |
| double m_dBrcInitResetInputBitsPerFrame = 0; |
| uint32_t m_brcInitResetBufSizeInBits = 0; |
| uint32_t m_brcConstantSurfaceWidth = 0; |
| uint32_t m_brcConstantSurfaceHeight = 0; |
| |
| uint32_t m_frameRate = 0; |
| }; |
| |
| #endif // __CODECHAL_ENCODER_VP8_H__ |
