1 /*
2 * Copyright (c) 2021-2022, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file     vp_user_feature_control.cpp
24 //! \brief    vp user feature control.
25 //! \details  vp user feature control.
26 //!
27 #include "vp_user_feature_control.h"
28 #include "vp_utils.h"
29 
30 using namespace vp;
31 
VpUserFeatureControl(MOS_INTERFACE & osInterface,VpPlatformInterface * vpPlatformInterface,void * owner)32 VpUserFeatureControl::VpUserFeatureControl(MOS_INTERFACE &osInterface, VpPlatformInterface *vpPlatformInterface, void *owner) :
33     m_owner(owner), m_osInterface(&osInterface), m_vpPlatformInterface(vpPlatformInterface)
34 {
35     MOS_STATUS status = MOS_STATUS_SUCCESS;
36     uint32_t compBypassMode = VPHAL_COMP_BYPASS_ENABLED;    // Vebox Comp Bypass is on by default
37     auto skuTable = m_osInterface->pfnGetSkuTable(m_osInterface);
38 
39     m_userSettingPtr = m_osInterface->pfnGetUserSettingInstance(m_osInterface);
40     // Read user feature key to get the Composition Bypass mode
41     if (skuTable && (!MEDIA_IS_SKU(skuTable, FtrVERing)))
42     {
43         m_ctrlValDefault.disableVeboxOutput = true;
44         m_ctrlValDefault.disableSfc         = true;
45 
46         VP_PUBLIC_NORMALMESSAGE("No VeRing, disableVeboxOutput %d, disableSfc %d", m_ctrlValDefault.disableVeboxOutput, m_ctrlValDefault.disableSfc);
47     }
48     else
49     {
50         status = ReadUserSetting(
51             m_userSettingPtr,
52             compBypassMode,
53             __VPHAL_BYPASS_COMPOSITION,
54             MediaUserSetting::Group::Sequence,
55             compBypassMode,
56             true);
57 
58         if (MOS_SUCCEEDED(status))
59         {
60             m_ctrlValDefault.disableVeboxOutput = VPHAL_COMP_BYPASS_DISABLED == compBypassMode;
61         }
62         else
63         {
64             // Default value
65             m_ctrlValDefault.disableVeboxOutput = false;
66         }
67 
68         VP_PUBLIC_NORMALMESSAGE("disableVeboxOutput %d", m_ctrlValDefault.disableVeboxOutput);
69 
70         if (skuTable && MEDIA_IS_SKU(skuTable, FtrSFCPipe))
71         {
72             // Read user feature key to Disable SFC
73             bool disableSFC = false;
74             status          = ReadUserSetting(
75                 m_userSettingPtr,
76                 disableSFC,
77                 __VPHAL_VEBOX_DISABLE_SFC,
78                 MediaUserSetting::Group::Sequence);
79 
80             if (MOS_SUCCEEDED(status))
81             {
82                 m_ctrlValDefault.disableSfc = disableSFC;
83             }
84             else
85             {
86                 // Default value
87                 m_ctrlValDefault.disableSfc = false;
88             }
89         }
90         else
91         {
92             m_ctrlValDefault.disableSfc = true;
93             VP_PUBLIC_NORMALMESSAGE("No FtrSFCPipe, disableSfc %d", m_ctrlValDefault.disableSfc);
94         }
95         VP_PUBLIC_NORMALMESSAGE("disableSfc %d", m_ctrlValDefault.disableSfc);
96     }
97 
98     // If disable dn
99     bool disableDn = false;
100     status = ReadUserSetting(
101         m_userSettingPtr,
102         disableDn,
103         __MEDIA_USER_FEATURE_VALUE_DISABLE_DN,
104         MediaUserSetting::Group::Sequence);
105     if (MOS_SUCCEEDED(status))
106     {
107         m_ctrlValDefault.disableDn = disableDn;
108     }
109     else
110     {
111         // Default value
112         m_ctrlValDefault.disableDn = false;
113     }
114     VP_PUBLIC_NORMALMESSAGE("disableDn %d", m_ctrlValDefault.disableDn);
115 
116    // Force enable vebox ouptut surface.
117     bool forceEnableVeboxOutputSurf = false;
118     status = ReadUserSetting(
119         m_userSettingPtr,
120         forceEnableVeboxOutputSurf,
121         __MEDIA_USER_FEATURE_VALUE_FORCE_ENABLE_VEBOX_OUTPUT_SURF,
122         MediaUserSetting::Group::Sequence);
123     if (MOS_SUCCEEDED(status))
124     {
125         m_ctrlValDefault.ForceEnableVeboxOutputSurf = forceEnableVeboxOutputSurf;
126     }
127     else
128     {
129         // Default value
130         m_ctrlValDefault.ForceEnableVeboxOutputSurf = false;
131     }
132     VP_PUBLIC_NORMALMESSAGE("ForceEnableVeboxOutputSurf %d", m_ctrlValDefault.ForceEnableVeboxOutputSurf);
133 
134     // __MEDIA_USER_FEATURE_VALUE_CSC_COEFF_PATCH_MODE_DISABLE
135     bool cscCoeffPatchModeDisabled = false;
136     status = ReadUserSetting(
137         m_userSettingPtr,
138         cscCoeffPatchModeDisabled,
139         __MEDIA_USER_FEATURE_VALUE_CSC_COEFF_PATCH_MODE_DISABLE,
140         MediaUserSetting::Group::Sequence);
141     if (MOS_SUCCEEDED(status))
142     {
143         m_ctrlValDefault.cscCosffPatchModeDisabled = cscCoeffPatchModeDisabled;
144     }
145     else
146     {
147         // Default value
148         m_ctrlValDefault.cscCosffPatchModeDisabled = false;
149     }
150     VP_PUBLIC_NORMALMESSAGE("cscCosffPatchModeDisabled %d", m_ctrlValDefault.cscCosffPatchModeDisabled);
151 
152     bool disablePacketReuse = false;
153     status = ReadUserSetting(
154         m_userSettingPtr,
155         disablePacketReuse,
156         __MEDIA_USER_FEATURE_VALUE_DISABLE_PACKET_REUSE,
157         MediaUserSetting::Group::Sequence);
158     if (MOS_SUCCEEDED(status))
159     {
160         m_ctrlValDefault.disablePacketReuse = disablePacketReuse;
161     }
162     else
163     {
164         // Default value
165         m_ctrlValDefault.disablePacketReuse = false;
166     }
167     VP_PUBLIC_NORMALMESSAGE("disablePacketReuse %d", m_ctrlValDefault.disablePacketReuse);
168 
169     bool enablePacketReuseTeamsAlways = false;
170     status = ReadUserSetting(
171         m_userSettingPtr,
172         enablePacketReuseTeamsAlways,
173         __MEDIA_USER_FEATURE_VALUE_ENABLE_PACKET_REUSE_TEAMS_ALWAYS,
174         MediaUserSetting::Group::Sequence);
175     if (MOS_SUCCEEDED(status))
176     {
177         m_ctrlValDefault.enablePacketReuseTeamsAlways = enablePacketReuseTeamsAlways;
178     }
179     else
180     {
181         // Default value
182         m_ctrlValDefault.enablePacketReuseTeamsAlways = false;
183     }
184     VP_PUBLIC_NORMALMESSAGE("enablePacketReuseTeamsAlways %d", m_ctrlValDefault.enablePacketReuseTeamsAlways);
185 
186     // bComputeContextEnabled is true only if Gen12+.
187     // Gen12+, compute context(MOS_GPU_NODE_COMPUTE, MOS_GPU_CONTEXT_COMPUTE) can be used for render engine.
188     // Before Gen12, we only use MOS_GPU_NODE_3D and MOS_GPU_CONTEXT_RENDER.
189     if (skuTable && MEDIA_IS_SKU(skuTable, FtrCCSNode))
190     {
191 #if (_DEBUG || _RELEASE_INTERNAL)
192         bool computeContextEnabled = false;
193         status = ReadUserSettingForDebug(
194             m_userSettingPtr,
195             computeContextEnabled,
196             __VPHAL_ENABLE_COMPUTE_CONTEXT,
197             MediaUserSetting::Group::Sequence);
198 
199         if (MOS_SUCCEEDED(status))
200         {
201             m_ctrlValDefault.computeContextEnabled = computeContextEnabled ? true : false;
202         }
203         else
204 #endif
205         {
206             // Default value
207             m_ctrlValDefault.computeContextEnabled = true;
208         }
209     }
210     else
211     {
212         m_ctrlValDefault.computeContextEnabled = false;
213     }
214     VP_PUBLIC_NORMALMESSAGE("computeContextEnabled %d", m_ctrlValDefault.computeContextEnabled);
215 
216     // Read userSettingForDebug
217     CreateUserSettingForDebug();
218 
219     if (m_vpPlatformInterface)
220     {
221         m_ctrlValDefault.eufusionBypassWaEnabled = m_vpPlatformInterface->IsEufusionBypassWaEnabled();
222         m_ctrlValDefault.decompForInterlacedSurfWaEnabled = m_vpPlatformInterface->IsDecompForInterlacedSurfWaEnabled();
223     }
224     else
225     {
226         // Should never come to here.
227         VP_PUBLIC_ASSERTMESSAGE("m_vpPlatformInterface == nullptr");
228     }
229     VP_PUBLIC_NORMALMESSAGE("eufusionBypassWaEnabled %d", m_ctrlValDefault.eufusionBypassWaEnabled);
230     VP_PUBLIC_NORMALMESSAGE("decompForInterlacedSurfWaEnabled %d", m_ctrlValDefault.decompForInterlacedSurfWaEnabled);
231 
232     MT_LOG3(MT_VP_USERFEATURE_CTRL, MT_NORMAL, MT_VP_UF_CTRL_DISABLE_VEOUT, m_ctrlValDefault.disableVeboxOutput,
233         MT_VP_UF_CTRL_DISABLE_SFC, m_ctrlValDefault.disableSfc, MT_VP_UF_CTRL_CCS, m_ctrlValDefault.computeContextEnabled);
234 
235 #if (_DEBUG || _RELEASE_INTERNAL)
236     uint32_t globalLutMode = VPHAL_HDR_LUT_MODE_NONE;
237     status                 = ReadUserSetting(
238         m_userSettingPtr,
239         globalLutMode,
240         __VPHAL_HDR_LUT_MODE,
241         MediaUserSetting::Group::Sequence,
242         VPHAL_HDR_LUT_MODE_NONE,
243         true);
244     if (MOS_SUCCEEDED(status))
245     {
246         m_ctrlValDefault.globalLutMode = (VPHAL_HDR_LUT_MODE)globalLutMode;
247     }
248 
249     bool gpuGenerate3DLUT = false;
250     status                = ReadUserSetting(
251         m_userSettingPtr,
252         gpuGenerate3DLUT,
253         __VPHAL_HDR_GPU_GENERTATE_3DLUT,
254         MediaUserSetting::Group::Sequence,
255         false,
256         true);
257     if (MOS_SUCCEEDED(status))
258     {
259         m_ctrlValDefault.gpuGenerate3DLUT = gpuGenerate3DLUT;
260     }
261 
262     bool disableAutoMode = false;
263     status               = ReadUserSetting(
264         m_userSettingPtr,
265         disableAutoMode,
266         __VPHAL_HDR_DISABLE_AUTO_MODE,
267         MediaUserSetting::Group::Sequence,
268         false,
269         true);
270     if (MOS_SUCCEEDED(status))
271     {
272         m_ctrlValDefault.disableAutoMode = disableAutoMode;
273     }
274 #endif
275 
276     uint32_t splitFramePortions = 1;
277     status                      = ReadUserSetting(
278         m_userSettingPtr,
279         splitFramePortions,
280         __VPHAL_HDR_SPLIT_FRAME_PORTIONS,
281         MediaUserSetting::Group::Sequence,
282         splitFramePortions,
283         true);
284     if (MOS_SUCCEEDED(status))
285     {
286         m_ctrlValDefault.splitFramePortions = splitFramePortions;
287     }
288 
289     //check vebox type
290     if (skuTable && (MEDIA_IS_SKU(skuTable, FtrVeboxTypeH)))
291     {
292         m_ctrlValDefault.veboxTypeH = true;
293     }
294     VP_PUBLIC_NORMALMESSAGE("veboxTypeH %d", m_ctrlValDefault.veboxTypeH);
295 
296     m_ctrlVal = m_ctrlValDefault;
297 }
298 
~VpUserFeatureControl()299 VpUserFeatureControl::~VpUserFeatureControl()
300 {
301     if (m_pOcaFeatureControlInfo)
302     {
303         MOS_FreeMemAndSetNull(m_pOcaFeatureControlInfo);
304     }
305 }
306 
CreateUserSettingForDebug()307 MOS_STATUS VpUserFeatureControl::CreateUserSettingForDebug()
308 {
309     MOS_STATUS eRegKeyReadStatus = MOS_STATUS_SUCCESS;
310 #if ((_DEBUG || _RELEASE_INTERNAL) && !EMUL)
311     bool forceDecompressedOutput = false;
312     eRegKeyReadStatus = ReadUserSettingForDebug(
313         m_userSettingPtr,
314         forceDecompressedOutput,
315         __VPHAL_RNDR_FORCE_VP_DECOMPRESSED_OUTPUT,
316         MediaUserSetting::Group::Sequence);
317     if (MOS_SUCCEEDED(eRegKeyReadStatus))
318     {
319         m_ctrlValDefault.forceDecompressedOutput = forceDecompressedOutput;
320     }
321     else
322     {
323         // Default value
324         m_ctrlValDefault.forceDecompressedOutput = false;
325     }
326 #endif
327 
328 #if (_DEBUG || _RELEASE_INTERNAL)
329     uint32_t   force3DLutInterpolation = 0;
330     eRegKeyReadStatus                  = ReadUserSettingForDebug(
331         m_userSettingPtr,
332         force3DLutInterpolation,
333         __VPHAL_FORCE_3DLUT_INTERPOLATION,
334         MediaUserSetting::Group::Sequence);
335     if (MOS_SUCCEEDED(eRegKeyReadStatus))
336     {
337         m_ctrlValDefault.force3DLutInterpolation = force3DLutInterpolation;
338     }
339     else
340     {
341         // Default value
342         m_ctrlValDefault.force3DLutInterpolation = 0;
343     }
344 
345     uint32_t is3DLutKernelOnly = 0;
346     eRegKeyReadStatus                = ReadUserSettingForDebug(
347         m_userSettingPtr,
348         is3DLutKernelOnly,
349         __VPHAL_FORCE_VP_3DLUT_KERNEL_ONLY,
350         MediaUserSetting::Group::Sequence);
351     if (MOS_SUCCEEDED(eRegKeyReadStatus))
352     {
353         m_ctrlValDefault.is3DLutKernelOnly = is3DLutKernelOnly;
354     }
355     else
356     {
357         // Default value
358         m_ctrlValDefault.is3DLutKernelOnly = 0;
359     }
360 
361     //SFC NV12/P010 Linear Output.
362     uint32_t enabledSFCNv12P010LinearOutput = 0;
363     eRegKeyReadStatus = ReadUserSettingForDebug(
364         m_userSettingPtr,
365         enabledSFCNv12P010LinearOutput,
366         __VPHAL_ENABLE_SFC_NV12_P010_LINEAR_OUTPUT,
367         MediaUserSetting::Group::Sequence);
368     if (MOS_SUCCEEDED(eRegKeyReadStatus))
369     {
370         m_ctrlValDefault.enabledSFCNv12P010LinearOutput = enabledSFCNv12P010LinearOutput;
371     }
372     else
373     {
374         // Default value
375         m_ctrlValDefault.enabledSFCNv12P010LinearOutput = 0;
376     }
377 
378     //SFC RGBP Linear/Tile RGB24 Linear Output.
379     uint32_t enabledSFCRGBPRGB24Output = 0;
380     eRegKeyReadStatus =ReadUserSettingForDebug(
381         m_userSettingPtr,
382         enabledSFCRGBPRGB24Output,
383         __VPHAL_ENABLE_SFC_RGBP_RGB24_OUTPUT,
384         MediaUserSetting::Group::Sequence);
385     if (MOS_SUCCEEDED(eRegKeyReadStatus))
386     {
387         m_ctrlValDefault.enabledSFCRGBPRGB24Output = enabledSFCRGBPRGB24Output;
388     }
389     else
390     {
391         // Default value
392         m_ctrlValDefault.enabledSFCRGBPRGB24Output = 0;
393     }
394 
395     //Enable IFNCC report
396     bool enableIFNCC  = false;
397     eRegKeyReadStatus = ReadUserSettingForDebug(
398         m_userSettingPtr,
399         enableIFNCC,
400         __MEDIA_USER_FEATURE_VALUE_ENABLE_IFNCC,
401         MediaUserSetting::Group::Sequence);
402     if (MOS_SUCCEEDED(eRegKeyReadStatus))
403     {
404         m_ctrlValDefault.enableIFNCC = enableIFNCC;
405         VP_PUBLIC_NORMALMESSAGE("Report IFNCC Reg Key Enabled. Will Report IFNCC Reg key at the end of VP pipeline.");
406     }
407     else
408     {
409         // Default value
410         m_ctrlValDefault.enableIFNCC = false;
411     }
412 
413     bool bEnableL03DLut = false;
414     eRegKeyReadStatus   = ReadUserSettingForDebug(
415         m_userSettingPtr,
416         bEnableL03DLut,
417         __MEDIA_USER_FEATURE_VALUE_ENABLE_VP_L0_3DLUT,
418         MediaUserSetting::Group::Sequence);
419     if (MOS_SUCCEEDED(eRegKeyReadStatus))
420     {
421         m_ctrlValDefault.bEnableL03DLut = bEnableL03DLut;
422     }
423     else
424     {
425         // Default value
426         m_ctrlValDefault.bEnableL03DLut = false;
427     }
428 
429     bool bForceL0FC   = false;
430     eRegKeyReadStatus = ReadUserSettingForDebug(
431         m_userSettingPtr,
432         bForceL0FC,
433         __MEDIA_USER_FEATURE_VALUE_ENABLE_VP_L0_FC,
434         MediaUserSetting::Group::Sequence);
435     if (MOS_SUCCEEDED(eRegKeyReadStatus))
436     {
437         m_ctrlValDefault.bForceL0FC = bForceL0FC;
438     }
439     else
440     {
441         // Default value
442         m_ctrlValDefault.bForceL0FC = false;
443     }
444 
445     bool bDisableL0FcFp = false;
446     eRegKeyReadStatus   = ReadUserSettingForDebug(
447         m_userSettingPtr,
448         bDisableL0FcFp,
449         __MEDIA_USER_FEATURE_VALUE_DISABLE_VP_L0_FC_FP,
450         MediaUserSetting::Group::Sequence);
451     if (MOS_SUCCEEDED(eRegKeyReadStatus))
452     {
453         m_ctrlValDefault.bDisableL0FcFp = bDisableL0FcFp;
454     }
455     else
456     {
457         // Default value
458         m_ctrlValDefault.bDisableL0FcFp = false;
459     }
460 #endif
461 #if (_DEBUG || _RELEASE_INTERNAL)
462     bool enableSFCLinearOutputByTileConvert = 0;
463     eRegKeyReadStatus   = ReadUserSettingForDebug(
464         m_userSettingPtr,
465         enableSFCLinearOutputByTileConvert,
466         __MEDIA_USER_FEATURE_VALUE_ENABLE_VESFC_LINEAR_OUTPUT_BY_TILECONVERT,
467         MediaUserSetting::Group::Device);
468     if (MOS_SUCCEEDED(eRegKeyReadStatus))
469     {
470         m_ctrlValDefault.enableSFCLinearOutputByTileConvert = enableSFCLinearOutputByTileConvert;
471     }
472     else
473 #endif
474     {
475         auto *waTable = m_osInterface->pfnGetWaTable(m_osInterface);
476         // Default value
477         m_ctrlValDefault.enableSFCLinearOutputByTileConvert = MEDIA_IS_WA(waTable, Wa_15016458807);
478     }
479     VP_PUBLIC_NORMALMESSAGE("enableSFCLinearOutputByTileConvert value is set as %d.", m_ctrlValDefault.enableSFCLinearOutputByTileConvert);
480 
481     return MOS_STATUS_SUCCESS;
482 }
483 
Update(PVP_PIPELINE_PARAMS params)484 MOS_STATUS VpUserFeatureControl::Update(PVP_PIPELINE_PARAMS params)
485 {
486     VP_PUBLIC_CHK_NULL_RETURN(params);
487 
488     m_ctrlVal = m_ctrlValDefault;
489 
490     if (params->bForceToRender)
491     {
492         m_ctrlVal.disableSfc         = true;
493         m_ctrlVal.disableVeboxOutput = true;
494         VP_PUBLIC_NORMALMESSAGE("Disable SFC and vebox output as task is forced to render.");
495     }
496 
497     return MOS_STATUS_SUCCESS;
498 }
499 
GetOcaFeautreControlInfo()500 PMOS_OCA_LOG_USER_FEATURE_CONTROL_INFO VpUserFeatureControl::GetOcaFeautreControlInfo()
501 {
502     if (nullptr == m_pOcaFeatureControlInfo)
503     {
504         m_pOcaFeatureControlInfo = (PMOS_OCA_LOG_USER_FEATURE_CONTROL_INFO)MOS_AllocAndZeroMemory(sizeof(MOS_OCA_LOG_USER_FEATURE_CONTROL_INFO));
505     }
506     return m_pOcaFeatureControlInfo;
507 }
508 
509 
EnableL0FC()510 bool VpUserFeatureControl::EnableL0FC()
511 {
512     bool bEnableL0FC = (m_vpPlatformInterface && m_vpPlatformInterface->SupportL0FC());
513 #if (_DEBUG || _RELEASE_INTERNAL)
514     bEnableL0FC |= m_ctrlVal.bForceL0FC;
515 #endif
516     return bEnableL0FC;
517 }