Media
/
media-driver
mirror of https://github.com/intel/media-driver.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[VP] Change Stateless Buffer to AddResourceToCmd 

change the stateless buffer added in common way
This commit is contained in:
Gu_Peiyi 2025-05-22 16:06:03 +08:00 committed by intel-mediadev
parent ffb3c1fcdb
commit 70cc7d5e76
12 changed files with 202 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
media_common/agnostic/common/renderhal/renderhal.h
View File

@ -1216,6 +1216,12 @@ typedef struct _RENDERHAL_INTERFACE
const void *sseuTable; // pointer of const VphalSseuSetting table on a platform
PMHW_INDIRECT_STATE_RESOURCE_PARAMS curbeResourceList;
uint32_t curbeResourceListSize;
PMHW_INDIRECT_STATE_RESOURCE_PARAMS inlineResourceList;
uint32_t inlineResourceListSize;
uint32_t dwIndirectHeapSize;
uint32_t dwTimeoutMs;
int32_t iMaxPalettes;
@ -1766,6 +1772,16 @@ typedef struct _RENDERHAL_INTERFACE
PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,
bool bEnableSLM);
MOS_STATUS (*pfnSetCurbeResourceList)(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_INDIRECT_STATE_RESOURCE_PARAMS curbeResourceList,
uint32_t curbeResourceListSize);
MOS_STATUS (*pfnSetInlineResourceList)(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_INDIRECT_STATE_RESOURCE_PARAMS inlineResourceList,
uint32_t inlineResourceListSize);
//!
//! \brief Get mmio registers address
//! \details Get mmio registers address
@ -1946,6 +1962,16 @@ MOS_STATUS RenderHal_SetSurfaceStateToken(
PMHW_SURFACE_TOKEN_PARAMS pParams,
void *pSurfaceStateToken);
MOS_STATUS RenderHal_SetInlineResourceList(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_INDIRECT_STATE_RESOURCE_PARAMS inlineResourceList,
uint32_t inlineResourceListSize);
MOS_STATUS RenderHal_SetCurbeResourceList(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_INDIRECT_STATE_RESOURCE_PARAMS curbeResourceList,
uint32_t curbeResourceListSize);
//!
//! \brief Send Surfaces PatchList
//! \details Send Surface State commands

2
media_common/agnostic/common/renderhal/renderhal_platform_interface.h
View File

@ -565,7 +565,7 @@ public:
return MOS_STATUS_SUCCESS;
};
virtual MOS_STATUS SendStateComputeMpde(
virtual MOS_STATUS SendStateComputeMode(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer)
{

48
media_softlet/agnostic/Xe_R/Xe2_HPG/hw/mhw_render_xe2_hpg_next_impl.h
View File

@ -218,6 +218,54 @@ public:
cmd.DW4.GenerateLocalId = params.isGenerateLocalId;
cmd.DW4.EmitLocal = params.emitLocal;
if (params.heapsResource.curbeResourceListSize > 0)
{
MHW_MI_CHK_NULL(params.heapsResource.curbeResourceList);
for (uint32_t i = 0; i < params.heapsResource.curbeResourceListSize; ++i)
{
MHW_INDIRECT_STATE_RESOURCE_PARAMS &resourceParam = params.heapsResource.curbeResourceList[i];
MHW_MI_CHK_NULL(resourceParam.stateHeap);
MHW_MI_CHK_NULL(resourceParam.stateBasePtr);
MOS_COMMAND_BUFFER cmdBuffer = {};
MHW_RESOURCE_PARAMS params = {};
cmdBuffer.OsResource = *resourceParam.stateHeap;
cmdBuffer.pCmdBase = (uint32_t *)resourceParam.stateBasePtr;
cmdBuffer.iOffset = resourceParam.stateOffset;
params.pdwCmd = (uint32_t*)(resourceParam.stateBasePtr + resourceParam.stateOffset);
params.presResource = resourceParam.resource;
params.dwLocationInCmd = 0;
params.dwOffset = resourceParam.resourceOffset;
params.bIsWritable = resourceParam.isWrite;
params.HwCommandType = MOS_HW_COMMANDS;
MHW_MI_CHK_STATUS(AddResourceToCmd(m_osItf, &cmdBuffer, &params));
}
}
if (params.heapsResource.inlineResourceListSize > 0)
{
MHW_MI_CHK_NULL(params.heapsResource.inlineResourceList);
for (uint32_t i = 0; i < params.heapsResource.inlineResourceListSize; ++i)
{
MHW_INDIRECT_STATE_RESOURCE_PARAMS &resourceParam = params.heapsResource.inlineResourceList[i];
MHW_RESOURCE_PARAMS params = {};
if (resourceParam.stateOffset % sizeof(uint32_t) != 0)
{
MHW_MI_CHK_STATUS(MOS_STATUS_INVALID_PARAMETER);
}
params.pdwCmd = (uint32_t *)((uint8_t *)cmd.InlineData.Value + resourceParam.stateOffset);
params.presResource = resourceParam.resource;
params.dwLocationInCmd = resourceParam.stateOffset / sizeof(uint32_t) + _MHW_CMD_DW_LOCATION(InlineData.Value);
params.dwOffset = resourceParam.resourceOffset;
params.bIsWritable = resourceParam.isWrite;
params.HwCommandType = MOS_HW_COMMANDS;
MHW_MI_CHK_STATUS(AddResourceToCmd(m_osItf, m_currentCmdBuf, &params));
}
}
return MOS_STATUS_SUCCESS;
}

4
media_softlet/agnostic/common/hw/mhw_render_cmdpar.h
View File

@ -65,6 +65,10 @@ struct MHW_HEAPS_RESOURCE
{
PMOS_RESOURCE presInstructionBuffer = nullptr;
uint64_t kernelStartGfxAddress = 0;
PMHW_INDIRECT_STATE_RESOURCE_PARAMS curbeResourceList = nullptr;
uint32_t curbeResourceListSize = 0;
PMHW_INDIRECT_STATE_RESOURCE_PARAMS inlineResourceList = nullptr;
uint32_t inlineResourceListSize = 0;
};
enum MHW_VFE_SLICE_DISABLE

11
media_softlet/agnostic/common/hw/mhw_utilities_next.h
View File

@ -603,6 +603,17 @@ typedef struct _MHW_MOCS_PARAMS
uint8_t bitFieldHigh;
} MHW_MOCS_PARAMS;
struct MHW_INDIRECT_STATE_RESOURCE_PARAMS
{
PMOS_RESOURCE stateHeap = nullptr;
uint8_t *stateBasePtr = nullptr;
uint32_t stateOffset = 0;
PMOS_RESOURCE resource = nullptr;
uint32_t resourceOffset = 0;
bool isWrite = false;
};
using PMHW_INDIRECT_STATE_RESOURCE_PARAMS = MHW_INDIRECT_STATE_RESOURCE_PARAMS*;
typedef struct _MHW_RESOURCE_PARAMS
{
PMOS_RESOURCE presResource;

60
media_softlet/agnostic/common/renderhal/renderhal.cpp
View File

@ -4857,6 +4857,19 @@ int32_t RenderHal_LoadCurbeData(
{
MOS_ZeroMemory(pPtrCurbe + iSize, iCurbeSize);
}
if (pRenderHal->curbeResourceListSize > 0)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->curbeResourceList);
for (uint32_t i = 0; i < pRenderHal->curbeResourceListSize; ++i)
{
MHW_INDIRECT_STATE_RESOURCE_PARAMS &resourceParam = pRenderHal->curbeResourceList[i];
resourceParam.stateHeap = &pStateHeap->GshOsResource;
resourceParam.stateBasePtr = pStateHeap->pGshBuffer;
resourceParam.stateOffset += (pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetCurbe + iOffset);
}
}
}
}
}
@ -5705,7 +5718,7 @@ MOS_STATUS RenderHal_AssignBindlessSurfaceStates(
return eStatus;
}
MOS_STATUS RenderHal_SendSurfaces_Bindelss(
MOS_STATUS RenderHal_SendBindlessSurfaces(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
bool bNeedNullPatch)
@ -7493,7 +7506,7 @@ MOS_STATUS RenderHal_InitInterface(
pRenderHal->pfnSetSurfaceStateBuffer = RenderHal_SetSurfaceStateBuffer;
pRenderHal->pfnCalculateYOffset = RenderHal_CalculateYOffset;
pRenderHal->pfnAssignBindlessSurfaceStates = RenderHal_AssignBindlessSurfaceStates;
pRenderHal->pfnSendBindlessSurfaceStates = RenderHal_SendSurfaces_Bindelss;
pRenderHal->pfnSendBindlessSurfaceStates = RenderHal_SendBindlessSurfaces;
pRenderHal->pfnGetPlaneDefinitionForCommonMessage = RenderHal_GetPlaneDefinitionForCommonMessage;
@ -7527,6 +7540,8 @@ MOS_STATUS RenderHal_InitInterface(
pRenderHal->pfnSendPalette = RenderHal_SendPalette;
pRenderHal->pfnSendMediaStates = RenderHal_SendMediaStates;
pRenderHal->pfnSendStateBaseAddress = RenderHal_SendStateBaseAddress;
pRenderHal->pfnSetCurbeResourceList = RenderHal_SetCurbeResourceList;
pRenderHal->pfnSetInlineResourceList = RenderHal_SetInlineResourceList;
// Initialize OS dependent RenderHal Interfaces common to all platforms
pRenderHal->pfnReset = RenderHal_Reset;
@ -7759,3 +7774,44 @@ MOS_STATUS RenderHal_SetBufferSurfaceForHwAccess(
return eStatus;
}
MOS_STATUS RenderHal_SetInlineResourceList(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_INDIRECT_STATE_RESOURCE_PARAMS inlineResourceList,
uint32_t inlineResourceListSize)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
if (inlineResourceListSize > 0)
{
MHW_RENDERHAL_CHK_NULL_RETURN(inlineResourceList);
pRenderHal->inlineResourceList = inlineResourceList;
pRenderHal->inlineResourceListSize = inlineResourceListSize;
}
else
{
pRenderHal->inlineResourceList = nullptr;
pRenderHal->inlineResourceListSize = 0;
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS RenderHal_SetCurbeResourceList(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_INDIRECT_STATE_RESOURCE_PARAMS curbeResourceList,
uint32_t curbeResourceListSize)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
if (curbeResourceListSize > 0)
{
MHW_RENDERHAL_CHK_NULL_RETURN(curbeResourceList);
pRenderHal->curbeResourceList = curbeResourceList;
pRenderHal->curbeResourceListSize = curbeResourceListSize;
}
else
{
pRenderHal->curbeResourceList = nullptr;
pRenderHal->curbeResourceListSize = 0;
}
return MOS_STATUS_SUCCESS;
}

6
media_softlet/agnostic/common/renderhal/renderhal_platform_interface_next.cpp
View File

@ -1544,6 +1544,7 @@ MHW_SETPAR_DECL_SRC(COMPUTE_WALKER, XRenderHal_Platform_Interface_Next)
{
MHW_RENDERHAL_CHK_NULL_RETURN(m_gpgpuWalkerParams);
MHW_RENDERHAL_CHK_NULL_RETURN(m_interfaceDescriptorParams);
MHW_RENDERHAL_CHK_NULL_RETURN(m_renderHal);
params.simdSize = m_gpgpuWalkerParams->simdSize;
params.IndirectDataLength = m_gpgpuWalkerParams->IndirectDataLength;
@ -1593,6 +1594,11 @@ MHW_SETPAR_DECL_SRC(COMPUTE_WALKER, XRenderHal_Platform_Interface_Next)
params.isGenerateLocalId = m_gpgpuWalkerParams->isGenerateLocalID;
params.emitLocal = mhw::render::MHW_EMIT_LOCAL_MODE(m_gpgpuWalkerParams->emitLocal);
params.heapsResource.curbeResourceList = m_renderHal->curbeResourceList;
params.heapsResource.curbeResourceListSize = m_renderHal->curbeResourceListSize;
params.heapsResource.inlineResourceList = m_renderHal->inlineResourceList;
params.heapsResource.inlineResourceListSize = m_renderHal->inlineResourceListSize;
return MOS_STATUS_SUCCESS;
}

2
media_softlet/agnostic/common/vp/hal/features/vp_hdr_filter.cpp
View File

@ -193,10 +193,12 @@ MOS_STATUS VpHdrFilter::CalculateEngineParams(
case LUT_FILLLUTTABLE_IOLUTINDEX:
VP_PUBLIC_CHK_NULL_RETURN(krnArg.pData);
*(uint32_t *)krnArg.pData = SurfaceType3DLut;
krnArg.isOutput = true;
break;
case LUT_FILLLUTTABLE_ICOEFINDEX:
VP_PUBLIC_CHK_NULL_RETURN(krnArg.pData);
*(uint32_t *)krnArg.pData = SurfaceType3DLutCoef;
krnArg.isOutput = false;
break;
case LUT_FILLLUTTABLE_LUTSIZE:
VP_PUBLIC_CHK_NULL_RETURN(krnArg.pData);

4
media_softlet/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp
View File

@ -985,6 +985,7 @@ MOS_STATUS VpRenderCmdPacket::SetupCurbeStateInBindlessMode()
uint32_t curbeLengthAligned = 0;
VP_RENDER_CHK_STATUS_RETURN(m_kernel->GetCurbeState(curbeData, curbeLength, curbeLengthAligned, m_renderData.KernelParam, m_renderHal->dwCurbeBlockAlign));
VP_RENDER_CHK_STATUS_RETURN(m_renderHal->pfnSetCurbeResourceList(m_renderHal, m_kernel->GetCurbeResourceList().data(), m_kernel->GetCurbeResourceList().size()));
m_renderData.iCurbeOffset = m_renderHal->pfnLoadCurbeData(
m_renderHal,
@ -1096,6 +1097,7 @@ MOS_STATUS VpRenderCmdPacket::SetupWalkerParams()
VP_RENDER_CHK_NULL_RETURN(m_kernel);
VP_RENDER_CHK_STATUS_RETURN(m_kernel->GetWalkerSetting(m_renderData.walkerParam, m_renderData));
VP_RENDER_CHK_STATUS_RETURN(m_renderHal->pfnSetInlineResourceList(m_renderHal, m_kernel->GetInlineResourceList().data(), m_kernel->GetInlineResourceList().size()));
MT_LOG2(MT_VP_CREATE, MT_NORMAL, MT_FUNC_END, 1, MT_MOS_STATUS, MOS_STATUS_SUCCESS);
return MOS_STATUS_SUCCESS;
@ -2034,7 +2036,7 @@ MOS_STATUS VpRenderCmdPacket::SendMediaStates(
}
else
{
pRenderHal->pRenderHalPltInterface->SendStateComputeMpde(pRenderHal, pCmdBuffer);
pRenderHal->pRenderHalPltInterface->SendStateComputeMode(pRenderHal, pCmdBuffer);
}
}

25
media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp
View File

@ -233,35 +233,10 @@ MOS_STATUS VpRenderKernelObj::CpPrepareResources()
MOS_STATUS VpRenderKernelObj::SetupStatelessBuffer()
{
m_statelessArray.clear();
VP_RENDER_NORMALMESSAGE("Not prepare stateless buffer in kernel %d.", m_kernelId);
return MOS_STATUS_SUCCESS;
}
MOS_STATUS VpRenderKernelObj::SetupStatelessBufferResource(SurfaceType surf, bool isWrite)
{
VP_RENDER_CHK_NULL_RETURN(m_surfaceGroup);
VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
if (surf != SurfaceTypeInvalid)
{
PMOS_INTERFACE osInterface = m_hwInterface->m_osInterface;
VP_RENDER_CHK_NULL_RETURN(osInterface);
auto it = m_surfaceGroup->find(surf);
VP_SURFACE *curSurf = (m_surfaceGroup->end() != it) ? it->second : nullptr;
VP_RENDER_CHK_NULL_RETURN(curSurf);
uint64_t ui64GfxAddress = osInterface->pfnGetResourceGfxAddress(osInterface, &curSurf->osSurface->OsResource);
VP_RENDER_CHK_STATUS_RETURN(osInterface->pfnRegisterResource(
osInterface,
&curSurf->osSurface->OsResource,
isWrite,
true));
m_statelessArray.emplace(surf, ui64GfxAddress);
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS VpRenderKernelObj::SetProcessSurfaceGroup(VP_SURFACE_GROUP &surfaces)
{
m_surfaceGroup = &surfaces;

16
media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h
View File

@ -86,7 +86,6 @@ using KERNEL_SAMPLER_STATES = std::vector<MHW_SAMPLER_STATE_PARAM>;
using KERNEL_SAMPLER_INDEX = std::vector<SamplerIndex>;
using KERNEL_SURFACE_CONFIG = std::map<SurfaceType, KERNEL_SURFACE_STATE_PARAM>;
using KERNEL_SURFACE_BINDING_INDEX = std::map<SurfaceType, std::set<uint32_t>>;
using KERNEL_STATELESS_BUFF_CONFIG = std::map<SurfaceType, uint64_t>;
using KERNEL_BINDELESS_SURFACE = std::map<SurfaceType, std::vector<uint64_t>>;
using KERNEL_BINDELESS_SAMPLER = std::map<uint32_t, uint64_t>;
@ -570,6 +569,16 @@ public:
return MOS_STATUS_SUCCESS;
}
std::vector<MHW_INDIRECT_STATE_RESOURCE_PARAMS> &GetCurbeResourceList()
{
return m_curbeResourceList;
}
std::vector<MHW_INDIRECT_STATE_RESOURCE_PARAMS> &GetInlineResourceList()
{
return m_inlineResourceList;
}
protected:
virtual MOS_STATUS SetWalkerSetting(KERNEL_THREAD_SPACE &threadSpace, bool bSyncFlag, bool flushL1 = false);
@ -588,8 +597,6 @@ protected:
virtual MOS_STATUS SetupStatelessBuffer();
virtual MOS_STATUS SetupStatelessBufferResource(SurfaceType surf, bool isWrite);
virtual MOS_STATUS GetCurbeState(void *&curbe, uint32_t &curbeLength) = 0;
virtual MOS_STATUS GetAlignedLength(uint32_t &curbeLength, uint32_t &curbeLengthAligned, RENDERHAL_KERNEL_PARAM kernelParam, uint32_t dwBlockAlign)
@ -613,9 +620,10 @@ protected:
KERNEL_SURFACE_BINDING_INDEX m_surfaceBindingIndex; // store the binding index for processed surface
PVpAllocator m_allocator = nullptr;
MediaUserSettingSharedPtr m_userSettingPtr = nullptr; // usersettingInstance
KERNEL_STATELESS_BUFF_CONFIG m_statelessArray;
KERNEL_BINDELESS_SURFACE m_bindlessSurfaceArray;
KERNEL_BINDELESS_SAMPLER m_bindlessSamperArray;
std::vector<MHW_INDIRECT_STATE_RESOURCE_PARAMS> m_curbeResourceList = {};
std::vector<MHW_INDIRECT_STATE_RESOURCE_PARAMS> m_inlineResourceList = {};
// kernel attribute
std::string m_kernelName = "";
void * m_kernelBinary = nullptr;

41
media_softlet/agnostic/common/vp/hal/packet/vp_render_vebox_hdr_3dlut_ocl_kernel.cpp
View File

@ -284,15 +284,14 @@ MOS_STATUS VpRenderHdr3DLutOclKernel::CpPrepareResources()
MOS_STATUS VpRenderHdr3DLutOclKernel::SetupStatelessBuffer()
{
VP_FUNC_CALL();
m_statelessArray.clear();
VP_RENDER_CHK_STATUS_RETURN(SetupStatelessBufferResource(SurfaceType3DLutCoef, false));
VP_RENDER_CHK_STATUS_RETURN(SetupStatelessBufferResource(SurfaceType3DLut, true));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS VpRenderHdr3DLutOclKernel::GetCurbeState(void *&curbe, uint32_t &curbeLength)
{
VP_FUNC_CALL();
m_curbeResourceList.clear();
curbeLength = m_curbeSize;
VP_RENDER_NORMALMESSAGE("KernelID %d, Curbe Size %d\n", m_kernelId, curbeLength);
@ -326,11 +325,19 @@ MOS_STATUS VpRenderHdr3DLutOclKernel::GetCurbeState(void *&curbe, uint32_t &curb
{
if (arg.addressMode == AddressingModeStateless && arg.pData != nullptr)
{
VP_PUBLIC_CHK_NULL_RETURN(m_surfaceGroup);
SurfaceType surfType = *((SurfaceType *)arg.pData);
auto it = m_statelessArray.find(surfType);
VP_PUBLIC_CHK_NOT_FOUND_RETURN(it, &m_statelessArray);
uint64_t ui64GfxAddress = it->second;
MOS_SecureMemcpy(pCurbe + arg.uOffsetInPayload, arg.uSize, &ui64GfxAddress, sizeof(ui64GfxAddress));
auto it = m_surfaceGroup->find(surfType);
VP_PUBLIC_CHK_NOT_FOUND_RETURN(it, m_surfaceGroup);
PVP_SURFACE surface = it->second;
VP_PUBLIC_CHK_NULL_RETURN(surface);
VP_PUBLIC_CHK_NULL_RETURN(surface->osSurface);
MHW_INDIRECT_STATE_RESOURCE_PARAMS params = {};
params.isWrite = arg.isOutput;
params.resource = &surface->osSurface->OsResource;
params.stateOffset = arg.uOffsetInPayload;
m_curbeResourceList.push_back(params);
}
}
else if (arg.eArgKind == ARG_KIND_INLINE)
@ -368,6 +375,7 @@ MOS_STATUS VpRenderHdr3DLutOclKernel::GetWalkerSetting(KERNEL_WALKER_PARAMS &wal
// Only for Adv kernels.
MOS_STATUS VpRenderHdr3DLutOclKernel::GetInlineData(uint8_t *inlineData)
{
m_inlineResourceList.clear();
for (auto &arg : m_kernelArgs)
{
if (arg.eArgKind == ARG_KIND_INLINE)
@ -376,12 +384,20 @@ MOS_STATUS VpRenderHdr3DLutOclKernel::GetInlineData(uint8_t *inlineData)
{
if (arg.addressMode == AddressingModeStateless)
{
VP_PUBLIC_CHK_NULL_RETURN(m_surfaceGroup);
SurfaceType surfType = *((SurfaceType *)arg.pData);
auto it = m_statelessArray.find(surfType);
VP_PUBLIC_CHK_NOT_FOUND_RETURN(it, &m_statelessArray);
uint64_t ui64GfxAddress = it->second;
MOS_SecureMemcpy(inlineData + arg.uOffsetInPayload, arg.uSize, &ui64GfxAddress, sizeof(ui64GfxAddress));
VP_RENDER_NORMALMESSAGE("Setting Inline Data Statelss Surface KernelID %d, index %d , value %d, address 0x%x argKind %d", m_kernelId, arg.uIndex, *(uint32_t *)arg.pData, ui64GfxAddress, arg.eArgKind);
auto it = m_surfaceGroup->find(surfType);
VP_PUBLIC_CHK_NOT_FOUND_RETURN(it, m_surfaceGroup);
PVP_SURFACE surface = it->second;
VP_PUBLIC_CHK_NULL_RETURN(surface);
VP_PUBLIC_CHK_NULL_RETURN(surface->osSurface);
MHW_INDIRECT_STATE_RESOURCE_PARAMS params = {};
params.isWrite = arg.isOutput;
params.resource = &surface->osSurface->OsResource;
params.stateOffset = arg.uOffsetInPayload;
m_inlineResourceList.push_back(params);
VP_RENDER_NORMALMESSAGE("Setting Stateless Inline Data Statelss Surface KernelID %d, index %d , surfType %d, argKind %d", m_kernelId, arg.uIndex, *(uint32_t *)arg.pData, arg.eArgKind);
}
else
{
@ -577,6 +593,7 @@ MOS_STATUS VpRenderHdr3DLutOclKernel::SetKernelArgs(KERNEL_ARGS &kernelArgs, VP_
{
dstArg.eArgKind = srcArg.eArgKind;
dstArg.pData = srcArg.pData;
dstArg.isOutput = srcArg.isOutput;
srcArg.pData = nullptr;
}
}