| /* |
| * Copyright (c) 2014-2020, 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 mhw_vdbox_hcp_interface.h |
| //! \brief MHW interface for constructing HCP commands for the Vdbox engine |
| //! \details Defines the interfaces for constructing MHW Vdbox HCP commands across all platforms |
| //! |
| |
| #ifndef _MHW_VDBOX_HCP_INTERFACE_H_ |
| #define _MHW_VDBOX_HCP_INTERFACE_H_ |
| |
| #include "mhw_vdbox.h" |
| #include "mhw_mi.h" |
| #include "codec_def_encode_hevc.h" |
| |
| #define MHW_HCP_WORST_CASE_LCU_CU_TU_INFO (26 * MHW_CACHELINE_SIZE) // 18+4+4 |
| #define MHW_HCP_WORST_CASE_LCU_CU_TU_INFO_REXT (35 * MHW_CACHELINE_SIZE) // 27+4+4 |
| |
| #define MHW_HCP_WORST_CASE_CU_TU_INFO (4 * MHW_CACHELINE_SIZE) // 2+1+1 |
| #define MHW_HCP_WORST_CASE_CU_TU_INFO_REXT (6 * MHW_CACHELINE_SIZE) // 4+1+1 |
| |
| struct MHW_VDBOX_HEVC_PIC_STATE |
| { |
| // Decode |
| PCODEC_HEVC_PIC_PARAMS pHevcPicParams = nullptr; |
| |
| // Encode |
| PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS pHevcEncSeqParams = nullptr; |
| PCODEC_HEVC_ENCODE_PICTURE_PARAMS pHevcEncPicParams = nullptr; |
| bool bSAOEnable = false; |
| bool bNotFirstPass = false; |
| bool bHevcRdoqEnabled = false; |
| bool bUseVDEnc = false; |
| bool sseEnabledInVmeEncode = false; |
| PMHW_BATCH_BUFFER pBatchBuffer = nullptr; |
| bool bBatchBufferInUse = false; |
| bool bRDOQIntraTUDisable = false; |
| uint16_t wRDOQIntraTUThreshold = 0; |
| uint32_t brcNumPakPasses = 0; |
| bool rhodomainRCEnable = false; |
| bool bTransformSkipEnable = false; |
| |
| //FEI multiple passes PAK ---max frame size |
| uint16_t currPass = 0; |
| uint8_t *deltaQp = nullptr; |
| uint32_t maxFrameSize = 0; |
| virtual ~MHW_VDBOX_HEVC_PIC_STATE(){} |
| }; |
| using PMHW_VDBOX_HEVC_PIC_STATE = MHW_VDBOX_HEVC_PIC_STATE * ; |
| |
| typedef struct _MHW_VDBOX_HEVC_TILE_STATE |
| { |
| PCODEC_HEVC_PIC_PARAMS pHevcPicParams; |
| uint16_t *pTileColWidth; |
| uint16_t *pTileRowHeight; |
| } MHW_VDBOX_HEVC_TILE_STATE, *PMHW_VDBOX_HEVC_TILE_STATE; |
| |
| typedef struct _MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS |
| { |
| uint8_t ucMaxBitDepth; |
| uint8_t ucChromaFormat; |
| uint32_t dwCtbLog2SizeY; |
| uint32_t dwPicWidth; |
| uint32_t dwPicHeight; |
| uint32_t dwBufferSize; |
| uint32_t dwMaxFrameSize; |
| }MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS, *PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS; |
| |
| typedef struct _MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS |
| { |
| uint8_t ucMaxBitDepth; |
| uint8_t ucChromaFormat; |
| uint32_t dwPicWidth; |
| uint32_t dwPicHeight; |
| uint32_t dwPicWidthAlloced; |
| uint32_t dwPicHeightAlloced; |
| uint32_t dwCtbLog2SizeY; |
| uint32_t dwCtbLog2SizeYMax; |
| uint32_t dwFrameSize; |
| uint32_t dwFrameSizeAlloced; |
| bool bNeedBiggerSize; |
| }MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS, *PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS; |
| |
| struct MHW_VDBOX_HEVC_REF_IDX_PARAMS |
| { |
| CODEC_PICTURE CurrPic = {}; |
| bool isEncode = false; |
| uint8_t ucList = 0; |
| uint8_t ucNumRefForList = 0; |
| CODEC_PICTURE RefPicList[2][CODEC_MAX_NUM_REF_FRAME_HEVC] = {}; |
| void **hevcRefList = nullptr; |
| int32_t poc_curr_pic = 0; |
| int32_t poc_list[CODEC_MAX_NUM_REF_FRAME_HEVC] = {}; |
| int8_t *pRefIdxMapping = 0; |
| uint16_t RefFieldPicFlag = 0; |
| uint16_t RefBottomFieldFlag = 0; |
| bool bDummyReference = false; |
| virtual ~MHW_VDBOX_HEVC_REF_IDX_PARAMS(){} |
| }; |
| using PMHW_VDBOX_HEVC_REF_IDX_PARAMS = MHW_VDBOX_HEVC_REF_IDX_PARAMS * ; |
| |
| typedef struct _MHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS |
| { |
| uint8_t ucList; |
| char LumaWeights[2][15]; |
| int16_t LumaOffsets[2][15]; |
| char ChromaWeights[2][15][2]; |
| int16_t ChromaOffsets[2][15][2]; |
| } MHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS, *PMHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS; |
| |
| typedef struct _MHW_VDBOX_ENCODE_HEVC_TRANSFORM_SKIP_PARAMS |
| { |
| bool Transformskip_enabled; |
| uint16_t Transformskip_lambda; |
| uint8_t Transformskip_Numzerocoeffs_Factor0; |
| uint8_t Transformskip_Numnonzerocoeffs_Factor0; |
| uint8_t Transformskip_Numzerocoeffs_Factor1; |
| uint8_t Transformskip_Numnonzerocoeffs_Factor1; |
| }MHW_VDBOX_ENCODE_HEVC_TRANSFORM_SKIP_PARAMS, *PMHW_VDBOX_ENCODE_HEVC_TRANSFORM_SKIP_PARAMS; |
| |
| struct MHW_VDBOX_HEVC_SLICE_STATE |
| { |
| PCODEC_PIC_ID pHevcPicIdx = nullptr; |
| PMOS_RESOURCE presDataBuffer = nullptr; |
| uint32_t dwDataBufferOffset = 0; |
| uint32_t dwOffset = 0; |
| uint32_t dwLength = 0; |
| uint32_t dwSliceIndex = 0; |
| bool bLastSlice = false; |
| bool bLastSliceInTile = false; |
| bool bLastSliceInTileColumn = false; |
| bool bHucStreamOut = false; |
| int8_t *pRefIdxMapping = nullptr; |
| bool bSaoLumaFlag = false; |
| bool bSaoChromaFlag = false; |
| |
| PCODEC_HEVC_SLICE_PARAMS pHevcSliceParams = nullptr; |
| PCODEC_HEVC_PIC_PARAMS pHevcPicParams = nullptr; |
| |
| // Encoding Only |
| PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS pEncodeHevcSeqParams = nullptr; |
| PCODEC_HEVC_ENCODE_PICTURE_PARAMS pEncodeHevcPicParams = nullptr; |
| PCODEC_HEVC_ENCODE_SLICE_PARAMS pEncodeHevcSliceParams = nullptr; |
| PBSBuffer pBsBuffer = nullptr; |
| PCODECHAL_NAL_UNIT_PARAMS *ppNalUnitParams = nullptr; |
| bool bFirstPass = false; |
| bool bLastPass = false; |
| bool bIntraRefFetchDisable = false; |
| bool bBrcEnabled = false; |
| uint32_t dwHeaderBytesInserted = 0; |
| uint32_t dwHeaderDummyBytes = 0; |
| uint32_t uiSkipEmulationCheckCount = 0; |
| bool bInsertBeforeSliceHeaders = false; |
| bool bIsLowDelay = false; |
| // Encoding + BRC only |
| PMHW_BATCH_BUFFER pBatchBufferForPakSlices = nullptr; |
| bool bSingleTaskPhaseSupported = false; |
| uint32_t dwBatchBufferForPakSlicesStartOffset = 0; |
| bool bVdencInUse = false; |
| bool bVdencHucInUse = false; |
| bool bWeightedPredInUse = false; |
| PMHW_BATCH_BUFFER pVdencBatchBuffer = nullptr; |
| |
| //Pak related params |
| MHW_VDBOX_ENCODE_HEVC_TRANSFORM_SKIP_PARAMS EncodeHevcTransformSkipParams = {}; |
| bool DeblockingFilterDisable = false; |
| char TcOffsetDiv2 = 0; |
| char BetaOffsetDiv2 = 0; |
| |
| uint8_t RoundingIntra = 0; |
| uint8_t RoundingInter = 0; |
| virtual ~MHW_VDBOX_HEVC_SLICE_STATE(){} |
| }; |
| using PMHW_VDBOX_HEVC_SLICE_STATE = MHW_VDBOX_HEVC_SLICE_STATE * ; |
| |
| typedef struct _MHW_VDBOX_VP9_ENCODE_PIC_STATE |
| { |
| PCODEC_VP9_ENCODE_PIC_PARAMS pVp9PicParams; |
| PCODEC_REF_LIST *ppVp9RefList; |
| PCODEC_VP9_ENCODE_SEQUENCE_PARAMS pVp9SeqParams; |
| |
| union |
| { |
| struct |
| { |
| uint8_t KeyFrame : 1; // [0..1] |
| uint8_t IntraOnly : 1; // [0..1] |
| uint8_t Display : 1; // [0..1] |
| uint8_t ReservedField : 5; // [0] |
| } fields; |
| uint8_t value; |
| } PrevFrameParams; |
| |
| uint32_t dwPrevFrmWidth; |
| uint32_t dwPrevFrmHeight; |
| uint8_t ucTxMode; |
| bool bUseDysRefSurface; |
| bool bNonFirstPassFlag; |
| bool bSSEEnable; |
| bool bVdencPakOnlyPassFlag; |
| uint32_t uiMaxBitRate; |
| uint32_t uiMinBitRate; |
| |
| } MHW_VDBOX_VP9_ENCODE_PIC_STATE, *PMHW_VDBOX_VP9_ENCODE_PIC_STATE; |
| |
| typedef struct _MHW_VDBOX_VP9_PIC_STATE |
| { |
| // Decode |
| PCODEC_VP9_PIC_PARAMS pVp9PicParams; |
| PCODEC_REF_LIST *ppVp9RefList; |
| |
| union |
| { |
| struct |
| { |
| uint8_t KeyFrame : 1; // [0..1] |
| uint8_t IntraOnly : 1; // [0..1] |
| uint8_t Display : 1; // [0..1] |
| uint8_t ReservedField : 5; // [0] |
| } fields; |
| uint8_t value; |
| } PrevFrameParams; |
| |
| uint32_t dwPrevFrmWidth; |
| uint32_t dwPrevFrmHeight; |
| |
| } MHW_VDBOX_VP9_PIC_STATE, *PMHW_VDBOX_VP9_PIC_STATE; |
| |
| typedef struct _MHW_VDBOX_IMAGE_STATUS_CONTROL |
| { |
| union |
| { |
| struct |
| { |
| uint32_t MaxMbConformanceFlag : 1; |
| uint32_t FrameBitcountFlag : 1; |
| uint32_t Panic : 1; |
| uint32_t MissingHuffmanCode : 1; // new addition for JPEG encode |
| uint32_t : 4; |
| uint32_t TotalNumPass : 4; |
| uint32_t VDENCSliceOverflowErrorOccurred : 1; |
| uint32_t NumPassPolarityChange : 2; |
| uint32_t CumulativeSliceQpPolarityChange : 1; |
| uint32_t SuggestedSliceQPDelta : 8; |
| uint32_t CumulativeSliceDeltaQP : 8; |
| }; |
| |
| struct |
| { |
| uint32_t hcpLCUMaxSizeViolate : 1; |
| uint32_t hcpFrameBitCountViolateOverRun : 1; |
| uint32_t hcpFrameBitCountViolateUnderRun : 1; |
| uint32_t : 5; |
| uint32_t hcpTotalPass : 4; |
| uint32_t : 4; |
| uint32_t hcpCumulativeFrameDeltaLF : 7; |
| uint32_t : 1; |
| uint32_t hcpCumulativeFrameDeltaQp : 8; |
| }; |
| |
| struct |
| { |
| uint32_t Value; |
| }; |
| }; |
| }MHW_VDBOX_IMAGE_STATUS_CONTROL, *PMHW_VDBOX_IMAGE_STATUS_CONTROL; |
| |
| typedef struct _MHW_VDBOX_PAK_NUM_OF_SLICES |
| { |
| // Num Slices |
| union |
| { |
| struct |
| { |
| uint32_t NumberOfSlices : 16; |
| uint32_t Reserved : 16; |
| }; |
| |
| struct |
| { |
| uint32_t Value; |
| }; |
| }; |
| }MHW_VDBOX_PAK_NUM_OF_SLICES, *PMHW_VDBOX_PAK_NUM_OF_SLICES; |
| |
| // definition for HEVC/VP9 internal buffer type |
| typedef enum _MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE |
| { |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE = 0x0, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_MV_UP_RT_COL, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_TR_NBR, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_HSSE_RS, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_HSAO_RS, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_CURR_MV_TEMPORAL, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_COLL_MV_TEMPORAL, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_SLC_STATE_STREAMOUT, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_CABAC_STREAMOUT, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_MV_UP_RIGHT_COL, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_INTRA_PRED_UP_RIGHT_COL, |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_INTRA_PRED_LFT_RECON_COL, |
| MHW_VDBOX_VP9_INTERNAL_BUFFER_SEGMENT_ID, |
| MHW_VDBOX_VP9_INTERNAL_BUFFER_HVD_LINE, |
| MHW_VDBOX_VP9_INTERNAL_BUFFER_HVD_TILE |
| } MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE; |
| |
| |
| |
| //! MHW Vdbox Hcp interface |
| /*! |
| This class defines the interfaces for constructing Vdbox Hcp commands across all platforms |
| */ |
| class MhwVdboxHcpInterface |
| { |
| public: |
| //! |
| //! \enum HevcSliceType |
| //! \brief HEVC slice type |
| //! |
| enum HevcSliceType |
| { |
| hevcSliceB = 0, |
| hevcSliceP = 1, |
| hevcSliceI = 2 |
| }; |
| |
| protected: |
| PMOS_INTERFACE m_osInterface = nullptr; //!< Pointer to OS interface |
| MhwMiInterface *m_miInterface = nullptr; //!< Pointer to MI interface |
| MhwCpInterface *m_cpInterface = nullptr; //!< Pointer to CP interface |
| MEDIA_FEATURE_TABLE *m_skuTable = nullptr; //!< Pointer to SKU table |
| MEDIA_WA_TABLE *m_waTable = nullptr; //!< Pointer to WA table |
| bool m_decodeInUse = false; //!< Flag to indicate if the interface is for decoder or encoder use |
| |
| MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {}; //!< Cacheability settings |
| |
| bool m_rhoDomainStatsEnabled = false; //!< Flag to indicate if Rho domain stats is enabled |
| bool m_rowstoreCachingSupported = false; //!< Flag to indicate if row store cache is supported |
| uint32_t m_brcNumPakPasses = 4; //!< Number of brc pak passes |
| |
| MHW_VDBOX_ROWSTORE_CACHE m_hevcDatRowStoreCache = {}; |
| MHW_VDBOX_ROWSTORE_CACHE m_hevcDfRowStoreCache = {}; |
| MHW_VDBOX_ROWSTORE_CACHE m_hevcSaoRowStoreCache = {}; |
| MHW_VDBOX_ROWSTORE_CACHE m_hevcHSaoRowStoreCache = {}; |
| MHW_VDBOX_ROWSTORE_CACHE m_vp9HvdRowStoreCache = {}; |
| MHW_VDBOX_ROWSTORE_CACHE m_vp9DfRowStoreCache = {}; |
| MHW_VDBOX_ROWSTORE_CACHE m_vp9DatRowStoreCache = {}; |
| |
| uint32_t m_hevcEncCuRecordSize = 0; //!< size of hevc enc cu record |
| uint32_t m_pakHWTileSizeRecordSize = 0; //! pak HW tile size recored size |
| |
| static const uint32_t m_timeStampCountsPerMillisecond = (12000048 / 1000); //<! Time stamp coounts per millisecond |
| static const uint32_t m_hcpCabacErrorFlagsMask = 0x0879; //<! Hcp CABAC error flags mask |
| |
| MmioRegistersHcp m_mmioRegisters[MHW_VDBOX_NODE_MAX] = {}; //!< hcp mmio registers |
| |
| static const HevcSliceType m_hevcBsdSliceType[3]; //!< HEVC Slice Types for Long Format |
| |
| //! |
| //! \brief Constructor |
| //! |
| MhwVdboxHcpInterface( |
| PMOS_INTERFACE osInterface, |
| MhwMiInterface *miInterface, |
| MhwCpInterface *cpInterface, |
| bool decodeInUse); |
| |
| //! |
| //! \brief Add a resource to the command buffer |
| //! \details Internal function to add either a graphics address of a resource or |
| //! add the resource to the patch list for the requested buffer |
| //! |
| //! \param [in] osInterface |
| //! OS interface |
| //! \param [in] cmdBuffer |
| //! Command buffer to which resource is added |
| //! \param [in] params |
| //! Parameters necessary to add the resource |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS(*pfnAddResourceToCmd) ( |
| PMOS_INTERFACE osInterface, |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_RESOURCE_PARAMS params); |
| |
| //! |
| //! \brief Convert to Sign Magnitude |
| //! \details Implementation of signed bitfield as specified |
| //! |
| //! \param [in] val |
| //! Input value to calculate |
| //! \param [in] signBitPos |
| //! The position of sign bit |
| //! |
| //! \return uint16_t |
| //! value calculated |
| //! |
| uint16_t Convert2SignMagnitude( |
| int32_t val, |
| uint32_t signBitPos); |
| |
| public: |
| |
| //! |
| //! \brief Destructor |
| //! |
| virtual ~MhwVdboxHcpInterface() {} |
| |
| //! |
| //! \brief Get OS interface |
| //! |
| //! \return [out] PMOS_INTERFACE |
| //! Pointer to the OS interface. |
| //! |
| inline PMOS_INTERFACE GetOsInterface() |
| { |
| return m_osInterface; |
| } |
| |
| //! |
| //! \brief Get mmio registers |
| //! |
| //! \param [in] index |
| //! mmio registers index. |
| //! |
| //! \return [out] MmioRegistersHcp* |
| //! mmio registers got. |
| //! |
| inline MmioRegistersHcp* GetMmioRegisters(MHW_VDBOX_NODE_IND index) |
| { |
| if (index < MHW_VDBOX_NODE_MAX) |
| { |
| return &m_mmioRegisters[index]; |
| } |
| else |
| { |
| MHW_ASSERT("index is out of range!"); |
| return &m_mmioRegisters[MHW_VDBOX_NODE_1]; |
| } |
| } |
| |
| //! |
| //! \brief Get Hcp Cabac Error Flags Mask |
| //! |
| //! \return [out] uint32_t |
| //! Mask got. |
| //! |
| virtual inline uint32_t GetHcpCabacErrorFlagsMask() |
| { |
| return m_hcpCabacErrorFlagsMask; |
| } |
| |
| //! |
| //! \brief Get Watch Dog Timer Threhold |
| //! |
| //! \return [out] uint32_t |
| //! Threhold got. |
| //! |
| virtual inline uint32_t GetWatchDogTimerThrehold() |
| { |
| return 0; |
| } |
| |
| //! |
| //! \brief Get Time Stamp Counts Per Millisecond |
| //! |
| //! \return [out] uint32_t |
| //! Counts got. |
| //! |
| inline uint32_t GetTimeStampCountsPerMillisecond() |
| { |
| return m_timeStampCountsPerMillisecond; |
| } |
| |
| //! |
| //! \brief Get hevc enc cu record size |
| //! \return [out] uint32_t |
| //! Brc pak passes num. |
| //! |
| inline uint32_t GetHevcEncCuRecordSize() |
| { |
| return m_hevcEncCuRecordSize; |
| } |
| |
| //! |
| //! \brief Get pak HW tile size record size |
| //! \return [out] uint32_t |
| //! Brc pak passes num. |
| //! |
| inline uint32_t GetPakHWTileSizeRecordSize() |
| { |
| return m_pakHWTileSizeRecordSize; |
| } |
| |
| //! |
| //! \brief Judge if row store caching supported |
| //! |
| //! \return bool |
| //! true if supported, else false |
| //! |
| inline bool IsRowStoreCachingSupported() |
| { |
| return m_rowstoreCachingSupported; |
| } |
| |
| //! |
| //! \brief Judge if hevc dat store caching enabled |
| //! |
| //! \return bool |
| //! true if enabled, else false |
| //! |
| inline bool IsHevcDatRowstoreCacheEnabled() |
| { |
| return m_hevcDatRowStoreCache.bEnabled ? true : false; |
| } |
| |
| //! |
| //! \brief Judge if hevc df row store caching enabled |
| //! |
| //! \return bool |
| //! true if enabled, else false |
| //! |
| inline bool IsHevcDfRowstoreCacheEnabled() |
| { |
| return m_hevcDfRowStoreCache.bEnabled ? true : false; |
| } |
| |
| //! |
| //! \brief Judge if hevc sao row store caching enabled |
| //! |
| //! \return bool |
| //! true if enabled, else false |
| //! |
| inline bool IsHevcSaoRowstoreCacheEnabled() |
| { |
| return m_hevcSaoRowStoreCache.bEnabled ? true : false; |
| } |
| |
| //! |
| //! \brief Judge if vp9 hvd row store caching enabled |
| //! |
| //! \return bool |
| //! true if enabled, else false |
| //! |
| inline bool IsVp9HvdRowstoreCacheEnabled() |
| { |
| return m_vp9HvdRowStoreCache.bEnabled ? true : false; |
| } |
| |
| //! |
| //! \brief Judge if vp9 df row store caching enabled |
| //! |
| //! \return bool |
| //! true if enabled, else false |
| //! |
| inline bool IsVp9DfRowstoreCacheEnabled() |
| { |
| return m_vp9DfRowStoreCache.bEnabled ? true : false; |
| } |
| |
| //! |
| //! \brief Judge if vp9 dat row store caching enabled |
| //! |
| //! \return bool |
| //! true if enabled, else false |
| //! |
| inline bool IsVp9DatRowstoreCacheEnabled() |
| { |
| return m_vp9DatRowStoreCache.bEnabled ? true : false; |
| } |
| |
| //! |
| //! \brief Set cacheability settings |
| //! |
| //! \param [in] cacheabilitySettings |
| //! Cacheability settings |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS SetCacheabilitySettings( |
| MHW_MEMORY_OBJECT_CONTROL_PARAMS cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) |
| { |
| MHW_FUNCTION_ENTER; |
| |
| uint32_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS); |
| MOS_STATUS eStatus = MOS_SecureMemcpy(m_cacheabilitySettings, size, |
| cacheabilitySettings, size); |
| |
| return eStatus; |
| } |
| |
| //! |
| //! \brief Determines if the slice is P slice |
| //! \param [in] sliceType |
| //! slice type |
| //! \return bool |
| //! True if it's P slice, otherwise return false |
| //! |
| inline bool IsHevcPSlice(uint8_t sliceType) |
| { |
| return (sliceType < MHW_ARRAY_SIZE(m_hevcBsdSliceType)) ? |
| (m_hevcBsdSliceType[sliceType] == hevcSliceP) : false; |
| } |
| |
| //! |
| //! \brief Determines if the slice is B slice |
| //! \param [in] sliceType |
| //! slice type |
| //! \return bool |
| //! True if it's B slice, otherwise return false |
| //! |
| inline bool IsHevcBSlice(uint8_t sliceType) |
| { |
| return (sliceType < MHW_ARRAY_SIZE(m_hevcBsdSliceType)) ? |
| (m_hevcBsdSliceType[sliceType] == hevcSliceB) : false; |
| } |
| |
| //! |
| //! \brief Determines if the slice is I slice |
| //! \param [in] sliceType |
| //! slice type |
| //! \return bool |
| //! True if it's I slice, otherwise return false |
| //! |
| inline bool IsHevcISlice(uint8_t sliceType) |
| { |
| return (sliceType < MHW_ARRAY_SIZE(m_hevcBsdSliceType)) ? |
| (m_hevcBsdSliceType[sliceType] == hevcSliceI) : false; |
| } |
| |
| //! |
| //! \brief Get pak object size |
| //! |
| //! \return uint32_t |
| //! The size got |
| //! |
| virtual uint32_t GetHcpPakObjSize() = 0; |
| |
| //! |
| //! \brief Calculates the maximum size for HCP picture level commands |
| //! \details Client facing function to calculate the maximum size for HCP picture level commands |
| //! \param [in] mode |
| //! Indicate the codec mode |
| //! \param [out] commandsSize |
| //! The maximum command buffer size |
| //! \param [out] patchListSize |
| //! The maximum command patch list size |
| //! \param [in] params |
| //! Indicate the command size parameters |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS GetHcpStateCommandSize( |
| uint32_t mode, |
| uint32_t *commandsSize, |
| uint32_t *patchListSize, |
| PMHW_VDBOX_STATE_CMDSIZE_PARAMS params) = 0; |
| |
| //! |
| //! \brief Calculates maximum size for HCP slice/MB level commands |
| //! \details Client facing function to calculate maximum size for HCP slice/MB level commands |
| //! \param [in] mode |
| //! Indicate the codec mode |
| //! \param [out] commandsSize |
| //! The maximum command buffer size |
| //! \param [out] patchListSize |
| //! The maximum command patch list size |
| //! \param [in] modeSpecific |
| //! Indicate the long or short format |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS GetHcpPrimitiveCommandSize( |
| uint32_t mode, |
| uint32_t *commandsSize, |
| uint32_t *patchListSize, |
| bool modeSpecific) = 0; |
| |
| //! |
| //! \brief get the size of hw command |
| //! \details Internal function to get the size of HEVC_VP9_RDOQ_STATE_CMD |
| //! \return commandSize |
| //! The command size |
| //! |
| virtual uint32_t GetHcpHevcVp9RdoqStateCommandSize() = 0; |
| |
| //! |
| //! \brief get the size of hw command |
| //! \details Internal function to get the size of HCP_VP9_PIC_STATE_CMD |
| //! \return commandSize |
| //! The command size |
| //! |
| virtual uint32_t GetHcpVp9PicStateCommandSize() = 0; |
| |
| //! |
| //! \brief get the size of hw command |
| //! \details Internal function to get the size of HCP_VP9_SEGMENT_STATE_CMD |
| //! \return commandSize |
| //! The command size |
| //! |
| virtual uint32_t GetHcpVp9SegmentStateCommandSize() = 0; |
| |
| //! |
| //! \brief Get the required buffer size for VDBOX |
| //! \details Internal function to get required buffer size for HEVC codec (both dual pipe and vdenc, enc and dec) |
| //! |
| //! \param [in] bufferType |
| //! HEVC Buffer type |
| //! \param [in, out] hcpBufSizeParam |
| //! HCP buffer size parameters |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS GetHevcBufferSize( |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType, |
| PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam) = 0; |
| |
| //! |
| //! \brief Get the required buffer size for VDBOX |
| //! \details Internal function to get required buffer size for VP9 codec |
| //! |
| //! \param [in] bufferType |
| //! HEVC Buffer type |
| //! \param [in, out] hcpBufSizeParam |
| //! HCP buffer size parameters |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS GetVp9BufferSize( |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType, |
| PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam) = 0; |
| |
| //! |
| //! \brief Get the required buffer size for VDBOX |
| //! \details Internal function to judge if buffer realloc is needed for HEVC codec |
| //! |
| //! \param [in] bufferType |
| //! HEVC Buffer type |
| //! \param [in, out] reallocParam |
| //! HCP Re-allocate parameters |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS IsHevcBufferReallocNeeded( |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType, |
| PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam) = 0; |
| |
| //! |
| //! \brief Get the required buffer size for VDBOX |
| //! \details Internal function to judge if buffer realloc is needed for VP9 codec |
| //! |
| //! \param [in] bufferType |
| //! HEVC Buffer type |
| //! \param [in, out] reallocParam |
| //! HCP Re-allocate parameters |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS IsVp9BufferReallocNeeded( |
| MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType, |
| PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam) = 0; |
| |
| //! |
| //! \brief Adds HCP Pipe Pipe Mode Select command in command buffer |
| //! \details Client facing function to add HCP Pipe Mode Select command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AddHcpSurfaceCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_SURFACE_PARAMS params); |
| |
| //! |
| //! \brief Adds HCP slice state command in command buffer |
| //! \details Client facing function to add HCP slice state command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] hevcSliceState |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AddHcpSliceStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState); |
| |
| //! |
| //! \brief Adds HCP picture State command in command buffer |
| //! \details Client facing function to add HCP picture State command for encode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AddHcpPicStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_PIC_STATE params); |
| |
| //! |
| //! \brief Adds HCP Protect State command in command buffer |
| //! \details Client facing function to add HCP picture State command for encode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] hevcSliceState |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| MOS_STATUS AddHcpProtectStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState); |
| |
| //! |
| //! \brief Programs base address of rowstore scratch buffers |
| //! \details Internal function to get base address of rowstore scratch buffers |
| //! |
| //! \param [in] rowstoreParams |
| //! Rowstore parameters |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS GetRowstoreCachingAddrs( |
| PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) = 0; |
| |
| //! |
| //! \brief Adds HCP Pipe Pipe Mode Select command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpPipeModeSelectCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP Surface State command for decode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpDecodeSurfaceStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_SURFACE_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP Surface State command for encode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpEncodeSurfaceStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_SURFACE_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP Pipe Buffer Address State command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpPipeBufAddrCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP Indirect Object Base Address State command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpIndObjBaseAddrCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP QM State command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpQmStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_QM_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP FQM State command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpFqmStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_QM_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP picture State command for decode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpDecodePicStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_PIC_STATE params) = 0; |
| |
| //! |
| //! \brief Adds HCP picture State command for encode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpEncodePicStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_PIC_STATE params) = 0; |
| |
| //! |
| //! \brief Adds HCP tile State command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpTileStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_TILE_STATE params) = 0; |
| |
| //! |
| //! \brief Adds HCP reference frame index command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] batchBuffer |
| //! Batch buffer to add to VDBOX_BUFFER_START |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpRefIdxStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_BATCH_BUFFER batchBuffer, |
| PMHW_VDBOX_HEVC_REF_IDX_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP weight offset state command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] batchBuffer |
| //! Batch buffer to add to VDBOX_BUFFER_START |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpWeightOffsetStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_BATCH_BUFFER batchBuffer, |
| PMHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP slice state command for decode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] hevcSliceState |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpDecodeSliceStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState) = 0; |
| |
| //! |
| //! \brief Adds HCP slice state command for encode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] hevcSliceState |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpEncodeSliceStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState) = 0; |
| |
| //! |
| //! \brief Adds HCP Protect state command for decode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] hevcSliceState |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpDecodeProtectStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState) = 0; |
| |
| //! |
| //! \brief Adds HCP BSD object state command in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpBsdObjectCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HCP_BSD_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds HCP Pak insert object State command foe encode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpPakInsertObject( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_PAK_INSERT_PARAMS params) = 0; |
| |
| //! |
| //! \brief Adds VP9 picture state command for decode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] batchBuffer |
| //! Batch buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpVp9PicStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_BATCH_BUFFER batchBuffer, |
| PMHW_VDBOX_VP9_PIC_STATE params) = 0; |
| |
| //! |
| //! \brief Adds VP9 picture state command for encode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] batchBuffer |
| //! Batch buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpVp9PicStateEncCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_BATCH_BUFFER batchBuffer, |
| PMHW_VDBOX_VP9_ENCODE_PIC_STATE params) = 0; |
| |
| //! |
| //! \brief Adds VP9 segment state command for decode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] batchBuffer |
| //! Batch buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpVp9SegmentStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_BATCH_BUFFER batchBuffer, |
| PMHW_VDBOX_VP9_SEGMENT_STATE params) = 0; |
| |
| //! |
| //! \brief Adds VP9 RDOQ state command for encode in command buffer |
| //! |
| //! \param [in] cmdBuffer |
| //! Command buffer to which HW command is added |
| //! \param [in] params |
| //! Params structure used to populate the HW command |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpHevcVp9RdoqStateCmd( |
| PMOS_COMMAND_BUFFER cmdBuffer, |
| PMHW_VDBOX_HEVC_PIC_STATE params) = 0; |
| |
| //! |
| //! \brief Adds HEVC Brc buffer |
| //! |
| //! \param [in] hcpImgStates |
| //! Resource to which Brc buffer is added |
| //! \param [in] hevcPicState |
| //! Params structure used to add the Brc buffer |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS AddHcpHevcPicBrcBuffer( |
| PMOS_RESOURCE hcpImgStates, |
| PMHW_VDBOX_HEVC_PIC_STATE hevcPicState) = 0; |
| |
| //! |
| //! \brief Get OsResLaceOrAceOrRgbHistogramBuffer Size |
| //! |
| //! \param [in] width |
| //! Width of Surface |
| //! \param [in] height |
| //! Height of Surface |
| //! \param [out] size |
| //! Size of OsResLaceOrAceOrRgbHistogramBuffer |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS GetOsResLaceOrAceOrRgbHistogramBufferSize( |
| uint32_t width, |
| uint32_t height, |
| uint32_t *size) = 0; |
| |
| //! |
| //! \brief Get OsResStatisticsOutputBuffer Size |
| //! |
| //! \param [in] width |
| //! Width of Surface |
| //! \param [in] height |
| //! Height of Surface |
| //! \param [out] size |
| //! Size of OsResStatisticsOutputBuffer |
| //! |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| //! |
| virtual MOS_STATUS GetOsResStatisticsOutputBufferSize( |
| uint32_t width, |
| uint32_t height, |
| uint32_t *size) = 0; |
| }; |
| |
| #endif |
