exynos: reorganized and updated from insignal

Changes needed on exynos4210 devices:

libcsc -> libseccscapi
libswconverter -> remove

TARGET_HAL_PATH := hardware/samsung/exynos4/hal
TARGET_OMX_PATH := hardware/samsung/exynos/multimedia/openmax
$(call inherit-product, hardware/samsung/exynos4210.mk)

Change-Id: Ic59ef95b85ef37b3f38fb36cf6a364a5414685ee

5 files changed, 2220 insertions, 0 deletions

diff --git a/exynos/multimedia/openmax/component/video/dec/vc1/Android.mk b/exynos/multimedia/openmax/component/video/dec/vc1/Android.mk
new file mode 100644
index 0000000..9412233
--- /dev/null
+++ b/exynos/multimedia/openmax/component/video/dec/vc1/Android.mk
@@ -0,0 +1,52 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	SEC_OMX_Wmvdec.c \
+	library_register.c
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libOMX.SEC.WMV.Decoder
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/omx
+
+LOCAL_CFLAGS :=
+
+ifeq ($(BOARD_NONBLOCK_MODE_PROCESS), true)
+LOCAL_CFLAGS += -DNONBLOCK_MODE_PROCESS
+endif
+
+ifeq ($(BOARD_USE_ANB), true)
+LOCAL_CFLAGS += -DUSE_ANB
+ifeq ($(BOARD_USE_CSC_FIMC), true)
+ifeq ($(BOARD_USE_V4L2_ION), false)
+LOCAL_CFLAGS += -DUSE_CSC_FIMC
+endif
+endif
+endif
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libSEC_OMX_Vdec libsecosal libsecbasecomponent \
+	libseccscapi libsecmfcapi
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui \
+	libSEC_OMX_Resourcemanager
+
+ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
+LOCAL_SHARED_LIBRARIES += libhwconverter
+endif
+
+#ifeq ($(BOARD_USE_V4L2_ION),true)
+#LOCAL_SHARED_LIBRARIES += libion
+#endif
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/osal \
+	$(SEC_OMX_TOP)/core \
+	$(SEC_OMX_COMPONENT)/common \
+	$(SEC_OMX_COMPONENT)/video/dec \
+    $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO)
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos/multimedia/openmax/component/video/dec/vc1/SEC_OMX_Wmvdec.c b/exynos/multimedia/openmax/component/video/dec/vc1/SEC_OMX_Wmvdec.c
new file mode 100644
index 0000000..ebc2a0f
--- /dev/null
+++ b/exynos/multimedia/openmax/component/video/dec/vc1/SEC_OMX_Wmvdec.c
@@ -0,0 +1,1960 @@
+/*
+ *
+ * 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_Wmvdec.c
+ * @brief
+ * @author    HyeYeon Chung (hyeon.chung@samsung.com)
+ * @version    1.1.0
+ * @history
+ *   2010.8.16 : Create
+ *   2010.8.20 : Support WMV3 (Vc-1 Simple/Main Profile)
+ *   2010.8.21 : Support WMvC1 (Vc-1 Advanced Profile)
+ */
+
+#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 "SEC_OSAL_Memory.h"
+#include "library_register.h"
+#include "SEC_OMX_Wmvdec.h"
+#include "SsbSipMfcApi.h"
+#include "SEC_OSAL_Event.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_WMV_DEC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+#define WMV_DEC_NUM_OF_EXTRA_BUFFERS 7
+
+//#define FULL_FRAME_SEARCH
+
+/* ASF parser does not send start code on OpenCORE */
+#define WO_START_CODE
+
+static OMX_HANDLETYPE ghMFCHandle = NULL;
+static WMV_FORMAT gWvmFormat = WMV_FORMAT_UNKNOWN;
+
+const OMX_U32 wmv3 = 0x33564d57;
+const OMX_U32 wvc1 = 0x31435657;
+const OMX_U32 wmva = 0x41564d57;
+
+static int Check_Wmv_Frame(OMX_U8 *pInputStream, OMX_U32 buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame)
+{
+    OMX_U32  compressionID;
+    OMX_BOOL bFrameStart;
+    OMX_U32  len, readStream;
+    OMX_U32  startCode;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "buffSize = %d", buffSize);
+
+    len = 0;
+    bFrameStart = OMX_FALSE;
+
+    if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
+        BitmapInfoHhr *pBitmapInfoHeader;
+        pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
+
+        compressionID = pBitmapInfoHeader->BiCompression;
+        if (compressionID == wmv3) {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "WMV_FORMAT_WMV3");
+            gWvmFormat  = WMV_FORMAT_WMV3;
+
+            *pbEndOfFrame = OMX_TRUE;
+            return buffSize;
+        }
+        else if ((compressionID == wvc1) || (compressionID == wmva)) {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "WMV_FORMAT_VC1");
+            gWvmFormat  = WMV_FORMAT_VC1;
+
+#ifdef WO_START_CODE
+/* ASF parser does not send start code on OpenCORE */
+            *pbEndOfFrame = OMX_TRUE;
+            return buffSize;
+#endif
+        }
+    }
+
+    if (gWvmFormat == WMV_FORMAT_WMV3) {
+        *pbEndOfFrame = OMX_TRUE;
+        return buffSize;
+    }
+
+#ifdef WO_START_CODE
+/* ASF parser does not send start code on OpenCORE */
+    if (gWvmFormat == WMV_FORMAT_VC1) {
+        *pbEndOfFrame = OMX_TRUE;
+        return buffSize;
+    }
+#else
+ /* TODO : for comformanc test based on common buffer scheme w/o parser */
+
+    if (bPreviousFrameEOF == OMX_FALSE)
+        bFrameStart = OMX_TRUE;
+
+    startCode = 0xFFFFFFFF;
+    if (bFrameStart == OMX_FALSE) {
+        /* find Frame start code */
+        while(startCode != 0x10D) {
+            readStream = *(pInputStream + len);
+            startCode = (startCode << 8) | readStream;
+            len++;
+            if (len > buffSize)
+                goto EXIT;
+        }
+    }
+
+    /* find next Frame start code */
+    startCode = 0xFFFFFFFF;
+    while ((startCode != 0x10D)) {
+        readStream = *(pInputStream + len);
+        startCode = (startCode << 8) | readStream;
+        len++;
+        if (len > buffSize)
+            goto EXIT;
+    }
+
+    *pbEndOfFrame = OMX_TRUE;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "1. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
+
+    return len - 4;
+#endif
+
+EXIT :
+    *pbEndOfFrame = OMX_FALSE;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "2. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 1, buffSize);
+
+    return --len;
+}
+
+OMX_BOOL Check_Stream_PrefixCode(OMX_U8 *pInputStream, OMX_U32 streamSize, WMV_FORMAT wmvFormat)
+{
+    switch (wmvFormat) {
+    case WMV_FORMAT_WMV3:
+        if (streamSize > 0)
+            return OMX_TRUE;
+        else
+            return OMX_FALSE;
+        break;
+    case WMV_FORMAT_VC1:
+
+#ifdef WO_START_CODE
+        /* ASF parser does not send start code on OpenCORE */
+        if (streamSize > 3)
+            return OMX_TRUE;
+        else
+            return OMX_FALSE;
+        break;
+#else
+        /* TODO : for comformanc test based on common buffer scheme w/o parser */
+        if (streamSize < 3) {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: streamSize is too small (%d)", __FUNCTION__, streamSize);
+            return OMX_FALSE;
+        } else if ((pInputStream[0] == 0x00) &&
+                   (pInputStream[1] == 0x00) &&
+                   (pInputStream[2] == 0x01)) {
+            return OMX_TRUE;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: Cannot find prefix", __FUNCTION__);
+            return OMX_FALSE;
+        }
+#endif
+        break;
+
+    default:
+        SEC_OSAL_Log(SEC_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
+        return OMX_FALSE;
+        break;
+    }
+}
+
+OMX_BOOL Make_Stream_MetaData(OMX_U8 *pInputStream, OMX_U32 *pStreamSize, WMV_FORMAT wmvFormat)
+{
+    OMX_U32 width, height;
+    OMX_U8  *pCurrBuf = pInputStream;
+    OMX_U32 currPos = 0;
+
+    FunctionIn();
+
+    /* Sequence Layer Data Structure */
+    OMX_U8 const_C5[4] = {0x00, 0x00, 0x00, 0xc5};
+    OMX_U8 const_04[4] = {0x04, 0x00, 0x00, 0x00};
+    OMX_U8 const_0C[4] = {0x0C, 0x00, 0x00, 0x00};
+    OMX_U8 struct_B_1[4] = {0xB3, 0x19, 0x00, 0x00};
+    OMX_U8 struct_B_2[4] = {0x44, 0x62, 0x05, 0x00};
+    OMX_U8 struct_B_3[4] = {0x0F, 0x00, 0x00, 0x00};
+    OMX_U8 struct_C[4] = {0x30, 0x00, 0x00, 0x00};
+
+    switch (wmvFormat) {
+    case WMV_FORMAT_WMV3:
+        if (*pStreamSize >= BITMAPINFOHEADER_SIZE) {
+            BitmapInfoHhr *pBitmapInfoHeader;
+            pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
+
+            width = pBitmapInfoHeader->BiWidth;
+            height = pBitmapInfoHeader->BiHeight;
+            if (*pStreamSize > BITMAPINFOHEADER_SIZE)
+                SEC_OSAL_Memcpy(struct_C, pInputStream+BITMAPINFOHEADER_SIZE, 4);
+
+            SEC_OSAL_Memcpy(pCurrBuf + currPos, const_C5, 4);
+            currPos +=4;
+
+            SEC_OSAL_Memcpy(pCurrBuf + currPos, const_04, 4);
+            currPos +=4;
+
+            SEC_OSAL_Memcpy(pCurrBuf + currPos, struct_C, 4);
+            currPos +=4;
+
+            /* struct_A : VERT_SIZE */
+            pCurrBuf[currPos] =  height & 0xFF;
+            pCurrBuf[currPos+1] = (height>>8) & 0xFF;
+            pCurrBuf[currPos+2] = (height>>16) & 0xFF;
+            pCurrBuf[currPos+3] = (height>>24) & 0xFF;
+            currPos +=4;
+
+            /* struct_A : HORIZ_SIZE */
+            pCurrBuf[currPos] =  width & 0xFF;
+            pCurrBuf[currPos+1] = (width>>8) & 0xFF;
+            pCurrBuf[currPos+2] = (width>>16) & 0xFF;
+            pCurrBuf[currPos+3] = (width>>24) & 0xFF;
+            currPos +=4;
+
+            SEC_OSAL_Memcpy(pCurrBuf + currPos,const_0C, 4);
+            currPos +=4;
+
+            SEC_OSAL_Memcpy(pCurrBuf + currPos, struct_B_1, 4);
+            currPos +=4;
+
+            SEC_OSAL_Memcpy(pCurrBuf + currPos, struct_B_2, 4);
+            currPos +=4;
+
+            SEC_OSAL_Memcpy(pCurrBuf + currPos, struct_B_3, 4);
+            currPos +=4;
+
+            *pStreamSize = currPos;
+            return OMX_TRUE;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
+            return OMX_FALSE;
+        }
+        break;
+    case WMV_FORMAT_VC1:
+        if (*pStreamSize >= BITMAPINFOHEADER_ASFBINDING_SIZE) {
+            SEC_OSAL_Memcpy(pCurrBuf, pInputStream + BITMAPINFOHEADER_ASFBINDING_SIZE, *pStreamSize - BITMAPINFOHEADER_ASFBINDING_SIZE);
+            *pStreamSize -= BITMAPINFOHEADER_ASFBINDING_SIZE;
+            return OMX_TRUE;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
+            return OMX_FALSE;
+        }
+        break;
+    default:
+        SEC_OSAL_Log(SEC_LOG_WARNING, "%s: It is not necessary to make bitstream metadata for wmvFormat (%d)", __FUNCTION__, wmvFormat);
+        return OMX_FALSE;
+        break;
+    }
+}
+
+#ifdef WO_START_CODE
+OMX_BOOL Make_Stream_StartCode(OMX_U8 *pInputStream, OMX_U32 streamSize, WMV_FORMAT wmvFormat)
+{
+    OMX_U8  frameStartCode[4] = {0x00, 0x00, 0x01, 0x0d};
+    OMX_U32 i;
+
+    switch (wmvFormat) {
+    case WMV_FORMAT_WMV3:
+        return OMX_TRUE;
+        break;
+
+    case WMV_FORMAT_VC1:
+        /* Should find better way to shift data */
+        SEC_OSAL_Memmove(pInputStream+4, pInputStream, streamSize);
+        SEC_OSAL_Memcpy(pInputStream, frameStartCode, 4);
+
+        return OMX_TRUE;
+        break;
+
+    default:
+        SEC_OSAL_Log(SEC_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
+        return OMX_FALSE;
+        break;
+    }
+}
+#endif
+
+OMX_ERRORTYPE SEC_MFC_WmvDec_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_IndexParamVideoWmv:
+    {
+        OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = NULL;
+        SEC_WMV_HANDLE          *pWmvDec = NULL;
+        ret = SEC_OMX_Check_SizeVersion(pDstWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
+            ret = OMX_ErrorBadPortIndex;
+        }
+
+        pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+        pSrcWmvParam = &pWmvDec->WmvComponent[pDstWmvParam->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
+    }
+        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_WMV_DEC_ROLE);
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
+        SEC_WMV_HANDLE                      *pWmvDec = 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;
+        }
+
+        pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+        pSrcErrorCorrectionType = &pWmvDec->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_WmvDec_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_IndexParamVideoWmv:
+    {
+        OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = NULL;
+        OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
+        SEC_WMV_HANDLE          *pWmvDec = NULL;
+        ret = SEC_OMX_Check_SizeVersion(pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+        pDstWmvParam = &pWmvDec->WmvComponent[pSrcWmvParam->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
+    }
+        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_WMV_DEC_ROLE)) {
+            pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
+        } 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_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
+        SEC_WMV_HANDLE                      *pWmvDec = 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;
+        }
+
+        pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+        pDstErrorCorrectionType = &pWmvDec->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_WmvDec_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) {
+    default:
+        ret = SEC_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_WmvDec_SetConfig(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nIndex,
+    OMX_IN OMX_PTR        pComponentConfigStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL || pComponentConfigStructure == 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) {
+    default:
+        ret = SEC_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_WmvDec_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_WMV_HANDLE *pWmvDec = (SEC_WMV_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_WmvDec_ComponentRoleEnum(
+    OMX_IN  OMX_HANDLETYPE hComponent,
+    OMX_OUT OMX_U8        *cRole,
+    OMX_IN  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_WMV_DEC_ROLE);
+        ret = OMX_ErrorNone;
+    } else {
+        ret = OMX_ErrorUnsupportedIndex;
+    }
+
+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_WMV_HANDLE        *pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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) {
+            pWmvDec->hMFCWmvHandle.returnCodec = SsbSipMfcDecExe(pWmvDec->hMFCWmvHandle.hMFCHandle, pVideoDec->NBDecThread.oneFrameSize);
+            SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameEnd);
+        }
+    }
+
+EXIT:
+    SEC_OSAL_ThreadExit(NULL);
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Init */
+OMX_ERRORTYPE SEC_MFC_WmvDec_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_WMV_HANDLE        *pWmvDec = NULL;
+    OMX_HANDLETYPE         hMFCHandle = NULL;
+    OMX_PTR                pStreamBuffer = NULL;
+    OMX_PTR                pStreamPhyBuffer = NULL;
+
+    FunctionIn();
+
+    pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+    pWmvDec->hMFCWmvHandle.bConfiguredMFC = OMX_FALSE;
+    pSECComponent->bUseFlagEOF = OMX_FALSE;
+    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+
+    /* MFC(Multi Format 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;
+    }
+    ghMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle = hMFCHandle;
+
+    /* 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)) {
+        pWmvDec->hMFCWmvHandle.returnCodec = MFC_RET_OK;
+    }
+#endif
+
+    pWmvDec->hMFCWmvHandle.pMFCStreamBuffer    = pVideoDec->MFCDecInputBuffer[0].VirAddr;
+    pWmvDec->hMFCWmvHandle.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);
+    pWmvDec->hMFCWmvHandle.indexTimestamp = 0;
+    pWmvDec->hMFCWmvHandle.outputIndexTimestamp = 0;
+    pSECComponent->getAllDelayBuffer = OMX_FALSE;
+
+#ifdef USE_CSC_FIMC
+    pWmvDec->hFIMCHandle = csc_fimc_open();
+#endif
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Terminate */
+OMX_ERRORTYPE SEC_MFC_WmvDec_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_WMV_HANDLE        *pWmvDec = NULL;
+    OMX_HANDLETYPE         hMFCHandle = NULL;
+
+    FunctionIn();
+
+    pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+    hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
+
+    pWmvDec->hMFCWmvHandle.pMFCStreamBuffer    = NULL;
+    pWmvDec->hMFCWmvHandle.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);
+        pWmvDec->hMFCWmvHandle.hMFCHandle = NULL;
+    }
+
+#ifdef USE_CSC_FIMC
+    if (pWmvDec->hFIMCHandle != NULL) {
+        csc_fimc_close(pWmvDec->hFIMCHandle);
+        pWmvDec->hFIMCHandle = NULL;
+    }
+#endif
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_Wmv_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_OMX_BASEPORT           *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT           *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    SEC_WMV_HANDLE             *pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+    OMX_U32                     oneFrameSize = pInputData->dataLen;
+    SSBSIP_MFC_DEC_OUTPUT_INFO  outputInfo;
+    OMX_S32                     configValue = 0;
+    OMX_BOOL                    bMetaData = OMX_FALSE;
+    OMX_BOOL                    bStartCode = OMX_FALSE;
+    int                         bufWidth = 0;
+    int                         bufHeight = 0;
+    OMX_U32                     FrameBufferYSize = 0;
+    OMX_U32                     FrameBufferUVSize = 0;
+    OMX_BOOL                    outputDataValid = OMX_FALSE;
+
+    FunctionIn();
+
+    if (pWmvDec->hMFCWmvHandle.bConfiguredMFC == OMX_FALSE) {
+        SSBSIP_MFC_CODEC_TYPE MFCCodecType;
+
+        if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = pInputData->nFlags;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+
+        if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3)
+            MFCCodecType = VC1RCV_DEC;
+        else if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_VC1)
+            MFCCodecType = VC1_DEC;
+        else
+            MFCCodecType = UNKNOWN_TYPE;
+
+        SEC_OSAL_Log(SEC_LOG_TRACE, "codec type = %d", MFCCodecType);
+
+        if (pVideoDec->bThumbnailMode == OMX_TRUE) {
+            configValue = 0;    // the number that you want to delay
+            SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &configValue);
+        } else {
+            configValue = WMV_DEC_NUM_OF_EXTRA_BUFFERS;
+            SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &configValue);
+        }
+
+        bMetaData = Make_Stream_MetaData(pInputData->dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
+        if (bMetaData == OMX_FALSE) {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "Fail to Make Stream MetaData");
+            ret = OMX_ErrorMFCInit;
+            goto EXIT;
+        }
+
+        SsbSipMfcDecSetInBuf(pWmvDec->hMFCWmvHandle.hMFCHandle,
+                             pWmvDec->hMFCWmvHandle.pMFCStreamPhyBuffer,
+                             pWmvDec->hMFCWmvHandle.pMFCStreamBuffer,
+                             pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
+
+        pWmvDec->hMFCWmvHandle.returnCodec = SsbSipMfcDecInit(pWmvDec->hMFCWmvHandle.hMFCHandle, MFCCodecType, oneFrameSize);
+        if (pWmvDec->hMFCWmvHandle.returnCodec == MFC_RET_OK) {
+            SSBSIP_MFC_IMG_RESOLUTION imgResol;
+
+            if (SsbSipMfcDecGetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol) != MFC_RET_OK) {
+                ret = OMX_ErrorMFCInit;
+                SEC_OSAL_Log(SEC_LOG_ERROR, "SsbSipMfcDecGetConfig failed");
+                goto EXIT;
+            }
+
+            SEC_OSAL_Log(SEC_LOG_TRACE, "## nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
+                pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
+                pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->portDefinition.format.video.nSliceHeight);
+
+            /** Update Frame Size **/
+            if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
+               (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
+                /* 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_OSAL_Log(SEC_LOG_TRACE, "nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
+                    pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
+                    pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->portDefinition.format.video.nSliceHeight);
+
+                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);
+            }
+
+            pWmvDec->hMFCWmvHandle.bConfiguredMFC = OMX_TRUE;
+
+            if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3) {
+                pOutputData->timeStamp = pInputData->timeStamp;
+                pOutputData->nFlags = pInputData->nFlags;
+                ret = OMX_ErrorNone;
+            } else {
+
+#ifdef WO_START_CODE
+/* ASF parser does not send start code on OpenCORE */
+                pOutputData->timeStamp = pInputData->timeStamp;
+                pOutputData->nFlags = pInputData->nFlags;
+                ret = OMX_ErrorNone;
+#else
+/* TODO : for comformanc test based on common buffer scheme w/o parser */
+                pOutputData->dataLen = 0;
+                ret = OMX_ErrorInputDataDecodeYet;
+#endif
+            }
+            goto EXIT;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "SsbSipMfcDecInit failed");
+            ret = OMX_ErrorMFCInit;    /* OMX_ErrorUndefined */
+            goto EXIT;
+        }
+    }
+
+#ifndef FULL_FRAME_SEARCH
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE))
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+#endif
+
+    pSECComponent->timeStamp[pWmvDec->hMFCWmvHandle.indexTimestamp] = pInputData->timeStamp;
+    pSECComponent->nFlags[pWmvDec->hMFCWmvHandle.indexTimestamp] = pInputData->nFlags;
+
+    if ((pWmvDec->hMFCWmvHandle.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(pWmvDec->hMFCWmvHandle.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 ((SsbSipMfcDecGetConfig(pWmvDec->hMFCWmvHandle.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) {
+                    pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
+                    pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
+                    pWmvDec->hMFCWmvHandle.outputIndexTimestamp = indexTimestamp;
+                } else {
+                    pOutputData->timeStamp = pSECComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
+                    pOutputData->nFlags = pSECComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
+                }
+#else
+                pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
+                pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
+#endif
+            }
+
+            if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
+                (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
+                outputDataValid = OMX_TRUE;
+                pWmvDec->hMFCWmvHandle.outputIndexTimestamp++;
+                pWmvDec->hMFCWmvHandle.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;
+    }
+
+#ifdef WO_START_CODE
+    if (pInputData->allocSize < oneFrameSize+4) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "Can't attach startcode due to lack of buffer space");
+        ret = OMX_ErrorMFCInit;
+        goto EXIT;
+    }
+
+    bStartCode = Make_Stream_StartCode(pInputData->dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
+    if (bStartCode == OMX_FALSE) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "Fail to Make Stream Start Code");
+        ret = OMX_ErrorMFCInit;
+        goto EXIT;
+    }
+#endif
+
+    if (ret == OMX_ErrorInputDataDecodeYet) {
+        pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
+        pVideoDec->indexInputBuffer++;
+        pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
+        pWmvDec->hMFCWmvHandle.pMFCStreamBuffer    = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
+        pWmvDec->hMFCWmvHandle.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;
+    }
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SsbSipMfcDecExe oneFrameSize = %d", oneFrameSize);
+
+    if ((Check_Stream_PrefixCode(pInputData->dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat) == OMX_TRUE) &&
+        ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
+        if ((ret != OMX_ErrorInputDataDecodeYet) || (pSECComponent->getAllDelayBuffer == OMX_TRUE)) {
+            SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pWmvDec->hMFCWmvHandle.indexTimestamp));
+            pWmvDec->hMFCWmvHandle.indexTimestamp++;
+            pWmvDec->hMFCWmvHandle.indexTimestamp %= MAX_TIMESTAMP;
+        }
+
+        SsbSipMfcDecSetInBuf(pWmvDec->hMFCWmvHandle.hMFCHandle,
+                             pWmvDec->hMFCWmvHandle.pMFCStreamPhyBuffer,
+                             pWmvDec->hMFCWmvHandle.pMFCStreamBuffer,
+                             pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
+
+        pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
+#ifdef WO_START_CODE
+        pVideoDec->NBDecThread.oneFrameSize = oneFrameSize + 4; /* Frame Start Code */
+#else
+        pVideoDec->NBDecThread.oneFrameSize = oneFrameSize;
+#endif
+        /* mfc decode start */
+        SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
+        pVideoDec->NBDecThread.bDecoderRun = OMX_TRUE;
+        pWmvDec->hMFCWmvHandle.returnCodec = MFC_RET_OK;
+
+        SEC_OSAL_SleepMillisec(0);
+
+        pVideoDec->indexInputBuffer++;
+        pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
+        pWmvDec->hMFCWmvHandle.pMFCStreamBuffer    = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
+        pWmvDec->hMFCWmvHandle.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) {
+        SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+        SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+        void *pOutputBuf = (void *)pOutputData->dataBuffer;
+        void *pYUVBuf[3];
+
+        int frameSize = bufWidth * bufHeight;
+        int width = outputInfo.img_width;
+        int height = outputInfo.img_height;
+        int imageSize = outputInfo.img_width * outputInfo.img_height;
+
+        pYUVBuf[0]  = (unsigned char *)pOutputBuf;
+        pYUVBuf[1]  = (unsigned char *)pOutputBuf + imageSize;
+        pYUVBuf[2]  = (unsigned char *)pOutputBuf + imageSize + imageSize / 4;
+        pOutputData->dataLen = (imageSize * 3) / 2;
+
+#ifdef USE_ANB
+        if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
+            OMX_U32 stride;
+            SEC_OSAL_LockANB(pOutputData->dataBuffer, width, height, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
+            width = 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 = (outputInfo.img_width * outputInfo.img_height * 3) / 2;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 out for ThumbnailMode");
+            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) && (pWmvDec->hFIMCHandle != NULL)) {
+                    void *pPhys[3];
+                    SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pPhys);
+                    pYUVBuf[0] = outputInfo.YPhyAddr;
+                    pYUVBuf[1] = outputInfo.CPhyAddr;
+                    csc_fimc_convert_nv12t(pWmvDec->hFIMCHandle, pPhys,
+                                        pYUVBuf, width, height,
+                                        OMX_SEC_COLOR_FormatANBYUV420SemiPlanar);
+                    break;
+                }
+#endif
+                csc_tiled_to_linear_y_neon(
+                    (unsigned char *)pYUVBuf[0],
+                    (unsigned char *)outputInfo.YVirAddr,
+                    width,
+                    height);
+                csc_tiled_to_linear_uv_neon(
+                    (unsigned char *)pYUVBuf[1],
+                    (unsigned char *)outputInfo.CVirAddr,
+                    width,
+                    height / 2);
+                break;
+            case OMX_COLOR_FormatYUV420Planar:
+            default:
+#ifdef USE_CSC_FIMC
+                if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (pWmvDec->hFIMCHandle != NULL)) {
+                    void *pPhys[3];
+                    SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pPhys);
+                    pYUVBuf[0] = outputInfo.YPhyAddr;
+                    pYUVBuf[1] = outputInfo.CPhyAddr;
+                    csc_fimc_convert_nv12t(pWmvDec->hFIMCHandle, pPhys,
+                                        pYUVBuf, width, height,
+                                        OMX_COLOR_FormatYUV420Planar);
+                    break;
+                }
+#endif
+                csc_tiled_to_linear_y_neon(
+                    (unsigned char *)pYUVBuf[0],
+                    (unsigned char *)outputInfo.YVirAddr,
+                    width,
+                    height);
+                csc_tiled_to_linear_uv_deinterleave_neon(
+                    (unsigned char *)pYUVBuf[1],
+                    (unsigned char *)pYUVBuf[2],
+                    (unsigned char *)outputInfo.CVirAddr,
+                    width,
+                    height / 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_Wmv_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_WMV_HANDLE             *pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+    OMX_U32                     oneFrameSize = pInputData->dataLen;
+    SSBSIP_MFC_DEC_OUTPUT_INFO  outputInfo;
+    OMX_S32                     configValue = 0;
+    OMX_S32                     returnCodec = 0;
+    OMX_BOOL                    bMetaData = OMX_FALSE;
+    OMX_BOOL                    bStartCode = OMX_FALSE;
+    int                         bufWidth = 0;
+    int                         bufHeight = 0;
+    OMX_U32                     FrameBufferYSize;
+    OMX_U32                     FrameBufferUVSize;
+
+    FunctionIn();
+
+    if (pWmvDec->hMFCWmvHandle.bConfiguredMFC == OMX_FALSE) {
+        SSBSIP_MFC_CODEC_TYPE MFCCodecType;
+
+        if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = pInputData->nFlags;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+
+        if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3)
+            MFCCodecType = VC1RCV_DEC;
+        else if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_VC1)
+            MFCCodecType = VC1_DEC;
+        else
+            MFCCodecType = UNKNOWN_TYPE;
+
+        SEC_OSAL_Log(SEC_LOG_TRACE, "codec type = %d", MFCCodecType);
+
+        if (pVideoDec->bThumbnailMode == OMX_TRUE) {
+            configValue = 0;    // the number that you want to delay
+            SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &configValue);
+        } else {
+            configValue = WMV_DEC_NUM_OF_EXTRA_BUFFERS;
+            SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &configValue);
+        }
+
+        bMetaData = Make_Stream_MetaData(pInputData->dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
+        if (bMetaData == OMX_FALSE) {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "Fail to Make Stream MetaData");
+            ret = OMX_ErrorMFCInit;
+            goto EXIT;
+        }
+
+        returnCodec = SsbSipMfcDecInit(pWmvDec->hMFCWmvHandle.hMFCHandle, MFCCodecType, oneFrameSize);
+        if (returnCodec == MFC_RET_OK) {
+            SSBSIP_MFC_IMG_RESOLUTION imgResol;
+
+            if (SsbSipMfcDecGetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol) != MFC_RET_OK) {
+                ret = OMX_ErrorMFCInit;
+                SEC_OSAL_Log(SEC_LOG_ERROR, "SsbSipMfcDecGetConfig failed");
+                goto EXIT;
+            }
+
+            SEC_OSAL_Log(SEC_LOG_TRACE, "## nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
+                pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
+                pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->portDefinition.format.video.nSliceHeight);
+
+            /** Update Frame Size **/
+            if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
+               (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
+                /* 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_OSAL_Log(SEC_LOG_TRACE, "nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
+                    pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
+                    pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->portDefinition.format.video.nSliceHeight);
+
+                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);
+            }
+
+            pWmvDec->hMFCWmvHandle.bConfiguredMFC = OMX_TRUE;
+
+            if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3) {
+                pOutputData->timeStamp = pInputData->timeStamp;
+                pOutputData->nFlags = pInputData->nFlags;
+                ret = OMX_ErrorNone;
+            } else {
+
+#ifdef WO_START_CODE
+/* ASF parser does not send start code on OpenCORE */
+                pOutputData->timeStamp = pInputData->timeStamp;
+                pOutputData->nFlags = pInputData->nFlags;
+                ret = OMX_ErrorNone;
+#else
+/* TODO : for comformanc test based on common buffer scheme w/o parser */
+                pOutputData->dataLen = 0;
+                ret = OMX_ErrorInputDataDecodeYet;
+#endif
+            }
+            goto EXIT;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "SsbSipMfcDecInit failed");
+            ret = OMX_ErrorMFCInit;    /* OMX_ErrorUndefined */
+            goto EXIT;
+        }
+    }
+
+#ifndef FULL_FRAME_SEARCH
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE))
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+#endif
+
+#ifdef WO_START_CODE
+    if (pInputData->allocSize < oneFrameSize+4) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "Can't attach startcode due to lack of buffer space");
+        ret = OMX_ErrorMFCInit;
+        goto EXIT;
+    }
+
+    bStartCode = Make_Stream_StartCode(pInputData->dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
+    if (bStartCode == OMX_FALSE) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "Fail to Make Stream Start Code");
+        ret = OMX_ErrorMFCInit;
+        goto EXIT;
+    }
+#endif
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SsbSipMfcDecExe oneFrameSize = %d", oneFrameSize);
+
+    if (Check_Stream_PrefixCode(pInputData->dataBuffer, pInputData->dataLen, pWmvDec->hMFCWmvHandle.wmvFormat) == OMX_TRUE) {
+        pSECComponent->timeStamp[pWmvDec->hMFCWmvHandle.indexTimestamp] = pInputData->timeStamp;
+        pSECComponent->nFlags[pWmvDec->hMFCWmvHandle.indexTimestamp] = pInputData->nFlags;
+        SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pWmvDec->hMFCWmvHandle.indexTimestamp));
+
+#ifdef WO_START_CODE
+        returnCodec = SsbSipMfcDecExe(pWmvDec->hMFCWmvHandle.hMFCHandle, oneFrameSize+4); /* Frame Start Code */
+#else
+        returnCodec = SsbSipMfcDecExe(pWmvDec->hMFCWmvHandle.hMFCHandle, oneFrameSize);
+#endif
+    } 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(pWmvDec->hMFCWmvHandle.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) {
+            pWmvDec->hMFCWmvHandle.indexTimestamp++;
+            pWmvDec->hMFCWmvHandle.indexTimestamp %= MAX_TIMESTAMP;
+        }
+
+        if (SsbSipMfcDecGetConfig(pWmvDec->hMFCWmvHandle.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) {
+                pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
+                pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
+                pWmvDec->hMFCWmvHandle.outputIndexTimestamp = indexTimestamp;
+            } else {
+                pOutputData->timeStamp = pSECComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
+                pOutputData->nFlags = pSECComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
+            }
+#else
+            pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
+            pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
+#endif
+        }
+
+        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 width = outputInfo.img_width;
+            int height = outputInfo.img_height;
+            int imageSize = outputInfo.img_width * outputInfo.img_height;
+
+            pYUVBuf[0]  = (unsigned char *)pOutputBuf;
+            pYUVBuf[1]  = (unsigned char *)pOutputBuf + imageSize;
+            pYUVBuf[2]  = (unsigned char *)pOutputBuf + imageSize + imageSize / 4;
+            pOutputData->dataLen = (imageSize * 3) / 2;
+
+#ifdef USE_ANB
+            if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
+                OMX_U32 stride;
+                SEC_OSAL_LockANB(pOutputData->dataBuffer, width, height, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
+                width = stride;
+                pOutputData->dataLen = sizeof(void *);
+            }
+#endif
+            if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
+                (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
+                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 = (outputInfo.img_width * outputInfo.img_height * 3) / 2;
+            } else {
+                SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 out for ThumbnailMode");
+                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) && (pWmvDec->hFIMCHandle != NULL)) {
+                        void *pPhys[3];
+                        SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pPhys);
+                        pYUVBuf[0] = outputInfo.YPhyAddr;
+                        pYUVBuf[1] = outputInfo.CPhyAddr;
+                        csc_fimc_convert_nv12t(pWmvDec->hFIMCHandle, pPhys,
+                                            pYUVBuf, width, height,
+                                            OMX_SEC_COLOR_FormatANBYUV420SemiPlanar);
+                        break;
+                    }
+#endif
+                    csc_tiled_to_linear_y_neon(
+                        (unsigned char *)pYUVBuf[0],
+                        (unsigned char *)outputInfo.YVirAddr,
+                        width,
+                        height);
+                    csc_tiled_to_linear_uv_neon(
+                        (unsigned char *)pYUVBuf[1],
+                        (unsigned char *)outputInfo.CVirAddr,
+                        width,
+                        height / 2);
+                    break;
+                case OMX_COLOR_FormatYUV420Planar:
+                default:
+#ifdef USE_CSC_FIMC
+                    if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (pWmvDec->hFIMCHandle != NULL)) {
+                        void *pPhys[3];
+                        SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pPhys);
+                        pYUVBuf[0] = outputInfo.YPhyAddr;
+                        pYUVBuf[1] = outputInfo.CPhyAddr;
+                        csc_fimc_convert_nv12t(pWmvDec->hFIMCHandle, pPhys,
+                                            pYUVBuf, width, height,
+                                            OMX_COLOR_FormatYUV420Planar);
+                        break;
+                    }
+#endif
+                    csc_tiled_to_linear_y_neon(
+                        (unsigned char *)pYUVBuf[0],
+                        (unsigned char *)outputInfo.YVirAddr,
+                        width,
+                        height);
+                    csc_tiled_to_linear_uv_deinterleave_neon(
+                        (unsigned char *)pYUVBuf[1],
+                        (unsigned char *)pYUVBuf[2],
+                        (unsigned char *)outputInfo.CVirAddr,
+                        width,
+                        height / 2);
+                    break;
+                }
+            }
+
+#ifdef USE_ANB
+            if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
+                SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
+            }
+#endif
+            pWmvDec->hMFCWmvHandle.outputIndexTimestamp++;
+            pWmvDec->hMFCWmvHandle.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_WmvDec_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_WMV_HANDLE        *pWmvDec = (SEC_WMV_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              bCheckPrefix = OMX_FALSE;
+
+    FunctionIn();
+
+    if ((!CHECK_PORT_ENABLED(pSECInputPort)) || (!CHECK_PORT_ENABLED(pSECOutputPort)) ||
+        (!CHECK_PORT_POPULATED(pSECInputPort)) || (!CHECK_PORT_POPULATED(pSECOutputPort))) {
+        goto EXIT;
+    }
+    if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
+        goto EXIT;
+    }
+
+    pWmvDec->hMFCWmvHandle.wmvFormat = gWvmFormat;
+
+#ifdef NONBLOCK_MODE_PROCESS
+    ret = SEC_MFC_Wmv_Decode_Nonblock(pOMXComponent, pInputData, pOutputData);
+#else
+    ret = SEC_MFC_Wmv_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_WMV_HANDLE        *pWmvDec = NULL;
+    OMX_S32               wmvFormat = WMV_FORMAT_UNKNOWN;
+    int i = 0;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (componentName == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_ComponentInit: parameters are null, ret:%X", ret);
+        goto EXIT;
+    }
+    if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_WMV_DEC, componentName) != 0) {
+        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, "SEC_OMX_ComponentInit: SEC_OMX_VideoDecodeComponentInit error, ret: %X", ret);
+        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, "SEC_OMX_ComponentInit: componentName alloc error, ret: %X", ret);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
+
+    pWmvDec = SEC_OSAL_Malloc(sizeof(SEC_WMV_HANDLE));
+    if (pWmvDec == NULL) {
+        SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_ComponentInit: SEC_WMV_HANDLE alloc error, ret: %X", ret);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pWmvDec, 0, sizeof(SEC_WMV_HANDLE));
+    pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
+    pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pWmvDec;
+    pWmvDec->hMFCWmvHandle.wmvFormat = wmvFormat;
+
+    SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_WMV_DEC);
+
+    /* 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;
+    pSECPort->portDefinition.format.video.nSliceHeight = 0;
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
+
+    pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
+    SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
+    SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/wmv");
+
+    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;
+
+    /* 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;
+    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;
+
+    for(i = 0; i < ALL_PORT_NUM; i++) {
+        INIT_SET_SIZE_VERSION(&pWmvDec->WmvComponent[i], OMX_VIDEO_PARAM_WMVTYPE);
+        pWmvDec->WmvComponent[i].nPortIndex = i;
+        pWmvDec->WmvComponent[i].eFormat    = OMX_VIDEO_WMVFormat9;
+    }
+
+    pOMXComponent->GetParameter      = &SEC_MFC_WmvDec_GetParameter;
+    pOMXComponent->SetParameter      = &SEC_MFC_WmvDec_SetParameter;
+    pOMXComponent->GetConfig         = &SEC_MFC_WmvDec_GetConfig;
+    pOMXComponent->SetConfig         = &SEC_MFC_WmvDec_SetConfig;
+    pOMXComponent->GetExtensionIndex = &SEC_MFC_WmvDec_GetExtensionIndex;
+    pOMXComponent->ComponentRoleEnum = &SEC_MFC_WmvDec_ComponentRoleEnum;
+    pOMXComponent->ComponentDeInit   = &SEC_OMX_ComponentDeinit;
+
+    pSECComponent->sec_mfc_componentInit      = &SEC_MFC_WmvDec_Init;
+    pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_WmvDec_Terminate;
+    pSECComponent->sec_mfc_bufferProcess      = &SEC_MFC_WmvDec_bufferProcess;
+    pSECComponent->sec_checkInputFrame = &Check_Wmv_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_WMV_HANDLE        *pWmvDec = 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;
+
+    pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
+    if (pWmvDec != NULL) {
+        SEC_OSAL_Free(pWmvDec);
+        pWmvDec = ((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;
+}
diff --git a/exynos/multimedia/openmax/component/video/dec/vc1/SEC_OMX_Wmvdec.h b/exynos/multimedia/openmax/component/video/dec/vc1/SEC_OMX_Wmvdec.h
new file mode 100644
index 0000000..c68b644
--- /dev/null
+++ b/exynos/multimedia/openmax/component/video/dec/vc1/SEC_OMX_Wmvdec.h
@@ -0,0 +1,99 @@
+/*
+ *
+ * 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_Wmvdec.h
+ * @brief
+ * @author    HyeYeon Chung (hyeon.chung@samsung.com)
+ * @version    1.1.0
+ * @history
+ *   2010.8.20 : Create
+ */
+
+#ifndef SEC_OMX_WMV_DEC_COMPONENT
+#define SEC_OMX_WMV_DEC_COMPONENT
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Component.h"
+
+#define BITMAPINFOHEADER_SIZE               40
+#define BITMAPINFOHEADER_ASFBINDING_SIZE    41
+#define COMPRESSION_POS                     16
+
+typedef enum WMV_FORMAT {
+    WMV_FORMAT_VC1,
+    WMV_FORMAT_WMV3,
+    WMV_FORMAT_UNKNOWN
+} WMV_FORMAT;
+
+/*
+ * This structure is the same as BitmapInfoHhr struct in pv_avifile_typedefs.h file
+ */
+typedef struct _BitmapInfoHhr
+{
+    OMX_U32    BiSize;
+    OMX_U32    BiWidth;
+    OMX_U32    BiHeight;
+    OMX_U16    BiPlanes;
+    OMX_U16    BiBitCount;
+    OMX_U32    BiCompression;
+    OMX_U32    BiSizeImage;
+    OMX_U32    BiXPelsPerMeter;
+    OMX_U32    BiYPelsPerMeter;
+    OMX_U32    BiClrUsed;
+    OMX_U32    BiClrImportant;
+} BitmapInfoHhr;
+
+typedef struct _SEC_MFC_WMV_HANDLE
+{
+    OMX_HANDLETYPE hMFCHandle;
+    OMX_PTR        pMFCStreamBuffer;
+    OMX_PTR        pMFCStreamPhyBuffer;
+    OMX_U32        indexTimestamp;
+    OMX_U32        outputIndexTimestamp;
+    OMX_BOOL       bConfiguredMFC;
+    WMV_FORMAT     wmvFormat;
+    OMX_S32        returnCodec;
+} SEC_MFC_WMV_HANDLE;
+
+typedef struct _SEC_WMV_HANDLE
+{
+    /* OMX Codec specific */
+    OMX_VIDEO_PARAM_WMVTYPE WmvComponent[ALL_PORT_NUM];
+    OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType[ALL_PORT_NUM];
+
+    /* SEC MFC Codec specific */
+    SEC_MFC_WMV_HANDLE      hMFCWmvHandle;
+
+    /* CSC FIMC handle */
+#ifdef USE_CSC_FIMC
+    OMX_PTR hFIMCHandle;
+#endif
+} SEC_WMV_HANDLE;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OSCL_EXPORT_REF OMX_ERRORTYPE SEC_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName);
+                OMX_ERRORTYPE SEC_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/exynos/multimedia/openmax/component/video/dec/vc1/library_register.c b/exynos/multimedia/openmax/component/video/dec/vc1/library_register.c
new file mode 100644
index 0000000..ce04f18
--- /dev/null
+++ b/exynos/multimedia/openmax/component/video/dec/vc1/library_register.c
@@ -0,0 +1,57 @@
+/*
+ *
+ * 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    library_register.c
+ * @brief
+ * @author    HyeYeon Chung (hyeon.chung@samsung.com)
+ * @version    1.1.0
+ * @history
+ *   2010.8.20 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dlfcn.h>
+
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_ETC.h"
+#include "library_register.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_WMV_DEC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent)
+{
+    FunctionIn();
+
+    if (ppSECComponent == NULL) {
+        goto EXIT;
+    }
+
+    /* component 1 - video decoder WMV */
+    SEC_OSAL_Strcpy(ppSECComponent[0]->componentName, SEC_OMX_COMPONENT_WMV_DEC);
+    SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPONENT_WMV_DEC_ROLE);
+    ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+    FunctionOut();
+    return MAX_COMPONENT_NUM;
+}
\ No newline at end of file
diff --git a/exynos/multimedia/openmax/component/video/dec/vc1/library_register.h b/exynos/multimedia/openmax/component/video/dec/vc1/library_register.h
new file mode 100644
index 0000000..adac586
--- /dev/null
+++ b/exynos/multimedia/openmax/component/video/dec/vc1/library_register.h
@@ -0,0 +1,52 @@
+/*
+ *
+ * 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    library_register.h
+ * @brief
+ * @author    HyeYeon Chung (hyeon.chung.chung@samsung.com)
+ * @version    1.1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_WMV_DEC_REG
+#define SEC_OMX_WMV_DEC_REG
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Component.h"
+#include "SEC_OMX_Component_Register.h"
+
+#define OSCL_EXPORT_REF __attribute__((visibility("default")))
+#define MAX_COMPONENT_NUM              1
+#define MAX_COMPONENT_ROLE_NUM    1
+
+/* WMV */
+#define SEC_OMX_COMPONENT_WMV_DEC         "OMX.SEC.WMV.Decoder"
+#define SEC_OMX_COMPONENT_WMV_DEC_ROLE    "video_decoder.wmv"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
\ No newline at end of file