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