diff options
Diffstat (limited to 'exynos/multimedia/openmax/component/video/dec/h264/SEC_OMX_H264dec.c')
-rw-r--r-- | exynos/multimedia/openmax/component/video/dec/h264/SEC_OMX_H264dec.c | 2067 |
1 files changed, 2067 insertions, 0 deletions
diff --git a/exynos/multimedia/openmax/component/video/dec/h264/SEC_OMX_H264dec.c b/exynos/multimedia/openmax/component/video/dec/h264/SEC_OMX_H264dec.c new file mode 100644 index 0000000..5efa041 --- /dev/null +++ b/exynos/multimedia/openmax/component/video/dec/h264/SEC_OMX_H264dec.c @@ -0,0 +1,2067 @@ +/* + * + * Copyright 2010 Samsung Electronics S.LSI Co. LTD + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * @file SEC_OMX_H264dec.c + * @brief + * @author SeungBeom Kim (sbcrux.kim@samsung.com) + * @version 1.1.0 + * @history + * 2010.7.15 : Create + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "SEC_OMX_Macros.h" +#include "SEC_OMX_Basecomponent.h" +#include "SEC_OMX_Baseport.h" +#include "SEC_OMX_Vdec.h" +#include "SEC_OSAL_ETC.h" +#include "SEC_OSAL_Semaphore.h" +#include "SEC_OSAL_Thread.h" +#include "library_register.h" +#include "SEC_OMX_H264dec.h" +#include "SsbSipMfcApi.h" +#include "color_space_convertor.h" + +#ifdef USE_ANB +#include "SEC_OSAL_Android.h" +#endif + +/* To use CSC FIMC in SEC OMX, gralloc should allocate physical memory using FIMC */ +/* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */ +#ifdef USE_CSC_FIMC +#include "csc_fimc.h" +#endif + +#undef SEC_LOG_TAG +#define SEC_LOG_TAG "SEC_H264_DEC" +#define SEC_LOG_OFF +#include "SEC_OSAL_Log.h" + +#define H264_DEC_NUM_OF_EXTRA_BUFFERS 7 + +#ifdef S3D_SUPPORT +#define ADD_SPS_PPS_I_FRAME +#else +//#define ADD_SPS_PPS_I_FRAME +#endif +//#define FULL_FRAME_SEARCH + +/* H.264 Decoder Supported Levels & profiles */ +SEC_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels[] ={ + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel32}, + {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel4}, + + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1b}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel11}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel12}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel13}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel2}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel21}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel22}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel3}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel31}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel32}, + {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel4}, + + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1b}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel11}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel12}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel13}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel2}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel21}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel22}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel3}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel31}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel32}, + {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel4}}; + + +static int Check_H264_Frame(OMX_U8 *pInputStream, OMX_U32 buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame) +{ + OMX_U32 preFourByte = (OMX_U32)-1; + int accessUnitSize = 0; + int frameTypeBoundary = 0; + int nextNaluSize = 0; + int naluStart = 0; + + if (bPreviousFrameEOF == OMX_TRUE) + naluStart = 0; + else + naluStart = 1; + + while (1) { + int inputOneByte = 0; + + if (accessUnitSize == (int)buffSize) + goto EXIT; + + inputOneByte = *(pInputStream++); + accessUnitSize += 1; + + if (preFourByte == 0x00000001 || (preFourByte << 8) == 0x00000100) { + int naluType = inputOneByte & 0x1F; + + SEC_OSAL_Log(SEC_LOG_TRACE, "NaluType : %d", naluType); + if (naluStart == 0) { +#ifdef ADD_SPS_PPS_I_FRAME + if (naluType == 1 || naluType == 5) +#else + if (naluType == 1 || naluType == 5 || naluType == 7 || naluType == 8) +#endif + naluStart = 1; + } else { +#ifdef OLD_DETECT + frameTypeBoundary = (8 - naluType) & (naluType - 10); //AUD(9) +#else + if (naluType == 9) + frameTypeBoundary = -2; +#endif + if (naluType == 1 || naluType == 5) { + if (accessUnitSize == (int)buffSize) { + accessUnitSize--; + goto EXIT; + } + inputOneByte = *pInputStream++; + accessUnitSize += 1; + + if (inputOneByte >= 0x80) + frameTypeBoundary = -1; + } + if (frameTypeBoundary < 0) { + break; + } + } + + } + preFourByte = (preFourByte << 8) + inputOneByte; + } + + *pbEndOfFrame = OMX_TRUE; + nextNaluSize = -5; + if (frameTypeBoundary == -1) + nextNaluSize = -6; + if (preFourByte != 0x00000001) + nextNaluSize++; + return (accessUnitSize + nextNaluSize); + +EXIT: + *pbEndOfFrame = OMX_FALSE; + + return accessUnitSize; +} + +OMX_BOOL Check_H264_StartCode(OMX_U8 *pInputStream, OMX_U32 streamSize) +{ + if (streamSize < 4) { + return OMX_FALSE; + } else if ((pInputStream[0] == 0x00) && + (pInputStream[1] == 0x00) && + (pInputStream[2] == 0x00) && + (pInputStream[3] != 0x00) && + ((pInputStream[3] >> 3) == 0x00)) { + return OMX_TRUE; + } else if ((pInputStream[0] == 0x00) && + (pInputStream[1] == 0x00) && + (pInputStream[2] != 0x00) && + ((pInputStream[2] >> 3) == 0x00)) { + return OMX_TRUE; + } else { + return OMX_FALSE; + } +} + +OMX_ERRORTYPE SEC_MFC_H264Dec_GetParameter( + OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_INDEXTYPE nParamIndex, + OMX_INOUT OMX_PTR pComponentParameterStructure) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = NULL; + SEC_OMX_BASECOMPONENT *pSECComponent = NULL; + + FunctionIn(); + + if (hComponent == NULL || pComponentParameterStructure == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; + ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + if (pOMXComponent->pComponentPrivate == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + + pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + if (pSECComponent->currentState == OMX_StateInvalid ) { + ret = OMX_ErrorInvalidState; + goto EXIT; + } + + switch (nParamIndex) { + case OMX_IndexParamVideoAvc: + { + OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure; + OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + + ret = SEC_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + pSrcAVCComponent = &pH264Dec->AVCComponent[pDstAVCComponent->nPortIndex]; + + SEC_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE)); + } + break; + case OMX_IndexParamStandardComponentRole: + { + OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure; + ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPONENT_H264_DEC_ROLE); + } + break; + case OMX_IndexParamVideoProfileLevelQuerySupported: + { + OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure; + SEC_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL; + OMX_U32 maxProfileLevelNum = 0; + + ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + + pProfileLevel = supportedAVCProfileLevels; + maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL); + + if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) { + ret = OMX_ErrorNoMore; + goto EXIT; + } + + pProfileLevel += pDstProfileLevel->nProfileIndex; + pDstProfileLevel->eProfile = pProfileLevel->profile; + pDstProfileLevel->eLevel = pProfileLevel->level; + } + break; + case OMX_IndexParamVideoProfileLevelCurrent: + { + OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure; + OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + + ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + pSrcAVCComponent = &pH264Dec->AVCComponent[pDstProfileLevel->nPortIndex]; + + pDstProfileLevel->eProfile = pSrcAVCComponent->eProfile; + pDstProfileLevel->eLevel = pSrcAVCComponent->eLevel; + } + break; + case OMX_IndexParamVideoErrorCorrection: + { + OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure; + OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + + ret = SEC_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + pSrcErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX]; + + pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC; + pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync; + pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing; + pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning; + pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC; + } + break; + default: + ret = SEC_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure); + break; + } +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_MFC_H264Dec_SetParameter( + OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_INDEXTYPE nIndex, + OMX_IN OMX_PTR pComponentParameterStructure) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = NULL; + SEC_OMX_BASECOMPONENT *pSECComponent = NULL; + + FunctionIn(); + + if (hComponent == NULL || pComponentParameterStructure == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; + ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + if (pOMXComponent->pComponentPrivate == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + + pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + if (pSECComponent->currentState == OMX_StateInvalid ) { + ret = OMX_ErrorInvalidState; + goto EXIT; + } + + switch (nIndex) { + case OMX_IndexParamVideoAvc: + { + OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL; + OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + + ret = SEC_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + pDstAVCComponent = &pH264Dec->AVCComponent[pSrcAVCComponent->nPortIndex]; + + SEC_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE)); + } + break; + case OMX_IndexParamStandardComponentRole: + { + OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure; + + ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) { + ret = OMX_ErrorIncorrectStateOperation; + goto EXIT; + } + + if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPONENT_H264_DEC_ROLE)) { + pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC; + } else { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + } + break; + case OMX_IndexParamPortDefinition: + { + OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure; + OMX_U32 portIndex = pPortDefinition->nPortIndex; + SEC_OMX_BASEPORT *pSECPort; + OMX_U32 width, height, size; + OMX_U32 realWidth, realHeight; + + if (portIndex >= pSECComponent->portParam.nPorts) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + ret = SEC_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + pSECPort = &pSECComponent->pSECPort[portIndex]; + + if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) { + if (pSECPort->portDefinition.bEnabled == OMX_TRUE) { + ret = OMX_ErrorIncorrectStateOperation; + goto EXIT; + } + } + if (pPortDefinition->nBufferCountActual < pSECPort->portDefinition.nBufferCountMin) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + + SEC_OSAL_Memcpy(&pSECPort->portDefinition, pPortDefinition, pPortDefinition->nSize); + + realWidth = pSECPort->portDefinition.format.video.nFrameWidth; + realHeight = pSECPort->portDefinition.format.video.nFrameHeight; + width = ((realWidth + 15) & (~15)); + height = ((realHeight + 15) & (~15)); + size = (width * height * 3) / 2; + pSECPort->portDefinition.format.video.nStride = width; + pSECPort->portDefinition.format.video.nSliceHeight = height; + pSECPort->portDefinition.nBufferSize = (size > pSECPort->portDefinition.nBufferSize) ? size : pSECPort->portDefinition.nBufferSize; + + if (portIndex == INPUT_PORT_INDEX) { + SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX]; + pSECOutputPort->portDefinition.format.video.nFrameWidth = pSECPort->portDefinition.format.video.nFrameWidth; + pSECOutputPort->portDefinition.format.video.nFrameHeight = pSECPort->portDefinition.format.video.nFrameHeight; + pSECOutputPort->portDefinition.format.video.nStride = width; + pSECOutputPort->portDefinition.format.video.nSliceHeight = height; + + switch (pSECOutputPort->portDefinition.format.video.eColorFormat) { + case OMX_COLOR_FormatYUV420Planar: + case OMX_COLOR_FormatYUV420SemiPlanar: + case OMX_SEC_COLOR_FormatNV12TPhysicalAddress: + case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar: + pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2; + break; + case OMX_SEC_COLOR_FormatNV12Tiled: + pSECOutputPort->portDefinition.nBufferSize = + ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight)) \ + + ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight/2)); + break; + default: + SEC_OSAL_Log(SEC_LOG_ERROR, "Color format is not support!! use default YUV size!!"); + ret = OMX_ErrorUnsupportedSetting; + break; + } + } + } + break; + case OMX_IndexParamVideoProfileLevelCurrent: + { + OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure; + OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + + ret = SEC_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE)); + if (ret != OMX_ErrorNone) + goto EXIT; + + if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + + pDstAVCComponent = &pH264Dec->AVCComponent[pSrcProfileLevel->nPortIndex]; + pDstAVCComponent->eProfile = pSrcProfileLevel->eProfile; + pDstAVCComponent->eLevel = pSrcProfileLevel->eLevel; + } + break; + case OMX_IndexParamVideoErrorCorrection: + { + OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure; + OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + + ret = SEC_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + pDstErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX]; + + pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC; + pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync; + pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing; + pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning; + pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC; + } + break; + default: + ret = SEC_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure); + break; + } +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_MFC_H264Dec_GetConfig( + OMX_HANDLETYPE hComponent, + OMX_INDEXTYPE nIndex, + OMX_PTR pComponentConfigStructure) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = NULL; + SEC_OMX_BASECOMPONENT *pSECComponent = NULL; + + FunctionIn(); + + if (hComponent == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; + ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pOMXComponent->pComponentPrivate == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + + if (pComponentConfigStructure == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + if (pSECComponent->currentState == OMX_StateInvalid) { + ret = OMX_ErrorInvalidState; + goto EXIT; + } + + switch (nIndex) { + case OMX_IndexConfigCommonOutputCrop: + { + SEC_H264DEC_HANDLE *pH264Dec = NULL; + OMX_CONFIG_RECTTYPE *pSrcRectType = NULL; + OMX_CONFIG_RECTTYPE *pDstRectType = NULL; + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + + if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) { + ret = OMX_ErrorNotReady; + break; + } + + pDstRectType = (OMX_CONFIG_RECTTYPE *)pComponentConfigStructure; + + if ((pDstRectType->nPortIndex != INPUT_PORT_INDEX) && + (pDstRectType->nPortIndex != OUTPUT_PORT_INDEX)) { + ret = OMX_ErrorBadPortIndex; + goto EXIT; + } + + SEC_OMX_BASEPORT *pSECPort = &pSECComponent->pSECPort[pDstRectType->nPortIndex]; + + pSrcRectType = &(pSECPort->cropRectangle); + + pDstRectType->nTop = pSrcRectType->nTop; + pDstRectType->nLeft = pSrcRectType->nLeft; + pDstRectType->nHeight = pSrcRectType->nHeight; + pDstRectType->nWidth = pSrcRectType->nWidth; + } + break; + default: + ret = SEC_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure); + break; + } + +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_MFC_H264Dec_SetConfig( + OMX_HANDLETYPE hComponent, + OMX_INDEXTYPE nIndex, + OMX_PTR pComponentConfigStructure) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = NULL; + SEC_OMX_BASECOMPONENT *pSECComponent = NULL; + + FunctionIn(); + + if (hComponent == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; + ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pOMXComponent->pComponentPrivate == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + + if (pComponentConfigStructure == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + if (pSECComponent->currentState == OMX_StateInvalid) { + ret = OMX_ErrorInvalidState; + goto EXIT; + } + + switch (nIndex) { + default: + ret = SEC_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure); + break; + } + +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_MFC_H264Dec_GetExtensionIndex( + OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_STRING cParameterName, + OMX_OUT OMX_INDEXTYPE *pIndexType) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = NULL; + SEC_OMX_BASECOMPONENT *pSECComponent = NULL; + + FunctionIn(); + + if (hComponent == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; + ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + if (pOMXComponent->pComponentPrivate == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + + if ((cParameterName == NULL) || (pIndexType == NULL)) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + if (pSECComponent->currentState == OMX_StateInvalid) { + ret = OMX_ErrorInvalidState; + goto EXIT; + } + + if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) { + SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + + *pIndexType = OMX_IndexVendorThumbnailMode; + + ret = OMX_ErrorNone; + } else { + ret = SEC_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType); + } + +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_MFC_H264Dec_ComponentRoleEnum(OMX_HANDLETYPE hComponent, OMX_U8 *cRole, OMX_U32 nIndex) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = NULL; + SEC_OMX_BASECOMPONENT *pSECComponent = NULL; + + FunctionIn(); + + if ((hComponent == NULL) || (cRole == NULL)) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) { + SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPONENT_H264_DEC_ROLE); + ret = OMX_ErrorNone; + } else { + ret = OMX_ErrorNoMore; + } + +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_MFC_DecodeThread(OMX_HANDLETYPE hComponent) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; + SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle; + SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)pVideoDec->hCodecHandle; + + FunctionIn(); + + if (hComponent == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + + while (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) { + SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameStart); + + if (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) { + pH264Dec->hMFCH264Handle.returnCodec = SsbSipMfcDecExe(pH264Dec->hMFCH264Handle.hMFCHandle, pVideoDec->NBDecThread.oneFrameSize); + SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameEnd); + } + } + +EXIT: + SEC_OSAL_ThreadExit(NULL); + FunctionOut(); + + return ret; +} + +/* MFC Init */ +OMX_ERRORTYPE SEC_MFC_H264Dec_Init(OMX_COMPONENTTYPE *pOMXComponent) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle; + SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX]; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + OMX_PTR hMFCHandle = NULL; + OMX_PTR pStreamBuffer = NULL; + OMX_PTR pStreamPhyBuffer = NULL; +#ifdef S3D_SUPPORT + OMX_S32 setConfVal = 0; +#endif + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_FALSE; + pSECComponent->bUseFlagEOF = OMX_FALSE; + pSECComponent->bSaveFlagEOS = OMX_FALSE; + + /* MFC(Multi Function Codec) decoder and CMM(Codec Memory Management) driver open */ + if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress) { + hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen(); + } else { + SSBIP_MFC_BUFFER_TYPE buf_type = CACHE; + hMFCHandle = (OMX_PTR)SsbSipMfcDecOpenExt(&buf_type); + } + + if (hMFCHandle == NULL) { + ret = OMX_ErrorInsufficientResources; + goto EXIT; + } + pH264Dec->hMFCH264Handle.hMFCHandle = hMFCHandle; + +#ifdef S3D_SUPPORT + /*Enable SEI parsing for checking frame_packing S3D*/ + setConfVal = 1; + SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_SEI_PARSE, &setConfVal); +#endif + + /* Allocate decoder's input buffer */ + /* Get first input buffer */ + pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2); + if (pStreamBuffer == NULL) { + ret = OMX_ErrorInsufficientResources; + goto EXIT; + } + pVideoDec->MFCDecInputBuffer[0].VirAddr = pStreamBuffer; + pVideoDec->MFCDecInputBuffer[0].PhyAddr = pStreamPhyBuffer; + pVideoDec->MFCDecInputBuffer[0].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2; + pVideoDec->MFCDecInputBuffer[0].dataSize = 0; + +#ifdef NONBLOCK_MODE_PROCESS + /* Get second input buffer */ + pStreamBuffer = NULL; + pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2); + if (pStreamBuffer == NULL) { + ret = OMX_ErrorInsufficientResources; + goto EXIT; + } + pVideoDec->MFCDecInputBuffer[1].VirAddr = pStreamBuffer; + pVideoDec->MFCDecInputBuffer[1].PhyAddr = pStreamPhyBuffer; + pVideoDec->MFCDecInputBuffer[1].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2; + pVideoDec->MFCDecInputBuffer[1].dataSize = 0; + pVideoDec->indexInputBuffer = 0; + + pVideoDec->bFirstFrame = OMX_TRUE; + + pVideoDec->NBDecThread.bExitDecodeThread = OMX_FALSE; + pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE; + pVideoDec->NBDecThread.oneFrameSize = 0; + SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameStart)); + SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameEnd)); + if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pVideoDec->NBDecThread.hNBDecodeThread, + SEC_MFC_DecodeThread, + pOMXComponent)) { + pH264Dec->hMFCH264Handle.returnCodec = MFC_RET_OK; + } +#endif + + pH264Dec->hMFCH264Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr; + pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[0].PhyAddr; + pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr; + pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[0].bufferSize; + + SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP); + SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS); + pH264Dec->hMFCH264Handle.indexTimestamp = 0; + pH264Dec->hMFCH264Handle.outputIndexTimestamp = 0; + + pSECComponent->getAllDelayBuffer = OMX_FALSE; + +#ifdef USE_CSC_FIMC + pH264Dec->hFIMCHandle = csc_fimc_open(); +#endif + +EXIT: + FunctionOut(); + + return ret; +} + +/* MFC Terminate */ +OMX_ERRORTYPE SEC_MFC_H264Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + OMX_PTR hMFCHandle = NULL; + + FunctionIn(); + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle; + + pH264Dec->hMFCH264Handle.pMFCStreamBuffer = NULL; + pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = NULL; + pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = NULL; + pSECComponent->processData[INPUT_PORT_INDEX].allocSize = 0; + +#ifdef NONBLOCK_MODE_PROCESS + if (pVideoDec->NBDecThread.hNBDecodeThread != NULL) { + pVideoDec->NBDecThread.bExitDecodeThread = OMX_TRUE; + SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart); + SEC_OSAL_ThreadTerminate(pVideoDec->NBDecThread.hNBDecodeThread); + pVideoDec->NBDecThread.hNBDecodeThread = NULL; + } + + if(pVideoDec->NBDecThread.hDecFrameEnd != NULL) { + SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameEnd); + pVideoDec->NBDecThread.hDecFrameEnd = NULL; + } + + if(pVideoDec->NBDecThread.hDecFrameStart != NULL) { + SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameStart); + pVideoDec->NBDecThread.hDecFrameStart = NULL; + } +#endif + + if (hMFCHandle != NULL) { + SsbSipMfcDecClose(hMFCHandle); + hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle = NULL; + } + +#ifdef USE_CSC_FIMC + if (pH264Dec->hFIMCHandle != NULL) { + csc_fimc_close(pH264Dec->hFIMCHandle); + pH264Dec->hFIMCHandle = NULL; + } +#endif + +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_MFC_H264_Decode_Nonblock(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle; + SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX]; + SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX]; + OMX_U32 oneFrameSize = pInputData->dataLen; + SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo; + OMX_S32 setConfVal = 0; + int bufWidth = 0; + int bufHeight = 0; + OMX_U32 FrameBufferYSize = 0; + OMX_U32 FrameBufferUVSize = 0; + OMX_BOOL outputDataValid = OMX_FALSE; +#ifdef S3D_SUPPORT + SSBSIP_MFC_FRAME_PACKING frame_packing; +#endif + + FunctionIn(); + + if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) { + SSBSIP_MFC_CODEC_TYPE eCodecType = H264_DEC; + + if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) { + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + ret = OMX_ErrorNone; + goto EXIT; + } + + /* Default number in the driver is optimized */ + if (pVideoDec->bThumbnailMode == OMX_TRUE) { + setConfVal = 0; + SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal); + } else { + setConfVal = H264_DEC_NUM_OF_EXTRA_BUFFERS; + SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &setConfVal); + + setConfVal = 8; + SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal); + } + + SsbSipMfcDecSetInBuf(pH264Dec->hMFCH264Handle.hMFCHandle, + pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer, + pH264Dec->hMFCH264Handle.pMFCStreamBuffer, + pSECComponent->processData[INPUT_PORT_INDEX].allocSize); + + pH264Dec->hMFCH264Handle.returnCodec = SsbSipMfcDecInit(pH264Dec->hMFCH264Handle.hMFCHandle, eCodecType, oneFrameSize); + if (pH264Dec->hMFCH264Handle.returnCodec == MFC_RET_OK) { + SSBSIP_MFC_IMG_RESOLUTION imgResol; + SSBSIP_MFC_CROP_INFORMATION cropInfo; + + SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol); + SEC_OSAL_Log(SEC_LOG_TRACE, "set width height information : %d, %d", + pSECInputPort->portDefinition.format.video.nFrameWidth, + pSECInputPort->portDefinition.format.video.nFrameHeight); + SEC_OSAL_Log(SEC_LOG_TRACE, "mfc width height information : %d, %d", + imgResol.width, imgResol.height); + + SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_CROP_INFO, &cropInfo); + SEC_OSAL_Log(SEC_LOG_TRACE, "mfc crop_top crop_bottom crop_left crop_right : %d, %d, %d, %d", + cropInfo.crop_top_offset , cropInfo.crop_bottom_offset , + cropInfo.crop_left_offset , cropInfo.crop_right_offset); + + pSECOutputPort->cropRectangle.nTop = cropInfo.crop_top_offset; + pSECOutputPort->cropRectangle.nLeft = cropInfo.crop_left_offset; + pSECOutputPort->cropRectangle.nWidth = imgResol.width - cropInfo.crop_left_offset - cropInfo.crop_right_offset; + pSECOutputPort->cropRectangle.nHeight = imgResol.height - cropInfo.crop_top_offset - cropInfo.crop_bottom_offset; + + pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_TRUE; + + /** Update Frame Size **/ + if ((cropInfo.crop_left_offset != 0) || (cropInfo.crop_right_offset != 0) || + (cropInfo.crop_top_offset != 0) || (cropInfo.crop_bottom_offset != 0)) { + /* change width and height information */ + pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width; + pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height; + pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15)); + pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15)); + + SEC_UpdateFrameSize(pOMXComponent); + + /** Send crop info call back **/ + (*(pSECComponent->pCallbacks->EventHandler)) + (pOMXComponent, + pSECComponent->callbackData, + OMX_EventPortSettingsChanged, /* The command was completed */ + OMX_DirOutput, /* This is the port index */ + OMX_IndexConfigCommonOutputCrop, + NULL); + } + if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) || + (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) { + SEC_OSAL_Log(SEC_LOG_TRACE, "change width height information : OMX_EventPortSettingsChanged"); + + /* change width and height information */ + pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width; + pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height; + pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15)); + pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15)); + + SEC_UpdateFrameSize(pOMXComponent); + + /** Send Port Settings changed call back **/ + (*(pSECComponent->pCallbacks->EventHandler)) + (pOMXComponent, + pSECComponent->callbackData, + OMX_EventPortSettingsChanged, /* The command was completed */ + OMX_DirOutput, /* This is the port index */ + 0, + NULL); + } + +#ifdef ADD_SPS_PPS_I_FRAME + ret = OMX_ErrorInputDataDecodeYet; +#else + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + + ret = OMX_ErrorNone; +#endif + goto EXIT; + } else { + ret = OMX_ErrorMFCInit; + goto EXIT; + } + } + +#ifndef FULL_FRAME_SEARCH + if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) && + (pSECComponent->bUseFlagEOF == OMX_FALSE)) + pSECComponent->bUseFlagEOF = OMX_TRUE; +#endif + + pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp; + pSECComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->nFlags; + + if ((pH264Dec->hMFCH264Handle.returnCodec == MFC_RET_OK) && + (pVideoDec->bFirstFrame == OMX_FALSE)) { + SSBSIP_MFC_DEC_OUTBUF_STATUS status; + OMX_S32 indexTimestamp = 0; + + /* wait for mfc decode done */ + if (pVideoDec->NBDecThread.bDecoderRun == OMX_TRUE) { + SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameEnd); + pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE; + } + + SEC_OSAL_SleepMillisec(0); + status = SsbSipMfcDecGetOutBuf(pH264Dec->hMFCH264Handle.hMFCHandle, &outputInfo); + bufWidth = (outputInfo.img_width + 15) & (~15); + bufHeight = (outputInfo.img_height + 15) & (~15); + FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height)); + FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2)); + +#ifdef S3D_SUPPORT + /* Check Whether frame packing information is available */ + SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_PACKING, &frame_packing); + + if (pVideoDec->bThumbnailMode == OMX_FALSE && + frame_packing.available && + pH264Dec->hMFCH264Handle.bS3DMode == OMX_FALSE) { + + SEC_OSAL_Log(SEC_LOG_TRACE, "arrangement ID: 0x%08x", frame_packing.arrangement_id); + SEC_OSAL_Log(SEC_LOG_TRACE, "arrangement_type: %d", frame_packing.arrangement_type); + SEC_OSAL_Log(SEC_LOG_TRACE, "content_interpretation_type: %d", frame_packing.content_interpretation_type); + SEC_OSAL_Log(SEC_LOG_TRACE, "current_frame_is_frame0_flag: %d", frame_packing.current_frame_is_frame0_flag); + SEC_OSAL_Log(SEC_LOG_TRACE, "spatial_flipping_flag: %d", frame_packing.spatial_flipping_flag); + SEC_OSAL_Log(SEC_LOG_TRACE, "fr0X:%d fr0Y:%d fr0X:%d fr0Y:%d", frame_packing.frame0_grid_pos_x, + frame_packing.frame0_grid_pos_y, frame_packing.frame1_grid_pos_x, frame_packing.frame1_grid_pos_y); + + /* Change Outport eColorFormat based on Framepacking information*/ + if (frame_packing.arrangement_type == 3) { + if (frame_packing.content_interpretation_type == 1) { + switch (pSECOutputPort->portDefinition.format.video.eColorFormat) { + case OMX_SEC_COLOR_FormatNV12Tiled: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled_SBS_LR; + break; + case OMX_COLOR_FormatYUV420SemiPlanar: + case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_LR; + break; + case OMX_COLOR_FormatYUV420Planar: + default: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420Planar_SBS_LR; + break; + } + } else if (frame_packing.content_interpretation_type == 2) { + switch (pSECOutputPort->portDefinition.format.video.eColorFormat) { + case OMX_SEC_COLOR_FormatNV12Tiled: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled_SBS_RL; + break; + case OMX_COLOR_FormatYUV420SemiPlanar: + case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_RL; + break; + case OMX_COLOR_FormatYUV420Planar: + default: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420Planar_SBS_RL; + break; + } + } + } else if (frame_packing.arrangement_type == 4) { + if (frame_packing.content_interpretation_type == 1) { + switch (pSECOutputPort->portDefinition.format.video.eColorFormat) { + case OMX_SEC_COLOR_FormatNV12Tiled: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled_TB_LR; + break; + case OMX_COLOR_FormatYUV420SemiPlanar: + case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_LR; + break; + case OMX_COLOR_FormatYUV420Planar: + default: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420Planar_TB_LR; + break; + } + } else if (frame_packing.content_interpretation_type == 2) { + switch (pSECOutputPort->portDefinition.format.video.eColorFormat) { + case OMX_SEC_COLOR_FormatNV12Tiled: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled_TB_RL; + break; + case OMX_COLOR_FormatYUV420SemiPlanar: + case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_RL; + break; + case OMX_COLOR_FormatYUV420Planar: + default: + pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420Planar_TB_RL; + break; + } + } + } + + /** Send Port Settings changed call back - output color format change */ + (*(pSECComponent->pCallbacks->EventHandler)) + (pOMXComponent, + pSECComponent->callbackData, + OMX_EventPortSettingsChanged, /* The command was completed */ + OMX_DirOutput, /* This is the port index */ + 0, + NULL); + + if ((pSECOutputPort->cropRectangle.nTop != 0) || (pSECOutputPort->cropRectangle.nLeft != 0)) { + /** Send crop info call back **/ + (*(pSECComponent->pCallbacks->EventHandler)) + (pOMXComponent, + pSECComponent->callbackData, + OMX_EventPortSettingsChanged, /* The command was completed */ + OMX_DirOutput, /* This is the port index */ + OMX_IndexConfigCommonOutputCrop, + NULL); + } + pH264Dec->hMFCH264Handle.bS3DMode = OMX_TRUE; + SEC_OSAL_SleepMillisec(0); + ret = OMX_ErrorInputDataDecodeYet; + goto EXIT; + } +#endif + + if ((SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) || + (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) { + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + } else { + /* For timestamp correction. if mfc support frametype detect */ + SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type); +#ifdef NEED_TIMESTAMP_REORDER + if ((outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) || + (pH264Dec->hMFCH264Handle.bFlashPlayerMode == OMX_TRUE)) { + pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp]; + pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp]; + pH264Dec->hMFCH264Handle.outputIndexTimestamp = indexTimestamp; + } else { + pOutputData->timeStamp = pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp]; + pOutputData->nFlags = pSECComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp]; + } +#else + pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp]; + pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp]; +#endif + SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6); + } + + if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) || + (status == MFC_GETOUTBUF_DISPLAY_ONLY)) { + outputDataValid = OMX_TRUE; + pH264Dec->hMFCH264Handle.outputIndexTimestamp++; + pH264Dec->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP; + } + if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS) + outputDataValid = OMX_FALSE; + + if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) || + (pSECComponent->getAllDelayBuffer == OMX_TRUE)) + ret = OMX_ErrorInputDataDecodeYet; + + if (status == MFC_GETOUTBUF_DECODING_ONLY) { + if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) && + ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) { + pInputData->nFlags |= OMX_BUFFERFLAG_EOS; + pSECComponent->getAllDelayBuffer = OMX_TRUE; + ret = OMX_ErrorInputDataDecodeYet; + } else { + ret = OMX_ErrorNone; + } + outputDataValid = OMX_FALSE; + } + +#ifdef FULL_FRAME_SEARCH + if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) && + (pSECComponent->bSaveFlagEOS == OMX_TRUE)) { + pInputData->nFlags |= OMX_BUFFERFLAG_EOS; + pSECComponent->getAllDelayBuffer = OMX_TRUE; + ret = OMX_ErrorInputDataDecodeYet; + } else +#endif + if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) { + pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS)); + pSECComponent->getAllDelayBuffer = OMX_TRUE; + ret = OMX_ErrorInputDataDecodeYet; + } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) { + pSECComponent->getAllDelayBuffer = OMX_FALSE; + ret = OMX_ErrorNone; + } + } else { + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + + if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || + (pSECComponent->getAllDelayBuffer == OMX_TRUE) || + (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) { + pOutputData->nFlags |= OMX_BUFFERFLAG_EOS; + pSECComponent->getAllDelayBuffer = OMX_FALSE; + } + + if ((pVideoDec->bFirstFrame == OMX_TRUE) && + ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) && + ((pInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) != OMX_BUFFERFLAG_CODECCONFIG)) { + pOutputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS)); + } + + outputDataValid = OMX_FALSE; + + /* ret = OMX_ErrorUndefined; */ + ret = OMX_ErrorNone; + } + + if (ret == OMX_ErrorInputDataDecodeYet) { + pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize; + pVideoDec->indexInputBuffer++; + pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX; + pH264Dec->hMFCH264Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr; + pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr; + pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr; + pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize; + oneFrameSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize; + //pInputData->dataLen = oneFrameSize; + //pInputData->remainDataLen = oneFrameSize; + } + + if ((Check_H264_StartCode(pInputData->dataBuffer, oneFrameSize) == OMX_TRUE) && + ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) { + if ((ret != OMX_ErrorInputDataDecodeYet) || (pSECComponent->getAllDelayBuffer == OMX_TRUE)) { + SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pH264Dec->hMFCH264Handle.indexTimestamp)); + pH264Dec->hMFCH264Handle.indexTimestamp++; + pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP; + } + + SsbSipMfcDecSetInBuf(pH264Dec->hMFCH264Handle.hMFCHandle, + pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer, + pH264Dec->hMFCH264Handle.pMFCStreamBuffer, + pSECComponent->processData[INPUT_PORT_INDEX].allocSize); + + pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize; + pVideoDec->NBDecThread.oneFrameSize = oneFrameSize; + + /* mfc decode start */ + SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart); + pVideoDec->NBDecThread.bDecoderRun = OMX_TRUE; + pH264Dec->hMFCH264Handle.returnCodec = MFC_RET_OK; + + SEC_OSAL_SleepMillisec(0); + + pVideoDec->indexInputBuffer++; + pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX; + pH264Dec->hMFCH264Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr; + pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr; + pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr; + pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize; + + if ((pVideoDec->bFirstFrame == OMX_TRUE) && + (pSECComponent->bSaveFlagEOS == OMX_TRUE) && + (outputDataValid == OMX_FALSE)) { + ret = OMX_ErrorInputDataDecodeYet; + } + + pVideoDec->bFirstFrame = OMX_FALSE; + } else { + if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) + pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE; + } + + /** Fill Output Buffer **/ + if (outputDataValid == OMX_TRUE) { + void *pOutputBuf = (void *)pOutputData->dataBuffer; + void *pYUVBuf[3]; + + int frameSize = bufWidth * bufHeight; + int actualWidth = outputInfo.img_width; + int actualHeight = outputInfo.img_height; + int actualImageSize = actualWidth * actualHeight; + + pYUVBuf[0] = (unsigned char *)pOutputBuf; + pYUVBuf[1] = (unsigned char *)pOutputBuf + actualImageSize; + pYUVBuf[2] = (unsigned char *)pOutputBuf + actualImageSize + actualImageSize / 4; + pOutputData->dataLen = (actualImageSize * 3) / 2; + +#ifdef USE_ANB + if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) { + OMX_U32 stride; + SEC_OSAL_LockANB(pOutputData->dataBuffer, actualWidth, actualHeight, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf); + actualWidth = stride; + pOutputData->dataLen = sizeof(void *); + } +#endif + if ((pVideoDec->bThumbnailMode == OMX_FALSE) && + (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) { + /* if use Post copy address structure */ + SEC_OSAL_Memcpy(pOutputBuf, &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr)); + SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr)); + SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr)); + SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr)); + pOutputData->dataLen = (actualWidth * actualHeight * 3) / 2; + } else { + SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420p out for ThumbnailMode/Flash player mode"); + switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) { + case OMX_SEC_COLOR_FormatNV12Tiled: +#ifdef S3D_SUPPORT + case OMX_SEC_COLOR_FormatNV12Tiled_SBS_LR: + case OMX_SEC_COLOR_FormatNV12Tiled_SBS_RL: + case OMX_SEC_COLOR_FormatNV12Tiled_TB_LR: + case OMX_SEC_COLOR_FormatNV12Tiled_TB_RL: +#endif + SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize); + SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize); + pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize; + break; + case OMX_COLOR_FormatYUV420SemiPlanar: +#ifdef S3D_SUPPORT + case OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_LR: + case OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_RL: + case OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_LR: + case OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_RL: +#endif + case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar: +#ifdef USE_CSC_FIMC + if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (pH264Dec->hFIMCHandle != NULL)) { + void *pPhys[3]; + SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pPhys); + pYUVBuf[0] = outputInfo.YPhyAddr; + pYUVBuf[1] = outputInfo.CPhyAddr; + csc_fimc_convert_nv12t(pH264Dec->hFIMCHandle, pPhys, + pYUVBuf, actualWidth, actualHeight, + OMX_COLOR_FormatYUV420SemiPlanar); + break; + } +#endif + csc_tiled_to_linear_y_neon( + (unsigned char *)pYUVBuf[0], + (unsigned char *)outputInfo.YVirAddr, + actualWidth, + actualHeight); + csc_tiled_to_linear_uv_neon( + (unsigned char *)pYUVBuf[1], + (unsigned char *)outputInfo.CVirAddr, + actualWidth, + actualHeight / 2); + break; + case OMX_COLOR_FormatYUV420Planar: +#ifdef S3D_SUPPORT + case OMX_SEC_COLOR_FormatYUV420Planar_SBS_LR: + case OMX_SEC_COLOR_FormatYUV420Planar_SBS_RL: + case OMX_SEC_COLOR_FormatYUV420Planar_TB_LR: + case OMX_SEC_COLOR_FormatYUV420Planar_TB_RL: +#endif + default: +#ifdef USE_CSC_FIMC + if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (pH264Dec->hFIMCHandle != NULL)) { + void *pPhys[3]; + SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pPhys); + pYUVBuf[0] = outputInfo.YPhyAddr; + pYUVBuf[1] = outputInfo.CPhyAddr; + csc_fimc_convert_nv12t(pH264Dec->hFIMCHandle, pPhys, + pYUVBuf, actualWidth, actualHeight, + OMX_COLOR_FormatYUV420Planar); + break; + } +#endif + csc_tiled_to_linear_y_neon( + (unsigned char *)pYUVBuf[0], + (unsigned char *)outputInfo.YVirAddr, + actualWidth, + actualHeight); + csc_tiled_to_linear_uv_deinterleave_neon( + (unsigned char *)pYUVBuf[1], + (unsigned char *)pYUVBuf[2], + (unsigned char *)outputInfo.CVirAddr, + actualWidth, + actualHeight / 2); + break; + } + } +#ifdef USE_ANB + if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) { + SEC_OSAL_UnlockANB(pOutputData->dataBuffer); + } +#endif + } else { + pOutputData->dataLen = 0; + } + +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_MFC_H264_Decode_Block(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle; + SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX]; + SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX]; + SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + OMX_U32 oneFrameSize = pInputData->dataLen; + SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo; + OMX_S32 setConfVal = 0; + OMX_S32 returnCodec = 0; + int bufWidth = 0; + int bufHeight = 0; + OMX_U32 FrameBufferYSize; + OMX_U32 FrameBufferUVSize; + + FunctionIn(); + + if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) { + SSBSIP_MFC_CODEC_TYPE eCodecType = H264_DEC; + + if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) { + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + ret = OMX_ErrorNone; + goto EXIT; + } + + /* Default number in the driver is optimized */ + if (pVideoDec->bThumbnailMode == OMX_TRUE) { + setConfVal = 0; + SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal); + } else { + setConfVal = H264_DEC_NUM_OF_EXTRA_BUFFERS; + SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &setConfVal); + + setConfVal = 8; + SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal); + } + + returnCodec = SsbSipMfcDecInit(pH264Dec->hMFCH264Handle.hMFCHandle, eCodecType, oneFrameSize); + if (returnCodec == MFC_RET_OK) { + SSBSIP_MFC_IMG_RESOLUTION imgResol; + SSBSIP_MFC_CROP_INFORMATION cropInfo; + + SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol); + SEC_OSAL_Log(SEC_LOG_TRACE, "set width height information : %d, %d", + pSECInputPort->portDefinition.format.video.nFrameWidth, + pSECInputPort->portDefinition.format.video.nFrameHeight); + SEC_OSAL_Log(SEC_LOG_TRACE, "mfc width height information : %d, %d", + imgResol.width, imgResol.height); + + SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_CROP_INFO, &cropInfo); + SEC_OSAL_Log(SEC_LOG_TRACE, "mfc crop_top crop_bottom crop_left crop_right : %d, %d, %d, %d", + cropInfo.crop_top_offset , cropInfo.crop_bottom_offset , + cropInfo.crop_left_offset , cropInfo.crop_right_offset); + + pSECOutputPort->cropRectangle.nTop = cropInfo.crop_top_offset; + pSECOutputPort->cropRectangle.nLeft = cropInfo.crop_left_offset; + pSECOutputPort->cropRectangle.nWidth = imgResol.width - cropInfo.crop_left_offset - cropInfo.crop_right_offset; + pSECOutputPort->cropRectangle.nHeight = imgResol.height - cropInfo.crop_top_offset - cropInfo.crop_bottom_offset; + + pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_TRUE; + + /** Update Frame Size **/ + if ((cropInfo.crop_left_offset != 0) || (cropInfo.crop_right_offset != 0) || + (cropInfo.crop_top_offset != 0) || (cropInfo.crop_bottom_offset != 0)) { + /* change width and height information */ + pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width; + pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height; + pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15)); + pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15)); + + SEC_UpdateFrameSize(pOMXComponent); + + /** Send crop info call back **/ + (*(pSECComponent->pCallbacks->EventHandler)) + (pOMXComponent, + pSECComponent->callbackData, + OMX_EventPortSettingsChanged, /* The command was completed */ + OMX_DirOutput, /* This is the port index */ + OMX_IndexConfigCommonOutputCrop, + NULL); + } + if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) || + (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) { + SEC_OSAL_Log(SEC_LOG_TRACE, "change width height information : OMX_EventPortSettingsChanged"); + /* change width and height information */ + pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width; + pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height; + pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15)); + pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15)); + + SEC_UpdateFrameSize(pOMXComponent); + + /** Send Port Settings changed call back **/ + (*(pSECComponent->pCallbacks->EventHandler)) + (pOMXComponent, + pSECComponent->callbackData, + OMX_EventPortSettingsChanged, /* The command was completed */ + OMX_DirOutput, /* This is the port index */ + 0, + NULL); + } + +#ifdef ADD_SPS_PPS_I_FRAME + ret = OMX_ErrorInputDataDecodeYet; +#else + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + + ret = OMX_ErrorNone; +#endif + goto EXIT; + } else { + ret = OMX_ErrorMFCInit; + goto EXIT; + } + } + +#ifndef FULL_FRAME_SEARCH + if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) && + (pSECComponent->bUseFlagEOF == OMX_FALSE)) + pSECComponent->bUseFlagEOF = OMX_TRUE; +#endif + + if (Check_H264_StartCode(pInputData->dataBuffer, pInputData->dataLen) == OMX_TRUE) { + pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp; + pSECComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->nFlags; + SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pH264Dec->hMFCH264Handle.indexTimestamp)); + + returnCodec = SsbSipMfcDecExe(pH264Dec->hMFCH264Handle.hMFCHandle, oneFrameSize); + } else { + if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) + pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE; + + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + returnCodec = MFC_RET_OK; + goto EXIT; + } + + if (returnCodec == MFC_RET_OK) { + SSBSIP_MFC_DEC_OUTBUF_STATUS status; + OMX_S32 indexTimestamp = 0; + + status = SsbSipMfcDecGetOutBuf(pH264Dec->hMFCH264Handle.hMFCHandle, &outputInfo); + bufWidth = (outputInfo.img_width + 15) & (~15); + bufHeight = (outputInfo.img_height + 15) & (~15); + FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height)); + FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2)); + + if (status != MFC_GETOUTBUF_DISPLAY_ONLY) { + pH264Dec->hMFCH264Handle.indexTimestamp++; + pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP; + } + + if ((SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) || + (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) { + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + } else { + /* For timestamp correction. if mfc support frametype detect */ + SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type); +#ifdef NEED_TIMESTAMP_REORDER + if ((outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) || + (pH264Dec->hMFCH264Handle.bFlashPlayerMode != OMX_FALSE)) { + pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp]; + pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp]; + pH264Dec->hMFCH264Handle.outputIndexTimestamp = indexTimestamp; + } else { + pOutputData->timeStamp = pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp]; + pOutputData->nFlags = pSECComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp]; + } +#else + pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp]; + pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp]; +#endif + SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6); + } + + if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) || + (status == MFC_GETOUTBUF_DISPLAY_ONLY)) { + /** Fill Output Buffer **/ + void *pOutputBuf = (void *)pOutputData->dataBuffer; + void *pYUVBuf[3]; + + int frameSize = bufWidth * bufHeight; + int actualWidth = outputInfo.img_width; + int actualHeight = outputInfo.img_height; + int actualImageSize = actualWidth * actualHeight; + + pYUVBuf[0] = (unsigned char *)pOutputBuf; + pYUVBuf[1] = (unsigned char *)pOutputBuf + actualImageSize; + pYUVBuf[2] = (unsigned char *)pOutputBuf + actualImageSize + actualImageSize / 4; + pOutputData->dataLen = (actualImageSize * 3) / 2; + +#ifdef USE_ANB + if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) { + OMX_U32 stride; + SEC_OSAL_LockANB(pOutputData->dataBuffer, actualWidth, actualHeight, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf); + actualWidth = stride; + pOutputData->dataLen = sizeof(void *); + } +#endif + if ((pVideoDec->bThumbnailMode == OMX_FALSE) && + (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) { + /* if use Post copy address structure */ + SEC_OSAL_Memcpy(pOutputBuf, &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr)); + SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr)); + SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr)); + SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr)); + pOutputData->dataLen = (actualWidth * actualHeight * 3) / 2; + } else { + SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420p out for ThumbnailMode/Flash player mode"); + switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) { + case OMX_SEC_COLOR_FormatNV12Tiled: + SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize); + SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize); + pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize; + break; + case OMX_COLOR_FormatYUV420SemiPlanar: + case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar: +#ifdef USE_CSC_FIMC + if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (pH264Dec->hFIMCHandle != NULL)) { + void *pPhys[3]; + SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pPhys); + pYUVBuf[0] = outputInfo.YPhyAddr; + pYUVBuf[1] = outputInfo.CPhyAddr; + csc_fimc_convert_nv12t(pH264Dec->hFIMCHandle, pPhys, + pYUVBuf, actualWidth, actualHeight, + OMX_SEC_COLOR_FormatANBYUV420SemiPlanar); + break; + } +#endif + csc_tiled_to_linear_y_neon( + (unsigned char *)pYUVBuf[0], + (unsigned char *)outputInfo.YVirAddr, + actualWidth, + actualHeight); + csc_tiled_to_linear_uv_neon( + (unsigned char *)pYUVBuf[1], + (unsigned char *)outputInfo.CVirAddr, + actualWidth, + actualHeight / 2); + break; + case OMX_COLOR_FormatYUV420Planar: + default: +#ifdef USE_CSC_FIMC + if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (pH264Dec->hFIMCHandle != NULL)) { + void *pPhys[3]; + SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pPhys); + pYUVBuf[0] = outputInfo.YPhyAddr; + pYUVBuf[1] = outputInfo.CPhyAddr; + csc_fimc_convert_nv12t(pH264Dec->hFIMCHandle, pPhys, + pYUVBuf, actualWidth, actualHeight, + OMX_COLOR_FormatYUV420Planar); + break; + } +#endif + csc_tiled_to_linear_y_neon( + (unsigned char *)pYUVBuf[0], + (unsigned char *)outputInfo.YVirAddr, + actualWidth, + actualHeight); + csc_tiled_to_linear_uv_deinterleave_neon( + (unsigned char *)pYUVBuf[1], + (unsigned char *)pYUVBuf[2], + (unsigned char *)outputInfo.CVirAddr, + actualWidth, + actualHeight / 2); + break; + } + } + +#ifdef USE_ANB + if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) { + SEC_OSAL_UnlockANB(pOutputData->dataBuffer); + } +#endif + pH264Dec->hMFCH264Handle.outputIndexTimestamp++; + pH264Dec->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP; + } + if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS) + pOutputData->dataLen = 0; + + if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) || + (pSECComponent->getAllDelayBuffer == OMX_TRUE)) + ret = OMX_ErrorInputDataDecodeYet; + + if (status == MFC_GETOUTBUF_DECODING_ONLY) { + if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) && + ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) { + pInputData->nFlags |= OMX_BUFFERFLAG_EOS; + pSECComponent->getAllDelayBuffer = OMX_TRUE; + ret = OMX_ErrorInputDataDecodeYet; + } else { + ret = OMX_ErrorNone; + } + goto EXIT; + } + +#ifdef FULL_FRAME_SEARCH + if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) && + (pSECComponent->bSaveFlagEOS == OMX_TRUE)) { + pInputData->nFlags |= OMX_BUFFERFLAG_EOS; + pSECComponent->getAllDelayBuffer = OMX_TRUE; + ret = OMX_ErrorInputDataDecodeYet; + } else +#endif + if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) { + pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS)); + pSECComponent->getAllDelayBuffer = OMX_TRUE; + ret = OMX_ErrorInputDataDecodeYet; + } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) { + pSECComponent->getAllDelayBuffer = OMX_FALSE; + ret = OMX_ErrorNone; + } + } else { + pOutputData->timeStamp = pInputData->timeStamp; + pOutputData->nFlags = pInputData->nFlags; + + if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || + (pSECComponent->getAllDelayBuffer == OMX_TRUE) || + (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) { + pOutputData->nFlags |= OMX_BUFFERFLAG_EOS; + pSECComponent->getAllDelayBuffer = OMX_FALSE; + } + pOutputData->dataLen = 0; + + /* ret = OMX_ErrorUndefined; */ + ret = OMX_ErrorNone; + goto EXIT; + } + +EXIT: + FunctionOut(); + + return ret; +} + +/* MFC Decode */ +OMX_ERRORTYPE SEC_MFC_H264Dec_bufferProcess(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX]; + SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX]; + OMX_BOOL endOfFrame = OMX_FALSE; + + FunctionIn(); + + if ((!CHECK_PORT_ENABLED(pSECInputPort)) || (!CHECK_PORT_ENABLED(pSECOutputPort)) || + (!CHECK_PORT_POPULATED(pSECInputPort)) || (!CHECK_PORT_POPULATED(pSECOutputPort))) { + ret = OMX_ErrorNone; + goto EXIT; + } + if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) { + ret = OMX_ErrorNone; + goto EXIT; + } + +#ifdef NONBLOCK_MODE_PROCESS + ret = SEC_MFC_H264_Decode_Nonblock(pOMXComponent, pInputData, pOutputData); +#else + ret = SEC_MFC_H264_Decode_Block(pOMXComponent, pInputData, pOutputData); +#endif + if (ret != OMX_ErrorNone) { + if (ret == OMX_ErrorInputDataDecodeYet) { + pOutputData->usedDataLen = 0; + pOutputData->remainDataLen = pOutputData->dataLen; + } else { + pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent, + pSECComponent->callbackData, + OMX_EventError, ret, 0, NULL); + } + } else { + pInputData->previousDataLen = pInputData->dataLen; + pInputData->usedDataLen += pInputData->dataLen; + pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen; + pInputData->dataLen -= pInputData->usedDataLen; + pInputData->usedDataLen = 0; + + pOutputData->usedDataLen = 0; + pOutputData->remainDataLen = pOutputData->dataLen; + } + +EXIT: + FunctionOut(); + + return ret; +} + +OSCL_EXPORT_REF OMX_ERRORTYPE SEC_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = NULL; + SEC_OMX_BASECOMPONENT *pSECComponent = NULL; + SEC_OMX_BASEPORT *pSECPort = NULL; + SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + OMX_BOOL bFlashPlayerMode = OMX_FALSE; + int i = 0; + + FunctionIn(); + + if ((hComponent == NULL) || (componentName == NULL)) { + ret = OMX_ErrorBadParameter; + SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__); + goto EXIT; + } + if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_H264_DEC, componentName) == 0) { + bFlashPlayerMode = OMX_FALSE; + } else if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_H264_FP_DEC, componentName) == 0) { + bFlashPlayerMode = OMX_TRUE; + } else { + ret = OMX_ErrorBadParameter; + SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__); + goto EXIT; + } + + pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; + ret = SEC_OMX_VideoDecodeComponentInit(pOMXComponent); + if (ret != OMX_ErrorNone) { + SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__); + goto EXIT; + } + pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + pSECComponent->codecType = HW_VIDEO_DEC_CODEC; + + pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE); + if (pSECComponent->componentName == NULL) { + SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent); + ret = OMX_ErrorInsufficientResources; + SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); + goto EXIT; + } + SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE); + + pH264Dec = SEC_OSAL_Malloc(sizeof(SEC_H264DEC_HANDLE)); + if (pH264Dec == NULL) { + SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent); + ret = OMX_ErrorInsufficientResources; + SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); + goto EXIT; + } + SEC_OSAL_Memset(pH264Dec, 0, sizeof(SEC_H264DEC_HANDLE)); + pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle; + pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pH264Dec; + + if (bFlashPlayerMode == OMX_FALSE) + SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_H264_DEC); + else + SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_H264_FP_DEC); + + pH264Dec->hMFCH264Handle.bFlashPlayerMode = bFlashPlayerMode; +#ifdef S3D_SUPPORT + pH264Dec->hMFCH264Handle.bS3DMode = OMX_FALSE; +#endif + + /* Set componentVersion */ + pSECComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER; + pSECComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER; + pSECComponent->componentVersion.s.nRevision = REVISION_NUMBER; + pSECComponent->componentVersion.s.nStep = STEP_NUMBER; + /* Set specVersion */ + pSECComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER; + pSECComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER; + pSECComponent->specVersion.s.nRevision = REVISION_NUMBER; + pSECComponent->specVersion.s.nStep = STEP_NUMBER; + + /* Android CapabilityFlags */ + pSECComponent->capabilityFlags.iIsOMXComponentMultiThreaded = OMX_TRUE; + pSECComponent->capabilityFlags.iOMXComponentSupportsExternalInputBufferAlloc = OMX_TRUE; + pSECComponent->capabilityFlags.iOMXComponentSupportsExternalOutputBufferAlloc = OMX_TRUE; + pSECComponent->capabilityFlags.iOMXComponentSupportsMovableInputBuffers = OMX_FALSE; + pSECComponent->capabilityFlags.iOMXComponentSupportsPartialFrames = OMX_FALSE; + pSECComponent->capabilityFlags.iOMXComponentUsesNALStartCodes = OMX_TRUE; + pSECComponent->capabilityFlags.iOMXComponentCanHandleIncompleteFrames = OMX_TRUE; + pSECComponent->capabilityFlags.iOMXComponentUsesFullAVCFrames = OMX_TRUE; + + /* Input port */ + pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX]; + pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH; + pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT; + pSECPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/ + pSECPort->portDefinition.format.video.nSliceHeight = 0; + pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE; + pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC; + SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE); + SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/avc"); + pSECPort->portDefinition.format.video.pNativeRender = 0; + pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE; + pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused; + pSECPort->portDefinition.bEnabled = OMX_TRUE; + if (bFlashPlayerMode != OMX_FALSE) { + pSECPort->portDefinition.nBufferCountActual = MAX_H264_FP_VIDEO_INPUTBUFFER_NUM; + pSECPort->portDefinition.nBufferCountMin = MAX_H264_FP_VIDEO_INPUTBUFFER_NUM; + } + + /* Output port */ + pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX]; + pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH; + pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT; + pSECPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/ + pSECPort->portDefinition.format.video.nSliceHeight = 0; + pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE; + pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; + SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE); + SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "raw/video"); + pSECPort->portDefinition.format.video.pNativeRender = 0; + pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE; + pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar; + pSECPort->portDefinition.bEnabled = OMX_TRUE; + if (bFlashPlayerMode != OMX_FALSE) { + pSECPort->portDefinition.nBufferCountActual = MAX_H264_FP_VIDEO_OUTPUTBUFFER_NUM; + pSECPort->portDefinition.nBufferCountMin = MAX_H264_FP_VIDEO_OUTPUTBUFFER_NUM; + } + + for(i = 0; i < ALL_PORT_NUM; i++) { + INIT_SET_SIZE_VERSION(&pH264Dec->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE); + pH264Dec->AVCComponent[i].nPortIndex = i; + pH264Dec->AVCComponent[i].eProfile = OMX_VIDEO_AVCProfileBaseline; + pH264Dec->AVCComponent[i].eLevel = OMX_VIDEO_AVCLevel4; + } + + pOMXComponent->GetParameter = &SEC_MFC_H264Dec_GetParameter; + pOMXComponent->SetParameter = &SEC_MFC_H264Dec_SetParameter; + pOMXComponent->GetConfig = &SEC_MFC_H264Dec_GetConfig; + pOMXComponent->SetConfig = &SEC_MFC_H264Dec_SetConfig; + pOMXComponent->GetExtensionIndex = &SEC_MFC_H264Dec_GetExtensionIndex; + pOMXComponent->ComponentRoleEnum = &SEC_MFC_H264Dec_ComponentRoleEnum; + pOMXComponent->ComponentDeInit = &SEC_OMX_ComponentDeinit; + + pSECComponent->sec_mfc_componentInit = &SEC_MFC_H264Dec_Init; + pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_H264Dec_Terminate; + pSECComponent->sec_mfc_bufferProcess = &SEC_MFC_H264Dec_bufferProcess; + pSECComponent->sec_checkInputFrame = &Check_H264_Frame; + + pSECComponent->currentState = OMX_StateLoaded; + + ret = OMX_ErrorNone; + +EXIT: + FunctionOut(); + + return ret; +} + +OMX_ERRORTYPE SEC_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent) +{ + OMX_ERRORTYPE ret = OMX_ErrorNone; + OMX_COMPONENTTYPE *pOMXComponent = NULL; + SEC_OMX_BASECOMPONENT *pSECComponent = NULL; + SEC_H264DEC_HANDLE *pH264Dec = NULL; + + FunctionIn(); + + if (hComponent == NULL) { + ret = OMX_ErrorBadParameter; + goto EXIT; + } + pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; + pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; + + SEC_OSAL_Free(pSECComponent->componentName); + pSECComponent->componentName = NULL; + + pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle; + if (pH264Dec != NULL) { + SEC_OSAL_Free(pH264Dec); + pH264Dec = ((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle = NULL; + } + + ret = SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent); + if (ret != OMX_ErrorNone) { + goto EXIT; + } + + ret = OMX_ErrorNone; + +EXIT: + FunctionOut(); + + return ret; +} |