diff --git a/media_common/agnostic/common/hw/mhw_render.h b/media_common/agnostic/common/hw/mhw_render.h
index 5abd00c1b6..b551ab1337 100644
--- a/media_common/agnostic/common/hw/mhw_render.h
+++ b/media_common/agnostic/common/hw/mhw_render.h
@@ -77,6 +77,7 @@ typedef struct _MHW_RENDER_ENGINE_L3_CACHE_CONFIG
 
 typedef enum _MHW_RENDER_ENGINE_ADDRESS_SHIFT
 {
+    MHW_RENDER_ENGINE_KERNEL_POINTER_SHIFT = 6,
     MHW_RENDER_ENGINE_STATE_BASE_ADDRESS_SHIFT  = 12
 } MHW_RENDER_ENGINE_ADDRESS_SHIFT;
 
@@ -146,6 +147,7 @@ typedef struct _MHW_STATE_BASE_ADDR_PARAMS
     uint32_t                mocs4IndirectObjectBuffer;
     uint32_t                mocs4StatelessDataport;
     uint32_t                l1CacheConfig;
+    bool                    addressDis;
 } MHW_STATE_BASE_ADDR_PARAMS, *PMHW_STATE_BASE_ADDR_PARAMS;
 
 typedef struct _MHW_VFE_SCOREBOARD_DELTA
@@ -309,7 +311,8 @@ typedef struct _MHW_GPGPU_WALKER_PARAMS
     MHW_EMIT_LOCAL_MODE        emitLocal;
 
     bool                       hasBarrier;
-    
+    PMHW_INLINE_DATA_PARAMS    inlineDataParamBase;
+
 } MHW_GPGPU_WALKER_PARAMS, *PMHW_GPGPU_WALKER_PARAMS;
 
 typedef struct _MHW_MEDIA_OBJECT_PARAMS
diff --git a/media_common/agnostic/common/hw/mhw_state_heap.h b/media_common/agnostic/common/hw/mhw_state_heap.h
index f6f7e05093..49add60823 100644
--- a/media_common/agnostic/common/hw/mhw_state_heap.h
+++ b/media_common/agnostic/common/hw/mhw_state_heap.h
@@ -83,6 +83,8 @@ typedef struct MHW_BLOCK_MANAGER *PMHW_BLOCK_MANAGER;
 
 #define MHW_INVALID_SYNC_TAG            0xFFFFFFFF
 
+#define MAX_INLINE_DATA_PARAMS          32
+
 enum MW_RENDER_ENGINE_ADDRESS_SHIFT
 {
     MHW_STATE_HEAP_SURFACE_STATE_SHIFT = 0
@@ -699,6 +701,14 @@ typedef enum _MHW_CHROMAKEY_MODE
     MHW_CHROMAKEY_MODE_REPLACE_BLACK = 1
 } MHW_CHROMAKEY_MODE;
 
+typedef struct _MHW_INLINE_DATA_PARAMS
+{
+    uint32_t          dwOffset;
+    uint32_t          dwSize;
+    PMOS_RESOURCE     resource;
+    bool              isPtrType;
+} MHW_INLINE_DATA_PARAMS, *PMHW_INLINE_DATA_PARAMS;
+
 typedef struct _MHW_SAMPLER_STATE_UNORM_PARAM
 {
     MHW_SAMPLER_FILTER_MODE      SamplerFilterMode;
@@ -845,6 +855,7 @@ struct MHW_STATE_HEAP_SETTINGS
     HeapManager::Behavior m_dshBehavior = HeapManager::Behavior::wait;    //!< DSH behavior
 
     uint32_t        dwNumSyncTags = 0; //!< to be removed with old interfaces
+    MOS_HW_RESOURCE_DEF m_heapUsageType = MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC;
 };
 
 typedef struct _MHW_STATE_HEAP_DYNAMIC_ALLOC_PARAMS
diff --git a/media_common/agnostic/common/os/mos_os_hw.h b/media_common/agnostic/common/os/mos_os_hw.h
index 22be1f8f87..fcea01884d 100644
--- a/media_common/agnostic/common/os/mos_os_hw.h
+++ b/media_common/agnostic/common/os/mos_os_hw.h
@@ -293,6 +293,7 @@ typedef enum MOS_HW_COMMAND_ENUM
     MOS_SURFACE_STATE,
     MOS_SURFACE_STATE_ADV,
     MOS_STATE_BASE_ADDR,
+    MOS_COMPUTE_WALKER,
     MOS_VEBOX_STATE,
     MOS_VEBOX_DI_IECP,
     MOS_VEBOX_TILING_CONVERT,
diff --git a/media_common/agnostic/common/renderhal/renderhal.h b/media_common/agnostic/common/renderhal/renderhal.h
index 0121cffb8e..480e771f0f 100644
--- a/media_common/agnostic/common/renderhal/renderhal.h
+++ b/media_common/agnostic/common/renderhal/renderhal.h
@@ -841,6 +841,7 @@ typedef struct _RENDERHAL_STATE_HEAP_SETTINGS
     int32_t             iSurfaceStates;                                         // Number of Surfaces per SSH
     int32_t             iSurfacesPerBT;                                         // Number of Surfaces per BT
     int32_t             iBTAlignment;                                           // BT Alignment size
+    MOS_HW_RESOURCE_DEF heapUsageType;
 } RENDERHAL_STATE_HEAP_SETTINGS, *PRENDERHAL_STATE_HEAP_SETTINGS;
 
 typedef struct _RENDERHAL_STATE_HEAP
@@ -1197,6 +1198,7 @@ typedef struct _RENDERHAL_INTERFACE
     bool                        bEnableGpgpuMidBatchPreEmption;                 // Middle Batch Buffer Preemption
     bool                        bEnableGpgpuMidThreadPreEmption;                // Middle Thread Preemption
     bool                        bComputeContextInUse;                           // Compute Context use for media
+    bool                        isBindlessHeapInUse;                            // Bindless Heap Mode use
 
     uint32_t                    dwMaskCrsThdConDataRdLn;                        // Unifies pfnSetupInterfaceDescriptor for g75,g8,...
     uint32_t                    dwMinNumberThreadsInGroup;                      // Unifies pfnSetupInterfaceDescriptor for g75,g8,...
@@ -1460,6 +1462,13 @@ typedef struct _RENDERHAL_INTERFACE
                 PMHW_SAMPLER_STATE_PARAM    pSamplerParams,
                 int32_t                     iSamplers);
 
+    MOS_STATUS (*pfnSetAndGetSamplerStates) (
+                PRENDERHAL_INTERFACE     pRenderHal,
+                int32_t                  iMediaID,
+                PMHW_SAMPLER_STATE_PARAM pSamplerParams,
+                int32_t                  iSamplers,
+                std::map<uint32_t, uint32_t> &samplerMap);
+
     int32_t (* pfnAllocateMediaID) (
                 PRENDERHAL_INTERFACE        pRenderHal,
                 int32_t                     iKernelAllocationID,
diff --git a/media_common/agnostic/common/renderhal/renderhal_platform_interface.h b/media_common/agnostic/common/renderhal/renderhal_platform_interface.h
index 5ad2d53c15..6a41af192c 100644
--- a/media_common/agnostic/common/renderhal/renderhal_platform_interface.h
+++ b/media_common/agnostic/common/renderhal/renderhal_platform_interface.h
@@ -565,6 +565,12 @@ class XRenderHal_Platform_Interface
         return MOS_STATUS_SUCCESS;
     };
 
+    virtual bool IsBindlessHeapInUse(
+        PRENDERHAL_INTERFACE pRenderHal)
+    {
+        return false;
+    }
+
     //! \brief    Allocates scratch space buffer.
     //! \details  On some new pltforms, a single scratch space buffer may be allocated and used for
     //!           all threads.
diff --git a/media_driver/media_softlet/agnostic/Xe_R/Xe_HPG/renderhal/renderhal_xe_hpg.cpp b/media_driver/media_softlet/agnostic/Xe_R/Xe_HPG/renderhal/renderhal_xe_hpg.cpp
index 6abb10732e..786f52d356 100644
--- a/media_driver/media_softlet/agnostic/Xe_R/Xe_HPG/renderhal/renderhal_xe_hpg.cpp
+++ b/media_driver/media_softlet/agnostic/Xe_R/Xe_HPG/renderhal/renderhal_xe_hpg.cpp
@@ -67,7 +67,8 @@ extern const RENDERHAL_STATE_HEAP_SETTINGS g_cRenderHal_State_Heap_Settings_xe_h
     RENDERHAL_SSH_BINDING_TABLES,              //!< iBindingTables
     RENDERHAL_SSH_SURFACE_STATES,              //!< iSurfaceStates
     RENDERHAL_SSH_SURFACES_PER_BT,             //!< iSurfacesPerBT
-    RENDERHAL_SSH_BINDING_TABLE_ALIGN          //!< iBTAlignment
+    RENDERHAL_SSH_BINDING_TABLE_ALIGN,         //!< iBTAlignment
+    MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC       //!< heapUsageType
 };
 
 extern const RENDERHAL_ENLARGE_PARAMS g_cRenderHal_Enlarge_State_Heap_Settings_Adv_xe_hpg =
diff --git a/media_driver/media_softlet/agnostic/g12/g12_base/renderhal/renderhal_g12_base.cpp b/media_driver/media_softlet/agnostic/g12/g12_base/renderhal/renderhal_g12_base.cpp
index 2bd07a1e99..31b2b0d5a3 100644
--- a/media_driver/media_softlet/agnostic/g12/g12_base/renderhal/renderhal_g12_base.cpp
+++ b/media_driver/media_softlet/agnostic/g12/g12_base/renderhal/renderhal_g12_base.cpp
@@ -71,7 +71,8 @@ extern const RENDERHAL_STATE_HEAP_SETTINGS g_cRenderHal_State_Heap_Settings_g12
     RENDERHAL_SSH_BINDING_TABLES,              //!< iBindingTables
     RENDERHAL_SSH_SURFACE_STATES,              //!< iSurfaceStates
     RENDERHAL_SSH_SURFACES_PER_BT,             //!< iSurfacesPerBT
-    RENDERHAL_SSH_BINDING_TABLE_ALIGN          //!< iBTAlignment
+    RENDERHAL_SSH_BINDING_TABLE_ALIGN,         //!< iBTAlignment
+    MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC       //!< heapUsageType
 };
 
 const uint32_t g_cLookup_RotationMode_g12[8] = 
diff --git a/media_softlet/agnostic/Xe_R/Xe2_HPG/renderhal/renderhal_xe2_hpg_next.cpp b/media_softlet/agnostic/Xe_R/Xe2_HPG/renderhal/renderhal_xe2_hpg_next.cpp
index 25e65e2756..ab48a2ba18 100644
--- a/media_softlet/agnostic/Xe_R/Xe2_HPG/renderhal/renderhal_xe2_hpg_next.cpp
+++ b/media_softlet/agnostic/Xe_R/Xe2_HPG/renderhal/renderhal_xe2_hpg_next.cpp
@@ -67,7 +67,8 @@ extern const RENDERHAL_STATE_HEAP_SETTINGS g_cRenderHal_State_Heap_Settings_xe2_
     RENDERHAL_SSH_BINDING_TABLES,      //!< iBindingTables
     RENDERHAL_SSH_SURFACE_STATES,      //!< iSurfaceStates
     RENDERHAL_SSH_SURFACES_PER_BT,     //!< iSurfacesPerBT
-    RENDERHAL_SSH_BINDING_TABLE_ALIGN  //!< iBTAlignment
+    RENDERHAL_SSH_BINDING_TABLE_ALIGN,  //!< iBTAlignment
+    MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC //!< heapUsageType
 };
 
 extern const RENDERHAL_ENLARGE_PARAMS g_cRenderHal_Enlarge_State_Heap_Settings_Adv_xe2_hpg =
diff --git a/media_softlet/agnostic/Xe_R/Xe_HPG_Base/renderhal/renderhal_xe_hpg_base.cpp b/media_softlet/agnostic/Xe_R/Xe_HPG_Base/renderhal/renderhal_xe_hpg_base.cpp
index 666195d7fc..e1f719c92f 100644
--- a/media_softlet/agnostic/Xe_R/Xe_HPG_Base/renderhal/renderhal_xe_hpg_base.cpp
+++ b/media_softlet/agnostic/Xe_R/Xe_HPG_Base/renderhal/renderhal_xe_hpg_base.cpp
@@ -61,7 +61,8 @@ extern const RENDERHAL_STATE_HEAP_SETTINGS g_cRenderHal_State_Heap_Settings_hpg_
     RENDERHAL_SSH_BINDING_TABLES,              //!< iBindingTables
     RENDERHAL_SSH_SURFACE_STATES,              //!< iSurfaceStates
     RENDERHAL_SSH_SURFACES_PER_BT,             //!< iSurfacesPerBT
-    RENDERHAL_SSH_BINDING_TABLE_ALIGN          //!< iBTAlignment
+    RENDERHAL_SSH_BINDING_TABLE_ALIGN,         //!< iBTAlignment
+    MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC       //!< heapUsageType
 };
 
 extern const RENDERHAL_ENLARGE_PARAMS g_cRenderHal_Enlarge_State_Heap_Settings_Adv_hpg_base =
diff --git a/media_softlet/agnostic/common/hw/mhw_render_cmdpar.h b/media_softlet/agnostic/common/hw/mhw_render_cmdpar.h
index 3510ec86e2..4c01d351ce 100644
--- a/media_softlet/agnostic/common/hw/mhw_render_cmdpar.h
+++ b/media_softlet/agnostic/common/hw/mhw_render_cmdpar.h
@@ -61,6 +61,12 @@ struct MHW_VFE_SCOREBOARD
     MHW_VFE_SCOREBOARD_DELTA ScoreboardDelta[MHW_MAX_DEPENDENCY_COUNT] = {};
 };
 
+struct MHW_HEAPS_RESOURCE
+{
+    PMOS_RESOURCE          presInstructionBuffer = nullptr;
+    PMHW_INLINE_DATA_PARAMS inlineDataParamsBase   = nullptr;
+};
+
 enum MHW_VFE_SLICE_DISABLE
 {
     MHW_VFE_SLICE_ALL = 0,
@@ -219,6 +225,7 @@ struct _MHW_PAR_T(STATE_BASE_ADDRESS)
     uint32_t                mocs4IndirectObjectBuffer  = 0;
     uint32_t                mocs4StatelessDataport     = 0;
     uint32_t                l1CacheConfig              = 0;
+    bool                    addressDis                 = false;
 };
 
 struct _MHW_PAR_T(MEDIA_VFE_STATE)
@@ -391,7 +398,9 @@ struct _MHW_PAR_T(COMPUTE_WALKER)
     bool                      isGenerateLocalId             = false;
     MHW_EMIT_LOCAL_MODE       emitLocal                     = MHW_EMIT_LOCAL_NONE;
     uint32_t                  preferredSlmAllocationSize    = 0;
-    
+    _MHW_PAR_T(CFE_STATE)     cfeState                      = {};
+    MHW_HEAPS_RESOURCE        heapsResource                 = {};
+
 };
 
 struct _MHW_PAR_T(STATE_COMPUTE_MODE)
diff --git a/media_softlet/agnostic/common/hw/mhw_render_impl.h b/media_softlet/agnostic/common/hw/mhw_render_impl.h
index 6a80d100c0..680cba65df 100644
--- a/media_softlet/agnostic/common/hw/mhw_render_impl.h
+++ b/media_softlet/agnostic/common/hw/mhw_render_impl.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2021, Intel Corporation
+* Copyright (c) 2021-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"),
@@ -72,6 +72,11 @@ class Impl : public Itf, public mhw::Impl
         return &m_l3CacheConfig;
     }
 
+    MOS_STATUS SetupInlineData() override
+    {
+        return MOS_STATUS_SUCCESS;
+    }
+
 protected:
     using base_t = Itf;
 
@@ -317,194 +322,197 @@ class Impl : public Itf, public mhw::Impl
     {
         _MHW_SETCMD_CALLBASE(STATE_BASE_ADDRESS);
 
-        MHW_RESOURCE_PARAMS resourceParams = {};
-
-        resourceParams.dwLsbNum      = MHW_RENDER_ENGINE_STATE_BASE_ADDRESS_SHIFT;
-        resourceParams.HwCommandType = MOS_STATE_BASE_ADDR;
-
-        if (!Mos_ResourceIsNull(params.presGeneralState))
+        if (params.addressDis == false)
         {
-            cmd.DW1_2.GeneralStateBaseAddressModifyEnable   = true;
-            cmd.DW12.GeneralStateBufferSizeModifyEnable     = true;
-            resourceParams.presResource                     = params.presGeneralState;
-            resourceParams.dwOffset                         = 0;
-            resourceParams.pdwCmd                           = cmd.DW1_2.Value;
-            resourceParams.dwLocationInCmd                  = _MHW_CMD_DW_LOCATION(DW1_2.Value);
+            MHW_RESOURCE_PARAMS resourceParams = {};
 
-            // upper bound of the allocated resource will not be set
-            resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
+            resourceParams.dwLsbNum      = MHW_RENDER_ENGINE_STATE_BASE_ADDRESS_SHIFT;
+            resourceParams.HwCommandType = MOS_STATE_BASE_ADDR;
 
-            InitMocsParams(resourceParams, &cmd.DW1_2.Value[0], 5, 10);
-            MHW_MI_CHK_STATUS(AddResourceToCmd(
-                this->m_osItf,
-                this->m_currentCmdBuf,
-                &resourceParams));
-
-            if (params.mocs4GeneralState != 0)
+            if (!Mos_ResourceIsNull(params.presGeneralState))
             {
-                cmd.DW1_2.GeneralStateMemoryObjectControlState = params.mocs4GeneralState;
+                cmd.DW1_2.GeneralStateBaseAddressModifyEnable = true;
+                cmd.DW12.GeneralStateBufferSizeModifyEnable   = true;
+                resourceParams.presResource                   = params.presGeneralState;
+                resourceParams.dwOffset                       = 0;
+                resourceParams.pdwCmd                         = cmd.DW1_2.Value;
+                resourceParams.dwLocationInCmd                = _MHW_CMD_DW_LOCATION(DW1_2.Value);
+
+                // upper bound of the allocated resource will not be set
+                resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
+
+                InitMocsParams(resourceParams, &cmd.DW1_2.Value[0], 5, 10);
+                MHW_MI_CHK_STATUS(AddResourceToCmd(
+                    this->m_osItf,
+                    this->m_currentCmdBuf,
+                    &resourceParams));
+
+                if (params.mocs4GeneralState != 0)
+                {
+                    cmd.DW1_2.GeneralStateMemoryObjectControlState = params.mocs4GeneralState;
+                }
+                MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW1_2.GeneralStateMemoryObjectControlState);
+                MHW_NORMALMESSAGE(
+                    "Feature Graph: Cache settings of DW1_2 GeneralState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
+                    cmd.DW1_2.GeneralStateMemoryObjectControlState,
+                    (cmd.DW1_2.GeneralStateMemoryObjectControlState >> 1) & 0x0000003f);
+                cmd.DW12.GeneralStateBufferSize = (params.dwGeneralStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
             }
-            MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW1_2.GeneralStateMemoryObjectControlState);
-            MHW_NORMALMESSAGE(
-                "Feature Graph: Cache settings of DW1_2 GeneralState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
-                cmd.DW1_2.GeneralStateMemoryObjectControlState,
-                (cmd.DW1_2.GeneralStateMemoryObjectControlState >> 1) & 0x0000003f);
-            cmd.DW12.GeneralStateBufferSize = (params.dwGeneralStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
-        }
 
-        if (this->m_osItf->bNoParsingAssistanceInKmd && !Mos_ResourceIsNull(&(this->m_currentCmdBuf->OsResource)))
-        {
-            uint32_t indirectStateOffset, indirectStateSize;
-            MHW_MI_CHK_STATUS(this->m_osItf->pfnGetIndirectState(this->m_osItf, &indirectStateOffset, &indirectStateSize));
-
-            // When KMD parsing assistance is not used,
-            // UMD is required to set up the SSH
-            // in the STATE_BASE_ADDRESS command.
-            // All addresses used in the STATE_BASE_ADDRESS
-            // command need to have the modify
-            // bit associated with it set to 1.
-            cmd.DW4_5.SurfaceStateBaseAddressModifyEnable  = true;
-            resourceParams.presResource                    = &(this->m_currentCmdBuf->OsResource);
-            resourceParams.dwOffset                        = indirectStateOffset;
-            resourceParams.pdwCmd                          = cmd.DW4_5.Value;
-            resourceParams.dwLocationInCmd                 = _MHW_CMD_DW_LOCATION(DW4_5.Value);
-
-            // upper bound of the allocated resource will not be set
-            resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
-
-            InitMocsParams(resourceParams, &cmd.DW4_5.Value[0], 5, 10);
-            MHW_MI_CHK_STATUS(AddResourceToCmd(
-                this->m_osItf,
-                this->m_currentCmdBuf,
-                &resourceParams));
-
-            if (params.mocs4SurfaceState != 0)
+            if (this->m_osItf->bNoParsingAssistanceInKmd && !Mos_ResourceIsNull(&(this->m_currentCmdBuf->OsResource)))
             {
-                cmd.DW4_5.SurfaceStateMemoryObjectControlState = params.mocs4SurfaceState;
+                uint32_t indirectStateOffset, indirectStateSize;
+                MHW_MI_CHK_STATUS(this->m_osItf->pfnGetIndirectState(this->m_osItf, &indirectStateOffset, &indirectStateSize));
+
+                // When KMD parsing assistance is not used,
+                // UMD is required to set up the SSH
+                // in the STATE_BASE_ADDRESS command.
+                // All addresses used in the STATE_BASE_ADDRESS
+                // command need to have the modify
+                // bit associated with it set to 1.
+                cmd.DW4_5.SurfaceStateBaseAddressModifyEnable = true;
+                resourceParams.presResource                   = &(this->m_currentCmdBuf->OsResource);
+                resourceParams.dwOffset                       = indirectStateOffset;
+                resourceParams.pdwCmd                         = cmd.DW4_5.Value;
+                resourceParams.dwLocationInCmd                = _MHW_CMD_DW_LOCATION(DW4_5.Value);
+
+                // upper bound of the allocated resource will not be set
+                resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
+
+                InitMocsParams(resourceParams, &cmd.DW4_5.Value[0], 5, 10);
+                MHW_MI_CHK_STATUS(AddResourceToCmd(
+                    this->m_osItf,
+                    this->m_currentCmdBuf,
+                    &resourceParams));
+
+                if (params.mocs4SurfaceState != 0)
+                {
+                    cmd.DW4_5.SurfaceStateMemoryObjectControlState = params.mocs4SurfaceState;
+                }
+                MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW4_5.SurfaceStateMemoryObjectControlState);
+                MHW_NORMALMESSAGE(
+                    "Feature Graph: Cache settings of DW4_5 SurfaceState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
+                    cmd.DW4_5.SurfaceStateMemoryObjectControlState,
+                    (cmd.DW4_5.SurfaceStateMemoryObjectControlState >> 1) & 0x0000003f);
             }
-            MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW4_5.SurfaceStateMemoryObjectControlState);
-            MHW_NORMALMESSAGE(
-                "Feature Graph: Cache settings of DW4_5 SurfaceState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
-                cmd.DW4_5.SurfaceStateMemoryObjectControlState,
-                (cmd.DW4_5.SurfaceStateMemoryObjectControlState >> 1) & 0x0000003f);
-        }
-
-        if (!Mos_ResourceIsNull(params.presDynamicState))
-        {
-            cmd.DW6_7.DynamicStateBaseAddressModifyEnable  = true;
-            cmd.DW13.DynamicStateBufferSizeModifyEnable    = true;
-            resourceParams.presResource                     = params.presDynamicState;
-            resourceParams.dwOffset                         = 0;
-            resourceParams.pdwCmd                           = cmd.DW6_7.Value;
-            resourceParams.dwLocationInCmd                  = _MHW_CMD_DW_LOCATION(DW6_7.Value);
-            resourceParams.bIsWritable                      = params.bDynamicStateRenderTarget;
-
-            // upper bound of the allocated resource will not be set
-            resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
-
-            InitMocsParams(resourceParams, &cmd.DW6_7.Value[0], 5, 10);
-            MHW_MI_CHK_STATUS(AddResourceToCmd(
-                this->m_osItf,
-                this->m_currentCmdBuf,
-                &resourceParams));
 
-            if (params.mocs4DynamicState != 0)
+            if (!Mos_ResourceIsNull(params.presDynamicState))
             {
-                cmd.DW6_7.DynamicStateMemoryObjectControlState = params.mocs4DynamicState;
+                cmd.DW6_7.DynamicStateBaseAddressModifyEnable = true;
+                cmd.DW13.DynamicStateBufferSizeModifyEnable   = true;
+                resourceParams.presResource                   = params.presDynamicState;
+                resourceParams.dwOffset                       = 0;
+                resourceParams.pdwCmd                         = cmd.DW6_7.Value;
+                resourceParams.dwLocationInCmd                = _MHW_CMD_DW_LOCATION(DW6_7.Value);
+                resourceParams.bIsWritable                    = params.bDynamicStateRenderTarget;
+
+                // upper bound of the allocated resource will not be set
+                resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
+
+                InitMocsParams(resourceParams, &cmd.DW6_7.Value[0], 5, 10);
+                MHW_MI_CHK_STATUS(AddResourceToCmd(
+                    this->m_osItf,
+                    this->m_currentCmdBuf,
+                    &resourceParams));
+
+                if (params.mocs4DynamicState != 0)
+                {
+                    cmd.DW6_7.DynamicStateMemoryObjectControlState = params.mocs4DynamicState;
+                }
+
+                MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW6_7.DynamicStateMemoryObjectControlState);
+                MHW_NORMALMESSAGE(
+                    "Feature Graph: Cache settings of DW6_7 DynamicState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
+                    cmd.DW6_7.DynamicStateMemoryObjectControlState,
+                    (cmd.DW6_7.DynamicStateMemoryObjectControlState >> 1) & 0x0000003f);
+                cmd.DW13.DynamicStateBufferSize = (params.dwDynamicStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
+
+                //Reset isOutput as it should be enabled only for Dynamic State
+                resourceParams.bIsWritable = false;
             }
 
-            MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW6_7.DynamicStateMemoryObjectControlState);
-            MHW_NORMALMESSAGE(
-                "Feature Graph: Cache settings of DW6_7 DynamicState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
-                cmd.DW6_7.DynamicStateMemoryObjectControlState,
-                (cmd.DW6_7.DynamicStateMemoryObjectControlState >> 1) & 0x0000003f);
-            cmd.DW13.DynamicStateBufferSize = (params.dwDynamicStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
-
-            //Reset isOutput as it should be enabled only for Dynamic State
-            resourceParams.bIsWritable = false;
-        }
-
-        if (!Mos_ResourceIsNull(params.presIndirectObjectBuffer))
-        {
-            cmd.DW8_9.IndirectObjectBaseAddressModifyEnable   = true;
-            cmd.DW14.IndirectObjectBufferSizeModifyEnable     = true;
-            resourceParams.presResource                       = params.presIndirectObjectBuffer;
-            resourceParams.dwOffset                           = 0;
-            resourceParams.pdwCmd                             = cmd.DW8_9.Value;
-            resourceParams.dwLocationInCmd                    = _MHW_CMD_DW_LOCATION(DW8_9.Value);
-
-            // upper bound of the allocated resource will not be set
-            resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
-
-            InitMocsParams(resourceParams, &cmd.DW8_9.Value[0], 5, 10);
-            MHW_MI_CHK_STATUS(AddResourceToCmd(
-                this->m_osItf,
-                this->m_currentCmdBuf,
-                &resourceParams));
-
-            if (params.mocs4IndirectObjectBuffer != 0)
+            if (!Mos_ResourceIsNull(params.presIndirectObjectBuffer))
             {
-                cmd.DW8_9.IndirectObjectMemoryObjectControlState = params.mocs4IndirectObjectBuffer;
+                cmd.DW8_9.IndirectObjectBaseAddressModifyEnable = true;
+                cmd.DW14.IndirectObjectBufferSizeModifyEnable   = true;
+                resourceParams.presResource                     = params.presIndirectObjectBuffer;
+                resourceParams.dwOffset                         = 0;
+                resourceParams.pdwCmd                           = cmd.DW8_9.Value;
+                resourceParams.dwLocationInCmd                  = _MHW_CMD_DW_LOCATION(DW8_9.Value);
+
+                // upper bound of the allocated resource will not be set
+                resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
+
+                InitMocsParams(resourceParams, &cmd.DW8_9.Value[0], 5, 10);
+                MHW_MI_CHK_STATUS(AddResourceToCmd(
+                    this->m_osItf,
+                    this->m_currentCmdBuf,
+                    &resourceParams));
+
+                if (params.mocs4IndirectObjectBuffer != 0)
+                {
+                    cmd.DW8_9.IndirectObjectMemoryObjectControlState = params.mocs4IndirectObjectBuffer;
+                }
+                MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW8_9.IndirectObjectMemoryObjectControlState);
+                MHW_NORMALMESSAGE(
+                    "Feature Graph: Cache settings of DW8_9 IndirectObject in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
+                    cmd.DW8_9.IndirectObjectMemoryObjectControlState,
+                    (cmd.DW8_9.IndirectObjectMemoryObjectControlState >> 1) & 0x0000003f);
+                cmd.DW14.IndirectObjectBufferSize = (params.dwIndirectObjectBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
             }
-            MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW8_9.IndirectObjectMemoryObjectControlState);
-            MHW_NORMALMESSAGE(
-                "Feature Graph: Cache settings of DW8_9 IndirectObject in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
-                cmd.DW8_9.IndirectObjectMemoryObjectControlState,
-                (cmd.DW8_9.IndirectObjectMemoryObjectControlState >> 1) & 0x0000003f);
-            cmd.DW14.IndirectObjectBufferSize = (params.dwIndirectObjectBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
-        }
-
-        if (!Mos_ResourceIsNull(params.presInstructionBuffer))
-        {
-            cmd.DW10_11.InstructionBaseAddressModifyEnable   = true;
-            cmd.DW15.InstructionBufferSizeModifyEnable       = true;
-            resourceParams.presResource                      = params.presInstructionBuffer;
-            resourceParams.dwOffset                          = 0;
-            resourceParams.pdwCmd                            = cmd.DW10_11.Value;
-            resourceParams.dwLocationInCmd                   = _MHW_CMD_DW_LOCATION(DW10_11.Value);
 
-            // upper bound of the allocated resource will not be set
-            resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
+            if (!Mos_ResourceIsNull(params.presInstructionBuffer))
+            {
+                cmd.DW10_11.InstructionBaseAddressModifyEnable = true;
+                cmd.DW15.InstructionBufferSizeModifyEnable     = true;
+                resourceParams.presResource                    = params.presInstructionBuffer;
+                resourceParams.dwOffset                        = 0;
+                resourceParams.pdwCmd                          = cmd.DW10_11.Value;
+                resourceParams.dwLocationInCmd                 = _MHW_CMD_DW_LOCATION(DW10_11.Value);
+
+                // upper bound of the allocated resource will not be set
+                resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
+
+                InitMocsParams(resourceParams, &cmd.DW10_11.Value[0], 5, 10);
+
+                MHW_MI_CHK_STATUS(AddResourceToCmd(
+                    this->m_osItf,
+                    this->m_currentCmdBuf,
+                    &resourceParams));
+
+                if (params.mocs4InstructionCache != 0)
+                {
+                    cmd.DW10_11.InstructionMemoryObjectControlState = params.mocs4InstructionCache;
+                }
+                MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW10_11.InstructionMemoryObjectControlState);
+                MHW_NORMALMESSAGE(
+                    "Feature Graph: Cache settings of DW10_11 Instruction in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
+                    cmd.DW10_11.InstructionMemoryObjectControlState,
+                    (cmd.DW10_11.InstructionMemoryObjectControlState >> 1) & 0x0000003f);
+                cmd.DW15.InstructionBufferSize = (params.dwInstructionBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
+            }
 
-            InitMocsParams(resourceParams, &cmd.DW10_11.Value[0], 5, 10);
+            // stateless dataport access
+            cmd.DW3.StatelessDataPortAccessMemoryObjectControlState = params.mocs4StatelessDataport;
+            MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW3.StatelessDataPortAccessMemoryObjectControlState);
+            MHW_NORMALMESSAGE(
+                "Feature Graph: Cache settings of DW3 StatelessDataPortAccess in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
+                cmd.DW3.StatelessDataPortAccessMemoryObjectControlState,
+                (cmd.DW3.StatelessDataPortAccessMemoryObjectControlState >> 1) & 0x0000003f);
 
-            MHW_MI_CHK_STATUS(AddResourceToCmd(
-                this->m_osItf,
-                this->m_currentCmdBuf,
-                &resourceParams));
+            MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState);
+            MHW_NORMALMESSAGE(
+                "Feature Graph: Cache settings of DW16_17 BindlessSurfaceState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
+                cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState,
+                (cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState >> 1) & 0x0000003f);
 
-            if (params.mocs4InstructionCache != 0)
-            {
-                cmd.DW10_11.InstructionMemoryObjectControlState = params.mocs4InstructionCache;
-            }
-            MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW10_11.InstructionMemoryObjectControlState);
+            MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState);
             MHW_NORMALMESSAGE(
-                "Feature Graph: Cache settings of DW10_11 Instruction in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
-                cmd.DW10_11.InstructionMemoryObjectControlState,
-                (cmd.DW10_11.InstructionMemoryObjectControlState >> 1) & 0x0000003f);
-            cmd.DW15.InstructionBufferSize = (params.dwInstructionBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
+                "Feature Graph: Cache settings of DW19_20 BindlessSamplerState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
+                cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState,
+                (cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState >> 1) & 0x0000003f);
         }
 
-        // stateless dataport access
-        cmd.DW3.StatelessDataPortAccessMemoryObjectControlState = params.mocs4StatelessDataport;
-        MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW3.StatelessDataPortAccessMemoryObjectControlState);
-        MHW_NORMALMESSAGE(
-            "Feature Graph: Cache settings of DW3 StatelessDataPortAccess in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
-            cmd.DW3.StatelessDataPortAccessMemoryObjectControlState,
-            (cmd.DW3.StatelessDataPortAccessMemoryObjectControlState >> 1) & 0x0000003f);
-
-        MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState);
-        MHW_NORMALMESSAGE(
-            "Feature Graph: Cache settings of DW16_17 BindlessSurfaceState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
-            cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState,
-            (cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState >> 1) & 0x0000003f);
-
-        MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState);
-        MHW_NORMALMESSAGE(
-            "Feature Graph: Cache settings of DW19_20 BindlessSamplerState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u",
-            cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState,
-            (cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState >> 1) & 0x0000003f);
-
         return MOS_STATUS_SUCCESS;
     }
 
diff --git a/media_softlet/agnostic/common/hw/mhw_render_itf.h b/media_softlet/agnostic/common/hw/mhw_render_itf.h
index 538f2c1c22..f4934de02e 100644
--- a/media_softlet/agnostic/common/hw/mhw_render_itf.h
+++ b/media_softlet/agnostic/common/hw/mhw_render_itf.h
@@ -82,6 +82,8 @@ class Itf
 
     virtual MHW_RENDER_ENGINE_L3_CACHE_CONFIG* GetL3CacheConfig() = 0;
 
+    virtual MOS_STATUS SetupInlineData() = 0;
+
     _RENDER_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_ITF);
 MEDIA_CLASS_DEFINE_END(mhw__render__Itf)
 };
diff --git a/media_softlet/agnostic/common/hw/mhw_state_heap.cpp b/media_softlet/agnostic/common/hw/mhw_state_heap.cpp
index 3fb15d5ad5..2838f68b38 100644
--- a/media_softlet/agnostic/common/hw/mhw_state_heap.cpp
+++ b/media_softlet/agnostic/common/hw/mhw_state_heap.cpp
@@ -1652,6 +1652,7 @@ MOS_STATUS XMHW_STATE_HEAP_INTERFACE::ExtendStateHeapSta(
         AllocParams.Format   = Format_Buffer;
         AllocParams.dwBytes  = pNewStateHeap->dwSize;
         AllocParams.pBufName = "StateHeap";
+        AllocParams.ResUsageType = m_StateHeapSettings.m_heapUsageType;
 
         if (MEDIA_IS_SKU(skuTable, FtrLimitedLMemBar))
         {
diff --git a/media_softlet/agnostic/common/renderhal/renderhal.cpp b/media_softlet/agnostic/common/renderhal/renderhal.cpp
index c829c7515e..a45993228b 100644
--- a/media_softlet/agnostic/common/renderhal/renderhal.cpp
+++ b/media_softlet/agnostic/common/renderhal/renderhal.cpp
@@ -1440,6 +1440,7 @@ MOS_STATUS RenderHal_AllocateStateHeaps(
         MhwStateHeapSettings.dwDshSize     = pStateHeap->dwSizeGSH;
         MhwStateHeapSettings.dwIshSize     = pStateHeap->dwSizeISH;
         MhwStateHeapSettings.dwNumSyncTags = pStateHeap->dwSizeSync;
+        MhwStateHeapSettings.m_heapUsageType = pSettings->heapUsageType;
 
         if (pRenderHal->pRenderHalPltInterface->AllocateHeaps(pRenderHal, MhwStateHeapSettings) != MOS_STATUS_SUCCESS)
         {
@@ -6458,33 +6459,32 @@ MOS_STATUS RenderHal_SetSamplerStates(
     MHW_RENDERHAL_ASSERT( iSamplers <= pRenderHal->StateHeapSettings.iSamplers );
     MHW_RENDERHAL_ASSERT((iMediaID >= 0) && (iMediaID < pRenderHal->StateHeapSettings.iMediaIDs));
     //-----------------------------------------------
-
-    pStateHeap    = pRenderHal->pStateHeap;
-    pMediaState   = pRenderHal->pStateHeap->pCurMediaState;
+    pStateHeap  = pRenderHal->pStateHeap;
+    pMediaState = pRenderHal->pStateHeap->pCurMediaState;
 
     // Offset/Pointer to Samplers
     iOffsetSampler   = pMediaState->dwOffset +                      // Offset to media state
                        pStateHeap->dwOffsetSampler +                // Offset to sampler area
-                       iMediaID * pStateHeap->dwSizeSamplers;        // Samplers for media ID
+                       iMediaID * pStateHeap->dwSizeSamplers;       // Samplers for media ID
     pPtrSampler      = pStateHeap->pGshBuffer + iOffsetSampler;     // Pointer to Samplers
 
     iOffsetSampler   = pMediaState->dwOffset +                      // Offset to media state
                        pStateHeap->dwOffsetSamplerAVS +             // Offset to sampler area
-                       iMediaID * pStateHeap->dwSizeSamplers;     // Samplers for media ID
+                       iMediaID * pStateHeap->dwSizeSamplers;       // Samplers for media ID
     pPtrSamplerAvs   = pStateHeap->pGshBuffer + iOffsetSampler;     // Pointer to AVS Samplers
 
     // Setup sampler states
-    pSamplerStateParams = pSamplerParams; // Pointer to First Sampler State in array
-    for (i = 0; i < iSamplers; i++, pSamplerStateParams++,
-         pPtrSampler += pRenderHal->pHwSizes->dwSizeSamplerState)
+    pSamplerStateParams = pSamplerParams;  // Pointer to First Sampler State in array
+    for (i = 0; i < iSamplers; i++, pSamplerStateParams++, 
+        pPtrSampler += pRenderHal->pHwSizes->dwSizeSamplerState)
     {
         PrintSamplerParams(i, pSamplerStateParams);
         if (pSamplerStateParams->bInUse)
         {
             MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pOsInterface->pfnSetCmdBufferDebugInfo(
                 pRenderHal->pOsInterface,
-                true,  //bSamplerState
-                false, //bSurfaceState
+                true,    //bSamplerState
+                false,   //bSurfaceState
                 i,
                 pSamplerStateParams->SamplerType));
 
@@ -6517,6 +6517,115 @@ MOS_STATUS RenderHal_SetSamplerStates(
 }
 
 //!
+//! \brief      Sets Sampler States for Gen8
+//! \details    Initialize and set sampler states
+//! \param      PRENDERHAL_INTERFACE pRenderHal
+//!             [in]    Pointer to HW interface
+//! \param      int32_t iMediaID
+//!             [in]    Media Interface Descriptor ID
+//! \param      PRENDERHAL_SAMPLER_STATE_PARAMS pSamplerParams
+//!             [in]    Pointer to sampler state parameters
+//! \param      int32_t iSamplers
+//!             [in]    Number of samplers
+//! \return     MOS_STATUS MOS_STATUS_SUCCESS if success, otherwise MOS_STATUS_UNKNOWN
+//!
+MOS_STATUS RenderHal_SetAndGetSamplerStates(
+    PRENDERHAL_INTERFACE     pRenderHal,
+    int32_t                  iMediaID,
+    PMHW_SAMPLER_STATE_PARAM pSamplerParams,
+    int32_t                  iSamplers,
+    std::map<uint32_t, uint32_t> &samplerMap)
+{
+    MOS_STATUS               eStatus;
+    PRENDERHAL_STATE_HEAP    pStateHeap;
+    PMHW_SAMPLER_STATE_PARAM pSamplerStateParams;
+    PRENDERHAL_MEDIA_STATE   pMediaState;
+    int32_t                  iOffsetSampler;
+    uint8_t                 *pPtrSampler;
+    int32_t                  i;
+    uint32_t                 stateOffsets = 0;
+
+    eStatus = MOS_STATUS_UNKNOWN;
+
+    //-----------------------------------------------
+    MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
+    MHW_RENDERHAL_CHK_NULL_RETURN(pSamplerParams);
+    MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
+    MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState);
+    MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
+    MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap);
+    MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pGshBuffer);
+    MHW_RENDERHAL_ASSERT(iSamplers <= pRenderHal->StateHeapSettings.iSamplers);
+    MHW_RENDERHAL_ASSERT((iMediaID >= 0) && (iMediaID < pRenderHal->StateHeapSettings.iMediaIDs));
+    //-----------------------------------------------
+
+
+    if (pRenderHal->isBindlessHeapInUse == false)
+    {
+        return RenderHal_SetSamplerStates(pRenderHal, iMediaID, pSamplerParams, iSamplers);
+    }
+    else
+    {
+        pStateHeap  = pRenderHal->pStateHeap;
+        pMediaState = pRenderHal->pStateHeap->pCurMediaState;
+
+        // Offset/Pointer to Samplers
+        iOffsetSampler = pMediaState->dwOffset +                 // Offset to media state
+                         pStateHeap->dwOffsetSampler +           // Offset to sampler area
+                         iMediaID * pStateHeap->dwSizeSamplers;  // Samplers for media ID
+
+        pPtrSampler = pStateHeap->pGshBuffer + iOffsetSampler;  // Pointer to Samplers
+
+        // Setup sampler states
+        pSamplerStateParams = pSamplerParams;  // Pointer to First Sampler State in array
+        if (samplerMap.size() != 0)
+        {
+            MHW_RENDERHAL_ASSERTMESSAGE("samplerMap is not empty!");
+            samplerMap.clear();
+        }
+        for (i = 0; i < iSamplers; i++, pSamplerStateParams++, pPtrSampler += pRenderHal->pHwSizes->dwSizeSamplerState)
+        {
+            PrintSamplerParams(i, pSamplerStateParams);
+            if (pSamplerStateParams->bInUse)
+            {
+                MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pOsInterface->pfnSetCmdBufferDebugInfo(
+                    pRenderHal->pOsInterface,
+                    true,   //bSamplerState
+                    false,  //bSurfaceState
+                    i,
+                    pSamplerStateParams->SamplerType));
+
+                switch (pSamplerStateParams->SamplerType)
+                {
+                case MHW_SAMPLER_TYPE_3D:
+                    stateOffsets = iOffsetSampler + i * pRenderHal->pHwSizes->dwSizeSamplerState;
+                    eStatus      = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSampler, pSamplerStateParams);
+                    break;
+                default:
+                    eStatus = MOS_STATUS_INVALID_PARAMETER;
+                    MHW_RENDERHAL_ASSERTMESSAGE("Unknown Sampler Type.");
+                    break;
+                }
+
+                samplerMap.insert(std::make_pair(i, stateOffsets));
+
+                if (MOS_FAILED(eStatus))
+                {
+                    MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup Sampler");
+                    return eStatus;
+                }
+            }
+        }
+
+        eStatus = MOS_STATUS_SUCCESS;
+
+        return eStatus;
+
+    }
+
+}
+
+    //!
 //! \brief    Setup Surface State
 //! \details  Setup Surface States
 //! \param    PRENDERHAL_INTERFACE pRenderHal
@@ -7227,6 +7336,7 @@ MOS_STATUS RenderHal_InitInterface(
     // Other states
     pRenderHal->pfnSetVfeStateParams          = RenderHal_SetVfeStateParams;
     pRenderHal->pfnSetSamplerStates           = RenderHal_SetSamplerStates;
+    pRenderHal->pfnSetAndGetSamplerStates     = RenderHal_SetAndGetSamplerStates;
 
     pRenderHal->pfnIs2PlaneNV12Needed         = RenderHal_Is2PlaneNV12Needed;
 
@@ -7246,6 +7356,7 @@ MOS_STATUS RenderHal_InitInterface(
     pRenderHal->bEnableYV12SinglePass         = pRenderHal->pRenderHalPltInterface->IsEnableYV12SinglePass(pRenderHal);
     pRenderHal->dwSamplerAvsIncrement         = pRenderHal->pRenderHalPltInterface->GetSizeSamplerStateAvs(pRenderHal);
     pRenderHal->bComputeContextInUse          = pRenderHal->pRenderHalPltInterface->IsComputeContextInUse(pRenderHal);
+    pRenderHal->isBindlessHeapInUse           = pRenderHal->pRenderHalPltInterface->IsBindlessHeapInUse(pRenderHal);
 
     pRenderHal->dwMaskCrsThdConDataRdLn       = (uint32_t) -1;
     pRenderHal->dwMinNumberThreadsInGroup     = 1;
diff --git a/media_softlet/agnostic/common/renderhal/renderhal_platform_interface_next.cpp b/media_softlet/agnostic/common/renderhal/renderhal_platform_interface_next.cpp
index ce6b389999..f71df3ec61 100644
--- a/media_softlet/agnostic/common/renderhal/renderhal_platform_interface_next.cpp
+++ b/media_softlet/agnostic/common/renderhal/renderhal_platform_interface_next.cpp
@@ -1507,6 +1507,7 @@ MHW_SETPAR_DECL_SRC(STATE_BASE_ADDRESS, XRenderHal_Platform_Interface_Next)
     params.mocs4SurfaceState = pStateBaseParams->mocs4SurfaceState;
     params.mocs4IndirectObjectBuffer = pStateBaseParams->mocs4IndirectObjectBuffer;
     params.mocs4StatelessDataport = pStateBaseParams->mocs4StatelessDataport;
+    params.addressDis                 = m_renderHal->isBindlessHeapInUse;
 
     return MOS_STATUS_SUCCESS;
 }
diff --git a/media_softlet/agnostic/common/shared/packet/media_render_cmd_packet.cpp b/media_softlet/agnostic/common/shared/packet/media_render_cmd_packet.cpp
index bdc86be7f7..dc9d6896ba 100644
--- a/media_softlet/agnostic/common/shared/packet/media_render_cmd_packet.cpp
+++ b/media_softlet/agnostic/common/shared/packet/media_render_cmd_packet.cpp
@@ -375,7 +375,11 @@ MOS_STATUS RenderCmdPacket::SetPowerMode(uint32_t KernelID)
     return eStatus;
 }
 
-uint32_t RenderCmdPacket::SetSurfaceForHwAccess(PMOS_SURFACE surface, PRENDERHAL_SURFACE_NEXT pRenderSurface, PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams, bool bWrite)
+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];
@@ -471,6 +475,118 @@ uint32_t RenderCmdPacket::SetSurfaceForHwAccess(PMOS_SURFACE surface, PRENDERHAL
     return iBTEntry;
 }
 
+
+uint32_t RenderCmdPacket::SetSurfaceForHwAccess(
+    PMOS_SURFACE                    surface,
+    PRENDERHAL_SURFACE_NEXT         pRenderSurface,
+    PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
+    bool                            bWrite,
+    std::set<uint32_t>             &stateOffsets)
+{
+    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));
+
+        //set mem object control for cache
+        surfaceParams.MemObjCtl = (m_renderHal->pOsInterface->pfnCachePolicyGetMemoryObject(
+                                       MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER,
+                                       m_renderHal->pOsInterface->pfnGetGmmClientContext(m_renderHal->pOsInterface))).DwordValue;
+
+        pSurfaceParams = &surfaceParams;
+    }
+
+    if (pSurfaceParams->bAVS)
+    {
+        pSurfaceParams->Type = m_renderHal->SurfaceTypeAdvanced;
+    }
+    else
+    {
+        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));
+
+    if (!m_isLargeSurfaceStateNeeded)
+    {
+        if (m_renderData.bindingTableEntry > 15)
+        {
+            RENDER_PACKET_ASSERTMESSAGE("input surface support up to 16 RSS");
+            m_renderData.bindingTableEntry = 0;
+        }
+    }
+    else
+    {
+        if (m_renderData.bindingTableEntry > 255)
+        {
+            RENDER_PACKET_ASSERTMESSAGE("input surface support up to 256 RSS");
+            m_renderData.bindingTableEntry = 0;
+        }
+    }
+
+    uint32_t iBTEntry = m_renderData.bindingTableEntry;
+    if (m_renderHal->isBindlessHeapInUse == false)
+    {
+        // Bind surface states------------------------------------------------------
+        for (i = 0; i < iSurfaceEntries; i++, m_renderData.bindingTableEntry++)
+        {
+            RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnBindSurfaceState(
+                m_renderHal,
+                m_renderData.bindingTable,
+                m_renderData.bindingTableEntry,
+                pSurfaceEntries[i]));
+
+            pRenderSurface->Index = m_renderData.bindingTableEntry;
+        }
+    }
+    else
+    {
+        for (i = 0; i < iSurfaceEntries; i++)
+        {
+            stateOffsets.insert(pSurfaceEntries[i]->dwSurfStateOffset);
+        }
+    }
+
+    return iBTEntry;
+}
+
 MOS_STATUS RenderCmdPacket::SetSurfaceForHwAccess(
     PMOS_SURFACE                    surface,
     PRENDERHAL_SURFACE_NEXT         pRenderSurface,
@@ -578,6 +694,7 @@ MOS_STATUS RenderCmdPacket::SetSurfaceForHwAccess(
     PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
     std::set<uint32_t>             &bindingIndexes,
     bool                            bWrite,
+    std::set<uint32_t>             &stateOffsets,
     uint32_t                        capcityOfSurfaceEntries,
     PRENDERHAL_SURFACE_STATE_ENTRY *surfaceEntries,
     uint32_t                       *numOfSurfaceEntries)
@@ -656,19 +773,29 @@ MOS_STATUS RenderCmdPacket::SetSurfaceForHwAccess(
         }
     }
 
-    for (uint32_t const &bindingIndex : bindingIndexes)
+    if (m_renderHal->isBindlessHeapInUse == false)
     {
-        uint32_t iBTEntry = bindingIndex;
-        // Bind surface states------------------------------------------------------
-        for (i = 0; i < iSurfaceEntries; i++, iBTEntry++)
+        for (uint32_t const &bindingIndex : bindingIndexes)
         {
-            RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnBindSurfaceState(
-                m_renderHal,
-                m_renderData.bindingTable,
-                iBTEntry,
-                pSurfaceEntries[i]));
-
-            pRenderSurface->Index = iBTEntry;
+            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_renderData.bindingTable,
+                    iBTEntry,
+                    pSurfaceEntries[i]));
+
+                pRenderSurface->Index = iBTEntry;
+            }
+        }
+    }
+    else
+    {
+        for (i = 0; i < iSurfaceEntries; i++)
+        {
+            stateOffsets.insert(pSurfaceEntries[i]->dwSurfStateOffset);
         }
     }
 
@@ -681,7 +808,12 @@ MOS_STATUS RenderCmdPacket::SetSurfaceForHwAccess(
 }
 
 
-uint32_t RenderCmdPacket::SetBufferForHwAccess(PMOS_SURFACE buffer, PRENDERHAL_SURFACE_NEXT pRenderSurface, PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams, bool bWrite)
+uint32_t RenderCmdPacket::SetBufferForHwAccess(
+    PMOS_SURFACE                    buffer,
+    PRENDERHAL_SURFACE_NEXT         pRenderSurface,
+    PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
+    bool                            bWrite,
+    std::set<uint32_t>             &stateOffsets)
 {
     RENDERHAL_SURFACE              RenderHalSurface;
     RENDERHAL_SURFACE_STATE_PARAMS SurfaceParam;
@@ -722,16 +854,23 @@ uint32_t RenderCmdPacket::SetBufferForHwAccess(PMOS_SURFACE buffer, PRENDERHAL_S
         pSurfaceParams,
         &pSurfaceEntry));
 
-    // Bind surface state-------------------------------------------------------
-    RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnBindSurfaceState(
-        m_renderHal,
-        m_renderData.bindingTable,
-        m_renderData.bindingTableEntry,
-        pSurfaceEntry));
+    if (m_renderHal->isBindlessHeapInUse == false)
+    {
+        // Bind surface state-------------------------------------------------------
+        RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnBindSurfaceState(
+            m_renderHal,
+            m_renderData.bindingTable,
+            m_renderData.bindingTableEntry,
+            pSurfaceEntry));
 
-    pRenderSurface->Index = m_renderData.bindingTableEntry;
+        pRenderSurface->Index = m_renderData.bindingTableEntry;
 
-    m_renderData.bindingTableEntry++;
+        m_renderData.bindingTableEntry++;
+    }
+    else
+    {
+        stateOffsets.insert(pSurfaceEntry->dwSurfStateOffset);
+    }
     return pRenderSurface->Index;
 }
 
@@ -796,7 +935,8 @@ MOS_STATUS RenderCmdPacket::SetBufferForHwAccess(
     PRENDERHAL_SURFACE_NEXT         pRenderSurface,
     PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
     std::set<uint32_t>             &bindingIndexes,
-    bool                            bWrite)
+    bool                            bWrite,
+    std::set<uint32_t>             &stateOffsets)
 {
     RENDERHAL_SURFACE              RenderHalSurface = {};
     RENDERHAL_SURFACE_STATE_PARAMS SurfaceParam     = {};
@@ -841,17 +981,24 @@ MOS_STATUS RenderCmdPacket::SetBufferForHwAccess(
         pSurfaceParams,
         &pSurfaceEntry));
 
-    for (uint32_t const &bindingIndex : bindingIndexes)
+    if (m_renderHal->isBindlessHeapInUse == false)
     {
-        uint32_t iBTEntry = bindingIndex;
-        // Bind surface state-------------------------------------------------------
-        RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnBindSurfaceState(
-            m_renderHal,
-            m_renderData.bindingTable,
-            iBTEntry,
-            pSurfaceEntry));
+        for (uint32_t const &bindingIndex : bindingIndexes)
+        {
+            uint32_t iBTEntry = bindingIndex;
+            // Bind surface state-------------------------------------------------------
+            RENDER_PACKET_CHK_STATUS_RETURN(m_renderHal->pfnBindSurfaceState(
+                m_renderHal,
+                m_renderData.bindingTable,
+                iBTEntry,
+                pSurfaceEntry));
 
-        pRenderSurface->Index = bindingIndex;
+            pRenderSurface->Index = bindingIndex;
+        }
+    }
+    else
+    {
+        stateOffsets.insert(pSurfaceEntry->dwSurfStateOffset);
     }
 
     return eStatus;
@@ -1117,7 +1264,8 @@ MOS_STATUS RenderCmdPacket::PrepareComputeWalkerParams(KERNEL_WALKER_PARAMS para
 
     gpgpuWalker.SLMSize           = params.slmSize;
     gpgpuWalker.hasBarrier        = params.hasBarrier;
-    
+    gpgpuWalker.inlineDataParamBase   = params.inlineDataParams;
+
     return MOS_STATUS_SUCCESS;
 }
 
diff --git a/media_softlet/agnostic/common/shared/packet/media_render_cmd_packet.h b/media_softlet/agnostic/common/shared/packet/media_render_cmd_packet.h
index 3e864f5c1a..89ac89d9a5 100644
--- a/media_softlet/agnostic/common/shared/packet/media_render_cmd_packet.h
+++ b/media_softlet/agnostic/common/shared/packet/media_render_cmd_packet.h
@@ -120,7 +120,8 @@ typedef struct _KERNEL_WALKER_PARAMS
 
     bool                                hasBarrier;
     uint32_t                            slmSize;
-    
+    MHW_INLINE_DATA_PARAMS              inlineDataParams[MAX_INLINE_DATA_PARAMS];
+    uint32_t                            inlineDataParamNum;
 }KERNEL_WALKER_PARAMS, * PKERNEL_WALKER_PARAMS;
 
 typedef struct _KERNEL_PACKET_RENDER_DATA
@@ -197,6 +198,13 @@ class RenderCmdPacket : virtual public CmdPacket, public mhw::mi::Itf::ParSettin
         return MOS_STATUS_SUCCESS;
     }
 
+    virtual uint32_t SetSurfaceForHwAccess(
+        PMOS_SURFACE                    surface,
+        PRENDERHAL_SURFACE_NEXT         pRenderSurface,
+        PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
+        bool                            bWrite,
+        std::set<uint32_t>             &stateOffsets);
+
     // Step3: RSS Setup, return index insert in binding table
     virtual uint32_t SetSurfaceForHwAccess(
         PMOS_SURFACE                    surface,
@@ -220,6 +228,7 @@ class RenderCmdPacket : virtual public CmdPacket, public mhw::mi::Itf::ParSettin
         PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
         std::set<uint32_t>             &bindingIndexes,
         bool                            bWrite,
+        std::set<uint32_t>             &stateOffsets,
         uint32_t                        capcityOfSurfaceEntries = 0,
         PRENDERHAL_SURFACE_STATE_ENTRY *surfaceEntries      = nullptr,
         uint32_t                       *numOfSurfaceEntries = nullptr);
@@ -228,7 +237,8 @@ class RenderCmdPacket : virtual public CmdPacket, public mhw::mi::Itf::ParSettin
         PMOS_SURFACE                    buffer,
         PRENDERHAL_SURFACE_NEXT         pRenderSurface,
         PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
-        bool                            bWrite);
+        bool                            bWrite,
+        std::set<uint32_t>             &stateOffsets);
 
     virtual uint32_t SetBufferForHwAccess(
         PMOS_SURFACE                    buffer,
@@ -242,7 +252,8 @@ class RenderCmdPacket : virtual public CmdPacket, public mhw::mi::Itf::ParSettin
         PRENDERHAL_SURFACE_NEXT         pRenderSurface,
         PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
         std::set<uint32_t>             &bindingIndexes,
-        bool                            bWrite);
+        bool                            bWrite,
+        std::set<uint32_t>             &stateOffsets);
 
     virtual uint32_t SetBufferForHwAccess(
         MOS_BUFFER                      buffer,
diff --git a/media_softlet/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp b/media_softlet/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp
index 78ef920a47..0a593ec46d 100644
--- a/media_softlet/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp
+++ b/media_softlet/agnostic/common/vp/hal/packet/vp_render_cmd_packet.cpp
@@ -412,11 +412,13 @@ MOS_STATUS VpRenderCmdPacket::SetupSamplerStates()
             MOS_STATUS_INVALID_PARAMETER;
         }
 
-        VP_RENDER_CHK_STATUS_RETURN(m_renderHal->pfnSetSamplerStates(
+        VP_RENDER_CHK_STATUS_RETURN(m_renderHal->pfnSetAndGetSamplerStates(
             m_renderHal,
             m_renderData.mediaID,
             &samplerStates[0],
-            samplerStates.size()));
+            samplerStates.size(),
+            m_kernel->GetBindlessSamplers()));
+
     }
 
     return MOS_STATUS_SUCCESS;
@@ -676,6 +678,7 @@ MOS_STATUS VpRenderCmdPacket::SetupSurfaceState()
     VP_RENDER_CHK_NULL_RETURN(m_renderHal);
     VP_RENDER_CHK_NULL_RETURN(m_renderHal->pOsInterface);
 
+
     if (!m_kernel->GetKernelSurfaceConfig().empty())
     {
         for (auto surface = m_kernel->GetKernelSurfaceConfig().begin(); surface != m_kernel->GetKernelSurfaceConfig().end(); surface++)
@@ -756,6 +759,7 @@ MOS_STATUS VpRenderCmdPacket::SetupSurfaceState()
                 bWrite = false;
             }
 
+            std::set<uint32_t> stateOffsets;
             if (kernelSurfaceParam->surfaceOverwriteParams.bindedKernel && !kernelSurfaceParam->surfaceOverwriteParams.bufferResource)
             {
                 auto bindingMap = m_kernel->GetSurfaceBindingIndex(type);
@@ -769,6 +773,7 @@ MOS_STATUS VpRenderCmdPacket::SetupSurfaceState()
                     &renderSurfaceParams,
                     bindingMap,
                     bWrite,
+                    stateOffsets,
                     kernelSurfaceParam->iCapcityOfSurfaceEntry,
                     kernelSurfaceParam->surfaceEntries,
                     kernelSurfaceParam->sizeOfSurfaceEntries));
@@ -776,7 +781,6 @@ MOS_STATUS VpRenderCmdPacket::SetupSurfaceState()
                 {
                     VP_RENDER_NORMALMESSAGE("Using Binded Index Surface. KernelID %d, SurfType %d, bti %d", m_kernel->GetKernelId(), type, bti);
                 }
-                
             }
             else
             {
@@ -794,7 +798,8 @@ MOS_STATUS VpRenderCmdPacket::SetupSurfaceState()
                         &renderHalSurface,
                         &renderSurfaceParams,
                         bindingMap,
-                        bWrite));
+                        bWrite,
+                        stateOffsets));
                     for (uint32_t const &bti : bindingMap)
                     {
                         VP_RENDER_NORMALMESSAGE("Using Binded Index Buffer. KernelID %d, SurfType %d, bti %d", m_kernel->GetKernelId(), type, bti);
@@ -811,7 +816,8 @@ MOS_STATUS VpRenderCmdPacket::SetupSurfaceState()
                         &renderHalSurface.OsSurface,
                         &renderHalSurface,
                         &renderSurfaceParams,
-                        bWrite);
+                        bWrite,
+                        stateOffsets);
                     VP_RENDER_CHK_STATUS_RETURN(m_kernel->UpdateCurbeBindingIndex(type, index));
                     VP_RENDER_NORMALMESSAGE("Using UnBinded Index Buffer. KernelID %d, SurfType %d, bti %d", m_kernel->GetKernelId(), type, index);
                 }
@@ -821,11 +827,17 @@ MOS_STATUS VpRenderCmdPacket::SetupSurfaceState()
                         &renderHalSurface.OsSurface,
                         &renderHalSurface,
                         &renderSurfaceParams,
-                        bWrite);
+                        bWrite,
+                        stateOffsets);
                     VP_RENDER_CHK_STATUS_RETURN(m_kernel->UpdateCurbeBindingIndex(type, index));
                     VP_RENDER_NORMALMESSAGE("Using UnBinded Index Surface. KernelID %d, SurfType %d, bti %d. If 1D buffer overwrite to 2D for use, it will go SetSurfaceForHwAccess()", m_kernel->GetKernelId(), type, index);
                 }
             }
+
+            if (stateOffsets.size() > 0)
+            {
+                m_kernel->UpdateBindlessSurfaceResource(type, stateOffsets);
+            }
         }
         VP_RENDER_CHK_STATUS_RETURN(m_kernel->UpdateCompParams());
     }
@@ -1924,7 +1936,7 @@ MOS_STATUS VpRenderCmdPacket::SendMediaStates(
     // Send State Base Address command
     MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSendStateBaseAddress(pRenderHal, pCmdBuffer));
 
-    if (pRenderHal->bComputeContextInUse)
+    if (pRenderHal->bComputeContextInUse && !pRenderHal->isBindlessHeapInUse)
     {
         pRenderHal->pRenderHalPltInterface->SendTo3DStateBindingTablePoolAlloc(pRenderHal, pCmdBuffer);
     }
@@ -1946,8 +1958,11 @@ MOS_STATUS VpRenderCmdPacket::SendMediaStates(
     }
     else
     {
-        // set CFE State
-        MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->AddCfeStateCmd(pRenderHal, pCmdBuffer, pVfeStateParams));
+        if (!pRenderHal->isBindlessHeapInUse)
+        {
+            // set CFE State
+            MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->AddCfeStateCmd(pRenderHal, pCmdBuffer, pVfeStateParams));
+        }
     }
 
     // Send CURBE Load
diff --git a/media_softlet/agnostic/common/vp/hal/packet/vp_render_common.h b/media_softlet/agnostic/common/vp/hal/packet/vp_render_common.h
index 475a973870..03020d8811 100644
--- a/media_softlet/agnostic/common/vp/hal/packet/vp_render_common.h
+++ b/media_softlet/agnostic/common/vp/hal/packet/vp_render_common.h
@@ -80,6 +80,15 @@ enum KRN_ARG_ADDRESSMODE
     AddressIngModeMax
 };
 
+enum IMPLICIT_ARG_TYPE
+{
+    ValueType = 0,
+    IndirectDataPtr,
+    ScratchPtr,
+    SamplerStateBasePtr,
+    SurfaceStateBasePtr
+};
+
 struct KRN_ARG
 {
     uint32_t               uIndex;
@@ -89,6 +98,7 @@ struct KRN_ARG
     KRN_ARG_KIND           eArgKind;
     bool                   isOutput;
     KRN_ARG_ADDRESSMODE    addressMode;
+    IMPLICIT_ARG_TYPE      implicitArgType;
 };
 
 //for L0 use only
diff --git a/media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp b/media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp
index 822f56cf38..d6630cbd5f 100644
--- a/media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp
+++ b/media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.cpp
@@ -264,6 +264,7 @@ MOS_STATUS VpRenderKernelObj::SetupStatelessBufferResource(SurfaceType surf)
 MOS_STATUS VpRenderKernelObj::SetProcessSurfaceGroup(VP_SURFACE_GROUP &surfaces)
 {
     m_surfaceGroup = &surfaces;
+    VP_RENDER_CHK_STATUS_RETURN(InitBindlessResources());
     VP_RENDER_CHK_STATUS_RETURN(SetupSurfaceState());
     VP_RENDER_CHK_STATUS_RETURN(CpPrepareResources());
     VP_RENDER_CHK_STATUS_RETURN(SetupStatelessBuffer());
@@ -739,3 +740,37 @@ void VpRenderKernelObj::DumpSurface(VP_SURFACE* pSurface, PCCHAR fileName)
 #endif
 }
 
+MOS_STATUS VpRenderKernelObj::SetInlineDataParameter(KERNEL_WALKER_PARAMS &walkerParam, KRN_ARG args, RENDERHAL_INTERFACE *renderhal)
+{
+    VP_FUNC_CALL();
+    MHW_INLINE_DATA_PARAMS inlineDataPar = {};
+    VP_RENDER_CHK_NULL_RETURN(renderhal);
+    MHW_STATE_BASE_ADDR_PARAMS *pStateBaseParams = &renderhal->StateBaseAddressParams;
+    inlineDataPar.dwOffset                       = args.uOffsetInPayload;
+    inlineDataPar.dwSize                         = args.uSize;
+    if (args.implicitArgType == IndirectDataPtr || args.implicitArgType == SamplerStateBasePtr)
+    {
+        inlineDataPar.resource = pStateBaseParams->presGeneralState;
+        inlineDataPar.isPtrType = true;
+    }
+    else if (args.implicitArgType == SurfaceStateBasePtr)
+    {
+        // New Heaps
+        inlineDataPar.isPtrType = true;
+    }
+    else if (args.implicitArgType == ValueType)
+    {
+        inlineDataPar.isPtrType = false;
+    }
+    if (walkerParam.inlineDataParamNum < MAX_INLINE_DATA_PARAMS)
+    {
+        walkerParam.inlineDataParams[walkerParam.inlineDataParamNum] = inlineDataPar;
+        walkerParam.inlineDataParamNum++;
+    }
+    else
+    {
+        VP_RENDER_ASSERTMESSAGE("Exceed max inline data params!");
+    }
+
+    return MOS_STATUS_SUCCESS;
+}
\ No newline at end of file
diff --git a/media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h b/media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h
index 33890b1a45..8b9abf9dca 100644
--- a/media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h
+++ b/media_softlet/agnostic/common/vp/hal/packet/vp_render_kernel_obj.h
@@ -70,7 +70,8 @@ typedef struct _KERNEL_SURFACE_STATE_PARAM
     bool                                isOutput;        // true for render target
     PRENDERHAL_SURFACE_STATE_ENTRY      *surfaceEntries;
     uint32_t                            *sizeOfSurfaceEntries;
-    uint32_t                             iCapcityOfSurfaceEntry = 0;
+    uint32_t                            iCapcityOfSurfaceEntry = 0;
+    bool                                isBindlessSurface = false;
 } KERNEL_SURFACE_STATE_PARAM;
 
 typedef struct _KERNEL_TUNING_PARAMS
@@ -94,6 +95,8 @@ using KERNEL_SURFACE_CONFIG = std::map<SurfaceType, KERNEL_SURFACE_STATE_PARAM>;
 using KERNEL_SURFACE_BINDING_INDEX = std::map<SurfaceType, std::set<uint32_t>>;
 using KERNEL_ARG_INDEX_SURFACE_MAP = std::map<uint32_t, SURFACE_PARAMS>;
 using KERNEL_STATELESS_BUFF_CONFIG = std::map<SurfaceType, uint64_t>;
+using KERNEL_BINDELESS_SURFACE = std::map<SurfaceType, std::set<uint32_t>>;
+using KERNEL_BINDELESS_SAMPLER = std::map<uint32_t, uint32_t>;
 
 typedef struct _KERNEL_PARAMS
 {
@@ -534,6 +537,30 @@ class VpRenderKernelObj
 
     virtual MOS_STATUS InitRenderHalSurfaceCMF(MOS_SURFACE* src, PRENDERHAL_SURFACE renderHalSurface);
 
+    virtual MOS_STATUS SetInlineDataParameter(KERNEL_WALKER_PARAMS &walkerParam, KRN_ARG args, RENDERHAL_INTERFACE *renderhal);
+
+    virtual MOS_STATUS UpdateBindlessSurfaceResource(SurfaceType surf, std::set<uint32_t> surfStateOffset)
+    {
+        if (surf != SurfaceTypeInvalid)
+        {
+            m_bindlessSurfaceArray.insert(std::make_pair(surf, surfStateOffset));
+        }
+
+        return MOS_STATUS_SUCCESS;
+    }
+
+    virtual std::map<uint32_t, uint32_t>& GetBindlessSamplers()
+    {
+        return m_bindlessSamperArray;
+    }
+
+    virtual MOS_STATUS InitBindlessResources()
+    {
+        m_bindlessSurfaceArray.clear();
+        m_bindlessSamperArray.clear();
+        return MOS_STATUS_SUCCESS;
+    }
+
 protected:
 
     virtual MOS_STATUS SetWalkerSetting(KERNEL_THREAD_SPACE &threadSpace, bool bSyncFlag, bool flushL1 = false);
@@ -573,6 +600,8 @@ class VpRenderKernelObj
     PVpAllocator                                            m_allocator = nullptr;
     MediaUserSettingSharedPtr                               m_userSettingPtr = nullptr;  // usersettingInstance
     KERNEL_STATELESS_BUFF_CONFIG                            m_statelessArray;
+    KERNEL_BINDELESS_SURFACE                                m_bindlessSurfaceArray;
+    KERNEL_BINDELESS_SAMPLER                                m_bindlessSamperArray;
     // kernel attribute 
     std::string                                             m_kernelName = "";
     void *                                                  m_kernelBinary = nullptr;