diff --git a/media_driver/linux/common/codec/ddi/media_ddi_decode_base.cpp b/media_driver/linux/common/codec/ddi/media_ddi_decode_base.cpp
index ed98570fee..fa1ce7d8e9 100644
--- a/media_driver/linux/common/codec/ddi/media_ddi_decode_base.cpp
+++ b/media_driver/linux/common/codec/ddi/media_ddi_decode_base.cpp
@@ -994,6 +994,7 @@ VAStatus DdiMediaDecode::CreateBuffer(
     buf->uiOffset      = 0;
     buf->bCFlushReq    = false;
     buf->pMediaCtx     = m_ddiDecodeCtx->pMediaCtx;
+    buf->lock          = MOS_New(std::shared_timed_mutex);
 
     switch ((int32_t)type)
     {
@@ -1122,6 +1123,7 @@ VAStatus DdiMediaDecode::CreateBuffer(
     if(buf)
     {
         MOS_FreeMemory(buf->pData);
+        MOS_Delete(buf->lock);
         MOS_FreeMemory(buf);
     }
     return va;
diff --git a/media_driver/linux/common/codec/ddi/media_ddi_encode_base.cpp b/media_driver/linux/common/codec/ddi/media_ddi_encode_base.cpp
index a600f0e8b6..6f57ad9dc4 100644
--- a/media_driver/linux/common/codec/ddi/media_ddi_encode_base.cpp
+++ b/media_driver/linux/common/codec/ddi/media_ddi_encode_base.cpp
@@ -917,6 +917,7 @@ VAStatus DdiEncodeBase::CreateBuffer(
     buf->uiNumElements = elementsNum;
     buf->uiType        = type;
     buf->uiOffset      = 0;
+    buf->lock          = MOS_New(std::shared_timed_mutex);
 
     uint32_t bufSize = 0;
     uint32_t expectedSize = 0xffffffff;
diff --git a/media_driver/linux/common/codec/ddi/media_libva_decoder.cpp b/media_driver/linux/common/codec/ddi/media_libva_decoder.cpp
index f6dba1902f..f656c6c4ef 100755
--- a/media_driver/linux/common/codec/ddi/media_libva_decoder.cpp
+++ b/media_driver/linux/common/codec/ddi/media_libva_decoder.cpp
@@ -408,6 +408,7 @@ VAStatus DdiDecode_StatusReport(PDDI_MEDIA_CONTEXT mediaCtx, CodechalDecode *dec
                     (tempNewReport.m_codecStatus == CODECHAL_STATUS_INCOMPLETE)     ||
                     (tempNewReport.m_codecStatus == CODECHAL_STATUS_RESET))
                 {
+                    mediaCtx->pSurfaceHeap->lock->lock_shared();
                     PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapElmt = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)mediaCtx->pSurfaceHeap->pHeapBase;
 
                     uint32_t j = 0;
@@ -422,6 +423,7 @@ VAStatus DdiDecode_StatusReport(PDDI_MEDIA_CONTEXT mediaCtx, CodechalDecode *dec
                             break;
                         }
                     }
+                    mediaCtx->pSurfaceHeap->lock->unlock_shared();
                 }
                 else
                 {
@@ -488,6 +490,7 @@ VAStatus DdiDecode_StatusReport(PDDI_MEDIA_CONTEXT mediaCtx, DecodePipelineAdapt
                     (tempNewReport.codecStatus == CODECHAL_STATUS_INCOMPLETE)   ||
                     (tempNewReport.codecStatus == CODECHAL_STATUS_RESET))
                 {
+                    mediaCtx->pSurfaceHeap->lock->lock_shared();
                     PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapElmt = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)mediaCtx->pSurfaceHeap->pHeapBase;
 
                     uint32_t j = 0;
@@ -502,6 +505,7 @@ VAStatus DdiDecode_StatusReport(PDDI_MEDIA_CONTEXT mediaCtx, DecodePipelineAdapt
                             break;
                         }
                     }
+                    mediaCtx->pSurfaceHeap->lock->unlock_shared();
                 }
                 else
                 {
diff --git a/media_driver/linux/common/ddi/media_libva.cpp b/media_driver/linux/common/ddi/media_libva.cpp
index 20b6619614..7f19be68af 100755
--- a/media_driver/linux/common/ddi/media_libva.cpp
+++ b/media_driver/linux/common/ddi/media_libva.cpp
@@ -300,12 +300,12 @@ static uint32_t DdiMedia_CreateRenderTarget(
     int                           memType
 )
 {
-    DdiMediaUtil_LockMutex(&mediaDrvCtx->SurfaceMutex);
+    //DdiMediaUtil_LockMutex(&mediaDrvCtx->SurfaceMutex);
 
     PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = DdiMediaUtil_AllocPMediaSurfaceFromHeap(mediaDrvCtx->pSurfaceHeap);
     if (nullptr == surfaceElement)
     {
-        DdiMediaUtil_UnLockMutex(&mediaDrvCtx->SurfaceMutex);
+        //DdiMediaUtil_UnLockMutex(&mediaDrvCtx->SurfaceMutex);
         return VA_INVALID_ID;
     }
 
@@ -313,7 +313,7 @@ static uint32_t DdiMedia_CreateRenderTarget(
     if (nullptr == surfaceElement->pSurface)
     {
         DdiMediaUtil_ReleasePMediaSurfaceFromHeap(mediaDrvCtx->pSurfaceHeap, surfaceElement->uiVaSurfaceID);
-        DdiMediaUtil_UnLockMutex(&mediaDrvCtx->SurfaceMutex);
+        //DdiMediaUtil_UnLockMutex(&mediaDrvCtx->SurfaceMutex);
         return VA_INVALID_ID;
     }
 
@@ -326,18 +326,20 @@ static uint32_t DdiMedia_CreateRenderTarget(
     surfaceElement->pSurface->uiLockedImageID = VA_INVALID_ID;
     surfaceElement->pSurface->surfaceUsageHint= surfaceUsageHint;
     surfaceElement->pSurface->memType         = memType;
+    surfaceElement->pSurface->lock            = MOS_New(std::shared_timed_mutex);
 
     if(DdiMediaUtil_CreateSurface(surfaceElement->pSurface, mediaDrvCtx)!= VA_STATUS_SUCCESS)
     {
+        MOS_Delete(surfaceElement->pSurface->lock);
         MOS_FreeMemory(surfaceElement->pSurface);
         DdiMediaUtil_ReleasePMediaSurfaceFromHeap(mediaDrvCtx->pSurfaceHeap, surfaceElement->uiVaSurfaceID);
-        DdiMediaUtil_UnLockMutex(&mediaDrvCtx->SurfaceMutex);
+        //DdiMediaUtil_UnLockMutex(&mediaDrvCtx->SurfaceMutex);
         return VA_INVALID_ID;
     }
 
     mediaDrvCtx->uiNumSurfaces++;
     uint32_t surfaceID = surfaceElement->uiVaSurfaceID;
-    DdiMediaUtil_UnLockMutex(&mediaDrvCtx->SurfaceMutex);
+    //DdiMediaUtil_UnLockMutex(&mediaDrvCtx->SurfaceMutex);
     return surfaceID;
 }
 
@@ -999,11 +1001,13 @@ void* DdiMedia_GetCtxFromVABufferID (PDDI_MEDIA_CONTEXT mediaCtx, VABufferID buf
 
     uint32_t i      = (uint32_t)bufferID;
     DDI_CHK_LESS(i, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "invalid buffer id", nullptr);
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    mediaCtx->pBufferHeap->lock->lock_shared();
     PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement  = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)mediaCtx->pBufferHeap->pHeapBase;
     bufHeapElement += i;
     void *temp      = bufHeapElement->pCtx;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    mediaCtx->pBufferHeap->lock->unlock_shared();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
 
     return temp;
 }
@@ -1025,11 +1029,13 @@ uint32_t DdiMedia_GetCtxTypeFromVABufferID (PDDI_MEDIA_CONTEXT mediaCtx, VABuffe
 
     uint32_t i       = (uint32_t)bufferID;
     DDI_CHK_LESS(i, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "invalid buffer id", DDI_MEDIA_CONTEXT_TYPE_NONE);
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    mediaCtx->pBufferHeap->lock->lock_shared();
     PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement  = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)mediaCtx->pBufferHeap->pHeapBase;
     bufHeapElement  += i;
     uint32_t ctxType = bufHeapElement->uiCtxType;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    mediaCtx->pBufferHeap->lock->unlock_shared();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
 
     return ctxType;
 
@@ -1335,14 +1341,16 @@ VAStatus DdiMedia_MediaMemoryDecompress(PDDI_MEDIA_CONTEXT mediaCtx, DDI_MEDIA_S
         }
         else
         {
-            DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+            //DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+            mediaSurface->lock->lock();
             DdiMediaUtil_LockMutex(&mediaCtx->MemDecompMutex);
 
+            //Note: find surfaceElement from pSurface and surfaceElement->lock->lock_shared();
             DdiMedia_MediaSurfaceToMosResource(mediaSurface, &surface);
             DdiMedia_MediaMemoryDecompressInternal(&mosCtx, &surface);
-
             DdiMediaUtil_UnLockMutex(&mediaCtx->MemDecompMutex);
-            DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+            mediaSurface->lock->unlock();
+            //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
 
             if (pCpDdiInterface)
             {
@@ -1384,10 +1392,12 @@ static VAStatus DdiMedia_HeapInitialize(
     mediaCtx->pSurfaceHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
     DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr pSurfaceHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
     mediaCtx->pSurfaceHeap->uiHeapElementSize = sizeof(DDI_MEDIA_SURFACE_HEAP_ELEMENT);
+    mediaCtx->pSurfaceHeap->lock = MOS_New(std::shared_timed_mutex);
 
     mediaCtx->pBufferHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
     DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr BufferHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
     mediaCtx->pBufferHeap->uiHeapElementSize = sizeof(DDI_MEDIA_BUFFER_HEAP_ELEMENT);
+    mediaCtx->pBufferHeap->lock = MOS_New(std::shared_timed_mutex);
 
     mediaCtx->pImageHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
     DDI_CHK_NULL(mediaCtx->pImageHeap, "nullptr ImageHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
@@ -1445,9 +1455,17 @@ static VAStatus DdiMedia_HeapDestroy(
 {
     DDI_CHK_NULL(mediaCtx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
     // destroy heaps
+    if (mediaCtx->pSurfaceHeap->lock)
+    {
+        MOS_Delete(mediaCtx->pSurfaceHeap->lock);
+    }
     MOS_FreeMemory(mediaCtx->pSurfaceHeap->pHeapBase);
     MOS_FreeMemory(mediaCtx->pSurfaceHeap);
 
+    if (mediaCtx->pBufferHeap->lock)
+    {
+        MOS_Delete(mediaCtx->pBufferHeap->lock);
+    }
     MOS_FreeMemory(mediaCtx->pBufferHeap->pHeapBase);
     MOS_FreeMemory(mediaCtx->pBufferHeap);
 
@@ -2516,7 +2534,9 @@ VAStatus DdiMedia_DestroySurfaces (
     for(int32_t i = 0; i < num_surfaces; i++)
     {
         DDI_CHK_LESS((uint32_t)surfaces[i], mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surfaces", VA_STATUS_ERROR_INVALID_SURFACE);
-        surface = DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, surfaces[i]);
+        PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = DdiMedia_GetSurfaceElementFromVASurfaceID (mediaCtx, surfaces[i]);
+        DDI_CHK_NULL(surfaceElement, "nullptr surfaceElement", VA_STATUS_ERROR_INVALID_SURFACE);
+        surface = surfaceElement->pSurface;
         DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
         if(surface->pCurrentFrameSemaphore)
         {
@@ -2552,12 +2572,15 @@ VAStatus DdiMedia_DestroySurfaces (
             MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
         }
 
-        DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+        //DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+        //surface->lock->lock();
         DdiMediaUtil_FreeSurface(surface);
+        //surface->lock->unlock();
+        //MOS_Delete(surface->lock);
         MOS_FreeMemory(surface);
         DdiMediaUtil_ReleasePMediaSurfaceFromHeap(mediaCtx->pSurfaceHeap, (uint32_t)surfaces[i]);
         mediaCtx->uiNumSurfaces--;
-        DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+        //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
     }
 
     MOS_TraceEventExt(EVENT_VA_FREE_SURFACE, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
@@ -3216,6 +3239,7 @@ VAStatus DdiMedia_CreateContext (
         vaStatus = VA_STATUS_ERROR_INVALID_CONFIG;
     }
 
+    //printf(">>>>>>>>>>>>>>>>>>create va ctx id = %d\n", *context);
     return vaStatus;
 }
 
@@ -3274,7 +3298,7 @@ VAStatus DdiMedia_CreateBuffer (
 
     *bufId     = VA_INVALID_ID;
 
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
     VAStatus va = VA_STATUS_SUCCESS;
     switch (ctxType)
     {
@@ -3294,7 +3318,7 @@ VAStatus DdiMedia_CreateBuffer (
             va = VA_STATUS_ERROR_INVALID_CONTEXT;
     }
 
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
     MOS_TraceEventExt(EVENT_VA_BUFFER, EVENT_TYPE_END, bufId, sizeof(bufId), nullptr, 0);
     return va;
 }
@@ -3373,7 +3397,9 @@ VAStatus DdiMedia_MapBufferInternal (
     DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
     DDI_CHK_LESS((uint32_t)buf_id, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid bufferId", VA_STATUS_ERROR_INVALID_CONTEXT);
 
-    DDI_MEDIA_BUFFER   *buf     = DdiMedia_GetBufferFromVABufferID(mediaCtx, buf_id);
+    PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement = DdiMedia_GetBufferElementFromVABufferID(mediaCtx, buf_id);
+    DDI_CHK_NULL(bufHeapElement, "nullptr bufHeapElement", VA_STATUS_ERROR_INVALID_BUFFER);
+    DDI_MEDIA_BUFFER   *buf     = bufHeapElement->pBuffer;
     DDI_CHK_NULL(buf, "nullptr buf", VA_STATUS_ERROR_INVALID_BUFFER);
 
     // The context is nullptr when the buffer is created from DdiMedia_DeriveImage
@@ -3571,9 +3597,11 @@ VAStatus DdiMedia_MapBufferInternal (
             *pbuf = (void *)(buf->pData + buf->uiOffset);
             break;
         case VAEncMacroblockMapBufferType:
-            DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+            //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+            buf->lock->lock();
             *pbuf = DdiMediaUtil_LockBuffer(buf, flag);
-            DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+            buf->lock->unlock();
+            //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
             MOS_TraceEventExt(EVENT_VA_MAP, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
             if (nullptr == (*pbuf))
             {
@@ -3601,13 +3629,16 @@ VAStatus DdiMedia_MapBufferInternal (
         default:
             if((buf->format != Media_Format_CPU) && (DdiMedia_MediaFormatToOsFormat(buf->format) != VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT))
             {
-                DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+                //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+                buf->lock->lock();
                 // A critical section starts.
                 // Make sure not to bailout with a return until the section ends.
 
                 if (nullptr != buf->pSurface && Media_Format_CPU != buf->format)
                 {
+                    buf->pSurface->lock->lock();
                     vaStatus = DdiMedia_MediaMemoryDecompress(mediaCtx, buf->pSurface);
+                    buf->pSurface->lock->unlock();
                 }
 
                 if (VA_STATUS_SUCCESS == vaStatus)
@@ -3621,7 +3652,8 @@ VAStatus DdiMedia_MapBufferInternal (
                 }
 
                 // The critical section ends.
-                DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+                buf->lock->unlock();
+                //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
             }
             else
             {
@@ -3640,6 +3672,7 @@ VAStatus DdiMedia_MapBuffer (
     void                **pbuf
 )
 {
+    //printf(">>>>>>>vaMap buf: %d\n", buf_id);
     return DdiMedia_MapBufferInternal(ctx, buf_id, pbuf, MOS_LOCKFLAG_READONLY | MOS_LOCKFLAG_WRITEONLY);
 }
 
@@ -3659,7 +3692,9 @@ VAStatus DdiMedia_UnmapBuffer (
     DDI_CHK_NULL( mediaCtx->pBufferHeap, "nullptr  mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
     DDI_CHK_LESS((uint32_t)buf_id, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid buf_id", VA_STATUS_ERROR_INVALID_BUFFER);
 
-    DDI_MEDIA_BUFFER   *buf     = DdiMedia_GetBufferFromVABufferID(mediaCtx,  buf_id);
+    PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement = DdiMedia_GetBufferElementFromVABufferID(mediaCtx, buf_id);
+    DDI_CHK_NULL(bufHeapElement, "nullptr buf", VA_STATUS_ERROR_INVALID_BUFFER);
+    DDI_MEDIA_BUFFER   *buf     = bufHeapElement->pBuffer;
     DDI_CHK_NULL(buf, "nullptr buf", VA_STATUS_ERROR_INVALID_BUFFER);
 
     // The context is nullptr when the buffer is created from DdiMedia_DeriveImage
@@ -3731,9 +3766,11 @@ VAStatus DdiMedia_UnmapBuffer (
         default:
             if((buf->format != Media_Format_CPU) &&(DdiMedia_MediaFormatToOsFormat(buf->format) != VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT))
             {
-                DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+                //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+                buf->lock->lock();
                 DdiMediaUtil_UnlockBuffer(buf);
-                DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+                buf->lock->unlock();
+                //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
             }
             break;
     }
@@ -3747,6 +3784,7 @@ VAStatus DdiMedia_DestroyBuffer (
     VABufferID          buffer_id
 )
 {
+    //printf(">>>>>>>vaDestroy buf: %d\n", buffer_id);
     DDI_FUNCTION_ENTER();
     MOS_TraceEventExt(EVENT_VA_FREE_BUFFER, EVENT_TYPE_START, &buffer_id, sizeof(buffer_id), nullptr, 0);
 
@@ -3925,6 +3963,11 @@ VAStatus DdiMedia_DestroyBuffer (
             break;
             //return va_STATUS_SUCCESS;
     }
+    if (buf->lock)
+    {
+        //buf->lock->unlock(); //todo: lock ahead firstly?
+        MOS_Delete(buf->lock); //todo: delete lock to avoid leak? check MOS_FreeMemory(buf) in code
+    }
     MOS_FreeMemory(buf);
 
     DdiMedia_DestroyBufFromVABufferID(mediaCtx, buffer_id);
@@ -3932,12 +3975,14 @@ VAStatus DdiMedia_DestroyBuffer (
     return VA_STATUS_SUCCESS;
 }
 
+//#include <pthread.h>
 VAStatus DdiMedia_BeginPicture (
     VADriverContextP    ctx,
     VAContextID         context,
     VASurfaceID         render_target
 )
 {
+    //printf(">>>>>>>>>>>>>>>>>>begine pic: thread: %lx, va ctx id = %d\n", pthread_self(), context);
     DDI_FUNCTION_ENTER();
 
     DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
@@ -3953,17 +3998,21 @@ VAStatus DdiMedia_BeginPicture (
     uint32_t event[] = {(uint32_t)context, ctxType, (uint32_t)render_target};
     MOS_TraceEventExt(EVENT_VA_PICTURE, EVENT_TYPE_START, event, sizeof(event), nullptr, 0);
 
-    PDDI_MEDIA_SURFACE surface = DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, render_target);
+    PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = DdiMedia_GetSurfaceElementFromVASurfaceID (mediaCtx, render_target);
+    DDI_CHK_NULL(surfaceElement, "nullptr surfaceElement", VA_STATUS_ERROR_INVALID_SURFACE);
+    PDDI_MEDIA_SURFACE surface = surfaceElement->pSurface;
     DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
 
-    DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+    surface->lock->lock();
     surface->curCtxType = ctxType;
     surface->curStatusReportQueryState = DDI_MEDIA_STATUS_REPORT_QUERY_STATE_PENDING;
     if(ctxType == DDI_MEDIA_CONTEXT_TYPE_VP)
     {
         surface->curStatusReport.vpp.status = VPREP_NOTAVAILABLE;
     }
-    DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+    surface->lock->unlock();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
 
     switch (ctxType)
     {
@@ -4071,7 +4120,10 @@ static VAStatus DdiMedia_StatusCheck (
     PDDI_DECODE_CONTEXT decCtx = (PDDI_DECODE_CONTEXT)surface->pDecCtx;
     if (decCtx && surface->curCtxType == DDI_MEDIA_CONTEXT_TYPE_DECODER)
     {
-        DdiMediaUtil_LockGuard guard(&mediaCtx->SurfaceMutex);
+        PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = DdiMedia_GetSurfaceElementFromVASurfaceID (mediaCtx, surface_id);
+        DDI_CHK_NULL(surfaceElement , "nullptr surfaceElement", VA_STATUS_ERROR_INVALID_SURFACE);
+        //DdiMediaUtil_LockGuard guard(&mediaCtx->SurfaceMutex);
+        DdiMediaUtil_LockGuard2 guard(surface->lock);
 
         Codechal *codecHal = decCtx->pCodecHal;
         //return success just avoid vaDestroyContext is ahead of vaSyncSurface
@@ -4400,7 +4452,9 @@ VAStatus DdiMedia_QuerySurfaceError(
     PDDI_MEDIA_CONTEXT mediaCtx = DdiMedia_GetMediaContext(ctx);
     DDI_CHK_NULL( mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
 
-    DDI_MEDIA_SURFACE *surface = DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, render_target);
+    PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = DdiMedia_GetSurfaceElementFromVASurfaceID (mediaCtx, render_target);
+    DDI_CHK_NULL(surfaceElement, "nullptr surfaceElement", VA_STATUS_ERROR_INVALID_SURFACE);
+    DDI_MEDIA_SURFACE *surface = surfaceElement->pSurface;
     DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
 
     PDDI_DECODE_CONTEXT decCtx = (PDDI_DECODE_CONTEXT)surface->pDecCtx;
@@ -4411,7 +4465,8 @@ VAStatus DdiMedia_QuerySurfaceError(
 
     VAStatus vaStatus = VA_STATUS_SUCCESS;
 
-    DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+    surface->lock->lock_shared();
     if (surface->curStatusReportQueryState == DDI_MEDIA_STATUS_REPORT_QUERY_STATE_COMPLETED)
     {
         if (error_status != -1 && surface->curCtxType == DDI_MEDIA_CONTEXT_TYPE_DECODER)
@@ -4430,7 +4485,8 @@ VAStatus DdiMedia_QuerySurfaceError(
                 surfaceErrors[0].decode_error_type = VADecodeMBError;
 #endif
                 *error_info = surfaceErrors;
-                DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+                surface->lock->unlock_shared();
+                //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
                 return VA_STATUS_SUCCESS;
             }
 #if VA_CHECK_VERSION(1, 20, 0)
@@ -4442,7 +4498,8 @@ VAStatus DdiMedia_QuerySurfaceError(
                 surfaceErrors[0].status            = 1;
                 surfaceErrors[0].decode_error_type = VADecodeReset;
                 *error_info                        = surfaceErrors;
-                DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+                surface->lock->unlock_shared();
+                //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
                 return VA_STATUS_SUCCESS;
             }
 #endif
@@ -4470,20 +4527,23 @@ VAStatus DdiMedia_QuerySurfaceError(
                 }
             }
 
-            DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+            surface->lock->unlock_shared();
+            //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
             return vaStatus;
         }
 
         if (surface->curCtxType == DDI_MEDIA_CONTEXT_TYPE_VP &&
             surface->curStatusReport.vpp.status == CODECHAL_STATUS_ERROR)
         {
-            DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+            surface->lock->unlock_shared();
+            //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
             return VA_STATUS_SUCCESS;
         }
     }
 
     surfaceErrors[0].status = -1;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+    surface->lock->unlock_shared();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
     return VA_STATUS_SUCCESS;
 }
 
@@ -4744,25 +4804,28 @@ VAStatus DdiMedia_CreateImage(
     buf->format            = Media_Format_CPU;//DdiCodec_OsFormatToMediaFormat(vaimg->format.fourcc); //Media_Format_Buffer;
     buf->uiOffset          = 0;
     buf->pMediaCtx         = mediaCtx;
+    buf->lock              = MOS_New(std::shared_timed_mutex);
 
     //Put Image in untiled buffer for better CPU access?
     VAStatus status= DdiMediaUtil_CreateBuffer(buf,  mediaCtx->pDrmBufMgr);
     if((status != VA_STATUS_SUCCESS))
     {
         MOS_FreeMemory(vaimg);
+        MOS_Delete(buf->lock);
         MOS_FreeMemory(buf);
         return status;
     }
     buf->TileType     = TILING_NONE;
 
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
     PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufferHeapElement  = DdiMediaUtil_AllocPMediaBufferFromHeap(mediaCtx->pBufferHeap);
 
     if (nullptr == bufferHeapElement)
     {
-        DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+        //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
         MOS_FreeMemory(vaimg);
         DdiMediaUtil_FreeBuffer(buf);
+        //MOS_Delete(buf->lock);
         MOS_FreeMemory(buf);
         return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
     }
@@ -4773,7 +4836,7 @@ VAStatus DdiMedia_CreateImage(
 
     vaimg->buf                   = bufferHeapElement->uiVaBufferID;
     mediaCtx->uiNumBufs++;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
 
     DdiMediaUtil_LockMutex(&mediaCtx->ImageMutex);
     PDDI_MEDIA_IMAGE_HEAP_ELEMENT imageHeapElement = DdiMediaUtil_AllocPVAImageFromHeap(mediaCtx->pImageHeap);
@@ -5076,15 +5139,18 @@ VAStatus DdiMedia_DeriveImage (
     buf->format        = mediaSurface->format;
     buf->TileType      = mediaSurface->TileType;
     buf->pSurface      = mediaSurface;
+    buf->lock          = MOS_New(std::shared_timed_mutex);
+    //buf->lock          = mediaSurface->lock;
     mos_bo_reference(mediaSurface->bo);
 
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
     PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufferHeapElement = DdiMediaUtil_AllocPMediaBufferFromHeap(mediaCtx->pBufferHeap);
 
     if (nullptr == bufferHeapElement)
     {
-        DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+        //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
         MOS_FreeMemory(vaimg);
+        MOS_Delete(buf->lock);
         MOS_FreeMemory(buf);
         return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
     }
@@ -5094,7 +5160,7 @@ VAStatus DdiMedia_DeriveImage (
 
     vaimg->buf             = bufferHeapElement->uiVaBufferID;
     mediaCtx->uiNumBufs++;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
 
     *image = *vaimg;
 
@@ -6789,7 +6855,9 @@ VAStatus DdiMedia_AcquireBufferHandle(
     PDDI_MEDIA_CONTEXT mediaCtx = DdiMedia_GetMediaContext(ctx);
     DDI_CHK_NULL(mediaCtx,          "Invalid Media ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
 
-    DDI_MEDIA_BUFFER   *buf     = DdiMedia_GetBufferFromVABufferID(mediaCtx, buf_id);
+    PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement = DdiMedia_GetBufferElementFromVABufferID(mediaCtx, buf_id);
+    DDI_CHK_NULL(bufHeapElement, "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
+    DDI_MEDIA_BUFFER   *buf     = bufHeapElement->pBuffer;
     DDI_CHK_NULL(buf,          "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
     DDI_CHK_NULL(buf->bo,      "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
 
@@ -6805,14 +6873,16 @@ VAStatus DdiMedia_AcquireBufferHandle(
         return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
     }
 
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    buf->lock->lock();
     // already acquired?
     if (buf->uiExportcount)
     {   // yes, already acquired
         // can't provide access thru another memtype
         if (buf->uiMemtype != buf_info->mem_type)
         {
-            DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+            buf->lock->unlock();
+            //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
             return VA_STATUS_ERROR_INVALID_PARAMETER;
         }
     }
@@ -6823,7 +6893,8 @@ VAStatus DdiMedia_AcquireBufferHandle(
             uint32_t flink = 0;
             if (mos_bo_flink(buf->bo, &flink) != 0)
             {
-                DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+                buf->lock->unlock();
+                //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
                 return VA_STATUS_ERROR_INVALID_BUFFER;
             }
             buf->handle = (intptr_t)flink;
@@ -6833,7 +6904,8 @@ VAStatus DdiMedia_AcquireBufferHandle(
             int32_t prime_fd = 0;
             if (mos_bo_export_to_prime(buf->bo, &prime_fd) != 0)
             {
-                DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+                buf->lock->unlock();
+                //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
                 return VA_STATUS_ERROR_INVALID_BUFFER;
             }
 
@@ -6852,7 +6924,8 @@ VAStatus DdiMedia_AcquireBufferHandle(
     buf_info->handle = buf->handle;
     buf_info->mem_size = buf->uiNumElements * buf->iSize;
 
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    buf->lock->unlock();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
     return VA_STATUS_SUCCESS;
 }
 
@@ -6878,14 +6951,18 @@ VAStatus DdiMedia_ReleaseBufferHandle(
     PDDI_MEDIA_CONTEXT mediaCtx = DdiMedia_GetMediaContext(ctx);
     DDI_CHK_NULL(mediaCtx, "Invalid Media ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
 
-    DDI_MEDIA_BUFFER   *buf     = DdiMedia_GetBufferFromVABufferID(mediaCtx, buf_id);
+    PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement = DdiMedia_GetBufferElementFromVABufferID(mediaCtx, buf_id);
+    DDI_CHK_NULL(bufHeapElement, "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
+    DDI_MEDIA_BUFFER   *buf     = bufHeapElement->pBuffer;
     DDI_CHK_NULL(buf,          "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
     DDI_CHK_NULL(buf->bo,      "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
 
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    buf->lock->lock();
     if (!buf->uiMemtype || !buf->uiExportcount)
     {
-        DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+        buf->lock->unlock();
+        //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
         return VA_STATUS_SUCCESS;
     }
     mos_bo_unreference(buf->bo);
@@ -6900,7 +6977,8 @@ VAStatus DdiMedia_ReleaseBufferHandle(
         }
         buf->uiMemtype = 0;
     }
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    buf->lock->unlock();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
 
     if (!buf->uiExportcount && buf->bPostponedBufFree) {
         MOS_FreeMemory(buf);
diff --git a/media_driver/linux/common/ddi/media_libva_common.cpp b/media_driver/linux/common/ddi/media_libva_common.cpp
index bea8b673e8..6378dd4e9f 100644
--- a/media_driver/linux/common/ddi/media_libva_common.cpp
+++ b/media_driver/linux/common/ddi/media_libva_common.cpp
@@ -130,7 +130,7 @@ void* DdiMedia_GetContextFromContextID (VADriverContextP ctx, VAContextID vaCtxI
 
 }
 
-DDI_MEDIA_SURFACE* DdiMedia_GetSurfaceFromVASurfaceID (PDDI_MEDIA_CONTEXT mediaCtx, VASurfaceID surfaceID)
+PDDI_MEDIA_SURFACE_HEAP_ELEMENT DdiMedia_GetSurfaceElementFromVASurfaceID (PDDI_MEDIA_CONTEXT mediaCtx, VASurfaceID surfaceID)
 {
     uint32_t                         i = 0;
     PDDI_MEDIA_SURFACE_HEAP_ELEMENT  surfaceElement = nullptr;
@@ -143,13 +143,25 @@ DDI_MEDIA_SURFACE* DdiMedia_GetSurfaceFromVASurfaceID (PDDI_MEDIA_CONTEXT mediaC
     if(validSurface)
     {
         DDI_CHK_LESS(i, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "invalid surface id", nullptr);
-        DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+        mediaCtx->pSurfaceHeap->lock->lock();
+        //DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
         surfaceElement  = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)mediaCtx->pSurfaceHeap->pHeapBase;
         surfaceElement += i;
-        surface         = surfaceElement->pSurface;
-        DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+        mediaCtx->pSurfaceHeap->lock->unlock();
+        //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
     }
 
+    return surfaceElement;
+}
+
+DDI_MEDIA_SURFACE* DdiMedia_GetSurfaceFromVASurfaceID (PDDI_MEDIA_CONTEXT mediaCtx, VASurfaceID surfaceID)
+{
+    PDDI_MEDIA_SURFACE_HEAP_ELEMENT  surfaceElement = nullptr;
+    PDDI_MEDIA_SURFACE               surface = nullptr;
+
+    surfaceElement = DdiMedia_GetSurfaceElementFromVASurfaceID(mediaCtx, surfaceID);
+    surface = surfaceElement != nullptr ? surfaceElement->pSurface : nullptr;
+
     return surface;
 }
 
@@ -157,15 +169,18 @@ VASurfaceID DdiMedia_GetVASurfaceIDFromSurface(PDDI_MEDIA_SURFACE surface)
 {
     DDI_CHK_NULL(surface, "nullptr surface", VA_INVALID_SURFACE);
 
+    surface->pMediaCtx->pSurfaceHeap->lock->lock();
     PDDI_MEDIA_SURFACE_HEAP_ELEMENT  surfaceElement = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surface->pMediaCtx->pSurfaceHeap->pHeapBase;
     for(uint32_t i = 0; i < surface->pMediaCtx->pSurfaceHeap->uiAllocatedHeapElements; i ++)
     {
         if(surface == surfaceElement->pSurface)
         {
+            surface->pMediaCtx->pSurfaceHeap->lock->unlock();
             return surfaceElement->uiVaSurfaceID;
         }
         surfaceElement ++;
     }
+    surface->pMediaCtx->pSurfaceHeap->lock->unlock();
     return VA_INVALID_SURFACE;
 }
 
@@ -219,7 +234,8 @@ PDDI_MEDIA_SURFACE DdiMedia_ReplaceSurfaceWithNewFormat(PDDI_MEDIA_SURFACE surfa
     }
 
     //lock surface heap
-    DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->SurfaceMutex);
+    mediaCtx->pSurfaceHeap->lock->lock();
     uint32_t i;
     //get current element heap and index
     for(i = 0; i < mediaCtx->pSurfaceHeap->uiAllocatedHeapElements; i ++)
@@ -233,7 +249,8 @@ PDDI_MEDIA_SURFACE DdiMedia_ReplaceSurfaceWithNewFormat(PDDI_MEDIA_SURFACE surfa
     //if cant find
     if(i == surface->pMediaCtx->pSurfaceHeap->uiAllocatedHeapElements)
     {
-        DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+        mediaCtx->pSurfaceHeap->lock->unlock();
+        //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
         if(dstSurface->pShadowBuffer)
         {
             MOS_FreeMemory(dstSurface->pShadowBuffer->pGmmResourceInfo);
@@ -249,7 +266,8 @@ PDDI_MEDIA_SURFACE DdiMedia_ReplaceSurfaceWithNewFormat(PDDI_MEDIA_SURFACE surfa
     DdiMediaUtil_FreeSurface(surface);
     MOS_FreeMemory(surface);
 
-    DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
+    mediaCtx->pSurfaceHeap->lock->unlock();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->SurfaceMutex);
 
     return dstSurface;
 }
@@ -274,16 +292,18 @@ PDDI_MEDIA_SURFACE DdiMedia_ReplaceSurfaceWithVariant(PDDI_MEDIA_SURFACE surface
         return nullptr;
     }
 
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    surface->pMediaCtx->pSurfaceHeap->lock->lock();
     PDDI_MEDIA_SURFACE_HEAP_ELEMENT  surfaceElement = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surface->pMediaCtx->pSurfaceHeap->pHeapBase;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    surface->pMediaCtx->pSurfaceHeap->lock->unlock();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
     if (nullptr == surfaceElement)
     {
         return nullptr;
     }
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
     surfaceElement += vaID;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
 
     aligned_format = surface->format;
     switch (surface->format)
@@ -348,11 +368,11 @@ PDDI_MEDIA_SURFACE DdiMedia_ReplaceSurfaceWithVariant(PDDI_MEDIA_SURFACE surface
         return surface;
     }
     //replace the surface
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
     surfaceElement = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surface->pMediaCtx->pSurfaceHeap->pHeapBase;
     surfaceElement += vaID;
     surfaceElement->pSurface = dstSurface;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
     //FreeSurface
     DdiMediaUtil_FreeSurface(surface);
     MOS_FreeMemory(surface);
@@ -360,29 +380,41 @@ PDDI_MEDIA_SURFACE DdiMedia_ReplaceSurfaceWithVariant(PDDI_MEDIA_SURFACE surface
     return dstSurface;
 }
 
-DDI_MEDIA_BUFFER* DdiMedia_GetBufferFromVABufferID (PDDI_MEDIA_CONTEXT mediaCtx, VABufferID bufferID)
+PDDI_MEDIA_BUFFER_HEAP_ELEMENT DdiMedia_GetBufferElementFromVABufferID (PDDI_MEDIA_CONTEXT mediaCtx, VABufferID bufferID)
 {
     uint32_t                       i = 0;
     PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement = nullptr;
-    PDDI_MEDIA_BUFFER              buf = nullptr;
 
     i                = (uint32_t)bufferID;
     DDI_CHK_LESS(i, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "invalid buffer id", nullptr);
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    mediaCtx->pBufferHeap->lock->lock();
     bufHeapElement  = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)mediaCtx->pBufferHeap->pHeapBase;
     bufHeapElement += i;
-    buf             = bufHeapElement->pBuffer;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    mediaCtx->pBufferHeap->lock->unlock();
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+
+    return bufHeapElement;
+}
+
+
+DDI_MEDIA_BUFFER* DdiMedia_GetBufferFromVABufferID (PDDI_MEDIA_CONTEXT mediaCtx, VABufferID bufferID)
+{
+    PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement = nullptr;
+    PDDI_MEDIA_BUFFER              buf = nullptr;
+
+    bufHeapElement  = DdiMedia_GetBufferElementFromVABufferID(mediaCtx, bufferID);
+    buf             = bufHeapElement != nullptr? bufHeapElement->pBuffer : nullptr;
 
     return buf;
 }
 
 bool DdiMedia_DestroyBufFromVABufferID (PDDI_MEDIA_CONTEXT mediaCtx, VABufferID bufferID)
 {
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
     DdiMediaUtil_ReleasePMediaBufferFromHeap(mediaCtx->pBufferHeap, bufferID);
     mediaCtx->uiNumBufs--;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
     return true;
 }
 
@@ -394,11 +426,11 @@ void* DdiMedia_GetContextFromVABufferID (PDDI_MEDIA_CONTEXT mediaCtx, VABufferID
 
     i                = (uint32_t)bufferID;
     DDI_CHK_LESS(i, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "invalid buffer id", nullptr);
-    DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_LockMutex(&mediaCtx->BufferMutex);
     bufHeapElement  = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)mediaCtx->pBufferHeap->pHeapBase;
     bufHeapElement += bufferID;
     ctx            = bufHeapElement->pCtx;
-    DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
+    //DdiMediaUtil_UnLockMutex(&mediaCtx->BufferMutex);
 
     return ctx;
 }
diff --git a/media_driver/linux/common/ddi/media_libva_common.h b/media_driver/linux/common/ddi/media_libva_common.h
index 4a9b653b1a..650edf838f 100644
--- a/media_driver/linux/common/ddi/media_libva_common.h
+++ b/media_driver/linux/common/ddi/media_libva_common.h
@@ -156,6 +156,19 @@ void DdiMedia_MediaBufferToMosResource(DDI_MEDIA_BUFFER *mediaBuffer, MOS_RESOUR
 //!
 void* DdiMedia_GetContextFromContextID (VADriverContextP ctx, VAContextID vaCtxID, uint32_t *ctxType);
 
+//!
+//! \brief  Get surface element from VA surface ID
+//!
+//! \param  [in] mediaCtx
+//!     Pointer to ddi media context
+//! \param  [in] surfaceID
+//!     VA surface ID
+//!
+//! \return PDDI_MEDIA_SURFACE_HEAP_ELEMENT
+//!     Pointer to ddi media surface element
+//!
+PDDI_MEDIA_SURFACE_HEAP_ELEMENT DdiMedia_GetSurfaceElementFromVASurfaceID (PDDI_MEDIA_CONTEXT mediaCtx, VASurfaceID surfaceID);
+
 //!
 //! \brief  Get surface from VA surface ID
 //!
@@ -204,6 +217,19 @@ PDDI_MEDIA_SURFACE DdiMedia_ReplaceSurfaceWithVariant(PDDI_MEDIA_SURFACE surface
 //!
 VASurfaceID DdiMedia_GetVASurfaceIDFromSurface(PDDI_MEDIA_SURFACE surface);
 
+//!
+//! \brief  Get buffer element from VA buffer ID
+//!
+//! \param  [in] mediaCtx
+//!     Pointer to ddi media context
+//! \param  [in] bufferID
+//!     VA buffer ID
+//!
+//! \return PDDI_MEDIA_BUFFER_HEAP_ELEMENT
+//!     Pointer to ddi media buffer element
+//!
+PDDI_MEDIA_BUFFER_HEAP_ELEMENT DdiMedia_GetBufferElementFromVABufferID (PDDI_MEDIA_CONTEXT mediaCtx, VABufferID bufferID);
+
 //!
 //! \brief  Get buffer from VA buffer ID
 //!
diff --git a/media_driver/linux/common/ddi/media_libva_util.cpp b/media_driver/linux/common/ddi/media_libva_util.cpp
index a4e12edfae..e6f7b34131 100755
--- a/media_driver/linux/common/ddi/media_libva_util.cpp
+++ b/media_driver/linux/common/ddi/media_libva_util.cpp
@@ -1192,6 +1192,7 @@ void* DdiMediaUtil_LockSurface(DDI_MEDIA_SURFACE* surface, uint32_t flag)
 {
     DDI_CHK_NULL(surface, "nullptr surface", nullptr);
     DDI_CHK_NULL(surface->pMediaCtx, "nullptr surface->pMediaCtx", nullptr);
+    surface->lock->lock();
     if (MEDIA_IS_SKU(&surface->pMediaCtx->SkuTable, FtrLocalMemory))
     {
         if ((MosUtilities::MosAtomicIncrement(&surface->iRefCount) == 1) && (false == surface->bMapped))
@@ -1215,6 +1216,7 @@ void* DdiMediaUtil_LockSurface(DDI_MEDIA_SURFACE* surface, uint32_t flag)
          }
          surface->iRefCount++;
     }
+    surface->lock->unlock();
 
     return surface->pData;
 
@@ -1506,6 +1508,8 @@ void DdiMediaUtil_FreeSurface(DDI_MEDIA_SURFACE *surface)
     DDI_CHK_NULL(surface->pMediaCtx, "nullptr surface->pMediaCtx", );
     DDI_CHK_NULL(surface->pMediaCtx->pGmmClientContext, "nullptr surface->pMediaCtx->pGmmClientContext", );
 
+    if (surface->lock)
+        surface->lock->lock();
     // Unmap Aux mapping if the surface was mapped
     if (surface->pMediaCtx->m_auxTableMgr)
     {
@@ -1538,6 +1542,12 @@ void DdiMediaUtil_FreeSurface(DDI_MEDIA_SURFACE *surface)
         surface->pMediaCtx->pGmmClientContext->DestroyResInfoObject(surface->pGmmResourceInfo);
         surface->pGmmResourceInfo = nullptr;
     }
+
+    if (surface->lock)
+    {
+        surface->lock->unlock();
+        MOS_Delete(surface->lock);
+    }
 }
 
 
@@ -1546,6 +1556,10 @@ void DdiMediaUtil_FreeBuffer(DDI_MEDIA_BUFFER  *buf)
 {
     DDI_CHK_NULL(buf, "nullptr", );
     // calling sequence checking
+    if (buf->lock)
+    {
+        buf->lock->lock();
+    }
     if (buf->bMapped)
     {
         DdiMediaUtil_UnlockBuffer(buf);
@@ -1567,6 +1581,12 @@ void DdiMediaUtil_FreeBuffer(DDI_MEDIA_BUFFER  *buf)
         buf->pMediaCtx->pGmmClientContext->DestroyResInfoObject(buf->pGmmResourceInfo);
         buf->pGmmResourceInfo = nullptr;
     }
+
+    if (buf->lock)
+    {
+        buf->lock->unlock();
+        MOS_Delete(buf->lock);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1660,12 +1680,14 @@ PDDI_MEDIA_SURFACE_HEAP_ELEMENT DdiMediaUtil_AllocPMediaSurfaceFromHeap(PDDI_MED
 
     PDDI_MEDIA_SURFACE_HEAP_ELEMENT  mediaSurfaceHeapElmt = nullptr;
 
+    surfaceHeap->lock->lock();
     if (nullptr == surfaceHeap->pFirstFreeHeapElement)
     {
         void *newHeapBase = MOS_ReallocMemory(surfaceHeap->pHeapBase, (surfaceHeap->uiAllocatedHeapElements + DDI_MEDIA_HEAP_INCREMENTAL_SIZE) * sizeof(DDI_MEDIA_SURFACE_HEAP_ELEMENT));
 
         if (nullptr == newHeapBase)
         {
+            surfaceHeap->lock->unlock();
             DDI_ASSERTMESSAGE("DDI: realloc failed.");
             return nullptr;
         }
@@ -1684,6 +1706,7 @@ PDDI_MEDIA_SURFACE_HEAP_ELEMENT DdiMediaUtil_AllocPMediaSurfaceFromHeap(PDDI_MED
 
     mediaSurfaceHeapElmt                          = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surfaceHeap->pFirstFreeHeapElement;
     surfaceHeap->pFirstFreeHeapElement            = mediaSurfaceHeapElmt->pNextFree;
+    surfaceHeap->lock->unlock();
 
     return mediaSurfaceHeapElmt;
 }
@@ -1697,12 +1720,14 @@ void DdiMediaUtil_ReleasePMediaSurfaceFromHeap(PDDI_MEDIA_HEAP surfaceHeap, uint
     PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapBase                   = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surfaceHeap->pHeapBase;
     DDI_CHK_NULL(mediaSurfaceHeapBase, "nullptr mediaSurfaceHeapBase", );
 
+    surfaceHeap->lock->lock();
     PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapElmt                   = &mediaSurfaceHeapBase[vaSurfaceID];
     DDI_CHK_NULL(mediaSurfaceHeapElmt->pSurface, "surface is already released", );
     void *firstFree                         = surfaceHeap->pFirstFreeHeapElement;
     surfaceHeap->pFirstFreeHeapElement     = (void*)mediaSurfaceHeapElmt;
     mediaSurfaceHeapElmt->pNextFree        = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)firstFree;
     mediaSurfaceHeapElmt->pSurface         = nullptr;
+    surfaceHeap->lock->unlock();
 }
 
 
@@ -1711,6 +1736,7 @@ PDDI_MEDIA_BUFFER_HEAP_ELEMENT DdiMediaUtil_AllocPMediaBufferFromHeap(PDDI_MEDIA
     DDI_CHK_NULL(bufferHeap, "nullptr bufferHeap", nullptr);
 
     PDDI_MEDIA_BUFFER_HEAP_ELEMENT  mediaBufferHeapElmt = nullptr;
+    bufferHeap->lock->lock();
     if (nullptr == bufferHeap->pFirstFreeHeapElement)
     {
         void *newHeapBase = MOS_ReallocMemory(bufferHeap->pHeapBase, (bufferHeap->uiAllocatedHeapElements + DDI_MEDIA_HEAP_INCREMENTAL_SIZE) * sizeof(DDI_MEDIA_BUFFER_HEAP_ELEMENT));
@@ -1733,6 +1759,7 @@ PDDI_MEDIA_BUFFER_HEAP_ELEMENT DdiMediaUtil_AllocPMediaBufferFromHeap(PDDI_MEDIA
 
     mediaBufferHeapElmt                       = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)bufferHeap->pFirstFreeHeapElement;
     bufferHeap->pFirstFreeHeapElement         = mediaBufferHeapElmt->pNextFree;
+    bufferHeap->lock->unlock();
     return mediaBufferHeapElmt;
 }
 
@@ -1742,6 +1769,7 @@ void DdiMediaUtil_ReleasePMediaBufferFromHeap(PDDI_MEDIA_HEAP bufferHeap, uint32
     DDI_CHK_NULL(bufferHeap, "nullptr bufferHeap", );
 
     DDI_CHK_LESS(vaBufferID, bufferHeap->uiAllocatedHeapElements, "invalid buffer id", );
+    bufferHeap->lock->lock();
     PDDI_MEDIA_BUFFER_HEAP_ELEMENT mediaBufferHeapBase                    = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)bufferHeap->pHeapBase;
     PDDI_MEDIA_BUFFER_HEAP_ELEMENT mediaBufferHeapElmt                    = &mediaBufferHeapBase[vaBufferID];
     DDI_CHK_NULL(mediaBufferHeapElmt->pBuffer, "buffer is already released", );
@@ -1749,6 +1777,7 @@ void DdiMediaUtil_ReleasePMediaBufferFromHeap(PDDI_MEDIA_HEAP bufferHeap, uint32
     bufferHeap->pFirstFreeHeapElement      = (void*)mediaBufferHeapElmt;
     mediaBufferHeapElmt->pNextFree         = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)firstFree;
     mediaBufferHeapElmt->pBuffer           = nullptr;
+    bufferHeap->lock->unlock();
 }
 
 PDDI_MEDIA_IMAGE_HEAP_ELEMENT DdiMediaUtil_AllocPVAImageFromHeap(PDDI_MEDIA_HEAP imageHeap)
diff --git a/media_driver/linux/common/ddi/media_libva_util.h b/media_driver/linux/common/ddi/media_libva_util.h
index 8f434859bc..1e326ec6b3 100644
--- a/media_driver/linux/common/ddi/media_libva_util.h
+++ b/media_driver/linux/common/ddi/media_libva_util.h
@@ -195,6 +195,20 @@ class DdiMediaUtil_LockGuard {
     }
 };
 
+class DdiMediaUtil_LockGuard2 {
+private:
+    std::shared_timed_mutex *m_pLock;
+public:
+    DdiMediaUtil_LockGuard2(std::shared_timed_mutex *pLock):m_pLock(pLock)
+    {
+        m_pLock->lock();
+    }
+    ~DdiMediaUtil_LockGuard2()
+    {
+        m_pLock->unlock();
+    }
+};
+
 //!
 //! \brief  Destroy semaphore
 //! 
diff --git a/media_driver/linux/common/vp/ddi/media_libva_vp.c b/media_driver/linux/common/vp/ddi/media_libva_vp.c
index dcff2555a7..cb7fff40b2 100644
--- a/media_driver/linux/common/vp/ddi/media_libva_vp.c
+++ b/media_driver/linux/common/vp/ddi/media_libva_vp.c
@@ -3069,6 +3069,7 @@ VAStatus DdiVp_CreateBuffer(
     pBuf->format        = Media_Format_Buffer;
     pBuf->uiOffset      = 0;
     pBuf->pData         = (uint8_t*)MOS_AllocAndZeroMemory(uiSize * uiNumElements);
+    pBuf->lock          = MOS_New(std::shared_timed_mutex);
     if (nullptr == pBuf->pData)
     {
         MOS_FreeMemAndSetNull(pBuf);
diff --git a/media_softlet/linux/common/ddi/media_libva_common_next.h b/media_softlet/linux/common/ddi/media_libva_common_next.h
index f4736fbb11..221e1541d8 100644
--- a/media_softlet/linux/common/ddi/media_libva_common_next.h
+++ b/media_softlet/linux/common/ddi/media_libva_common_next.h
@@ -34,6 +34,8 @@
 #include "GmmLib.h"
 #include "mos_bufmgr_api.h"
 #include "mos_defs_specific.h"
+//#include <mutex>
+#include <shared_mutex>
 
 #define DDI_MEDIA_MAX_SURFACE_NUMBER_CONTEXT       127
 #define DDI_MEDIA_MAX_INSTANCE_NUMBER              0x0FFFFFFF
@@ -258,6 +260,7 @@ typedef struct _DDI_MEDIA_SURFACE
 
     uint32_t                uiVariantFlag;
     int                     memType;
+    std::shared_timed_mutex            *lock = nullptr;;
 } DDI_MEDIA_SURFACE, *PDDI_MEDIA_SURFACE;
 
 typedef struct _DDI_MEDIA_BUFFER
@@ -289,6 +292,7 @@ typedef struct _DDI_MEDIA_BUFFER
     PDDI_MEDIA_SURFACE     pSurface          = nullptr;
     GMM_RESOURCE_INFO     *pGmmResourceInfo  = nullptr; // GMM resource descriptor
     PDDI_MEDIA_CONTEXT     pMediaCtx         = nullptr; // Media driver Context
+    std::shared_timed_mutex            *lock = nullptr;;
 } DDI_MEDIA_BUFFER, *PDDI_MEDIA_BUFFER;
 
 typedef struct _DDI_MEDIA_SURFACE_HEAP_ELEMENT
@@ -327,6 +331,8 @@ typedef struct _DDI_MEDIA_HEAP
     uint32_t           uiHeapElementSize;
     uint32_t           uiAllocatedHeapElements;
     void               *pFirstFreeHeapElement;
+    //std::shared_timed_mutex lock;
+    std::shared_timed_mutex            *lock = nullptr;;
 }DDI_MEDIA_HEAP, *PDDI_MEDIA_HEAP;
 
 #ifndef ANDROID