1 /*
2 * Copyright (c) 2022, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file vp_render_vebox_hvs_kernel.cpp
24 //! \brief render packet which used in by mediapipline.
25 //! \details render packet provide the structures and generate the cmd buffer which mediapipline will used.
26 //!
27 #include "vp_render_vebox_hvs_kernel.h"
28 #include "vp_dumper.h"
29 #include "vp_kernelset.h"
30
31 using namespace vp;
32
33 #define VP_HVS_KERNEL_NAME "UpdateDNDITable"
34
VpRenderHVSKernel(PVP_MHWINTERFACE hwInterface,VpKernelID kernelID,uint32_t kernelIndex,PVpAllocator allocator)35 VpRenderHVSKernel::VpRenderHVSKernel(PVP_MHWINTERFACE hwInterface, VpKernelID kernelID, uint32_t kernelIndex, PVpAllocator allocator) :
36 VpRenderKernelObj(hwInterface, kernelID, kernelIndex, VP_HVS_KERNEL_NAME, allocator)
37 {
38 m_kernelBinaryID = VP_ADV_KERNEL_BINARY_ID(kernelID);
39 m_isAdvKernel = true;
40 }
41
~VpRenderHVSKernel()42 VpRenderHVSKernel::~VpRenderHVSKernel()
43 {
44 // No need to destroy dstArg.pData, which points to the local variable
45 // in VpDnFilter.
46 }
47
Init(VpRenderKernel & kernel)48 MOS_STATUS VpRenderHVSKernel::Init(VpRenderKernel &kernel)
49 {
50 VP_FUNC_CALL();
51 m_kernelSize = kernel.GetKernelSize() + KERNEL_BINARY_PADDING_SIZE;
52
53 uint8_t *pKernelBin = (uint8_t *)kernel.GetKernelBinPointer();
54 VP_RENDER_CHK_NULL_RETURN(pKernelBin);
55
56 m_kernelBinary = pKernelBin + kernel.GetKernelBinOffset();
57
58 m_kernelArgs = kernel.GetKernelArgs();
59
60 return MOS_STATUS_SUCCESS;
61 }
62
GetWalkerSetting(KERNEL_WALKER_PARAMS & walkerParam,KERNEL_PACKET_RENDER_DATA & renderData)63 MOS_STATUS VpRenderHVSKernel::GetWalkerSetting(KERNEL_WALKER_PARAMS &walkerParam, KERNEL_PACKET_RENDER_DATA &renderData)
64 {
65 VP_FUNC_CALL();
66
67 VP_RENDER_CHK_STATUS_RETURN(VpRenderKernelObj::GetWalkerSetting(m_walkerParam, renderData));
68
69 walkerParam = m_walkerParam;
70 return MOS_STATUS_SUCCESS;
71 }
72
73 // Only for Adv kernels.
SetWalkerSetting(KERNEL_THREAD_SPACE & threadSpace,bool bSyncFlag,bool flushL1)74 MOS_STATUS VpRenderHVSKernel::SetWalkerSetting(KERNEL_THREAD_SPACE &threadSpace, bool bSyncFlag, bool flushL1)
75 {
76 VP_FUNC_CALL();
77 MOS_ZeroMemory(&m_walkerParam, sizeof(KERNEL_WALKER_PARAMS));
78
79 m_walkerParam.iBlocksX = threadSpace.uWidth;
80 m_walkerParam.iBlocksY = threadSpace.uHeight;
81 m_walkerParam.isVerticalPattern = false;
82 m_walkerParam.bSyncFlag = bSyncFlag;
83
84 return MOS_STATUS_SUCCESS;
85 }
86
SetKernelArgs(KERNEL_ARGS & kernelArgs,VP_PACKET_SHARED_CONTEXT * sharedContext)87 MOS_STATUS VpRenderHVSKernel::SetKernelArgs(KERNEL_ARGS &kernelArgs, VP_PACKET_SHARED_CONTEXT *sharedContext)
88 {
89 VP_FUNC_CALL();
90 auto &hvsParams = sharedContext->hvsParams;
91 KRN_ARG krnArg = {};
92
93 krnArg.uIndex = 1;
94 krnArg.eArgKind = ARG_KIND_GENERAL;
95 krnArg.uSize = 2;
96 krnArg.pData = &hvsParams.Mode;
97 kernelArgs.push_back(krnArg);
98
99 krnArg.uIndex = 2;
100 krnArg.eArgKind = ARG_KIND_GENERAL;
101 krnArg.uSize = 2;
102 krnArg.pData = &hvsParams.Format;
103 kernelArgs.push_back(krnArg);
104
105 krnArg.uIndex = 3;
106 krnArg.eArgKind = ARG_KIND_GENERAL;
107 krnArg.uSize = 2;
108 krnArg.pData = &hvsParams.Width;
109 kernelArgs.push_back(krnArg);
110
111 krnArg.uIndex = 4;
112 krnArg.eArgKind = ARG_KIND_GENERAL;
113 krnArg.uSize = 2;
114 krnArg.pData = &hvsParams.Height;
115 kernelArgs.push_back(krnArg);
116
117 krnArg.uIndex = 5;
118 krnArg.eArgKind = ARG_KIND_GENERAL;
119 krnArg.uSize = 4;
120 krnArg.pData = &hvsParams.dwGlobalNoiseLevel;
121 kernelArgs.push_back(krnArg);
122
123 krnArg.uIndex = 6;
124 krnArg.eArgKind = ARG_KIND_GENERAL;
125 krnArg.uSize = 4;
126 krnArg.pData = &hvsParams.dwGlobalNoiseLevelU;
127 kernelArgs.push_back(krnArg);
128
129 krnArg.uIndex = 7;
130 krnArg.eArgKind = ARG_KIND_GENERAL;
131 krnArg.uSize = 4;
132 krnArg.pData = &hvsParams.dwGlobalNoiseLevelV;
133 kernelArgs.push_back(krnArg);
134
135 krnArg.uIndex = 8;
136 krnArg.eArgKind = ARG_KIND_GENERAL;
137 krnArg.uSize = 4;
138 krnArg.pData = &hvsParams.Sgne_Level;
139 kernelArgs.push_back(krnArg);
140
141 krnArg.uIndex = 9;
142 krnArg.eArgKind = ARG_KIND_GENERAL;
143 krnArg.uSize = 4;
144 krnArg.pData = &hvsParams.Sgne_LevelU;
145 kernelArgs.push_back(krnArg);
146
147 krnArg.uIndex = 10;
148 krnArg.eArgKind = ARG_KIND_GENERAL;
149 krnArg.uSize = 4;
150 krnArg.pData = &hvsParams.Sgne_LevelV;
151 kernelArgs.push_back(krnArg);
152
153 krnArg.uIndex = 11;
154 krnArg.eArgKind = ARG_KIND_GENERAL;
155 krnArg.uSize = 4;
156 krnArg.pData = &hvsParams.Sgne_Count;
157 kernelArgs.push_back(krnArg);
158
159 krnArg.uIndex = 12;
160 krnArg.eArgKind = ARG_KIND_GENERAL;
161 krnArg.uSize = 4;
162 krnArg.pData = &hvsParams.Sgne_Count;
163 kernelArgs.push_back(krnArg);
164
165 krnArg.uIndex = 13;
166 krnArg.eArgKind = ARG_KIND_GENERAL;
167 krnArg.uSize = 4;
168 krnArg.pData = &hvsParams.Sgne_CountV;
169 kernelArgs.push_back(krnArg);
170
171 krnArg.uIndex = 14;
172 krnArg.eArgKind = ARG_KIND_GENERAL;
173 krnArg.uSize = 4;
174 krnArg.pData = &hvsParams.PrevNslvTemporal;
175 kernelArgs.push_back(krnArg);
176
177 krnArg.uIndex = 15;
178 krnArg.eArgKind = ARG_KIND_GENERAL;
179 krnArg.uSize = 4;
180 krnArg.pData = &hvsParams.PrevNslvTemporalU;
181 kernelArgs.push_back(krnArg);
182
183 krnArg.uIndex = 16;
184 krnArg.eArgKind = ARG_KIND_GENERAL;
185 krnArg.uSize = 4;
186 krnArg.pData = &hvsParams.PrevNslvTemporalV;
187 kernelArgs.push_back(krnArg);
188
189 krnArg.uIndex = 17;
190 krnArg.eArgKind = ARG_KIND_GENERAL;
191 krnArg.uSize = 2;
192 krnArg.pData = &hvsParams.QP;
193 kernelArgs.push_back(krnArg);
194
195 krnArg.uIndex = 18;
196 krnArg.eArgKind = ARG_KIND_GENERAL;
197 krnArg.uSize = 2;
198 krnArg.pData = &hvsParams.FirstFrame;
199 kernelArgs.push_back(krnArg);
200
201 krnArg.uIndex = 19;
202 krnArg.eArgKind = ARG_KIND_GENERAL;
203 krnArg.uSize = 2;
204 krnArg.pData = &hvsParams.TgneFirstFrame;
205 kernelArgs.push_back(krnArg);
206
207 krnArg.uIndex = 20;
208 krnArg.eArgKind = ARG_KIND_GENERAL;
209 krnArg.uSize = 2;
210 krnArg.pData = &hvsParams.Fallback;
211 kernelArgs.push_back(krnArg);
212
213 krnArg.uIndex = 21;
214 krnArg.eArgKind = ARG_KIND_GENERAL;
215 krnArg.uSize = 2;
216 krnArg.pData = &hvsParams.EnableChroma;
217 kernelArgs.push_back(krnArg);
218
219 krnArg.uIndex = 22;
220 krnArg.eArgKind = ARG_KIND_GENERAL;
221 krnArg.uSize = 2;
222 krnArg.pData = &hvsParams.EnableTemporalGNE;
223 kernelArgs.push_back(krnArg);
224
225 if (kernelArgs.size() != m_kernelArgs.size())
226 {
227 VP_RENDER_ASSERTMESSAGE("The Kernel Arguments is not aligned!");
228 return MOS_STATUS_INVALID_PARAMETER;
229 }
230
231 for (uint32_t i = 0; i < m_kernelArgs.size(); ++i)
232 {
233 if (i >= kernelArgs.size())
234 {
235 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
236 }
237 KRN_ARG &srcArg = kernelArgs[i];
238 KRN_ARG &dstArg = m_kernelArgs[i];
239
240 if (srcArg.uIndex != dstArg.uIndex ||
241 srcArg.uSize != dstArg.uSize ||
242 srcArg.eArgKind != dstArg.eArgKind &&
243 dstArg.eArgKind != (srcArg.eArgKind & ~SURFACE_MASK) ||
244 srcArg.pData == nullptr)
245 {
246 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
247 }
248 dstArg.eArgKind = srcArg.eArgKind;
249 dstArg.pData = srcArg.pData;
250 srcArg.pData = nullptr;
251 }
252
253 return MOS_STATUS_SUCCESS;
254 }
255
GetCurbeState(void * & curbe,uint32_t & curbeLength)256 MOS_STATUS VpRenderHVSKernel::GetCurbeState(void *&curbe, uint32_t &curbeLength)
257 {
258 VP_FUNC_CALL();
259 curbeLength = 0;
260 for (auto arg : m_kernelArgs)
261 {
262 curbeLength += arg.uSize;
263 }
264
265 if (sizeof(m_curbe) != curbeLength)
266 {
267 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
268 }
269
270 uint8_t *data = (uint8_t *)&m_curbe;
271
272 for (auto &arg : m_kernelArgs)
273 {
274 if (arg.eArgKind == ARG_KIND_SURFACE)
275 {
276 // Resource need be added.
277 uint32_t *pSurfaceindex = static_cast<uint32_t *>(arg.pData);
278 auto bindingMap = GetSurfaceBindingIndex((SurfaceType)*pSurfaceindex);
279 if (bindingMap.empty())
280 {
281 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
282 }
283 *((uint32_t *)(data + arg.uOffsetInPayload)) = *bindingMap.begin();
284 }
285 else if (arg.eArgKind == ARG_KIND_GENERAL)
286 {
287 MOS_SecureMemcpy(data + arg.uOffsetInPayload, arg.uSize, arg.pData, arg.uSize);
288 }
289 else
290 {
291 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_UNIMPLEMENTED);
292 }
293 }
294
295 curbe = data;
296 VP_RENDER_NORMALMESSAGE("HVS Kernel curbelength %d", curbeLength);
297 return MOS_STATUS_SUCCESS;
298 }
299
SetupSurfaceState()300 MOS_STATUS VpRenderHVSKernel::SetupSurfaceState()
301 {
302 VP_FUNC_CALL();
303 VP_RENDER_CHK_NULL_RETURN(m_surfaceGroup);
304 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
305
306 PRENDERHAL_INTERFACE renderHal = m_hwInterface->m_renderHal;
307 PMOS_INTERFACE osInterface = m_hwInterface->m_osInterface;
308 m_surfaceBindingIndex.clear();
309 m_surfaceState.clear();
310 for (auto arg : m_kernelArgs)
311 {
312 VP_RENDER_CHK_NULL_RETURN(arg.pData);
313
314 if (arg.eArgKind == ARG_KIND_SURFACE)
315 {
316 SurfaceType surfType = *(SurfaceType *)arg.pData;
317
318 auto it = m_surfaceGroup->find(surfType);
319 if (m_surfaceGroup->end() == it)
320 {
321 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
322 }
323
324 auto surf = it->second;
325 VP_RENDER_CHK_NULL_RETURN(surf);
326 VP_RENDER_CHK_NULL_RETURN(surf->osSurface);
327
328 uint32_t width = surf->bufferWidth;
329 uint32_t height = surf->bufferHeight;
330
331 KERNEL_SURFACE_STATE_PARAM kernelSurfaceParam = {};
332 kernelSurfaceParam.surfaceOverwriteParams.updatedSurfaceParams = true;
333 kernelSurfaceParam.surfaceOverwriteParams.width = surf->bufferWidth;
334 kernelSurfaceParam.surfaceOverwriteParams.height = 256;
335 kernelSurfaceParam.surfaceOverwriteParams.pitch = 0;
336 kernelSurfaceParam.surfaceOverwriteParams.format = Format_A8R8G8B8;
337 kernelSurfaceParam.surfaceOverwriteParams.tileType = surf->osSurface->TileType;
338 kernelSurfaceParam.surfaceOverwriteParams.surface_offset = 0;
339
340 //kernelSurfaceParam.surfaceOverwriteParams.updatedRenderSurfaces = true;
341 //kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams.Type = renderHal->SurfaceTypeDefault;
342 //kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams.isOutput = true; // true if no need sync for read.
343 //kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams.bWidthInDword_Y = true;
344 //kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams.bWidthInDword_UV = true;
345 //kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
346 //kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams.bWidth16Align = false;
347 ////set mem object control for cache
348 //kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = (osInterface->pfnCachePolicyGetMemoryObject(
349 // MOS_MP_RESOURCE_USAGE_DEFAULT,
350 // osInterface->pfnGetGmmClientContext(osInterface))).DwordValue;
351
352 m_surfaceState.insert(std::make_pair(*(SurfaceType *)arg.pData, kernelSurfaceParam));
353 }
354 }
355
356 return MOS_STATUS_SUCCESS;
357 }
358
SetKernelConfigs(KERNEL_CONFIGS & kernelConfigs)359 MOS_STATUS VpRenderHVSKernel::SetKernelConfigs(KERNEL_CONFIGS& kernelConfigs)
360 {
361 VP_FUNC_CALL();
362 auto it = kernelConfigs.find((VpKernelID)kernelHVSCalc);
363
364 if (kernelConfigs.end() == it || nullptr == it->second)
365 {
366 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
367 }
368
369 PRENDER_DN_HVS_CAL_PARAMS params = (PRENDER_DN_HVS_CAL_PARAMS)it->second;
370
371 return MOS_STATUS_SUCCESS;
372 }
373