blob: af65dbec5d96039b7d013e6c050b63a0bdeaa472 [file] [log] [blame]
/*
* Copyright (c) 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_def.h
//! \brief MHW interface common defines
//! \details
//!
#ifndef __MHW_DEF_H__
#define __MHW_DEF_H__
#include <memory>
#include <vector>
#include "mhw_utilities.h"
// [Macro Prefixes] | [Macro Suffixes]
// No Prefix: for external use | _T : type
// _ : for internal use | _F : function name
// __ : intermediate macros | _M : class member name
// only used by other | _DECL: declaration
// macros | _DEF : definition
#define _MHW_CMD_T(cmd) cmd##_CMD // MHW command type
#define __MHW_CMD_PAR_M(cmd) m_##cmd##_Params // member which is a pointer to MHW command parameters
#define __MHW_CMD_PAR_GET_F(cmd) GetCmdPar_##cmd // function name to get the pointer to MHW command parameter
#define __MHW_CMD_BYTE_SIZE_GET_F(cmd) GetCmdByteSize_##cmd // function name to get MHW command size in byte
#define __MHW_CMD_ADD_F(cmd) AddCmd_##cmd // function name to add command
#define __MHW_CMD_CREATE_F(cmd) CreateCmd_##cmd // function name to create command data
#define __MHW_CMD_SET_F(cmd) SetCmd_##cmd // function name to set command data
#define __MHW_CMD_PAR_GET_DECL(cmd) mhw::Pointer<_MHW_CMD_PAR_T(cmd)> __MHW_CMD_PAR_GET_F(cmd)(bool reset)
#define __MHW_CMD_BYTE_SIZE_GET_DECL(cmd) size_t __MHW_CMD_BYTE_SIZE_GET_F(cmd)() const
#define __MHW_CMD_ADD_DECL(cmd) MOS_STATUS __MHW_CMD_ADD_F(cmd)(PMOS_COMMAND_BUFFER cmdBuf, \
PMHW_BATCH_BUFFER batchBuf = nullptr, \
const uint8_t * extraData = nullptr, \
size_t extraDataSize = 0)
#define __MHW_CMD_CREATE_DECL(cmd) mhw::Pointer<std::vector<uint8_t>> __MHW_CMD_CREATE_F(cmd)() const
#define __MHW_CMD_SET_DECL(cmd) MOS_STATUS __MHW_CMD_SET_F(cmd)(uint8_t * cmdDataPtr)
#define _MHW_CMD_SET_DECL_OVERRIDE(cmd) __MHW_CMD_SET_DECL(cmd) override
#define __MHW_CMD_PAR_GET_COMMON_DEF(cmd, par_t) \
__MHW_CMD_PAR_GET_DECL(cmd) override \
{ \
MHW_FUNCTION_ENTER; \
if (this->__MHW_CMD_PAR_M(cmd) == nullptr) \
{ \
this->__MHW_CMD_PAR_M(cmd) = mhw::MakePointer<par_t(cmd)>(); \
} \
if (reset) \
{ \
auto p = mhw::DynamicPointerCast<par_t(cmd)>(this->__MHW_CMD_PAR_M(cmd)); \
*p = par_t(cmd)(); \
} \
return this->__MHW_CMD_PAR_M(cmd); \
}
#define __MHW_CMD_BYTE_SIZE_GET_DEF(cmd) \
__MHW_CMD_BYTE_SIZE_GET_DECL(cmd) override \
{ \
return sizeof(typename cmd_t::_MHW_CMD_T(cmd)); \
}
#define __MHW_CMD_ADD_DEF(cmd) \
__MHW_CMD_ADD_DECL(cmd) override \
{ \
MHW_FUNCTION_ENTER; \
this->m_currentCmdBuf = cmdBuf; \
this->m_currentBatchBuf = batchBuf; \
auto cmdData = this->__MHW_CMD_CREATE_F(cmd)(); \
MHW_CHK_STATUS_RETURN(this->__MHW_CMD_SET_F(cmd)(cmdData->data())); \
MHW_CHK_STATUS_RETURN(Mhw_AddCommandCmdOrBB(cmdBuf, batchBuf, cmdData->data(), cmdData->size())); \
if (extraData && extraDataSize > 0) \
{ \
MHW_CHK_STATUS_RETURN(Mhw_AddCommandCmdOrBB(cmdBuf, batchBuf, extraData, extraDataSize)); \
} \
return MOS_STATUS_SUCCESS; \
}
#define __MHW_CMD_CREATE_DEF(cmd) \
__MHW_CMD_CREATE_DECL(cmd) override \
{ \
typename cmd_t::_MHW_CMD_T(cmd) cmdData; \
auto p = reinterpret_cast<const uint8_t *>(&cmdData); \
return mhw::MakePointer<std::vector<uint8_t>>(p, p + sizeof(cmdData)); \
}
#define _MHW_CMD_ALL_DEF_FOR_ITF(cmd) \
public: \
virtual __MHW_CMD_PAR_GET_DECL(cmd) = 0; \
virtual __MHW_CMD_BYTE_SIZE_GET_DECL(cmd) = 0; \
virtual __MHW_CMD_ADD_DECL(cmd) = 0
#define _MHW_CMD_ALL_DEF_FOR_IMPL(cmd) \
public: \
__MHW_CMD_PAR_GET_COMMON_DEF(cmd, _MHW_CMD_PAR_T); \
__MHW_CMD_ADD_DEF(cmd); \
\
protected: \
virtual __MHW_CMD_CREATE_DECL(cmd) = 0; \
virtual __MHW_CMD_SET_DECL(cmd) { return MOS_STATUS_SUCCESS; } \
mhw::Pointer<_MHW_CMD_PAR_T(cmd)> __MHW_CMD_PAR_M(cmd) = nullptr
#define _MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(cmd) \
public: \
__MHW_CMD_BYTE_SIZE_GET_DEF(cmd); \
\
protected: \
__MHW_CMD_CREATE_DEF(cmd)
#define __MHW_CMDSET_GETCMDPARAMS_COMMON(cmdName, par_t) \
MHW_FUNCTION_ENTER; \
auto cmd = reinterpret_cast<typename cmd_t::_MHW_CMD_T(cmdName) *>(cmdDataPtr); \
auto params = mhw::DynamicPointerCast<par_t(cmdName)>(this->__MHW_CMD_PAR_M(cmdName)); \
MHW_CHK_NULL_RETURN(cmd); \
MHW_CHK_NULL_RETURN(params)
#define __MHW_CMDSET_CALLBASE(cmd) base_t::__MHW_CMD_SET_F(cmd)(cmdDataPtr)
#define _MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(cmd) \
__MHW_CMDSET_GETCMDPARAMS_COMMON(cmd, _MHW_CMD_PAR_T); \
__MHW_CMDSET_CALLBASE(cmd)
#define _MHW_SETPARAMS_AND_ADDCMD(cmd, cmdPar_t, GetPar, AddCmd, ...) \
{ \
auto par = GetPar(cmd, true); \
auto p = dynamic_cast<const cmdPar_t *>(this); \
if (p) \
{ \
p->__MHW_CMD_PAR_SET_F(cmd)(par); \
} \
LOOP_FEATURE_INTERFACE_RETURN(cmdPar_t, __MHW_CMD_PAR_SET_F(cmd), par); \
AddCmd(cmd, __VA_ARGS__); \
}
// DWORD location of a command field
#define _MHW_CMD_DW_LOCATION(field) \
static_cast<uint32_t>((reinterpret_cast<uint32_t *>(&(cmd->field)) - reinterpret_cast<uint32_t *>(&(*cmd))))
namespace mhw
{
inline int32_t Clip3(int32_t x, int32_t y, int32_t z)
{
int32_t ret = 0;
if (z < x)
{
ret = x;
}
else if (z > y)
{
ret = y;
}
else
{
ret = z;
}
return ret;
}
inline bool MmcEnabled(MOS_MEMCOMP_STATE state)
{
return state == MOS_MEMCOMP_RC || state == MOS_MEMCOMP_MC;
}
inline bool MmcRcEnabled(MOS_MEMCOMP_STATE state)
{
return state == MOS_MEMCOMP_RC;
}
inline uint32_t GetHwTileType(MOS_TILE_TYPE tileType, MOS_TILE_MODE_GMM tileModeGMM, bool gmmTileEnabled)
{
uint32_t tileMode = 0;
if (gmmTileEnabled)
{
return tileModeGMM;
}
switch (tileType)
{
case MOS_TILE_LINEAR:
tileMode = 0;
break;
case MOS_TILE_YS:
tileMode = 1;
break;
case MOS_TILE_X:
tileMode = 2;
break;
default:
tileMode = 3;
break;
}
return tileMode;
}
} // namespace mhw
#endif // __MHW_DEF_H__