/* * Copyright (c) 2009-2018, 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_mdf_wrapper.h //! \brief Abstraction for MDF related operations. //! \details It is a thin wrapper layer based on MDF APIs. //! #ifndef __VPHAL_MDF_WRAPPER_H__ #define __VPHAL_MDF_WRAPPER_H__ #include #include #include #include #include #include "cm_rt_umd.h" #include "vphal.h" template class VpCmSurfaceHolder; class CmContext; class EventListener { public: virtual void OnEventAvailable(CmEvent *event, const std::string &name) = 0; }; class EventManager : public EventListener { public: EventManager(const std::string &owner, CmContext *cmContext) : mOwner(owner), m_cmContext(cmContext) { } virtual ~EventManager() { Clear(); } void OnEventAvailable(CmEvent *event, const std::string &name) override; CmEvent* GetLastEvent() const; private: void AddEvent(const std::string &name, CmEvent *event); void Clear(); void Profiling() const; std::unordered_map > mEventMap; const std::string mOwner; int mEventCount = 0; CmEvent *mLastEvent = nullptr; bool mReport = false; CmContext *m_cmContext = nullptr; }; // This is not multi-threads safe. Is it a good idea to use singleton here? class CmContext { public: // noncopyable CmContext(const CmContext&) = delete; CmContext& operator=(const CmContext&) = delete; CmContext(PMOS_INTERFACE osInterface); virtual ~CmContext(); void Destroy(); CmDevice* GetCmDevice() const { return mCmDevice; } CmQueue* GetCmQueue() const { return mCmQueue; } CmVebox* GetCmVebox() const { return mCmVebox; } void ConnectEventListener(EventListener *listener) { mEventListener = listener; } CmKernel* CloneKernel(CmKernel *kernel); void BatchKernel(CmKernel *kernel, CmThreadSpace *threadSpace, bool bFence); void FlushBatchTask(bool waitForFinish); void RunSingleKernel( CmKernel *kernel, CmThreadSpace *threadSpace, const std::string &name, bool waitForFinish); void BeginConditionalExecute(VpCmSurfaceHolder *conditionalBatchBuffer) { FlushBatchTask(false); mConditionalBatchBuffer = conditionalBatchBuffer; } void EndConditionalExecute() { FlushBatchTask(false); mConditionalBatchBuffer = nullptr; } private: void EnqueueTask(CmTask *task, CmThreadSpace *threadSpace, const std::string &name, bool waitForFinish); int mRefCount; CmDevice *mCmDevice; CmQueue *mCmQueue; CmVebox *mCmVebox; PMOS_INTERFACE m_osInterface = nullptr; CmTask *mBatchTask; std::vector mAddedKernels; std::vector mKernelsToPurge; std::vector mThreadSpacesToPurge; bool mHasBatchedTask; VpCmSurfaceHolder *mConditionalBatchBuffer; // CmContext does NOT own this. CM_CONDITIONAL_END_PARAM mCondParam; EventListener *mEventListener; // CmContext does NOT own this. }; static inline GMM_RESOURCE_FORMAT ConvertMosFmtToGmmFmt(MOS_FORMAT format) { switch (format) { case Format_X8R8G8B8: return GMM_FORMAT_B8G8R8X8_UNORM_TYPE; case Format_A8R8G8B8: return GMM_FORMAT_B8G8R8A8_UNORM_TYPE; case Format_NV12: return GMM_FORMAT_NV12_TYPE; case Format_A8: return GMM_FORMAT_A8_UNORM_TYPE; case Format_YUY2: return GMM_FORMAT_R8G8_UNORM_TYPE; case Format_R8G8UN: return GMM_FORMAT_R8G8_UNORM_TYPE; case Format_R32F: return GMM_FORMAT_R32_FLOAT_TYPE; case Format_AYUV: return GMM_FORMAT_AYUV_TYPE; case Format_Buffer: return GMM_FORMAT_A8_UNORM_TYPE; // Format_A16R16G16B16 and Format_A16B16G16R16 are using the same surface layout. case Format_A16R16G16B16: return GMM_FORMAT_R16G16B16A16_UNORM_TYPE; case Format_A16B16G16R16: return GMM_FORMAT_R16G16B16A16_UNORM_TYPE; default: { VPHAL_RENDER_ASSERTMESSAGE("Unsupported format %d\n", format); return GMM_FORMAT_INVALID; } } } static inline MOS_FORMAT ConvertGmmFmtToMosFmt(GMM_RESOURCE_FORMAT format) { switch (format) { case GMM_FORMAT_B8G8R8X8_UNORM_TYPE : return Format_X8R8G8B8; case GMM_FORMAT_B8G8R8A8_UNORM_TYPE : return Format_A8R8G8B8; case GMM_FORMAT_NV12_TYPE: return Format_NV12; case GMM_FORMAT_A8_UNORM_TYPE : return Format_A8; case GMM_FORMAT_R8G8_UNORM_TYPE : return Format_R8G8UN; case GMM_FORMAT_R32_FLOAT_TYPE : return Format_R32F; case GMM_FORMAT_AYUV_TYPE : return Format_AYUV; // WA for GMM and MDF issue. Will revisit it after fixing the issue. case GMM_FORMAT_R16G16B16A16_UNORM_TYPE: return Format_A16B16G16R16; default: { VPHAL_RENDER_ASSERTMESSAGE("Unsupported format %d\n", format); return Format_Invalid; } } } static inline int GetBitsPerPixel(GMM_RESOURCE_FORMAT format) { switch (format) { case GMM_FORMAT_B8G8R8X8_UNORM_TYPE: return 32; case GMM_FORMAT_B8G8R8A8_UNORM_TYPE: return 32; case GMM_FORMAT_NV12_TYPE: return 12; case GMM_FORMAT_A8_UNORM_TYPE: return 8; case GMM_FORMAT_R8G8_UNORM_TYPE: return 16; case GMM_FORMAT_R32_FLOAT_TYPE: return 32; case GMM_FORMAT_AYUV_TYPE: return 32; case GMM_FORMAT_R16G16B16A16_UNORM_TYPE: return 64; case GMM_FORMAT_R16G16B16X16_UNORM_TYPE: return 64; default: { VPHAL_RENDER_ASSERTMESSAGE("Unsupported format %d\n", format); return 0; } } } template class VpCmSurfaceHolder { public: static_assert( std::is_same::value || std::is_same::value || std::is_same::value, "CmSurfType need to be one of CmBuffer, CmSurface2D or CmSurface3D."); VpCmSurfaceHolder(PVPHAL_SURFACE vpSurf, CmContext *cmContext): mCmSurface(nullptr), mSurfaceIndex(nullptr), mSamplerSurfaceIndex(nullptr), mSampler8x8SurfaceIndex(nullptr), mWidth(vpSurf->dwWidth), mHeight(vpSurf->dwHeight), mDepth(vpSurf->dwDepth), mFormat(ConvertMosFmtToGmmFmt(vpSurf->Format)), m_cmContext(cmContext) { int result = CreateCmSurfaceSpecialized(vpSurf, mCmSurface); if ((result != CM_SUCCESS) || (!mCmSurface)) { VPHAL_RENDER_ASSERTMESSAGE("Failed to create VpCmSurfaceHolder from VP Surface!\n"); return; } result = mCmSurface->GetIndex(mSurfaceIndex); if (result != CM_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed to Get Surface Index"); } } VpCmSurfaceHolder(int width, int height, int depth, GMM_RESOURCE_FORMAT format, CmContext *cmContext) : mCmSurface(nullptr), mSurfaceIndex(nullptr), mSamplerSurfaceIndex(nullptr), mSampler8x8SurfaceIndex(nullptr), mWidth(width), mHeight(height), mDepth(depth), mFormat(format), m_cmContext(cmContext) { int result = CreateCmSurfaceSpecialized(width, height, depth, format, mCmSurface); if ((result != CM_SUCCESS) || (!mCmSurface)) { VPHAL_RENDER_ASSERTMESSAGE("Failed to create VpCmSurfaceHolder!\n"); return; } mCmSurface->GetIndex(mSurfaceIndex); } virtual ~VpCmSurfaceHolder() { VPHAL_RENDER_CHK_NULL_NO_STATUS_RETURN(m_cmContext); CmDevice *dev = m_cmContext->GetCmDevice(); int result = CM_SUCCESS; if (mSampler8x8SurfaceIndex) { result = dev->DestroySampler8x8Surface(mSampler8x8SurfaceIndex); if (result != CM_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed to destroy mSampler8x8SurfaceIndex!"); } } if (mSamplerSurfaceIndex) { result = dev->DestroySamplerSurface(mSamplerSurfaceIndex); if (result != CM_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed to destroy mSamplerSurfaceIndex!"); } } if (mCmSurface) { result = dev->DestroySurface(mCmSurface); if (result != CM_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed to destroy mCmSurface!"); } } } CmSurfType* GetCmSurface() const { return mCmSurface; } SurfaceIndex* GetCmSurfaceIndex() { if (!mSurfaceIndex) { int result = mCmSurface->GetIndex(mSurfaceIndex); if (result != CM_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed to GetCmSurfaceIndex!"); } } return mSurfaceIndex; } SurfaceIndex* GetCmSamplerSurfaceIndex() { if (!mSamplerSurfaceIndex) { if (!m_cmContext) { return mSamplerSurfaceIndex; } int result = m_cmContext->GetCmDevice()->CreateSamplerSurface2D(mCmSurface, mSamplerSurfaceIndex); if (result != CM_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed in CreateSamplerSurface2D!\n"); } } return mSamplerSurfaceIndex; } SurfaceIndex* GetCmSampler8x8SurfaceIndex() { if (!mSampler8x8SurfaceIndex) { if (!m_cmContext) { return mSampler8x8SurfaceIndex; } int result = m_cmContext->GetCmDevice()->CreateSampler8x8Surface(mCmSurface, mSampler8x8SurfaceIndex, CM_AVS_SURFACE, CM_SURFACE_CLAMP); if (result != CM_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed in CreateSampler8x8Surface!\n"); } } return mSampler8x8SurfaceIndex; } void GetSurfaceDimentions(int &width, int &height, int &depth) { width = mWidth; height = mHeight; depth = mDepth; } int GetSurfaceSize() const { return (mWidth * mHeight * mDepth * GetBitsPerPixel(mFormat)) >> 3; } GMM_RESOURCE_FORMAT GetFormat() const { return mFormat; } void InitSurfaceFromFile(const std::string &fileName) { std::ifstream blob(fileName, std::ifstream::ate | std::ifstream::binary); if (!blob.is_open()) { VPHAL_RENDER_ASSERTMESSAGE("Error in opening raw data file: %s.\n", fileName.c_str()); return; } const int fileSize = static_cast(blob.tellg()); if (fileSize == 0) { VPHAL_RENDER_ASSERTMESSAGE("file size is 0.\n"); return; } blob.seekg(0, blob.beg); std::vector temp(GetSurfaceSize()); blob.read(temp.data(), MOS_MIN(fileSize, GetSurfaceSize())); mCmSurface->WriteSurface((unsigned char *)temp.data(), nullptr); } void DumpSurfaceToFile(const std::string &fileName) { std::ofstream blob(fileName, std::ofstream::out | std::ifstream::binary); if (!blob.is_open()) { VPHAL_RENDER_ASSERTMESSAGE("Error in opening raw data file: %s.\n", fileName.c_str()); return; } const int size = GetSurfaceSize(); std::vector temp(size); mCmSurface->ReadSurface((unsigned char*)temp.data(), nullptr, size); blob.write(temp.data(), size); } private: VpCmSurfaceHolder(const VpCmSurfaceHolder &) = delete; VpCmSurfaceHolder& operator=(const VpCmSurfaceHolder &) = delete; inline int CreateCmSurfaceSpecialized(PVPHAL_SURFACE vpSurf, CmSurfType* &surf) { return 0; } inline int CreateCmSurfaceSpecialized(int width, int height, int depth, GMM_RESOURCE_FORMAT format, CmSurfType* &surf) { return 0; } PVPHAL_SURFACE mVphalSurface = nullptr; CmSurfType *mCmSurface = nullptr; SurfaceIndex *mSurfaceIndex = nullptr; SurfaceIndex *mSamplerSurfaceIndex = nullptr; SurfaceIndex *mSampler8x8SurfaceIndex = nullptr; const int mWidth = 0; const int mHeight = 0; const int mDepth = 0; const GMM_RESOURCE_FORMAT mFormat; CmContext *m_cmContext = nullptr; }; template <> inline int VpCmSurfaceHolder::CreateCmSurfaceSpecialized(PVPHAL_SURFACE vpSurf, CmBuffer* &surf) { if (!m_cmContext) { return CM_NULL_POINTER; } return m_cmContext->GetCmDevice()->CreateBuffer(&vpSurf->OsResource, surf); } template <> inline int VpCmSurfaceHolder::CreateCmSurfaceSpecialized(PVPHAL_SURFACE vpSurf, CmSurface2D* &surf) { if (!m_cmContext) { return CM_NULL_POINTER; } return m_cmContext->GetCmDevice()->CreateSurface2D(&vpSurf->OsResource, surf); } template <> inline int VpCmSurfaceHolder::CreateCmSurfaceSpecialized(int width, int height, int depth, GMM_RESOURCE_FORMAT format, CmBuffer* &surf) { if (!m_cmContext) { return CM_NULL_POINTER; } return m_cmContext->GetCmDevice()->CreateBuffer(width, surf); } template <> inline int VpCmSurfaceHolder::CreateCmSurfaceSpecialized(int width, int height, int depth, GMM_RESOURCE_FORMAT format, CmSurface2D* &surf) { if (!m_cmContext) { return CM_NULL_POINTER; } return m_cmContext->GetCmDevice()->CreateSurface2D(width, height, ConvertGmmFmtToMosFmt(format), surf); } template <> inline int VpCmSurfaceHolder::CreateCmSurfaceSpecialized(int width, int height, int depth, GMM_RESOURCE_FORMAT format, CmSurface3D* &surf) { if (!m_cmContext) { return CM_NULL_POINTER; } return m_cmContext->GetCmDevice()->CreateSurface3D(width, height, depth, ConvertGmmFmtToMosFmt(format), surf); } class VPRender { public: virtual ~VPRender() { } virtual void Render(void *payload) = 0; }; // A simple CM kernel render wrapper. // All methods derived classes need to implement are private. // This means the calling order of such methods is fixed, and they will // get hooked to the Render() entry method in this base class. class VPCmRenderer: public VPRender { public: VPCmRenderer(const std::string &name, CmContext *cmContext); virtual ~VPCmRenderer(); void Render(void *payload) override; void SetmBlockingMode(bool enable) { mBlockingMode = enable; } void EnableDump(bool enable) { mEnableDump = enable; } void EnableBatchDispatch(bool enable) { mBatchDispatch = enable; } protected: CmProgram* LoadProgram(const void *binary, int size); CmProgram* LoadProgram(const std::string& binaryFileName); const std::string mName; CmContext *m_cmContext = nullptr; private: virtual void AttachPayload(void *) = 0; virtual CmKernel* GetKernelToRun(std::string &name) = 0; virtual void GetThreadSpaceDimension(int &tsWidth, int &tsHeight, int &tsColor) = 0; virtual void PrepareKernel(CmKernel *kernel) = 0; // Derived class can override this method if special setup needs be performed on thread space, // like walking pattern, dependency pattern(scoreboard), etc. virtual void SetupThreadSpace(CmThreadSpace *threadSpace, int /*tsWidth*/, int /*tsHeight*/, int /*tsColor*/) { int32_t iStatus = threadSpace->SelectMediaWalkingPattern(CM_WALK_VERTICAL); if (iStatus != CM_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("SelectMediaWalkingPattern Returns %d", iStatus); } } // This method will take effect only if this renderer works in batch dispatching mode(multi-kernels in one task). // Be careful if derived class want to override it. Return true is always safe and workable. // Return false if its kernel has no dependency against previous ones, // thus will enable kernel parallel execution, which can improve performance in some cases. virtual bool NeedAddSync() { return true; } virtual bool CannotAssociateThreadSpace() { return true; } virtual void Dump() { } bool mBatchDispatch; bool mBlockingMode; bool mEnableDump; }; #endif // __VPHAL_MDF_WRAPPER_H__