/* * Copyright (c) 2018-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 codechal_decode_scalability_g12.h //! \brief Impelements the public interface for Gen12 Scalability Decode //! #ifndef __CODECHAL_DECODE_SCALABILITY_G12_H__ #define __CODECHAL_DECODE_SCALABILITY_G12_H__ #include "codechal.h" #include "codechal_hw.h" #include "codechal_hw_g12_X.h" #include "codechal_decoder.h" #include "mos_os_virtualengine_scalability.h" #include "codechal_decode_scalability.h" #define CODECHAL_HCP_DECODE_PHASE_REAL_TILE 0xFF #define CODECHAL_SCALABILITY_SLICE_STATE_CACHELINES_PER_SLICE_TGL 9 #define CODECHAL_SCALABILITY_ADDITIONAL_BES_MEMORY_OF_TWO_PIPE 2 #define CODECHAL_SCALABILITY_MAX_PIPE_INDEX_OF_TWO_PIPE 1 inline static uint8_t CodecHalDecodeMaxNumPipesInUseG12(uint8_t vdboxNum) { uint8_t maxNumPipesInUs = 1; if (vdboxNum == 2) { maxNumPipesInUs = 2; } else { maxNumPipesInUs = vdboxNum - 1; } return maxNumPipesInUs; } typedef struct _CODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 : public _CODECHAL_DECODE_SCALABILITY_INIT_PARAMS { bool bIsTileEnabled; //!< The picture can be partitioned into tiles bool bIsSccDecoding; //!< Codec is HEVC SCC decoding bool bHasSubsetParams; //!< Whether it has subset parameters }CODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12, *PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12; typedef struct _CODECHAL_DECODE_SFC_SCALABILITY_PARAMS { // HCP-SFC pipe only for scalability and more input/output color format uint32_t engineMode; //!< 0 - single, 1 - left most column, 2 - right most column, 3 - middle column uint32_t tileType; //!< Real tile = 0, virtual tile = 1 uint32_t srcStartX; //!< Source surface column horizontal start position in pixel uint32_t srcEndX; //!< Source surface column horizontal end position in pixel uint32_t dstStartX; //!< Output surface column horizontal start position in pixel uint32_t dstEndX; //!< Output surface column horizontal end position in pixel }CODECHAL_DECODE_SFC_SCALABILITY_PARAMS, *PCODECHAL_DECODE_SFC_SCALABILITY_PARAMS; typedef struct _CODECHAL_DECODE_SCALABILITY_STATE_G12 : public _CODECHAL_DECODE_SCALABILITY_STATE { // For hevc real tile decoding bool bIsRtMode; uint8_t u8RtCurPipe; uint8_t u8RtCurPhase; uint8_t u8RtPhaseNum; uint8_t u8RtPipeInLastPhase; MOS_RESOURCE resSemaMemBEsAdditional[CODECHAL_SCALABILITY_ADDITIONAL_BES_MEMORY_OF_TWO_PIPE]; //!< Additional BEs sync for two pipes #if (_DEBUG || _RELEASE_INTERNAL) bool bDisableRtMode; bool bEnableRtMultiPhase; uint8_t dbgOverUserPipeNum; #endif }CODECHAL_DECODE_SCALABILITY_STATE_G12, *PCODECHAL_DECODE_SCALABILITY_STATE_G12; #define CodecHalDecodeScalablity_SetPhaseIndicator(PhaseIndicator)\ { \ if (m_scalabilityState->u8RtCurPhase == 0) \ { \ PhaseIndicator = MHW_VDBOX_HCP_RT_FIRST_PHASE; \ } \ else if (m_scalabilityState->u8RtCurPhase == m_scalabilityState->u8RtPhaseNum - 1) \ { \ PhaseIndicator = MHW_VDBOX_HCP_RT_LAST_PHASE; \ } \ else \ { \ PhaseIndicator = MHW_VDBOX_HCP_RT_MIDDLE_PHASE; \ } \ }while (0) #define CodecHalDecodeScalabilityIsRealTileMode(pScalabilityState) \ (pScalabilityState ? (pScalabilityState->bScalableDecodeMode && pScalabilityState->bIsRtMode): false) #define CodecHalDecodeScalabilityIsVirtualTileMode(pScalabilityState) \ (pScalabilityState ? (pScalabilityState->bScalableDecodeMode && !pScalabilityState->bIsRtMode): false) #define CodecHalDecodeScalabilityIsRealTilePhase(pScalabilityState) \ (pScalabilityState && pScalabilityState->bScalableDecodeMode && \ (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE)) #define CodecHalDecodeScalabilityIsFirstRealTilePhase(pScalabilityState) \ (CodecHalDecodeScalabilityIsRealTilePhase(pScalabilityState) && \ (pScalabilityState->u8RtCurPhase == 0)) #define CodecHalDecodeScalabilityIsLastRealTilePhase(pScalabilityState) \ (CodecHalDecodeScalabilityIsRealTilePhase(pScalabilityState) && \ ((pScalabilityState->u8RtCurPhase == pScalabilityState->u8RtPhaseNum - 1) || \ ((pScalabilityState->u8RtCurPipe >= pScalabilityState->u8RtPipeInLastPhase) && \ (pScalabilityState->u8RtCurPhase == pScalabilityState->u8RtPhaseNum - 2)))) #define CodecHalDecodeScalabilityIsLastRealTilePass(pScalabilityState) \ (CodecHalDecodeScalabilityIsRealTilePhase(pScalabilityState) && \ (pScalabilityState->u8RtCurPhase == pScalabilityState->u8RtPhaseNum - 1) && \ (pScalabilityState->u8RtCurPipe == pScalabilityState->u8RtPipeInLastPhase - 1)) #define CodecHalDecodeScalabilityIsBEPhaseG12(pScalabilityState) \ (pScalabilityState && pScalabilityState->bScalableDecodeMode && \ ((pScalabilityState->HcpDecPhase >= CODECHAL_HCP_DECODE_PHASE_BE0) && \ (pScalabilityState->HcpDecPhase != CODECHAL_HCP_DECODE_PHASE_REAL_TILE))) #define CodecHalDecodeScalabilityIsFinalBEPhaseG12(pScalabilityState) \ (pScalabilityState && pScalabilityState->bScalableDecodeMode && \ ((pScalabilityState->HcpDecPhase >= CODECHAL_HCP_DECODE_PHASE_BE0) && \ (pScalabilityState->HcpDecPhase != CODECHAL_HCP_DECODE_PHASE_REAL_TILE)) && \ (pScalabilityState->ucScalablePipeNum == pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE)) #define CodecHalDecodeScalablity_DecPhaseToHwWorkMode_G12(EngineMode, PipeWorkMode)\ do \ { \ if (m_hcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE) \ { \ PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CABAC_REAL_TILE; \ if (m_scalabilityState->u8RtCurPipe == 0) \ { \ if ((m_scalabilityState->u8RtCurPhase == m_scalabilityState->u8RtPhaseNum - 1) && \ (m_scalabilityState->u8RtPipeInLastPhase == 1)) \ EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY; \ else \ EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_LEFT; \ } \ else if (m_scalabilityState->u8RtCurPipe == m_scalabilityState->ucScalablePipeNum - 1) \ EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_RIGHT; \ else \ EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_MIDDLE; \ } \ else if (m_hcpDecPhase == CODECHAL_HCP_DECODE_PHASE_FE) \ { \ EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY; \ PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CABAC_FE; \ } \ else if (m_hcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0) \ { \ EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_LEFT; \ PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CODEC_BE; \ } \ else \ { \ if(((m_hcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE) <= m_scalabilityState->ucScalablePipeNum) && \ (m_hcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0)) \ { \ CODECHAL_DECODE_ASSERT(m_scalabilityState->ucScalablePipeNum >= 2); \ EngineMode = (m_scalabilityState->ucScalablePipeNum == (m_hcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE)) ? \ MHW_VDBOX_HCP_MULTI_ENGINE_MODE_RIGHT : MHW_VDBOX_HCP_MULTI_ENGINE_MODE_MIDDLE; \ PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CODEC_BE; \ } \ } \ }while (0) //! //! \brief Get secondary cmd buffer //! \param [in] pScalabilityState //! Scalability decode state //! \param [in] pSdryCmdBuf //! secondary cmd buffer address //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_GetVESecondaryCmdBuffer_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, PMOS_COMMAND_BUFFER pSdryCmdBuf); //! //! \brief get command buffer to use //! \details decide and get command buffer to add cmds. it is for decoder which can support both scalability and single pipe //! \param [in] pScalabilityState //! Scalability decode state //! \param [in] pScdryCmdBuf //! pointer to secondary cmd buffer //! \param [in] ppCmdBufToUse //! pointer to cmd buffer to use //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_GetCmdBufferToUse_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, PMOS_COMMAND_BUFFER pScdryCmdBuf, PMOS_COMMAND_BUFFER *ppCmdBufToUse); //! //! \brief return secondary cmd buffer //! \param [in] pScalabilityState //! Scalability decode state //! \param [in] pScdryCmdBuf //! pointer to secondary cmd buffer //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, PMOS_COMMAND_BUFFER pSdryCmdBuf); #if (_DEBUG || _RELEASE_INTERNAL) //! //! \brief dump command buffer in scalability mode //! \param [in] pDecoder //! Decoder device //! \param [in] pScalabilityState //! Scalability decode state //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_DbgDumpCmdBuffer_G12( CodechalDecode *pDecoder, PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, CodechalDebugInterface *debugInterface, PMOS_COMMAND_BUFFER pPrimCmdBuf); #endif //! //! \brief Determine decode phase //! \details determine decode phase for decoder supporting scalability mode but not necessarily always running in scalable mode //! \param [in] pScalabilityState //! Scalability decode state //! \param [in] pHcpDecPhase //! Address of hcp decode phase //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_DetermineDecodePhase_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, uint32_t *pHcpDecPhase); //! //! \brief Initiliaze Decode Parameters for virtual engine decode //! \details Initiliaze decode parameters for virtual engine decode. this is for decoder supporting scalability but not necessarily always running in scalable mode //! \param [in] pScalabilityState //! Scalability decode state //! \param [in] pInitParams //! pointer to parameters to initialize decode scalability //! \param [in] pucDecPassNum //! pointer to decode pass number //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_InitScalableParams_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams, uint16_t *pucDecPassNum); //! //! \brief Set virtual engine hint parameters for scalable decode //! \param [in] pScalabilityState //! Scalability decode state //! \param [in] pSetHintParms //! pointer to set hint parameter //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_SetHintParams_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, PCODECHAL_DECODE_SCALABILITY_SETHINT_PARMS pSetHintParms); //! //! \brief Sync between FE and BE //! \details This function does 3 major things //! 1) send hw or sw semaphore wait at start of BE0 cmd. //! 2) use HW semaphore wait and MI ATOMIC cmd to make all BEs start running at the same time //! 3) add COND BB END cmd to check if CABAC stream out buffer overflow. //! \param [in] pScalabilityState //! Scalability decode state //! \param [in] pCmdBufferInUse //! address of command buffer //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_FEBESync_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, PMOS_COMMAND_BUFFER pCmdBufferInUse, bool phasedSubmission); //! //! \brief To judge if command buffer should be submitted. //! \param [in] pScalabilityState //! Scalability decode state //! \return bool //! True means to submit command buffer, False means not to submit. //! bool CodecHalDecodeScalabilityIsToSubmitCmdBuffer_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState); //! //! \brief Read CS ENGINEID register to know which engine is in use for current workload //! \param [in] pDecodeStatusBuf //! Decode status buffer //! \param [in] pCmdBufferInUse //! address of command buffer //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_ReadCSEngineIDReg_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, CodechalDecodeStatusBuffer *pDecodeStatusBuf, PMOS_COMMAND_BUFFER pCmdBufferInUse); //! //! \brief State initialization for virtual engine decode supporting scalable and single pipe mode //! \param [in] pDecoder //! Decoder device //! \param [in] pScalabilityState //! Scalability decode state //! \param [in] bShortFormat //! short format decode flag //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_InitializeState_G12( CodechalDecode *pDecoder, PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, CodechalHwInterface *hwInterface, bool bShortFormat, CodechalSetting *settings); //! \brief construct gpu context creation options when scalability supported //! \param [in] scalabilityState //! Scalability decode state //! \param [in] gpuCtxCreatOptions //! pointer to gpu context creation options //! \param [in] codechalSetting //! Pointer to codechal setting //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodechalDecodeScalability_ConstructParmsForGpuCtxCreation_g12( PCODECHAL_DECODE_SCALABILITY_STATE pScalState, PMOS_GPUCTX_CREATOPTIONS_ENHANCED gpuCtxCreatOpts, CodechalSetting * codecHalSetting); //! //! \brief State initialization for virtual engine decode supporting scalable and single pipe mode //! \param [in] pScalabilityState //! Scalability decode state //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_AdvanceRealTilePass( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState); //! //! \brief Get curent tile column index in real tile decoding //! \param [in] pScalabilityState //! Scalability decode state //! \param [out] col //! reference to column id //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_GetCurrentRealTileColumnId( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, uint8_t &col); //! \brief Set scalability parameters in SFC state //! \param [in] scalabilityState //! Scalability decode state //! \param [in] picParams //! Picture parameters for HEVC or VP9 //! \param [in] srcRegion //! SFC input surface region //! \param [in] dstRegion //! SFC output surface region //! \param [out] sfcScalabilityParams //! Pointer to SFC Scalability state parameters //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS CodecHalDecodeScalability_SetSfcState( PCODECHAL_DECODE_SCALABILITY_STATE scalabilityState, void *picParams, CodecRectangle *srcRegion, CodecRectangle *dstRegion, PCODECHAL_DECODE_SFC_SCALABILITY_PARAMS sfcScalabilityParams); MOS_STATUS CodecHalDecodeScalability_AllocateResources_VariableSizes_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState, PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS pHcpBufSizeParam, PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS pAllocParam); MOS_STATUS CodecHalDecodeScalability_AllocateResources_FixedSizes_G12( PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState); bool CodecHalDecodeScalability_DecideEnableScala_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalState, PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams, bool bCanEnableRealTile); MOS_STATUS CodecHalDecodeScalability_DecidePipeNum_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalState, PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams); MOS_STATUS CodechalDecodeScalability_MapPipeNumToLRCACount_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalState, uint32_t *LRCACount); #if (_DEBUG || _RELEASE_INTERNAL) MOS_STATUS CodechalDecodeScalability_DebugOvrdDecidePipeNum_G12( PCODECHAL_DECODE_SCALABILITY_STATE pScalState); #endif void CodecHalDecodeScalability_DecPhaseToSubmissionType_G12( PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState, PMOS_COMMAND_BUFFER pCmdBuffer); void CodecHalDecodeScalability_Destroy_G12( PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState); #endif // __CODECHAL_DECODE_SCALABILITY_G12_H__