| /* |
| * Copyright (c) 2017-2020, 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_ddi_decode_base.cpp |
| //! \brief The class implementation of DdiDecodeBase for all decoders |
| //! |
| |
| #include "media_libva_decoder.h" |
| #include "media_libva_vp.h" |
| #include "media_libva_util.h" |
| #include "media_ddi_decode_base.h" |
| #include "codechal.h" |
| #include "codechal_memdecomp.h" |
| #include "media_interfaces_codechal.h" |
| #include "media_interfaces_mmd.h" |
| #include "mos_solo_generic.h" |
| |
| DdiMediaDecode::DdiMediaDecode(DDI_DECODE_CONFIG_ATTR *ddiDecodeAttr) |
| : DdiMediaBase() |
| { |
| m_ddiDecodeAttr = ddiDecodeAttr; |
| m_ddiDecodeCtx = nullptr; |
| MOS_ZeroMemory(&m_destSurface, sizeof(m_destSurface)); |
| m_groupIndex = 0; |
| m_picWidthInMB = 0; |
| m_picHeightInMB = 0; |
| m_decProcessingType = 0; |
| m_width = 0; |
| m_height = 0; |
| m_streamOutEnabled = false; |
| m_sliceParamBufNum = 0; |
| m_sliceCtrlBufNum = 0; |
| m_codechalSettings = CodechalSetting::CreateCodechalSetting(); |
| } |
| |
| VAStatus DdiMediaDecode::BasicInit( |
| DDI_DECODE_CONFIG_ATTR *ddiConfAttr) |
| { |
| if (ddiConfAttr == nullptr) |
| { |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| m_ddiDecodeAttr = (DDI_DECODE_CONFIG_ATTR *)MOS_AllocAndZeroMemory( |
| sizeof(DDI_DECODE_CONFIG_ATTR)); |
| if (m_ddiDecodeAttr && ddiConfAttr) |
| { |
| MOS_SecureMemcpy(m_ddiDecodeAttr, sizeof(DDI_DECODE_CONFIG_ATTR), ddiConfAttr, sizeof(DDI_DECODE_CONFIG_ATTR)); |
| } |
| |
| m_ddiDecodeCtx = (DDI_DECODE_CONTEXT *)MOS_AllocAndZeroMemory( |
| sizeof(DDI_DECODE_CONTEXT)); |
| |
| if ((m_ddiDecodeAttr == nullptr) || |
| (m_ddiDecodeCtx == nullptr)) |
| { |
| MOS_FreeMemory(m_ddiDecodeAttr); |
| m_ddiDecodeAttr = nullptr; |
| MOS_FreeMemory(m_ddiDecodeCtx); |
| m_ddiDecodeCtx = nullptr; |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| uint32_t DdiMediaDecode::GetBsBufOffset(int32_t sliceGroup) |
| { |
| return m_ddiDecodeCtx->BufMgr.pSliceData[sliceGroup].uiOffset; |
| } |
| |
| VAStatus DdiMediaDecode::ParseProcessingBuffer( |
| DDI_MEDIA_CONTEXT *mediaCtx, |
| void *bufAddr) |
| { |
| #ifdef _DECODE_PROCESSING_SUPPORTED |
| VAProcPipelineParameterBuffer *procBuf = |
| (VAProcPipelineParameterBuffer *)bufAddr; |
| |
| DDI_CHK_NULL(procBuf, "nullptr Processing buffer", VA_STATUS_ERROR_INVALID_PARAMETER) |
| |
| if (m_decProcessingType == VA_DEC_PROCESSING) |
| { |
| if(m_procBuf == nullptr) |
| { |
| m_procBuf = (VAProcPipelineParameterBuffer*)MOS_AllocAndZeroMemory(sizeof(VAProcPipelineParameterBuffer)); |
| DDI_CHK_NULL(m_procBuf, "nullptr m_procBuf", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| MOS_SecureMemcpy(m_procBuf, sizeof(VAProcPipelineParameterBuffer), procBuf, sizeof(VAProcPipelineParameterBuffer)); |
| } |
| auto decProcessingParams = |
| (DecodeProcessingParams *)m_ddiDecodeCtx->DecodeParams.m_procParams; |
| |
| auto decProcessingSurface = decProcessingParams->m_outputSurface; |
| |
| memset(decProcessingSurface, 0, sizeof(MOS_SURFACE)); |
| |
| PDDI_MEDIA_SURFACE surface = |
| DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, procBuf->additional_outputs[0]); |
| |
| DDI_CHK_NULL(surface, "Null surface in Processing buffer", VA_STATUS_ERROR_INVALID_PARAMETER) |
| |
| DdiMedia_MediaSurfaceToMosResource(surface, &(decProcessingSurface->OsResource)); |
| |
| decProcessingSurface->dwWidth = decProcessingSurface->OsResource.iWidth; |
| decProcessingSurface->dwHeight = decProcessingSurface->OsResource.iHeight; |
| decProcessingSurface->dwPitch = decProcessingSurface->OsResource.iPitch; |
| decProcessingSurface->TileType = decProcessingSurface->OsResource.TileType; |
| decProcessingSurface->Format = decProcessingSurface->OsResource.Format; |
| |
| decProcessingParams->m_inputSurfaceRegion.m_x = procBuf->surface_region->x; |
| decProcessingParams->m_inputSurfaceRegion.m_y = procBuf->surface_region->y; |
| decProcessingParams->m_inputSurfaceRegion.m_width = procBuf->surface_region->width; |
| decProcessingParams->m_inputSurfaceRegion.m_height = procBuf->surface_region->height; |
| |
| decProcessingParams->m_outputSurface = decProcessingSurface; |
| decProcessingParams->m_outputSurfaceRegion.m_x = procBuf->output_region->x; |
| decProcessingParams->m_outputSurfaceRegion.m_y = procBuf->output_region->y; |
| decProcessingParams->m_outputSurfaceRegion.m_width = procBuf->output_region->width; |
| decProcessingParams->m_outputSurfaceRegion.m_height = procBuf->output_region->height; |
| |
| // Interpolation flags |
| // Set the vdbox scaling mode |
| uint32_t uInterpolationflags = 0; |
| #if VA_CHECK_VERSION(1, 9, 0) |
| uInterpolationflags = procBuf->filter_flags & VA_FILTER_INTERPOLATION_MASK; |
| #endif |
| |
| switch (uInterpolationflags) |
| { |
| #if VA_CHECK_VERSION(1, 9, 0) |
| case VA_FILTER_INTERPOLATION_NEAREST_NEIGHBOR: |
| decProcessingParams->m_scalingMode = CODECHAL_SCALING_NEAREST; |
| break; |
| case VA_FILTER_INTERPOLATION_BILINEAR: |
| decProcessingParams->m_scalingMode = CODECHAL_SCALING_BILINEAR; |
| break; |
| case VA_FILTER_INTERPOLATION_ADVANCED: |
| case VA_FILTER_INTERPOLATION_DEFAULT: |
| #endif |
| default: |
| decProcessingParams->m_scalingMode = CODECHAL_SCALING_AVS; |
| break; |
| } |
| |
| // Chroma siting |
| // Set the vertical chroma siting info |
| uint32_t chromaSitingFlags = 0; |
| chromaSitingFlags = procBuf->input_color_properties.chroma_sample_location & 0x3; |
| decProcessingParams->m_chromaSitingType = CODECHAL_CHROMA_SITING_NONE; |
| decProcessingParams->m_rotationState = 0; |
| decProcessingParams->m_blendState = 0; |
| decProcessingParams->m_mirrorState = 0; |
| |
| switch (chromaSitingFlags) |
| { |
| case VA_CHROMA_SITING_VERTICAL_TOP: |
| decProcessingParams->m_chromaSitingType = CODECHAL_CHROMA_SITING_VERT_TOP; |
| break; |
| case VA_CHROMA_SITING_VERTICAL_CENTER: |
| decProcessingParams->m_chromaSitingType = CODECHAL_CHROMA_SITING_VERT_CENTER; |
| break; |
| case VA_CHROMA_SITING_VERTICAL_BOTTOM: |
| decProcessingParams->m_chromaSitingType = CODECHAL_CHROMA_SITING_VERT_BOTTOM; |
| break; |
| default: |
| decProcessingParams->m_chromaSitingType = CODECHAL_CHROMA_SITING_NONE; |
| break; |
| } |
| |
| if (decProcessingParams->m_chromaSitingType != CODECHAL_CHROMA_SITING_NONE) |
| { |
| // Set the horizontal chroma siting info |
| chromaSitingFlags = procBuf->input_color_properties.chroma_sample_location & 0xc; |
| |
| switch (chromaSitingFlags) |
| { |
| case VA_CHROMA_SITING_HORIZONTAL_LEFT: |
| decProcessingParams->m_chromaSitingType |= CODECHAL_CHROMA_SITING_HORZ_LEFT; |
| break; |
| case VA_CHROMA_SITING_HORIZONTAL_CENTER: |
| decProcessingParams->m_chromaSitingType |= CODECHAL_CHROMA_SITING_HORZ_CENTER; |
| break; |
| default: |
| decProcessingParams->m_chromaSitingType = CODECHAL_CHROMA_SITING_NONE; |
| break; |
| } |
| } |
| } |
| |
| return VA_STATUS_SUCCESS; |
| #else |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| #endif |
| } |
| |
| VAStatus DdiMediaDecode::BeginPicture( |
| VADriverContextP ctx, |
| VAContextID context, |
| VASurfaceID renderTarget) |
| { |
| DDI_FUNCTION_ENTER(); |
| |
| PDDI_MEDIA_CONTEXT mediaCtx; |
| |
| /* As it is already checked in the upper caller, skip the check */ |
| mediaCtx = DdiMedia_GetMediaContext(ctx); |
| |
| #ifdef _DECODE_PROCESSING_SUPPORTED |
| //renderTarget is decode output surface; set renderTarget as vp sfc input surface m_procBuf->surface = rederTarget |
| if(m_procBuf) |
| { |
| m_procBuf->surface = renderTarget; |
| } |
| #endif |
| |
| DDI_MEDIA_SURFACE *curRT; |
| curRT = (DDI_MEDIA_SURFACE *)DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, renderTarget); |
| DDI_CHK_NULL(curRT, "nullptr pCurRT", VA_STATUS_ERROR_INVALID_SURFACE); |
| curRT->pDecCtx = m_ddiDecodeCtx; |
| |
| DDI_CODEC_RENDER_TARGET_TABLE *RTtbl; |
| RTtbl = &(m_ddiDecodeCtx->RTtbl); |
| RTtbl->pCurrentRT = curRT; |
| |
| m_streamOutEnabled = false; |
| m_ddiDecodeCtx->DecodeParams.m_numSlices = 0; |
| m_ddiDecodeCtx->DecodeParams.m_dataSize = 0; |
| m_ddiDecodeCtx->DecodeParams.m_dataOffset = 0; |
| m_ddiDecodeCtx->DecodeParams.m_deblockDataSize = 0; |
| m_ddiDecodeCtx->DecodeParams.m_executeCallIndex = 0; |
| m_ddiDecodeCtx->DecodeParams.m_cencBuf = nullptr; |
| m_groupIndex = 0; |
| |
| // register render targets |
| DDI_CHK_RET(RegisterRTSurfaces(&m_ddiDecodeCtx->RTtbl, curRT),"RegisterRTSurfaces failed!"); |
| |
| if (nullptr == m_ddiDecodeCtx->pCodecHal) |
| { |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| MOS_STATUS eStatus = m_ddiDecodeCtx->pCodecHal->BeginFrame(); |
| if (eStatus != MOS_STATUS_SUCCESS) |
| { |
| return VA_STATUS_ERROR_DECODING_ERROR; |
| } |
| |
| DDI_FUNCTION_EXIT(VA_STATUS_SUCCESS); |
| return VA_STATUS_SUCCESS; |
| } |
| |
| VAStatus DdiMediaDecode::DecodeCombineBitstream(DDI_MEDIA_CONTEXT *mediaCtx) |
| { |
| DDI_CODEC_COM_BUFFER_MGR *bufMgr; |
| /* As it is checked in previous caller, it is skipped. */ |
| bufMgr = &(m_ddiDecodeCtx->BufMgr); |
| |
| if (bufMgr && (bufMgr->bIsSliceOverSize == false)) |
| { |
| return VA_STATUS_SUCCESS; |
| } |
| |
| PDDI_MEDIA_BUFFER newBitstreamBuffer; |
| //allocate a new bit stream buffer |
| newBitstreamBuffer = (DDI_MEDIA_BUFFER *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_BUFFER)); |
| if (newBitstreamBuffer == nullptr) |
| { |
| DDI_ASSERTMESSAGE("DDI:AllocAndZeroMem return failure."); |
| return VA_STATUS_ERROR_DECODING_ERROR; |
| } |
| |
| newBitstreamBuffer->iSize = m_ddiDecodeCtx->DecodeParams.m_dataSize; |
| newBitstreamBuffer->uiType = VASliceDataBufferType; |
| newBitstreamBuffer->format = Media_Format_Buffer; |
| newBitstreamBuffer->uiOffset = 0; |
| newBitstreamBuffer->pMediaCtx = mediaCtx; |
| |
| VAStatus vaStatus; |
| vaStatus = DdiMediaUtil_CreateBuffer(newBitstreamBuffer, |
| mediaCtx->pDrmBufMgr); |
| if (vaStatus != VA_STATUS_SUCCESS) |
| { |
| MOS_FreeMemory(newBitstreamBuffer); |
| newBitstreamBuffer = nullptr; |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| uint8_t *newBitStreamBase; |
| newBitStreamBase = (uint8_t *)DdiMediaUtil_LockBuffer(newBitstreamBuffer, MOS_LOCKFLAG_WRITEONLY); |
| |
| if (newBitStreamBase == nullptr) |
| { |
| DdiMediaUtil_FreeBuffer(newBitstreamBuffer); |
| MOS_FreeMemory(newBitstreamBuffer); |
| newBitstreamBuffer = nullptr; |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| uint32_t slcInd; |
| //copy data to new bit stream |
| for (slcInd = 0; slcInd < bufMgr->dwNumSliceData; slcInd++) |
| { |
| if (bufMgr->pSliceData[slcInd].bIsUseExtBuf == true) |
| { |
| if (bufMgr->pSliceData[slcInd].pSliceBuf) |
| { |
| MOS_SecureMemcpy(newBitStreamBase + bufMgr->pSliceData[slcInd].uiOffset, |
| bufMgr->pSliceData[slcInd].uiLength, |
| bufMgr->pSliceData[slcInd].pSliceBuf, |
| bufMgr->pSliceData[slcInd].uiLength); |
| MOS_FreeMemory(bufMgr->pSliceData[slcInd].pSliceBuf); |
| bufMgr->pSliceData[slcInd].pSliceBuf = nullptr; |
| bufMgr->pSliceData[slcInd].bIsUseExtBuf = false; |
| } |
| } |
| else |
| { |
| MOS_SecureMemcpy(newBitStreamBase + bufMgr->pSliceData[slcInd].uiOffset, |
| bufMgr->pSliceData[slcInd].uiLength, |
| bufMgr->pBitStreamBase[bufMgr->dwBitstreamIndex] + bufMgr->pSliceData[slcInd].uiOffset, |
| bufMgr->pSliceData[slcInd].uiLength); |
| } |
| } |
| |
| //free original buffers |
| if (bufMgr->pBitStreamBase[bufMgr->dwBitstreamIndex]) |
| { |
| DdiMediaUtil_UnlockBuffer(bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex]); |
| bufMgr->pBitStreamBase[bufMgr->dwBitstreamIndex] = nullptr; |
| } |
| |
| if (bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex]) |
| { |
| DdiMediaUtil_FreeBuffer(bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex]); |
| MOS_FreeMemory(bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex]); |
| bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex] = nullptr; |
| } |
| |
| //set new bitstream buffer |
| bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex] = newBitstreamBuffer; |
| bufMgr->pBitStreamBase[bufMgr->dwBitstreamIndex] = newBitStreamBase; |
| DdiMedia_MediaBufferToMosResource(m_ddiDecodeCtx->BufMgr.pBitStreamBuffObject[bufMgr->dwBitstreamIndex], &m_ddiDecodeCtx->BufMgr.resBitstreamBuffer); |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| void DdiMediaDecode::DestroyContext(VADriverContextP ctx) |
| { |
| Codechal *codecHal; |
| /* as they are already checked in caller, this is skipped */ |
| codecHal = m_ddiDecodeCtx->pCodecHal; |
| |
| if (codecHal != nullptr) |
| { |
| if (codecHal->GetOsInterface() && codecHal->GetOsInterface()->pOsContext) |
| { |
| MOS_FreeMemory(codecHal->GetOsInterface()->pOsContext->pPerfData); |
| codecHal->GetOsInterface()->pOsContext->pPerfData = nullptr; |
| } |
| |
| // destroy codechal |
| codecHal->Destroy(); |
| MOS_Delete(codecHal); |
| |
| m_ddiDecodeCtx->pCodecHal = nullptr; |
| } |
| |
| int32_t i; |
| for (i = 0; i < DDI_MEDIA_MAX_SURFACE_NUMBER_CONTEXT; i++) |
| { |
| if ((m_ddiDecodeCtx->RTtbl.pRT[i] != nullptr) && |
| (m_ddiDecodeCtx->RTtbl.pRT[i]->pDecCtx == m_ddiDecodeCtx)) |
| { |
| m_ddiDecodeCtx->RTtbl.pRT[i]->pDecCtx = nullptr; |
| } |
| } |
| |
| if (m_ddiDecodeCtx->pCpDdiInterface) |
| { |
| Delete_DdiCpInterface(m_ddiDecodeCtx->pCpDdiInterface); |
| m_ddiDecodeCtx->pCpDdiInterface = nullptr; |
| } |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_iqMatrixBuffer); |
| m_ddiDecodeCtx->DecodeParams.m_iqMatrixBuffer = nullptr; |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_huffmanTable); |
| m_ddiDecodeCtx->DecodeParams.m_huffmanTable = nullptr; |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_picParams); |
| m_ddiDecodeCtx->DecodeParams.m_picParams = nullptr; |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_sliceParams); |
| m_ddiDecodeCtx->DecodeParams.m_sliceParams = nullptr; |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_extPicParams); |
| m_ddiDecodeCtx->DecodeParams.m_sliceParams = nullptr; |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_advPicParams); |
| m_ddiDecodeCtx->DecodeParams.m_sliceParams = nullptr; |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_extSliceParams); |
| m_ddiDecodeCtx->DecodeParams.m_sliceParams = nullptr; |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_subsetParams); |
| m_ddiDecodeCtx->DecodeParams.m_sliceParams = nullptr; |
| |
| #ifdef _DECODE_PROCESSING_SUPPORTED |
| if (m_ddiDecodeCtx->DecodeParams.m_procParams != nullptr) |
| { |
| auto procParams = |
| (DecodeProcessingParams *)m_ddiDecodeCtx->DecodeParams.m_procParams; |
| MOS_FreeMemory(procParams->m_outputSurface); |
| procParams->m_outputSurface = nullptr; |
| |
| MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_procParams); |
| m_ddiDecodeCtx->DecodeParams.m_procParams = nullptr; |
| } |
| #endif |
| |
| return; |
| } |
| |
| int32_t DdiMediaDecode::GetBitstreamBufIndexFromBuffer(DDI_CODEC_COM_BUFFER_MGR *bufMgr, DDI_MEDIA_BUFFER *buf) |
| { |
| int32_t i; |
| for(i = 0; i < DDI_CODEC_MAX_BITSTREAM_BUFFER; i++) |
| { |
| if(bufMgr->pBitStreamBuffObject[i]->bo == buf->bo) |
| { |
| return i; |
| } |
| } |
| |
| return DDI_CODEC_INVALID_BUFFER_INDEX; |
| } |
| |
| VAStatus DdiMediaDecode::AllocBsBuffer( |
| DDI_CODEC_COM_BUFFER_MGR *bufMgr, |
| DDI_MEDIA_BUFFER *buf) |
| { |
| uint32_t index, i; |
| VAStatus vaStatus; |
| uint8_t *sliceBuf; |
| DDI_MEDIA_BUFFER *bsBufObj = nullptr; |
| uint8_t *bsBufBaseAddr = nullptr; |
| bool createBsBuffer = false; |
| |
| if ( nullptr == bufMgr || nullptr == buf || nullptr == (m_ddiDecodeCtx->pMediaCtx) ) |
| { |
| DDI_ASSERTMESSAGE("invalidate input parameters."); |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| index = bufMgr->dwNumSliceData; |
| vaStatus = VA_STATUS_SUCCESS; |
| sliceBuf = nullptr; |
| |
| /* the pSliceData needs to be reallocated in order to contain more SliceDataBuf */ |
| if (index >= bufMgr->m_maxNumSliceData) |
| { |
| /* In theroy it can resize the m_maxNumSliceData one by one. But in order to |
| * avoid calling realloc frequently, it will try to allocate 10 to hold more |
| * SliceDataBuf. This is only for the optimized purpose. |
| */ |
| int32_t reallocSize = bufMgr->m_maxNumSliceData + 10; |
| |
| bufMgr->pSliceData = (DDI_CODEC_BITSTREAM_BUFFER_INFO *)realloc(bufMgr->pSliceData, sizeof(bufMgr->pSliceData[0]) * reallocSize); |
| |
| if (bufMgr->pSliceData == nullptr) |
| { |
| DDI_ASSERTMESSAGE("fail to reallocate pSliceData\n."); |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| memset(bufMgr->pSliceData + bufMgr->m_maxNumSliceData, 0, |
| sizeof(bufMgr->pSliceData[0]) * 10); |
| |
| bufMgr->m_maxNumSliceData += 10; |
| } |
| |
| if(index >= 1) |
| { |
| buf->uiOffset = bufMgr->pSliceData[index-1].uiOffset + bufMgr->pSliceData[index-1].uiLength; |
| if((buf->uiOffset + buf->iSize) > bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex]->iSize) |
| { |
| sliceBuf = (uint8_t*)MOS_AllocAndZeroMemory(buf->iSize); |
| if(sliceBuf == nullptr) |
| { |
| DDI_ASSERTMESSAGE("DDI:AllocAndZeroMem return failure.") |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| bufMgr->bIsSliceOverSize = true; |
| } |
| else |
| { |
| bufMgr->bIsSliceOverSize = false; |
| } |
| } |
| else |
| { |
| bufMgr->bIsSliceOverSize = false; |
| for (i = 0; i < DDI_CODEC_MAX_BITSTREAM_BUFFER; i++) |
| { |
| if (bufMgr->pBitStreamBuffObject[i]->bo != nullptr) |
| { |
| if (!mos_bo_busy(bufMgr->pBitStreamBuffObject[i]->bo)) |
| { |
| //find a bitstream buffer whoes graphic memory is allocated but not used by HW now. |
| break; |
| } |
| } |
| else |
| { |
| //find a new bitstream buffer whoes graphic memory is not allocated yet |
| break; |
| } |
| } |
| |
| if (i == DDI_CODEC_MAX_BITSTREAM_BUFFER) |
| { |
| //find the oldest bistream buffer which is the most possible one to become free in the shortest time. |
| bufMgr->dwBitstreamIndex = (bufMgr->ui64BitstreamOrder >> (DDI_CODEC_BITSTREAM_BUFFER_INDEX_BITS * DDI_CODEC_MAX_BITSTREAM_BUFFER_MINUS1)) & DDI_CODEC_MAX_BITSTREAM_BUFFER_INDEX; |
| // wait until decode complete |
| mos_bo_wait_rendering(bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex]->bo); |
| } |
| else |
| { |
| bufMgr->dwBitstreamIndex = i; |
| } |
| bufMgr->ui64BitstreamOrder = (bufMgr->ui64BitstreamOrder << 4) + bufMgr->dwBitstreamIndex; |
| |
| bsBufObj = bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex]; |
| bsBufObj ->pMediaCtx = m_ddiDecodeCtx->pMediaCtx; |
| bsBufBaseAddr = bufMgr->pBitStreamBase[bufMgr->dwBitstreamIndex]; |
| |
| if(bsBufBaseAddr == nullptr) |
| { |
| createBsBuffer = true; |
| if (buf->iSize > bsBufObj->iSize) |
| { |
| bsBufObj->iSize = buf->iSize; |
| } |
| } |
| else if(buf->iSize > bsBufObj->iSize) |
| { |
| //free bo |
| DdiMediaUtil_UnlockBuffer(bsBufObj); |
| DdiMediaUtil_FreeBuffer(bsBufObj); |
| bsBufBaseAddr = nullptr; |
| |
| createBsBuffer = true; |
| bsBufObj->iSize = buf->iSize; |
| } |
| |
| if (createBsBuffer) |
| { |
| if(VA_STATUS_SUCCESS != DdiMediaUtil_CreateBuffer(bsBufObj, m_ddiDecodeCtx->pMediaCtx->pDrmBufMgr)) |
| { |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| bsBufBaseAddr = (uint8_t*)DdiMediaUtil_LockBuffer(bsBufObj, MOS_LOCKFLAG_WRITEONLY); |
| if(bsBufBaseAddr == nullptr) |
| { |
| DdiMediaUtil_FreeBuffer(bsBufObj); |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| bufMgr->pBitStreamBase[bufMgr->dwBitstreamIndex] = bsBufBaseAddr; |
| } |
| } |
| |
| if(bufMgr->pBitStreamBase[bufMgr->dwBitstreamIndex] == nullptr) |
| { |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| bufMgr->pSliceData[index].uiLength = buf->iSize; |
| bufMgr->pSliceData[index].uiOffset = buf->uiOffset; |
| |
| if(bufMgr->bIsSliceOverSize == true) |
| { |
| buf->pData = sliceBuf; |
| buf->uiOffset = 0; |
| bufMgr->pSliceData[index].bIsUseExtBuf = true; |
| bufMgr->pSliceData[index].pSliceBuf = sliceBuf; |
| buf->bCFlushReq = false; |
| } |
| else |
| { |
| buf->pData = (uint8_t*)(bufMgr->pBitStreamBase[bufMgr->dwBitstreamIndex]); |
| bufMgr->pSliceData[index].bIsUseExtBuf = false; |
| bufMgr->pSliceData[index].pSliceBuf = nullptr; |
| buf->bCFlushReq = true; |
| } |
| |
| bufMgr->dwNumSliceData ++; |
| buf->bo = bufMgr->pBitStreamBuffObject[bufMgr->dwBitstreamIndex]->bo; |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| MOS_FORMAT DdiMediaDecode::GetFormat() |
| { |
| return Format_NV12; |
| } |
| |
| VAStatus DdiMediaDecode::InitDecodeParams( |
| VADriverContextP ctx, |
| VAContextID context) |
| { |
| /* skip the mediaCtx check as it is checked in caller */ |
| PDDI_MEDIA_CONTEXT mediaCtx; |
| mediaCtx = DdiMedia_GetMediaContext(ctx); |
| DDI_CHK_RET(DecodeCombineBitstream(mediaCtx),"DecodeCombineBitstream failed!"); |
| DDI_CODEC_COM_BUFFER_MGR *bufMgr = &(m_ddiDecodeCtx->BufMgr); |
| bufMgr->dwNumSliceData = 0; |
| bufMgr->dwNumSliceControl = 0; |
| memset(&m_destSurface, 0, sizeof(MOS_SURFACE)); |
| m_destSurface.dwOffset = 0; |
| |
| DDI_CODEC_RENDER_TARGET_TABLE *rtTbl = &(m_ddiDecodeCtx->RTtbl); |
| |
| if ((rtTbl == nullptr) || (rtTbl->pCurrentRT == nullptr)) |
| { |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| return VA_STATUS_SUCCESS; |
| |
| } |
| |
| VAStatus DdiMediaDecode::SetDecodeParams() |
| { |
| DDI_CODEC_COM_BUFFER_MGR *bufMgr = &(m_ddiDecodeCtx->BufMgr); |
| if ((&m_ddiDecodeCtx->DecodeParams)->m_numSlices == 0) |
| { |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| |
| MOS_FORMAT expectedFormat = GetFormat(); |
| m_destSurface.Format = expectedFormat; |
| DdiMedia_MediaSurfaceToMosResource((&(m_ddiDecodeCtx->RTtbl))->pCurrentRT, &(m_destSurface.OsResource)); |
| |
| if (m_destSurface.OsResource.Format != expectedFormat) |
| { |
| DDI_NORMALMESSAGE("Surface fomrat of decoded surface is inconsistent with Codec bitstream\n"); |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| |
| m_ddiDecodeCtx->DecodeParams.m_destSurface = &m_destSurface; |
| m_ddiDecodeCtx->DecodeParams.m_deblockSurface = nullptr; |
| |
| m_ddiDecodeCtx->DecodeParams.m_dataBuffer = &bufMgr->resBitstreamBuffer; |
| m_ddiDecodeCtx->DecodeParams.m_bitStreamBufData = bufMgr->pBitstreamBuffer; |
| |
| m_ddiDecodeCtx->DecodeParams.m_bitplaneBuffer = nullptr; |
| |
| if (m_streamOutEnabled) |
| { |
| m_ddiDecodeCtx->DecodeParams.m_streamOutEnabled = true; |
| m_ddiDecodeCtx->DecodeParams.m_externalStreamOutBuffer = &bufMgr->resExternalStreamOutBuffer; |
| } |
| else |
| { |
| m_ddiDecodeCtx->DecodeParams.m_streamOutEnabled = false; |
| m_ddiDecodeCtx->DecodeParams.m_externalStreamOutBuffer = nullptr; |
| } |
| |
| if (m_ddiDecodeCtx->pCpDdiInterface) |
| { |
| DDI_CHK_RET(m_ddiDecodeCtx->pCpDdiInterface->SetDecodeParams(m_ddiDecodeCtx, m_codechalSettings),"SetDecodeParams failed!"); |
| } |
| |
| Mos_Solo_OverrideBufferSize(m_ddiDecodeCtx->DecodeParams.m_dataSize, m_ddiDecodeCtx->DecodeParams.m_dataBuffer); |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| VAStatus DdiMediaDecode::ExtraDownScaling( |
| VADriverContextP ctx, |
| VAContextID context) |
| { |
| #ifdef _DECODE_PROCESSING_SUPPORTED |
| DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT); |
| VAStatus vaStatus = MOS_STATUS_SUCCESS; |
| PDDI_MEDIA_CONTEXT mediaCtx = DdiMedia_GetMediaContext(ctx); |
| DDI_CHK_NULL(mediaCtx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT); |
| DDI_CHK_NULL(m_ddiDecodeCtx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| bool isDecodeDownScalingSupported = false; |
| if (m_ddiDecodeCtx->pCodecHal->IsApogeiosEnabled()) |
| { |
| DecodePipelineAdapter *decoder = dynamic_cast<DecodePipelineAdapter *>(m_ddiDecodeCtx->pCodecHal); |
| DDI_CHK_NULL(decoder, "nullptr decoder", VA_STATUS_ERROR_INVALID_PARAMETER); |
| isDecodeDownScalingSupported = decoder->IsDownSamplingSupported(); |
| } |
| else |
| { |
| CodechalDecode *decoder = dynamic_cast<CodechalDecode *>(m_ddiDecodeCtx->pCodecHal); |
| DDI_CHK_NULL(decoder, "nullptr decoder", VA_STATUS_ERROR_INVALID_PARAMETER); |
| isDecodeDownScalingSupported = decoder->IsVdSfcSupported(); |
| } |
| |
| if(m_ddiDecodeCtx->DecodeParams.m_procParams != nullptr && |
| m_procBuf && |
| !isDecodeDownScalingSupported) |
| { |
| //check vp context |
| VAContextID vpCtxID = VA_INVALID_ID; |
| if (mediaCtx->pVpCtxHeap != nullptr && mediaCtx->pVpCtxHeap->pHeapBase != nullptr) |
| { |
| //Get VP Context from heap. |
| vpCtxID = (VAContextID)(0 + DDI_MEDIA_VACONTEXTID_OFFSET_VP); |
| } |
| else |
| { |
| //Create VP Context. |
| vaStatus = DdiVp_CreateContext(ctx, 0, 0, 0, 0, 0, 0, &vpCtxID); |
| DDI_CHK_RET(vaStatus, "Create VP Context failed."); |
| } |
| |
| uint32_t ctxType; |
| PDDI_VP_CONTEXT pVpCtx = (PDDI_VP_CONTEXT)DdiMedia_GetContextFromContextID(ctx, vpCtxID, &ctxType); |
| DDI_CHK_NULL(pVpCtx, "nullptr pVpCtx", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| //Set parameters |
| VAProcPipelineParameterBuffer* pInputPipelineParam = m_procBuf; |
| DDI_CHK_NULL(pInputPipelineParam, "nullptr pInputPipelineParam", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| vaStatus = DdiVp_BeginPicture(ctx, vpCtxID, pInputPipelineParam->additional_outputs[0]); |
| DDI_CHK_RET(vaStatus, "VP BeginPicture failed"); |
| |
| vaStatus = DdiVp_SetProcPipelineParams(ctx, pVpCtx, pInputPipelineParam); |
| DDI_CHK_RET(vaStatus, "VP SetProcPipelineParams failed."); |
| |
| vaStatus = DdiVp_EndPicture(ctx, vpCtxID); |
| DDI_CHK_RET(vaStatus, "VP EndPicture failed."); |
| } |
| #endif |
| return MOS_STATUS_SUCCESS; |
| } |
| |
| VAStatus DdiMediaDecode::InitDummyReference(CodechalDecode& decoder) |
| { |
| PMOS_SURFACE dummyReference = decoder.GetDummyReference(); |
| |
| // If dummy reference is from decode output surface, need to update frame by frame |
| if (decoder.GetDummyReferenceStatus() == CODECHAL_DUMMY_REFERENCE_DEST_SURFACE) |
| { |
| MOS_ZeroMemory(dummyReference, sizeof(MOS_SURFACE)); |
| decoder.SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_INVALID); |
| } |
| |
| if (!Mos_ResourceIsNull(&dummyReference->OsResource)) |
| { |
| Mos_Specific_GetResourceInfo(decoder.GetOsInterface(), &dummyReference->OsResource, dummyReference); |
| |
| // Check if need to re-get dummy reference from DPB or re-allocated |
| if (dummyReference->dwWidth < m_ddiDecodeCtx->DecodeParams.m_destSurface->dwWidth || |
| dummyReference->dwHeight < m_ddiDecodeCtx->DecodeParams.m_destSurface->dwHeight) |
| { |
| // Check if the dummy reference needs to be re-allocated |
| if (decoder.GetDummyReferenceStatus() == CODECHAL_DUMMY_REFERENCE_ALLOCATED) |
| { |
| decoder.GetOsInterface()->pfnFreeResource(decoder.GetOsInterface(), &dummyReference->OsResource); |
| } |
| |
| // Reset dummy reference |
| MOS_ZeroMemory(dummyReference, sizeof(MOS_SURFACE)); |
| decoder.SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_INVALID); |
| |
| // Considering potential risk, disable the dummy reference from DPB path temporarily |
| //GetDummyReferenceFromDPB(m_ddiDecodeCtx); |
| |
| //if (!Mos_ResourceIsNull(&dummyReference->OsResource)) |
| //{ |
| // decoder->SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_DPB); |
| //} |
| } |
| } |
| else |
| { |
| // Init dummy reference |
| MOS_ZeroMemory(dummyReference, sizeof(MOS_SURFACE)); |
| decoder.SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_INVALID); |
| |
| // Considering potential risk, disable the dummy reference from DPB path temporarily |
| //GetDummyReferenceFromDPB(m_ddiDecodeCtx); |
| //if (!Mos_ResourceIsNull(&dummyReference->OsResource)) |
| //{ |
| // decoder->SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_DPB); |
| //} |
| } |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| VAStatus DdiMediaDecode::InitDummyReference(DecodePipelineAdapter& decoder) |
| { |
| PMOS_SURFACE dummyReference = decoder.GetDummyReference(); |
| |
| // If dummy reference is from decode output surface, need to update frame by frame |
| if (decoder.GetDummyReferenceStatus() == CODECHAL_DUMMY_REFERENCE_DEST_SURFACE) |
| { |
| MOS_ZeroMemory(dummyReference, sizeof(MOS_SURFACE)); |
| decoder.SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_INVALID); |
| } |
| |
| if (!Mos_ResourceIsNull(&dummyReference->OsResource)) |
| { |
| Mos_Specific_GetResourceInfo(decoder.GetOsInterface(), &dummyReference->OsResource, dummyReference); |
| |
| // Check if need to re-get dummy reference from DPB or re-allocated |
| if (dummyReference->dwWidth < m_ddiDecodeCtx->DecodeParams.m_destSurface->dwWidth || |
| dummyReference->dwHeight < m_ddiDecodeCtx->DecodeParams.m_destSurface->dwHeight) |
| { |
| // Check if the dummy reference needs to be re-allocated |
| if (decoder.GetDummyReferenceStatus() == CODECHAL_DUMMY_REFERENCE_ALLOCATED) |
| { |
| decoder.GetOsInterface()->pfnFreeResource(decoder.GetOsInterface(), &dummyReference->OsResource); |
| } |
| |
| // Reset dummy reference |
| MOS_ZeroMemory(dummyReference, sizeof(MOS_SURFACE)); |
| decoder.SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_INVALID); |
| |
| // Considering potential risk, disable the dummy reference from DPB path temporarily |
| //GetDummyReferenceFromDPB(m_ddiDecodeCtx); |
| |
| //if (!Mos_ResourceIsNull(&dummyReference->OsResource)) |
| //{ |
| // decoder->SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_DPB); |
| //} |
| } |
| } |
| else |
| { |
| // Init dummy reference |
| MOS_ZeroMemory(dummyReference, sizeof(MOS_SURFACE)); |
| decoder.SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_INVALID); |
| |
| // Considering potential risk, disable the dummy reference from DPB path temporarily |
| //GetDummyReferenceFromDPB(m_ddiDecodeCtx); |
| //if (!Mos_ResourceIsNull(&dummyReference->OsResource)) |
| //{ |
| // decoder->SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_DPB); |
| //} |
| } |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| VAStatus DdiMediaDecode::EndPicture( |
| VADriverContextP ctx, |
| VAContextID context) |
| { |
| DDI_FUNCTION_ENTER(); |
| |
| if (m_ddiDecodeCtx->bDecodeModeReported == false) |
| { |
| ReportDecodeMode(m_ddiDecodeCtx->wMode); |
| m_ddiDecodeCtx->bDecodeModeReported = true; |
| } |
| |
| DDI_CHK_RET(InitDecodeParams(ctx,context),"InitDecodeParams failed!"); |
| |
| DDI_CHK_RET(SetDecodeParams(), "SetDecodeParams failed!"); |
| DDI_CHK_RET(ClearRefList(&(m_ddiDecodeCtx->RTtbl), m_withDpb), "ClearRefList failed!"); |
| if (m_ddiDecodeCtx->pCodecHal == nullptr) |
| { |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| if (MEDIA_IS_WA(&m_ddiDecodeCtx->pMediaCtx->WaTable, WaDummyReference)) |
| { |
| Mos_Specific_GetResourceInfo( |
| m_ddiDecodeCtx->pCodecHal->GetOsInterface(), |
| &m_ddiDecodeCtx->DecodeParams.m_destSurface->OsResource, |
| m_ddiDecodeCtx->DecodeParams.m_destSurface); |
| |
| if(m_ddiDecodeCtx->pCodecHal->IsApogeiosEnabled()) |
| { |
| DecodePipelineAdapter *decoder = dynamic_cast<DecodePipelineAdapter *>(m_ddiDecodeCtx->pCodecHal); |
| DDI_CHK_NULL(decoder, "Null decoder", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_RET(InitDummyReference(*decoder), "InitDummyReference failed!"); |
| } |
| else |
| { |
| CodechalDecode *decoder = dynamic_cast<CodechalDecode *>(m_ddiDecodeCtx->pCodecHal); |
| DDI_CHK_NULL(decoder, "Null decoder", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_RET(InitDummyReference(*decoder), "InitDummyReference failed!"); |
| } |
| } |
| |
| MOS_STATUS status = m_ddiDecodeCtx->pCodecHal->Execute((void *)(&m_ddiDecodeCtx->DecodeParams)); |
| if (status != MOS_STATUS_SUCCESS) |
| { |
| DDI_ASSERTMESSAGE("DDI:DdiDecode_DecodeInCodecHal return failure."); |
| return VA_STATUS_ERROR_DECODING_ERROR; |
| } |
| |
| m_ddiDecodeCtx->DecodeParams.m_executeCallIndex++; |
| |
| (&(m_ddiDecodeCtx->RTtbl))->pCurrentRT = nullptr; |
| |
| status = m_ddiDecodeCtx->pCodecHal->EndFrame(); |
| if (status != MOS_STATUS_SUCCESS) |
| { |
| return VA_STATUS_ERROR_DECODING_ERROR; |
| } |
| |
| #ifdef _DECODE_PROCESSING_SUPPORTED |
| if (ExtraDownScaling(ctx,context) != VA_STATUS_SUCCESS) |
| { |
| return VA_STATUS_ERROR_DECODING_ERROR; |
| } |
| #endif |
| |
| DDI_FUNCTION_EXIT(VA_STATUS_SUCCESS); |
| return VA_STATUS_SUCCESS; |
| } |
| |
| VAStatus DdiMediaDecode::CreateBuffer( |
| VABufferType type, |
| uint32_t size, |
| uint32_t numElements, |
| void *data, |
| VABufferID *bufId) |
| { |
| DDI_MEDIA_BUFFER *buf; |
| PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufferHeapElement; |
| uint16_t segMapWidth, segMapHeight; |
| MOS_STATUS status = MOS_STATUS_SUCCESS; |
| VAStatus va = VA_STATUS_SUCCESS; |
| |
| segMapWidth = m_picWidthInMB; |
| segMapHeight= m_picHeightInMB; |
| |
| // only for VASliceParameterBufferType of buffer, the number of elements can be greater than 1 |
| if(type != VASliceParameterBufferType && numElements > 1) |
| { |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| |
| buf = (DDI_MEDIA_BUFFER *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_BUFFER)); |
| if (buf == nullptr) |
| { |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| buf->iSize = size * numElements; |
| buf->uiNumElements = numElements; |
| buf->uiType = type; |
| buf->format = Media_Format_Buffer; |
| buf->uiOffset = 0; |
| buf->bCFlushReq = false; |
| buf->pMediaCtx = m_ddiDecodeCtx->pMediaCtx; |
| |
| switch ((int32_t)type) |
| { |
| case VABitPlaneBufferType: |
| buf->pData = (uint8_t*)((m_ddiDecodeCtx->BufMgr.Codec_Param.Codec_Param_VC1.pBitPlaneBuffer)); |
| break; |
| case VASliceDataBufferType: |
| case VAProtectedSliceDataBufferType: |
| va = AllocBsBuffer(&(m_ddiDecodeCtx->BufMgr), buf); |
| if(va != VA_STATUS_SUCCESS) |
| { |
| goto CleanUpandReturn; |
| } |
| |
| break; |
| case VASliceParameterBufferType: |
| va = AllocSliceControlBuffer(buf); |
| if(va != VA_STATUS_SUCCESS) |
| { |
| goto CleanUpandReturn; |
| } |
| buf->format = Media_Format_CPU; |
| break; |
| case VAPictureParameterBufferType: |
| buf->pData = GetPicParamBuf(&(m_ddiDecodeCtx->BufMgr)); |
| buf->format = Media_Format_CPU; |
| break; |
| case VASubsetsParameterBufferType: |
| //maximum entry point supported should not be more than 440 |
| if(numElements > 440) |
| { |
| va = VA_STATUS_ERROR_INVALID_PARAMETER; |
| goto CleanUpandReturn; |
| } |
| buf->pData = (uint8_t*)MOS_AllocAndZeroMemory(size * numElements); |
| buf->format = Media_Format_CPU; |
| break; |
| case VAIQMatrixBufferType: |
| buf->pData = (uint8_t*)MOS_AllocAndZeroMemory(size * numElements); |
| buf->format = Media_Format_CPU; |
| break; |
| case VAProbabilityBufferType: |
| buf->pData = (uint8_t*)(&(m_ddiDecodeCtx->BufMgr.Codec_Param.Codec_Param_VP8.ProbabilityDataVP8)); |
| break; |
| case VAProcFilterParameterBufferType: |
| buf->pData = (uint8_t*)MOS_AllocAndZeroMemory(sizeof(VAProcPipelineCaps)); |
| buf->format = Media_Format_CPU; |
| break; |
| case VAProcPipelineParameterBufferType: |
| buf->pData = (uint8_t*)MOS_AllocAndZeroMemory(sizeof(VAProcPipelineParameterBuffer)); |
| buf->format = Media_Format_CPU; |
| break; |
| case VADecodeStreamoutBufferType: |
| { |
| segMapHeight = ((segMapHeight + 1) >> 1); //uiSize must be equal and bigger than size for interlaced case |
| |
| if (size < MOS_ALIGN_CEIL(segMapHeight * segMapWidth * CODEC_SIZE_MFX_STREAMOUT_DATA, 64)) |
| { |
| va = VA_STATUS_ERROR_INVALID_PARAMETER; |
| goto CleanUpandReturn; |
| } |
| buf->iSize = size * numElements; |
| buf->format = Media_Format_Buffer; |
| va = DdiMediaUtil_CreateBuffer(buf, m_ddiDecodeCtx->pMediaCtx->pDrmBufMgr); |
| if(va != VA_STATUS_SUCCESS) |
| { |
| goto CleanUpandReturn; |
| } |
| break; |
| } |
| case VAHuffmanTableBufferType: |
| buf->pData = (uint8_t*)MOS_AllocAndZeroMemory(size * numElements); |
| buf->format = Media_Format_CPU; |
| break; |
| #if VA_CHECK_VERSION(1, 10, 0) |
| case VAContextParameterUpdateBufferType: |
| { |
| buf->pData = (uint8_t*)MOS_AllocAndZeroMemory(size * numElements); |
| buf->format = Media_Format_CPU; |
| break; |
| } |
| #endif |
| default: |
| va = m_ddiDecodeCtx->pCpDdiInterface->CreateBuffer(type, buf, size, numElements); |
| if (va == VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE) |
| { |
| DDI_ASSERTMESSAGE("DDI:Decode CreateBuffer unsuppoted buffer type."); |
| buf->pData = (uint8_t*)MOS_AllocAndZeroMemory(size * numElements); |
| buf->format = Media_Format_CPU; |
| if(buf->pData != NULL) |
| { |
| va = VA_STATUS_SUCCESS; |
| } |
| } |
| break; |
| } |
| |
| bufferHeapElement = DdiMediaUtil_AllocPMediaBufferFromHeap(m_ddiDecodeCtx->pMediaCtx->pBufferHeap); |
| if (nullptr == bufferHeapElement) |
| { |
| va = VA_STATUS_ERROR_MAX_NUM_EXCEEDED; |
| goto CleanUpandReturn; |
| } |
| bufferHeapElement->pBuffer = buf; |
| bufferHeapElement->pCtx = (void*)m_ddiDecodeCtx; |
| bufferHeapElement->uiCtxType = DDI_MEDIA_CONTEXT_TYPE_DECODER; |
| *bufId = bufferHeapElement->uiVaBufferID; |
| |
| // Keep record the VaBufferID of JPEG slice data buffer we allocated, in order to do buffer mapping when render this buffer. otherwise we |
| // can not get correct buffer address when application create them disordered. |
| if (type == VASliceDataBufferType && m_ddiDecodeCtx->wMode == CODECHAL_DECODE_MODE_JPEG) |
| { |
| // since the dwNumSliceData already +1 when allocate buffer, but here we need to track the VaBufferID before dwSliceData increased. |
| m_ddiDecodeCtx->BufMgr.pSliceData[m_ddiDecodeCtx->BufMgr.dwNumSliceData - 1].vaBufferId = *bufId; |
| } |
| m_ddiDecodeCtx->pMediaCtx->uiNumBufs++; |
| |
| if(data == nullptr) |
| { |
| return va; |
| } |
| |
| if( true == buf->bCFlushReq ) |
| { |
| mos_bo_subdata(buf->bo, buf->uiOffset, size * numElements, data); |
| } |
| else |
| { |
| status = MOS_SecureMemcpy((void *)(buf->pData + buf->uiOffset), size * numElements, data, size * numElements); |
| DDI_CHK_CONDITION((status != MOS_STATUS_SUCCESS), "DDI:Failed to copy buffer data!", VA_STATUS_ERROR_OPERATION_FAILED); |
| } |
| return va; |
| |
| CleanUpandReturn: |
| if(buf) |
| { |
| MOS_FreeMemory(buf->pData); |
| MOS_FreeMemory(buf); |
| } |
| return va; |
| |
| } |
| |
| void DdiMediaDecode::ContextInit( |
| int32_t picWidth, |
| int32_t picHeight) |
| { |
| m_width = picWidth; |
| m_height = picHeight; |
| m_picWidthInMB = (int16_t)(DDI_CODEC_NUM_MACROBLOCKS_WIDTH(picWidth)); |
| m_picHeightInMB = (int16_t)(DDI_CODEC_NUM_MACROBLOCKS_HEIGHT(picHeight)); |
| m_ddiDecodeCtx->wMode = CODECHAL_DECODE_MODE_AVCVLD; |
| m_ddiDecodeCtx->bShortFormatInUse = false; |
| #ifdef _DECODE_PROCESSING_SUPPORTED |
| if (m_ddiDecodeAttr->uiDecProcessingType == VA_DEC_PROCESSING) |
| { |
| DDI_NORMALMESSAGE("Decoding context has scaling/format conversion capabilities"); |
| m_decProcessingType = VA_DEC_PROCESSING; |
| } |
| else |
| #endif |
| { |
| DDI_NORMALMESSAGE("Decoding context DOESN'T have scaling/format conversion capabilities"); |
| m_decProcessingType = VA_DEC_PROCESSING_NONE; |
| } |
| m_streamOutEnabled = false; |
| m_ddiDecodeCtx->DecodeParams.m_picIdRemappingInUse = true; |
| } |
| |
| VAStatus DdiMediaDecode::CreateCodecHal( |
| DDI_MEDIA_CONTEXT *mediaCtx, |
| void *ptr, |
| _CODECHAL_STANDARD_INFO *standardInfo) |
| { |
| if ((mediaCtx == nullptr) || |
| (ptr == nullptr) || |
| (m_codechalSettings == nullptr) || |
| (standardInfo == nullptr)) |
| { |
| DDI_ASSERTMESSAGE("NULL pointer is passed for CreateCodecHal.\n"); |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| |
| } |
| MOS_CONTEXT *mosCtx = (MOS_CONTEXT *)ptr; |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| |
| Codechal *codecHal = CodechalDevice::CreateFactory( |
| nullptr, |
| mosCtx, |
| standardInfo, |
| m_codechalSettings); |
| |
| if (nullptr == codecHal) |
| { |
| DDI_ASSERTMESSAGE("Failure in CodecHal create.\n"); |
| vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
| return vaStatus; |
| } |
| |
| if (codecHal->IsApogeiosEnabled()) |
| { |
| DecodePipelineAdapter *decoder = dynamic_cast<DecodePipelineAdapter *>(codecHal); |
| if (nullptr == decoder) |
| { |
| DDI_ASSERTMESSAGE("Failure in CodecHal create.\n"); |
| vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
| return vaStatus; |
| } |
| } |
| else |
| { |
| CodechalDecode *decoder = dynamic_cast<CodechalDecode *>(codecHal); |
| if (nullptr == decoder) |
| { |
| DDI_ASSERTMESSAGE("Failure in CodecHal create.\n"); |
| vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
| return vaStatus; |
| } |
| } |
| |
| m_ddiDecodeCtx->pCodecHal = codecHal; |
| |
| m_codechalSettings->sfcInUseHinted = true; |
| |
| if (m_ddiDecodeAttr && m_ddiDecodeAttr->uiEncryptionType) |
| { |
| m_codechalSettings->secureMode = true; |
| } |
| |
| if (codecHal->Allocate(m_codechalSettings) != MOS_STATUS_SUCCESS) |
| { |
| DDI_ASSERTMESSAGE("Failure in decode allocate.\n"); |
| vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
| return vaStatus; |
| } |
| |
| PMOS_INTERFACE osInterface = codecHal->GetOsInterface(); |
| if (osInterface == nullptr) |
| { |
| DDI_ASSERTMESSAGE("Failure in decode allocate.\n"); |
| vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
| return vaStatus; |
| } |
| |
| #ifdef _MMC_SUPPORTED |
| if (!osInterface->apoMosEnabled && |
| MEDIA_IS_SKU(osInterface->pfnGetSkuTable(osInterface), FtrMemoryCompression) && |
| !mediaCtx->pMediaMemDecompState) |
| { |
| mediaCtx->pMediaMemDecompState = |
| static_cast<MediaMemDecompState *>(MmdDevice::CreateFactory(mosCtx)); |
| } |
| #endif |
| |
| m_ddiDecodeCtx->pCpDdiInterface->CreateCencDecode(codecHal->GetDebugInterface(), mosCtx, m_codechalSettings); |
| |
| return vaStatus; |
| } |
| |
| void DdiMediaDecode::GetDummyReferenceFromDPB( |
| DDI_DECODE_CONTEXT *decodeCtx) |
| { |
| MOS_SURFACE *destSurface = decodeCtx->DecodeParams.m_destSurface; |
| MOS_SURFACE dummyReference; |
| MOS_STATUS eStatus; |
| uint32_t i; |
| |
| if (destSurface == nullptr) |
| { |
| DDI_ASSERTMESSAGE("Decode output surface is NULL.\n"); |
| return; |
| } |
| |
| for (i = 0; i < DDI_MEDIA_MAX_SURFACE_NUMBER_CONTEXT; i++) |
| { |
| if (decodeCtx->RTtbl.pRT[i] != nullptr && |
| decodeCtx->RTtbl.pRT[i] != decodeCtx->RTtbl.pCurrentRT) |
| { |
| MOS_ZeroMemory(&dummyReference, sizeof(MOS_SURFACE)); |
| DdiMedia_MediaSurfaceToMosResource(decodeCtx->RTtbl.pRT[i], &(dummyReference.OsResource)); |
| |
| if (!Mos_ResourceIsNull(&dummyReference.OsResource)) |
| { |
| eStatus = MOS_STATUS_SUCCESS; |
| dummyReference.Format = Format_Invalid; |
| eStatus = Mos_Specific_GetResourceInfo(decodeCtx->pCodecHal->GetOsInterface(), &dummyReference.OsResource, &dummyReference); |
| if (eStatus != MOS_STATUS_SUCCESS) |
| { |
| continue; |
| } |
| |
| if (dummyReference.Type == destSurface->Type && |
| dummyReference.Format == destSurface->Format && |
| dummyReference.bIsCompressed == destSurface->bIsCompressed && |
| dummyReference.CompressionMode == destSurface->CompressionMode && |
| dummyReference.TileType == destSurface->TileType && |
| dummyReference.dwPitch >= destSurface->dwPitch && |
| dummyReference.dwWidth >= destSurface->dwWidth && |
| dummyReference.dwHeight >= destSurface->dwHeight) |
| { |
| break; |
| } |
| } |
| } |
| } |
| |
| if (i < DDI_MEDIA_MAX_SURFACE_NUMBER_CONTEXT) |
| { |
| if (decodeCtx->pCodecHal->IsApogeiosEnabled()) |
| { |
| DecodePipelineAdapter *decoder = dynamic_cast<DecodePipelineAdapter *>(decodeCtx->pCodecHal); |
| if (decoder == nullptr) |
| { |
| DDI_ASSERTMESSAGE("Codechal decode context is NULL.\n"); |
| return; |
| } |
| decoder->GetDummyReference()->OsResource = dummyReference.OsResource; |
| } |
| else |
| { |
| CodechalDecode *decoder = dynamic_cast<CodechalDecode *>(decodeCtx->pCodecHal); |
| if (decoder == nullptr) |
| { |
| DDI_ASSERTMESSAGE("Codechal decode context is NULL.\n"); |
| return; |
| } |
| decoder->GetDummyReference()->OsResource = dummyReference.OsResource; |
| } |
| } |
| } |
| |
| void DdiMediaDecode::ReportDecodeMode( |
| uint16_t wMode) |
| { |
| MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData; |
| MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData)); |
| userFeatureWriteData.Value.i32Data = wMode; |
| switch (wMode) |
| { |
| case CODECHAL_DECODE_MODE_MPEG2IDCT: |
| case CODECHAL_DECODE_MODE_MPEG2VLD: |
| userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_MPEG2_MODE_ID; |
| MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, nullptr); |
| break; |
| case CODECHAL_DECODE_MODE_VC1IT: |
| case CODECHAL_DECODE_MODE_VC1VLD: |
| userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_VC1_MODE_ID; |
| MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, nullptr); |
| break; |
| case CODECHAL_DECODE_MODE_AVCVLD: |
| userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_AVC_MODE_ID; |
| MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, nullptr); |
| break; |
| case CODECHAL_DECODE_MODE_JPEG: |
| userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_JPEG_MODE_ID; |
| MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, nullptr); |
| break; |
| case CODECHAL_DECODE_MODE_VP8VLD: |
| userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_VP8_MODE_ID; |
| MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, nullptr); |
| break; |
| case CODECHAL_DECODE_MODE_HEVCVLD: |
| userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_HEVC_MODE_ID; |
| MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, nullptr); |
| break; |
| case CODECHAL_DECODE_MODE_VP9VLD: |
| userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_VP9_MODE_ID; |
| MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, nullptr); |
| break; |
| case CODECHAL_DECODE_MODE_AV1VLD: |
| userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_AV1_MODE_ID; |
| MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, nullptr); |
| break; |
| default: |
| break; |
| } |
| } |
