/* * Copyright (c) 2021, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file media_libva_common_next.cpp //! \brief libva common next implementaion. //! #include #include "mos_utilities.h" #include "media_libva_common_next.h" #include "media_libva_util_next.h" #include "mos_solo_generic.h" #include "mos_interface.h" #include "media_libva_interface_next.h" #include "media_ddi_prot.h" DDI_MEDIA_SURFACE* MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(PDDI_MEDIA_CONTEXT mediaCtx, VASurfaceID surfaceID) { uint32_t id = 0; PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = nullptr; PDDI_MEDIA_SURFACE surface = nullptr; DDI_FUNC_ENTER; DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", nullptr); id = (uint32_t)surfaceID; bool validSurface = (id != VA_INVALID_SURFACE); if(validSurface) { DDI_CHK_LESS(id, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "invalid surface id", nullptr); MosUtilities::MosLockMutex(&mediaCtx->SurfaceMutex); surfaceElement = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)mediaCtx->pSurfaceHeap->pHeapBase; surfaceElement += id; surface = surfaceElement->pSurface; MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex); } return surface; } void MediaLibvaCommonNext::MediaSurfaceToMosResource(DDI_MEDIA_SURFACE *mediaSurface, MOS_RESOURCE *mosResource) { DDI_FUNC_ENTER; DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface",); DDI_CHK_NULL(mosResource, "nullptr mosResource",); MosInterface::ConvertResourceFromDdi(mediaSurface, mosResource, OS_SPECIFIC_RESOURCE_SURFACE, 0); Mos_Solo_SetOsResource(mediaSurface->pGmmResourceInfo, mosResource); return; } void MediaLibvaCommonNext::MediaBufferToMosResource(DDI_MEDIA_BUFFER *mediaBuffer, MOS_RESOURCE *mosResource) { DDI_FUNC_ENTER; DDI_CHK_NULL(mediaBuffer, "nullptr mediaBuffer",); DDI_CHK_NULL(mosResource, "nullptr mosResource",); if (nullptr == mediaBuffer->bo) { DDI_ASSERTMESSAGE("nullptr mediaBuffer->bo"); } MosInterface::ConvertResourceFromDdi(mediaBuffer, mosResource, OS_SPECIFIC_RESOURCE_BUFFER, 0); Mos_Solo_SetOsResource(mediaBuffer->pGmmResourceInfo, mosResource); return; } VASurfaceID MediaLibvaCommonNext::GetVASurfaceIDFromSurface(PDDI_MEDIA_SURFACE surface) { DDI_FUNC_ENTER; DDI_CHK_NULL(surface, "nullptr surface", VA_INVALID_SURFACE); DDI_CHK_NULL(surface->pMediaCtx, "nullptr mediaCtx", VA_INVALID_SURFACE); DDI_CHK_NULL(surface->pMediaCtx->pSurfaceHeap, "nullptr surface heap", VA_INVALID_SURFACE); PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surface->pMediaCtx->pSurfaceHeap->pHeapBase; DDI_CHK_NULL(surfaceElement, "nullptr surface element", VA_INVALID_SURFACE); for(uint32_t i = 0; i < surface->pMediaCtx->pSurfaceHeap->uiAllocatedHeapElements; i ++) { if(surface == surfaceElement->pSurface) { return surfaceElement->uiVaSurfaceID; } surfaceElement ++; } return VA_INVALID_SURFACE; } PDDI_MEDIA_SURFACE MediaLibvaCommonNext::ReplaceSurfaceWithNewFormat(PDDI_MEDIA_SURFACE surface, DDI_MEDIA_FORMAT expectedFormat) { DDI_FUNC_ENTER; DDI_CHK_NULL(surface, "nullptr surface", nullptr); PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surface->pMediaCtx->pSurfaceHeap->pHeapBase; PDDI_MEDIA_CONTEXT mediaCtx = surface->pMediaCtx; // Check some conditions if (expectedFormat == surface->format) { return surface; } // Create new dst surface and copy the structure PDDI_MEDIA_SURFACE dstSurface = (DDI_MEDIA_SURFACE *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_SURFACE)); if (nullptr == surfaceElement) { MOS_FreeMemory(dstSurface); return nullptr; } MOS_SecureMemcpy(dstSurface, sizeof(DDI_MEDIA_SURFACE), surface, sizeof(DDI_MEDIA_SURFACE)); DDI_CHK_NULL(dstSurface, "nullptr dstSurface", nullptr); dstSurface->format = expectedFormat; dstSurface->uiLockedBufID = VA_INVALID_ID; dstSurface->uiLockedImageID = VA_INVALID_ID; dstSurface->pSurfDesc = nullptr; // Lock surface heap MosUtilities::MosLockMutex(&mediaCtx->SurfaceMutex); uint32_t i; // Get current element heap and index for (i = 0; i < mediaCtx->pSurfaceHeap->uiAllocatedHeapElements; i++) { if (surface == surfaceElement->pSurface) { break; } surfaceElement++; } // If cant find if (i == surface->pMediaCtx->pSurfaceHeap->uiAllocatedHeapElements) { MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex); MOS_FreeMemory(dstSurface); return nullptr; } // FreeSurface MediaLibvaUtilNext::FreeSurface(surface); MOS_FreeMemory(surface); // CreateNewSurface MediaLibvaUtilNext::CreateSurface(dstSurface,mediaCtx); surfaceElement->pSurface = dstSurface; MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex); return dstSurface; } PDDI_MEDIA_SURFACE MediaLibvaCommonNext::ReplaceSurfaceWithVariant(PDDI_MEDIA_SURFACE surface, VAEntrypoint entrypoint) { DDI_FUNC_ENTER; DDI_CHK_NULL(surface, "nullptr surface", nullptr); PDDI_MEDIA_CONTEXT mediaCtx = surface->pMediaCtx; DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", nullptr); uint32_t alignedWidth, alignedHeight; DDI_MEDIA_FORMAT alignedFormat; if(surface->uiVariantFlag) { return surface; } VASurfaceID vaID = MediaLibvaCommonNext::GetVASurfaceIDFromSurface(surface); if(VA_INVALID_SURFACE == vaID) { return nullptr; } MosUtilities::MosLockMutex(&mediaCtx->SurfaceMutex); PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surface->pMediaCtx->pSurfaceHeap->pHeapBase; if (surfaceElement == nullptr) { MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex); return nullptr; } surfaceElement += vaID; MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex); alignedFormat = surface->format; switch (surface->format) { case Media_Format_AYUV: #if VA_CHECK_VERSION(1, 13, 0) case Media_Format_XYUV: #endif alignedWidth = MOS_ALIGN_CEIL(surface->iWidth, 128); alignedHeight = MOS_ALIGN_CEIL(surface->iHeight * 3 / 4, 64); break; case Media_Format_Y410: alignedWidth = MOS_ALIGN_CEIL(surface->iWidth, 64); alignedHeight = MOS_ALIGN_CEIL(surface->iHeight * 3 / 2, 64); break; case Media_Format_Y216: #if VA_CHECK_VERSION(1, 9, 0) case Media_Format_Y212: #endif case Media_Format_Y210: alignedWidth = (surface->iWidth + 1) >> 1; alignedHeight = surface->iHeight * 2; alignedFormat = Media_Format_Y216; break; case Media_Format_YUY2: alignedWidth = (surface->iWidth + 1) >> 1; alignedHeight = surface->iHeight * 2; break; case Media_Format_P016: case Media_Format_P012: case Media_Format_P010: alignedHeight = surface->iHeight; alignedWidth = surface->iWidth; if(entrypoint == VAEntrypointEncSlice) { alignedWidth = surface->iWidth * 2; alignedFormat = Media_Format_NV12; } else { alignedFormat = Media_Format_P016; } break; default: return surface; } //create new dst surface and copy the structure PDDI_MEDIA_SURFACE dstSurface = (DDI_MEDIA_SURFACE *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_SURFACE)); DDI_CHK_NULL(dstSurface, "nullptr dstSurface", nullptr); MOS_SecureMemcpy(dstSurface,sizeof(DDI_MEDIA_SURFACE),surface,sizeof(DDI_MEDIA_SURFACE)); dstSurface->uiVariantFlag = 1; dstSurface->format = alignedFormat; dstSurface->iWidth = alignedWidth; dstSurface->iHeight = alignedHeight; //CreateNewSurface if(MediaLibvaUtilNext::CreateSurface(dstSurface,mediaCtx) != VA_STATUS_SUCCESS) { MOS_FreeMemory(dstSurface); return surface; } //replace the surface MosUtilities::MosLockMutex(&mediaCtx->SurfaceMutex); surfaceElement = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surface->pMediaCtx->pSurfaceHeap->pHeapBase; surfaceElement += vaID; surfaceElement->pSurface = dstSurface; MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex); //FreeSurface MediaLibvaUtilNext::FreeSurface(surface); MOS_FreeMemory(surface); return dstSurface; } DDI_MEDIA_BUFFER* MediaLibvaCommonNext::GetBufferFromVABufferID( PDDI_MEDIA_CONTEXT mediaCtx, VABufferID bufferID) { DDI_FUNC_ENTER; DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", nullptr); 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); MosUtilities::MosLockMutex(&mediaCtx->BufferMutex); bufHeapElement = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)mediaCtx->pBufferHeap->pHeapBase; bufHeapElement += i; buf = bufHeapElement->pBuffer; MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex); return buf; } void* MediaLibvaCommonNext::GetVaContextFromHeap( PDDI_MEDIA_HEAP mediaHeap, uint32_t index, PMOS_MUTEX mutex) { PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT vaCtxHeapElmt = nullptr; void *context = nullptr; DDI_FUNC_ENTER; MosUtilities::MosLockMutex(mutex); if(nullptr == mediaHeap || index >= mediaHeap->uiAllocatedHeapElements) { MosUtilities::MosUnlockMutex(mutex); return nullptr; } vaCtxHeapElmt = (PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT)mediaHeap->pHeapBase; vaCtxHeapElmt += index; context = vaCtxHeapElmt->pVaContext; MosUtilities::MosUnlockMutex(mutex); return context; } void* MediaLibvaCommonNext::GetContextFromContextID( VADriverContextP ctx, VAContextID vaCtxID, uint32_t *ctxType) { PDDI_MEDIA_CONTEXT mediaCtx = nullptr; uint32_t index = 0; DDI_FUNC_ENTER; DDI_CHK_NULL(ctx, "nullptr ctx", nullptr); DDI_CHK_NULL(ctxType, "nullptr ctxType", nullptr); if (vaCtxID < DDI_MEDIA_VACONTEXTID_BASE) { DDI_ASSERTMESSAGE("Invalid ContextID"); return nullptr; } mediaCtx = GetMediaContext(ctx); index = vaCtxID & DDI_MEDIA_MASK_VACONTEXTID; if (index >= DDI_MEDIA_MAX_INSTANCE_NUMBER) { return nullptr; } if ((vaCtxID & DDI_MEDIA_MASK_VACONTEXT_TYPE) == DDI_MEDIA_SOFTLET_VACONTEXTID_DECODER_OFFSET) { DDI_VERBOSEMESSAGE("Decode context detected: 0x%x", vaCtxID); *ctxType = DDI_MEDIA_CONTEXT_TYPE_DECODER; return GetVaContextFromHeap(mediaCtx->pDecoderCtxHeap, index, &mediaCtx->DecoderMutex); } else if ((vaCtxID & DDI_MEDIA_MASK_VACONTEXT_TYPE) == DDI_MEDIA_SOFTLET_VACONTEXTID_ENCODER_OFFSET) { *ctxType = DDI_MEDIA_CONTEXT_TYPE_ENCODER; return GetVaContextFromHeap(mediaCtx->pEncoderCtxHeap, index, &mediaCtx->EncoderMutex); } else if ((vaCtxID & DDI_MEDIA_MASK_VACONTEXT_TYPE) == DDI_MEDIA_SOFTLET_VACONTEXTID_VP_OFFSET) { *ctxType = DDI_MEDIA_CONTEXT_TYPE_VP; return GetVaContextFromHeap(mediaCtx->pVpCtxHeap, index, &mediaCtx->VpMutex); } else if ((vaCtxID & DDI_MEDIA_MASK_VACONTEXT_TYPE) == DDI_MEDIA_SOFTLET_VACONTEXTID_CP_OFFSET) { DDI_VERBOSEMESSAGE("Protected session detected: 0x%x", vaCtxID); *ctxType = DDI_MEDIA_CONTEXT_TYPE_PROTECTED; index = index & DDI_MEDIA_MASK_VAPROTECTEDSESSION_ID; return GetVaContextFromHeap(mediaCtx->pProtCtxHeap, index, &mediaCtx->ProtMutex); } else { DDI_ASSERTMESSAGE("Invalid context: 0x%x", vaCtxID); *ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE; return nullptr; } } uint32_t MediaLibvaCommonNext::GetCtxTypeFromVABufferID(PDDI_MEDIA_CONTEXT mediaCtx, VABufferID bufferID) { PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement = nullptr; uint32_t i = 0; uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE; DDI_FUNC_ENTER; DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", DDI_MEDIA_CONTEXT_TYPE_NONE); DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_PARAMETER); i = (uint32_t)bufferID; DDI_CHK_LESS(i, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "invalid buffer id", DDI_MEDIA_CONTEXT_TYPE_NONE); MosUtilities::MosLockMutex(&mediaCtx->BufferMutex); bufHeapElement = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)mediaCtx->pBufferHeap->pHeapBase; bufHeapElement += i; ctxType = bufHeapElement->uiCtxType; MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex); return ctxType; } void* MediaLibvaCommonNext::GetCtxFromVABufferID(PDDI_MEDIA_CONTEXT mediaCtx, VABufferID bufferID) { uint32_t i = 0; PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufHeapElement = nullptr; DDI_FUNC_ENTER; DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", nullptr); DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", nullptr); i = (uint32_t)bufferID; DDI_CHK_LESS(i, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "invalid buffer id", nullptr); MosUtilities::MosLockMutex(&mediaCtx->BufferMutex); bufHeapElement = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)mediaCtx->pBufferHeap->pHeapBase; bufHeapElement += i; void *temp = bufHeapElement->pCtx; MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex); return temp; } int32_t MediaLibvaCommonNext::GetGpuPriority( VADriverContextP ctx, VABufferID *buffers, int32_t numBuffers, bool *updatePriority, int32_t *priority) { void *data = nullptr; uint32_t updateSessionPriority = 0; uint32_t priorityValue = 0; int32_t priorityIndexInBuf = -1; PDDI_MEDIA_CONTEXT mediaCtx = nullptr; DDI_MEDIA_BUFFER *buf = nullptr; VAContextParameterUpdateBuffer *contextParamBuf = nullptr; DDI_FUNC_ENTER; DDI_CHK_NULL(ctx, "nullptr context in GetGpuPriority!", -1); mediaCtx = GetMediaContext(ctx); DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", -1); #if VA_CHECK_VERSION(1, 10, 0) for (int32_t i = 0; i < numBuffers; i++) { buf = GetBufferFromVABufferID(mediaCtx, buffers[i]); DDI_CHK_NULL(buf, "Invalid buffer.", -1); if ((int32_t)buf->uiType == VAContextParameterUpdateBufferType) { //Read the priority from the VAContextParameterUpdateBuffer MediaLibvaInterfaceNext::MapBuffer(ctx, buffers[i], &data); DDI_CHK_NULL(data, "nullptr data.", -1); contextParamBuf = (VAContextParameterUpdateBuffer *)data; DDI_CHK_NULL(contextParamBuf, "nullptr contextParamBuf.", -1); updateSessionPriority = contextParamBuf->flags.bits.context_priority_update; priorityValue = contextParamBuf->context_priority.bits.priority; if (updateSessionPriority) { *updatePriority = true; if (priorityValue <= CONTEXT_PRIORITY_MAX) { *priority = priorityValue - CONTEXT_PRIORITY_MAX / 2; } else { *priority = 0; } } else { *updatePriority = false; *priority = 0; } MediaLibvaInterfaceNext::UnmapBuffer(ctx, buffers[i]); priorityIndexInBuf = i; break; } } #endif return priorityIndexInBuf; } void MediaLibvaCommonNext::MovePriorityBufferIdToEnd(VABufferID *buffers, int32_t priorityIndexInBuf, int32_t numBuffers) { VABufferID vaBufferID = 0; DDI_FUNC_ENTER; if( (numBuffers > 1) && (priorityIndexInBuf < numBuffers -1) ) { vaBufferID = buffers[priorityIndexInBuf]; while(priorityIndexInBuf < (numBuffers - 1) ) { buffers[priorityIndexInBuf] = buffers[priorityIndexInBuf+1]; priorityIndexInBuf++; } buffers[numBuffers -1] = vaBufferID; } return; }