Debian Codegraph @

media_softlet/agnostic/common/vp/hal/packet/vp_render_hdrlite_kernel.cpp

raw
1 #include "vp_render_hdrlite_kernel.h"
2
3 using namespace vp;
4
5 VpRenderHDRLITEKernel::VpRenderHDRLITEKernel(PVP_MHWINTERFACE hwInterface, VpKernelID kernelID, uint32_t kernelIndex, PVpAllocator allocator) : VpRenderKernelObj(hwInterface, kernelID, kernelIndex, "", allocator)
6 {
7 m_renderHal = hwInterface ? hwInterface->m_renderHal : nullptr;
8 m_kernelIndex = kernelIndex;
9
10 switch (static_cast<int>(kernelID))
11 {
12 case static_cast<int>(kernelHdrMandatoryLite):
13 m_kernelName = "HDR_mandatory_HdrRender"; // This is the exact name in igvp_xxx.cpp:InitVpDelayedNativeAdvKernel
14 break;
15 default:
16 m_kernelName.assign("");
17 VP_RENDER_ASSERTMESSAGE("Kernel ID cannot map to Kernel Name");
18 break;
19 }
20 m_isAdvKernel = true;
21 m_useIndependentSamplerGroup = true;
22 m_kernelBinaryID = VP_ADV_KERNEL_BINARY_ID(kernelHdrMandatoryLite);
23 }
24
25 VpRenderHDRLITEKernel::~VpRenderHDRLITEKernel()
26 {
27 MOS_SafeFreeMemory(m_curbe);
28 m_curbe = nullptr;
29 }
30
31 MOS_STATUS VpRenderHDRLITEKernel::Init(VpRenderKernel &kernel)
32 {
33 VP_FUNC_CALL();
34
35 VP_RENDER_NORMALMESSAGE("Initializing HDRLITE krn %s", kernel.GetKernelName().c_str());
36
37 m_kernelSize = kernel.GetKernelSize();
38
39 uint8_t *pKernelBin = (uint8_t *)kernel.GetKernelBinPointer();
40 VP_RENDER_CHK_NULL_RETURN(pKernelBin);
41
42 m_kernelBinary = pKernelBin + kernel.GetKernelBinOffset();
43
44 m_kernelArgs.clear();
45 for (auto &arg : kernel.GetKernelArgs())
46 {
47 arg.pData = nullptr;
48 m_kernelArgs.emplace(arg.uIndex,arg);
49 }
50
51 m_kernelBtis = kernel.GetKernelBtis();
52
53 m_kernelEnv = kernel.GetKernelExeEnv();
54
55 m_curbeLocation.size = kernel.GetCurbeSize();
56
57 m_inlineData.resize(m_kernelEnv.uInlineDataPayloadSize);
58
59 return MOS_STATUS_SUCCESS;
60 }
61
62 MOS_STATUS VpRenderHDRLITEKernel::SetSamplerStates(KERNEL_SAMPLER_STATE_GROUP &samplerStateGroup)
63 {
64 VP_FUNC_CALL();
65
66 if (m_kernelEnv.bHasSample)
67 {
68 samplerStateGroup.clear();
69
70 MHW_SAMPLER_STATE_PARAM samplerStateParam = {};
71 samplerStateParam.Unorm.SamplerFilterMode = MHW_SAMPLER_FILTER_BILINEAR;
72 samplerStateParam.Unorm.MagFilter = MHW_GFX3DSTATE_MAPFILTER_LINEAR;
73 samplerStateParam.Unorm.MinFilter = MHW_GFX3DSTATE_MAPFILTER_LINEAR;
74 samplerStateParam.Unorm.AddressU = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
75 samplerStateParam.Unorm.AddressV = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
76 samplerStateParam.Unorm.AddressW = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
77 samplerStateParam.bInUse = true;
78 samplerStateParam.SamplerType = MHW_SAMPLER_TYPE_3D;
79 if (m_linearSamplerIndex >= 0)
80 {
81 VP_RENDER_NORMALMESSAGE("Bilinear Sampler Set on Sampler Index %d", m_linearSamplerIndex);
82 samplerStateGroup.emplace(m_linearSamplerIndex, samplerStateParam);
83 }
84 else
85 {
86 VP_RENDER_NORMALMESSAGE("Bilinear Sampler NOT SET for Invalid Index %d", m_linearSamplerIndex);
87 }
88
89 samplerStateParam = {};
90 samplerStateParam.Unorm.SamplerFilterMode = MHW_SAMPLER_FILTER_NEAREST;
91 samplerStateParam.Unorm.MagFilter = MHW_GFX3DSTATE_MAPFILTER_NEAREST;
92 samplerStateParam.Unorm.MinFilter = MHW_GFX3DSTATE_MAPFILTER_NEAREST;
93 samplerStateParam.Unorm.AddressU = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
94 samplerStateParam.Unorm.AddressV = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
95 samplerStateParam.Unorm.AddressW = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
96 samplerStateParam.bInUse = true;
97 samplerStateParam.SamplerType = MHW_SAMPLER_TYPE_3D;
98 if (m_nearestSamplerIndex >= 0)
99 {
100 VP_RENDER_NORMALMESSAGE("Nearest Sampler Set on Sampler Index %d", m_nearestSamplerIndex);
101 samplerStateGroup.emplace(m_nearestSamplerIndex, samplerStateParam);
102 }
103 else
104 {
105 VP_RENDER_NORMALMESSAGE("Nearest Sampler NOT SET for Invalid Index %d", m_nearestSamplerIndex);
106 }
107 }
108
109 return MOS_STATUS_SUCCESS;
110 }
111
112 MOS_STATUS VpRenderHDRLITEKernel::SetKernelArgs(KERNEL_ARGS &kernelArgs, VP_PACKET_SHARED_CONTEXT *sharedContext)
113 {
114 VP_FUNC_CALL();
115
116 //All pData will be free in VpFilter::Destroy so no need to free here
117 for (KRN_ARG &srcArg : kernelArgs)
118 {
119 auto handle = m_kernelArgs.find(srcArg.uIndex);
120
121 if (srcArg.eArgKind == ARG_KIND_GENERAL || srcArg.eArgKind == ARG_KIND_INLINE)
122 {
123 if (handle != m_kernelArgs.end())
124 {
125 KRN_ARG &dstArg = handle->second;
126 if (srcArg.pData == nullptr)
127 {
128 VP_RENDER_ASSERTMESSAGE("The Kernel Argument General Data is null! KernelID %d, argIndex %d", m_kernelId, dstArg.uIndex);
129 return MOS_STATUS_INVALID_PARAMETER;
130 }
131 else
132 {
133 dstArg.eArgKind = srcArg.eArgKind;
134 dstArg.pData = srcArg.pData;
135 srcArg.pData = nullptr;
136 }
137 }
138 }
139 else if (srcArg.eArgKind == ARG_KIND_SAMPLER)
140 {
141 if (handle != m_kernelArgs.end())
142 {
143 KRN_ARG &dstArg = handle->second;
144 if (srcArg.pData == nullptr)
145 {
146 VP_RENDER_ASSERTMESSAGE("The Kernel Argument Sampler Data is null! KernelID %d, argIndex %d", m_kernelId, dstArg.uIndex);
147 return MOS_STATUS_INVALID_PARAMETER;
148 }
149 else
150 {
151 if (*(uint32_t *)srcArg.pData == MHW_SAMPLER_FILTER_BILINEAR)
152 {
153 dstArg.pData = srcArg.pData;
154 srcArg.pData = nullptr;
155 }
156 else if (*(uint32_t *)srcArg.pData == MHW_SAMPLER_FILTER_NEAREST)
157 {
158 dstArg.pData = srcArg.pData;
159 srcArg.pData = nullptr;
160 }
161 else
162 {
163 VP_RENDER_ASSERTMESSAGE("The Kernel Argument Sampler Data is INVALID TYPE! KernelID %d, argIndex %d, type %d", m_kernelId, dstArg.uIndex, *(uint32_t *)srcArg.pData);
164 return MOS_STATUS_INVALID_PARAMETER;
165 }
166 }
167 }
168 }
169
170 if (srcArg.pData != nullptr)
171 {
172 srcArg.pData = nullptr;
173 VP_RENDER_ASSERTMESSAGE("The Kernel Argument is set but not used. KernelID %d, argIndex %d", m_kernelId, srcArg.uIndex);
174 }
175 }
176
177 return MOS_STATUS_SUCCESS;
178 }
179
180 MOS_STATUS VpRenderHDRLITEKernel::GetCurbeState(void *&curbe, uint32_t &curbeLength)
181 {
182 VP_FUNC_CALL();
183 curbeLength = m_curbeLocation.size;
184
185 bool isLocalIdGeneratedByRuntime = IsLocalIdGeneratedByRuntime(m_kernelEnv, m_kernelPerThreadArgInfo, m_walkerParam.threadWidth, m_walkerParam.threadHeight, m_walkerParam.threadDepth);
186 if (isLocalIdGeneratedByRuntime)
187 {
188 VP_RENDER_CHK_STATUS_RETURN(PaddingPerThreadCurbe(curbeLength, m_walkerParam.threadWidth, m_walkerParam.threadHeight, m_walkerParam.threadDepth));
189 }
190
191 VP_RENDER_NORMALMESSAGE("KernelID %d, Kernel Name %s, Curbe Size %d\n", m_kernelId, m_kernelName.c_str(), curbeLength);
192
193 if (curbeLength == 0)
194 {
195 VP_RENDER_NORMALMESSAGE("Skip Allocate Curbe for its Size is 0");
196 curbe = nullptr;
197 return MOS_STATUS_SUCCESS;
198 }
199
200 uint8_t *pCurbe = (uint8_t *)MOS_AllocAndZeroMemory(curbeLength);
201 VP_RENDER_CHK_NULL_RETURN(pCurbe);
202 MOS_FreeMemAndSetNull(m_curbe);
203 m_curbe = pCurbe;
204
205 for (auto &handle : m_kernelArgs)
206 {
207 KRN_ARG &arg = handle.second;
208 switch (arg.eArgKind)
209 {
210 case ARG_KIND_GENERAL:
211 if (arg.pData != nullptr)
212 {
213 MOS_SecureMemcpy(pCurbe + arg.uOffsetInPayload, arg.uSize, arg.pData, arg.uSize);
214 VP_RENDER_NORMALMESSAGE("Setting Curbe State KernelID %d, index %d , value %d, argKind %d", m_kernelId, arg.uIndex, *(uint32_t *)arg.pData, arg.eArgKind);
215 }
216 else
217 {
218 VP_RENDER_NORMALMESSAGE("KernelID %d, index %d, argKind %d is empty", m_kernelId, arg.uIndex, arg.eArgKind);
219 }
220 break;
221 case ARG_KIND_SURFACE:
222 if (arg.addressMode == AddressingModeBindless)
223 {
224 // this is bindless surface
225 VP_PUBLIC_CHK_STATUS_RETURN(SetBindlessSurfaceStateToResourceList(arg));
226 VP_RENDER_NORMALMESSAGE("Setting Curbe State Bindless Surface KernelID %d, index %d, argKind %d", m_kernelId, arg.uIndex, arg.eArgKind);
227 }
228 else if(arg.addressMode == AddressingModeStateless)
229 {
230 VP_PUBLIC_CHK_NULL_RETURN(arg.pData)
231 VP_PUBLIC_CHK_NULL_RETURN(m_surfaceGroup);
232 SurfaceType surfType = *((SurfaceType *)arg.pData);
233 auto it = m_surfaceGroup->find(surfType);
234 VP_PUBLIC_CHK_NOT_FOUND_RETURN(it, m_surfaceGroup);
235 PVP_SURFACE surface = it->second;
236 VP_PUBLIC_CHK_NULL_RETURN(surface);
237 VP_PUBLIC_CHK_NULL_RETURN(surface->osSurface);
238
239 MHW_INDIRECT_STATE_RESOURCE_PARAMS params = {};
240 params.isWrite = arg.isOutput;
241 params.resource = &surface->osSurface->OsResource;
242 params.stateOffset = arg.uOffsetInPayload;
243 m_curbeResourceList.push_back(params);
244 }
245 else
246 {
247 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_UNIMPLEMENTED);
248 }
249 break;
250 case ARG_KIND_INLINE:
251 break;
252 case ARG_KIND_SAMPLER:
253 if (arg.addressMode == AddressingModeBindless)
254 {
255 VP_RENDER_CHK_NULL_RETURN(arg.pData);
256 uint32_t samplerIndex = (*(uint32_t *)arg.pData == MHW_SAMPLER_FILTER_NEAREST) ? m_nearestSamplerIndex : m_linearSamplerIndex;
257 VP_RENDER_CHK_STATUS_RETURN(SetBindlessSamplerToResourceList(arg, samplerIndex));
258 VP_RENDER_NORMALMESSAGE("Setting Curbe State Bindless Sampler KernelID %d, index %d, argKind %d", m_kernelId, arg.uIndex, arg.eArgKind);
259 }
260 break;
261 default:
262 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_UNIMPLEMENTED);
263 }
264 }
265
266 if (isLocalIdGeneratedByRuntime)
267 {
268 VP_RENDER_CHK_STATUS_RETURN(SetPerThreadCurbe(pCurbe, m_curbeLocation.size, curbeLength, m_kernelPerThreadArgInfo, m_walkerParam.threadWidth, m_walkerParam.threadHeight, m_walkerParam.threadDepth));
269 }
270
271 curbe = pCurbe;
272
273 return MOS_STATUS_SUCCESS;
274 }
275
276 MOS_STATUS VpRenderHDRLITEKernel::GetKernelSurfaceParam(SURFACE_PARAMS &surfParam, KERNEL_SURFACE_STATE_PARAM &kernelSurfaceParam)
277 {
278 MOS_ZeroMemory(&kernelSurfaceParam, sizeof(KERNEL_SURFACE_STATE_PARAM));
279 kernelSurfaceParam.surfaceOverwriteParams.updatedRenderSurfaces = true;
280 kernelSurfaceParam.surfaceOverwriteParams.bindedKernel = false;
281 PRENDERHAL_SURFACE_STATE_PARAMS pRenderSurfaceParams = &kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams;
282 pRenderSurfaceParams->bAVS = false;
283 pRenderSurfaceParams->Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
284 pRenderSurfaceParams->b2PlaneNV12NeededByKernel = true;
285 pRenderSurfaceParams->forceCommonSurfaceMessage = true;
286 MOS_HW_RESOURCE_DEF resourceType = MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER;
287 SurfaceType surfType = surfParam.surfType;
288
289 if (surfParam.combineChannelY)
290 {
291 pRenderSurfaceParams->combineChannelY = true;
292 }
293 pRenderSurfaceParams->isOutput = surfParam.isOutput;
294
295 auto surf = m_surfaceGroup->find(surfType);
296 if (m_surfaceGroup->end() == surf)
297 {
298 VP_RENDER_ASSERTMESSAGE("surf was not found %d", surfType);
299 return MOS_STATUS_NULL_POINTER;
300 }
301 VP_RENDER_CHK_NULL_RETURN(surf->second);
302 VP_RENDER_CHK_NULL_RETURN(surf->second->osSurface);
303
304 pRenderSurfaceParams->MemObjCtl = (m_renderHal->pOsInterface->pfnCachePolicyGetMemoryObject(
305 resourceType,
306 m_renderHal->pOsInterface->pfnGetGmmClientContext(m_renderHal->pOsInterface)))
307 .DwordValue;
308 pRenderSurfaceParams->Component = COMPONENT_VPCommon;
309
310 if (surfParam.needVerticalStirde)
311 {
312 switch (surf->second->SampleType)
313 {
314 case SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD:
315 case SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD:
316 pRenderSurfaceParams->bVertStride = true;
317 pRenderSurfaceParams->bVertStrideOffs = 0;
318 break;
319 case SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD:
320 case SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD:
321 pRenderSurfaceParams->bVertStride = true;
322 pRenderSurfaceParams->bVertStrideOffs = 1;
323 break;
324 default:
325 pRenderSurfaceParams->bVertStride = false;
326 pRenderSurfaceParams->bVertStrideOffs = 0;
327 break;
328 }
329 }
330
331 if (surf->second->osSurface->Format == Format_Buffer)
332 {
333 kernelSurfaceParam.surfaceOverwriteParams.updatedSurfaceParams = true;
334 kernelSurfaceParam.surfaceOverwriteParams.bufferResource = true;
335 }
336
337 return MOS_STATUS_SUCCESS;
338 }
339
340 MOS_STATUS VpRenderHDRLITEKernel::SetupSurfaceState()
341 {
342 VP_FUNC_CALL();
343
344 KERNEL_SURFACE_STATE_PARAM kernelSurfaceParam;
345 m_surfaceState.clear();
346 for (auto &handle : m_kernelArgs)
347 {
348 KRN_ARG &arg = handle.second;
349
350 if (arg.addressMode != AddressingModeBindless || arg.eArgKind != ARG_KIND_SURFACE)
351 {
352 continue;
353 }
354 uint32_t argIndex = arg.uIndex;
355 auto surfHandle = m_argIndexSurfMap.find(argIndex);
356 VP_PUBLIC_CHK_NOT_FOUND_RETURN(surfHandle, &m_argIndexSurfMap);
357 SURFACE_PARAMS &surfParam = surfHandle->second;
358 SurfaceType surfType = surfParam.surfType;
359 if (surfParam.planeIndex != 0 || surfType == SurfaceTypeSubPlane || surfType == SurfaceTypeInvalid)
360 {
361 VP_RENDER_NORMALMESSAGE("Will skip bindless surface argIndex %d for its planeIndex is set as %d, surfType %d", argIndex, surfParam.planeIndex, surfType);
362 continue;
363 }
364 if (m_surfaceState.find(surfType) != m_surfaceState.end())
365 {
366 continue;
367 }
368
369 VP_PUBLIC_CHK_STATUS_RETURN(GetKernelSurfaceParam(surfParam, kernelSurfaceParam));
370
371 m_surfaceState.insert(std::make_pair(surfType, kernelSurfaceParam));
372 }
373
374 return MOS_STATUS_SUCCESS;
375 }
376
377 MOS_STATUS VpRenderHDRLITEKernel::GetWalkerSetting(KERNEL_WALKER_PARAMS &walkerParam, KERNEL_PACKET_RENDER_DATA &renderData)
378 {
379 VP_FUNC_CALL();
380
381 for (auto &handle : m_kernelArgs)
382 {
383 KRN_ARG &arg = handle.second;
384 if (arg.eArgKind == ARG_KIND_INLINE)
385 {
386 VP_PUBLIC_CHK_STATUS_RETURN(SetInlineDataParameter(arg, m_inlineData.data()));
387 }
388 }
389
390 walkerParam = m_walkerParam;
391
392 walkerParam.iBindingTable = renderData.bindingTable;
393 walkerParam.iMediaID = renderData.mediaID;
394 walkerParam.iCurbeOffset = renderData.iCurbeOffset;
395 // Should use renderData.iCurbeLength instead of kernelSettings.CURBE_Length.
396 // kernelSettings.CURBE_Length is 32 aligned with 5 bits shift.
397 // renderData.iCurbeLength is RENDERHAL_CURBE_BLOCK_ALIGN(64) aligned.
398 walkerParam.iCurbeLength = renderData.iCurbeLength;
399
400 walkerParam.curbeResourceList = m_curbeResourceList.data();
401 walkerParam.curbeResourceListSize = m_curbeResourceList.size();
402 walkerParam.inlineResourceList = m_inlineResourceList.data();
403 walkerParam.inlineResourceListSize = m_inlineResourceList.size();
404
405 return MOS_STATUS_SUCCESS;
406 }
407
408 // Only for Adv kernels.
409 MOS_STATUS VpRenderHDRLITEKernel::SetWalkerSetting(KERNEL_THREAD_SPACE &threadSpace, bool bSyncFlag, bool flushL1)
410 {
411 VP_FUNC_CALL();
412 MOS_ZeroMemory(&m_walkerParam, sizeof(KERNEL_WALKER_PARAMS));
413
414 m_walkerParam.iBlocksX = threadSpace.uWidth;
415 m_walkerParam.iBlocksY = threadSpace.uHeight;
416 m_walkerParam.threadWidth = threadSpace.uLocalWidth;
417 m_walkerParam.threadHeight = threadSpace.uLocalHeight;
418 m_walkerParam.threadDepth = 1;
419 m_walkerParam.isVerticalPattern = false;
420 m_walkerParam.bSyncFlag = bSyncFlag;
421
422 m_walkerParam.pipeControlParams.bUpdateNeeded = true;
423 m_walkerParam.pipeControlParams.bEnableDataPortFlush = true;
424 m_walkerParam.pipeControlParams.bUnTypedDataPortCacheFlush = true;
425 m_walkerParam.pipeControlParams.bFlushRenderTargetCache = false;
426 m_walkerParam.pipeControlParams.bInvalidateTextureCache = false;
427
428 m_walkerParam.inlineDataLength = m_inlineData.size();
429 m_walkerParam.inlineData = m_inlineData.data();
430
431 m_walkerParam.slmSize = m_kernelEnv.uiSlmSize;
432 m_walkerParam.hasBarrier = (m_kernelEnv.uBarrierCount > 0);
433
434 m_walkerParam.isEmitInlineParameter = m_kernelEnv.uInlineDataPayloadSize > 0;
435
436 if (m_kernelEnv.uSimdSize != 1 && m_kernelPerThreadArgInfo.localIdSize > 0)
437 {
438 m_walkerParam.isGenerateLocalID = true;
439 m_walkerParam.emitLocal = MHW_EMIT_LOCAL_XYZ;
440 }
441
442 return MOS_STATUS_SUCCESS;
443 }
444
445 MOS_STATUS VpRenderHDRLITEKernel::SetKernelConfigs(KERNEL_CONFIGS &kernelConfigs)
446 {
447 VP_FUNC_CALL();
448
449 //Skip config
450
451 return MOS_STATUS_SUCCESS;
452 }
453
454 MOS_STATUS VpRenderHDRLITEKernel::SetPerfTag()
455 {
456 auto pOsInterface = m_hwInterface->m_osInterface;
457 VP_RENDER_CHK_NULL_RETURN(pOsInterface);
458 VP_RENDER_CHK_NULL_RETURN(pOsInterface->pfnSetPerfTag);
459
460 //skip perf tag
461
462 return MOS_STATUS_SUCCESS;
463 }