1 /*
2 * Copyright (c) 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 vphal_render_vebox_xe_hpm.cpp
24 //! \brief Interface and structure specific for Xe_HPM Vebox
25 //! \details Interface and structure specific for Xe_HPM Vebox
26 //!
27 #include "vphal.h"
28 #include "vphal_render_vebox_base.h"
29 #include "vphal_render_vebox_xe_hpm.h"
30 #include "mhw_vebox_xe_hpm.h"
31 #include "mos_interface.h"
32 #include "vphal_debug.h"
33 #include "vp_hal_ddi_utils.h"
34 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
35 #include "igvpkrn_isa_xe_hpg.h"
36 #endif
37
VPHAL_VEBOX_STATE_XE_HPM(PMOS_INTERFACE pOsInterface,PMHW_VEBOX_INTERFACE pVeboxInterface,PMHW_SFC_INTERFACE pSfcInterface,PRENDERHAL_INTERFACE pRenderHal,PVPHAL_VEBOX_EXEC_STATE pVeboxExecState,PVPHAL_RNDR_PERF_DATA pPerfData,const VPHAL_DNDI_CACHE_CNTL & dndiCacheCntl,MOS_STATUS * peStatus)38 VPHAL_VEBOX_STATE_XE_HPM::VPHAL_VEBOX_STATE_XE_HPM(
39 PMOS_INTERFACE pOsInterface,
40 PMHW_VEBOX_INTERFACE pVeboxInterface,
41 PMHW_SFC_INTERFACE pSfcInterface,
42 PRENDERHAL_INTERFACE pRenderHal,
43 PVPHAL_VEBOX_EXEC_STATE pVeboxExecState,
44 PVPHAL_RNDR_PERF_DATA pPerfData,
45 const VPHAL_DNDI_CACHE_CNTL &dndiCacheCntl,
46 MOS_STATUS *peStatus) :
47 VPHAL_VEBOX_STATE(pOsInterface, pVeboxInterface, pSfcInterface, pRenderHal, pVeboxExecState, pPerfData, dndiCacheCntl, peStatus),
48 VPHAL_VEBOX_STATE_G12_BASE(pOsInterface, pVeboxInterface, pSfcInterface, pRenderHal, pVeboxExecState, pPerfData, dndiCacheCntl, peStatus),
49 VPHAL_VEBOX_STATE_XE_XPM(pOsInterface, pVeboxInterface, pSfcInterface, pRenderHal, pVeboxExecState, pPerfData, dndiCacheCntl, peStatus)
50 {
51 uint32_t i;
52 uint32_t veboxMaxPipeNum = 0;
53 MEDIA_SYSTEM_INFO *gtSystemInfo = nullptr;
54
55 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
56 m_hdr3DLutKernelBinary = (uint32_t *)IGVP3DLUT_GENERATION_XE_HPG;
57 m_hdr3DLutKernelBinarySize = IGVP3DLUT_GENERATION_XE_HPG_SIZE;
58 #endif
59
60 // Vebox Scalability
61 bVeboxScalableMode = false; //!< Vebox Scalable Mode
62 if(!pOsInterface)
63 {
64 *peStatus = MOS_STATUS_NULL_POINTER;
65 return;
66 }
67
68 gtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
69 if (gtSystemInfo)
70 {
71 veboxMaxPipeNum = gtSystemInfo->MaxVECS;
72 }
73
74 for (i = 0; i < veboxMaxPipeNum; i++)
75 {
76 PMOS_COMMAND_BUFFER pCmdBuffer = (PMOS_COMMAND_BUFFER)MOS_AllocAndZeroMemory(sizeof(MOS_COMMAND_BUFFER));
77 if (pCmdBuffer == nullptr)
78 {
79 *peStatus = MOS_STATUS_NO_SPACE;
80 return;
81 }
82 m_veCmdBuffers.emplace_back(pCmdBuffer);
83 }
84
85 dwVECmdBufSize = 0; //!< Command Buffer Size
86 for (i = 0; i < MHW_VEBOX_MAX_SEMAPHORE_NUM_G12; i++)
87 {
88 VESemaMemS[i] = {};
89 }
90 dwNumofVebox = 0;
91
92 #if LINUX
93 char* ScalingHQPerfMode = getenv("SET_SCALINGHQ_AS_PERFMODE");
94 if (ScalingHQPerfMode)
95 {
96 bScalingHQPefMode = strcmp(ScalingHQPerfMode, "ON")?false:true;
97 }
98 #endif
99 }
100
~VPHAL_VEBOX_STATE_XE_HPM()101 VPHAL_VEBOX_STATE_XE_HPM::~VPHAL_VEBOX_STATE_XE_HPM()
102 {
103 for (auto &icmdBuffer : m_veCmdBuffers)
104 {
105 if (icmdBuffer)
106 {
107 MOS_FreeMemory(icmdBuffer);
108 }
109 icmdBuffer = nullptr;
110 }
111 m_veCmdBuffers.clear();
112 return;
113 }
114
115 //!
116 //! \brief Vebox allocate resources
117 //! \details Allocate resources that will be used in Vebox
118 //! \return MOS_STATUS
119 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
120 //!
AllocateResources()121 MOS_STATUS VPHAL_VEBOX_STATE_XE_HPM::AllocateResources()
122 {
123 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
124 PVPHAL_VEBOX_STATE_XE_HPM pVeboxState = this;
125 PVPHAL_VEBOX_RENDER_DATA pRenderData;
126
127 VPHAL_RENDER_CHK_NULL(pVeboxState);
128 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
129 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pVeboxInterface);
130
131 pRenderData = GetLastExecRenderData();
132
133 VPHAL_RENDER_CHK_STATUS(VPHAL_VEBOX_STATE_XE_XPM::AllocateResources());
134
135 finish:
136 if (eStatus != MOS_STATUS_SUCCESS)
137 {
138 pVeboxState->FreeResources();
139 }
140
141 return eStatus;
142 }
143
144 //!
145 //! \brief Vebox state heap update for Auto-DN/ACE
146 //! \details update Vebox states (DN, ACE),
147 //! in normal case, use CPU to update the Vebox state heap in clear memory (DriverResource).
148 //! Otherwise use kernel to update the Vebox state heap in non-clear memory (KernelResource)
149 //! \param PVPHAL_SURFACE pSrcSurface
150 //! [in] Pointer to input surface of Vebox
151 //! \return MOS_STATUS
152 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
153 //!
VeboxUpdateVeboxStates(PVPHAL_SURFACE pSrcSurface)154 MOS_STATUS VPHAL_VEBOX_STATE_XE_HPM::VeboxUpdateVeboxStates(
155 PVPHAL_SURFACE pSrcSurface)
156 {
157 PRENDERHAL_INTERFACE pRenderHal;
158 PMOS_INTERFACE pOsInterface;
159 MOS_STATUS eStatus;
160 bool bCPUUpdate;
161 uint8_t * pStat;
162 uint8_t * pStatSlice0Base, *pStatSlice1Base;
163 int32_t iCurbeOffsetDN;
164 int32_t iKrnAllocation;
165 MHW_KERNEL_PARAM MhwKernelParam;
166 uint32_t dwKernelUpdate;
167 uint32_t dwQuery;
168 MOS_LOCK_PARAMS LockFlags;
169 PVPHAL_VEBOX_STATE_XE_HPM pVeboxState = this;
170 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
171
172 VPHAL_RENDER_CHK_NULL(pVeboxState);
173 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pRenderHal);
174 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
175 VPHAL_RENDER_CHK_NULL(pSrcSurface);
176
177 eStatus = MOS_STATUS_SUCCESS;
178 pRenderHal = pVeboxState->m_pRenderHal;
179 pOsInterface = pVeboxState->m_pOsInterface;
180 dwKernelUpdate = pVeboxState->dwKernelUpdate;
181
182 #if VEBOX_AUTO_DENOISE_SUPPORTED
183 if (!(pRenderData->bAutoDenoise ||
184 (pRenderData->bDenoise) ||
185 (pRenderData->bDenoise && !bFirstFrame && m_bTgneEnable)))
186 {
187 // no need to update, direct return.
188 VPHAL_RENDER_NORMALMESSAGE("No need update vebox states.");
189 return MOS_STATUS_SUCCESS;
190 }
191
192 VPHAL_RENDER_NORMALMESSAGE("Update vebox states.");
193
194 // Update DN State in CPU
195 bCPUUpdate = !(dwKernelUpdate);
196
197 if (bCPUUpdate)
198 {
199 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
200 LockFlags.ReadOnly = 1;
201
202 // Get Statistic surface
203 pStat = (uint8_t *)pOsInterface->pfnLockResource(
204 pOsInterface,
205 &pVeboxState->VeboxStatisticsSurface.OsResource,
206 &LockFlags);
207
208 VPHAL_RENDER_CHK_NULL(pStat);
209
210 VPHAL_RENDER_CHK_STATUS(VeboxGetStatisticsSurfaceBase(
211 pStat,
212 &pStatSlice0Base,
213 &pStatSlice1Base));
214
215 VPHAL_DBG_STATE_DUMPPER_DUMP_VEBOX_STATISTICS(pRenderHal, (void *)pVeboxState, pStatSlice0Base, pStatSlice1Base);
216
217 // Get GNE from Statistics
218 if (pRenderData->bDenoise)
219 {
220 // Query platform dependent GNE offset
221 VPHAL_RENDER_CHK_STATUS(pVeboxState->VeboxQueryStatLayout(
222 VEBOX_STAT_QUERY_GNE_OFFEST,
223 &dwQuery));
224
225 // check TGNE is valid or not.
226 VPHAL_RENDER_CHK_STATUS(pVeboxState->CheckTGNEValid(
227 (uint32_t *)(pStatSlice0Base + dwQuery),
228 (uint32_t *)(pStatSlice1Base + dwQuery),
229 &dwQuery));
230
231 if (pSrcSurface->pDenoiseParams->bEnableHVSDenoise)
232 {
233 VPHAL_RENDER_CHK_STATUS(VeboxUpdateDnStatesForHVS(
234 pSrcSurface->pDenoiseParams,
235 (uint32_t *)(pStatSlice0Base + dwQuery),
236 (uint32_t *)(pStatSlice1Base + dwQuery)));
237 }
238 }
239
240 // unlock the statistic surface
241 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnUnlockResource(
242 pOsInterface,
243 &pVeboxState->VeboxStatisticsSurface.OsResource));
244
245 // Set up the Vebox State in Clear Memory
246 VPHAL_RENDER_CHK_STATUS(VeboxUpdateVeboxHwStates(
247 pSrcSurface,
248 pRenderData->GetVeboxStateParams()));
249 }
250 else // launch update kernel to update VEBOX state
251 {
252 // Switch GPU Context to Render Engine
253 pOsInterface->pfnSetGpuContext(pOsInterface, RenderGpuContext);
254
255 // Reset allocation list and house keeping
256 pOsInterface->pfnResetOsStates(pOsInterface);
257
258 // Register the resource of GSH
259 VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnReset(pRenderHal));
260
261 // Set up UpdateDNState kernel
262 if (pRenderData->bAutoDenoise)
263 {
264 pVeboxState->SetupVeboxKernel(KERNEL_UPDATEDNSTATE);
265 }
266
267 //----------------------------------
268 // Allocate and reset media state
269 //----------------------------------
270 pRenderData->pMediaState = pRenderHal->pfnAssignMediaState(pRenderHal, RENDERHAL_COMPONENT_VEBOX);
271 VPHAL_RENDER_CHK_NULL(pRenderData->pMediaState);
272
273 //----------------------------------
274 //Allocate and reset SSH instance
275 //----------------------------------
276 VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnAssignSshInstance(pRenderHal));
277
278 //----------------------------------
279 // Assign and Reset Binding Table
280 //----------------------------------
281 VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnAssignBindingTable(
282 pRenderHal,
283 &pRenderData->iBindingTable));
284
285 //------------------------------------------
286 // Setup Surface states for DN Update kernel
287 //------------------------------------------
288 if (pRenderData->bAutoDenoise)
289 {
290 VPHAL_RENDER_CHK_STATUS(pVeboxState->SetupSurfaceStatesForDenoise());
291 }
292
293 //----------------------------------
294 // Load static data (platform specific)
295 //----------------------------------
296 VPHAL_RENDER_CHK_STATUS(pVeboxState->LoadUpdateDenoiseKernelStaticData(
297 &iCurbeOffsetDN));
298
299 //----------------------------------
300 // Setup VFE State params. Each Renderer MUST call pfnSetVfeStateParams().
301 //----------------------------------
302 VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnSetVfeStateParams(
303 pRenderHal,
304 MEDIASTATE_DEBUG_COUNTER_FREE_RUNNING,
305 pVeboxState->pKernelParamTable[KERNEL_UPDATEDNSTATE].Thread_Count,
306 pRenderData->iCurbeLength,
307 pRenderData->iInlineLength,
308 nullptr));
309
310 //----------------------------------
311 // Load DN update kernel to GSH
312 //----------------------------------
313 if (pRenderData->bAutoDenoise)
314 {
315 INIT_MHW_KERNEL_PARAM(MhwKernelParam, &pRenderData->KernelEntry[KERNEL_UPDATEDNSTATE]);
316 iKrnAllocation = pRenderHal->pfnLoadKernel(
317 pRenderHal,
318 pRenderData->pKernelParam[KERNEL_UPDATEDNSTATE],
319 &MhwKernelParam,
320 nullptr);
321
322 if (iKrnAllocation < 0)
323 {
324 eStatus = MOS_STATUS_UNKNOWN;
325 goto finish;
326 }
327
328 //----------------------------------
329 // Allocate Media ID, link to kernel
330 //----------------------------------
331 pRenderData->iMediaID0 = pRenderHal->pfnAllocateMediaID(
332 pRenderHal,
333 iKrnAllocation,
334 pRenderData->iBindingTable,
335 iCurbeOffsetDN,
336 pRenderData->pKernelParam[KERNEL_UPDATEDNSTATE]->CURBE_Length << 5,
337 0,
338 nullptr);
339
340 if (pRenderData->iMediaID0 < 0)
341 {
342 eStatus = MOS_STATUS_UNKNOWN;
343 goto finish;
344 }
345 }
346
347 //---------------------------
348 // Render Batch Buffer (Submit commands to HW)
349 //---------------------------
350 VPHAL_RENDER_CHK_STATUS(VeboxFlushUpdateStateCmdBuffer());
351 }
352
353 finish:
354 return eStatus;
355 #else
356 finish:
357 return MOS_STATUS_SUCCESS;
358 #endif
359 }
360
CheckTGNEValid(uint32_t * pStatSlice0GNEPtr,uint32_t * pStatSlice1GNEPtr,uint32_t * pQuery)361 MOS_STATUS VPHAL_VEBOX_STATE_XE_HPM::CheckTGNEValid(
362 uint32_t *pStatSlice0GNEPtr,
363 uint32_t *pStatSlice1GNEPtr,
364 uint32_t *pQuery)
365 {
366 uint32_t bGNECountLumaValid = 0;
367 PVPHAL_VEBOX_STATE_XE_HPM pVeboxState = this;
368 uint32_t dwTGNEoffset = 0;
369 MOS_STATUS eStatus;
370
371 VPHAL_RENDER_CHK_NULL(pVeboxState);
372
373 eStatus = MOS_STATUS_SUCCESS;
374 dwTGNEoffset = (VPHAL_VEBOX_STATISTICS_SURFACE_TGNE_OFFSET_G12 - VPHAL_VEBOX_STATISTICS_SURFACE_GNE_OFFSET_G12) / 4;
375
376 if (m_bTgneEnable)
377 {
378 bGNECountLumaValid = (pStatSlice0GNEPtr[dwTGNEoffset + 3] & 0x80000000) || (pStatSlice1GNEPtr[dwTGNEoffset + 3] & 0x80000000);
379
380 VPHAL_RENDER_NORMALMESSAGE("TGNE:bGNECountLumaValid %x", bGNECountLumaValid);
381
382 if (bGNECountLumaValid)
383 {
384 *pQuery = VPHAL_VEBOX_STATISTICS_SURFACE_TGNE_OFFSET_G12;
385 bTGNE_Valid = true;
386
387 if (bTGNE_FirstFrame)
388 {
389 bTGNE_FirstFrame = false;
390 }
391 }
392 else
393 {
394 *pQuery = VPHAL_VEBOX_STATISTICS_SURFACE_GNE_OFFSET_G12;
395 bTGNE_Valid = false;
396 }
397 }
398 else
399 {
400 *pQuery = VPHAL_VEBOX_STATISTICS_SURFACE_GNE_OFFSET_G12;
401 bTGNE_Valid = false;
402 bTGNE_FirstFrame = true;
403 }
404
405 finish:
406 VPHAL_RENDER_NORMALMESSAGE("TGNE:bTGNEValid %x", bTGNE_Valid);
407 return eStatus;
408 }
409
410 //!
411 //! \brief Consistent Check the value of GNE Luma
412 //! \details Consistent Check the value of GNE Luma
413 //! \param [in, out] dwGNELuma
414 //! Spatial GNE in Y channel
415 //! \param uint32_t* pStatSlice0GNEPtr
416 //! [in] Pointer to Vebox slice0 GNE data
417 //! \param uint32_t* pStatSlice1GNEPtr
418 //! [in] Pointer to Vebox slice1 GNE data
419 //! \return MOS_STATUS
420 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
421 //!
GNELumaConsistentCheck(uint32_t & dwGNELuma,uint32_t * pStatSlice0GNEPtr,uint32_t * pStatSlice1GNEPtr)422 MOS_STATUS VPHAL_VEBOX_STATE_XE_HPM::GNELumaConsistentCheck(
423 uint32_t &dwGNELuma,
424 uint32_t *pStatSlice0GNEPtr,
425 uint32_t *pStatSlice1GNEPtr)
426 {
427 MOS_STATUS eStatus;
428 uint32_t dwGNEChromaU, dwGNEChromaV;
429 uint32_t dwGNECountChromaU, dwGNECountChromaV;
430 VPHAL_RENDER_CHK_NULL(pStatSlice0GNEPtr);
431 VPHAL_RENDER_CHK_NULL(pStatSlice1GNEPtr);
432
433 eStatus = MOS_STATUS_SUCCESS;
434 dwGNEChromaU = 0;
435 dwGNEChromaV = 0;
436 dwGNECountChromaU = 0;
437 dwGNECountChromaV = 0;
438
439 // Combine the GNE in slice0 and slice1 to generate the global GNE and Count
440 dwGNEChromaU = pStatSlice0GNEPtr[1] + pStatSlice1GNEPtr[1];
441 dwGNEChromaV = pStatSlice0GNEPtr[2] + pStatSlice1GNEPtr[2];
442
443 dwGNECountChromaU = pStatSlice0GNEPtr[4] + pStatSlice1GNEPtr[4];
444 dwGNECountChromaV = pStatSlice0GNEPtr[5] + pStatSlice1GNEPtr[5];
445
446 // Validate GNE
447 if (dwGNEChromaU == 0xFFFFFFFF || dwGNECountChromaU == 0xFFFFFFFF ||
448 dwGNEChromaV == 0xFFFFFFFF || dwGNECountChromaV == 0xFFFFFFFF)
449 {
450 VPHAL_RENDER_ASSERTMESSAGE("Incorrect GNE / GNE count.");
451 eStatus = MOS_STATUS_UNKNOWN;
452 goto finish;
453 }
454
455 dwGNEChromaU = dwGNEChromaU * 100 / (dwGNECountChromaU + 1);
456 dwGNEChromaV = dwGNEChromaV * 100 / (dwGNECountChromaV + 1);
457 VPHAL_RENDER_NORMALMESSAGE("dwGNEChromaU %d dwGNEChromaV %d", dwGNEChromaU, dwGNEChromaV);
458 if ((dwGNEChromaU < NOSIE_GNE_CHROMA_THRESHOLD) &&
459 (dwGNEChromaV < NOSIE_GNE_CHROMA_THRESHOLD) &&
460 (dwGNEChromaU != 0) &&
461 (dwGNEChromaV != 0) &&
462 (dwGNELuma > NOSIE_GNE_LUMA_THRESHOLD))
463 {
464 dwGNELuma = dwGNELuma >> 2;
465 }
466
467 finish:
468 return eStatus;
469 }
470
471 //!
472 //! \brief Vebox HW state heap update for Auto-DN
473 //! \details update Vebox HW states (DN),
474 //! \param PVPHAL_SURFACE pSrcSurface
475 //! [in] Pointer to input surface of Vebox
476 //! \param PVPHAL_VEBOX_PARAMS_EXT pVeboxStateParams
477 //! [in] Pointer to VEBOX State Params
478 //! \return MOS_STATUS
479 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
480 //!
VeboxUpdateVeboxHwStates(PVPHAL_SURFACE pSrcSurface,PVPHAL_VEBOX_STATE_PARAMS pVeboxStateParams)481 MOS_STATUS VPHAL_VEBOX_STATE_XE_HPM::VeboxUpdateVeboxHwStates(
482 PVPHAL_SURFACE pSrcSurface,
483 PVPHAL_VEBOX_STATE_PARAMS pVeboxStateParams)
484 {
485 PRENDERHAL_INTERFACE pRenderHal = nullptr;
486 PMHW_VEBOX_INTERFACE pVeboxInterface = nullptr;
487 MHW_VEBOX_IECP_PARAMS VeboxIecpParams;
488 MOS_STATUS eStatus;
489 PVPHAL_VEBOX_STATE_XE_HPM pVeboxState = this;
490 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
491
492 pRenderHal = pVeboxState->m_pRenderHal;
493 pVeboxInterface = pVeboxState->m_pVeboxInterface;
494 if (!pVeboxStateParams->pVphalVeboxDndiParams)
495 {
496 eStatus = MOS_STATUS_UNKNOWN;
497 goto finish;
498 }
499
500 eStatus = MOS_STATUS_SUCCESS;
501
502 if (pVeboxStateParams->pVphalVeboxDndiParams)
503 {
504 MhwVeboxInterfaceG12 *pVeboxInterface12;
505 pVeboxInterface12 = static_cast<MhwVeboxInterfaceG12 *>(pVeboxInterface);
506
507 VPHAL_RENDER_CHK_STATUS(pVeboxInterface12->SetVeboxChromaParams(
508 (MhwVeboxInterfaceG12::MHW_VEBOX_CHROMA_PARAMS *)&pRenderData->VeboxChromaParams));
509
510 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxDndiState(
511 pVeboxStateParams->pVphalVeboxDndiParams));
512 }
513
514 finish:
515 return eStatus;
516 }
517
518 //!
519 //! \brief Vebox update HVS DN states
520 //! \details CPU update for VEBOX HVS DN states
521 //! \param PVPHAL_DENOISE_PARAMS pDNParams
522 //! [in] Pointer to DN parameter
523 //! \param uint32_t* pStatSlice0GNEPtr
524 //! [out] Pointer to Vebox slice0 GNE data
525 //! \param uint32_t* pStatSlice1GNEPtr
526 //! [out] Pointer to Vebox slice1 GNE data
527 //! \return MOS_STATUS
528 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
529 //!
VeboxUpdateDnStatesForHVS(PVPHAL_DENOISE_PARAMS pDNParams,uint32_t * pStatSlice0GNEPtr,uint32_t * pStatSlice1GNEPtr)530 MOS_STATUS VPHAL_VEBOX_STATE_XE_HPM::VeboxUpdateDnStatesForHVS(
531 PVPHAL_DENOISE_PARAMS pDNParams,
532 uint32_t * pStatSlice0GNEPtr,
533 uint32_t * pStatSlice1GNEPtr)
534 {
535 MOS_STATUS eStatus;
536 uint32_t dwGNELuma, dwGNEChromaU, dwGNEChromaV;
537 uint32_t dwGNECountLuma, dwGNECountChromaU, dwGNECountChromaV;
538 PVPHAL_DNUV_PARAMS pChromaParams = nullptr;
539 VPHAL_DNUV_PARAMS ChromaParams;
540 PMHW_VEBOX_DNDI_PARAMS pDNDIParams;
541 PVPHAL_VEBOX_STATE_XE_HPM pVeboxState = this;
542 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
543 PMHW_VEBOX_INTERFACE pVeboxInterface;
544 MhwVeboxInterfaceXe_Hpm * pVeboxInterfaceXe_Hpm;
545 int32_t sgne_offset = 0;
546 uint32_t dwSgneCountLuma = 0, dwSgneCountU = 0, dwSgneCountV;
547 uint32_t dwSgneLuma = 0, dwSgneU = 0, dwSgneV = 0;
548 uint32_t resltn = 0;
549
550 VPHAL_RENDER_CHK_NULL(pVeboxState);
551 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pVeboxInterface);
552 VPHAL_RENDER_CHK_NULL(pRenderData);
553 VPHAL_RENDER_CHK_NULL(pDNParams);
554
555 eStatus = MOS_STATUS_SUCCESS;
556 dwGNELuma = 0;
557 dwGNEChromaU = 0;
558 dwGNEChromaV = 0;
559 dwGNECountLuma = 0;
560 dwGNECountChromaU = 0;
561 dwGNECountChromaV = 0;
562 pChromaParams = nullptr;
563 pDNDIParams = pRenderData->GetVeboxStateParams()->pVphalVeboxDndiParams;
564 resltn = pVeboxState->m_currentSurface->dwWidth * pVeboxState->m_currentSurface->dwHeight;
565
566 VPHAL_RENDER_CHK_NULL(pDNDIParams);
567
568 // update the DNDI parameters
569 PMHW_VEBOX_DNDI_PARAMS pVeboxDNDIParams;
570 // Populate the VEBOX VEBOX parameters
571 pVeboxDNDIParams = &pRenderData->VeboxDNDIParams;
572 // Pick up already programmed states from clear memory, since we perform a complete refresh of VEBOX params
573 pVeboxDNDIParams->bDNDITopFirst = pDNDIParams->bDNDITopFirst;
574 pVeboxDNDIParams->bProgressiveDN = pDNDIParams->bProgressiveDN;
575 pVeboxDNDIParams->dwFMDFirstFieldCurrFrame = pDNDIParams->dwFMDFirstFieldCurrFrame;
576 pVeboxDNDIParams->dwFMDSecondFieldPrevFrame = pDNDIParams->dwFMDSecondFieldPrevFrame;
577
578 // Only need to reverse bDNDITopFirst for no reference case, no need to reverse it for having refrenece case
579 if (!pRenderData->bRefValid)
580 {
581 pVeboxDNDIParams->bDNDITopFirst = pRenderData->bTopField;
582 }
583
584 // Combine the GNE in slice0 and slice1 to generate the global GNE and Count
585 dwGNELuma = pStatSlice0GNEPtr[0] + pStatSlice1GNEPtr[0];
586
587 pVeboxInterface = pVeboxState->m_pVeboxInterface;
588 pVeboxInterfaceXe_Hpm = (MhwVeboxInterfaceXe_Hpm *)pVeboxInterface;
589
590 VPHAL_RENDER_NORMALMESSAGE("m_bTgneEnable %d, bTGNE_Valid %d, bTGNE_FirstFrame %d, bFirstFrame %d",
591 m_bTgneEnable,
592 bTGNE_Valid,
593 bTGNE_FirstFrame,
594 bFirstFrame);
595
596 // Set HVS kernel Params
597 pDNParams->HVSDenoise.Fallback = !bTGNE_Valid && !bFirstFrame && !bTGNE_FirstFrame;
598 pDNParams->HVSDenoise.EnableChroma = pRenderData->bChromaDenoise;
599 pDNParams->HVSDenoise.TgneEnable = m_bTgneEnable;
600 pDNParams->HVSDenoise.FirstFrame = bFirstFrame;
601 pDNParams->HVSDenoise.TgneFirstFrame = !bFirstFrame && bTGNE_FirstFrame;
602 pDNParams->HVSDenoise.EnableTemporalGNE = m_bTgneEnable;
603 pDNParams->HVSDenoise.Width = (uint16_t)pVeboxState->m_currentSurface->dwWidth;
604 pDNParams->HVSDenoise.Height = (uint16_t)pVeboxState->m_currentSurface->dwHeight;
605
606 if (pDNParams->HVSDenoise.Mode == HVSDENOISE_AUTO_BDRATE && pDNParams->bEnableHVSDenoise)
607 {
608 pVeboxInterfaceXe_Hpm->bHVSAutoBdrateEnable = true;
609 }
610 else if (pDNParams->HVSDenoise.Mode == HVSDENOISE_AUTO_SUBJECTIVE && pDNParams->bEnableHVSDenoise)
611 {
612 pVeboxInterfaceXe_Hpm->bHVSAutoSubjectiveEnable = true;
613 pVeboxInterfaceXe_Hpm->dwBSDThreshold = (resltn < RESOLUTION_THRESHOLD) ? 240 : 135;
614 }
615 else
616 {
617 pVeboxInterfaceXe_Hpm->bHVSAutoBdrateEnable = false;
618 pVeboxInterfaceXe_Hpm->bHVSAutoSubjectiveEnable = false;
619 }
620
621 if (m_bTgneEnable && bTGNE_FirstFrame && !bFirstFrame) //2nd frame
622 {
623 pVeboxInterfaceXe_Hpm->bTGNEEnable = true;
624 pVeboxInterfaceXe_Hpm->dwLumaStadTh = 3200;
625 if (MEDIA_IS_WA(pVeboxState->m_pRenderHal->pWaTable, Wa_1609102037) &&
626 VpHalDDIUtils::GetSurfaceColorPack(pVeboxState->m_currentSurface->Format) == VPHAL_COLORPACK_444)
627 {
628 pVeboxInterfaceXe_Hpm->dw4X4TGNEThCnt = ((pVeboxState->m_currentSurface->dwWidth - 32) *
629 (pVeboxState->m_currentSurface->dwHeight - 8)) /
630 1600;
631 }
632 else
633 {
634 pVeboxInterfaceXe_Hpm->dw4X4TGNEThCnt = ((pVeboxState->m_currentSurface->dwWidth - 8) *
635 (pVeboxState->m_currentSurface->dwHeight - 8)) /
636 1600;
637 }
638
639 if (pDNParams->HVSDenoise.Mode == HVSDENOISE_AUTO_BDRATE)
640 {
641 pVeboxInterfaceXe_Hpm->dwLumaStadTh = 250;
642 pVeboxInterfaceXe_Hpm->dwHistoryInit = 27;
643 dwGNECountLuma = pStatSlice0GNEPtr[3] + pStatSlice1GNEPtr[3];
644 dwGNELuma = dwGNELuma * 100 / (dwGNECountLuma + 1);
645 // Validate GNE
646 if (dwGNELuma == 0xFFFFFFFF || dwGNECountLuma == 0xFFFFFFFF)
647 {
648 VPHAL_RENDER_ASSERTMESSAGE("Incorrect GNE / GNE count.");
649 eStatus = MOS_STATUS_INVALID_PARAMETER;
650 goto finish;
651 }
652
653 // consistent check
654 if (pRenderData->bChromaDenoise)
655 {
656 GNELumaConsistentCheck(dwGNELuma, pStatSlice0GNEPtr, pStatSlice1GNEPtr);
657 }
658 dwGlobalNoiseLevel_Temporal = (dwGNELuma + 50) / 100;
659 }
660
661 pDNParams->HVSDenoise.PrevNslvTemporal = -1;
662 pDNParams->HVSDenoise.Sgne_Level = dwGNELuma;
663 pDNParams->HVSDenoise.Sgne_Count = dwGNECountLuma;
664 pDNParams->HVSDenoise.dwGlobalNoiseLevel = dwGlobalNoiseLevel_Temporal;
665 }
666 else if (m_bTgneEnable && bTGNE_Valid && !bFirstFrame) // middle frame
667 {
668 dwGNECountLuma = (pStatSlice0GNEPtr[3] & 0x7FFFFFFF) + (pStatSlice1GNEPtr[3] & 0x7FFFFFFF);
669
670 // Validate TGNE
671 if (dwGNECountLuma == 0)
672 {
673 VPHAL_RENDER_ASSERTMESSAGE("Incorrect GNE count.");
674 eStatus = MOS_STATUS_INVALID_PARAMETER;
675 goto finish;
676 }
677
678 VPHAL_RENDER_NORMALMESSAGE("GNELuma 0x%x GNECountLuma 0x%x", dwGNELuma, dwGNECountLuma);
679 curNoiseLevel_Temporal = dwGNELuma / dwGNECountLuma;
680 dwGlobalNoiseLevel_Temporal = MOS_ROUNDUP_SHIFT(dwGlobalNoiseLevel_Temporal + curNoiseLevel_Temporal, 1);
681
682 if (pVeboxInterfaceXe_Hpm->bHVSfallback)
683 {
684 pDNParams->HVSDenoise.dwGlobalNoiseLevel = curNoiseLevel_Temporal;
685 }
686 else
687 {
688 pDNParams->HVSDenoise.dwGlobalNoiseLevel = dwGlobalNoiseLevel_Temporal;
689 }
690 pVeboxInterfaceXe_Hpm->bTGNEEnable = true;
691 sgne_offset = -12; //VPHAL_VEBOX_STATISTICS_SURFACE_GNE_OFFSET_G12 - VPHAL_VEBOX_STATISTICS_SURFACE_TGNE_OFFSET_G12;
692 dwSgneCountLuma = pStatSlice0GNEPtr[sgne_offset + 3] + pStatSlice1GNEPtr[sgne_offset + 3];
693 dwSgneLuma = pStatSlice0GNEPtr[sgne_offset] + pStatSlice1GNEPtr[sgne_offset];
694 pDNParams->HVSDenoise.Sgne_Level = dwSgneLuma * 100 / (dwSgneCountLuma + 1);
695 pDNParams->HVSDenoise.Sgne_Count = dwSgneCountLuma;
696 pDNParams->HVSDenoise.PrevNslvTemporal = curNoiseLevel_Temporal;
697
698 if (pDNParams->HVSDenoise.Mode == HVSDENOISE_AUTO_BDRATE)
699 {
700 pVeboxInterfaceXe_Hpm->dwLumaStadTh = 250;
701 pVeboxInterfaceXe_Hpm->dwHistoryInit = 27;
702 }
703 else
704 {
705 pVeboxInterfaceXe_Hpm->dwLumaStadTh = (dwGlobalNoiseLevel_Temporal <= 1) ? 3200 : (pVeboxInterfaceXe_Hpm->dwLumaStadTh + (curNoiseLevel_Temporal << 1) + 1) >> 1;
706 }
707
708 if (MEDIA_IS_WA(pVeboxState->m_pRenderHal->pWaTable, Wa_1609102037) &&
709 VpHalDDIUtils::GetSurfaceColorPack(pVeboxState->m_currentSurface->Format) == VPHAL_COLORPACK_444)
710 {
711 pVeboxInterfaceXe_Hpm->dw4X4TGNEThCnt = ((pVeboxState->m_currentSurface->dwWidth - 32) *
712 (pVeboxState->m_currentSurface->dwHeight - 8)) /
713 1600;
714 }
715 else
716 {
717 pVeboxInterfaceXe_Hpm->dw4X4TGNEThCnt = ((pVeboxState->m_currentSurface->dwWidth - 8) *
718 (pVeboxState->m_currentSurface->dwHeight - 8)) /
719 1600;
720 }
721 }
722 else //first frame or fallback
723 {
724 dwGNECountLuma = pStatSlice0GNEPtr[3] + pStatSlice1GNEPtr[3];
725
726 // Validate GNE
727 if (dwGNELuma == 0xFFFFFFFF || dwGNECountLuma == 0xFFFFFFFF)
728 {
729 VPHAL_RENDER_ASSERTMESSAGE("Incorrect GNE / GNE count.");
730 eStatus = MOS_STATUS_INVALID_PARAMETER;
731 goto finish;
732 }
733
734 dwGNELuma = dwGNELuma * 100 / (dwGNECountLuma + 1);
735
736 // consistent check
737 if (pRenderData->bChromaDenoise)
738 {
739 GNELumaConsistentCheck(dwGNELuma, pStatSlice0GNEPtr, pStatSlice1GNEPtr);
740 }
741
742 if (pDNParams->HVSDenoise.Fallback)
743 {
744 pVeboxInterfaceXe_Hpm->bHVSfallback = true;
745 pVeboxInterfaceXe_Hpm->dwHistoryInit = 32;
746 }
747 else
748 {
749 if (pDNParams->HVSDenoise.Mode == HVSDENOISE_AUTO_BDRATE && pDNParams->bEnableHVSDenoise)
750 {
751 pVeboxInterfaceXe_Hpm->dwHistoryInit = 32;
752 }
753 pVeboxInterfaceXe_Hpm->bTGNEEnable = false;
754 pVeboxInterfaceXe_Hpm->dwLumaStadTh = 0;
755 pVeboxInterfaceXe_Hpm->dw4X4TGNEThCnt = 0;
756 }
757
758 pDNParams->HVSDenoise.dwGlobalNoiseLevel = dwGNELuma;
759 pDNParams->HVSDenoise.Sgne_Level = dwGNELuma;
760 pDNParams->HVSDenoise.Sgne_Count = dwGNECountLuma;
761 pDNParams->HVSDenoise.PrevNslvTemporal = -1;
762 }
763
764 // -------------------------- Update Chroma -------------------------------
765 // Only use Luma params to substitute Bayer pattern (RGB) DN in Capture Pipe.
766 // Chroma params will not be used since there is no chroma.
767 if (pRenderData->bChromaDenoise)
768 {
769 pChromaParams = &ChromaParams;
770 MOS_ZeroMemory(pChromaParams, sizeof(VPHAL_DNUV_PARAMS));
771
772 // Setup default Denoise Params for Chroma
773 pChromaParams->dwHistoryDeltaUV = NOISE_HISTORY_DELTA_DEFAULT;
774 pChromaParams->dwHistoryMaxUV = NOISE_HISTORY_MAX_DEFAULT;
775 pVeboxDNDIParams->bChromaDNEnable = pRenderData->bChromaDenoise;
776
777 // Combine the GNE in slice0 and slice1 to generate the global GNE and Count
778 dwGNEChromaU = pStatSlice0GNEPtr[1] + pStatSlice1GNEPtr[1];
779 dwGNEChromaV = pStatSlice0GNEPtr[2] + pStatSlice1GNEPtr[2];
780 dwGNECountChromaU = pStatSlice0GNEPtr[4] + pStatSlice1GNEPtr[4];
781 dwGNECountChromaV = pStatSlice0GNEPtr[5] + pStatSlice1GNEPtr[5];
782 dwGNEChromaU = dwGNEChromaU * 100 / (dwGNECountChromaU + 1);
783 dwGNEChromaV = dwGNEChromaV * 100 / (dwGNECountChromaV + 1);
784
785 if (m_bTgneEnable && bTGNE_FirstFrame && !bFirstFrame)
786 {
787 pVeboxInterfaceXe_Hpm->dwChromaStadTh = 1600;
788
789 if (pDNParams->HVSDenoise.Mode == HVSDENOISE_AUTO_BDRATE)
790 {
791 pVeboxInterfaceXe_Hpm->dwChromaStadTh = 250;
792
793 // Validate GNE
794 if (dwGNEChromaU == 0xFFFFFFFF || dwGNECountChromaU == 0xFFFFFFFF ||
795 dwGNEChromaV == 0xFFFFFFFF || dwGNECountChromaV == 0xFFFFFFFF)
796 {
797 VPHAL_RENDER_ASSERTMESSAGE("Incorrect GNE / GNE count.");
798 eStatus = MOS_STATUS_UNKNOWN;
799 goto finish;
800 }
801 dwGlobalNoiseLevelU_Temporal = (dwGNEChromaU + 50) / 100;
802 dwGlobalNoiseLevelV_Temporal = (dwGNEChromaV + 50) / 100;
803 }
804 pDNParams->HVSDenoise.PrevNslvTemporalU = -1;
805 pDNParams->HVSDenoise.PrevNslvTemporalV = -1;
806 pDNParams->HVSDenoise.Sgne_CountU = dwGNECountChromaU;
807 pDNParams->HVSDenoise.Sgne_CountV = dwGNECountChromaV;
808 pDNParams->HVSDenoise.Sgne_LevelU = dwGNEChromaU;
809 pDNParams->HVSDenoise.Sgne_LevelV = dwGNEChromaV;
810 pDNParams->HVSDenoise.dwGlobalNoiseLevelU = dwGlobalNoiseLevelU_Temporal;
811 pDNParams->HVSDenoise.dwGlobalNoiseLevelV = dwGlobalNoiseLevelV_Temporal;
812 }
813 else if (m_bTgneEnable && bTGNE_Valid && !bFirstFrame)
814 {
815 dwGNECountChromaU = (pStatSlice0GNEPtr[4] & 0x7FFFFFFF) + (pStatSlice1GNEPtr[4] & 0x7FFFFFFF);
816 dwGNECountChromaV = (pStatSlice0GNEPtr[5] & 0x7FFFFFFF) + (pStatSlice1GNEPtr[5] & 0x7FFFFFFF);
817
818 // Validate TGNE
819 if (dwGNECountChromaU == 0 || dwGNECountChromaV == 0)
820 {
821 VPHAL_RENDER_ASSERTMESSAGE("Incorrect GNE count.");
822 eStatus = MOS_STATUS_UNKNOWN;
823 goto finish;
824 }
825
826 curNoiseLevelU_Temporal = dwGNEChromaU / dwGNECountChromaU;
827 curNoiseLevelV_Temporal = dwGNEChromaV / dwGNECountChromaV;
828
829 if (pVeboxInterfaceXe_Hpm->bHVSfallback)
830 {
831 pDNParams->HVSDenoise.dwGlobalNoiseLevelU = curNoiseLevelU_Temporal;
832 pDNParams->HVSDenoise.dwGlobalNoiseLevelV = curNoiseLevelU_Temporal;
833 pVeboxInterfaceXe_Hpm->bHVSfallback = false;
834 }
835 else
836 {
837 dwGlobalNoiseLevelU_Temporal = MOS_ROUNDUP_SHIFT(dwGlobalNoiseLevelU_Temporal + curNoiseLevelU_Temporal, 1);
838 dwGlobalNoiseLevelV_Temporal = MOS_ROUNDUP_SHIFT(dwGlobalNoiseLevelV_Temporal + curNoiseLevelV_Temporal, 1);
839 pDNParams->HVSDenoise.dwGlobalNoiseLevelU = dwGlobalNoiseLevelU_Temporal;
840 pDNParams->HVSDenoise.dwGlobalNoiseLevelV = dwGlobalNoiseLevelV_Temporal;
841 }
842
843 sgne_offset = -12; //VPHAL_VEBOX_STATISTICS_SURFACE_GNE_OFFSET_G12 - VPHAL_VEBOX_STATISTICS_SURFACE_TGNE_OFFSET_G12;
844 dwSgneCountU = pStatSlice0GNEPtr[sgne_offset + 3 + 1] + pStatSlice1GNEPtr[sgne_offset + 3 + 1];
845 dwSgneCountV = pStatSlice0GNEPtr[sgne_offset + 3 + 2] + pStatSlice1GNEPtr[sgne_offset + 3 + 2];
846 dwSgneU = pStatSlice0GNEPtr[sgne_offset + 1] + pStatSlice1GNEPtr[sgne_offset + 1];
847 dwSgneV = pStatSlice0GNEPtr[sgne_offset + 2] + pStatSlice1GNEPtr[sgne_offset + 2];
848
849 pDNParams->HVSDenoise.PrevNslvTemporalU = curNoiseLevelU_Temporal;
850 pDNParams->HVSDenoise.PrevNslvTemporalV = curNoiseLevelV_Temporal;
851 pDNParams->HVSDenoise.Sgne_CountU = dwSgneCountU;
852 pDNParams->HVSDenoise.Sgne_CountV = dwSgneCountV;
853 pDNParams->HVSDenoise.Sgne_LevelU = dwSgneU * 100 / (dwSgneCountU + 1);
854 pDNParams->HVSDenoise.Sgne_LevelV = dwSgneV * 100 / (dwSgneCountV + 1);
855
856 if (pDNParams->HVSDenoise.Mode == HVSDENOISE_AUTO_BDRATE)
857 {
858 pVeboxInterfaceXe_Hpm->dwChromaStadTh = 250;
859 }
860 else
861 {
862 pVeboxInterfaceXe_Hpm->dwChromaStadTh = (dwGlobalNoiseLevelU_Temporal <= 1 || dwGlobalNoiseLevelV_Temporal <= 1) ? 1600 : (pVeboxInterfaceXe_Hpm->dwChromaStadTh + curNoiseLevelU_Temporal + curNoiseLevelV_Temporal + 1) >> 1;
863 }
864 }
865 else
866 {
867 dwGNECountChromaU = pStatSlice0GNEPtr[4] + pStatSlice1GNEPtr[4];
868 dwGNECountChromaV = pStatSlice0GNEPtr[5] + pStatSlice1GNEPtr[5];
869
870 // Validate GNE
871 if (dwGNEChromaU == 0xFFFFFFFF || dwGNECountChromaU == 0xFFFFFFFF ||
872 dwGNEChromaV == 0xFFFFFFFF || dwGNECountChromaV == 0xFFFFFFFF)
873 {
874 VPHAL_RENDER_ASSERTMESSAGE("Incorrect GNE / GNE count.");
875 eStatus = MOS_STATUS_UNKNOWN;
876 goto finish;
877 }
878
879 dwGNEChromaU = dwGNEChromaU * 100 / (dwGNECountChromaU + 1);
880 dwGNEChromaV = dwGNEChromaV * 100 / (dwGNECountChromaV + 1);
881
882 if (!pDNParams->HVSDenoise.Fallback)
883 {
884 pVeboxInterfaceXe_Hpm->dwChromaStadTh = 0;
885 }
886
887 pDNParams->HVSDenoise.PrevNslvTemporalU = -1;
888 pDNParams->HVSDenoise.PrevNslvTemporalV = -1;
889 pDNParams->HVSDenoise.Sgne_CountU = dwGNECountChromaU;
890 pDNParams->HVSDenoise.Sgne_CountV = dwGNECountChromaV;
891 pDNParams->HVSDenoise.Sgne_LevelU = dwGNEChromaU;
892 pDNParams->HVSDenoise.Sgne_LevelV = dwGNEChromaV;
893 pDNParams->HVSDenoise.dwGlobalNoiseLevelU = dwGNEChromaU;
894 pDNParams->HVSDenoise.dwGlobalNoiseLevelV = dwGNEChromaV;
895 }
896 }
897
898 VPHAL_VEBOX_STATE_XE_XPM::VeboxSetHVSDNParams(pDNParams);
899
900 if (m_bTgneEnable && bTGNE_FirstFrame && !bFirstFrame)
901 {
902 bTGNE_FirstFrame = false;
903 }
904
905 finish:
906 return eStatus;
907 }
908