[VP] Enable 3dLut kernel

Enable 3dLut kernel with L0

media_common/agnostic/common/vp/hal/vp_common_defs.h

@@ -193,6 +193,7 @@ enum VpKernelIDNext
 {
     vpKernelIDNextBase = 0x200,
     kernelHdr3DLutCalc = vpKernelIDNextBase,
+    kernelHdr3DLutCalcL0,
     kernelHVSCalc,
     vpKernelIDNextMax
 };

media_softlet/agnostic/common/vp/hal/feature_manager/sw_filter.cpp

@@ -1298,6 +1298,18 @@ MOS_STATUS SwFilterHdr::Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf,
     uint32_t     dwUpdateMask = 0;
     bool                        bSupported       = false;
     VPHAL_HDR_LUT_MODE          CurrentLUTMode      = VPHAL_HDR_LUT_MODE_NONE;
+    VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface());
+    VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface()->m_userFeatureControl);
+    VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface()->m_vpPlatformInterface);
+    VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface()->m_reporting);
+
+    auto userFeatureControl = m_vpInterface.GetHwInterface()->m_userFeatureControl;
+    auto vpPlatformInterface = m_vpInterface.GetHwInterface()->m_vpPlatformInterface;
+    VpFeatureReport *vpFeatureReport  = dynamic_cast<VpFeatureReport *>(m_vpInterface.GetHwInterface()->m_reporting);
+#if (_DEBUG || _RELEASE_INTERNAL)
+    m_Params.isL0KernelEnabled               = (vpPlatformInterface->IsAdvanceNativeKernelSupported() && userFeatureControl->EnableL03DLut());
+    vpFeatureReport->GetFeatures().isL03DLut = m_Params.isL0KernelEnabled;
+#endif
 
     VP_PUBLIC_CHK_NULL_RETURN(surfInput);
     VP_PUBLIC_CHK_NULL_RETURN(surfOutput);

media_softlet/agnostic/common/vp/hal/feature_manager/sw_filter.h

@@ -882,6 +882,7 @@ struct FeatureParamHdr : public FeatureParam
     uint32_t                uiSplitFramePortions                 = 1;                     //!< Split Frame flag
     bool                    bForceSplitFrame                     = false;
     bool                    bNeed3DSampler                       = false;                 //!< indicate whether 3D should neede by force considering AVS removal etc.
+    bool                    isL0KernelEnabled                    = false;
 
     HDR_PARAMS srcHDRParams    = {};
     HDR_PARAMS targetHDRParams = {};

media_softlet/agnostic/common/vp/hal/feature_manager/vp_kernelset.cpp

@@ -31,6 +31,7 @@
 #include "vp_render_vebox_hvs_kernel.h"
 #include "vp_render_hdr_kernel.h"
 #include "vp_render_l0_fc_kernel.h"
+#include "vp_render_vebox_hdr_3dlut_l0_kernel.h"
 
 using namespace vp;
 
@@ -139,6 +140,11 @@ MOS_STATUS VpKernelSet::CreateSingleKernelObject(
         }
         VP_RENDER_CHK_NULL_RETURN(kernel);
         break;
+    case kernelHdr3DLutCalcL0:
+        VP_RENDER_NORMALMESSAGE("HDR 3dlut kernel use l0 fillLutTable_3dlut kernel");
+        kernel = (VpRenderKernelObj *)MOS_New(VpRenderHdr3DLutL0Kernel, m_hwInterface, m_allocator);
+        VP_RENDER_CHK_NULL_RETURN(kernel);
+        break;
     case kernelHVSCalc:
         kernel = (VpRenderKernelObj *)MOS_New(VpRenderHVSKernel, m_hwInterface, kernelId, kernelIndex, m_allocator);
         VP_RENDER_CHK_NULL_RETURN(kernel);

media_softlet/agnostic/common/vp/hal/features/kernel_args/igvp3dlut_args.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2024, Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+////////////////////////////////////////////////////////////////////////////////
+// !!! WARNING - AUTO GENERATED FILE. DO NOT EDIT DIRECTLY. !!!
+// Generated by KernelBinToSource.exe tool
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __IGVP3DLUT_ENUM_H__
+#define __IGVP3DLUT_ENUM_H__
+
+enum ARGS_3DLUT_FILLLUTTABLE
+{
+    LUT_FILLLUTTABLE_IOLUTINDEX,
+    LUT_FILLLUTTABLE_ICOEFINDEX,
+    LUT_FILLLUTTABLE_LUTSIZE,
+    LUT_FILLLUTTABLE_MULSIZE,
+    LUT_FILLLUTTABLE_PRIVATE_BASE_STATELESS,
+    LUT_FILLLUTTABLE_GLOBAL_ID_OFFSET,
+    LUT_FILLLUTTABLE_LOCAL_SIZE,
+    LUT_FILLLUTTABLE_MAX
+};
+
+#endif // __IGVP3DLUT_ENUM_H__

media_softlet/agnostic/common/vp/hal/features/kernel_args/media_srcs.cmake

@@ -24,6 +24,7 @@ set(TMP_SOURCES_
 
 set(TMP_HEADERS_
     ${CMAKE_CURRENT_LIST_DIR}/igvpfc_scale_args.h
+    ${CMAKE_CURRENT_LIST_DIR}/igvp3dlut_args.h
 )
 
 set(SOFTLET_VP_SOURCES_

media_softlet/agnostic/common/vp/hal/features/vp_filter.h

@@ -357,6 +357,8 @@ struct _RENDER_HDR_3DLUT_CAL_PARAMS
     VpKernelID                      kernelId;
     uint32_t                        threadWidth;
     uint32_t                        threadHeight;
+    uint32_t                        localWidth;
+    uint32_t                        localHeight;
     KERNEL_ARGS                     kernelArgs;
     void                            Init();
 };

media_softlet/agnostic/common/vp/hal/features/vp_hdr_filter.cpp

@@ -28,6 +28,7 @@
 #include "hw_filter.h"
 #include "sw_filter_pipe.h"
 #include "vp_render_cmd_packet.h"
+#include "igvp3dlut_args.h"
 
 namespace vp
 {
@@ -53,7 +54,11 @@ MOS_STATUS VpHdrFilter::Prepare()
 MOS_STATUS VpHdrFilter::Destroy()
 {
     VP_FUNC_CALL();
-
+    for (auto &handle : m_renderHdr3DLutL0Params)
+    {
+        KRN_ARG &krnArg = handle.second;
+        MOS_FreeMemAndSetNull(krnArg.pData);
+    }
     return MOS_STATUS_SUCCESS;
 }
 
@@ -107,35 +112,116 @@ MOS_STATUS VpHdrFilter::CalculateEngineParams(
         m_renderHdr3DLutParams.maxDisplayLum       = hdrParams.uiMaxDisplayLum;
         m_renderHdr3DLutParams.maxContentLevelLum  = hdrParams.uiMaxContentLevelLum;
         m_renderHdr3DLutParams.hdrMode             = hdrParams.hdrMode;
-        m_renderHdr3DLutParams.kernelId            = (VpKernelID)kernelHdr3DLutCalc;
 
         m_renderHdr3DLutParams.threadWidth  = hdrParams.lutSize;
         m_renderHdr3DLutParams.threadHeight = hdrParams.lutSize;
 
-        KRN_ARG krnArg  = {};
-        krnArg.uIndex   = 0;
-        krnArg.eArgKind = ARG_KIND_SURFACE;
-        krnArg.uSize    = 4;
-        krnArg.pData    = &m_surfType3DLut;
-        m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
-
-        krnArg.uIndex   = 1;
-        krnArg.eArgKind = ARG_KIND_SURFACE;
-        krnArg.uSize    = 4;
-        krnArg.pData    = &m_surfType3DLutCoef;
-        m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
-
-        krnArg.uIndex   = 2;
-        krnArg.eArgKind = ARG_KIND_GENERAL;
-        krnArg.uSize    = 2;
-        krnArg.pData    = &m_3DLutSurfaceWidth;
-        m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
-
-        krnArg.uIndex   = 3;
-        krnArg.eArgKind = ARG_KIND_GENERAL;
-        krnArg.uSize    = 2;
-        krnArg.pData    = &m_3DLutSurfaceHeight;
-        m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
+        if (hdrParams.isL0KernelEnabled == false)
+        {
+            KRN_ARG krnArg  = {};
+            krnArg.uIndex   = 0;
+            krnArg.eArgKind = ARG_KIND_SURFACE;
+            krnArg.uSize    = 4;
+            krnArg.pData    = &m_surfType3DLut;
+            m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
+
+            krnArg.uIndex   = 1;
+            krnArg.eArgKind = ARG_KIND_SURFACE;
+            krnArg.uSize    = 4;
+            krnArg.pData    = &m_surfType3DLutCoef;
+            m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
+
+            krnArg.uIndex   = 2;
+            krnArg.eArgKind = ARG_KIND_GENERAL;
+            krnArg.uSize    = 2;
+            krnArg.pData    = &m_3DLutSurfaceWidth;
+            m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
+
+            krnArg.uIndex                   = 3;
+            krnArg.eArgKind                 = ARG_KIND_GENERAL;
+            krnArg.uSize                    = 2;
+            krnArg.pData                    = &m_3DLutSurfaceHeight;
+            m_renderHdr3DLutParams.kernelId = (VpKernelID)kernelHdr3DLutCalc;
+            m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
+        }
+        else
+        {
+            VP_PUBLIC_CHK_NULL_RETURN(m_pvpMhwInterface);
+            VP_PUBLIC_CHK_NULL_RETURN(m_pvpMhwInterface->m_vpPlatformInterface);
+
+            auto handle = m_pvpMhwInterface->m_vpPlatformInterface->GetKernelPool().find("fillLutTable_3dlut");
+            VP_PUBLIC_CHK_NOT_FOUND_RETURN(handle, &m_pvpMhwInterface->m_vpPlatformInterface->GetKernelPool());
+            KERNEL_ARGS kernelArgs             = handle->second.GetKernelArgs();
+            uint32_t    localWidth             = 128;
+            uint32_t    localHeight            = 1;
+            uint32_t    localDepth             = 1;
+            m_renderHdr3DLutParams.localWidth  = localWidth;
+            m_renderHdr3DLutParams.localHeight = localHeight;
+            m_renderHdr3DLutParams.kernelId    = (VpKernelID)kernelHdr3DLutCalcL0;
+
+            //step 1: setting curbe arguments
+            for (auto const &kernelArg : kernelArgs)
+            {
+                uint32_t uIndex    = kernelArg.uIndex;
+                auto     argHandle = m_renderHdr3DLutL0Params.find(uIndex);
+                if (argHandle == m_renderHdr3DLutL0Params.end())
+                {
+                    KRN_ARG krnArg = {};
+                    argHandle      = m_renderHdr3DLutL0Params.insert(std::make_pair(uIndex, krnArg)).first;
+                    VP_PUBLIC_CHK_NOT_FOUND_RETURN(argHandle, &m_renderHdr3DLutL0Params);
+                }
+                KRN_ARG &krnArg = argHandle->second;
+                krnArg.uIndex   = uIndex;
+                bool bInit      = true;
+                if (krnArg.pData == nullptr)
+                {
+                    if (kernelArg.uSize > 0)
+                    {
+                        krnArg.uSize = kernelArg.uSize;
+                        krnArg.pData = MOS_AllocAndZeroMemory(kernelArg.uSize);
+                    }
+                }
+                else
+                {
+                    VP_PUBLIC_CHK_VALUE_RETURN(krnArg.uSize, kernelArg.uSize);
+                    MOS_ZeroMemory(krnArg.pData, krnArg.uSize);
+                }
+                uint16_t mulSize = hdrParams.lutSize == 65 ? 128 : 64;
+                krnArg.eArgKind  = kernelArg.eArgKind;
+                switch (krnArg.uIndex)
+                {
+                case LUT_FILLLUTTABLE_IOLUTINDEX:
+                    VP_PUBLIC_CHK_NULL_RETURN(krnArg.pData);
+                    *(uint32_t *)krnArg.pData = SurfaceType3DLut;
+                    break;
+                case LUT_FILLLUTTABLE_ICOEFINDEX:
+                    VP_PUBLIC_CHK_NULL_RETURN(krnArg.pData);
+                    *(uint32_t *)krnArg.pData = SurfaceType3DLutCoef;
+                    break;
+                case LUT_FILLLUTTABLE_LUTSIZE:
+                    VP_PUBLIC_CHK_NULL_RETURN(krnArg.pData);
+                    MOS_SecureMemcpy(krnArg.pData, kernelArg.uSize, &hdrParams.lutSize, sizeof(uint16_t));
+                    break;
+                case LUT_FILLLUTTABLE_MULSIZE:
+                    VP_PUBLIC_CHK_NULL_RETURN(krnArg.pData);
+                    MOS_SecureMemcpy(krnArg.pData, kernelArg.uSize, &mulSize, sizeof(uint16_t));
+                    break;
+                case LUT_FILLLUTTABLE_LOCAL_SIZE:
+                    VP_PUBLIC_CHK_NULL_RETURN(krnArg.pData);
+                    static_cast<uint32_t *>(krnArg.pData)[0] = localWidth;
+                    static_cast<uint32_t *>(krnArg.pData)[1] = localHeight;
+                    static_cast<uint32_t *>(krnArg.pData)[2] = localDepth;
+                    break;
+                default:
+                    bInit = false;
+                    break;
+                }
+                if (bInit)
+                {
+                    m_renderHdr3DLutParams.kernelArgs.push_back(krnArg);
+                }
+            }
+        }
     }
     else
     {

media_softlet/agnostic/common/vp/hal/features/vp_hdr_filter.h

@@ -243,6 +243,7 @@ class VpHdrFilter : public VpFilter
     VEBOX_HDR_PARAMS m_veboxHdrParams = {};
     RENDER_HDR_3DLUT_CAL_PARAMS m_renderHdr3DLutParams = {};
     RENDER_HDR_PARAMS           m_renderHdrParams      = {};
+    KERNEL_INDEX_ARG_MAP        m_renderHdr3DLutL0Params = {};
     SwFilterPipe                *m_executedPipe        = nullptr;
 
     SurfaceType m_surfType3DLut         = SurfaceType3DLut;

media_softlet/agnostic/common/vp/hal/packet/media_srcs.cmake

@@ -33,6 +33,7 @@ set(TMP_SOURCES_
     ${CMAKE_CURRENT_LIST_DIR}/vp_render_vebox_hvs_kernel.cpp
     ${CMAKE_CURRENT_LIST_DIR}/vp_render_hdr_kernel.cpp
     ${CMAKE_CURRENT_LIST_DIR}/vp_render_l0_fc_kernel.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/vp_render_vebox_hdr_3dlut_l0_kernel.cpp
 )
 
 set(TMP_HEADERS_
@@ -55,6 +56,7 @@ set(TMP_HEADERS_
     ${CMAKE_CURRENT_LIST_DIR}/vp_render_vebox_hvs_kernel.h
     ${CMAKE_CURRENT_LIST_DIR}/vp_render_hdr_kernel.h
     ${CMAKE_CURRENT_LIST_DIR}/vp_render_l0_fc_kernel.h
+    ${CMAKE_CURRENT_LIST_DIR}/vp_render_vebox_hdr_3dlut_l0_kernel.h
 )
 
 set(SOFTLET_VP_SOURCES_

media_softlet/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp

@@ -829,6 +829,12 @@ MOS_STATUS VpRenderCmdPacket::SetupSurfaceState()
         }
         VP_RENDER_CHK_STATUS_RETURN(m_kernel->UpdateCompParams());
     }
+    else
+    {
+        // Reset status
+        m_renderHal->bCmfcCoeffUpdate  = false;
+        m_renderHal->pCmfcCoeffSurface = nullptr;
+    }
 
     return MOS_STATUS_SUCCESS;
 }
@@ -2116,6 +2122,8 @@ MOS_STATUS VpRenderCmdPacket::SetHdr3DLutParams(
     // kernel.GetKernelArgs().
     kernelParams.kernelThreadSpace.uWidth = params->threadWidth;
     kernelParams.kernelThreadSpace.uHeight = params->threadHeight;
+    kernelParams.kernelThreadSpace.uLocalWidth = params->localWidth;
+    kernelParams.kernelThreadSpace.uLocalHeight = params->localHeight;
     kernelParams.kernelArgs = params->kernelArgs;
     kernelParams.syncFlag = true;
     m_renderKernelParams.push_back(kernelParams);

media_softlet/agnostic/common/vp/hal/packet/vp_render_common.h

@@ -72,6 +72,14 @@ enum KRN_ARG_KIND
     ARG_KIND_INLINE                 = 0xa00
 };
 
+enum KRN_ARG_ADDRESSMODE
+{
+    AddressingModeStateful = 0,
+    AddressingModeStateless,
+    AddressingModeBindless,
+    AddressIngModeMax
+};
+
 struct KRN_ARG
 {
     uint32_t               uIndex;
@@ -80,6 +88,7 @@ struct KRN_ARG
     uint32_t               uSize;            // size of arg in byte
     KRN_ARG_KIND           eArgKind;
     bool                   isOutput;
+    KRN_ARG_ADDRESSMODE    addressMode;
 };
 
 //for L0 use only

media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp

@@ -222,11 +222,43 @@ MOS_STATUS VpRenderKernelObj::CpPrepareResources()
     return MOS_STATUS_SUCCESS;
 }
 
+MOS_STATUS VpRenderKernelObj::SetupStatelessBuffer()
+{
+    m_statelessArray.clear();
+    VP_RENDER_NORMALMESSAGE("Not prepare stateless buffer in kernel %d.", m_kernelId);
+    return MOS_STATUS_SUCCESS;
+}
+
+MOS_STATUS VpRenderKernelObj::SetupStatelessBufferResource(SurfaceType surf)
+{
+    VP_RENDER_CHK_NULL_RETURN(m_surfaceGroup);
+    VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
+    if (surf != SurfaceTypeInvalid)
+    {
+        PMOS_INTERFACE osInterface = m_hwInterface->m_osInterface;
+        VP_RENDER_CHK_NULL_RETURN(osInterface);
+        auto           it          = m_surfaceGroup->find(surf);
+        VP_SURFACE    *curSurf     = (m_surfaceGroup->end() != it) ? it->second : nullptr;
+        VP_RENDER_CHK_NULL_RETURN(curSurf);
+        uint64_t ui64GfxAddress = osInterface->pfnGetResourceGfxAddress(osInterface, &curSurf->osSurface->OsResource);
+
+        VP_RENDER_CHK_STATUS_RETURN(osInterface->pfnRegisterResource(
+            osInterface,
+            &curSurf->osSurface->OsResource,
+            false,
+            true));
+        m_statelessArray.insert(std::make_pair(surf, ui64GfxAddress));
+    }
+
+    return MOS_STATUS_SUCCESS;
+}
+
 MOS_STATUS VpRenderKernelObj::SetProcessSurfaceGroup(VP_SURFACE_GROUP &surfaces)
 {
     m_surfaceGroup = &surfaces;
     VP_RENDER_CHK_STATUS_RETURN(SetupSurfaceState());
     VP_RENDER_CHK_STATUS_RETURN(CpPrepareResources());
+    VP_RENDER_CHK_STATUS_RETURN(SetupStatelessBuffer());
     return MOS_STATUS_SUCCESS;
 }