| /* |
| * Copyright (c) 2010-2019, 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 vphal_render_sfc_base.h |
| //! \brief The header file of the base class of VPHAL SFC rendering component |
| //! \details The SFC renderer supports Scaling, IEF, CSC/ColorFill and Rotation. |
| //! It's responsible for setting up HW states and generating the SFC |
| //! commands. |
| //! |
| #ifndef __VPHAL_RENDER_SFC_BASE_H__ |
| #define __VPHAL_RENDER_SFC_BASE_H__ |
| |
| #include "mhw_sfc.h" |
| #include "renderhal.h" |
| #include "vphal.h" |
| #include "vphal_render_common.h" |
| #include "vphal_render_vebox_iecp.h" |
| |
| #ifndef __VPHAL_SFC_SUPPORTED |
| #define __VPHAL_SFC_SUPPORTED 1 |
| #endif |
| |
| //! |
| //! \brief Structure to hold AVS Coeff tables |
| //! |
| struct VPHAL_SFC_AVS_STATE |
| { |
| MHW_SFC_AVS_LUMA_TABLE LumaCoeffs; |
| MHW_SFC_AVS_CHROMA_TABLE ChromaCoeffs; |
| MHW_SFC_AVS_STATE AvsStateParams; |
| }; |
| |
| //! |
| //! \brief Transient Render data populated for every BLT call |
| //! |
| typedef struct _VPHAL_SFC_RENDER_DATA |
| { |
| bool bColorFill; //!< Enable ColorFill |
| bool bScaling; //!< Enable Scaling |
| bool bIEF; //!< Enable IEF filter |
| bool bCSC; //!< Enable CSC filter |
| |
| float fScaleX; //!< X Scaling ratio |
| float fScaleY; //!< Y Scaling ratio |
| uint16_t wIEFFactor; //!< IEF factor |
| MHW_SFC_STATE_PARAMS *SfcStateParams; //!< Pointer to SFC state params |
| MHW_SFC_IEF_STATE_PARAMS IEFStateParams; //!< Pointer to IEF state params |
| PMHW_AVS_PARAMS pAvsParams; //!< Pointer to AVS params |
| PVPHAL_COLORFILL_PARAMS pColorFillParams; //!< Pointer to ColorFill params |
| PVPHAL_ALPHA_PARAMS pAlphaParams; //!< Pointer to Alpha params |
| VPHAL_CSPACE SfcInputCspace; //!< SFC Input Color Space |
| MOS_FORMAT SfcInputFormat; //!< SFC Input Format |
| VPHAL_ROTATION SfcRotation; //!< SFC Rotation Mode |
| VPHAL_SCALING_MODE SfcScalingMode; //!< SFC Scaling Mode |
| uint32_t SfcSrcChromaSiting; //!< SFC Source Surface Chroma Siting |
| |
| PVPHAL_SURFACE pSfcPipeOutSurface; //!< SFC Pipe output surface |
| |
| bool bForcePolyPhaseCoefs; //!< SFC AVS force polyphase coef |
| } VPHAL_SFC_RENDER_DATA, *PVPHAL_SFC_RENDER_DATA; |
| |
| #if __VPHAL_SFC_SUPPORTED |
| class VphalSfcState |
| { |
| public: |
| //! |
| //! \brief VphalSfcState constructor |
| //! \param [in] osInterface |
| //! Pointer to os interface |
| //! \param [in] renderHal |
| //! pointer to renderhal structure |
| //! \param [in] sfcInterface |
| //! pointer to mhw sfc interface |
| //! \return void |
| //! |
| VphalSfcState(PMOS_INTERFACE osInterface, |
| PRENDERHAL_INTERFACE renderHal, |
| PMHW_SFC_INTERFACE sfcInterface); |
| //! |
| //! \brief VphalSfcState destructor |
| //! \return void |
| //! |
| virtual ~VphalSfcState(); |
| |
| //! |
| //! \brief Disable the SFC functionality |
| //! \param [in] disable |
| //! true to disable, false to enable SFC |
| //! \return void |
| //! |
| void SetDisable(bool disable) |
| { |
| disableSFC = disable; |
| } |
| |
| //! |
| //! \brief Set SFC MMC status |
| //! \param [in] enable |
| //! true to disable, false to enable SFC MMC |
| //! \return void |
| //! |
| void SetSfcOutputMmcStatus(bool enable) |
| { |
| enableSfcMMC = enable; |
| } |
| |
| //! |
| //! \brief Check if SFC functionality is disabled |
| //! \return true if disabled, false if enabled |
| //! |
| bool IsDisabled() |
| { |
| return disableSFC; |
| } |
| |
| //! |
| //! \brief Check if SFC MMC is enabled |
| //! \return true if enabled, false if disabled |
| //! |
| bool IsSfcMmcEnabled() |
| { |
| return enableSfcMMC; |
| } |
| |
| //! |
| //! \brief Set stero channel of input |
| //! \param [in] currentChannel |
| //! Current stero channel |
| //! \return void |
| //! |
| void SetStereoChannel(uint32_t currentChannel) |
| { |
| m_currentChannel = currentChannel; |
| } |
| |
| //! |
| //! \brief Get Sfc's input format |
| //! \return MOS_FORMAT |
| //! |
| MOS_FORMAT GetInputFormat() |
| { |
| return m_renderData.SfcInputFormat; |
| } |
| |
| //! |
| //! \brief Get Sfc's input color space |
| //! \return VPHAL_CSPACE |
| //! |
| VPHAL_CSPACE GetInputColorSpace() |
| { |
| return m_renderData.SfcInputCspace; |
| } |
| |
| //! |
| //! \brief Initialize sfc render data |
| //! \return void |
| //! |
| virtual void InitRenderData() |
| { |
| MOS_FreeMemory(m_renderData.SfcStateParams); |
| m_renderData = { }; |
| } |
| |
| //! |
| //! \brief Get the output pipe considering the SFC restrictions |
| //! \details Check which output pipe can be applied, SFC or Comp |
| //! \param [in] pSrc |
| //! Pointer to input surface of SFC |
| //! \param [in] pRenderTarget |
| //! Pointer to RenderTarget |
| //! \param [in] pcRenderParams |
| //! Pointer to VpHal render parameters |
| //! \return the output pipe mode |
| //! |
| virtual VPHAL_OUTPUT_PIPE_MODE GetOutputPipe( |
| PVPHAL_SURFACE pSrc, |
| PVPHAL_SURFACE pRenderTarget, |
| PCVPHAL_RENDER_PARAMS pcRenderParams); |
| |
| //! |
| //! \brief Check if SFC is feasible to generate output |
| //! \param [in] pcRenderParams |
| //! Pointer to VpHal render parameters |
| //! \param [in] pSrcSurface |
| //! Pointer to input surface of SFC |
| //! \param [in] pRenderTarget |
| //! Pointer to RenderTarget |
| //! \return true if SFC is feasible |
| //! |
| virtual bool IsOutputPipeSfcFeasible( |
| PCVPHAL_RENDER_PARAMS pcRenderParams, |
| PVPHAL_SURFACE pSrcSurface, |
| PVPHAL_SURFACE pRenderTarget); |
| |
| //! |
| //! \brief Setup SFC Rendering Flags |
| //! \details Set up the SFC rendering flag based the input and render target |
| //! surface, SFC state and the ColorFill/Alpha parameters |
| //! \param [in] pColorFillParams |
| //! Pointer to ColorFill params |
| //! \param [in] pAlphaParams |
| //! Pointer to Alpha params |
| //! \param [in] pSrc |
| //! Pointer to Source Surface |
| //! \param [in] pRenderTarget |
| //! Pointer to Render Target Surface |
| //! \param [in,out] pRenderData |
| //! Pointer to Vebox render Data |
| //! \return void |
| //! |
| virtual void SetRenderingFlags( |
| PVPHAL_COLORFILL_PARAMS pColorFillParams, |
| PVPHAL_ALPHA_PARAMS pAlphaParams, |
| PVPHAL_SURFACE pSrc, |
| PVPHAL_SURFACE pRenderTarget, |
| PVPHAL_VEBOX_RENDER_DATA pRenderData); |
| |
| //! |
| //! \brief Free resources used by SFC Pipe |
| //! \details Free the AVS and IEF line buffer surfaces for SFC |
| //! \return void |
| //! |
| virtual void FreeResources(); |
| |
| //! |
| //! \brief Check to see if the i/o surface is supported by SFC |
| //! \details Check the format and the size of i/o surface and determine |
| //! whether it can go through SFC pipe |
| //! \param [in] pSrcSurface |
| //! Pointer to Src surface |
| //! \param [in] pOutSurface |
| //! Pointer to Output surface |
| //! \param [in] pAlphaParams |
| //! Pointer to Alpha params |
| //! \return true if SFC Pipe is needed else false |
| //! |
| virtual bool IsFormatSupported( |
| PVPHAL_SURFACE pSrcSurface, |
| PVPHAL_SURFACE pOutSurface, |
| PVPHAL_ALPHA_PARAMS pAlphaParams); |
| |
| //! |
| //! \brief Setup SFC states and parameters |
| //! \details Setup SFC states and parameters including SFC State, AVS |
| //! and IEF parameters |
| //! \param [in] pSrcSurface |
| //! Pointer to Source Surface |
| //! \param [in] pOutSurface |
| //! Pointer to Output Surface |
| //! \param [in,out] pRenderData |
| //! Pointer to Vebox Render data |
| //! \return Return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| virtual MOS_STATUS SetupSfcState( |
| PVPHAL_SURFACE pSrcSurface, |
| PVPHAL_SURFACE pOutSurface, |
| PVPHAL_VEBOX_RENDER_DATA pRenderData); |
| |
| //! |
| //! \brief Send SFC pipe commands |
| //! \details Register the surfaces and send the commands needed by SFC pipe |
| //! \param [in] pRenderData |
| //! Pointer to Vebox Render data |
| //! \param [in,out] pCmdBuffer |
| //! Pointer to command buffer |
| //! \return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| virtual MOS_STATUS SendSfcCmd( |
| PVPHAL_VEBOX_RENDER_DATA pRenderData, |
| PMOS_COMMAND_BUFFER pCmdBuffer); |
| |
| //! |
| //! \brief Set Sfc index used by HW |
| //! \details VPHAL set Sfc index used by HW |
| //! \param [in] dwSfcIndex; |
| //! set which Sfc can be used by HW |
| //! \param [in] dwSfcCount; |
| //! set Sfc Count |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if success, else fail reason |
| virtual MOS_STATUS SetSfcIndex( |
| uint32_t dwSfcIndex, |
| uint32_t dwSfcCount) |
| { |
| MOS_UNUSED(dwSfcIndex); |
| MOS_UNUSED(dwSfcCount); |
| return MOS_STATUS_SUCCESS; |
| } |
| |
| protected: |
| //! |
| //! \brief Gen specific function for SFC adjust boundary |
| //! \details Adjust the width and height of the input surface for SFC |
| //! \param [in] pSurface |
| //! Pointer to input Surface |
| //! \param [out] pdwSurfaceWidth |
| //! Pointer to adjusted surface width |
| //! \param [out] pdwSurfaceHeight |
| //! Pointer to adjusted surface height |
| //! \return void |
| //! |
| virtual void AdjustBoundary( |
| PVPHAL_SURFACE pSurface, |
| uint32_t* pdwSurfaceWidth, |
| uint32_t* pdwSurfaceHeight); |
| |
| //! |
| //! \brief Allocate Resources for SFC Pipe |
| //! \details Allocate the AVS and IEF line buffer surfaces for SFC |
| //! \return Return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| virtual MOS_STATUS AllocateResources(); |
| |
| //! |
| //! \brief Is the Format MMC Supported in SFC |
| //! \details Check whether input format is supported by memory compression |
| //! \param [in] Format |
| //! Surface format |
| //! \return true if supported, false if not |
| //! |
| virtual bool IsFormatMMCSupported( |
| MOS_FORMAT Format); |
| |
| //! |
| //! \brief Check if SFC is capable to output |
| //! \details Check all conditions to see if it meets SFC's capablitiy |
| //! \param [in] isColorFill |
| //! indicates whether color fill is required |
| //! \param [in] src |
| //! Pointer to source surface |
| //! \param [in] renderTarget |
| //! Pointer to renderTarget surface |
| //! \return true if capable, false if not |
| //! |
| virtual bool IsOutputCapable( |
| bool isColorFill, |
| PVPHAL_SURFACE src, |
| PVPHAL_SURFACE renderTarget); |
| |
| //! |
| //! \brief Check if the input format is supported |
| //! \param [in] srcSurface |
| //! input surface |
| //! \return true if supported, false if not |
| //! |
| virtual bool IsInputFormatSupported( |
| PVPHAL_SURFACE srcSurface) = 0; |
| |
| //! |
| //! \brief Check if the output format is supported |
| //! \param [in] outSurface |
| //! output surface |
| //! \return true if supported, false if not |
| //! |
| virtual bool IsOutputFormatSupported( |
| PVPHAL_SURFACE outSurface) = 0; |
| |
| //! |
| //! \brief Get width and height align unit of input format |
| //! \param [in] inputFormat |
| //! input format |
| //! \param [in] outputFormat |
| //! output format |
| //! \param [out] widthAlignUnit |
| //! width align unit |
| //! \param [out] heightAlignUnit |
| //! height align unit |
| //! \return void |
| //! |
| virtual void GetInputWidthHeightAlignUnit( |
| MOS_FORMAT inputFormat, |
| MOS_FORMAT outputFormat, |
| uint16_t &widthAlignUnit, |
| uint16_t &heightAlignUnit) = 0; |
| |
| //! |
| //! \brief Get width and height align unit of output format |
| //! \param [in] outputFormat |
| //! output format |
| //! \param [out] widthAlignUnit |
| //! width align unit |
| //! \param [out] heightAlignUnit |
| //! height align unit |
| //! \return void |
| //! |
| virtual void GetOutputWidthHeightAlignUnit( |
| MOS_FORMAT outputFormat, |
| uint16_t &widthAlignUnit, |
| uint16_t &heightAlignUnit, |
| bool isInterlacedScaling = false); |
| |
| //! |
| //! \brief Setup SFC State related parameters |
| //! \details Setup the SFC State related parameters based on the i/o surface |
| //! and Vebox and SFC rendering data |
| //! \param [in,out] pRenderData |
| //! Pointer to Vebox Render data |
| //! \param [in] pSrcSurface |
| //! Pointer to Input Source Surface |
| //! \param [in] pOutSurface |
| //! Pointer to Output Source Surface |
| //! \return MOS_STATUS |
| //! Return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| virtual MOS_STATUS SetSfcStateParams( |
| PVPHAL_VEBOX_RENDER_DATA pRenderData, |
| PVPHAL_SURFACE pSrcSurface, |
| PVPHAL_SURFACE pOutSurface); |
| |
| //! |
| //! \brief Setup parameters related to SFC_IEF State |
| //! \details Setup the IEF and CSC params of the SFC_IEF State |
| //! \param [in] veboxRenderData |
| //! Pointer to Vebox Render Data |
| //! \param [in,out] sfcStateParams |
| //! Pointer to SFC_STATE params |
| //! \param [in] inputSurface |
| //! Pointer to Input Surface |
| //! \return void |
| //! |
| virtual void SetIefStateParams( |
| PVPHAL_VEBOX_RENDER_DATA veboxRenderData, |
| PMHW_SFC_STATE_PARAMS sfcStateParams, |
| PVPHAL_SURFACE inputSurface); |
| |
| //! |
| //! \brief Setup CSC parameters of the SFC State |
| //! \param [in,out] pSfcStateParams |
| //! Pointer to SFC_STATE params |
| //! \param [out] pIEFStateParams |
| //! Pointer to MHW IEF state params |
| //! \return void |
| //! |
| virtual void SetIefStateCscParams( |
| PMHW_SFC_STATE_PARAMS pSfcStateParams, |
| PMHW_SFC_IEF_STATE_PARAMS pIEFStateParams); |
| |
| //! |
| //! \brief Update SFC Rendering Flags |
| //! \details Update the SFC rendering flag based the input and render target |
| //! surface, SFC state and the ColorFill/Alpha parameters |
| //! \param [in] pSrcSurface |
| //! Pointer to Source Surface |
| //! \param [in] pOutSurface |
| //! Pointer to Render Target Surface |
| //! \param [in,out] pRenderData |
| //! Pointer to Vebox Render Data |
| //! \return MOS_STATUS |
| //! |
| virtual MOS_STATUS UpdateRenderingFlags( |
| PVPHAL_SURFACE pSrcSurface, |
| PVPHAL_SURFACE pOutSurface, |
| PVPHAL_VEBOX_RENDER_DATA pRenderData); |
| |
| //! |
| //! \brief Determine if CSC is required in SFC pipe and set related params |
| //! \param [in] src |
| //! Pointer to Source Surface |
| //! \param [in] renderTarget |
| //! Pointer to Target Surface |
| //! \return void |
| //! |
| virtual void DetermineCscParams( |
| PVPHAL_SURFACE src, |
| PVPHAL_SURFACE renderTarget); |
| |
| //! |
| //! \brief Determine SFC input surface format |
| //! \details Determine SFC input surface format according to |
| //! surface info and vebox flags |
| //! \param [in] src |
| //! Pointer to Source Surface |
| //! \param [in] veboxRenderData |
| //! Pointer to vebox Render Data |
| //! \return void |
| //! |
| virtual void DetermineInputFormat( |
| PVPHAL_SURFACE src, |
| PVPHAL_VEBOX_RENDER_DATA veboxRenderData); |
| |
| //! |
| //! \brief Determine SFC input ordering mode |
| //! \details Determine SFC input ordering mode according to |
| //! vebox flags |
| //! \param [in] veboxRenderData |
| //! Pointer to vebox Render Data |
| //! \param [out] sfcStateParams |
| //! Pointer to SFC state params |
| //! \return void |
| //! |
| virtual void SetSfcStateInputOrderingMode( |
| PVPHAL_VEBOX_RENDER_DATA veboxRenderData, |
| PMHW_SFC_STATE_PARAMS sfcStateParams); |
| |
| //! |
| //! \brief Send SFC pipe commands |
| //! \details Register the surfaces and send the commands needed by SFC pipe |
| //! \param [in] pSfcInterface |
| //! Pointer to SFC interface |
| //! \param [in] pMhwMiInterface |
| //! Pointer to MI interface |
| //! \param [in] pOsInterface |
| //! Pointer to OS interface |
| //! \param [in] pSfcPipeOutSurface |
| //! Pointer to SFC Output surface |
| //! \param [in,out] pCmdBuffer |
| //! Pointer to command buffer |
| //! \return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| virtual MOS_STATUS RenderSfcMmcCMD( |
| PMHW_SFC_INTERFACE pSfcInterface, |
| MhwMiInterface * pMhwMiInterface, |
| PMOS_INTERFACE pOsInterface, |
| PMHW_SFC_OUT_SURFACE_PARAMS pSfcPipeOutSurface, |
| PMOS_COMMAND_BUFFER pCmdBuffer) |
| { |
| return MOS_STATUS_SUCCESS; |
| } |
| |
| //! |
| //! \brief Set SFC MMC States |
| //! \details Update the SFC output MMC status |
| //! \param [in] renderData |
| //! Pointer to Render Data |
| //! \param [in] outSurface |
| //! Pointer to Sfc Output Surface |
| //! \param [in,out] sfcStateParams |
| //! Pointer to SFC State Params |
| //! \return MOS_STATUS |
| //! |
| virtual MOS_STATUS SetSfcMmcStatus( |
| PVPHAL_VEBOX_RENDER_DATA renderData, |
| PVPHAL_SURFACE outSurface, |
| PMHW_SFC_STATE_PARAMS sfcStateParams); |
| |
| private: |
| |
| //! |
| //! \brief Setup parameters related to SFC_AVS State |
| //! \details Setup the 8x8 table of SFC sampler |
| //! \return MOS_STATUS |
| //! |
| MOS_STATUS SetAvsStateParams(); |
| |
| public: |
| bool m_bSFC2Pass = false; |
| bool m_bSFC2PassPerfMode = false; |
| |
| protected: |
| bool disableSFC = false; //!< Disable SFC for validation purposes |
| bool enableSfcMMC = false; //!< Memory compression enbale flag - read from User feature keys |
| |
| PMOS_INTERFACE m_osInterface; //!< Os Interface |
| PRENDERHAL_INTERFACE m_renderHal; //!< Pointer to RenderHal Structure Interface |
| PMHW_SFC_INTERFACE m_sfcInterface; //!< Pointer to SFC Structure Interface |
| |
| // AVS related params |
| MHW_AVS_PARAMS m_AvsParameters = {}; //!< AVS parameters |
| VPHAL_SFC_AVS_STATE m_avsState = {}; //!< AVS State and Coeff. table |
| |
| // ColorFill CSC related params |
| VPHAL_COLOR_SAMPLE_8 m_colorFillColorSrc = {}; //!< ColorFill Sample from DDI |
| VPHAL_COLOR_SAMPLE_8 m_colorFillColorDst = {}; //!< ColorFill Sample programmed in Sfc State |
| VPHAL_CSPACE m_colorFillSrcCspace = {}; //!< Cspace of the source ColorFill Color |
| VPHAL_CSPACE m_colorFillRTCspace = {}; //!< Cspace of the Render Target |
| |
| // CSC related params |
| VPHAL_CSPACE m_cscRTCspace = {}; //!< Cspace of Render Target |
| VPHAL_CSPACE m_cscInputCspace = {}; //!< Cspace of input frame |
| float m_cscCoeff[9] = {}; //!< [3x3] Coeff matrix |
| float m_cscInOffset[3] = {}; //!< [3x1] Input Offset matrix |
| float m_cscOutOffset[3] = {}; //!< [3x1] Output Offset matrix |
| |
| // Surfaces used by SFC |
| VPHAL_SURFACE m_AVSLineBufferSurface = {}; //!< AVS Line Buffer Surface for SFC |
| VPHAL_SURFACE m_IEFLineBufferSurface = {}; //!< IEF Line Buffer Surface for SFC |
| VPHAL_SURFACE m_SFDLineBufferSurface = {}; //!< SFD Line Buffer Surface for SFC |
| |
| // Stereo state. |
| uint32_t m_currentChannel = 0; //!< 0=StereoLeft or nonStereo, 1=StereoRight. N/A in nonStereo |
| |
| VPHAL_SFC_RENDER_DATA m_renderData = {}; //!< Transient Render data populated for every BLT call |
| |
| }; |
| #else |
| // A dummy class that does nothing when SFC is not supported |
| |
| class VphalSfcState |
| { |
| public: |
| VphalSfcState( |
| PMOS_INTERFACE osInterface, |
| PRENDERHAL_INTERFACE renderHal, |
| PMHW_SFC_INTERFACE sfcInterface) {} |
| virtual ~VphalSfcState() {} |
| |
| //! |
| //! \brief Disable the SFC functionality |
| //! \param [in] disable |
| //! true to disable, false to enable SFC |
| //! \return void |
| void SetDisable(bool disable) |
| { |
| |
| } |
| |
| //! |
| //! \brief Set SFC MMC status |
| //! \param [in] enable |
| //! true to disable, false to enable SFC MMC |
| //! \return void |
| void SetSfcOutputMmcStatus(bool enable) |
| { |
| |
| } |
| //! |
| //! \brief Check if SFC functionality is disabled |
| //! \return true if disabled, false if enabled |
| bool IsDisabled() |
| { |
| return true; |
| } |
| |
| //! |
| //! \brief Set stero channel of input |
| //! \param [in] currentChannel |
| //! Current stero channel |
| //! \return void |
| void SetStereoChannel(uint32_t currentChannel) |
| { |
| |
| } |
| |
| MOS_FORMAT GetInputFormat() |
| { |
| return Format_Invalid; |
| } |
| |
| VPHAL_CSPACE GetInputColorSpace() |
| { |
| return CSpace_None; |
| } |
| |
| void InitRenderData() |
| { |
| {}; |
| } |
| |
| //! |
| //! \brief Get the output pipe considering the SFC restrictions |
| //! \details Check which output pipe can be applied, SFC or Comp |
| //! \param [in] pSrc |
| //! Pointer to input surface of SFC |
| //! \param [in] pRenderTarget |
| //! Pointer to RenderTarget |
| //! \param [in] pcRenderParams |
| //! Pointer to VpHal render parameters |
| //! \return the output pipe mode |
| //! |
| VPHAL_OUTPUT_PIPE_MODE GetOutputPipe( |
| PVPHAL_SURFACE pSrc, |
| PVPHAL_SURFACE pRenderTarget, |
| PCVPHAL_RENDER_PARAMS pcRenderParams) |
| { |
| return VPHAL_OUTPUT_PIPE_MODE_COMP; |
| } |
| |
| //! |
| //! \brief Setup SFC Rendering Flags |
| //! \details Set up the SFC rendering flag based the input and render target |
| //! surface, SFC state and the ColorFill/Alpha parameters |
| //! \param [in] pColorFillParams |
| //! Pointer to ColorFill params |
| //! \param [in] pAlphaParams |
| //! Pointer to Alpha params |
| //! \param [in] pSrc |
| //! Pointer to Source Surface |
| //! \param [in] pRenderTarget |
| //! Pointer to Render Target Surface |
| //! \param [in,out] pRenderData |
| //! Pointer to Vebox render Data |
| //! \return void |
| //! |
| void SetRenderingFlags( |
| PVPHAL_COLORFILL_PARAMS pColorFillParams, |
| PVPHAL_ALPHA_PARAMS pAlphaParams, |
| PVPHAL_SURFACE pSrc, |
| PVPHAL_SURFACE pRenderTarget, |
| PVPHAL_VEBOX_RENDER_DATA pRenderData) { } |
| |
| //! |
| //! \brief Free resources used by SFC Pipe |
| //! \details Free the AVS and IEF line buffer surfaces for SFC |
| //! \return void |
| //! |
| void FreeResources() { } |
| |
| //! |
| //! \brief Check to see if the i/o surface is supported by SFC |
| //! \details Check the format and the size of i/o surface and determine |
| //! whether it can go through SFC pipe |
| //! \param [in] pSrcSurface |
| //! Pointer to Src surface |
| //! \param [in] pOutSurface |
| //! Pointer to Output surface |
| //! \param [in] pAlphaParams |
| //! Pointer to Alpha params |
| //! \return true if SFC Pipe is needed else false |
| //! |
| bool IsFormatSupported( |
| PVPHAL_SURFACE pSrcSurface, |
| PVPHAL_SURFACE pOutSurface, |
| PVPHAL_ALPHA_PARAMS pAlphaParams) { return false;} |
| |
| //! |
| //! \brief Setup SFC states and parameters |
| //! \details Setup SFC states and parameters including SFC State, AVS |
| //! and IEF parameters |
| //! \param [in] pSrcSurface |
| //! Pointer to Source Surface |
| //! \param [in] pOutSurface |
| //! Pointer to Output Surface |
| //! \param [in,out] pRenderData |
| //! Pointer to Vebox Render data |
| //! \return Return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| MOS_STATUS SetupSfcState( |
| PVPHAL_SURFACE pSrcSurface, |
| PVPHAL_SURFACE pOutSurface, |
| PVPHAL_VEBOX_RENDER_DATA pRenderData) {return MOS_STATUS_SUCCESS; } |
| |
| //! |
| //! \brief Send SFC pipe commands |
| //! \details Register the surfaces and send the commands needed by SFC pipe |
| //! \param [in] pRenderData |
| //! Pointer to Vebox Render data |
| //! \param [in,out] pCmdBuffer |
| //! Pointer to command buffer |
| //! \return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| MOS_STATUS SendSfcCmd( |
| PVPHAL_VEBOX_RENDER_DATA pRenderData, |
| PMOS_COMMAND_BUFFER pCmdBuffer) { return MOS_STATUS_SUCCESS;} |
| }; |
| #endif |
| |
| #endif // __VPHAL_RENDER_SFC_BASE_H__ |
