1 /*
2 * Copyright (c) 2020-2021, 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 decode_filmgrain_gennoise_rp2_packet_g12.cpp
24 //! \brief film grain regress phase2 kernel render packet which used in by mediapipline.
25 //! \details film grain regress phase2 kernel render packet provide the structures and generate the cmd buffer which mediapipline will used.
26 //!
27
28 #include "decode_filmgrain_gennoise_rp2_packet_g12.h"
29 #include "decode_av1_filmgrain_feature_g12.h"
30 #include "decode_av1_feature_defs_g12.h"
31 #include "mos_defs.h"
32 #include "hal_oca_interface.h"
33
34 namespace decode
35 {
36
FilmGrainRp2Packet(MediaPipeline * pipeline,MediaTask * task,CodechalHwInterface * hwInterface)37 FilmGrainRp2Packet::FilmGrainRp2Packet(MediaPipeline *pipeline, MediaTask *task, CodechalHwInterface *hwInterface):
38 CmdPacket(task),
39 RenderCmdPacket(task, hwInterface->GetOsInterface(), hwInterface->GetRenderHalInterface())
40 {
41 if (pipeline != nullptr)
42 {
43 m_statusReport = pipeline->GetStatusReportInstance();
44 m_featureManager = pipeline->GetFeatureManager();
45 m_av1Pipeline = dynamic_cast<Av1PipelineG12_Base *>(pipeline);
46 }
47 if (hwInterface != nullptr)
48 {
49 m_hwInterface = hwInterface;
50 m_miInterface = hwInterface->GetMiInterface();
51 m_osInterface = hwInterface->GetOsInterface();
52 m_vdencInterface = hwInterface->GetVdencInterface();
53 m_renderHal = hwInterface->GetRenderHalInterface();
54 }
55 }
56
Init()57 MOS_STATUS FilmGrainRp2Packet::Init()
58 {
59 DECODE_FUNC_CALL();
60 DECODE_CHK_NULL(m_miInterface);
61 DECODE_CHK_NULL(m_statusReport);
62 DECODE_CHK_NULL(m_featureManager);
63 DECODE_CHK_NULL(m_av1Pipeline);
64 DECODE_CHK_NULL(m_osInterface);
65 DECODE_CHK_NULL(m_vdencInterface);
66
67 DECODE_CHK_STATUS(RenderCmdPacket::Init());
68
69 m_av1BasicFeature = dynamic_cast<Av1BasicFeatureG12 *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
70 DECODE_CHK_NULL(m_av1BasicFeature);
71
72 m_filmGrainFeature = dynamic_cast<Av1DecodeFilmGrainG12 *>(m_featureManager->GetFeature(Av1FeatureIDs::av1SwFilmGrain));
73 DECODE_CHK_NULL(m_filmGrainFeature);
74
75 m_allocator = m_av1Pipeline->GetDecodeAllocator();
76 DECODE_CHK_NULL(m_allocator);
77
78 DECODE_CHK_STATUS(Initilize());
79
80 return MOS_STATUS_SUCCESS;
81 }
82
Prepare()83 MOS_STATUS FilmGrainRp2Packet::Prepare()
84 {
85 DECODE_FUNC_CALL();
86
87 DECODE_CHK_NULL(m_hwInterface);
88
89 m_picParams = m_av1BasicFeature->m_av1PicParams;
90
91 ResetBindingTableEntry();
92
93 DECODE_CHK_STATUS(RenderEngineSetup());
94 DECODE_CHK_STATUS(KernelStateSetup());
95 DECODE_CHK_STATUS(SetUpSurfaceState());
96 DECODE_CHK_STATUS(SetCurbeRegressPhase2());
97 DECODE_CHK_STATUS(LoadKernel());
98
99 if (m_walkerType == WALKER_TYPE_MEDIA)
100 {
101 DECODE_CHK_STATUS(SetupMediaWalker());
102 }
103 else if (m_walkerType == WALKER_TYPE_COMPUTE)
104 {
105 m_renderData.walkerParam.alignedRect.left = 0;
106 m_renderData.walkerParam.alignedRect.top = 0;
107 m_renderData.walkerParam.alignedRect.right = m_av1BasicFeature->m_filmGrainProcParams->m_outputSurface->dwWidth;
108 m_renderData.walkerParam.alignedRect.bottom = m_av1BasicFeature->m_filmGrainProcParams->m_outputSurface->dwHeight;
109 m_renderData.walkerParam.iCurbeLength = m_renderData.iCurbeLength;
110 m_renderData.walkerParam.iCurbeOffset = m_renderData.iCurbeOffset;
111 m_renderData.walkerParam.iBindingTable = m_renderData.bindingTable;
112 m_renderData.walkerParam.iMediaID = m_renderData.mediaID;
113 m_renderData.walkerParam.iBlocksX = m_renderData.KernelParam.blocks_x;
114 m_renderData.walkerParam.iBlocksY = m_renderData.KernelParam.blocks_y;
115 DECODE_CHK_STATUS(PrepareComputeWalkerParams(m_renderData.walkerParam, m_gpgpuWalkerParams));
116 }
117 else
118 {
119 DECODE_ASSERTMESSAGE("Walker is disabled!");
120 return MOS_STATUS_UNKNOWN;
121 }
122
123 return MOS_STATUS_SUCCESS;
124 }
125
Submit(MOS_COMMAND_BUFFER * commandBuffer,uint8_t packetPhase)126 MOS_STATUS FilmGrainRp2Packet::Submit(MOS_COMMAND_BUFFER *commandBuffer, uint8_t packetPhase)
127 {
128 PMOS_INTERFACE pOsInterface = nullptr;
129 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
130 uint32_t dwSyncTag = 0;
131 int32_t i = 0, iRemaining = 0;
132 PMHW_MI_INTERFACE pMhwMiInterface = nullptr;
133 MhwRenderInterface * pMhwRender = nullptr;
134 MHW_MEDIA_STATE_FLUSH_PARAM FlushParam = {};
135 bool bEnableSLM = false;
136 RENDERHAL_GENERIC_PROLOG_PARAMS GenericPrologParams = {};
137 MOS_RESOURCE GpuStatusBuffer = {};
138 MediaPerfProfiler * pPerfProfiler = nullptr;
139 MOS_CONTEXT * pOsContext = nullptr;
140 PMHW_MI_MMIOREGISTERS pMmioRegisters = nullptr;
141
142 RENDER_PACKET_CHK_NULL_RETURN(m_renderHal);
143 RENDER_PACKET_CHK_NULL_RETURN(m_renderHal->pMhwRenderInterface);
144 RENDER_PACKET_CHK_NULL_RETURN(m_renderHal->pMhwMiInterface);
145 RENDER_PACKET_CHK_NULL_RETURN(m_renderHal->pMhwRenderInterface->GetMmioRegisters());
146 RENDER_PACKET_CHK_NULL_RETURN(m_renderHal->pOsInterface);
147 RENDER_PACKET_CHK_NULL_RETURN(m_renderHal->pOsInterface->pOsContext);
148
149 eStatus = MOS_STATUS_UNKNOWN;
150 pOsInterface = m_renderHal->pOsInterface;
151 pMhwMiInterface = m_renderHal->pMhwMiInterface;
152 pMhwRender = m_renderHal->pMhwRenderInterface;
153 iRemaining = 0;
154 FlushParam = g_cRenderHal_InitMediaStateFlushParams;
155 pPerfProfiler = m_renderHal->pPerfProfiler;
156 pOsContext = pOsInterface->pOsContext;
157 pMmioRegisters = pMhwRender->GetMmioRegisters();
158
159 RENDER_PACKET_CHK_STATUS_RETURN(SetPowerMode(CODECHAl_MEDIA_STATE_AV1_FILM_GRAIN_RP2));
160
161 // Initialize command buffer and insert prolog
162 RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnInitCommandBuffer(m_renderHal, commandBuffer, &GenericPrologParams));
163
164 HalOcaInterface::On1stLevelBBStart(*commandBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle,
165 *m_hwInterface->GetMiInterface(), *m_hwInterface->GetMiInterface()->GetMmioRegisters());
166 HalOcaInterface::TraceMessage(*commandBuffer, *m_osInterface->pOsContext, __FUNCTION__, sizeof(__FUNCTION__));
167
168 if(pOsInterface && !m_av1BasicFeature->m_singleKernelPerfFlag)
169 {
170 pOsInterface->pfnSetPerfTag(pOsInterface, ((PERFTAG_CALL_FILM_GRAIN_RP2_KERNEL << 8) | CODECHAL_DECODE_MODE_AV1VLD << 4 | m_av1BasicFeature->m_pictureCodingType));
171 RENDER_PACKET_CHK_STATUS_RETURN(pPerfProfiler->AddPerfCollectStartCmd((void *)m_renderHal, pOsInterface, pMhwMiInterface, commandBuffer));
172 }
173
174 // Write timing data for 3P budget
175 RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnSendTimingData(m_renderHal, commandBuffer, true));
176
177 bEnableSLM = false; // Media walker first
178 RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnSetCacheOverrideParams(
179 m_renderHal,
180 &m_renderHal->L3CacheSettings,
181 bEnableSLM));
182
183 // Flush media states
184 RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnSendMediaStates(
185 m_renderHal,
186 commandBuffer,
187 m_walkerType == WALKER_TYPE_MEDIA ? &m_mediaWalkerParams : nullptr,
188 m_walkerType == WALKER_TYPE_MEDIA ? nullptr : &m_gpgpuWalkerParams));
189
190 // Write back GPU Status tag
191 if (!pOsInterface->bEnableKmdMediaFrameTracking)
192 {
193 RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnSendRcsStatusTag(m_renderHal, commandBuffer));
194 }
195
196 if (!m_av1BasicFeature->m_singleKernelPerfFlag)
197 {
198 RENDER_PACKET_CHK_STATUS_RETURN(pPerfProfiler->AddPerfCollectEndCmd((void *)m_renderHal, pOsInterface, pMhwMiInterface, commandBuffer));
199 }
200
201 // Write timing data for 3P budget
202 RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnSendTimingData(m_renderHal, commandBuffer, false));
203
204 MHW_PIPE_CONTROL_PARAMS PipeControlParams;
205
206 MOS_ZeroMemory(&PipeControlParams, sizeof(PipeControlParams));
207 PipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
208 PipeControlParams.bGenericMediaStateClear = false;
209 PipeControlParams.bIndirectStatePointersDisable = true;
210 PipeControlParams.bDisableCSStall = false;
211 RENDER_PACKET_CHK_STATUS_RETURN(pMhwMiInterface->AddPipeControl(commandBuffer, nullptr, &PipeControlParams));
212
213 if (MEDIA_IS_WA(m_renderHal->pWaTable, WaSendDummyVFEafterPipelineSelect))
214 {
215 MHW_VFE_PARAMS VfeStateParams = {};
216 VfeStateParams.dwNumberofURBEntries = 1;
217 RENDER_PACKET_CHK_STATUS_RETURN(pMhwRender->AddMediaVfeCmd(commandBuffer, &VfeStateParams));
218 }
219
220 // Add media flush command in case HW not cleaning the media state
221 if (MEDIA_IS_WA(m_renderHal->pWaTable, WaMSFWithNoWatermarkTSGHang))
222 {
223 FlushParam.bFlushToGo = true;
224 if (m_walkerType == WALKER_TYPE_MEDIA)
225 {
226 FlushParam.ui8InterfaceDescriptorOffset = m_mediaWalkerParams.InterfaceDescriptorOffset;
227 }
228 else
229 {
230 RENDER_PACKET_ASSERTMESSAGE("ERROR, pWalkerParams is nullptr and cannot get InterfaceDescriptorOffset.");
231 }
232 RENDER_PACKET_CHK_STATUS_RETURN(pMhwMiInterface->AddMediaStateFlush(commandBuffer, nullptr, &FlushParam));
233 }
234 else if (MEDIA_IS_WA(m_renderHal->pWaTable, WaAddMediaStateFlushCmd))
235 {
236 RENDER_PACKET_CHK_STATUS_RETURN(pMhwMiInterface->AddMediaStateFlush(commandBuffer, nullptr, &FlushParam));
237 }
238
239 HalOcaInterface::On1stLevelBBEnd(*commandBuffer, *m_osInterface);
240
241 if (pBatchBuffer)
242 {
243 // Send Batch Buffer end command (HW/OS dependent)
244 RENDER_PACKET_CHK_STATUS_RETURN(pMhwMiInterface->AddMiBatchBufferEnd(commandBuffer, nullptr));
245 }
246 else if (IsMiBBEndNeeded(pOsInterface))
247 {
248 // Send Batch Buffer end command for 1st level Batch Buffer
249 RENDER_PACKET_CHK_STATUS_RETURN(pMhwMiInterface->AddMiBatchBufferEnd(commandBuffer, nullptr));
250 }
251 else if (m_renderHal->pOsInterface->bNoParsingAssistanceInKmd)
252 {
253 RENDER_PACKET_CHK_STATUS_RETURN(pMhwMiInterface->AddMiBatchBufferEnd(commandBuffer, nullptr));
254 }
255
256 // Return unused command buffer space to OS
257 pOsInterface->pfnReturnCommandBuffer(pOsInterface, commandBuffer, 0);
258
259 MOS_NULL_RENDERING_FLAGS NullRenderingFlags = pOsInterface->pfnGetNullHWRenderFlags(pOsInterface);
260
261 if ((NullRenderingFlags.VPLgca ||
262 NullRenderingFlags.VPGobal) == false)
263 {
264 dwSyncTag = m_renderHal->pStateHeap->dwNextTag++;
265
266 // Set media state and batch buffer as busy
267 m_renderHal->pStateHeap->pCurMediaState->bBusy = true;
268 if (pBatchBuffer)
269 {
270 pBatchBuffer->bBusy = true;
271 pBatchBuffer->dwSyncTag = dwSyncTag;
272 }
273 }
274
275 return MOS_STATUS_SUCCESS;
276 }
277
SetupMediaWalker()278 MOS_STATUS FilmGrainRp2Packet::SetupMediaWalker()
279 {
280 DECODE_FUNC_CALL();
281
282 DECODE_CHK_NULL(m_hwInterface);
283
284 // Current only add Media Walker Support in film Grain
285 m_walkerType = WALKER_TYPE_MEDIA;
286
287 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
288 memset(&walkerCodecParams, 0, sizeof(walkerCodecParams));
289 walkerCodecParams.WalkerMode = MHW_WALKER_MODE_DUAL;
290 walkerCodecParams.dwResolutionX = 1;
291 walkerCodecParams.dwResolutionY = 1;
292 walkerCodecParams.bNoDependency = true; // raster scan mode
293
294 DECODE_CHK_STATUS(CodecHalInitMediaObjectWalkerParams(m_hwInterface, &m_mediaWalkerParams, &walkerCodecParams));
295
296 return MOS_STATUS_SUCCESS;
297 }
298
Initilize()299 MOS_STATUS FilmGrainRp2Packet::Initilize()
300 {
301 m_kernelIndex = regressPhase2;
302
303 return MOS_STATUS_SUCCESS;
304 }
305
KernelStateSetup()306 MOS_STATUS FilmGrainRp2Packet::KernelStateSetup()
307 {
308 m_kernelCount = 1;
309 MHW_KERNEL_STATE *kernelState = &m_filmGrainFeature->m_kernelStates[m_kernelIndex];
310 uint32_t btCount = m_filmGrainFeature->m_filmGrainBindingTableCount[m_kernelIndex];
311 int32_t curbeLength = m_filmGrainFeature->m_filmGrainCurbeSize[m_kernelIndex];
312
313 // Initialize States
314 MOS_ZeroMemory(m_filter, sizeof(m_filter));
315 MOS_ZeroMemory(&m_renderData.KernelEntry, sizeof(Kdll_CacheEntry));
316
317 // Set Kernel Parameter
318 m_renderData.KernelParam.GRF_Count = 0;
319 m_renderData.KernelParam.BT_Count = btCount;
320 m_renderData.KernelParam.Sampler_Count = 0;
321 m_renderData.KernelParam.Thread_Count = m_renderHal->pMhwRenderInterface->GetHwCaps()->dwMaxThreads;
322 m_renderData.KernelParam.GRF_Start_Register = 0;
323 m_renderData.KernelParam.CURBE_Length = curbeLength;
324 m_renderData.KernelParam.block_width = CODECHAL_MACROBLOCK_WIDTH;
325 m_renderData.KernelParam.block_height = CODECHAL_MACROBLOCK_HEIGHT;
326 m_renderData.KernelParam.blocks_x = 1;
327 m_renderData.KernelParam.blocks_y = 1;
328
329 m_renderData.iCurbeOffset = m_renderHal->pMhwStateHeap->GetSizeofCmdInterfaceDescriptorData();
330
331 // Set Parameters for Kernel Entry
332 m_renderData.KernelEntry.iKUID = 0;
333 m_renderData.KernelEntry.iKCID = m_kernelIndex;
334 m_renderData.KernelEntry.iFilterSize = 2;
335 m_renderData.KernelEntry.pFilter = m_filter;
336 m_renderData.KernelEntry.iSize = kernelState->KernelParams.iSize;
337 m_renderData.KernelEntry.pBinary = kernelState->KernelParams.pBinary;
338
339 // set Curbe/Inline Data length
340 m_renderData.iInlineLength = 0;
341 m_renderData.iCurbeLength = 0;
342
343 return MOS_STATUS_SUCCESS;
344 }
345
SetUpSurfaceState()346 MOS_STATUS FilmGrainRp2Packet::SetUpSurfaceState()
347 {
348 DECODE_FUNC_CALL();
349
350 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
351
352 //Set Surface States
353 RENDERHAL_SURFACE_NEXT renderHalSurfaceNext;
354 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
355
356 //Y random values - input
357 bool isWritable = false;
358 RENDERHAL_SURFACE_STATE_PARAMS surfaceParams;
359 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
360 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
361 surfaceParams.bRenderTarget = true;
362 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
363
364 m_bindingTableIndex[rp2InputYRandomValue] = SetSurfaceForHwAccess(
365 m_filmGrainFeature->m_yRandomValuesSurface,
366 &renderHalSurfaceNext,
367 &surfaceParams,
368 isWritable);
369 DECODE_VERBOSEMESSAGE("RP2: surface[%d] Input Y Random values index: %d\n", rp2InputYRandomValue, m_bindingTableIndex[rp2InputYRandomValue]);
370
371 //U random values - input
372 isWritable = false;
373 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
374 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
375 surfaceParams.bRenderTarget = true;
376 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
377 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
378 m_bindingTableIndex[rp2InputURandomValue] = SetSurfaceForHwAccess(
379 m_filmGrainFeature->m_uRandomValuesSurface,
380 &renderHalSurfaceNext,
381 &surfaceParams,
382 isWritable);
383 DECODE_VERBOSEMESSAGE("RP2: surface[%d] Input U Random values BT index: %d\n", rp2InputURandomValue, m_bindingTableIndex[rp2InputURandomValue]);
384
385 //V random values - input
386 isWritable = false;
387 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
388 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
389 surfaceParams.bRenderTarget = true;
390 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
391 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
392 m_bindingTableIndex[rp2InputVRandomValue] = SetSurfaceForHwAccess(
393 m_filmGrainFeature->m_vRandomValuesSurface,
394 &renderHalSurfaceNext,
395 &surfaceParams,
396 isWritable);
397 DECODE_VERBOSEMESSAGE("RP2: surface[%d] Input V Random values BT index: %d\n", rp2InputVRandomValue, m_bindingTableIndex[rp2InputVRandomValue]);
398
399 //Y dithering surface - input
400 isWritable = true;
401 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
402 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
403 surfaceParams.bRenderTarget = true;
404 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
405 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
406 m_bindingTableIndex[rp2InputYDithering] = SetSurfaceForHwAccess(
407 m_filmGrainFeature->m_yDitheringTempSurface,
408 &renderHalSurfaceNext,
409 &surfaceParams,
410 isWritable);
411 DECODE_VERBOSEMESSAGE("RP2: surface[%d] Input Y dithering surface BT index: %d\n", rp2InputYDithering, m_bindingTableIndex[rp2InputYDithering]);
412
413 //Y dithering surface - output
414 isWritable = true;
415 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
416 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
417 surfaceParams.bRenderTarget = true;
418 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
419 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
420 m_bindingTableIndex[rp2OutputYDithering] = SetSurfaceForHwAccess(
421 m_filmGrainFeature->m_yDitheringSurface,
422 &renderHalSurfaceNext,
423 &surfaceParams,
424 isWritable);
425 DECODE_VERBOSEMESSAGE("RP2: surface[%d] Output Y dithering surface BT index: %d\n", rp2OutputYDithering, m_bindingTableIndex[rp2OutputYDithering]);
426
427 //U dithering surface - output
428 isWritable = true;
429 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
430 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
431 surfaceParams.bRenderTarget = true;
432 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
433 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
434 m_bindingTableIndex[rp2OutputUDithering] = SetSurfaceForHwAccess(
435 m_filmGrainFeature->m_uDitheringSurface,
436 &renderHalSurfaceNext,
437 &surfaceParams,
438 isWritable);
439 DECODE_VERBOSEMESSAGE("RP2: surface[%d] Output U dithering surface BT index: %d\n", rp2OutputUDithering, m_bindingTableIndex[rp2OutputUDithering]);
440
441 //V dithering surface - output
442 isWritable = true;
443 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
444 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
445 surfaceParams.bRenderTarget = true;
446 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
447 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
448 m_bindingTableIndex[rp2OutputVDithering] = SetSurfaceForHwAccess(
449 m_filmGrainFeature->m_vDitheringSurface,
450 &renderHalSurfaceNext,
451 &surfaceParams,
452 isWritable);
453 DECODE_VERBOSEMESSAGE("RP2: surface[%d] Output V dithering surface BT index: %d\n", rp2OutputVDithering, m_bindingTableIndex[rp2OutputVDithering]);
454
455 //Y coefficients - input
456 isWritable = false;
457 m_filmGrainFeature->m_yCoeffSurface->size = 32 * sizeof(short);
458 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
459 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
460 surfaceParams.bRenderTarget = false;
461 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
462 surfaceParams.bBufferUse = true;
463 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
464 m_bindingTableIndex[rp2InputYCoeff] = SetBufferForHwAccess(
465 *m_filmGrainFeature->m_yCoeffSurface,
466 &renderHalSurfaceNext,
467 &surfaceParams,
468 isWritable);
469 DECODE_VERBOSEMESSAGE("RP2: surface[%d] Y coeff input surface BT index: %d\n", rp2InputYCoeff, m_bindingTableIndex[rp2InputYCoeff]);
470
471 //U coefficients - input
472 isWritable = false;
473 m_filmGrainFeature->m_uCoeffSurface->size = 32 * sizeof(short);
474 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
475 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
476 surfaceParams.bRenderTarget = false;
477 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
478 surfaceParams.bBufferUse = true;
479 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
480 m_bindingTableIndex[rp2InputUCoeff] = SetBufferForHwAccess(
481 *m_filmGrainFeature->m_uCoeffSurface,
482 &renderHalSurfaceNext,
483 &surfaceParams,
484 isWritable);
485 DECODE_VERBOSEMESSAGE("RP2: surface[%d] U coeff input surface BT index: %d\n", rp2InputUCoeff, m_bindingTableIndex[rp2InputUCoeff]);
486
487 //V coefficients - input
488 isWritable = false;
489 m_filmGrainFeature->m_vCoeffSurface->size = 32 * sizeof(short);
490 MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
491 surfaceParams.MemObjCtl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3].Value;
492 surfaceParams.bRenderTarget = false;
493 surfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
494 surfaceParams.bBufferUse = true;
495 MOS_ZeroMemory(&renderHalSurfaceNext, sizeof(RENDERHAL_SURFACE_NEXT));
496 m_bindingTableIndex[rp2InputVCoeff] = SetBufferForHwAccess(
497 *m_filmGrainFeature->m_vCoeffSurface,
498 &renderHalSurfaceNext,
499 &surfaceParams,
500 isWritable);
501 DECODE_VERBOSEMESSAGE("RP2: surface[%d] U coeff input surface BT index: %d\n", rp2InputVCoeff, m_bindingTableIndex[rp2InputVCoeff]);
502
503 return MOS_STATUS_SUCCESS;
504 }
505
SetCurbeRegressPhase2()506 MOS_STATUS FilmGrainRp2Packet::SetCurbeRegressPhase2()
507 {
508 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
509
510 DECODE_FUNC_CALL();
511
512 CodecAv1FilmGrainParams *filmGrainParams = (CodecAv1FilmGrainParams *)&m_picParams->m_filmGrainParams;
513
514 FilmGrainRegressPhase2Curbe curbe;
515 curbe.DW0.YRandomValuesSurfaceIndex = rp2InputYRandomValue;
516 curbe.DW1.URandomValuesSurfaceIndex = rp2InputURandomValue;
517 curbe.DW2.VRandomValuesSurfaceIndex = rp2InputVRandomValue;
518 curbe.DW3.YDitheringInputSurfaceIndex = rp2InputYDithering;
519 curbe.DW4.YDitheringSurfaceIndex = rp2OutputYDithering;
520 curbe.DW5.UDitheringSurfaceIndex = rp2OutputUDithering;
521 curbe.DW6.VDitheringSurfaceIndex = rp2OutputVDithering;
522 curbe.DW7.YCoeffSurfaceIndex = rp2InputYCoeff;
523 curbe.DW8.UCoeffSurfaceIndex = rp2InputUCoeff;
524 curbe.DW9.VCoeffSurfaceIndex = rp2InputVCoeff;
525 curbe.DW10.RegressionCoefficientShift = m_picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_arCoeffShiftMinus6 + 6;
526
527 DECODE_CHK_STATUS(SetupCurbe(
528 &curbe,
529 sizeof(FilmGrainRegressPhase2Curbe),
530 m_renderData.KernelParam.Thread_Count));
531
532 return eStatus;
533 }
534
535
CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)536 MOS_STATUS FilmGrainRp2Packet::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize)
537 {
538 DECODE_FUNC_CALL();
539
540 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
541
542 commandBufferSize = m_hwInterface->GetKernelLoadCommandSize(m_renderData.KernelParam.BT_Count);
543 requestedPatchListSize = 0;
544
545 return MOS_STATUS_SUCCESS;
546 }
547
548 }
549