diff --git a/media_driver/agnostic/common/vp/hal/vphal_render_vebox_base.cpp b/media_driver/agnostic/common/vp/hal/vphal_render_vebox_base.cpp
index a0ec85c..bde7eaa 100644
--- a/media_driver/agnostic/common/vp/hal/vphal_render_vebox_base.cpp
+++ b/media_driver/agnostic/common/vp/hal/vphal_render_vebox_base.cpp
@@ -346,7 +346,7 @@
     pVeboxState->SetRenderDisableFlag( pSettings->disableDnDi == false ? false : true );
 
     // Enable/Disable kernel Copy/Update for VEBox
-    pVeboxState->dwKernelUpdate = pSettings->kernelUpdate;
+    pVeboxState->dwKernelUpdate       = pSettings->kernelUpdate;
 
     // Setup Same Sample Threshold for VEBOX
     pVeboxState->iSameSampleThreshold = pSettings->sameSampleThreshold;
diff --git a/media_driver/media_driver_next/agnostic/common/shared/packet/media_render_cmd_packet.cpp b/media_driver/media_driver_next/agnostic/common/shared/packet/media_render_cmd_packet.cpp
index 1ae755c..63c08da 100644
--- a/media_driver/media_driver_next/agnostic/common/shared/packet/media_render_cmd_packet.cpp
+++ b/media_driver/media_driver_next/agnostic/common/shared/packet/media_render_cmd_packet.cpp
@@ -260,9 +260,6 @@
         m_renderHal,
         &m_bindingTable));
 
-    // Reset a new Binding index from start
-    m_bindingTableEntry = 0;
-
     // load kernels before packet submit PipeLine to load kernel
 
     return MOS_STATUS_SUCCESS;
@@ -355,6 +352,7 @@
 
 uint32_t RenderCmdPacket::SetSurfaceForHwAccess(PMOS_SURFACE surface, PRENDERHAL_SURFACE_NEXT pRenderSurface, PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams, bool bWrite)
 {
+
     PMOS_INTERFACE                  pOsInterface;
     PRENDERHAL_SURFACE_STATE_ENTRY  pSurfaceEntries[MHW_MAX_SURFACE_PLANES];
     int32_t                         iSurfaceEntries;
@@ -425,133 +423,6 @@
     return iBTEntry;
 }
 
-uint32_t RenderCmdPacket::SetSurfaceForHwAccess(
-    PMOS_SURFACE                    surface, 
-    PRENDERHAL_SURFACE_NEXT         pRenderSurface, 
-    PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams, 
-    uint32_t                        bindingIndex, 
-    bool                            bWrite)
-{
-    PMOS_INTERFACE                  pOsInterface;
-    PRENDERHAL_SURFACE_STATE_ENTRY  pSurfaceEntries[MHW_MAX_SURFACE_PLANES];
-    int32_t                         iSurfaceEntries;
-    int32_t                         i;
-    MOS_STATUS                      eStatus;
-    RENDERHAL_SURFACE_STATE_PARAMS  surfaceParams;
-
-    // Initialize Variables
-    eStatus = MOS_STATUS_SUCCESS;
-    pOsInterface = m_osInterface;
-
-    RENDER_PACKET_CHK_NULL_RETURN(pRenderSurface);
-    RENDER_PACKET_CHK_NULL_RETURN(pOsInterface);
-
-    // Register surfaces for rendering (GfxAddress/Allocation index)
-    // Register resource
-    RENDER_PACKET_CHK_STATUS_RETURN(m_osInterface->pfnRegisterResource(
-        m_osInterface,
-        &surface->OsResource,
-        bWrite,
-        true));
-
-    if (!pSurfaceParams)
-    {
-        MOS_ZeroMemory(&surfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
-        pSurfaceParams = &surfaceParams;
-    }
-
-    pSurfaceParams->Type = m_renderHal->SurfaceTypeDefault;
-
-    RENDER_PACKET_CHK_STATUS_RETURN(InitRenderHalSurface(
-        *surface,
-        pRenderSurface));
-
-    if (bWrite)
-    {
-        pRenderSurface->SurfType = RENDERHAL_SURF_OUT_RENDERTARGET;
-    }
-
-    // Setup surface states-----------------------------------------------------
-    RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnSetupSurfaceState(
-        m_renderHal,
-        pRenderSurface,
-        pSurfaceParams,
-        &iSurfaceEntries,  // for most cases, surface entry should only take 1 entry, need align with kerenl design
-        pSurfaceEntries,
-        nullptr));
-
-    uint32_t iBTEntry = bindingIndex;
-    // Bind surface states------------------------------------------------------
-    for (i = 0; i < iSurfaceEntries; i++, iBTEntry++)
-    {
-        RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnBindSurfaceState(
-            m_renderHal,
-            m_bindingTable,
-            iBTEntry,
-            pSurfaceEntries[i]));
-
-        pRenderSurface->Index = iBTEntry;
-    }
-
-    return bindingIndex;
-}
-
-uint32_t RenderCmdPacket::SetBufferForHwAccess(PMOS_SURFACE buffer, PRENDERHAL_SURFACE_NEXT pRenderSurface, PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams, bool bWrite)
-{
-    RENDERHAL_SURFACE                   RenderHalSurface;
-    RENDERHAL_SURFACE_STATE_PARAMS      SurfaceParam;
-    PRENDERHAL_SURFACE_STATE_ENTRY      pSurfaceEntry;
-
-    RENDER_PACKET_CHK_NULL_RETURN(m_osInterface);
-    RENDER_PACKET_CHK_NULL_RETURN(m_osInterface->osCpInterface);
-    RENDER_PACKET_CHK_NULL_RETURN(buffer);
-
-    MOS_ZeroMemory(&RenderHalSurface, sizeof(RenderHalSurface));
-
-    // not support CP yet
-    if (m_osInterface->osCpInterface->IsHMEnabled())
-    {
-        RENDER_PACKET_ASSERTMESSAGE("ERROR, need to use VpHal_CommonSetBufferSurfaceForHwAccess if under CP HM.");
-    }
-
-    // Register surfaces for rendering (GfxAddress/Allocation index)
-    // Register resource
-    RENDER_PACKET_CHK_STATUS_RETURN(m_osInterface->pfnRegisterResource(
-        m_osInterface,
-        &buffer->OsResource,
-        bWrite,
-        true));
-
-    // Setup Buffer surface-----------------------------------------------------
-    if (pSurfaceParams == nullptr)
-    {
-        MOS_ZeroMemory(&SurfaceParam, sizeof(SurfaceParam));
-        pSurfaceParams = &SurfaceParam;
-    }
-
-    RENDER_PACKET_CHK_STATUS_RETURN(InitRenderHalSurface(
-        *buffer,
-        &RenderHalSurface));
-
-    RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnSetupBufferSurfaceState(
-        m_renderHal,
-        &RenderHalSurface,
-        pSurfaceParams,
-        &pSurfaceEntry));
-
-    // Bind surface state-------------------------------------------------------
-    RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnBindSurfaceState(
-        m_renderHal,
-        m_bindingTable,
-        m_bindingTableEntry,
-        pSurfaceEntry));
-
-    pRenderSurface->Index = m_bindingTableEntry;
-
-    m_bindingTableEntry++;
-    return pRenderSurface->Index;
-}
-
 uint32_t RenderCmdPacket::SetBufferForHwAccess(MOS_BUFFER buffer, PRENDERHAL_SURFACE_NEXT pRenderSurface, PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams, bool bWrite)
 {
     RENDERHAL_SURFACE                   RenderHalSurface;
@@ -561,8 +432,6 @@
     RENDER_PACKET_CHK_NULL_RETURN(m_osInterface);
     RENDER_PACKET_CHK_NULL_RETURN(m_osInterface->osCpInterface);
 
-    MOS_ZeroMemory(&RenderHalSurface, sizeof(RenderHalSurface));
-
     // not support CP yet
     if (m_osInterface->osCpInterface->IsHMEnabled())
     {
@@ -822,17 +691,18 @@
     {
         pRenderSurface->OsSurface = surface;
     }
-
     return MOS_STATUS_SUCCESS;
 }
 
-MOS_STATUS RenderCmdPacket::InitRenderHalBuffer(MOS_BUFFER surface, PRENDERHAL_SURFACE pRenderSurface)
+MOS_STATUS RenderCmdPacket::InitRenderHalBuffer(MOS_BUFFER pSurface, PRENDERHAL_SURFACE pRenderSurface)
 {
     RENDER_PACKET_CHK_NULL_RETURN(pRenderSurface);
-    pRenderSurface->OsSurface.OsResource         = surface.OsResource;
-    pRenderSurface->OsSurface.dwWidth            = surface.size;
+    pRenderSurface->OsSurface.OsResource = pSurface.OsResource;
+
+    pRenderSurface->OsSurface.OsResource         = pSurface.OsResource;
+    pRenderSurface->OsSurface.dwWidth            = pSurface.size;
     pRenderSurface->OsSurface.dwHeight           = 1;
-    pRenderSurface->OsSurface.dwPitch            = surface.size;
+    pRenderSurface->OsSurface.dwPitch            = pSurface.size;
     pRenderSurface->OsSurface.Format             = Format_RAW;
 
     return MOS_STATUS_SUCCESS;
diff --git a/media_driver/media_driver_next/agnostic/common/shared/packet/media_render_cmd_packet.h b/media_driver/media_driver_next/agnostic/common/shared/packet/media_render_cmd_packet.h
index 952da4d..0bc3c28 100644
--- a/media_driver/media_driver_next/agnostic/common/shared/packet/media_render_cmd_packet.h
+++ b/media_driver/media_driver_next/agnostic/common/shared/packet/media_render_cmd_packet.h
@@ -146,7 +146,6 @@
     // 2 VEBOX KERNELS
     VeboxSecureBlockCopy,
     VeboxUpdateDnState,
-    VeboxKernelMax,
 
     // User Ptr
     UserPtr,
@@ -194,20 +193,6 @@
         PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
         bool                            bWrite);
 
-    // Step3: RSS Setup with fixed binding index, return index insert in binding table
-    virtual uint32_t SetSurfaceForHwAccess(
-        PMOS_SURFACE                     surface,
-        PRENDERHAL_SURFACE_NEXT         pRenderSurface,
-        PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
-        uint32_t                        bindingIndex,
-        bool                            bWrite);
-
-    virtual uint32_t SetBufferForHwAccess(
-        PMOS_SURFACE                        buffer,
-        PRENDERHAL_SURFACE_NEXT             pRenderSurface,
-        PRENDERHAL_SURFACE_STATE_PARAMS     pSurfaceParams,
-        bool                                bWrite);
-
     virtual uint32_t SetBufferForHwAccess(
         MOS_BUFFER                          buffer,
         PRENDERHAL_SURFACE_NEXT             pRenderSurface,
@@ -222,10 +207,7 @@
         uint32_t  maximumNumberofThreads = 0);
 
     // Step6: different kernel have different media walker settings
-    virtual MOS_STATUS SetupMediaWalker()
-    {
-        return MOS_STATUS_SUCCESS;
-    }
+    virtual MOS_STATUS SetupMediaWalker() = 0;
 
     MOS_STATUS PrepareMediaWalkerParams(KERNEL_WALKER_PARAMS params, MHW_WALKER_PARAMS& mediaWalker);
 
@@ -238,11 +220,11 @@
 
     // for VPP usage, there are more data need to updated, create as virtual for future inplemention in VPP
     virtual MOS_STATUS InitRenderHalSurface(
-        MOS_SURFACE        surface,
+        MOS_SURFACE        pSurface,
         PRENDERHAL_SURFACE pRenderSurface);
 
     virtual MOS_STATUS InitRenderHalBuffer(
-        MOS_BUFFER         surface,
+        MOS_BUFFER         pSurface,
         PRENDERHAL_SURFACE pRenderSurface);
 
     MOS_STATUS InitKernelEntry();
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_allocator.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_allocator.cpp
index 0071d3f..0be2b08 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_allocator.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_allocator.cpp
@@ -434,8 +434,7 @@
     {
         // VP_SURFACE should always be allocated by interface in VpAllocator,
         // which will ensure nullptr != surface->osSurface.
-        VP_PUBLIC_NORMALMESSAGE("Surfaces already been deleted, return status!");
-        return status;
+        VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
     }
 
     if (surface->isResourceOwner)
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.cpp
index 9fdba55..1217c54 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.cpp
@@ -319,7 +319,7 @@
 {
     surfSetting.Clean();
 
-    if (caps.bVebox || caps.bDnKernelUpdate)
+    if (caps.bVebox)
     {
         // Create Vebox Resources
         VP_PUBLIC_CHK_STATUS_RETURN(AssignVeboxResource(caps, inputSurface, outputSurface, pastSurface, futureSurface, resHint, surfSetting));
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/hw_filter.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/hw_filter.cpp
index d009a44..18ecfc3 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/hw_filter.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/hw_filter.cpp
@@ -168,29 +168,5 @@
 
 MOS_STATUS HwFilterRender::SetPacketParams(VpCmdPacket &packet)
 {
-    bool bRet = true;
-
-    PVPHAL_SURFACE pSrcSurface    = nullptr;
-    PVPHAL_SURFACE pOutputSurface = nullptr;
-
-    // Remove dependence on vphal surface later.
-    VP_PUBLIC_CHK_NULL_RETURN(m_swFilterPipe);
-    VP_SURFACE* inputSurf  = m_swFilterPipe->GetSurface(true, 0);
-    VP_SURFACE* outputSurf = m_swFilterPipe->GetSurface(false, 0);
-    // previousSurf can be nullptr;
-    VP_SURFACE* previousSurf = m_swFilterPipe->GetPastSurface(0);
-    auto& surfSetting        = m_swFilterPipe->GetSurfacesSetting();
-    VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
-    VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
-    VP_PUBLIC_CHK_STATUS_RETURN(packet.PacketInit(inputSurf, outputSurf,
-        previousSurf, surfSetting, m_vpExecuteCaps));
-
-    for (auto handler : m_Params.Params)
-    {
-        if (handler)
-        {
-            bRet = handler->SetPacketParam(&packet) && bRet;
-        }
-    }
-    return bRet ? MOS_STATUS_SUCCESS : MOS_STATUS_UNKNOWN;
+    return MOS_STATUS_SUCCESS;
 }
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.cpp
index a7df810..d75813b 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.cpp
@@ -1146,20 +1146,7 @@
         auto it = m_RenderFeatureHandlers.begin();
         for (; it != m_RenderFeatureHandlers.end(); ++it)
         {
-            if ((*(it->second)).IsFeatureEnabled(caps))
-            {
-                HwFilterParameter* pHwFilterParam = (*(it->second)).CreateHwFilterParam(caps, *params.executedFilters, m_vpInterface.GetHwInterface());
 
-                if (pHwFilterParam)
-                {
-                    params.Params.push_back(pHwFilterParam);
-                }
-                else
-                {
-                    VP_PUBLIC_ASSERTMESSAGE("Create HW Filter Failed, Return Error");
-                    return MOS_STATUS_NO_SPACE;
-                }
-            }
         }
     }
 
@@ -1306,10 +1293,6 @@
             VP_PUBLIC_CHK_STATUS_RETURN(params.executedFilters->AddSurface(surfOutput, false, 0));
         }
     }
-    else if (featurePipe.GetSecureProcessFlag())
-    {
-        VP_PUBLIC_CHK_STATUS_RETURN(UpdateSecureExecuteResource(featurePipe, caps, params));
-    }
     else
     {
         VP_PUBLIC_ASSERTMESSAGE("Output is not empty, featurePipe.IsPrimaryEmpty() = %d", featurePipe.IsPrimaryEmpty());
@@ -1441,8 +1424,8 @@
         return false;
     }
 
-    if (!m_vpInterface.GetHwInterface()->m_osInterface ||
-        !m_vpInterface.GetHwInterface()->m_osInterface->osCpInterface)
+    if (!(m_vpInterface.GetHwInterface()->m_osInterface &&
+          m_vpInterface.GetHwInterface()->m_osInterface->osCpInterface))
     {
         VP_PUBLIC_ASSERTMESSAGE("No CP Interface Available");
         return false;
@@ -1453,14 +1436,10 @@
     // Place holder: DDI can also have conditions for Kernel resource using
     if (!featurePipe.GetSecureProcessFlag() && caps.bVebox && cpInterface->IsHMEnabled())
     {
+        featurePipe.SetSecureProcessFlag(true);
         return true;
     }
 
-    if (featurePipe.GetSecureProcessFlag())
-    {
-        featurePipe.SetSecureProcessFlag(false);
-    }
-
     return false;
 }
 
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.h
index bdf5525..bcca409 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.h
@@ -115,10 +115,6 @@
     MOS_STATUS AssignExecuteResource(VP_EXECUTE_CAPS& caps, HW_FILTER_PARAMS& params);
 
     bool IsVeboxSecurePathEnabled(SwFilterPipe& subSwFilterPipe, VP_EXECUTE_CAPS& caps);
-    virtual MOS_STATUS UpdateSecureExecuteResource(SwFilterPipe& featurePipe, VP_EXECUTE_CAPS& caps, HW_FILTER_PARAMS& params)
-    {
-        return MOS_STATUS_SUCCESS;
-    }
 
     std::map<FeatureType, PolicyFeatureHandler*> m_VeboxSfcFeatureHandlers;
     std::map<FeatureType, PolicyFeatureHandler*> m_RenderFeatureHandlers;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.h
index e4a87f6..a615366 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.h
@@ -59,8 +59,7 @@
     FeatureTypeSteOnVebox,
     FeatureTypeAce              = 0x700,
     FeatureTypeAceOnVebox,
-    FeatureTypeVeboxUpdate      = 0x800,
-    FeatureTypeVeboxUpdateOnRender,
+    FeatureTypeSecureVeboxUpdate = 0x800,
     FeatureTypeTcc              = 0x900,
     FeatureTypeTccOnVebox,
     FeatureTypeProcamp          = 0xA00,
@@ -73,8 +72,6 @@
     FeatureTypeFD               = 0xD00,
     FeatureTypeFLD              = 0xE00,
     FeatureTypeFB               = 0xF00,
-    FeatureTypeSecureCopy      = 0x1000,
-    FeatureTypeSecureCopyOnRender,
     // ...
     NumOfFeatureType
 };
@@ -184,7 +181,7 @@
         return MOS_STATUS_UNIMPLEMENTED;
     }
 
-    virtual MOS_STATUS Configure(SwFilter& swFilter, VP_EXECUTE_CAPS caps)
+    virtual MOS_STATUS Configure(SwFilter* swFilter, VP_EXECUTE_CAPS caps)
     {
         return MOS_STATUS_UNIMPLEMENTED;
     }
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_kernelset.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_kernelset.h
index 705715d..356df8e 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_kernelset.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_kernelset.h
@@ -44,14 +44,11 @@
 struct RENDER_KERNEL_PARAMS
 {
     std::map<SurfaceType, VP_SURFACE*> *surfacesGroup;
-    std::vector<uint32_t>* kernelId;
+    std::vector<KernelId>* kernelId;
 };
 
 typedef std::map<KernelId, VpRenderKernelObj*> KERNEL_OBJECTS;
 
-typedef std::map<KernelId, void*> KERNEL_CONFIGS;
-typedef std::map<KernelId, KERNEL_PACKET_RENDER_DATA> KERNEL_RENDER_DATA;
-
 class VpKernelSet
 {
 public:
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_filter.h b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_filter.h
index 815e560..a7c8fc0 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_filter.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_filter.h
@@ -245,6 +245,14 @@
     uint32_t                        chromaDownSamplingHorizontalCoef;            // Chroma DownSampling Horizontal Coeff
 };
 
+struct _VEBOX_UPDATE_PARAMS
+{
+    bool                            bSecureCopyVeboxState;
+    bool                            bDnEnabled;
+    bool                            bAutoDetect;
+    VPHAL_NOISELEVEL                NoiseLevel;
+};
+
 struct _VEBOX_HDR_PARAMS
 {
     uint32_t                        uiMaxDisplayLum;       //!< Maximum Display Luminance
@@ -277,14 +285,6 @@
 using PVEBOX_PROCAMP_PARAMS = VEBOX_PROCAMP_PARAMS *;
 using VEBOX_CSC_PARAMS      = _VEBOX_CSC_PARAMS;
 using PVEBOX_CSC_PARAMS     = VEBOX_CSC_PARAMS *;
-
-struct _VEBOX_UPDATE_PARAMS
-{
-    VEBOX_DN_PARAMS                 denoiseParams;
-    VP_EXECUTE_CAPS                 veboxExecuteCaps;
-    std::vector<uint32_t>           kernelGroup;
-};
-
 using VEBOX_UPDATE_PARAMS      = _VEBOX_UPDATE_PARAMS;
 using PVEBOX_UPDATE_PARAMS     = VEBOX_UPDATE_PARAMS *;
 using VEBOX_HDR_PARAMS      = _VEBOX_HDR_PARAMS;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_cmd_packet.h b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_cmd_packet.h
index 3727c67..38ece2c 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_cmd_packet.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_cmd_packet.h
@@ -63,11 +63,6 @@
         return MOS_STATUS_SUCCESS;
     };
 
-    virtual MOS_STATUS PrepareState()
-    {
-        return MOS_STATUS_SUCCESS;
-    };
-
     PacketType GetPacketId()
     {
         return m_PacketId;
@@ -101,10 +96,9 @@
     PacketType                  m_PacketId = VP_PIPELINE_PACKET_UNINITIALIZED;
     VP_PACKET_SHARED_CONTEXT*   m_packetSharedContext = nullptr;
     VP_SURFACE_SETTING          m_surfSetting;
-    bool                        m_packetResourcesdPrepared = false;
 
 private:
-    MediaScalability *          m_scalability = nullptr;
+    MediaScalability *m_scalability = nullptr;
 };
 }
 #endif // !__VP_CMD_PACKET_H__
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_packet_pipe.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_packet_pipe.cpp
index 81cbdec..87286ce 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_packet_pipe.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_packet_pipe.cpp
@@ -220,13 +220,6 @@
 
 MOS_STATUS PacketPipe::Execute(MediaStatusReport *statusReport, MediaScalability *&scalability, MediaContext *mediaContext, bool bEnableVirtualEngine, uint8_t numVebox)
 {
-    // PrePare Packet in case any packet resources shared
-    for (std::vector<VpCmdPacket*>::reverse_iterator it = m_Pipe.rbegin(); it != m_Pipe.rend(); ++it)
-    {
-        VpCmdPacket* packet = *it;
-        VP_PUBLIC_CHK_STATUS_RETURN(packet->PrepareState());
-    }
-
     for (std::vector<VpCmdPacket *>::iterator it = m_Pipe.begin(); it != m_Pipe.end(); ++it)
     {
         VpCmdPacket *pPacket = *it;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp
index 7ac011a..3025a53 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp
@@ -68,12 +68,6 @@
     VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
     VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_vpPlatformInterface);
 
-    if (m_packetResourcesdPrepared)
-    {
-        VP_RENDER_NORMALMESSAGE("Resource Prepared, skip this time");
-        return MOS_STATUS_SUCCESS;
-    }
-
     m_PacketId = VP_PIPELINE_PACKET_RENDER;
 
     //m_kernelCount = IDR_VP_TOTAL_NUM_KERNELS;
@@ -87,25 +81,16 @@
     // for multi-kernel prepare together
     for (auto it = m_kernelObjs.begin(); it != m_kernelObjs.end(); it++)
     {
-        void* kernelParams = nullptr;
-        KernelId kernelExecuteID = it->first;
-        m_kernel                 = it->second;
+        m_kernel = it->second;
 
         VP_RENDER_CHK_NULL_RETURN(m_kernel);
 
-        if (m_kernelConfigs.find(kernelExecuteID) != m_kernelConfigs.end())
-        {
-            kernelParams = m_kernelConfigs.find(kernelExecuteID)->second;
-        }
-
-        m_kernel->SetKernelConfigs(kernelParams);
-
         // reset render Data for current kernel
         MOS_ZeroMemory(&m_renderData, sizeof(m_renderData));
 
         VP_RENDER_CHK_STATUS_RETURN(RenderEngineSetup());
 
-        VP_RENDER_CHK_STATUS_RETURN(KernelStateSetup((KernelID)kernelExecuteID));
+        VP_RENDER_CHK_STATUS_RETURN(KernelStateSetup());
 
         VP_RENDER_CHK_STATUS_RETURN(SetupSurfaceState()); // once Surface setup done, surface index should be created here
 
@@ -113,12 +98,8 @@
 
         VP_RENDER_CHK_STATUS_RETURN(LoadKernel());
 
-        m_kernelRenderData.insert(std::make_pair(kernelExecuteID, m_renderData));
-
     }
 
-    m_packetResourcesdPrepared = true;
-
     return MOS_STATUS_SUCCESS;
 }
 
@@ -132,17 +113,7 @@
     // for multi-kernel submit in one BB for prepared kernels
     for (auto it = m_kernelObjs.begin(); it != m_kernelObjs.end(); it++)
     {
-        KernelId kernelExecuteID = it->first;
-        VpRenderKernelObj* kernel = it->second;
-
-        VP_RENDER_CHK_NULL_RETURN(kernel);
-
-        if (m_kernelRenderData.find(kernelExecuteID) != m_kernelRenderData.end())
-        {
-            m_renderData = m_kernelRenderData.find(kernelExecuteID)->second;
-        }
-
-        VP_RENDER_CHK_STATUS_RETURN(SetupMediaWalker(kernel));
+        VP_RENDER_CHK_STATUS_RETURN(SetupMediaWalker());
 
         VP_RENDER_CHK_STATUS_RETURN(RenderCmdPacket::Submit(commandBuffer, packetPhase));
     }
@@ -154,29 +125,9 @@
 
 MOS_STATUS VpRenderCmdPacket::SetVeboxUpdateParams(PVEBOX_UPDATE_PARAMS params)
 {
-    VP_RENDER_CHK_NULL_RETURN(params);
-
-    if (params->kernelGroup.empty())
-    {
-        VP_RENDER_ASSERTMESSAGE("No Kernel need to be processed");
-        return MOS_STATUS_INVALID_PARAMETER;
-    }
-
-    for (auto it : params->kernelGroup)
-    {
-        uint32_t kernel = it;
-        m_kernelId.push_back(kernel);
-        m_kernelConfigs.insert(std::make_pair((KernelId)kernel, (void*)params));
-    }
-
     return MOS_STATUS_SUCCESS;
 }
 
-MOS_STATUS VpRenderCmdPacket::SetSecureCopyParams(bool copyNeeded)
-{
-    return MOS_STATUS();
-}
-
 MOS_STATUS VpRenderCmdPacket::PacketInit(
     VP_SURFACE* inputSurface, 
     VP_SURFACE* outputSurface, 
@@ -190,15 +141,11 @@
     VP_UNUSED(previousSurface);
 
     m_PacketCaps    = packetCaps;
-
-    // Init packet surface params.
-    m_surfSetting = surfSetting;
-
-    m_packetResourcesdPrepared = false;
+    m_surfSetting   = surfSetting;
     return MOS_STATUS_SUCCESS;
 }
 
-MOS_STATUS VpRenderCmdPacket::KernelStateSetup(KernelID kernelExecuteID)
+MOS_STATUS VpRenderCmdPacket::KernelStateSetup()
 {
     if (m_kernelId.empty())
     {
@@ -218,7 +165,7 @@
     MOS_ZeroMemory(&m_renderData.KernelEntry, sizeof(Kdll_CacheEntry));
 
     // Store pointer to Kernel Parameter
-    VP_RENDER_CHK_STATUS_RETURN(m_kernel->GetKernelSettings(m_renderData.KernelParam, kernelExecuteID));
+    VP_RENDER_CHK_STATUS_RETURN(m_kernel->GetKernelSettings(m_renderData.KernelParam));
     VP_RENDER_CHK_STATUS_RETURN(m_kernel->GetKernelID(iKUID));
     kernelSize   = m_kernel->GetKernelSize();
     kernelBinary = m_kernel->GetKernelBinary();
@@ -245,92 +192,52 @@
 {
     VP_RENDER_CHK_NULL_RETURN(m_kernel);
 
-    VP_RENDER_CHK_STATUS_RETURN(m_kernel->SetProcessSurface(m_surfSetting.surfGroup));
-
-    if (!m_kernel->GetKernelSurfaceConfig().empty())
+    for (auto it : m_kernel->GetProcessingSurfaces())
     {
-        for (auto surface = m_kernel->GetKernelSurfaceConfig().begin(); surface != m_kernel->GetKernelSurfaceConfig().end(); surface++)
+        auto surface = m_kernel->GetKernelSurfaceConfig().find(it);
+
+        if (surface != m_kernel->GetKernelSurfaceConfig().end())
         {
-            KERNEL_SURFACE2D_STATE_PARAM *kernelSurfaceParam = &surface->second;
-            SurfaceType type = surface->first;
+            KERNEL_SURFACE2D_STATE_PARAM kernelSurfaceParam = surface->second;
 
             RENDERHAL_SURFACE_NEXT renderHalSurface;
             MOS_ZeroMemory(&renderHalSurface, sizeof(RENDERHAL_SURFACE_NEXT));
 
             RENDERHAL_SURFACE_STATE_PARAMS renderSurfaceParams;
             MOS_ZeroMemory(&renderSurfaceParams, sizeof(RENDERHAL_SURFACE_STATE_PARAMS));
-            if (kernelSurfaceParam->surfaceOverwriteParams.updatedRenderSurfaces)
+            if (kernelSurfaceParam.surfaceOverwriteParams.updatedSurfaceParams)
             {
-                renderSurfaceParams = kernelSurfaceParam->surfaceOverwriteParams.renderSurfaceParams;
+                renderSurfaceParams = kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams;
             }
             else
             {
-                renderSurfaceParams.bRenderTarget    = (kernelSurfaceParam->renderTarget == true) ? 1 : 0;
+                renderSurfaceParams.bRenderTarget    = (kernelSurfaceParam.renderTarget == true) ? 1 : 0;
                 renderSurfaceParams.Boundary         = RENDERHAL_SS_BOUNDARY_ORIGINAL; // Add conditional in future for Surfaces out of range
                 renderSurfaceParams.bWidth16Align    = false;
                 renderSurfaceParams.bWidthInDword_Y  = true;
                 renderSurfaceParams.bWidthInDword_UV = true;
             }
 
-            VP_SURFACE* vpSurface = nullptr;
+            VP_SURFACE* vpSurface = m_surfSetting.surfGroup.find(it)->second;
 
-            if (m_surfSetting.surfGroup.find(type) != m_surfSetting.surfGroup.end())
-            {
-                vpSurface = m_surfSetting.surfGroup.find(type)->second;
-            }
-            else
-            {
-                vpSurface = nullptr;
-            }
+            VP_RENDER_CHK_NULL_RETURN(vpSurface);
 
-            if (vpSurface)
-            {
-                // Prepare surfaces tracked in Resource manager
-                VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurface(*vpSurface, renderHalSurface));
-            }
-            else
-            {
-                // State Heaps are not tracked in resource manager till now
-                VP_RENDER_CHK_STATUS_RETURN(InitStateHeapSurface(type, renderHalSurface));
-            }
+            VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurface(*vpSurface, renderHalSurface));
 
-            VP_RENDER_CHK_STATUS_RETURN(UpdateRenderSurface(renderHalSurface, *kernelSurfaceParam));
+            VP_RENDER_CHK_STATUS_RETURN(UpdateRenderSurface(renderHalSurface, kernelSurfaceParam));
 
-            uint32_t index = 0;
+            uint32_t index = SetSurfaceForHwAccess(
+                vpSurface->osSurface,
+                &renderHalSurface,
+                &renderSurfaceParams,
+                renderSurfaceParams.bRenderTarget);
 
-            if (kernelSurfaceParam->surfaceOverwriteParams.bindedKernel)
-            {
-                index = SetSurfaceForHwAccess(
-                    &renderHalSurface.OsSurface,
-                    &renderHalSurface,
-                    &renderSurfaceParams,
-                    kernelSurfaceParam->surfaceOverwriteParams.bindIndex,
-                    renderSurfaceParams.bRenderTarget);
-            }
-            else
-            {
-                if ((kernelSurfaceParam->surfaceOverwriteParams.updatedSurfaceParams  &&
-                     kernelSurfaceParam->surfaceOverwriteParams.bufferResource)       ||
-                    (!kernelSurfaceParam->surfaceOverwriteParams.updatedSurfaceParams &&
-                      renderHalSurface.OsSurface.Type == MOS_GFXRES_BUFFER))
-                {
-                    index = SetBufferForHwAccess(
-                        &renderHalSurface.OsSurface,
-                        &renderHalSurface,
-                        &renderSurfaceParams,
-                        renderSurfaceParams.bRenderTarget);
-                }
-                else
-                {
-                    index = SetSurfaceForHwAccess(
-                        &renderHalSurface.OsSurface,
-                        &renderHalSurface,
-                        &renderSurfaceParams,
-                        renderSurfaceParams.bRenderTarget);
-                }
-            }
-
-            VP_RENDER_CHK_STATUS_RETURN(m_kernel->UpdateCurbeBindingIndex(type, index));
+            VP_RENDER_CHK_STATUS_RETURN(m_kernel->UpdateCurbeBindingIndex(it, index));
+        }
+        else
+        {
+            VP_RENDER_ASSERTMESSAGE("Kernel Obj Issue: Didn't find correct kernel surface here, return error");
+            return MOS_STATUS_UNIMPLEMENTED;
         }
     }
 
@@ -363,23 +270,22 @@
     return surf;
 }
 
-MOS_STATUS VpRenderCmdPacket::SetupMediaWalker(VpRenderKernelObj* kernel)
+MOS_STATUS VpRenderCmdPacket::SetupMediaWalker()
 {
-    VP_RENDER_CHK_NULL_RETURN(kernel);
+    VP_RENDER_CHK_NULL_RETURN(m_kernel);
 
-    VP_RENDER_CHK_STATUS_RETURN(kernel->GetWalkerSetting(m_renderData.walkerParam));
-
-    MOS_ZeroMemory(&m_mediaWalkerParams, sizeof(MHW_WALKER_PARAMS));
-    MOS_ZeroMemory(&m_gpgpuWalkerParams, sizeof(MHW_GPGPU_WALKER_PARAMS));
+    VP_RENDER_CHK_STATUS_RETURN(m_kernel->GetWalkerSetting(m_renderData.walkerParam));
 
     switch (m_walkerType)
     {
     case WALKER_TYPE_MEDIA:
+        MOS_ZeroMemory(&m_mediaWalkerParams, sizeof(MHW_WALKER_PARAMS));
         // Prepare Media Walker Params
         VP_RENDER_CHK_STATUS_RETURN(PrepareMediaWalkerParams(m_renderData.walkerParam, m_mediaWalkerParams));
         break;
     case WALKER_TYPE_COMPUTE:
         // Parepare Compute Walker Param
+        MOS_ZeroMemory(&m_gpgpuWalkerParams, sizeof(MHW_GPGPU_WALKER_PARAMS));
         VP_RENDER_CHK_STATUS_RETURN(PrepareComputeWalkerParams(m_renderData.walkerParam, m_gpgpuWalkerParams));
         break;
     case WALKER_TYPE_DISABLED:
@@ -403,41 +309,6 @@
 
     return MOS_STATUS_SUCCESS;
 }
-MOS_STATUS VpRenderCmdPacket::InitStateHeapSurface(SurfaceType type, RENDERHAL_SURFACE& renderSurface)
-{
-    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
-
-    MOS_SURFACE mosSurface;
-
-    MOS_ZeroMemory(&mosSurface, sizeof(MOS_SURFACE));
-
-    // Check for Vebox Heap readiness
-    const MHW_VEBOX_HEAP* pVeboxHeap = nullptr;
-    VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
-    VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_veboxInterface);
-
-    VP_RENDER_CHK_STATUS_RETURN(m_hwInterface->m_veboxInterface->GetVeboxHeapInfo(
-        &pVeboxHeap));
-    VP_RENDER_CHK_NULL_RETURN(pVeboxHeap);
-
-    switch (type)
-    {
-    case SurfaceTypeVeboxStateHeap_Drv:
-        mosSurface.OsResource = pVeboxHeap->DriverResource;
-        break;
-    case SurfaceTypeVeboxStateHeap_Knr:
-        mosSurface.OsResource = pVeboxHeap->KernelResource;
-        break;
-    default:
-        eStatus = MOS_STATUS_UNIMPLEMENTED;
-        VP_RENDER_ASSERTMESSAGE("Not Inplenmented in driver now, return fail");
-        break;
-    }
-
-    VP_RENDER_CHK_STATUS_RETURN(RenderCmdPacket::InitRenderHalSurface(mosSurface, &renderSurface));
-
-    return eStatus;
-}
 MOS_STATUS VpRenderCmdPacket::UpdateRenderSurface(RENDERHAL_SURFACE_NEXT& renderSurface, KERNEL_SURFACE2D_STATE_PARAM& kernelParams)
 {
     auto& overwriteParam = kernelParams.surfaceOverwriteParams;
@@ -445,9 +316,8 @@
     {
         if (overwriteParam.width && overwriteParam.height)
         {
-            renderSurface.OsSurface.dwWidth  = overwriteParam.width;
+            renderSurface.OsSurface.dwWidth = overwriteParam.width;
             renderSurface.OsSurface.dwHeight = overwriteParam.height;
-            renderSurface.OsSurface.dwQPitch = overwriteParam.height;
         }
 
         renderSurface.OsSurface.dwPitch = overwriteParam.pitch != 0 ? overwriteParam.pitch : renderSurface.OsSurface.dwPitch;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_cmd_packet.h b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_cmd_packet.h
index 904f1c7..218f5bf 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_cmd_packet.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_cmd_packet.h
@@ -67,8 +67,6 @@
 
     MOS_STATUS SetVeboxUpdateParams(PVEBOX_UPDATE_PARAMS params);
 
-    MOS_STATUS SetSecureCopyParams(bool copyNeeded);
-
     MOS_STATUS PacketInit(
         VP_SURFACE* inputSurface,
         VP_SURFACE* outputSurface,
@@ -77,7 +75,7 @@
         VP_EXECUTE_CAPS packetCaps) override;
 
 protected:
-    MOS_STATUS KernelStateSetup(KernelID kernelExecuteID);
+    MOS_STATUS KernelStateSetup();
 
     virtual MOS_STATUS SetupSurfaceState();
 
@@ -85,29 +83,23 @@
 
     virtual VP_SURFACE* GetSurface(SurfaceType type);
 
-    virtual MOS_STATUS SetupMediaWalker(VpRenderKernelObj * kernel);
+    virtual MOS_STATUS SetupMediaWalker() override;
 
     MOS_STATUS InitRenderHalSurface(
         VP_SURFACE         &surface,
         RENDERHAL_SURFACE  &renderSurface);
 
-    MOS_STATUS InitStateHeapSurface(
-        SurfaceType        type,
-        RENDERHAL_SURFACE& renderSurface);
-
     // comments here: Hight overwite params if needed
     MOS_STATUS UpdateRenderSurface(RENDERHAL_SURFACE_NEXT &renderSurface, KERNEL_SURFACE2D_STATE_PARAM& kernelParams);
 
 protected:
 
     KERNEL_OBJECTS                     m_kernelObjs;
-    KERNEL_CONFIGS                     m_kernelConfigs;
-    KERNEL_RENDER_DATA                 m_kernelRenderData;
 
     int32_t                            m_kernelIndex = 0;
     Kdll_FilterEntry                  *m_filter = nullptr;                                       // Kernel Filter (points to base of filter array)
     bool                               m_firstFrame = true;
-    std::vector<uint32_t>              m_kernelId;
+    std::vector<KernelId>              m_kernelId;
     VpKernelSet                       *m_kernelSet = nullptr;
     VpRenderKernelObj                 *m_kernel    = nullptr; // processing kernel pointer
 };
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp
index 8547a32..512096f 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp
@@ -27,7 +27,7 @@
 #include "vp_render_kernel_obj.h"
 using namespace vp;
 
-const vp::MEDIA_OBJECT_KA2_INLINE_DATA g_cInit_MEDIA_VP_OBJECT_KA2_INLINE_DATA =
+extern const vp::MEDIA_OBJECT_KA2_INLINE_DATA g_cInit_MEDIA_VP_OBJECT_KA2_INLINE_DATA =
 {
     // DWORD 0
     {
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h
index ba227c2..1c46967 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h
@@ -283,21 +283,23 @@
     } DW15;
 };
 
+extern const MEDIA_OBJECT_KA2_INLINE_DATA g_cInit_MEDIA_VP_OBJECT_KA2_INLINE_DATA;
+
 typedef struct _KERNEL_SURFACE2D_STATE_PARAM
 {
     struct {
-        bool                           updatedSurfaceParams; // true if using included surface params
-        MOS_FORMAT                     format;               // MOS_FORMAT for processing surfaces
-        uint32_t                       width;
-        uint32_t                       height;
-        uint32_t                       pitch;
-        uint32_t                       surface_offset;     // Offset to the origin of the surface, in bytes.
-        MOS_TILE_TYPE                  tileType;
-        bool                           bufferResource;
-        bool                           bindedKernel;
-        uint32_t                       bindIndex;
-        bool                           updatedRenderSurfaces;
-        RENDERHAL_SURFACE_STATE_PARAMS renderSurfaceParams;  // default can be skip. for future usages, if surface configed by kernel, use it directlly
+        bool       updatedSurfaceParams; // true if using included surface params
+        MOS_FORMAT format; //[IN] MOS_FORMAT
+        uint32_t   width;
+        uint32_t   height;
+        //uint32_t   depth;
+        uint32_t   pitch;
+        //uint16_t   memory_object_control;
+        //uint32_t   surface_x_offset;   // Horizontal offset to the origin of the surface, in columns of pixels.
+        //uint32_t   surface_y_offset;   // Vertical offset to the origin of the surface, in rows of pixels.
+        uint32_t   surface_offset;     // Offset to the origin of the surface, in bytes.
+        MOS_TILE_TYPE tileType;
+        RENDERHAL_SURFACE_STATE_PARAMS renderSurfaceParams;  // defaule can be skip. for future usages, if surface configed by kernel, use it directlly
     } surfaceOverwriteParams;
     bool       renderTarget;        // true for render target
     uint32_t   reserved[2]; // for future usage
@@ -309,6 +311,11 @@
     VpRenderKernelObj(PVP_MHWINTERFACE hwInterface);
     virtual ~VpRenderKernelObj() {};
 
+    virtual void SetKernelParams(RENDER_KERNEL_PARAMS& kernelParams)
+    {
+        m_kernelParams = &kernelParams;
+    }
+
     // Kernel Specific, which will inplenment be each kernel
     // GetCurbeState should be called after UpdateCurbeBindingIndex for all processed surfaces being called
     virtual MOS_STATUS GetCurbeState(void*& curbe, uint32_t& curbeLength) = 0;
@@ -321,20 +328,14 @@
 
     virtual MOS_STATUS GetWalkerSetting(KERNEL_WALKER_PARAMS& walkerParam) = 0;
 
-    virtual MOS_STATUS SetKernelConfigs(void* params) = 0;
-
     // Kernel Common configs
-    virtual MOS_STATUS GetKernelSettings(RENDERHAL_KERNEL_PARAM &settsings, KernelID executeKernelID)
+    virtual MOS_STATUS GetKernelSettings(RENDERHAL_KERNEL_PARAM &settsings)
     {
         MOS_ZeroMemory(&settsings, sizeof(RENDERHAL_KERNEL_PARAM));
 
         if (m_hwInterface && m_hwInterface->m_vpPlatformInterface)
         {
-            // adding when insert new kernels
-            if (executeKernelID >= VeboxSecureBlockCopy && executeKernelID < VeboxKernelMax)
-            {
-                settsings = m_hwInterface->m_vpPlatformInterface->GetVeboxKernelSettings(executeKernelID - VeboxSecureBlockCopy);
-            }
+            settsings = m_hwInterface->m_vpPlatformInterface->GetVeboxKernelSettings(m_kernelID);
             return MOS_STATUS_SUCCESS;
         }
         else
@@ -404,10 +405,12 @@
         m_kernelSize = size;
         return MOS_STATUS_SUCCESS;
     }
+protected:
 
     virtual MOS_STATUS SetupSurfaceState() = 0;
 
 protected:
+    RENDER_KERNEL_PARAMS                                *m_kernelParams = nullptr;   // kernel input for processing params include kernel ID and process surface group
     std::map<SurfaceType, VP_SURFACE*>                  *m_surfaceGroup = nullptr;   // input surface process surface groups
     PVP_MHWINTERFACE                                     m_hwInterface = nullptr;
     std::vector<SurfaceType>                             m_surfaces;                 // vector for processed surfaces, the order should match with Curbe surface order
@@ -421,6 +424,4 @@
     //KERNEL_WALKER_PARAMS                                 m_kernelWalkerParams = {};   // Kernel Walker Params
 };
 }
-
-extern const vp::MEDIA_OBJECT_KA2_INLINE_DATA g_cInit_MEDIA_VP_OBJECT_KA2_INLINE_DATA;
 #endif // __VP_RENDER_KERNEL_OBJ_H__
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.cpp
index 6f1594a..1553809 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.cpp
@@ -997,7 +997,7 @@
 
 bool VpVeboxCmdPacket::UseKernelResource()
 {
-    return true;// false;
+    return false;
 }
 
 MOS_STATUS VpVeboxCmdPacket::InitVeboxSurfaceParams(
@@ -1616,36 +1616,6 @@
     return eStatus;
 }
 
-MOS_STATUS VpVeboxCmdPacket::Prepare()
-{
-    VP_FUNC_CALL();
-
-    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
-
-    return eStatus;
-}
-
-MOS_STATUS VpVeboxCmdPacket::PrepareState()
-{
-    VP_FUNC_CALL();
-
-    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
-
-    if (m_packetResourcesdPrepared)
-    {
-        VP_RENDER_NORMALMESSAGE("Resource Prepared, skip this time");
-        return MOS_STATUS_SUCCESS;
-    }
-
-    VP_RENDER_CHK_STATUS_RETURN(SetupIndirectStates());
-
-    VP_RENDER_CHK_STATUS_RETURN(UpdateVeboxStates());
-
-    m_packetResourcesdPrepared = true;
-
-    return eStatus;
-}
-
 MOS_STATUS VpVeboxCmdPacket::PacketInit(
     VP_SURFACE                          *inputSurface,
     VP_SURFACE                          *outputSurface,
@@ -1656,7 +1626,6 @@
     VP_FUNC_CALL();
 
     VpVeboxRenderData       *pRenderData = GetLastExecRenderData();
-    m_packetResourcesdPrepared = false;
 
     VP_RENDER_CHK_NULL_RETURN(pRenderData);
     VP_RENDER_CHK_NULL_RETURN(inputSurface);
@@ -1727,6 +1696,9 @@
         }
     }
 
+    // Setup, Copy and Update VEBOX State
+    VP_RENDER_CHK_STATUS_RETURN(CopyAndUpdateVeboxState());
+
     // Send vebox command
     VP_RENDER_CHK_STATUS_RETURN(SendVeboxCmd(commandBuffer));
 
@@ -1767,6 +1739,34 @@
     m_allocator->DestroyVpSurface(m_renderTarget);
 }
 
+MOS_STATUS VpVeboxCmdPacket::CopyAndUpdateVeboxState()
+{
+    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
+
+    // Setup VEBOX State
+    VP_RENDER_CHK_STATUS_RETURN(SetupIndirectStates());
+
+    // Copy VEBOX State
+    VP_RENDER_CHK_STATUS_RETURN(CopyVeboxStates());
+
+    // Update VEBOX State
+    VP_RENDER_CHK_STATUS_RETURN(UpdateVeboxStates());
+
+    return eStatus;
+}
+
+
+//!
+//! \brief    Vebox Copy Vebox state heap, intended for HM or IDM
+//! \details  Copy Vebox state heap between different memory
+//! \return   MOS_STATUS
+//!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
+//!
+MOS_STATUS VpVeboxCmdPacket::CopyVeboxStates()
+{
+    return MOS_STATUS_SUCCESS;  // no need to copy, always use driver resource in clear memory
+}
+
 //!
 //! \brief    Calculate offsets of statistics surface address based on the
 //!           functions which were enabled in the previous call,
@@ -1863,6 +1863,19 @@
     return eStatus;
 }
 
+//!
+//! \brief    Vebox state heap update for auto mode features
+//! \details  Update Vebox indirect states for auto mode features
+//! \param    [in] pSrcSurface
+//!           Pointer to input surface of Vebox
+//! \return   MOS_STATUS
+//!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
+//!
+MOS_STATUS VpVeboxCmdPacket::UpdateVeboxStates()
+{
+    return MOS_STATUS_SUCCESS;
+}
+
 MOS_STATUS VpVeboxCmdPacket::AddVeboxDndiState()
 {                                                                          
     PMHW_VEBOX_INTERFACE             pVeboxInterface = m_hwInterface->m_veboxInterface;;
@@ -2336,11 +2349,6 @@
     return MOS_STATUS_SUCCESS;
 }
 
-MOS_STATUS VpVeboxCmdPacket::UpdateVeboxStates()
-{
-    return MOS_STATUS_SUCCESS;
-}
-
 MOS_STATUS VpVeboxCmdPacket::InitSurfMemCacheControl(VP_EXECUTE_CAPS packetCaps)
 {
     MOS_HW_RESOURCE_DEF                 Usage           = MOS_HW_RESOURCE_DEF_MAX;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.h b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.h
index 24e9f39..3e45603 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.h
@@ -321,9 +321,7 @@
 
     virtual MOS_STATUS Destory() { return MOS_STATUS_SUCCESS; };
 
-    virtual MOS_STATUS Prepare() override;
-
-    virtual MOS_STATUS PrepareState() override;
+    virtual MOS_STATUS Prepare() override { return MOS_STATUS_SUCCESS; };
 
     virtual MOS_STATUS                  AllocateExecRenderData()
     {
@@ -736,6 +734,13 @@
         VP_SURFACE_SETTING                  &surfSetting,
         VP_EXECUTE_CAPS                     packetCaps) override;
 
+    //!
+    //! \brief    Copy and update vebox state
+    //! \details  Copy and update vebox state for input frame.
+    //! \return   MOS_STATUS
+    //!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
+    //!
+    virtual MOS_STATUS CopyAndUpdateVeboxState();
 
     //!
     //! \brief    Check whether the Vebox command parameters are correct
@@ -751,6 +756,24 @@
         const MHW_VEBOX_DI_IECP_CMD_PARAMS          &VeboxDiIecpCmdParams,
         const VPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS  &VeboxSurfaceStateCmdParams);
 
+    //!
+    //! \brief    Copy Vebox state heap
+    //! \details  Call HW interface function,
+    //!           use Secure_Block_Copy kernel,
+    //!           copy Vebox state heap between different memory
+    //! \return   MOS_STATUS
+    //!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
+    //!
+    virtual MOS_STATUS CopyVeboxStates();
+
+    //!
+    //! \brief    Vebox state heap update for auto mode features
+    //! \details  Update Vebox indirect states for auto mode features
+    //! \return   MOS_STATUS
+    //!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
+    //!
+    virtual MOS_STATUS UpdateVeboxStates();
+
     virtual MOS_STATUS QueryStatLayout(
         VEBOX_STAT_QUERY_TYPE QueryType,
         uint32_t*             pQuery) {return MOS_STATUS_SUCCESS;};
@@ -790,15 +813,6 @@
     //!
     virtual MOS_STATUS VeboxSetPerfTagPaFormat();
 
-    //!
-    //! \brief    Vebox state heap update for auto mode features
-    //! \details  Update Vebox indirect states for auto mode features
-    //! \return   MOS_STATUS
-    //!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
-    //!
-    virtual MOS_STATUS UpdateVeboxStates();
-
-
 protected:
 
     //!
diff --git a/media_driver/media_driver_next/agnostic/gen12_tgllp/vp/hal/platform_interface/vp_platform_interface_g12_tgllp.cpp b/media_driver/media_driver_next/agnostic/gen12_tgllp/vp/hal/platform_interface/vp_platform_interface_g12_tgllp.cpp
index 83493be..a28ed7c 100644
--- a/media_driver/media_driver_next/agnostic/gen12_tgllp/vp/hal/platform_interface/vp_platform_interface_g12_tgllp.cpp
+++ b/media_driver/media_driver_next/agnostic/gen12_tgllp/vp/hal/platform_interface/vp_platform_interface_g12_tgllp.cpp
@@ -39,7 +39,7 @@
 
 using namespace vp;
 //Kernel Params ---------------------------------------------------------------
-extern const RENDERHAL_KERNEL_PARAM g_Vebox_KernelParam_m12[VEBOX_KERNEL_BASE_MAX_G12] =
+const RENDERHAL_KERNEL_PARAM g_Vebox_KernelParam_g12[VEBOX_KERNEL_BASE_MAX_G12] =
 {
     ///*  GRF_Count
     //    |  BT_Count
@@ -136,11 +136,7 @@
     MOS_ZeroMemory(&kernelParam, sizeof(RENDERHAL_KERNEL_PARAM));
     if (iKDTIndex < VEBOX_KERNEL_BASE_MAX_G12)
     {
-        kernelParam = g_Vebox_KernelParam_m12[iKDTIndex];
-    }
-    else
-    {
-        VP_PUBLIC_ASSERTMESSAGE("not support in Vebox Kernels");
+        kernelParam = g_Vebox_KernelParam_g12[iKDTIndex];
     }
     return kernelParam;
 }