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