S5PC11X: OMX: Added SEC_OMX(OpenMAX IL)

Component name
    1. OMX.SEC.AVC.Decoder
    2. OMX.SEC.MPEG4.Decoder
    3. OMX.SEC.H263.Decoder
    4. OMX.SEC.AVC.Encoder
    5. OMX.SEC.MPEG4.Encoder
    6. OMX.SEC.H263.Encoder

Change-Id: I4ae562c6d44fac8c376a8f60fd376c46bd1e721d
Signed-off-by: SeungBeom Kim <sbcrux.kim@samsung.com>

77 files changed, 22860 insertions, 0 deletions

diff --git a/sec_mm/Android.mk b/sec_mm/Android.mk
new file mode 100644
index 0000000..16298da
--- /dev/null
+++ b/sec_mm/Android.mk
@@ -0,0 +1,5 @@
+WITH_SEC_OMX := true
+
+ifeq ($(WITH_SEC_OMX), true)
+  include $(all-subdir-makefiles)
+endif
diff --git a/sec_mm/sec_omx/Android.mk b/sec_mm/sec_omx/Android.mk
new file mode 100644
index 0000000..63aac7b
--- /dev/null
+++ b/sec_mm/sec_omx/Android.mk
@@ -0,0 +1,23 @@
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+SEC_OMX_CFLAGS := -Wall -fpic -pipe -DSTATIC_TABLE -O0
+
+SEC_OMX_TOP := $(LOCAL_PATH)
+SEC_CODECS := $(SEC_OMX_TOP)/sec_codecs/
+
+SEC_OMX_INC := $(SEC_OMX_TOP)/sec_omx_include/
+SEC_OMX_COMPONENT := $(SEC_OMX_TOP)/sec_omx_component
+
+include $(SEC_OMX_TOP)/sec_osal/Android.mk
+include $(SEC_OMX_TOP)/sec_omx_core/Android.mk
+
+include $(SEC_CODECS)/Android.mk
+include $(SEC_OMX_COMPONENT)/common/Android.mk
+include $(SEC_OMX_COMPONENT)/video/dec/h264dec/Android.mk
+include $(SEC_OMX_COMPONENT)/video/dec/mpeg4dec/Android.mk
+include $(SEC_OMX_COMPONENT)/video/enc/h264enc/Android.mk
+include $(SEC_OMX_COMPONENT)/video/enc/mpeg4enc/Android.mk
+
diff --git a/sec_mm/sec_omx/sec_codecs/Android.mk b/sec_mm/sec_omx/sec_codecs/Android.mk
new file mode 100644
index 0000000..a51a075
--- /dev/null
+++ b/sec_mm/sec_omx/sec_codecs/Android.mk
@@ -0,0 +1,7 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+include   $(SEC_CODECS)/video/mfc_c110/dec/Android.mk
+include   $(SEC_CODECS)/video/mfc_c110/enc/Android.mk
+
diff --git a/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/Android.mk b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/Android.mk
new file mode 100644
index 0000000..7d1f027
--- /dev/null
+++ b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/Android.mk
@@ -0,0 +1,26 @@
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	src/SsbSipMfcDecAPI.c
+
+LOCAL_MODULE := libsecmfcdecapi
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES :=
+
+LOCAL_SHARED_LIBRARIES := liblog
+
+LOCAL_C_INCLUDES := \
+	$(SEC_CODECS)/video/mfc_c110/include
+
+include $(BUILD_STATIC_LIBRARY)
+
diff --git a/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/src/SsbSipMfcDecAPI.c b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/src/SsbSipMfcDecAPI.c
new file mode 100644
index 0000000..abcc020
--- /dev/null
+++ b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/src/SsbSipMfcDecAPI.c
@@ -0,0 +1,584 @@
+/*
+ * Copyright 2010 Samsung Electronics 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.
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <utils/Log.h>
+
+#include "mfc_interface.h"
+#include "SsbSipMfcApi.h"
+
+#define _MFCLIB_MAGIC_NUMBER    0x92241000
+
+#define USR_DATA_START_CODE     (0x000001B2)
+#define VOP_START_CODE          (0x000001B6)
+#define MP4_START_CODE          (0x000001)
+
+static void getAByte(char *buff, int *code)
+{
+    int byte;
+
+    *code = (*code << 8);
+    byte = (int)*buff;
+    byte &= 0xFF;
+    *code |= byte;
+}
+
+static mfc_packed_mode isPBPacked(_MFCLIB *pCtx, int length)
+{
+    char *strmBuffer = NULL;
+    char *strmBufferEnd = NULL;
+    int startCode = 0xFFFFFFFF;
+
+    strmBuffer = (char *)pCtx->virStrmBuf;
+    strmBufferEnd = (char *)pCtx->virStrmBuf + length;
+
+    while (1) {
+        while (startCode != USR_DATA_START_CODE) {
+            if (startCode == VOP_START_CODE) {
+                LOGV("isPBPacked: VOP START Found !!.....return\n");
+                LOGV("isPBPacked: Non Packed PB\n");
+                return MFC_UNPACKED_PB;
+            }
+            getAByte(strmBuffer, &startCode);
+            strmBuffer++;
+            if (strmBuffer >= strmBufferEnd)
+                goto out;
+        }
+        LOGV("isPBPacked: User Data Found !!\n");
+
+        do {
+            if (*strmBuffer == 'p') {
+                LOGI("isPBPacked: Packed PB\n");
+                return MFC_PACKED_PB;
+            }
+            getAByte(strmBuffer, &startCode);
+            strmBuffer++;
+            if (strmBuffer >= strmBufferEnd)
+                goto out;
+        } while ((startCode >> 8) != MP4_START_CODE);
+    }
+
+out:
+    LOGV("isPBPacked: Non Packed PB\n");
+    return MFC_UNPACKED_PB;
+}
+
+void *SsbSipMfcDecOpen(void)
+{
+    int hMFCOpen;
+    unsigned int mapped_addr;
+    _MFCLIB *pCTX;
+
+    pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
+    if (pCTX == NULL) {
+        LOGE("SsbSipMfcDecOpen: malloc failed.\n");
+        return NULL;
+    }
+    memset(pCTX, 0, sizeof(_MFCLIB));
+
+    hMFCOpen = open(S5PC110_MFC_DEV_NAME, O_RDWR | O_NDELAY);
+    if (hMFCOpen < 0) {
+        LOGE("SsbSipMfcDecOpen: MFC Open failure\n");
+        return NULL;
+    }
+
+    mapped_addr = (unsigned int)mmap(0, MMAP_BUFFER_SIZE_MMAP, PROT_READ | PROT_WRITE, MAP_SHARED, hMFCOpen, 0);
+    if (!mapped_addr) {
+        LOGE("SsbSipMfcDecOpen: FIMV5.0 driver address mapping failed\n");
+        return NULL;
+    }
+
+    pCTX->magic = _MFCLIB_MAGIC_NUMBER;
+    pCTX->hMFC = hMFCOpen;
+    pCTX->mapped_addr = mapped_addr;
+    pCTX->inter_buff_status = MFC_USE_NONE;
+
+    return (void *)pCTX;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecInit(void *openHandle, SSBSIP_MFC_CODEC_TYPE codec_type, int Frameleng)
+{
+    int ret_code;
+    int packedPB = MFC_UNPACKED_PB;
+    mfc_common_args DecArg;
+    _MFCLIB *pCTX;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcDecSetConfig: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+    memset(&DecArg, 0x00, sizeof(DecArg));
+
+    if ((codec_type != MPEG4_DEC)  &&
+        (codec_type != H264_DEC)   &&
+        (codec_type != H263_DEC)   &&
+        (codec_type != MPEG1_DEC)  &&
+        (codec_type != MPEG2_DEC)  &&
+        (codec_type != FIMV1_DEC)  &&
+        (codec_type != FIMV2_DEC)  &&
+        (codec_type != FIMV3_DEC)  &&
+        (codec_type != FIMV4_DEC)  &&
+        (codec_type != XVID_DEC)   &&
+        (codec_type != VC1RCV_DEC) &&
+        (codec_type != VC1_DEC)) {
+        LOGE("SsbSipMfcDecOpen: Undefined codec type.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX->codec_type = codec_type;
+
+    if ((pCTX->codec_type == MPEG4_DEC)   ||
+        (pCTX->codec_type == FIMV1_DEC) ||
+        (pCTX->codec_type == FIMV2_DEC) ||
+        (pCTX->codec_type == FIMV3_DEC) ||
+        (pCTX->codec_type == FIMV4_DEC) ||
+        (pCTX->codec_type == XVID_DEC))
+        packedPB = isPBPacked(pCTX, Frameleng);
+
+    /* init args */
+    DecArg.args.dec_init.in_codec_type = pCTX->codec_type;
+    DecArg.args.dec_init.in_strm_size = Frameleng;
+    DecArg.args.dec_init.in_strm_buf = pCTX->phyStrmBuf;
+    DecArg.args.dec_init.in_packed_PB = packedPB;
+
+    /* mem alloc args */
+    DecArg.args.dec_init.in_mapped_addr = pCTX->mapped_addr;
+
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_DEC_INIT, &DecArg);
+    if (DecArg.ret_code != MFC_RET_OK) {
+        LOGE("SsbSipMfcDecInit: IOCTL_MFC_DEC_INIT (%d) failed\n", DecArg.ret_code);
+        return MFC_RET_DEC_INIT_FAIL;
+    }
+
+    pCTX->decOutInfo.img_width = DecArg.args.dec_init.out_img_width;
+    pCTX->decOutInfo.img_height = DecArg.args.dec_init.out_img_height;
+    pCTX->decOutInfo.buf_width = DecArg.args.dec_init.out_buf_width;
+    pCTX->decOutInfo.buf_height = DecArg.args.dec_init.out_buf_height;
+
+    pCTX->virFrmBuf.luma = DecArg.args.dec_init.out_u_addr.luma;
+    pCTX->virFrmBuf.chroma = DecArg.args.dec_init.out_u_addr.chroma;
+
+    pCTX->phyFrmBuf.luma = DecArg.args.dec_init.out_p_addr.luma;
+    pCTX->phyFrmBuf.chroma = DecArg.args.dec_init.out_p_addr.chroma;
+    pCTX->sizeFrmBuf.luma = DecArg.args.dec_init.out_frame_buf_size.luma;
+    pCTX->sizeFrmBuf.chroma = DecArg.args.dec_init.out_frame_buf_size.chroma;
+    pCTX->inter_buff_status |= MFC_USE_YUV_BUFF;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecExe(void *openHandle, int lengthBufFill)
+{
+    int ret_code;
+    int Yoffset;
+    int Coffset;
+    _MFCLIB *pCTX;
+    mfc_common_args DecArg;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcDecExe: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    if ((lengthBufFill < 0) || (lengthBufFill > MAX_DECODER_INPUT_BUFFER_SIZE)) {
+        LOGE("SsbSipMfcDecExe: lengthBufFill is invalid. (lengthBufFill=%d)\n", lengthBufFill);
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+    memset(&DecArg, 0x00, sizeof(DecArg));
+
+    DecArg.args.dec_exe.in_codec_type = pCTX->codec_type;
+    DecArg.args.dec_exe.in_strm_buf = pCTX->phyStrmBuf;
+    DecArg.args.dec_exe.in_strm_size = lengthBufFill;
+    DecArg.args.dec_exe.in_frm_buf.luma = pCTX->phyFrmBuf.luma;
+    DecArg.args.dec_exe.in_frm_buf.chroma = pCTX->phyFrmBuf.chroma;
+    DecArg.args.dec_exe.in_frm_size.luma = pCTX->sizeFrmBuf.luma;
+    DecArg.args.dec_exe.in_frm_size.chroma = pCTX->sizeFrmBuf.chroma;
+    DecArg.args.dec_exe.in_frametag = pCTX->in_frametag;
+
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_DEC_EXE, &DecArg);
+    if (DecArg.ret_code != MFC_RET_OK) {
+        LOGE("SsbSipMfcDecExe: IOCTL_MFC_DEC_EXE failed(ret : %d)\n", DecArg.ret_code);
+        return MFC_RET_DEC_EXE_ERR;
+    }
+
+    Yoffset = DecArg.args.dec_exe.out_display_Y_addr - DecArg.args.dec_exe.in_frm_buf.luma;
+    Coffset = DecArg.args.dec_exe.out_display_C_addr - DecArg.args.dec_exe.in_frm_buf.chroma;
+
+    pCTX->decOutInfo.YPhyAddr = (void *)(DecArg.args.dec_exe.out_display_Y_addr);
+    pCTX->decOutInfo.CPhyAddr = (void *)(DecArg.args.dec_exe.out_display_C_addr);
+    pCTX->decOutInfo.YVirAddr = (void *)(pCTX->virFrmBuf.luma + Yoffset);
+    pCTX->decOutInfo.CVirAddr = (void *)(pCTX->virFrmBuf.chroma + Coffset);
+    pCTX->decOutInfo.timestamp_top = DecArg.args.dec_exe.out_timestamp_top;
+    pCTX->decOutInfo.timestamp_bottom = DecArg.args.dec_exe.out_timestamp_bottom;
+    pCTX->decOutInfo.consumedByte = DecArg.args.dec_exe.out_consume_bytes;
+    pCTX->decOutInfo.res_change = DecArg.args.dec_exe.out_res_change;
+    pCTX->decOutInfo.crop_top_offset = DecArg.args.dec_exe.out_crop_top_offset;
+    pCTX->decOutInfo.crop_bottom_offset = DecArg.args.dec_exe.out_crop_bottom_offset;
+    pCTX->decOutInfo.crop_left_offset = DecArg.args.dec_exe.out_crop_left_offset;
+    pCTX->decOutInfo.crop_right_offset = DecArg.args.dec_exe.out_crop_right_offset;
+    pCTX->out_frametag_top = DecArg.args.dec_exe.out_frametag_top;
+    pCTX->out_frametag_bottom = DecArg.args.dec_exe.out_frametag_bottom;
+    pCTX->displayStatus = DecArg.args.dec_exe.out_display_status;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecClose(void *openHandle)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args free_arg;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcDecClose: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    if (pCTX->inter_buff_status & MFC_USE_YUV_BUFF) {
+        free_arg.args.mem_free.u_addr = pCTX->virFrmBuf.luma;
+        ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
+        free_arg.args.mem_free.u_addr = pCTX->virFrmBuf.chroma;
+        ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
+    }
+
+    if (pCTX->inter_buff_status & MFC_USE_STRM_BUFF) {
+        free_arg.args.mem_free.u_addr = pCTX->virStrmBuf;
+        ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
+    }
+
+    pCTX->inter_buff_status = MFC_USE_NONE;
+
+    munmap((void *)pCTX->mapped_addr, MMAP_BUFFER_SIZE_MMAP);
+    close(pCTX->hMFC);
+    free(pCTX);
+
+    return MFC_RET_OK;
+}
+
+void *SsbSipMfcDecGetInBuf(void *openHandle, void **phyInBuf, int inputBufferSize)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args user_addr_arg, phys_addr_arg;
+
+    if (inputBufferSize < 0) {
+        LOGE("SsbSipMfcDecGetInBuf: inputBufferSize = %d is invalid\n", inputBufferSize);
+        return NULL;
+    }
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcDecGetInBuf: openHandle is NULL\n");
+        return NULL;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    user_addr_arg.args.mem_alloc.codec_type = pCTX->codec_type;
+    user_addr_arg.args.mem_alloc.buff_size = inputBufferSize;
+    user_addr_arg.args.mem_alloc.mapped_addr = pCTX->mapped_addr;
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_IN_BUF, &user_addr_arg);
+    if (ret_code < 0) {
+        LOGE("SsbSipMfcDecGetInBuf: IOCTL_MFC_GET_IN_BUF failed\n");
+        return NULL;
+    }
+    pCTX->virStrmBuf = user_addr_arg.args.mem_alloc.out_uaddr;
+    pCTX->phyStrmBuf = user_addr_arg.args.mem_alloc.out_paddr;
+    pCTX->sizeStrmBuf = inputBufferSize;
+    pCTX->inter_buff_status |= MFC_USE_STRM_BUFF;
+
+    *phyInBuf = (void *)pCTX->phyStrmBuf;
+
+    return (void *)pCTX->virStrmBuf;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, void *phyInBuf, void *virInBuf, int inputBufferSize)
+{
+    _MFCLIB *pCTX;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcDecSetInBuf: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX  = (_MFCLIB *)openHandle;
+
+    pCTX->phyStrmBuf = (int)phyInBuf;
+    pCTX->virStrmBuf = (int)virInBuf;
+    pCTX->sizeStrmBuf = inputBufferSize;
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecGetOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info)
+{
+    _MFCLIB *pCTX;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcDecGetOutBuf: openHandle is NULL\n");
+        return MFC_GETOUTBUF_DISPLAY_END;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    output_info->YPhyAddr = pCTX->decOutInfo.YPhyAddr;
+    output_info->CPhyAddr = pCTX->decOutInfo.CPhyAddr;
+
+    output_info->YVirAddr = pCTX->decOutInfo.YVirAddr;
+    output_info->CVirAddr = pCTX->decOutInfo.CVirAddr;
+
+    output_info->img_width = pCTX->decOutInfo.img_width;
+    output_info->img_height= pCTX->decOutInfo.img_height;
+
+    output_info->buf_width = pCTX->decOutInfo.buf_width;
+    output_info->buf_height= pCTX->decOutInfo.buf_height;
+
+    if (pCTX->displayStatus == 0)
+        return MFC_GETOUTBUF_DISPLAY_END;
+    else if (pCTX->displayStatus == 1)
+        return MFC_GETOUTBUF_DISPLAY_DECODING;
+    else if (pCTX->displayStatus == 2)
+        return MFC_GETOUTBUF_DISPLAY_ONLY;
+    else
+        return MFC_GETOUTBUF_DECODING_ONLY;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetConfig(void *openHandle, SSBSIP_MFC_DEC_CONF conf_type, void *value)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args DecArg;
+    SSBSIP_MFC_IMG_RESOLUTION *img_resolution;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcDecSetConfig: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    if (value == NULL) {
+        LOGE("SsbSipMfcDecSetConfig: value is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+    memset(&DecArg, 0x00, sizeof(DecArg));
+
+    switch (conf_type) {
+    case MFC_DEC_SETCONF_POST_ENABLE:
+    case MFC_DEC_SETCONF_EXTRA_BUFFER_NUM:
+    case MFC_DEC_SETCONF_DISPLAY_DELAY:
+    case MFC_DEC_SETCONF_IS_LAST_FRAME:
+    case MFC_DEC_SETCONF_SLICE_ENABLE:
+    case MFC_DEC_SETCONF_CRC_ENABLE:
+        DecArg.args.set_config.in_config_param = conf_type;
+        DecArg.args.set_config.in_config_value[0] = *((unsigned int *)value);
+        DecArg.args.set_config.in_config_value[1] = 0;
+        break;
+
+    case MFC_DEC_SETCONF_FIMV1_WIDTH_HEIGHT:
+        img_resolution = (SSBSIP_MFC_IMG_RESOLUTION *)value;
+        DecArg.args.set_config.in_config_param = conf_type;
+        DecArg.args.set_config.in_config_value[0] = img_resolution->width;
+        DecArg.args.set_config.in_config_value[1] = img_resolution->height;
+        break;
+
+    case MFC_DEC_SETCONF_FRAME_TAG:
+        pCTX->in_frametag = *((int *)value);
+        return MFC_RET_OK;
+
+    default:
+        LOGE("SsbSipMfcDecSetConfig: No such conf_type is supported.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_SET_CONFIG, &DecArg);
+    if (DecArg.ret_code != MFC_RET_OK) {
+        LOGE("SsbSipMfcDecSetConfig: IOCTL_MFC_SET_CONFIG failed(ret : %d, conf_type: %d)\n", DecArg.ret_code, conf_type);
+        return MFC_RET_DEC_SET_CONF_FAIL;
+    }
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecGetConfig(void *openHandle, SSBSIP_MFC_DEC_CONF conf_type, void *value)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args DecArg;
+
+    SSBSIP_MFC_IMG_RESOLUTION *img_resolution;
+    MFC_CRC_DATA *crc_data;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcDecGetConfig: openHandle is NULL\n");
+        return MFC_RET_FAIL;
+    }
+
+    if (value == NULL) {
+        LOGE("SsbSipMfcDecGetConfig: value is NULL\n");
+        return MFC_RET_FAIL;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+    memset(&DecArg, 0x00, sizeof(DecArg));
+
+    switch (conf_type) {
+    case MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT:
+        img_resolution = (SSBSIP_MFC_IMG_RESOLUTION *)value;
+        img_resolution->width = pCTX->decOutInfo.img_width;
+        img_resolution->height = pCTX->decOutInfo.img_height;
+        img_resolution->buf_width = pCTX->decOutInfo.buf_width;
+        img_resolution->buf_height = pCTX->decOutInfo.buf_height;
+        break;
+
+    case MFC_DEC_GETCONF_CRC_DATA:
+        crc_data = (MFC_CRC_DATA *)value;
+
+        DecArg.args.get_config.in_config_param = conf_type;
+
+        ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_CONFIG, &DecArg);
+        if (DecArg.ret_code != MFC_RET_OK) {
+            LOGE("SsbSipMfcDecGetConfig: IOCTL_MFC_GET_CONFIG failed(ret : %d, conf_type: %d)\n", DecArg.ret_code, conf_type);
+            return MFC_RET_DEC_GET_CONF_FAIL;
+        }
+        crc_data->luma0 = DecArg.args.get_config.out_config_value[0];
+        crc_data->chroma0 = DecArg.args.get_config.out_config_value[1];
+        break;
+
+    case MFC_DEC_GETCONF_FRAME_TAG:
+        *((unsigned int *)value) = pCTX->out_frametag_top;
+        break;
+
+    default:
+        LOGE("SsbSipMfcDecGetConfig: No such conf_type is supported.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    return MFC_RET_OK;
+}
+
+int tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos)
+{
+    int pixel_x_m1, pixel_y_m1;
+    int roundup_x, roundup_y;
+    int linear_addr0, linear_addr1, bank_addr ;
+    int x_addr;
+    int trans_addr;
+
+    pixel_x_m1 = x_size -1;
+    pixel_y_m1 = y_size -1;
+
+    roundup_x = ((pixel_x_m1 >> 7) + 1);
+    roundup_y = ((pixel_x_m1 >> 6) + 1);
+
+    x_addr = x_pos >> 2;
+
+    if ((y_size <= y_pos+32) && ( y_pos < y_size) &&
+        (((pixel_y_m1 >> 5) & 0x1) == 0) && (((y_pos >> 5) & 0x1) == 0)) {
+        linear_addr0 = (((y_pos & 0x1f) <<4) | (x_addr & 0xf));
+        linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 6) & 0x3f));
+
+        if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
+            bank_addr = ((x_addr >> 4) & 0x1);
+        else
+            bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
+    } else {
+        linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
+        linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 5) & 0x7f));
+
+        if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
+            bank_addr = ((x_addr >> 4) & 0x1);
+        else
+            bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
+    }
+
+    linear_addr0 = linear_addr0 << 2;
+    trans_addr = (linear_addr1 <<13) | (bank_addr << 11) | linear_addr0;
+
+    return trans_addr;
+}
+
+void tile_to_linear_4x2(unsigned char *p_linear_addr, unsigned char *p_tiled_addr, unsigned int x_size, unsigned int y_size)
+{
+    int trans_addr;
+    unsigned int i, j, k, index;
+    unsigned char data8[4];
+    unsigned int max_index = x_size * y_size;
+
+    for (i = 0; i < y_size; i = i + 16) {
+        for (j = 0; j < x_size; j = j + 16) {
+            trans_addr = tile_4x2_read(x_size, y_size, j, i);
+            for (k = 0; k < 16; k++) {
+                /* limit check - prohibit segmentation fault */
+                index = (i * x_size) + (x_size * k) + j;
+                /* remove equal condition to solve thumbnail bug */
+                if (index + 16 > max_index) {
+                    continue;
+                }
+
+                data8[0] = p_tiled_addr[trans_addr + 64 * k + 0];
+                data8[1] = p_tiled_addr[trans_addr + 64 * k + 1];
+                data8[2] = p_tiled_addr[trans_addr + 64 * k + 2];
+                data8[3] = p_tiled_addr[trans_addr + 64 * k + 3];
+
+                p_linear_addr[i * x_size + x_size * k + j] = data8[0];
+                p_linear_addr[i * x_size + x_size * k + j + 1] = data8[1];
+                p_linear_addr[i * x_size + x_size * k + j + 2] = data8[2];
+                p_linear_addr[i * x_size + x_size * k + j + 3] = data8[3];
+
+                data8[0] = p_tiled_addr[trans_addr + 64 * k + 4];
+                data8[1] = p_tiled_addr[trans_addr + 64 * k + 5];
+                data8[2] = p_tiled_addr[trans_addr + 64 * k + 6];
+                data8[3] = p_tiled_addr[trans_addr + 64 * k + 7];
+
+                p_linear_addr[i * x_size + x_size * k + j + 4] = data8[0];
+                p_linear_addr[i * x_size + x_size * k + j + 5] = data8[1];
+                p_linear_addr[i * x_size + x_size * k + j + 6] = data8[2];
+                p_linear_addr[i * x_size + x_size * k + j + 7] = data8[3];
+
+                data8[0] = p_tiled_addr[trans_addr + 64 * k + 8];
+                data8[1] = p_tiled_addr[trans_addr + 64 * k + 9];
+                data8[2] = p_tiled_addr[trans_addr + 64 * k + 10];
+                data8[3] = p_tiled_addr[trans_addr + 64 * k + 11];
+                p_linear_addr[i*x_size + x_size * k + j + 8] = data8[0];
+                p_linear_addr[i*x_size + x_size * k + j + 9] = data8[1];
+                p_linear_addr[i*x_size + x_size * k + j + 10] = data8[2];
+                p_linear_addr[i*x_size + x_size * k + j + 11] = data8[3];
+
+                data8[0] = p_tiled_addr[trans_addr + 64 * k + 12];
+                data8[1] = p_tiled_addr[trans_addr + 64 * k + 13];
+                data8[2] = p_tiled_addr[trans_addr + 64 * k + 14];
+                data8[3] = p_tiled_addr[trans_addr + 64 * k + 15];
+                p_linear_addr[i*x_size + x_size * k + j + 12] = data8[0];
+                p_linear_addr[i*x_size + x_size * k + j + 13] = data8[1];
+                p_linear_addr[i*x_size + x_size * k + j + 14] = data8[2];
+                p_linear_addr[i*x_size + x_size * k + j + 15] = data8[3];
+            }
+        }
+    }
+}
diff --git a/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/Android.mk b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/Android.mk
new file mode 100644
index 0000000..735da6b
--- /dev/null
+++ b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/Android.mk
@@ -0,0 +1,26 @@
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	src/SsbSipMfcEncAPI.c
+
+LOCAL_MODULE := libsecmfcencapi
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_CFLAGS := -DUSE_FIMC_FRAME_BUFFER
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES :=
+
+LOCAL_SHARED_LIBRARIES := liblog
+
+LOCAL_C_INCLUDES := \
+	$(SEC_CODECS)/video/mfc_c110/include
+
+include $(BUILD_STATIC_LIBRARY)
+
diff --git a/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/src/SsbSipMfcEncAPI.c b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/src/SsbSipMfcEncAPI.c
new file mode 100644
index 0000000..2c33c5b
--- /dev/null
+++ b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/src/SsbSipMfcEncAPI.c
@@ -0,0 +1,630 @@
+/*
+ * Copyright 2010 Samsung Electronics 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.
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <utils/Log.h>
+
+#include "SsbSipMfcApi.h"
+#include "mfc_interface.h"
+
+#define _MFCLIB_MAGIC_NUMBER     0x92241001
+
+void *SsbSipMfcEncOpen(void)
+{
+    int hMFCOpen;
+    _MFCLIB *pCTX;
+    unsigned int mapped_addr;
+
+    hMFCOpen = open(S5PC110_MFC_DEV_NAME, O_RDWR | O_NDELAY);
+    if (hMFCOpen < 0) {
+        LOGE("SsbSipMfcEncOpen: MFC Open failure\n");
+        return NULL;
+    }
+
+    pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
+    if (pCTX == NULL) {
+        LOGE("SsbSipMfcEncOpen: malloc failed.\n");
+        close(hMFCOpen);
+        return NULL;
+    }
+
+    mapped_addr = (unsigned int)mmap(0, MMAP_BUFFER_SIZE_MMAP, PROT_READ | PROT_WRITE, MAP_SHARED, hMFCOpen, 0);
+    if (!mapped_addr) {
+        LOGE("SsbSipMfcEncOpen: FIMV5.0 driver address mapping failed\n");
+        return NULL;
+    }
+
+    memset(pCTX, 0, sizeof(_MFCLIB));
+
+    pCTX->magic = _MFCLIB_MAGIC_NUMBER;
+    pCTX->hMFC = hMFCOpen;
+    pCTX->mapped_addr = mapped_addr;
+    pCTX->inter_buff_status = MFC_USE_NONE;
+
+    return (void *)pCTX;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncInit(void *openHandle, void *param)
+{
+    int ret_code;
+    int dpbBufSize;
+
+    _MFCLIB *pCTX;
+    mfc_common_args EncArg;
+    mfc_common_args user_addr_arg, phys_addr_arg;
+    SSBSIP_MFC_ENC_H264_PARAM *h264_arg;
+    SSBSIP_MFC_ENC_MPEG4_PARAM *mpeg4_arg;
+    SSBSIP_MFC_ENC_H263_PARAM *h263_arg;
+    SSBSIP_MFC_CODEC_TYPE codec_type;
+
+    pCTX = (_MFCLIB *)openHandle;
+    memset(&EncArg, 0, sizeof(mfc_common_args));
+
+    LOGV("SsbSipMfcEncInit: Encode Init start\n");
+
+    mpeg4_arg = (SSBSIP_MFC_ENC_MPEG4_PARAM *)param;
+    codec_type = mpeg4_arg->codecType;
+
+    if ((codec_type != MPEG4_ENC) &&
+        (codec_type != H264_ENC)  &&
+        (codec_type != H263_ENC)) {
+        LOGE("SsbSipMfcEncOpen: Undefined codec type.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX->codec_type = codec_type;
+
+    switch (pCTX->codec_type) {
+    case MPEG4_ENC:
+        LOGV("SsbSipMfcEncInit: MPEG4 Encode\n");
+        mpeg4_arg = (SSBSIP_MFC_ENC_MPEG4_PARAM *)param;
+
+        pCTX->width = mpeg4_arg->SourceWidth;
+        pCTX->height = mpeg4_arg->SourceHeight;
+        break;
+
+    case H263_ENC:
+        LOGV("SsbSipMfcEncInit: H263 Encode\n");
+        h263_arg = (SSBSIP_MFC_ENC_H263_PARAM *)param;
+
+        pCTX->width = h263_arg->SourceWidth;
+        pCTX->height = h263_arg->SourceHeight;
+        break;
+
+    case H264_ENC:
+        LOGV("SsbSipMfcEncInit: H264 Encode\n");
+        h264_arg = (SSBSIP_MFC_ENC_H264_PARAM *)param;
+
+        pCTX->width = h264_arg->SourceWidth;
+        pCTX->height = h264_arg->SourceHeight;
+        break;
+
+    default:
+        break;
+    }
+
+    switch (pCTX->codec_type) {
+    case MPEG4_ENC:
+        mpeg4_arg = (SSBSIP_MFC_ENC_MPEG4_PARAM*)param;
+
+        EncArg.args.enc_init_mpeg4.in_codec_type = pCTX->codec_type;
+        EncArg.args.enc_init_mpeg4.in_profile_level = ENC_PROFILE_LEVEL(mpeg4_arg->ProfileIDC, mpeg4_arg->LevelIDC);
+
+        EncArg.args.enc_init_mpeg4.in_width = mpeg4_arg->SourceWidth;
+        EncArg.args.enc_init_mpeg4.in_height = mpeg4_arg->SourceHeight;
+        EncArg.args.enc_init_mpeg4.in_gop_num = mpeg4_arg->IDRPeriod;
+        if (mpeg4_arg->DisableQpelME)
+            EncArg.args.enc_init_mpeg4.in_qpelME_enable = 0;
+        else
+            EncArg.args.enc_init_mpeg4.in_qpelME_enable = 1;
+
+        EncArg.args.enc_init_mpeg4.in_MS_mode = mpeg4_arg->SliceMode;
+        EncArg.args.enc_init_mpeg4.in_MS_size = mpeg4_arg->SliceArgument;
+
+        if (mpeg4_arg->NumberBFrames > 2) {
+            LOGE("SsbSipMfcEncInit: No such BframeNum is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_mpeg4.in_BframeNum = mpeg4_arg->NumberBFrames;
+        EncArg.args.enc_init_mpeg4.in_mb_refresh = mpeg4_arg->RandomIntraMBRefresh;
+
+        /* rate control*/
+        EncArg.args.enc_init_mpeg4.in_RC_frm_enable = mpeg4_arg->EnableFRMRateControl;
+        if ((mpeg4_arg->QSCodeMin > 51) || (mpeg4_arg->QSCodeMax > 51)) {
+            LOGE("SsbSipMfcEncInit: No such Min/Max QP is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_mpeg4.in_RC_qbound = ENC_RC_QBOUND(mpeg4_arg->QSCodeMin, mpeg4_arg->QSCodeMax);
+        EncArg.args.enc_init_mpeg4.in_RC_rpara = mpeg4_arg->CBRPeriodRf;
+
+        /* pad control */
+        EncArg.args.enc_init_mpeg4.in_pad_ctrl_on = mpeg4_arg->PadControlOn;
+        if ((mpeg4_arg->LumaPadVal > 255) || (mpeg4_arg->CbPadVal > 255) || (mpeg4_arg->CrPadVal > 255)) {
+            LOGE("SsbSipMfcEncInit: No such Pad value is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_mpeg4.in_luma_pad_val = mpeg4_arg->LumaPadVal;
+        EncArg.args.enc_init_mpeg4.in_cb_pad_val = mpeg4_arg->CbPadVal;
+        EncArg.args.enc_init_mpeg4.in_cr_pad_val = mpeg4_arg->CrPadVal;
+
+        EncArg.args.enc_init_mpeg4.in_time_increament_res = mpeg4_arg->TimeIncreamentRes;
+        EncArg.args.enc_init_mpeg4.in_time_vop_time_increament = mpeg4_arg->VopTimeIncreament;
+        EncArg.args.enc_init_mpeg4.in_RC_framerate = (mpeg4_arg->TimeIncreamentRes / mpeg4_arg->VopTimeIncreament);
+        EncArg.args.enc_init_mpeg4.in_RC_bitrate = mpeg4_arg->Bitrate;
+        if ((mpeg4_arg->FrameQp > 51) || (mpeg4_arg->FrameQp_P) > 51 || (mpeg4_arg->FrameQp_B > 51)) {
+            LOGE("SsbSipMfcEncInit: No such FrameQp is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_mpeg4.in_frame_qp = mpeg4_arg->FrameQp;
+        if (mpeg4_arg->FrameQp_P)
+            EncArg.args.enc_init_mpeg4.in_frame_P_qp = mpeg4_arg->FrameQp_P;
+        else
+            EncArg.args.enc_init_mpeg4.in_frame_P_qp = mpeg4_arg->FrameQp;
+        if (mpeg4_arg->FrameQp_B)
+            EncArg.args.enc_init_mpeg4.in_frame_B_qp = mpeg4_arg->FrameQp_B;
+        else
+            EncArg.args.enc_init_mpeg4.in_frame_B_qp = mpeg4_arg->FrameQp;
+
+            break;
+
+    case H263_ENC:
+        h263_arg = (SSBSIP_MFC_ENC_H263_PARAM *)param;
+
+        EncArg.args.enc_init_mpeg4.in_codec_type = pCTX->codec_type;
+        EncArg.args.enc_init_mpeg4.in_profile_level = ENC_PROFILE_LEVEL(66, 40);
+        EncArg.args.enc_init_mpeg4.in_width = h263_arg->SourceWidth;
+        EncArg.args.enc_init_mpeg4.in_height = h263_arg->SourceHeight;
+        EncArg.args.enc_init_mpeg4.in_gop_num = h263_arg->IDRPeriod;
+        EncArg.args.enc_init_mpeg4.in_mb_refresh = h263_arg->RandomIntraMBRefresh;
+        EncArg.args.enc_init_mpeg4.in_MS_mode = h263_arg->SliceMode;
+        EncArg.args.enc_init_mpeg4.in_MS_size = 0;
+
+        /* rate control*/
+        EncArg.args.enc_init_mpeg4.in_RC_frm_enable = h263_arg->EnableFRMRateControl;
+        if ((h263_arg->QSCodeMin > 51) || (h263_arg->QSCodeMax > 51)) {
+            LOGE("SsbSipMfcEncInit: No such Min/Max QP is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_mpeg4.in_RC_qbound = ENC_RC_QBOUND(h263_arg->QSCodeMin, h263_arg->QSCodeMax);
+        EncArg.args.enc_init_mpeg4.in_RC_rpara = h263_arg->CBRPeriodRf;
+
+        /* pad control */
+        EncArg.args.enc_init_mpeg4.in_pad_ctrl_on = h263_arg->PadControlOn;
+        if ((h263_arg->LumaPadVal > 255) || (h263_arg->CbPadVal > 255) || (h263_arg->CrPadVal > 255)) {
+            LOGE("SsbSipMfcEncInit: No such Pad value is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_mpeg4.in_luma_pad_val = h263_arg->LumaPadVal;
+        EncArg.args.enc_init_mpeg4.in_cb_pad_val = h263_arg->CbPadVal;
+        EncArg.args.enc_init_mpeg4.in_cr_pad_val = h263_arg->CrPadVal;
+
+        EncArg.args.enc_init_mpeg4.in_RC_framerate = h263_arg->FrameRate;
+        EncArg.args.enc_init_mpeg4.in_RC_bitrate = h263_arg->Bitrate;
+        if (h263_arg->FrameQp > 51) {
+            LOGE("SsbSipMfcEncInit: No such FrameQp is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_mpeg4.in_frame_qp = h263_arg->FrameQp;
+        if (h263_arg->FrameQp_P)
+            EncArg.args.enc_init_mpeg4.in_frame_P_qp = h263_arg->FrameQp_P;
+        else
+            EncArg.args.enc_init_mpeg4.in_frame_P_qp = h263_arg->FrameQp;
+
+        break;
+
+    case H264_ENC:
+        h264_arg = (SSBSIP_MFC_ENC_H264_PARAM *)param;
+
+        EncArg.args.enc_init_h264.in_codec_type = H264_ENC;
+        EncArg.args.enc_init_h264.in_profile_level = ENC_PROFILE_LEVEL(h264_arg->ProfileIDC, h264_arg->LevelIDC);
+
+        EncArg.args.enc_init_h264.in_width = h264_arg->SourceWidth;
+        EncArg.args.enc_init_h264.in_height = h264_arg->SourceHeight;
+        EncArg.args.enc_init_h264.in_gop_num = h264_arg->IDRPeriod;
+
+        if ((h264_arg->NumberRefForPframes > 2) || (h264_arg->NumberReferenceFrames > 2)) {
+            LOGE("SsbSipMfcEncInit: No such ref Num is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_h264.in_reference_num = h264_arg->NumberReferenceFrames;
+        EncArg.args.enc_init_h264.in_ref_num_p = h264_arg->NumberRefForPframes;
+
+        if ((h264_arg->SliceMode == 0) || (h264_arg->SliceMode == 1) ||
+            (h264_arg->SliceMode == 2) || (h264_arg->SliceMode == 4)) {
+            EncArg.args.enc_init_h264.in_MS_mode = h264_arg->SliceMode;
+        } else {
+            LOGE("SsbSipMfcEncInit: No such slice mode is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_h264.in_MS_size = h264_arg->SliceArgument;
+
+        if (h264_arg->NumberBFrames > 2) {
+            LOGE("SsbSipMfcEncInit: No such BframeNum is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_h264.in_BframeNum = h264_arg->NumberBFrames;
+
+        EncArg.args.enc_init_h264.in_deblock_filt = h264_arg->LoopFilterDisable;
+        if ((abs(h264_arg->LoopFilterAlphaC0Offset) > 6) || (abs(h264_arg->LoopFilterBetaOffset) > 6)) {
+            LOGE("SsbSipMfcEncInit: No such AlphaC0Offset or BetaOffset is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_h264.in_deblock_alpha_C0 = h264_arg->LoopFilterAlphaC0Offset;
+        EncArg.args.enc_init_h264.in_deblock_beta = h264_arg->LoopFilterBetaOffset;
+
+        EncArg.args.enc_init_h264.in_symbolmode = h264_arg->SymbolMode;
+        EncArg.args.enc_init_h264.in_interlace_mode = h264_arg->PictureInterlace;
+        EncArg.args.enc_init_h264.in_transform8x8_mode = h264_arg->Transform8x8Mode;
+
+        EncArg.args.enc_init_h264.in_mb_refresh = h264_arg->RandomIntraMBRefresh;
+
+        /* pad control */
+        EncArg.args.enc_init_h264.in_pad_ctrl_on = h264_arg->PadControlOn;
+        if ((h264_arg->LumaPadVal > 255) || (h264_arg->CbPadVal > 255) || (h264_arg->CrPadVal > 255)) {
+            LOGE("SsbSipMfcEncInit: No such Pad value is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_h264.in_luma_pad_val = h264_arg->LumaPadVal;
+        EncArg.args.enc_init_h264.in_cb_pad_val = h264_arg->CbPadVal;
+        EncArg.args.enc_init_h264.in_cr_pad_val = h264_arg->CrPadVal;
+
+        /* rate control*/
+        EncArg.args.enc_init_h264.in_RC_frm_enable = h264_arg->EnableFRMRateControl;
+        EncArg.args.enc_init_h264.in_RC_mb_enable = h264_arg->EnableMBRateControl;
+        EncArg.args.enc_init_h264.in_RC_framerate = h264_arg->FrameRate;
+        EncArg.args.enc_init_h264.in_RC_bitrate = h264_arg->Bitrate;
+        if (h264_arg->FrameQp > 51) {
+            LOGE("SsbSipMfcEncInit: No such FrameQp is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_h264.in_frame_qp = h264_arg->FrameQp;
+        if (h264_arg->FrameQp_P)
+            EncArg.args.enc_init_h264.in_frame_P_qp = h264_arg->FrameQp_P;
+        else
+            EncArg.args.enc_init_h264.in_frame_P_qp = h264_arg->FrameQp;
+        if (h264_arg->FrameQp_B)
+            EncArg.args.enc_init_h264.in_frame_B_qp = h264_arg->FrameQp_B;
+        else
+            EncArg.args.enc_init_h264.in_frame_B_qp = h264_arg->FrameQp;
+
+        if ((h264_arg->QSCodeMin > 51) || (h264_arg->QSCodeMax > 51)) {
+            LOGE("SsbSipMfcEncInit: No such Min/Max QP is supported.\n");
+            return MFC_RET_INVALID_PARAM;
+        }
+        EncArg.args.enc_init_h264.in_RC_qbound = ENC_RC_QBOUND(h264_arg->QSCodeMin, h264_arg->QSCodeMax);
+        EncArg.args.enc_init_h264.in_RC_rpara = h264_arg->CBRPeriodRf;
+        EncArg.args.enc_init_h264.in_RC_mb_dark_disable    = h264_arg->DarkDisable;
+        EncArg.args.enc_init_h264.in_RC_mb_smooth_disable = h264_arg->SmoothDisable;
+        EncArg.args.enc_init_h264.in_RC_mb_static_disable = h264_arg->StaticDisable;
+        EncArg.args.enc_init_h264.in_RC_mb_activity_disable = h264_arg->ActivityDisable;
+
+        /* default setting */
+        EncArg.args.enc_init_h264.in_md_interweight_pps = 0;
+        EncArg.args.enc_init_h264.in_md_intraweight_pps = 0;
+        break;
+
+    default:
+        break;
+    }
+
+    EncArg.args.enc_init_mpeg4.in_mapped_addr = pCTX->mapped_addr;
+
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_ENC_INIT, &EncArg);
+    if (EncArg.ret_code != MFC_RET_OK) {
+        LOGE("SsbSipMfcEncInit: IOCTL_MFC_ENC_INIT (%d) failed\n", EncArg.ret_code);
+        return MFC_RET_ENC_INIT_FAIL;
+    }
+
+    pCTX->virStrmBuf = EncArg.args.enc_init_mpeg4.out_u_addr.strm_ref_y;
+    pCTX->phyStrmBuf = EncArg.args.enc_init_mpeg4.out_p_addr.strm_ref_y;
+    pCTX->sizeStrmBuf = MAX_ENCODER_OUTPUT_BUFFER_SIZE;
+    pCTX->encodedHeaderSize = EncArg.args.enc_init_mpeg4.out_header_size;
+
+    pCTX->virMvRefYC = EncArg.args.enc_init_mpeg4.out_u_addr.mv_ref_yc;
+
+    pCTX->inter_buff_status |= MFC_USE_STRM_BUFF;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncExe(void *openHandle)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args EncArg;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcEncExe: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    memset(&EncArg, 0x00, sizeof(mfc_common_args));
+
+    EncArg.args.enc_exe.in_codec_type = pCTX->codec_type;
+    EncArg.args.enc_exe.in_Y_addr = (unsigned int)pCTX->phyFrmBuf.luma;
+    EncArg.args.enc_exe.in_CbCr_addr = (unsigned int)pCTX->phyFrmBuf.chroma;
+    EncArg.args.enc_exe.in_Y_addr_vir = (unsigned int)pCTX->virFrmBuf.luma;
+    EncArg.args.enc_exe.in_CbCr_addr_vir = (unsigned int)pCTX->virFrmBuf.chroma;
+    EncArg.args.enc_exe.in_strm_st = (unsigned int)pCTX->phyStrmBuf;
+    EncArg.args.enc_exe.in_strm_end = (unsigned int)pCTX->phyStrmBuf + pCTX->sizeStrmBuf;
+    EncArg.args.enc_exe.in_frametag = pCTX->in_frametag;
+
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_ENC_EXE, &EncArg);
+    if (EncArg.ret_code != MFC_RET_OK) {
+        LOGE("SsbSipMfcDecExe: IOCTL_MFC_ENC_EXE failed(ret : %d)\n", EncArg.ret_code);
+        return MFC_RET_ENC_EXE_ERR;
+    }
+
+    pCTX->encodedDataSize = EncArg.args.enc_exe.out_encoded_size;
+    pCTX->encodedframeType = EncArg.args.enc_exe.out_frame_type;
+    pCTX->encoded_Y_paddr = EncArg.args.enc_exe.out_encoded_Y_paddr;
+    pCTX->encoded_C_paddr = EncArg.args.enc_exe.out_encoded_C_paddr;
+    pCTX->out_frametag_top = EncArg.args.enc_exe.out_frametag_top;
+    pCTX->out_frametag_bottom = EncArg.args.enc_exe.out_frametag_bottom;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncClose(void *openHandle)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args free_arg;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcEncClose: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    if (pCTX->inter_buff_status & MFC_USE_YUV_BUFF) {
+        free_arg.args.mem_free.u_addr = pCTX->virFrmBuf.luma;
+        ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
+    }
+
+    if (pCTX->inter_buff_status & MFC_USE_STRM_BUFF) {
+        free_arg.args.mem_free.u_addr = pCTX->virStrmBuf;
+        ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
+        free_arg.args.mem_free.u_addr = pCTX->virMvRefYC;
+        ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
+    }
+
+    pCTX->inter_buff_status = MFC_USE_NONE;
+
+    munmap((void *)pCTX->mapped_addr, MMAP_BUFFER_SIZE_MMAP);
+    close(pCTX->hMFC);
+    free(pCTX);
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args user_addr_arg, phys_addr_arg;
+    int y_size, c_size;
+    int aligned_y_size, aligned_c_size;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcEncGetInBuf: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    user_addr_arg.args.mem_alloc.codec_type = pCTX->codec_type;
+
+    y_size = pCTX->width * pCTX->height;
+    c_size = (pCTX->width * pCTX->height) >> 1;
+
+    aligned_y_size = ALIGN_TO_8KB(ALIGN_TO_128B(pCTX->width) * ALIGN_TO_32B(pCTX->height));
+    aligned_c_size = ALIGN_TO_8KB(ALIGN_TO_128B(pCTX->width) * ALIGN_TO_32B(pCTX->height/2));
+
+    /* Allocate luma & chroma buf */
+    user_addr_arg.args.mem_alloc.buff_size = aligned_y_size + aligned_c_size;
+    user_addr_arg.args.mem_alloc.mapped_addr = pCTX->mapped_addr;
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_IN_BUF, &user_addr_arg);
+    if (ret_code < 0) {
+        LOGE("SsbSipMfcEncGetInBuf: IOCTL_MFC_GET_IN_BUF failed\n");
+        return MFC_RET_ENC_GET_INBUF_FAIL;
+    }
+    pCTX->virFrmBuf.luma = user_addr_arg.args.mem_alloc.out_uaddr;
+    pCTX->virFrmBuf.chroma = user_addr_arg.args.mem_alloc.out_uaddr + (unsigned int)aligned_y_size;
+    pCTX->phyFrmBuf.luma = user_addr_arg.args.mem_alloc.out_paddr;
+    pCTX->phyFrmBuf.chroma = user_addr_arg.args.mem_alloc.out_paddr + (unsigned int)aligned_y_size;
+
+    pCTX->sizeFrmBuf.luma = (unsigned int)y_size;
+    pCTX->sizeFrmBuf.chroma = (unsigned int)c_size;
+    pCTX->inter_buff_status |= MFC_USE_YUV_BUFF;
+
+    input_info->YPhyAddr = (void*)pCTX->phyFrmBuf.luma;
+    input_info->CPhyAddr = (void*)pCTX->phyFrmBuf.chroma;
+    input_info->YVirAddr = (void*)pCTX->virFrmBuf.luma;
+    input_info->CVirAddr = (void*)pCTX->virFrmBuf.chroma;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
+{
+    _MFCLIB *pCTX;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcEncSetInBuf: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    LOGV("SsbSipMfcEncSetInBuf: input_info->YPhyAddr & input_info->CPhyAddr should be 64KB aligned\n");
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    pCTX->phyFrmBuf.luma = (unsigned int)input_info->YPhyAddr;
+    pCTX->phyFrmBuf.chroma = (unsigned int)input_info->CPhyAddr;
+    pCTX->virFrmBuf.luma = (unsigned int)input_info->YVirAddr;
+    pCTX->virFrmBuf.chroma = (unsigned int)input_info->CVirAddr;
+
+    pCTX->sizeFrmBuf.luma = (unsigned int)input_info->YSize;
+    pCTX->sizeFrmBuf.chroma = (unsigned int)input_info->CSize;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetOutBuf(void *openHandle, SSBSIP_MFC_ENC_OUTPUT_INFO *output_info)
+{
+    _MFCLIB *pCTX;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcEncGetOutBuf: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    output_info->headerSize = pCTX->encodedHeaderSize;
+    output_info->dataSize = pCTX->encodedDataSize;
+    output_info->StrmPhyAddr = (void *)pCTX->phyStrmBuf;
+    output_info->StrmVirAddr = (void *)pCTX->virStrmBuf;
+
+    if (pCTX->encodedframeType == 0)
+        output_info->frameType = MFC_FRAME_TYPE_NOT_CODED;
+    else if (pCTX->encodedframeType == 1)
+        output_info->frameType = MFC_FRAME_TYPE_I_FRAME;
+    else if (pCTX->encodedframeType == 2)
+        output_info->frameType = MFC_FRAME_TYPE_P_FRAME;
+    else if (pCTX->encodedframeType == 3)
+        output_info->frameType = MFC_FRAME_TYPE_B_FRAME;
+    else if (pCTX->encodedframeType == 4)
+        output_info->frameType = MFC_FRAME_TYPE_OTHERS;
+    else {
+        LOGE("Strange encoded frame type = %d\n", pCTX->encodedframeType);
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    output_info->encodedYPhyAddr = (void *)pCTX->encoded_Y_paddr;
+    output_info->encodedCPhyAddr = (void *)pCTX->encoded_C_paddr;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetOutBuf(void *openHandle, void *phyOutbuf, void *virOutbuf, int outputBufferSize)
+{
+    _MFCLIB *pCTX;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcEncSetOutBuf: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    pCTX->phyStrmBuf = (int)phyOutbuf;
+    pCTX->virStrmBuf = (int)virOutbuf;
+    pCTX->sizeStrmBuf = outputBufferSize;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetConfig(void *openHandle, SSBSIP_MFC_ENC_CONF conf_type, void *value)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args EncArg;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcEncSetConfig: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    if (value == NULL) {
+        LOGE("SsbSipMfcEncSetConfig: value is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+    memset(&EncArg, 0x00, sizeof(mfc_common_args));
+
+    switch (conf_type) {
+    case MFC_ENC_SETCONF_FRAME_TYPE:
+    case MFC_ENC_SETCONF_CHANGE_FRAME_RATE:
+    case MFC_ENC_SETCONF_CHANGE_BIT_RATE:
+    case MFC_ENC_SETCONF_ALLOW_FRAME_SKIP:
+        EncArg.args.set_config.in_config_param = conf_type;
+        EncArg.args.set_config.in_config_value[0] = *((unsigned int *) value);
+        EncArg.args.set_config.in_config_value[1] = 0;
+        break;
+
+    case MFC_ENC_SETCONF_FRAME_TAG:
+        pCTX->in_frametag = *((int *)value);
+        return MFC_RET_OK;
+
+    default:
+        LOGE("SsbSipMfcEncSetConfig: No such conf_type is supported.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_SET_CONFIG, &EncArg);
+    if (EncArg.ret_code != MFC_RET_OK) {
+        LOGE("SsbSipMfcEncSetConfig: IOCTL_MFC_SET_CONFIG failed(ret : %d)\n", EncArg.ret_code);
+        return MFC_RET_ENC_SET_CONF_FAIL;
+    }
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetConfig(void *openHandle, SSBSIP_MFC_ENC_CONF conf_type, void *value)
+{
+    int ret_code;
+    _MFCLIB *pCTX;
+    mfc_common_args EncArg;
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    if (openHandle == NULL) {
+        LOGE("SsbSipMfcEncGetConfig: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+    if (value == NULL) {
+        LOGE("SsbSipMfcEncGetConfig: value is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+    memset(&EncArg, 0x00, sizeof(mfc_common_args));
+
+    switch (conf_type) {
+    case MFC_ENC_GETCONF_FRAME_TAG:
+        *((unsigned int *)value) = pCTX->out_frametag_top;
+        break;
+
+    default:
+        LOGE("SsbSipMfcEncGetConfig: No such conf_type is supported.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    return MFC_RET_OK;
+}
diff --git a/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/SsbSipMfcApi.h b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/SsbSipMfcApi.h
new file mode 100644
index 0000000..f8aaddc
--- /dev/null
+++ b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/SsbSipMfcApi.h
@@ -0,0 +1,323 @@
+/*
+ * Copyright 2010 Samsung Electronics 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.
+ */
+
+#ifndef _SSBSIP_MFC_API_H_
+#define _SSBSIP_MFC_API_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Definition                                                                     */
+/*--------------------------------------------------------------------------------*/
+#define MAX_DECODER_INPUT_BUFFER_SIZE  (1024 * 3072)
+#define MAX_ENCODER_OUTPUT_BUFFER_SIZE (1024 * 3072)
+
+#define SUPPORT_1080P        1
+
+#if SUPPORT_1080P
+#define MMAP_BUFFER_SIZE_MMAP          (63*1024*1024)
+#else
+#define MMAP_BUFFER_SIZE_MMAP          (49*1024*1024)
+#endif
+
+#define S5PC110_MFC_DEV_NAME           "/dev/s3c-mfc"
+
+/*--------------------------------------------------------------------------------*/
+/* Structure and Type                                                             */
+/*--------------------------------------------------------------------------------*/
+typedef enum {
+    H264_DEC,
+    VC1_DEC,     /* VC1 advaced Profile decoding  */
+    MPEG4_DEC,
+    XVID_DEC,
+    MPEG1_DEC,
+    MPEG2_DEC,
+    H263_DEC,
+    VC1RCV_DEC,  /* VC1 simple/main profile decoding  */
+    FIMV1_DEC,
+    FIMV2_DEC,
+    FIMV3_DEC,
+    FIMV4_DEC,
+    H264_ENC,
+    MPEG4_ENC,
+    H263_ENC,
+    UNKNOWN_TYPE
+} SSBSIP_MFC_CODEC_TYPE;
+
+typedef enum {
+    DONT_CARE = 0,
+    I_FRAME = 1,
+    NOT_CODED = 2
+} SSBSIP_MFC_FORCE_SET_FRAME_TYPE;
+
+typedef enum {
+    MFC_DEC_SETCONF_POST_ENABLE = 1,
+    MFC_DEC_SETCONF_EXTRA_BUFFER_NUM,
+    MFC_DEC_SETCONF_DISPLAY_DELAY,
+    MFC_DEC_SETCONF_IS_LAST_FRAME,
+    MFC_DEC_SETCONF_SLICE_ENABLE,
+    MFC_DEC_SETCONF_CRC_ENABLE,
+    MFC_DEC_SETCONF_FIMV1_WIDTH_HEIGHT,
+    MFC_DEC_SETCONF_FRAME_TAG,
+    MFC_DEC_GETCONF_CRC_DATA,
+    MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT,
+    MFC_DEC_GETCONF_FRAME_TAG
+} SSBSIP_MFC_DEC_CONF;
+
+typedef enum {
+    MFC_ENC_SETCONF_FRAME_TYPE = 100,
+    MFC_ENC_SETCONF_CHANGE_FRAME_RATE,
+    MFC_ENC_SETCONF_CHANGE_BIT_RATE,
+    MFC_ENC_SETCONF_FRAME_TAG,
+    MFC_ENC_SETCONF_ALLOW_FRAME_SKIP,
+    MFC_ENC_GETCONF_FRAME_TAG
+} SSBSIP_MFC_ENC_CONF;
+
+typedef enum {
+    MFC_GETOUTBUF_STATUS_NULL = 0,
+    MFC_GETOUTBUF_DECODING_ONLY = 1,
+    MFC_GETOUTBUF_DISPLAY_DECODING,
+    MFC_GETOUTBUF_DISPLAY_ONLY,
+    MFC_GETOUTBUF_DISPLAY_END
+} SSBSIP_MFC_DEC_OUTBUF_STATUS;
+
+typedef enum {
+    MFC_FRAME_TYPE_NOT_CODED,
+    MFC_FRAME_TYPE_I_FRAME,
+    MFC_FRAME_TYPE_P_FRAME,
+    MFC_FRAME_TYPE_B_FRAME,
+    MFC_FRAME_TYPE_OTHERS
+} SSBSIP_MFC_FRAME_TYPE;
+
+typedef enum {
+    MFC_RET_OK                      = 1,
+    MFC_RET_FAIL                    = -1000,
+    MFC_RET_OPEN_FAIL               = -1001,
+    MFC_RET_CLOSE_FAIL              = -1002,
+
+    MFC_RET_DEC_INIT_FAIL           = -2000,
+    MFC_RET_DEC_EXE_TIME_OUT        = -2001,
+    MFC_RET_DEC_EXE_ERR             = -2002,
+    MFC_RET_DEC_GET_INBUF_FAIL      = -2003,
+    MFC_RET_DEC_SET_INBUF_FAIL      = -2004,
+    MFC_RET_DEC_GET_OUTBUF_FAIL     = -2005,
+    MFC_RET_DEC_GET_CONF_FAIL       = -2006,
+    MFC_RET_DEC_SET_CONF_FAIL       = -2007,
+
+    MFC_RET_ENC_INIT_FAIL           = -3000,
+    MFC_RET_ENC_EXE_TIME_OUT        = -3001,
+    MFC_RET_ENC_EXE_ERR             = -3002,
+    MFC_RET_ENC_GET_INBUF_FAIL      = -3003,
+    MFC_RET_ENC_SET_INBUF_FAIL      = -3004,
+    MFC_RET_ENC_GET_OUTBUF_FAIL     = -3005,
+    MFC_RET_ENC_SET_OUTBUF_FAIL     = -3006,
+    MFC_RET_ENC_GET_CONF_FAIL       = -3007,
+    MFC_RET_ENC_SET_CONF_FAIL       = -3008,
+
+    MFC_RET_INVALID_PARAM           = -4000
+} SSBSIP_MFC_ERROR_CODE;
+
+typedef struct {
+    void *YPhyAddr;                     // [OUT] physical address of Y
+    void *CPhyAddr;                     // [OUT] physical address of CbCr
+    void *YVirAddr;                     // [OUT] virtual address of Y
+    void *CVirAddr;                     // [OUT] virtual address of CbCr
+
+    int img_width;                      // [OUT] width of real image
+    int img_height;                     // [OUT] height of real image
+    int buf_width;                      // [OUT] width aligned to 16
+    int buf_height;                     // [OUT] height alighed to 16
+
+    int timestamp_top;                  // [OUT] timestamp of top filed(This is used for interlaced stream)
+    int timestamp_bottom;               // [OUT] timestamp of bottom filed(This is used for interlaced stream)
+    int consumedByte;                   // [OUT] the number of byte consumed during decoding
+    int res_change;                     // [OUT] whether resolution is changed or not. 0: not change, 1: increased, 2: decreased
+    int crop_top_offset;                // [OUT] crop information, top_offset
+    int crop_bottom_offset;             // [OUT] crop information, bottom_offset
+    int crop_left_offset;               // [OUT] crop information, left_offset
+    int crop_right_offset;              // [OUT] crop information, right_offset
+} SSBSIP_MFC_DEC_OUTPUT_INFO;
+
+typedef struct {
+    void *YPhyAddr;                     // [IN/OUT] physical address of Y
+    void *CPhyAddr;                     // [IN/OUT] physical address of CbCr
+    void *YVirAddr;                     // [IN/OUT] virtual address of Y
+    void *CVirAddr;                     // [IN/OUT] virtual address of CbCr
+    int YSize;                          // [IN/OUT] input size of Y data
+    int CSize;                          // [IN/OUT] input size of CbCr data
+} SSBSIP_MFC_ENC_INPUT_INFO;
+
+typedef struct {
+    unsigned int dataSize;              // [OUT] encoded data size(without header)
+    unsigned int headerSize;            // [OUT] encoded header size
+    unsigned int frameType;             // [OUT] frame type of encoded stream
+    void *StrmPhyAddr;                  // [OUT] physical address of Y
+    void *StrmVirAddr;                  // [OUT] virtual address of Y
+    void *encodedYPhyAddr;              // [OUT] physical address of Y which is flushed
+    void *encodedCPhyAddr;              // [OUT] physical address of C which is flushed
+} SSBSIP_MFC_ENC_OUTPUT_INFO;
+
+typedef struct {
+    // common parameters
+    SSBSIP_MFC_CODEC_TYPE codecType;    // [IN] codec type
+    int SourceWidth;                    // [IN] width of video to be encoded
+    int SourceHeight;                   // [IN] height of video to be encoded
+    int IDRPeriod;                      // [IN] GOP number(interval of I-frame)
+    int SliceMode;                      // [IN] Multi slice mode
+    int RandomIntraMBRefresh;           // [IN] cyclic intra refresh
+    int EnableFRMRateControl;           // [IN] frame based rate control enable
+    int Bitrate;                        // [IN] rate control parameter(bit rate)
+    int FrameQp;                        // [IN] The quantization parameter of the frame
+    int FrameQp_P;                      // [IN] The quantization parameter of the P frame
+    int QSCodeMax;                      // [IN] Maximum Quantization value
+    int QSCodeMin;                      // [IN] Minimum Quantization value
+    int CBRPeriodRf;                    // [IN] Reaction coefficient parameter for rate control
+    int PadControlOn;                   // [IN] Enable padding control
+    int LumaPadVal;                     // [IN] Luma pel value used to fill padding area
+    int CbPadVal;                       // [IN] CB pel value used to fill padding area
+    int CrPadVal;                       // [IN] CR pel value used to fill padding area
+
+    // H.264 specific parameters
+    int ProfileIDC;                     // [IN] profile
+    int LevelIDC;                       // [IN] level
+    int FrameQp_B;                      // [IN] The quantization parameter of the B frame
+    int FrameRate;                      // [IN] rate control parameter(frame rate)
+    int SliceArgument;                  // [IN] MB number or byte number
+    int NumberBFrames;                  // [IN] The number of consecutive B frame inserted
+    int NumberReferenceFrames;          // [IN] The number of reference pictures used
+    int NumberRefForPframes;            // [IN] The number of reference pictures used for encoding P pictures
+    int LoopFilterDisable;              // [IN] disable the loop filter
+    int LoopFilterAlphaC0Offset;        // [IN] Alpha & C0 offset for H.264 loop filter
+    int LoopFilterBetaOffset;           // [IN] Beta offset for H.264 loop filter
+    int SymbolMode;                     // [IN] The mode of entropy coding(CABAC, CAVLC)
+    int PictureInterlace;               // [IN] Enables the interlace mode
+    int Transform8x8Mode;               // [IN] Allow 8x8 transform(This is allowed only for high profile)
+    int EnableMBRateControl;            // [IN] Enable macroblock-level rate control
+    int DarkDisable;                    // [IN] Disable adaptive rate control on dark region
+    int SmoothDisable;                  // [IN] Disable adaptive rate control on smooth region
+    int StaticDisable;                  // [IN] Disable adaptive rate control on static region
+    int ActivityDisable;                // [IN] Disable adaptive rate control on high activity region
+} SSBSIP_MFC_ENC_H264_PARAM;
+
+typedef struct {
+    // common parameters
+    SSBSIP_MFC_CODEC_TYPE codecType;    // [IN] codec type
+    int SourceWidth;                    // [IN] width of video to be encoded
+    int SourceHeight;                   // [IN] height of video to be encoded
+    int IDRPeriod;                      // [IN] GOP number(interval of I-frame)
+    int SliceMode;                      // [IN] Multi slice mode
+    int RandomIntraMBRefresh;           // [IN] cyclic intra refresh
+    int EnableFRMRateControl;           // [IN] frame based rate control enable
+    int Bitrate;                        // [IN] rate control parameter(bit rate)
+    int FrameQp;                        // [IN] The quantization parameter of the frame
+    int FrameQp_P;                      // [IN] The quantization parameter of the P frame
+    int QSCodeMax;                      // [IN] Maximum Quantization value
+    int QSCodeMin;                      // [IN] Minimum Quantization value
+    int CBRPeriodRf;                    // [IN] Reaction coefficient parameter for rate control
+    int PadControlOn;                   // [IN] Enable padding control
+    int LumaPadVal;                     // [IN] Luma pel value used to fill padding area
+    int CbPadVal;                       // [IN] CB pel value used to fill padding area
+    int CrPadVal;                       // [IN] CR pel value used to fill padding area
+
+    // MPEG4 specific parameters
+    int ProfileIDC;                     // [IN] profile
+    int LevelIDC;                       // [IN] level
+    int FrameQp_B;                      // [IN] The quantization parameter of the B frame
+    int TimeIncreamentRes;              // [IN] frame rate
+    int VopTimeIncreament;              // [IN] frame rate
+    int SliceArgument;                  // [IN] MB number or byte number
+    int NumberBFrames;                  // [IN] The number of consecutive B frame inserted
+    int DisableQpelME;                  // [IN] disable quarter-pixel motion estimation
+} SSBSIP_MFC_ENC_MPEG4_PARAM;
+
+typedef struct {
+    // common parameters
+    SSBSIP_MFC_CODEC_TYPE codecType;    // [IN] codec type
+    int SourceWidth;                    // [IN] width of video to be encoded
+    int SourceHeight;                   // [IN] height of video to be encoded
+    int IDRPeriod;                      // [IN] GOP number(interval of I-frame)
+    int SliceMode;                      // [IN] Multi slice mode
+    int RandomIntraMBRefresh;           // [IN] cyclic intra refresh
+    int EnableFRMRateControl;           // [IN] frame based rate control enable
+    int Bitrate;                        // [IN] rate control parameter(bit rate)
+    int FrameQp;                        // [IN] The quantization parameter of the frame
+    int FrameQp_P;                      // [IN] The quantization parameter of the P frame
+    int QSCodeMax;                      // [IN] Maximum Quantization value
+    int QSCodeMin;                      // [IN] Minimum Quantization value
+    int CBRPeriodRf;                    // [IN] Reaction coefficient parameter for rate control
+    int PadControlOn;                   // [IN] Enable padding control
+    int LumaPadVal;                     // [IN] Luma pel value used to fill padding area
+    int CbPadVal;                       // [IN] CB pel value used to fill padding area
+    int CrPadVal;                       // [IN] CR pel value used to fill padding area
+
+    // H.263 specific parameters
+    int FrameRate;                      // [IN] rate control parameter(frame rate)
+} SSBSIP_MFC_ENC_H263_PARAM;
+
+typedef struct {
+    int width;
+    int height;
+    int buf_width;
+    int buf_height;
+} SSBSIP_MFC_IMG_RESOLUTION;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*--------------------------------------------------------------------------------*/
+/* Format Conversion API                                                          */
+/*--------------------------------------------------------------------------------*/
+
+void tile_to_linear_4x2(unsigned char *p_linear_addr, unsigned char *p_tiled_addr, unsigned int x_size, unsigned int y_size);
+void tile_to_linear_NEON_NEW(unsigned char *p_linear_addr, unsigned char *p_tiled_addr, unsigned int x_size, unsigned int y_size);
+
+/*--------------------------------------------------------------------------------*/
+/* Decoding APIs                                                                  */
+/*--------------------------------------------------------------------------------*/
+void *SsbSipMfcDecOpen(void);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecInit(void *openHandle, SSBSIP_MFC_CODEC_TYPE codec_type, int Frameleng);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecExe(void *openHandle, int lengthBufFill);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecClose(void *openHandle);
+
+void *SsbSipMfcDecGetInBuf(void *openHandle, void **phyInBuf, int inputBufferSize);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, void *phyInBuf, void *virInBuf, int inputBufferSize);
+
+SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecGetOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info);
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetConfig(void *openHandle, SSBSIP_MFC_DEC_CONF conf_type, void *value);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcDecGetConfig(void *openHandle, SSBSIP_MFC_DEC_CONF conf_type, void *value);
+
+/*--------------------------------------------------------------------------------*/
+/* Encoding APIs                                                                  */
+/*--------------------------------------------------------------------------------*/
+void *SsbSipMfcEncOpen(void);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncInit(void *openHandle, void *param);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncExe(void *openHandle);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncClose(void *openHandle);
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info);
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetOutBuf(void *openHandle, SSBSIP_MFC_ENC_OUTPUT_INFO *output_info);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetOutBuf (void *openHandle, void *phyOutbuf, void *virOutbuf, int outputBufferSize);
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetConfig(void *openHandle, SSBSIP_MFC_ENC_CONF conf_type, void *value);
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetConfig(void *openHandle, SSBSIP_MFC_ENC_CONF conf_type, void *value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SSBSIP_MFC_API_H_ */
diff --git a/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/mfc_interface.h b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/mfc_interface.h
new file mode 100644
index 0000000..ba7f537
--- /dev/null
+++ b/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/mfc_interface.h
@@ -0,0 +1,328 @@
+/*
+ * Copyright 2010 Samsung Electronics 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.
+ */
+
+#ifndef _MFC_INTERFACE_H_
+#define _MFC_INTERFACE_H_
+
+#include "SsbSipMfcApi.h"
+
+#define IOCTL_MFC_DEC_INIT                     0x00800001
+#define IOCTL_MFC_ENC_INIT                     0x00800002
+#define IOCTL_MFC_DEC_EXE                      0x00800003
+#define IOCTL_MFC_ENC_EXE                      0x00800004
+
+#define IOCTL_MFC_GET_IN_BUF                   0x00800010
+#define IOCTL_MFC_FREE_BUF                     0x00800011
+#define IOCTL_MFC_GET_PHYS_ADDR                0x00800012
+
+#define IOCTL_MFC_SET_CONFIG                   0x00800101
+#define IOCTL_MFC_GET_CONFIG                   0x00800102
+
+/* MFC H/W support maximum 32 extra DPB */
+#define MFC_MAX_EXTRA_DPB                      5
+
+#define ENC_PROFILE_LEVEL(profile, level)      ((profile) | ((level) << 8))
+
+#define ENC_PROFILE_MPEG4_SP                   0
+#define ENC_PROFILE_MPEG4_ASP                  1
+#define ENC_PROFILE_H264_BP                    0
+#define ENC_PROFILE_H264_MAIN                  1
+#define ENC_PROFILE_H264_HIGH                  2
+
+#define ENC_RC_DISABLE                         0
+#define ENC_RC_ENABLE_MACROBLOCK               1
+#define ENC_RC_ENABLE_FRAME                    2
+
+#define ENC_RC_QBOUND(min_qp, max_qp)          ((min_qp) | ((max_qp) << 8))
+#define ENC_RC_MB_CTRL_DARK_DISABLE            (1 << 3)
+#define ENC_RC_MB_CTRL_SMOOTH_DISABLE          (1 << 2)
+#define ENC_RC_MB_CTRL_STATIC_DISABLE          (1 << 1)
+#define ENC_RC_MB_CTRL_ACTIVITY_DISABLE        (1 << 0)
+
+#define ALIGN_TO_16B(x)   ((((x) + (1 <<  4) - 1) >>  4) <<  4)
+#define ALIGN_TO_32B(x)   ((((x) + (1 <<  5) - 1) >>  5) <<  5)
+#define ALIGN_TO_64B(x)   ((((x) + (1 <<  6) - 1) >>  6) <<  6)
+#define ALIGN_TO_128B(x)  ((((x) + (1 <<  7) - 1) >>  7) <<  7)
+#define ALIGN_TO_2KB(x)   ((((x) + (1 << 11) - 1) >> 11) << 11)
+#define ALIGN_TO_4KB(x)   ((((x) + (1 << 12) - 1) >> 12) << 12)
+#define ALIGN_TO_8KB(x)   ((((x) + (1 << 13) - 1) >> 13) << 13)
+#define ALIGN_TO_64KB(x)  ((((x) + (1 << 16) - 1) >> 16) << 16)
+#define ALIGN_TO_128KB(x) ((((x) + (1 << 17) - 1) >> 17) << 17)
+
+typedef struct {
+    int luma0;    // per frame (or top field)
+    int chroma0;    // per frame (or top field)
+    int luma1;    // per frame (or bottom field)
+    int chroma1;    // per frame (or bottom field)
+} MFC_CRC_DATA;
+
+typedef enum {
+    MFC_USE_NONE = 0x00,
+    MFC_USE_YUV_BUFF = 0x01,
+    MFC_USE_STRM_BUFF = 0x10
+} mfc_interbuff_status;
+
+typedef enum {
+    MFC_UNPACKED_PB = 0,
+    MFC_PACKED_PB = 1
+} mfc_packed_mode;
+
+typedef struct tag_strm_ref_buf_arg {
+    unsigned int strm_ref_y;
+    unsigned int mv_ref_yc;
+} mfc_strm_ref_buf_arg_t;
+
+typedef struct tag_frame_buf_arg {
+    unsigned int luma;
+    unsigned int chroma;
+} mfc_frame_buf_arg_t;
+
+typedef struct {
+    SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN] codec type                                              */
+    int in_width;                        /* [IN] width of YUV420 frame to be encoded                     */
+    int in_height;                       /* [IN] height of YUV420 frame to be encoded                    */
+    int in_profile_level;                /* [IN] profile & level                                         */
+    int in_gop_num;                      /* [IN] GOP Number (interval of I-frame)                        */
+    int in_frame_qp;                     /* [IN] the quantization parameter of the frame                 */
+    int in_frame_P_qp;                   /* [IN] the quantization parameter of the P frame               */
+    int in_frame_B_qp;                   /* [IN] the quantization parameter of the B frame               */
+
+    int in_RC_frm_enable;                /* [IN] RC enable (0:disable, 1:frame level RC)                 */
+    int in_RC_framerate;                 /* [IN] RC parameter (framerate)                                */
+    int in_RC_bitrate;                   /* [IN] RC parameter (bitrate in kbps)                          */
+    int in_RC_qbound;                    /* [IN] RC parameter (Q bound)                                  */
+    int in_RC_rpara;                     /* [IN] RC parameter (Reaction Coefficient)                     */
+
+    int in_MS_mode;                      /* [IN] Multi-slice mode (0:single, 1:multiple)                 */
+    int in_MS_size;                      /* [IN] Multi-slice size (in num. of mb or byte)                */
+    int in_mb_refresh;                   /* [IN] Macroblock refresh                                      */
+    int in_interlace_mode;               /* [IN] interlace mode(0:progressive, 1:interlace)              */
+    int in_BframeNum;                    /* [IN] B frame number                                          */
+
+    int in_pad_ctrl_on;                  /* [IN] Enable (1) / Disable (0) padding                        */
+    int in_luma_pad_val;                 /* [IN] pad value if pad_ctrl_on is Enable                      */
+    int in_cb_pad_val;
+    int in_cr_pad_val;
+
+    unsigned int in_mapped_addr;
+    mfc_strm_ref_buf_arg_t out_u_addr;
+    mfc_strm_ref_buf_arg_t out_p_addr;
+    mfc_strm_ref_buf_arg_t out_buf_size;
+    unsigned int out_header_size;
+
+    /* MPEG4 Only */
+    int in_qpelME_enable;                /* [IN] Quarter-pel MC enable(1:enable, 0:disable)              */
+    int in_time_increament_res;          /* [IN] time increment resolution                               */
+    int in_time_vop_time_increament;     /* [IN] time increment                                          */
+} mfc_enc_init_mpeg4_arg_t;
+
+typedef mfc_enc_init_mpeg4_arg_t mfc_enc_init_h263_arg_t;
+
+typedef struct {
+    SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN] codec type                                              */
+    int in_width;                        /* [IN] width  of YUV420 frame to be encoded                    */
+    int in_height;                       /* [IN] height of YUV420 frame to be encoded                    */
+    int in_profile_level;                /* [IN] profile & level                                         */
+    int in_gop_num;                      /* [IN] GOP Number (interval of I-frame)                        */
+    int in_frame_qp;                     /* [IN] the quantization parameter of the frame                 */
+    int in_frame_P_qp;                   /* [IN] the quantization parameter of the P frame               */
+    int in_frame_B_qp;                   /* [IN] the quantization parameter of the B frame               */
+
+    int in_RC_frm_enable;                /* [IN] RC enable (0:disable, 1:frame level RC)                 */
+    int in_RC_framerate;                 /* [IN]  RC parameter (framerate)                               */
+    int in_RC_bitrate;                   /* [IN]  RC parameter (bitrate in kbps)                         */
+    int in_RC_qbound;                    /* [IN]  RC parameter (Q bound)                                 */
+    int in_RC_rpara;                     /* [IN]  RC parameter (Reaction Coefficient)                    */
+
+    int in_MS_mode;                      /* [IN] Multi-slice mode (0:single, 1:multiple)                 */
+    int in_MS_size;                      /* [IN] Multi-slice size (in num. of mb or byte)                */
+    int in_mb_refresh;                   /* [IN] Macroblock refresh                                      */
+    int in_interlace_mode;               /* [IN] interlace mode(0:progressive, 1:interlace)              */
+    int in_BframeNum;
+
+    int in_pad_ctrl_on;                  /* [IN] Enable padding control                                  */
+    int in_luma_pad_val;                 /* [IN] Luma pel value used to fill padding area                */
+    int in_cb_pad_val;                   /* [IN] CB pel value used to fill padding area                  */
+    int in_cr_pad_val;                   /* [IN] CR pel value used to fill padding area                  */
+
+    unsigned int in_mapped_addr;
+    mfc_strm_ref_buf_arg_t out_u_addr;
+    mfc_strm_ref_buf_arg_t out_p_addr;
+    mfc_strm_ref_buf_arg_t out_buf_size;
+    unsigned int out_header_size;
+
+    /* H264 Only */
+    int in_RC_mb_enable;                 /* [IN] RC enable (0:disable, 1:MB level RC)                    */
+    int in_reference_num;                /* [IN] The number of reference pictures used                   */
+    int in_ref_num_p;                    /* [IN] The number of reference pictures used for P pictures    */
+    int in_RC_mb_dark_disable;           /* [IN] Disable adaptive rate control on dark region            */
+    int in_RC_mb_smooth_disable;         /* [IN] Disable adaptive rate control on smooth region          */
+    int in_RC_mb_static_disable;         /* [IN] Disable adaptive rate control on static region          */
+    int in_RC_mb_activity_disable;       /* [IN] Disable adaptive rate control on static region          */
+    int in_deblock_filt;                 /* [IN] disable the loop filter                                 */
+    int in_deblock_alpha_C0;             /* [IN] Alpha & C0 offset for H.264 loop filter                 */
+    int in_deblock_beta;                 /* [IN] Beta offset for H.264 loop filter                       */
+    int in_symbolmode;                   /* [IN] The mode of entropy coding(CABAC, CAVLC)                */
+    int in_transform8x8_mode;            /* [IN] Allow 8x8 transform(only for high profile)              */
+    int in_md_interweight_pps;           /* [IN] Inter weighted parameter for mode decision              */
+    int in_md_intraweight_pps;           /* [IN] Intra weighted parameter for mode decision              */
+} mfc_enc_init_h264_arg_t;
+
+typedef struct {
+    SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN]  codec type                                             */
+    unsigned int in_Y_addr;              /* [IN]  In-buffer addr of Y component                          */
+    unsigned int in_CbCr_addr;           /* [IN]  In-buffer addr of CbCr component                       */
+    unsigned int in_Y_addr_vir;          /* [IN]  In-buffer addr of Y component                          */
+    unsigned int in_CbCr_addr_vir;       /* [IN]  In-buffer addr of CbCr component                       */
+    unsigned int in_strm_st;             /* [IN]  Out-buffer start addr of encoded strm                  */
+    unsigned int in_strm_end;            /* [IN]  Out-buffer end addr of encoded strm                    */
+    int in_frametag;                     /* [IN]  unique frame ID                                        */
+
+    unsigned int out_frame_type;         /* [OUT] frame type                                             */
+    int out_encoded_size;                /* [OUT] Length of Encoded video stream                         */
+    unsigned int out_encoded_Y_paddr;    /* [OUT] physical Y address which is flushed                    */
+    unsigned int out_encoded_C_paddr;    /* [OUT] physical C address which is flushed                    */
+    int out_frametag_top;                /* [OUT] unique frame ID of an output frame or top field        */
+    int out_frametag_bottom;             /* [OUT] unique frame ID of bottom field                        */
+} mfc_enc_exe_arg;
+
+typedef struct {
+    SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN]  codec type                                             */
+    unsigned int in_strm_buf;            /* [IN]  the physical address of STRM_BUF                       */
+    int in_strm_size;                    /* [IN]  size of video stream filled in STRM_BUF                */
+    int in_packed_PB;                    /* [IN]  Is packed PB frame or not, 1: packedPB  0: unpacked    */
+
+    int out_img_width;                   /* [OUT] width  of YUV420 frame                                 */
+    int out_img_height;                  /* [OUT] height of YUV420 frame                                 */
+    int out_buf_width;                   /* [OUT] width  of YUV420 frame                                 */
+    int out_buf_height;                  /* [OUT] height of YUV420 frame                                 */
+    int out_dpb_cnt;                     /* [OUT] the number of buffers which is nessary during decoding */
+
+    mfc_frame_buf_arg_t in_frm_buf;      /* [IN] the address of dpb FRAME_BUF                            */
+    mfc_frame_buf_arg_t in_frm_size;     /* [IN] size of dpb FRAME_BUF                                   */
+    unsigned int in_mapped_addr;
+
+    mfc_frame_buf_arg_t out_u_addr;
+    mfc_frame_buf_arg_t out_p_addr;
+    mfc_frame_buf_arg_t out_frame_buf_size;
+} mfc_dec_init_arg_t;
+
+typedef struct {
+    SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN]  codec type                                             */
+    unsigned int in_strm_buf;            /* [IN]  the physical address of STRM_BUF                       */
+    int in_strm_size;                    /* [IN]  Size of video stream filled in STRM_BUF                */
+    mfc_frame_buf_arg_t in_frm_buf;      /* [IN]  the address of dpb FRAME_BUF                           */
+    mfc_frame_buf_arg_t in_frm_size;     /* [IN]  size of dpb FRAME_BUF                                  */
+    int in_frametag;                     /* [IN]  unique frame ID                                        */
+
+    unsigned int out_display_Y_addr;     /* [OUT] the physical address of display buf                    */
+    unsigned int out_display_C_addr;     /* [OUT] the physical address of display buf                    */
+    int out_display_status;              /* [OUT] whether display frame exist or not.                    */
+    int out_timestamp_top;               /* [OUT] presentation time of an output frame or top field      */
+    int out_timestamp_bottom;            /* [OUT] presentation time of bottom field                      */
+    int out_consume_bytes;               /* [OUT] consumed bytes when decoding finished                  */
+    int out_frametag_top;                /* [OUT] unique frame ID of an output frame or top field        */
+    int out_frametag_bottom;             /* [OUT] unique frame ID of bottom field                        */
+    int out_res_change;                  /* [OUT] whether resolution is changed or not (0, 1, 2)         */
+    int out_crop_top_offset;             /* [OUT] crop information, top offset                           */
+    int out_crop_bottom_offset;          /* [OUT] crop information, bottom offset                        */
+    int out_crop_left_offset;            /* [OUT] crop information, left offset                          */
+    int out_crop_right_offset;           /* [OUT] crop information, right offset                         */
+} mfc_dec_exe_arg_t;
+
+typedef struct {
+    int in_config_param;                 /* [IN]  Configurable parameter type                            */
+    int out_config_value[4];             /* [IN]  Values to get for the configurable parameter.          */
+} mfc_get_config_arg_t;
+
+typedef struct {
+    int in_config_param;                 /* [IN]  Configurable parameter type                            */
+    int in_config_value[2];              /* [IN]  Values to be set for the configurable parameter.       */
+    int out_config_value_old[2];         /* [OUT] Old values of the configurable parameters              */
+} mfc_set_config_arg_t;
+
+typedef struct tag_get_phys_addr_arg
+{
+    unsigned int u_addr;
+    unsigned int p_addr;
+} mfc_get_phys_addr_arg_t;
+
+typedef struct tag_mem_alloc_arg
+{
+    SSBSIP_MFC_CODEC_TYPE codec_type;
+    int buff_size;
+    unsigned int mapped_addr;
+    unsigned int out_uaddr;
+    unsigned int out_paddr;
+} mfc_mem_alloc_arg_t;
+
+typedef struct tag_mem_free_arg_t
+{
+    unsigned int u_addr;
+} mfc_mem_free_arg_t;
+
+typedef union {
+    mfc_enc_init_mpeg4_arg_t enc_init_mpeg4;
+    mfc_enc_init_h263_arg_t enc_init_h263;
+    mfc_enc_init_h264_arg_t enc_init_h264;
+    mfc_enc_exe_arg enc_exe;
+
+    mfc_dec_init_arg_t dec_init;
+    mfc_dec_exe_arg_t dec_exe;
+
+    mfc_get_config_arg_t get_config;
+    mfc_set_config_arg_t set_config;
+
+    mfc_mem_alloc_arg_t mem_alloc;
+    mfc_mem_free_arg_t mem_free;
+    mfc_get_phys_addr_arg_t get_phys_addr;
+} mfc_args;
+
+typedef struct tag_mfc_args {
+    SSBSIP_MFC_ERROR_CODE ret_code; /* [OUT] error code */
+    mfc_args args;
+} mfc_common_args;
+
+typedef struct {
+    int magic;
+    int hMFC;
+    int width;
+    int height;
+    int sizeStrmBuf;
+    mfc_frame_buf_arg_t sizeFrmBuf;
+    int displayStatus;
+    int inter_buff_status;
+    unsigned int virFreeStrmAddr;
+    unsigned int phyStrmBuf;
+    unsigned int virStrmBuf;
+    unsigned int virMvRefYC;
+    mfc_frame_buf_arg_t phyFrmBuf;
+    mfc_frame_buf_arg_t virFrmBuf;
+    unsigned int mapped_addr;
+    mfc_common_args MfcArg;
+    SSBSIP_MFC_CODEC_TYPE codec_type;
+    SSBSIP_MFC_DEC_OUTPUT_INFO decOutInfo;
+    unsigned int encodedHeaderSize;
+    int encodedDataSize;
+    unsigned int encodedframeType;
+    int in_frametag;
+    int out_frametag_top;
+    int out_frametag_bottom;
+    unsigned int encoded_Y_paddr;
+    unsigned int encoded_C_paddr;
+} _MFCLIB;
+
+#endif /* _MFC_INTERFACE_H_ */
diff --git a/sec_mm/sec_omx/sec_omx_component/common/Android.mk b/sec_mm/sec_omx/sec_omx_component/common/Android.mk
new file mode 100644
index 0000000..824dd16
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/common/Android.mk
@@ -0,0 +1,24 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	SEC_OMX_Basecomponent.c \
+	SEC_OMX_Baseport.c \
+	SEC_OMX_Resourcemanager.c
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libsecbasecomponent
+
+LOCAL_CFLAGS :=
+
+LOCAL_STATIC_LIBRARIES :=
+LOCAL_SHARED_LIBRARIES := libcutils libutils
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/sec_osal
+
+include $(BUILD_STATIC_LIBRARY)
+
diff --git a/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.c b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.c
new file mode 100644
index 0000000..7bc6074
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.c
@@ -0,0 +1,1467 @@
+/*
+ *
+ * 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_Basecomponent.c
+ * @brief
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ *             Yunji Kim (yunji.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OSAL_Event.h"
+#include "SEC_OSAL_Thread.h"
+#include "SEC_OMX_Baseport.h"
+#include "SEC_OMX_Basecomponent.h"
+#include "SEC_OMX_Macros.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_BASE_COMP"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+/* Change CHECK_SIZE_VERSION Macro */
+OMX_ERRORTYPE SEC_OMX_Check_SizeVersion(OMX_PTR header, OMX_U32 size)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    OMX_VERSIONTYPE* version = NULL;
+    if (header == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    version = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
+    if (*((OMX_U32*)header) != size) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (version->s.nVersionMajor != VERSIONMAJOR_NUMBER ||
+        version->s.nVersionMinor != VERSIONMINOR_NUMBER) {
+        ret = OMX_ErrorVersionMismatch;
+        goto EXIT;
+    }
+    ret = OMX_ErrorNone;
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_GetComponentVersion(
+    OMX_IN  OMX_HANDLETYPE   hComponent,
+    OMX_OUT OMX_STRING       pComponentName,
+    OMX_OUT OMX_VERSIONTYPE *pComponentVersion,
+    OMX_OUT OMX_VERSIONTYPE *pSpecVersion,
+    OMX_OUT OMX_UUIDTYPE    *pComponentUUID)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    OMX_U32                compUUID[3];
+
+    FunctionIn();
+
+    /* check parameters */
+    if (hComponent     == NULL ||
+        pComponentName == NULL || pComponentVersion == NULL ||
+        pSpecVersion   == NULL || pComponentUUID    == 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;
+    }
+
+    SEC_OSAL_Strcpy(pComponentName, pSECComponent->componentName);
+    SEC_OSAL_Memcpy(pComponentVersion, &(pSECComponent->componentVersion), sizeof(OMX_VERSIONTYPE));
+    SEC_OSAL_Memcpy(pSpecVersion, &(pSECComponent->specVersion), sizeof(OMX_VERSIONTYPE));
+
+    /* Fill UUID with handle address, PID and UID.
+     * This should guarantee uiniqness */
+    compUUID[0] = (OMX_U32)pOMXComponent;
+    compUUID[1] = getpid();
+    compUUID[2] = getuid();
+    SEC_OSAL_Memcpy(*pComponentUUID, compUUID, 3 * sizeof(*compUUID));
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_GetState (
+    OMX_IN OMX_HANDLETYPE  hComponent,
+    OMX_OUT OMX_STATETYPE *pState)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL || pState == 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;
+
+    *pState = pSECComponent->currentState;
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_OMX_BufferProcessThread(OMX_PTR threadData)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_MESSAGE       *message = NULL;
+
+    FunctionIn();
+
+    if (threadData == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)threadData;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pSECComponent->sec_BufferProcess(pOMXComponent);
+
+    SEC_OSAL_TheadExit(NULL);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_ComponentStateSet(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 messageParam)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_MESSAGE       *message;
+    OMX_STATETYPE          destState = messageParam;
+    OMX_STATETYPE          currentState = pSECComponent->currentState;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_S32                countValue = 0;
+    int                   i = 0, j = 0;
+
+    FunctionIn();
+
+    /* check parameters */
+    if (currentState == destState) {
+         ret = OMX_ErrorSameState;
+            goto EXIT;
+    }
+    if (currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    if ((currentState == OMX_StateLoaded) && (destState == OMX_StateIdle)) {
+        ret = SEC_OMX_Get_Resource(pOMXComponent);
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+    }
+    if (((currentState == OMX_StateIdle) && (destState == OMX_StateLoaded))       ||
+        ((currentState == OMX_StateIdle) && (destState == OMX_StateInvalid))      ||
+        ((currentState == OMX_StateExecuting) && (destState == OMX_StateInvalid)) ||
+        ((currentState == OMX_StatePause) && (destState == OMX_StateInvalid))) {
+        SEC_OMX_Release_Resource(pOMXComponent);
+    }
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "destState: %d", destState);
+
+    switch (destState) {
+    case OMX_StateInvalid:
+        switch (currentState) {
+        case OMX_StateIdle:
+        case OMX_StateExecuting:
+        case OMX_StatePause:
+        case OMX_StateLoaded:
+        case OMX_StateWaitForResources:
+            pSECComponent->currentState = OMX_StateInvalid;
+            if (pSECComponent->hBufferProcess) {
+                pSECComponent->bExitBufferProcessThread = OMX_TRUE;
+                SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
+                for (i = 0; i < ALL_PORT_NUM; i++) {
+                    SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[i].bufferSemID, &countValue);
+                    if (countValue == 0)
+                        SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID);
+                }
+                for (i = 0; i < ALL_PORT_NUM; i++) {
+                    SEC_OSAL_MutexTerminate(pSECComponent->secDataBuffer[i].bufferMutex);
+                    pSECComponent->secDataBuffer[i].bufferMutex = NULL;
+                }
+                SEC_OSAL_ThreadTerminate(pSECComponent->hBufferProcess);
+                pSECComponent->hBufferProcess = NULL;
+            }
+            if (pSECComponent->sec_mfc_componentTerminate != NULL)
+                pSECComponent->sec_mfc_componentTerminate(pOMXComponent);
+            break;
+        }
+        ret = OMX_ErrorInvalidState;
+        break;
+    case OMX_StateLoaded:
+        switch (currentState) {
+        case OMX_StateIdle:
+            pSECComponent->bExitBufferProcessThread = OMX_TRUE;
+
+            for (i = 0; i < ALL_PORT_NUM; i++) {
+                SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[i].bufferSemID, &countValue);
+                if (countValue == 0)
+                    SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID);
+            }
+
+            for (i = 0; i < ALL_PORT_NUM; i++) {
+                SEC_OSAL_MutexTerminate(pSECComponent->secDataBuffer[i].bufferMutex);
+                pSECComponent->secDataBuffer[i].bufferMutex = NULL;
+            }
+
+            SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
+            SEC_OSAL_ThreadTerminate(pSECComponent->hBufferProcess);
+            pSECComponent->hBufferProcess = NULL;
+            SEC_OSAL_SignalTerminate(pSECComponent->pauseEvent);
+            for (i = 0; i > ALL_PORT_NUM; i++) {
+                SEC_OSAL_SemaphoreTerminate(pSECComponent->pSECPort[i].bufferSemID);
+                pSECComponent->pSECPort[i].bufferSemID = NULL;
+            }
+
+            pSECComponent->sec_mfc_componentTerminate(pOMXComponent);
+
+            for (i = 0; i < (pSECComponent->portParam.nPorts); i++) {
+                pSECPort = (pSECComponent->pSECPort + i);
+                if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                    while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) > 0) {
+                        message = (SEC_OMX_MESSAGE*)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+                        if (message != NULL)
+                            SEC_OSAL_Free(message);
+                    }
+                    ret = pSECComponent->sec_FreeTunnelBuffer(pSECComponent, i);
+                    if (OMX_ErrorNone != ret) {
+                        goto EXIT;
+                    }
+                } else {
+                    if (CHECK_PORT_ENABLED(pSECPort)) {
+                        SEC_OSAL_SemaphoreWait(pSECPort->unloadedResource);
+                        pSECPort->portDefinition.bPopulated = OMX_FALSE;
+                    }
+                }
+            }
+            pSECComponent->currentState = OMX_StateLoaded;
+            break;
+        case OMX_StateWaitForResources:
+            ret = SEC_OMX_Out_WaitForResource(pOMXComponent);
+            pSECComponent->currentState = OMX_StateLoaded;
+            break;
+        case OMX_StateExecuting:
+        case OMX_StatePause:
+        default:
+            ret = OMX_ErrorIncorrectStateTransition;
+            break;
+        }
+        break;
+    case OMX_StateIdle:
+        switch (currentState) {
+        case OMX_StateLoaded:
+            for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
+                pSECPort = (pSECComponent->pSECPort + i);
+                if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                    if (CHECK_PORT_ENABLED(pSECPort)) {
+                        ret = pSECComponent->sec_AllocateTunnelBuffer(pSECPort, i);
+                        if (ret!=OMX_ErrorNone)
+                            goto EXIT;
+                    }
+                } else {
+                    if (CHECK_PORT_ENABLED(pSECPort)) {
+                        SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[i].loadedResource);
+                        pSECPort->portDefinition.bPopulated = OMX_TRUE;
+                    }
+                }
+            }
+            ret = pSECComponent->sec_mfc_componentInit(pOMXComponent);
+            if (ret != OMX_ErrorNone) {
+                /*
+                 * if (CHECK_PORT_TUNNELED == OMX_TRUE) thenTunnel Buffer Free
+                 */
+                goto EXIT;
+            }
+            pSECComponent->bExitBufferProcessThread = OMX_FALSE;
+            SEC_OSAL_SignalCreate(&pSECComponent->pauseEvent);
+            for (i = 0; i < ALL_PORT_NUM; i++) {
+                SEC_OSAL_SemaphoreCreate(&pSECComponent->pSECPort[i].bufferSemID);
+            }
+            for (i = 0; i < ALL_PORT_NUM; i++) {
+                SEC_OSAL_MutexCreate(&pSECComponent->secDataBuffer[i].bufferMutex);
+            }
+            ret = SEC_OSAL_ThreadCreate(&pSECComponent->hBufferProcess,
+                             SEC_OMX_BufferProcessThread,
+                             pOMXComponent);
+            if (ret != OMX_ErrorNone) {
+                /*
+                 * if (CHECK_PORT_TUNNELED == OMX_TRUE) thenTunnel Buffer Free
+                 */
+
+                SEC_OSAL_SignalTerminate(pSECComponent->pauseEvent);
+                for (i = 0; i < ALL_PORT_NUM; i++) {
+                    SEC_OSAL_MutexTerminate(pSECComponent->secDataBuffer[i].bufferMutex);
+                    pSECComponent->secDataBuffer[i].bufferMutex = NULL;
+                }
+                for (i = 0; i > ALL_PORT_NUM; i++) {
+                    SEC_OSAL_SemaphoreTerminate(pSECComponent->pSECPort[i].bufferSemID);
+                    pSECComponent->pSECPort[i].bufferSemID = NULL;
+                }
+
+                ret = OMX_ErrorInsufficientResources;
+                goto EXIT;
+            }
+            pSECComponent->currentState = OMX_StateIdle;
+            break;
+        case OMX_StateExecuting:
+        case OMX_StatePause:
+            SEC_OMX_BufferFlushProcessNoEvent(pOMXComponent, ALL_PORT_INDEX);
+            pSECComponent->currentState = OMX_StateIdle;
+            break;
+        case OMX_StateWaitForResources:
+            pSECComponent->currentState = OMX_StateIdle;
+            break;
+        }
+        break;
+    case OMX_StateExecuting:
+        switch (currentState) {
+        case OMX_StateLoaded:
+            ret = OMX_ErrorIncorrectStateTransition;
+            break;
+        case OMX_StateIdle:
+            for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
+                pSECPort = &pSECComponent->pSECPort[i];
+                if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort) && CHECK_PORT_ENABLED(pSECPort)) {
+                    for (j = 0; j < pSECPort->tunnelBufferNum; j++) {
+                        SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID);
+                    }
+                }
+            }
+
+            pSECComponent->transientState = SEC_OMX_TransStateMax;
+            pSECComponent->currentState = OMX_StateExecuting;
+            SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
+            break;
+        case OMX_StatePause:
+            for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
+                pSECPort = &pSECComponent->pSECPort[i];
+                if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort) && CHECK_PORT_ENABLED(pSECPort)) {
+                    OMX_U32 semaValue = 0, cnt = 0;
+                    SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[i].bufferSemID, &semaValue);
+                    if (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) > semaValue) {
+                        cnt = SEC_OSAL_GetElemNum(&pSECPort->bufferQ) - semaValue;
+                        for (j = 0; j < cnt; j++) {
+                            SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID);
+                        }
+                    }
+                }
+            }
+
+            pSECComponent->currentState = OMX_StateExecuting;
+            SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
+            break;
+        case OMX_StateWaitForResources:
+            ret = OMX_ErrorIncorrectStateTransition;
+            break;
+        }
+        break;
+    case OMX_StatePause:
+        switch (currentState) {
+        case OMX_StateLoaded:
+            ret = OMX_ErrorIncorrectStateTransition;
+            break;
+        case OMX_StateIdle:
+            pSECComponent->currentState = OMX_StatePause;
+            break;
+        case OMX_StateExecuting:
+            pSECComponent->currentState = OMX_StatePause;
+            break;
+        case OMX_StateWaitForResources:
+            ret = OMX_ErrorIncorrectStateTransition;
+            break;
+        }
+        break;
+    case OMX_StateWaitForResources:
+        switch (currentState) {
+        case OMX_StateLoaded:
+            ret = SEC_OMX_In_WaitForResource(pOMXComponent);
+            pSECComponent->currentState = OMX_StateWaitForResources;
+            break;
+        case OMX_StateIdle:
+        case OMX_StateExecuting:
+        case OMX_StatePause:
+            ret = OMX_ErrorIncorrectStateTransition;
+            break;
+        }
+        break;
+    }
+
+EXIT:
+    if (ret == OMX_ErrorNone) {
+        if (pSECComponent->pCallbacks != NULL) {
+            pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
+            pSECComponent->callbackData,
+            OMX_EventCmdComplete, OMX_CommandStateSet,
+            destState, NULL);
+        }
+    } else {
+        if (pSECComponent->pCallbacks != NULL) {
+            pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
+            pSECComponent->callbackData,
+            OMX_EventError, ret, 0, NULL);
+        }
+    }
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_OMX_MessageHandlerThread(OMX_PTR threadData)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_MESSAGE       *message = NULL;
+    OMX_U32                messageType = 0, portIndex = 0;
+
+    FunctionIn();
+
+    if (threadData == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pOMXComponent = (OMX_COMPONENTTYPE *)threadData;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    while (pSECComponent->bExitMessageHandlerThread != OMX_TRUE) {
+        SEC_OSAL_SemaphoreWait(pSECComponent->msgSemaphoreHandle);
+        message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECComponent->messageQ);
+        if (message != NULL) {
+            messageType = message->messageType;
+            switch (messageType) {
+            case OMX_CommandStateSet:
+                ret = SEC_OMX_ComponentStateSet(pOMXComponent, message->messageParam);
+                break;
+            case OMX_CommandFlush:
+                ret = SEC_OMX_BufferFlushProcess(pOMXComponent, message->messageParam);
+                break;
+            case OMX_CommandPortDisable:
+                ret = SEC_OMX_PortDisableProcess(pOMXComponent, message->messageParam);
+                break;
+            case OMX_CommandPortEnable:
+                ret = SEC_OMX_PortEnableProcess(pOMXComponent, message->messageParam);
+                break;
+            case OMX_CommandMarkBuffer:
+                portIndex = message->messageParam;
+                pSECComponent->pSECPort[portIndex].markType.hMarkTargetComponent = ((OMX_MARKTYPE *)message->pCmdData)->hMarkTargetComponent;
+                pSECComponent->pSECPort[portIndex].markType.pMarkData            = ((OMX_MARKTYPE *)message->pCmdData)->pMarkData;
+                break;
+            case (OMX_COMMANDTYPE)SEC_OMX_CommandComponentDeInit:
+                pSECComponent->bExitMessageHandlerThread = OMX_TRUE;
+                break;
+            default:
+                break;
+            }
+            SEC_OSAL_Free(message);
+            message = NULL;
+        }
+    }
+
+    SEC_OSAL_TheadExit(NULL);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_StateSet(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
+{
+    OMX_U32 destState = nParam;
+    OMX_U32 i = 0;
+
+    if ((destState == OMX_StateIdle) && (pSECComponent->currentState == OMX_StateLoaded)) {
+        pSECComponent->transientState = SEC_OMX_TransStateLoadedToIdle;
+        for(i = 0; i < pSECComponent->portParam.nPorts; i++) {
+            pSECComponent->pSECPort[i].portState = OMX_StateIdle;
+        }
+        SEC_OSAL_Log(SEC_LOG_TRACE, "to OMX_StateIdle");
+    } else if ((destState == OMX_StateLoaded) && (pSECComponent->currentState == OMX_StateIdle)) {
+        pSECComponent->transientState = SEC_OMX_TransStateIdleToLoaded;
+        for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
+            pSECComponent->pSECPort[i].portState = OMX_StateLoaded;
+        }
+        SEC_OSAL_Log(SEC_LOG_TRACE, "to OMX_StateLoaded");
+    } else if ((destState == OMX_StateIdle) && (pSECComponent->currentState == OMX_StateExecuting)) {
+        pSECComponent->transientState = SEC_OMX_TransStateExecutingToIdle;
+        SEC_OSAL_Log(SEC_LOG_TRACE, "to OMX_StateIdle");
+    } else if ((destState == OMX_StateExecuting) && (pSECComponent->currentState == OMX_StateIdle)) {
+        pSECComponent->transientState = SEC_OMX_TransStateIdleToExecuting;
+        SEC_OSAL_Log(SEC_LOG_TRACE, "to OMX_StateExecuting");
+    } else if (destState == OMX_StateInvalid) {
+        for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
+            pSECComponent->pSECPort[i].portState = OMX_StateInvalid;
+        }
+    }
+
+    return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE SEC_SetPortFlush(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
+{
+    OMX_ERRORTYPE     ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT *pSECPort = NULL;
+    OMX_U32           portIndex = nParam;
+    OMX_U16           i = 0, cnt = 0;
+
+
+    if ((pSECComponent->currentState == OMX_StateExecuting) ||
+        (pSECComponent->currentState == OMX_StatePause)) {
+        if ((portIndex != ALL_PORT_INDEX) &&
+           ((OMX_S32)portIndex >= (OMX_S32)pSECComponent->portParam.nPorts)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        /*********************
+        *    need flush event set ?????
+        **********************/
+
+    } else {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+    ret = OMX_ErrorNone;
+
+EXIT:
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_SetPortEnable(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
+{
+    OMX_ERRORTYPE     ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT *pSECPort = NULL;
+    OMX_U32           portIndex = nParam;
+    OMX_U16           i = 0, cnt = 0;
+
+    FunctionIn();
+
+    if ((portIndex != ALL_PORT_INDEX) &&
+        ((OMX_S32)portIndex >= (OMX_S32)pSECComponent->portParam.nPorts)) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    if (portIndex == ALL_PORT_INDEX) {
+        for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
+            pSECPort = &pSECComponent->pSECPort[i];
+            if (CHECK_PORT_ENABLED(pSECPort)) {
+                ret = OMX_ErrorIncorrectStateOperation;
+                goto EXIT;
+            } else {
+                pSECPort->portState = OMX_StateIdle;
+            }
+        }
+    } else {
+        pSECPort = &pSECComponent->pSECPort[portIndex];
+        if (CHECK_PORT_ENABLED(pSECPort)) {
+            ret = OMX_ErrorIncorrectStateOperation;
+            goto EXIT;
+        } else {
+            pSECPort->portState = OMX_StateIdle;
+        }
+    }
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+
+}
+
+static OMX_ERRORTYPE SEC_SetPortDisable(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
+{
+    OMX_ERRORTYPE     ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT *pSECPort = NULL;
+    OMX_U32           portIndex = nParam;
+    OMX_U16           i = 0, cnt = 0;
+
+    FunctionIn();
+
+    if ((portIndex != ALL_PORT_INDEX) &&
+        ((OMX_S32)portIndex >= (OMX_S32)pSECComponent->portParam.nPorts)) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    if (portIndex == ALL_PORT_INDEX) {
+        for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
+            pSECPort = &pSECComponent->pSECPort[i];
+            if (!CHECK_PORT_ENABLED(pSECPort)) {
+                ret = OMX_ErrorIncorrectStateOperation;
+                goto EXIT;
+            }
+            pSECPort->portState = OMX_StateLoaded;
+        }
+    } else {
+        pSECPort = &pSECComponent->pSECPort[portIndex];
+        pSECPort->portState = OMX_StateLoaded;
+    }
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_SetMarkBuffer(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
+{
+    OMX_ERRORTYPE     ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT *pSECPort = NULL;
+    OMX_U32           portIndex = nParam;
+    OMX_U16           i = 0, cnt = 0;
+
+
+    if (nParam >= pSECComponent->portParam.nPorts) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    if ((pSECComponent->currentState == OMX_StateExecuting) ||
+        (pSECComponent->currentState == OMX_StatePause)) {
+        ret = OMX_ErrorNone;
+    } else {
+        ret = OMX_ErrorIncorrectStateOperation;
+    }
+
+EXIT:
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_OMX_CommandQueue(
+    SEC_OMX_BASECOMPONENT *pSECComponent,
+    OMX_COMMANDTYPE        Cmd,
+    OMX_U32                nParam,
+    OMX_PTR                pCmdData)
+{
+    OMX_ERRORTYPE    ret = OMX_ErrorNone;
+    SEC_OMX_MESSAGE *command = (SEC_OMX_MESSAGE *)SEC_OSAL_Malloc(sizeof(SEC_OMX_MESSAGE));
+
+    if (command == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    command->messageType  = (OMX_U32)Cmd;
+    command->messageParam = nParam;
+    command->pCmdData     = pCmdData;
+
+    ret = SEC_OSAL_Queue(&pSECComponent->messageQ, (void *)command);
+    if (ret != 0) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+    ret = SEC_OSAL_SemaphorePost(pSECComponent->msgSemaphoreHandle);
+
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_SendCommand(
+    OMX_IN OMX_HANDLETYPE  hComponent,
+    OMX_IN OMX_COMMANDTYPE Cmd,
+    OMX_IN OMX_U32         nParam,
+    OMX_IN OMX_PTR         pCmdData)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_MESSAGE       *message = 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 (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (Cmd) {
+    case OMX_CommandStateSet :
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandStateSet");
+        SEC_StateSet(pSECComponent, nParam);
+        break;
+    case OMX_CommandFlush :
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandFlush");
+        ret = SEC_SetPortFlush(pSECComponent, nParam);
+        if (ret != OMX_ErrorNone)
+            goto EXIT;
+        break;
+    case OMX_CommandPortDisable :
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandPortDisable");
+        ret = SEC_SetPortDisable(pSECComponent, nParam);
+        if (ret != OMX_ErrorNone)
+            goto EXIT;
+        break;
+    case OMX_CommandPortEnable :
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandPortEnable");
+        ret = SEC_SetPortEnable(pSECComponent, nParam);
+        if (ret != OMX_ErrorNone)
+            goto EXIT;
+        break;
+    case OMX_CommandMarkBuffer :
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandMarkBuffer");
+        ret = SEC_SetMarkBuffer(pSECComponent, nParam);
+        if (ret != OMX_ErrorNone)
+            goto EXIT;
+        break;
+/*
+    case SEC_CommandFillBuffer :
+    case SEC_CommandEmptyBuffer :
+    case SEC_CommandDeInit :
+*/
+    default:
+        break;
+    }
+
+    ret = SEC_OMX_CommandQueue(pSECComponent, Cmd, nParam, pCmdData);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_GetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nParamIndex,
+    OMX_INOUT OMX_PTR     ComponentParameterStructure)
+{
+    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 (ComponentParameterStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (nParamIndex) {
+    case (OMX_INDEXTYPE)OMX_COMPONENT_CAPABILITY_TYPE_INDEX:
+    {
+        /* For Android PV OpenCORE */
+        OMXComponentCapabilityFlagsType *capabilityFlags = (OMXComponentCapabilityFlagsType *)ComponentParameterStructure;
+        SEC_OSAL_Memcpy(capabilityFlags, &pSECComponent->capabilityFlags, sizeof(OMXComponentCapabilityFlagsType));
+    }
+        break;
+    case OMX_IndexParamAudioInit:
+    case OMX_IndexParamVideoInit:
+    case OMX_IndexParamImageInit:
+    case OMX_IndexParamOtherInit:
+    {
+        OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
+        ret = SEC_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+        portParam->nPorts         = 0;
+        portParam->nStartPortNumber     = 0;
+    }
+        break;
+    case OMX_IndexParamPortDefinition:
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
+        OMX_U32                       portIndex = portDefinition->nPortIndex;
+        SEC_OMX_BASEPORT             *pSECPort;
+
+        if (portIndex >= pSECComponent->portParam.nPorts) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+        ret = SEC_OMX_Check_SizeVersion(portDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        pSECPort = &pSECComponent->pSECPort[portIndex];
+        SEC_OSAL_Memcpy(portDefinition, &pSECPort->portDefinition, portDefinition->nSize);
+    }
+        break;
+    case OMX_IndexParamPriorityMgmt:
+    {
+        OMX_PRIORITYMGMTTYPE *compPriority = (OMX_PRIORITYMGMTTYPE *)ComponentParameterStructure;
+
+        ret = SEC_OMX_Check_SizeVersion(compPriority, sizeof(OMX_PRIORITYMGMTTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        compPriority->nGroupID       = pSECComponent->compPriority.nGroupID;
+        compPriority->nGroupPriority = pSECComponent->compPriority.nGroupPriority;
+    }
+        break;
+
+    case OMX_IndexParamCompBufferSupplier:
+    {
+        OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE *)ComponentParameterStructure;
+        OMX_U32                       portIndex = bufferSupplier->nPortIndex;
+        SEC_OMX_BASEPORT             *pSECPort;
+
+        if ((pSECComponent->currentState == OMX_StateLoaded) ||
+            (pSECComponent->currentState == OMX_StateWaitForResources)) {
+            if (portIndex >= pSECComponent->portParam.nPorts) {
+                ret = OMX_ErrorBadPortIndex;
+                goto EXIT;
+            }
+            ret = SEC_OMX_Check_SizeVersion(bufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
+            if (ret != OMX_ErrorNone) {
+                goto EXIT;
+            }
+
+            pSECPort = &pSECComponent->pSECPort[portIndex];
+
+
+            if (pSECPort->portDefinition.eDir == OMX_DirInput) {
+                if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                    bufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
+                } else if (CHECK_PORT_TUNNELED(pSECPort)) {
+                    bufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
+                } else {
+                    bufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
+                }
+            } else {
+                if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                    bufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
+                } else if (CHECK_PORT_TUNNELED(pSECPort)) {
+                    bufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
+                } else {
+                    bufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
+                }
+            }
+        }
+        else
+        {
+            ret = OMX_ErrorIncorrectStateOperation;
+            goto EXIT;
+        }
+    }
+        break;
+    default:
+    {
+        ret = OMX_ErrorUnsupportedIndex;
+        goto EXIT;
+    }
+        break;
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_SetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nIndex,
+    OMX_IN OMX_PTR        ComponentParameterStructure)
+{
+    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 (ComponentParameterStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexParamAudioInit:
+    case OMX_IndexParamVideoInit:
+    case OMX_IndexParamImageInit:
+    case OMX_IndexParamOtherInit:
+    {
+        OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
+        ret = SEC_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if ((pSECComponent->currentState != OMX_StateLoaded) &&
+            (pSECComponent->currentState != OMX_StateWaitForResources)) {
+            ret = OMX_ErrorIncorrectStateOperation;
+            goto EXIT;
+        }
+        ret = OMX_ErrorUndefined;
+        /* SEC_OSAL_Memcpy(&pSECComponent->portParam, portParam, sizeof(OMX_PORT_PARAM_TYPE)); */
+    }
+        break;
+    case OMX_IndexParamPortDefinition:
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
+        OMX_U32               portIndex = portDefinition->nPortIndex;
+        SEC_OMX_BASEPORT         *pSECPort;
+
+        if (portIndex >= pSECComponent->portParam.nPorts) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+        ret = SEC_OMX_Check_SizeVersion(portDefinition, 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 (portDefinition->nBufferCountActual < pSECPort->portDefinition.nBufferCountMin) {
+            ret = OMX_ErrorBadParameter;
+            goto EXIT;
+        }
+
+        SEC_OSAL_Memcpy(&pSECPort->portDefinition, portDefinition, portDefinition->nSize);
+    }
+        break;
+    case OMX_IndexParamPriorityMgmt:
+    {
+        OMX_PRIORITYMGMTTYPE *compPriority = (OMX_PRIORITYMGMTTYPE *)ComponentParameterStructure;
+
+        if ((pSECComponent->currentState != OMX_StateLoaded) &&
+            (pSECComponent->currentState != OMX_StateWaitForResources)) {
+            ret = OMX_ErrorIncorrectStateOperation;
+            goto EXIT;
+        }
+
+        ret = SEC_OMX_Check_SizeVersion(compPriority, sizeof(OMX_PRIORITYMGMTTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        pSECComponent->compPriority.nGroupID = compPriority->nGroupID;
+        pSECComponent->compPriority.nGroupPriority = compPriority->nGroupPriority;
+    }
+        break;
+    case OMX_IndexParamCompBufferSupplier:
+    {
+        OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE *)ComponentParameterStructure;
+        OMX_U32               portIndex = bufferSupplier->nPortIndex;
+        SEC_OMX_BASEPORT         *pSECPort;
+
+        if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
+            if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
+                ret = OMX_ErrorIncorrectStateOperation;
+                goto EXIT;
+            }
+        }
+
+        if (portIndex >= pSECComponent->portParam.nPorts) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+        ret = SEC_OMX_Check_SizeVersion(bufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        pSECPort = &pSECComponent->pSECPort[portIndex];
+        if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyUnspecified) {
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+        if (CHECK_PORT_TUNNELED(pSECPort) == 0) {
+            ret = OMX_ErrorNone; /*OMX_ErrorNone ?????*/
+            goto EXIT;
+        }
+
+        if (pSECPort->portDefinition.eDir == OMX_DirInput) {
+            if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) {
+                /*
+                if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                    ret = OMX_ErrorNone;
+                }
+                */
+                pSECPort->tunnelFlags |= SEC_TUNNEL_IS_SUPPLIER;
+                bufferSupplier->nPortIndex = pSECPort->tunneledPort;
+                ret = OMX_SetParameter(pSECPort->tunneledComponent, OMX_IndexParamCompBufferSupplier, bufferSupplier);
+                goto EXIT;
+            } else if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) {
+                ret = OMX_ErrorNone;
+                if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                    pSECPort->tunnelFlags &= ~SEC_TUNNEL_IS_SUPPLIER;
+                    bufferSupplier->nPortIndex = pSECPort->tunneledPort;
+                    ret = OMX_SetParameter(pSECPort->tunneledComponent, OMX_IndexParamCompBufferSupplier, bufferSupplier);
+                }
+                goto EXIT;
+            }
+        } else if (pSECPort->portDefinition.eDir == OMX_DirOutput) {
+            if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) {
+                ret = OMX_ErrorNone;
+                if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                    pSECPort->tunnelFlags &= ~SEC_TUNNEL_IS_SUPPLIER;
+                    ret = OMX_ErrorNone;
+                }
+                goto EXIT;
+            } else if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) {
+                /*
+                if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                    ret = OMX_ErrorNone;
+                }
+                */
+                pSECPort->tunnelFlags |= SEC_TUNNEL_IS_SUPPLIER;
+                ret = OMX_ErrorNone;
+                goto EXIT;
+            }
+        }
+    }
+        break;
+    default:
+    {
+        ret = OMX_ErrorUnsupportedIndex;
+        goto EXIT;
+    }
+        break;
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_GetConfig(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nIndex,
+    OMX_INOUT 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;
+    }
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_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) {
+        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;
+    }
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_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;
+    }
+
+    ret = OMX_ErrorBadParameter;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_SetCallbacks (
+    OMX_IN OMX_HANDLETYPE    hComponent,
+    OMX_IN OMX_CALLBACKTYPE* pCallbacks,
+    OMX_IN OMX_PTR           pAppData)
+{
+    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 (pCallbacks == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState != OMX_StateLoaded) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+
+    pSECComponent->pCallbacks = pCallbacks;
+    pSECComponent->callbackData = pAppData;
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_UseEGLImage(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN void                     *eglImage)
+{
+    return OMX_ErrorNotImplemented;
+}
+
+OMX_ERRORTYPE SEC_OMX_BaseComponent_Constructor(
+    OMX_IN OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    pSECComponent = SEC_OSAL_Malloc(sizeof(SEC_OMX_BASECOMPONENT));
+    if (pSECComponent == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECComponent, 0, sizeof(SEC_OMX_BASECOMPONENT));
+    pOMXComponent->pComponentPrivate = (OMX_PTR)pSECComponent;
+
+    ret = SEC_OSAL_SemaphoreCreate(&pSECComponent->msgSemaphoreHandle);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    ret = SEC_OSAL_MutexCreate(&pSECComponent->compMutex);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    pSECComponent->bExitMessageHandlerThread = OMX_FALSE;
+    SEC_OSAL_QueueCreate(&pSECComponent->messageQ);
+    ret = SEC_OSAL_ThreadCreate(&pSECComponent->hMessageHandler, SEC_OMX_MessageHandlerThread, pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    pOMXComponent->GetComponentVersion = &SEC_OMX_GetComponentVersion;
+    pOMXComponent->SendCommand         = &SEC_OMX_SendCommand;
+    pOMXComponent->GetConfig           = &SEC_OMX_GetConfig;
+    pOMXComponent->GetExtensionIndex   = &SEC_OMX_GetExtensionIndex;
+    pOMXComponent->GetState            = &SEC_OMX_GetState;
+    pOMXComponent->SetCallbacks        = &SEC_OMX_SetCallbacks;
+    pOMXComponent->UseEGLImage         = &SEC_OMX_UseEGLImage;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_BaseComponent_Destructor(
+    OMX_IN OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    OMX_U32                semaValue = 0;
+
+    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;
+
+    SEC_OMX_CommandQueue(pSECComponent, SEC_OMX_CommandComponentDeInit, 0, NULL);
+    SEC_OSAL_SleepMillisec(0);
+    SEC_OSAL_Get_SemaphoreCount(pSECComponent->msgSemaphoreHandle, &semaValue);
+    if (semaValue == 0)
+        SEC_OSAL_SemaphorePost(pSECComponent->msgSemaphoreHandle);
+    SEC_OSAL_SemaphorePost(pSECComponent->msgSemaphoreHandle);
+
+    SEC_OSAL_ThreadTerminate(pSECComponent->hMessageHandler);
+    pSECComponent->hMessageHandler = NULL;
+
+    SEC_OSAL_MutexTerminate(pSECComponent->compMutex);
+    pSECComponent->compMutex = NULL;
+    SEC_OSAL_SemaphoreTerminate(pSECComponent->msgSemaphoreHandle);
+    pSECComponent->msgSemaphoreHandle = NULL;
+    SEC_OSAL_QueueTerminate(&pSECComponent->messageQ);
+
+    SEC_OSAL_Free(pSECComponent);
+    pSECComponent = NULL;
+
+    ret = OMX_ErrorNone;
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+
diff --git a/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.h b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.h
new file mode 100644
index 0000000..ac9872b
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.h
@@ -0,0 +1,153 @@
+/*
+ *
+ * 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_Basecomponent.h
+ * @brief
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ *             Yunji Kim (yunji.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_BASECOMP
+#define SEC_OMX_BASECOMP
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Component.h"
+#include "SEC_OSAL_Queue.h"
+#include "SEC_OMX_Baseport.h"
+
+
+typedef struct _SEC_OMX_MESSAGE
+{
+    OMX_U32 messageType;
+    OMX_U32 messageParam;
+    OMX_PTR pCmdData;
+} SEC_OMX_MESSAGE;
+
+typedef struct _SEC_OMX_DATABUFFER
+{
+    OMX_HANDLETYPE        bufferMutex;
+    OMX_BUFFERHEADERTYPE* bufferHeader;
+    OMX_BOOL              dataValid;
+    OMX_U32               allocSize;
+    OMX_U32               dataLen;
+    OMX_U32               usedDataLen;
+    OMX_U32               remainDataLen;
+    OMX_U32               nFlags;
+    OMX_TICKS             timeStamp;
+} SEC_OMX_DATABUFFER;
+
+typedef struct _SEC_BUFFER_HEADER{
+    void *YPhyAddr; // [IN/OUT] physical address of Y
+    void *CPhyAddr; // [IN/OUT] physical address of CbCr
+    void *YVirAddr; // [IN/OUT] virtual address of Y
+    void *CVirAddr; // [IN/OUT] virtual address of CbCr
+    int YSize;      // [IN/OUT] input size of Y data
+    int CSize;      // [IN/OUT] input size of CbCr data
+} SEC_BUFFER_HEADER;
+
+typedef struct _SEC_OMX_DATA
+{
+    OMX_BYTE  dataBuffer;
+    OMX_U32   allocSize;
+    OMX_U32   dataLen;
+    OMX_U32   usedDataLen;
+    OMX_U32   remainDataLen;
+    OMX_U32   nFlags;
+    OMX_TICKS timeStamp;
+    SEC_BUFFER_HEADER specificBufferHeader;
+} SEC_OMX_DATA;
+
+typedef struct _SEC_OMX_BASECOMPONENT
+{
+    OMX_STRING               componentName;
+    OMX_VERSIONTYPE          componentVersion;
+    OMX_VERSIONTYPE          specVersion;
+
+    OMX_STATETYPE            currentState;
+    SEC_OMX_TRANS_STATETYPE  transientState;
+
+    SEC_CODEC_TYPE           codecType;
+    SEC_OMX_PRIORITYMGMTTYPE compPriority;
+    OMX_MARKTYPE             propagateMarkType;
+    OMX_HANDLETYPE           compMutex;
+
+    OMX_HANDLETYPE           hCodecHandle;
+
+    /* Message Handler */
+    OMX_BOOL                 bExitMessageHandlerThread;
+    OMX_HANDLETYPE           hMessageHandler;
+    OMX_HANDLETYPE           msgSemaphoreHandle;
+    SEC_QUEUE                messageQ;
+
+    /* Buffer Process */
+    OMX_BOOL                 bExitBufferProcessThread;
+    OMX_HANDLETYPE           hBufferProcess;
+
+    /* Buffer */
+    SEC_OMX_DATABUFFER       secDataBuffer[2];
+
+    /* Data */
+    SEC_OMX_DATA             processData[2];
+
+    /* Port */
+    OMX_PORT_PARAM_TYPE      portParam;
+    SEC_OMX_BASEPORT        *pSECPort;
+
+    OMX_HANDLETYPE           pauseEvent;
+
+    /* Callback function */
+    OMX_CALLBACKTYPE        *pCallbacks;
+    OMX_PTR                  callbackData;
+
+    /* Android CapabilityFlags */
+    OMXComponentCapabilityFlagsType capabilityFlags;
+
+    OMX_BOOL bUseFlagEOF;
+    OMX_BOOL bSaveFlagEOS;
+
+    OMX_ERRORTYPE (*sec_mfc_componentInit)(OMX_COMPONENTTYPE *pOMXComponent);
+    OMX_ERRORTYPE (*sec_mfc_componentTerminate)(OMX_COMPONENTTYPE *pOMXComponent);
+    OMX_ERRORTYPE (*sec_mfc_bufferProcess) (OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData);
+
+    OMX_ERRORTYPE (*sec_AllocateTunnelBuffer)(SEC_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex);
+    OMX_ERRORTYPE (*sec_FreeTunnelBuffer)(SEC_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex);
+    OMX_ERRORTYPE (*sec_BufferProcess)(OMX_HANDLETYPE hComponent);
+    OMX_ERRORTYPE (*sec_BufferReset)(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex);
+    OMX_ERRORTYPE (*sec_InputBufferReturn)(OMX_COMPONENTTYPE *pOMXComponent);
+    OMX_ERRORTYPE (*sec_OutputBufferReturn)(OMX_COMPONENTTYPE *pOMXComponent);
+
+    int (*sec_checkInputFrame)(unsigned char *pInputStream, int buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame);
+
+} SEC_OMX_BASECOMPONENT;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    OMX_ERRORTYPE SEC_OMX_Check_SizeVersion(OMX_PTR header, OMX_U32 size);
+
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.c b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.c
new file mode 100644
index 0000000..092b16d
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.c
@@ -0,0 +1,959 @@
+/*
+ *
+ * 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_Baseport.c
+ * @brief
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ *             HyeYeon Chung (hyeon.chung@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OMX_Macros.h"
+#include "SEC_OSAL_Event.h"
+#include "SEC_OSAL_Semaphore.h"
+#include "SEC_OSAL_Mutex.h"
+
+#include "SEC_OMX_Baseport.h"
+#include "SEC_OMX_Basecomponent.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_BASE_PORT"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+OMX_ERRORTYPE SEC_OMX_FlushPort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE  *bufferHeader = NULL;
+    SEC_OMX_MESSAGE       *message = NULL;
+    OMX_U32                flushNum = 0;
+    OMX_S32                semValue = 0;
+
+    FunctionIn();
+
+    pSECPort = &pSECComponent->pSECPort[portIndex];
+    flushNum = SEC_OSAL_GetElemNum(&pSECPort->bufferQ);
+
+    while ((flushNum--) > 0) {
+        SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[portIndex].bufferSemID, &semValue);
+        if (semValue == 0)
+            SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[portIndex].bufferSemID);
+        SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[portIndex].bufferSemID);
+
+        message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+        if (message != NULL) {
+            bufferHeader = (OMX_BUFFERHEADERTYPE *)message->pCmdData;
+            bufferHeader->nFilledLen = 0;
+
+            if (CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                if (portIndex) {
+                    OMX_EmptyThisBuffer(pSECPort->tunneledComponent, bufferHeader);
+                } else {
+                    OMX_FillThisBuffer(pSECPort->tunneledComponent, bufferHeader);
+                }
+                SEC_OSAL_Free(message);
+                message = NULL;
+            } else if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                SEC_OSAL_Queue(&pSECPort->bufferQ, pSECPort);
+            } else {
+                if (portIndex == OUTPUT_PORT_INDEX) {
+                    pSECComponent->pCallbacks->FillBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+                } else {
+                    pSECComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+                }
+
+                SEC_OSAL_Free(message);
+                message = NULL;
+            }
+        }
+    }
+
+    if (pSECComponent->secDataBuffer[portIndex].dataValid == OMX_TRUE) {
+        if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+            message = SEC_OSAL_Malloc(sizeof(SEC_OMX_MESSAGE));
+            message->pCmdData = pSECComponent->secDataBuffer[portIndex].bufferHeader;
+            message->messageType = 0;
+            message->messageParam = -1;
+            SEC_OSAL_Queue(&pSECPort->bufferQ, message);
+            pSECComponent->sec_BufferReset(pOMXComponent, portIndex);
+        } else {
+            if (portIndex == INPUT_PORT_INDEX)
+                pSECComponent->sec_InputBufferReturn(pOMXComponent);
+            else if (portIndex == OUTPUT_PORT_INDEX)
+                pSECComponent->sec_OutputBufferReturn(pOMXComponent);
+        }
+    }
+
+    if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) < pSECPort->assignedBufferNum) {
+            SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[portIndex].bufferSemID);
+        }
+    }
+
+    while(1) {
+        int cnt;
+        SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[portIndex].bufferSemID, &cnt);
+        if (cnt == 0)
+            break;
+        SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[portIndex].bufferSemID);
+    }
+
+/*    pSECComponent->processData[portIndex].dataLen       = 0; */
+    pSECComponent->processData[portIndex].nFlags        = 0;
+/*    pSECComponent->processData[portIndex].remainDataLen = 0; */
+/*    pSECComponent->processData[portIndex].timeStamp     = 0; */
+/*    pSECComponent->processData[portIndex].usedDataLen   = 0; */
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_BufferFlushProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_S32                portIndex = 0;
+    OMX_U32                i = 0, cnt = 0;
+    SEC_OMX_DATABUFFER    *flushBuffer = NULL;
+
+    FunctionIn();
+
+    if (pOMXComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    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;
+
+    cnt = (nPortIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
+
+    for (i = 0; i < cnt; i++) {
+        if (nPortIndex == ALL_PORT_INDEX)
+            portIndex = i;
+        else
+            portIndex = nPortIndex;
+
+        pSECComponent->pSECPort[portIndex].bIsPortFlushed = OMX_TRUE;
+
+        SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
+
+        flushBuffer = &pSECComponent->secDataBuffer[portIndex];
+
+        SEC_OSAL_MutexLock(flushBuffer->bufferMutex);
+        ret = SEC_OMX_FlushPort(pOMXComponent, portIndex);
+        SEC_OSAL_MutexUnlock(flushBuffer->bufferMutex);
+
+        pSECComponent->pSECPort[portIndex].bIsPortFlushed = OMX_FALSE;
+
+        if (ret == OMX_ErrorNone) {
+            SEC_OSAL_Log(SEC_LOG_TRACE,"OMX_CommandFlush EventCmdComplete");
+            pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
+                            pSECComponent->callbackData,
+                            OMX_EventCmdComplete,
+                            OMX_CommandFlush, portIndex, NULL);
+        }
+    }
+
+EXIT:
+    if (ret != OMX_ErrorNone) {
+            pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                            pSECComponent->callbackData,
+                            OMX_EventError,
+                            ret, 0, NULL);
+    }
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_BufferFlushProcessNoEvent(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_S32                portIndex = 0;
+    OMX_U32                i = 0, cnt = 0;
+    SEC_OMX_DATABUFFER    *flushBuffer = NULL;
+
+    FunctionIn();
+
+    if (pOMXComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    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;
+
+    cnt = (nPortIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
+
+    for (i = 0; i < cnt; i++) {
+        if (nPortIndex == ALL_PORT_INDEX)
+            portIndex = i;
+        else
+            portIndex = nPortIndex;
+
+        pSECComponent->pSECPort[portIndex].bIsPortFlushed = OMX_TRUE;
+
+        SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
+
+        flushBuffer = &pSECComponent->secDataBuffer[portIndex];
+
+        SEC_OSAL_MutexLock(flushBuffer->bufferMutex);
+        ret = SEC_OMX_FlushPort(pOMXComponent, portIndex);
+        SEC_OSAL_MutexUnlock(flushBuffer->bufferMutex);
+
+        pSECComponent->pSECPort[portIndex].bIsPortFlushed = OMX_FALSE;
+    }
+
+EXIT:
+    if (ret != OMX_ErrorNone) {
+        pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                            pSECComponent->callbackData,
+                            OMX_EventError,
+                            ret, 0, NULL);
+    }
+
+    FunctionOut();
+
+    return ret;
+}
+
+
+OMX_ERRORTYPE SEC_OMX_EnablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_U32                i = 0, cnt = 0;
+
+    FunctionIn();
+
+    pSECPort = &pSECComponent->pSECPort[portIndex];
+    pSECPort->portDefinition.bEnabled = OMX_TRUE;
+
+    if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        ret = pSECComponent->sec_AllocateTunnelBuffer(pSECPort, portIndex);
+        if (OMX_ErrorNone != ret) {
+            goto EXIT;
+        }
+        pSECPort->portDefinition.bPopulated = OMX_TRUE;
+        if (pSECComponent->currentState == OMX_StateExecuting) {
+            for (i=0; i<pSECPort->tunnelBufferNum; i++) {
+                SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[portIndex].bufferSemID);
+            }
+        }
+    } else if (CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
+            SEC_OSAL_SemaphoreWait(pSECPort->loadedResource);
+            pSECPort->portDefinition.bPopulated = OMX_TRUE;
+        }
+    } else {
+        if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
+            SEC_OSAL_SemaphoreWait(pSECPort->loadedResource);
+            pSECPort->portDefinition.bPopulated = OMX_TRUE;
+        }
+    }
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_PortEnableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    OMX_S32                portIndex = 0;
+    OMX_U32                i = 0, cnt = 0;
+
+    FunctionIn();
+
+    if (pOMXComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    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;
+
+    cnt = (nPortIndex == ALL_PORT_INDEX) ? ALL_PORT_NUM : 1;
+
+    for (i = 0; i < cnt; i++) {
+        if (nPortIndex == ALL_PORT_INDEX)
+            portIndex = i;
+        else
+            portIndex = nPortIndex;
+
+        ret = SEC_OMX_EnablePort(pOMXComponent, portIndex);
+        if (ret == OMX_ErrorNone) {
+            pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                            pSECComponent->callbackData,
+                            OMX_EventCmdComplete,
+                            OMX_CommandPortEnable, portIndex, NULL);
+        }
+    }
+
+EXIT:
+    if (ret != OMX_ErrorNone) {
+            pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                            pSECComponent->callbackData,
+                            OMX_EventError,
+                            ret, 0, NULL);
+        }
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_DisablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_U32                i = 0, elemNum = 0;
+    SEC_OMX_MESSAGE       *message;
+
+    FunctionIn();
+
+    pSECPort = &pSECComponent->pSECPort[portIndex];
+
+    if (!CHECK_PORT_ENABLED(pSECPort)) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    if (pSECComponent->currentState!=OMX_StateLoaded) {
+        if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+            while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) >0 ) {
+                message = (SEC_OMX_MESSAGE*)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+                SEC_OSAL_Free(message);
+            }
+            ret = pSECComponent->sec_FreeTunnelBuffer(pSECPort, portIndex);
+            if (OMX_ErrorNone != ret) {
+                goto EXIT;
+            }
+            pSECPort->portDefinition.bPopulated = OMX_FALSE;
+        } else if (CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+            pSECPort->portDefinition.bPopulated = OMX_FALSE;
+            SEC_OSAL_SemaphoreWait(pSECPort->unloadedResource);
+        } else {
+            if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+                while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) >0 ) {
+                    message = (SEC_OMX_MESSAGE*)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+                    SEC_OSAL_Free(message);
+                }
+            }
+            pSECPort->portDefinition.bPopulated = OMX_FALSE;
+            SEC_OSAL_SemaphoreWait(pSECPort->unloadedResource);
+        }
+    }
+    pSECPort->portDefinition.bEnabled = OMX_FALSE;
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_PortDisableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    OMX_S32                portIndex = 0;
+    OMX_U32                i = 0, cnt = 0;
+    SEC_OMX_DATABUFFER      *flushBuffer = NULL;
+
+    FunctionIn();
+
+    if (pOMXComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    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;
+
+    cnt = (nPortIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
+
+    /* port flush*/
+    for(i = 0; i < cnt; i++) {
+        if (nPortIndex == ALL_PORT_INDEX)
+            portIndex = i;
+        else
+            portIndex = nPortIndex;
+
+        pSECComponent->pSECPort[portIndex].bIsPortFlushed = OMX_TRUE;
+
+        flushBuffer = &pSECComponent->secDataBuffer[portIndex];
+
+        SEC_OSAL_MutexLock(flushBuffer->bufferMutex);
+        ret = SEC_OMX_FlushPort(pOMXComponent, portIndex);
+        SEC_OSAL_MutexUnlock(flushBuffer->bufferMutex);
+
+        pSECComponent->pSECPort[portIndex].bIsPortFlushed = OMX_FALSE;
+    }
+
+    for(i = 0; i < cnt; i++) {
+        if (nPortIndex == ALL_PORT_INDEX)
+            portIndex = i;
+        else
+            portIndex = nPortIndex;
+
+        ret = SEC_OMX_DisablePort(pOMXComponent, portIndex);
+        if (ret == OMX_ErrorNone) {
+            pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                            pSECComponent->callbackData,
+                            OMX_EventCmdComplete,
+                            OMX_CommandPortDisable, portIndex, NULL);
+        }
+    }
+
+EXIT:
+    if (ret != OMX_ErrorNone) {
+        pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                        pSECComponent->callbackData,
+                        OMX_EventError,
+                        ret, 0, NULL);
+    }
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_EmptyThisBuffer(
+    OMX_IN OMX_HANDLETYPE        hComponent,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BOOL               findBuffer = OMX_FALSE;
+    SEC_OMX_MESSAGE       *message;
+    OMX_U32                i = 0;
+
+    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 (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    if (pBuffer == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pBuffer->nInputPortIndex != INPUT_PORT_INDEX) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    ret = SEC_OMX_Check_SizeVersion(pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if ((pSECComponent->currentState != OMX_StateIdle) &&
+        (pSECComponent->currentState != OMX_StateExecuting) &&
+        (pSECComponent->currentState != OMX_StatePause)) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    if ((!CHECK_PORT_ENABLED(pSECPort)) ||
+       (pSECComponent->transientState == SEC_OMX_TransStateExecutingToIdle &&
+        (CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)))) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+
+    for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
+        if (pBuffer == pSECPort->bufferHeader[i]) {
+            findBuffer = OMX_TRUE;
+            break;
+        }
+    }
+
+    if (findBuffer == OMX_FALSE) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    } else {
+        ret = OMX_ErrorNone;
+    }
+
+    message = SEC_OSAL_Malloc(sizeof(SEC_OMX_MESSAGE));
+    if (message == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    message->messageType = SEC_OMX_CommandEmptyBuffer;
+    message->messageParam = (OMX_U32) i;
+    message->pCmdData = (OMX_PTR)pBuffer;
+
+    SEC_OSAL_Queue(&pSECPort->bufferQ, (void *)message);
+    SEC_OSAL_SemaphorePost(pSECPort->bufferSemID);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_FillThisBuffer(
+    OMX_IN OMX_HANDLETYPE        hComponent,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BOOL               findBuffer = OMX_FALSE;
+    SEC_OMX_MESSAGE       *message;
+    OMX_U32                i = 0;
+
+    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 (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    if (pBuffer == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pBuffer->nOutputPortIndex != OUTPUT_PORT_INDEX) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    ret = SEC_OMX_Check_SizeVersion(pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if ((pSECComponent->currentState != OMX_StateIdle) &&
+        (pSECComponent->currentState != OMX_StateExecuting) &&
+        (pSECComponent->currentState != OMX_StatePause)) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+
+    pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    if ((!CHECK_PORT_ENABLED(pSECPort)) ||
+       (pSECComponent->transientState == SEC_OMX_TransStateExecutingToIdle &&
+        (CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)))) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+
+    for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
+        if (pBuffer == pSECPort->bufferHeader[i]) {
+            findBuffer = OMX_TRUE;
+            break;
+        }
+    }
+
+    if (findBuffer == OMX_FALSE) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    } else {
+        ret = OMX_ErrorNone;
+    }
+
+    message = SEC_OSAL_Malloc(sizeof(SEC_OMX_MESSAGE));
+    if (message == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    message->messageType = SEC_OMX_CommandFillBuffer;
+    message->messageParam = (OMX_U32) i;
+    message->pCmdData = (OMX_PTR)pBuffer;
+
+    SEC_OSAL_Queue(&pSECPort->bufferQ, (void *)message);
+    SEC_OSAL_SemaphorePost(pSECPort->bufferSemID);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_Port_Constructor(OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    SEC_OMX_BASEPORT      *pSECInputPort = NULL;
+    SEC_OMX_BASEPORT      *pSECOutputPort = NULL;
+    int i = 0;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
+        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;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    INIT_SET_SIZE_VERSION(&pSECComponent->portParam, OMX_PORT_PARAM_TYPE);
+    pSECComponent->portParam.nPorts = ALL_PORT_NUM;
+    pSECComponent->portParam.nStartPortNumber = INPUT_PORT_INDEX;
+
+    pSECPort = SEC_OSAL_Malloc(sizeof(SEC_OMX_BASEPORT) * ALL_PORT_NUM);
+    if (pSECPort == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECPort, 0, sizeof(SEC_OMX_BASEPORT) * ALL_PORT_NUM);
+    pSECComponent->pSECPort = pSECPort;
+
+    /* Input Port */
+    pSECInputPort = &pSECPort[INPUT_PORT_INDEX];
+
+    SEC_OSAL_QueueCreate(&pSECInputPort->bufferQ);
+
+    pSECInputPort->bufferHeader = SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM);
+    if (pSECInputPort->bufferHeader == NULL) {
+        SEC_OSAL_Free(pSECPort);
+        pSECPort = NULL;
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECInputPort->bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM);
+
+    pSECInputPort->bufferStateAllocate = SEC_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM);
+    if (pSECInputPort->bufferStateAllocate == NULL) {
+        SEC_OSAL_Free(pSECInputPort->bufferHeader);
+        pSECInputPort->bufferHeader = NULL;
+        SEC_OSAL_Free(pSECPort);
+        pSECPort = NULL;
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECInputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM);
+
+    pSECInputPort->bufferSemID = NULL;
+    pSECInputPort->assignedBufferNum = 0;
+    pSECInputPort->portState = OMX_StateMax;
+    pSECInputPort->bIsPortFlushed = OMX_FALSE;
+    pSECInputPort->tunneledComponent = NULL;
+    pSECInputPort->tunneledPort = 0;
+    pSECInputPort->tunnelBufferNum = 0;
+    pSECInputPort->bufferSupplier = OMX_BufferSupplyUnspecified;
+    pSECInputPort->tunnelFlags = 0;
+    pSECInputPort->eControlRate = OMX_Video_ControlRateDisable;
+    ret = SEC_OSAL_SemaphoreCreate(&pSECInputPort->loadedResource);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
+        pSECInputPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferHeader);
+        pSECInputPort->bufferHeader = NULL;
+        SEC_OSAL_Free(pSECPort);
+        pSECPort = NULL;
+        goto EXIT;
+    }
+    ret = SEC_OSAL_SemaphoreCreate(&pSECInputPort->unloadedResource);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource);
+        pSECInputPort->loadedResource = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
+        pSECInputPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferHeader);
+        pSECInputPort->bufferHeader = NULL;
+        SEC_OSAL_Free(pSECPort);
+        pSECPort = NULL;
+        goto EXIT;
+    }
+
+    INIT_SET_SIZE_VERSION(&pSECInputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
+    pSECInputPort->portDefinition.nPortIndex = INPUT_PORT_INDEX;
+    pSECInputPort->portDefinition.eDir = OMX_DirInput;
+    pSECInputPort->portDefinition.nBufferCountActual = 0;
+    pSECInputPort->portDefinition.nBufferCountMin = 0;
+    pSECInputPort->portDefinition.nBufferSize = 0;
+    pSECInputPort->portDefinition.bEnabled = OMX_FALSE;
+    pSECInputPort->portDefinition.bPopulated = OMX_FALSE;
+    pSECInputPort->portDefinition.eDomain = OMX_PortDomainMax;
+    pSECInputPort->portDefinition.bBuffersContiguous = OMX_FALSE;
+    pSECInputPort->portDefinition.nBufferAlignment = 0;
+    pSECInputPort->markType.hMarkTargetComponent = NULL;
+    pSECInputPort->markType.pMarkData = NULL;
+
+    /* Output Port */
+    pSECOutputPort = &pSECPort[OUTPUT_PORT_INDEX];
+
+    SEC_OSAL_QueueCreate(&pSECOutputPort->bufferQ);
+
+    pSECOutputPort->bufferHeader = SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM);
+    if (pSECOutputPort->bufferHeader == NULL) {
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource);
+        pSECInputPort->unloadedResource = NULL;
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource);
+        pSECInputPort->loadedResource = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
+        pSECInputPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferHeader);
+        pSECInputPort->bufferHeader = NULL;
+        SEC_OSAL_Free(pSECPort);
+        pSECPort = NULL;
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECOutputPort->bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM);
+
+    pSECOutputPort->bufferStateAllocate = SEC_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM);
+    if (pSECOutputPort->bufferStateAllocate == NULL) {
+        SEC_OSAL_Free(pSECOutputPort->bufferHeader);
+        pSECOutputPort->bufferHeader = NULL;
+
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource);
+        pSECInputPort->unloadedResource = NULL;
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource);
+        pSECInputPort->loadedResource = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
+        pSECInputPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferHeader);
+        pSECInputPort->bufferHeader = NULL;
+        SEC_OSAL_Free(pSECPort);
+        pSECPort = NULL;
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECOutputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM);
+
+    pSECOutputPort->bufferSemID = NULL;
+    pSECOutputPort->assignedBufferNum = 0;
+    pSECOutputPort->portState = OMX_StateMax;
+    pSECOutputPort->bIsPortFlushed = OMX_FALSE;
+    pSECOutputPort->tunneledComponent = NULL;
+    pSECOutputPort->tunneledPort = 0;
+    pSECOutputPort->tunnelBufferNum = 0;
+    pSECOutputPort->bufferSupplier = OMX_BufferSupplyUnspecified;
+    pSECOutputPort->tunnelFlags = 0;
+    pSECOutputPort->eControlRate = OMX_Video_ControlRateDisable;
+    ret = SEC_OSAL_SemaphoreCreate(&pSECOutputPort->loadedResource);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Free(pSECOutputPort->bufferStateAllocate);
+        pSECOutputPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECOutputPort->bufferHeader);
+        pSECOutputPort->bufferHeader = NULL;
+
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource);
+        pSECInputPort->unloadedResource = NULL;
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource);
+        pSECInputPort->loadedResource = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
+        pSECInputPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferHeader);
+        pSECInputPort->bufferHeader = NULL;
+        SEC_OSAL_Free(pSECPort);
+        pSECPort = NULL;
+        goto EXIT;
+    }
+    ret = SEC_OSAL_SemaphoreCreate(&pSECOutputPort->unloadedResource);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_SemaphoreTerminate(pSECOutputPort->loadedResource);
+        pSECOutputPort->loadedResource = NULL;
+        SEC_OSAL_Free(pSECOutputPort->bufferStateAllocate);
+        pSECOutputPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECOutputPort->bufferHeader);
+        pSECOutputPort->bufferHeader = NULL;
+
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource);
+        pSECInputPort->unloadedResource = NULL;
+        SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource);
+        pSECInputPort->loadedResource = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
+        pSECInputPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECInputPort->bufferHeader);
+        pSECInputPort->bufferHeader = NULL;
+        SEC_OSAL_Free(pSECPort);
+        pSECPort = NULL;
+        goto EXIT;
+    }
+
+    INIT_SET_SIZE_VERSION(&pSECOutputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
+    pSECOutputPort->portDefinition.nPortIndex = OUTPUT_PORT_INDEX;
+    pSECOutputPort->portDefinition.eDir = OMX_DirOutput;
+    pSECOutputPort->portDefinition.nBufferCountActual = 0;
+    pSECOutputPort->portDefinition.nBufferCountMin = 0;
+    pSECOutputPort->portDefinition.nBufferSize = 0;
+    pSECOutputPort->portDefinition.bEnabled = OMX_FALSE;
+    pSECOutputPort->portDefinition.bPopulated = OMX_FALSE;
+    pSECOutputPort->portDefinition.eDomain = OMX_PortDomainMax;
+    pSECOutputPort->portDefinition.bBuffersContiguous = OMX_FALSE;
+    pSECOutputPort->portDefinition.nBufferAlignment = 0;
+    pSECOutputPort->markType.hMarkTargetComponent = NULL;
+    pSECOutputPort->markType.pMarkData = NULL;
+
+    pOMXComponent->EmptyThisBuffer = &SEC_OMX_EmptyThisBuffer;
+    pOMXComponent->FillThisBuffer  = &SEC_OMX_FillThisBuffer;
+
+    ret = OMX_ErrorNone;
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_Port_Destructor(OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+/*
+    SEC_OMX_BASEPORT      *pSECInputPort = NULL;
+    SEC_OMX_BASEPORT      *pSECOutputPort = NULL;
+*/
+    FunctionIn();
+
+    int i = 0;
+
+    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;
+    for (i = 0; i < ALL_PORT_NUM; i++) {
+        pSECPort = &pSECComponent->pSECPort[i];
+
+        SEC_OSAL_SemaphoreTerminate(pSECPort->loadedResource);
+        pSECPort->loadedResource = NULL;
+        SEC_OSAL_SemaphoreTerminate(pSECPort->unloadedResource);
+        pSECPort->unloadedResource = NULL;
+        SEC_OSAL_Free(pSECPort->bufferStateAllocate);
+        pSECPort->bufferStateAllocate = NULL;
+        SEC_OSAL_Free(pSECPort->bufferHeader);
+        pSECPort->bufferHeader = NULL;
+
+        SEC_OSAL_QueueTerminate(&pSECPort->bufferQ);
+    }
+    SEC_OSAL_Free(pSECComponent->pSECPort);
+    pSECComponent->pSECPort = NULL;
+    ret = OMX_ErrorNone;
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.h b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.h
new file mode 100644
index 0000000..820ac63
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.h
@@ -0,0 +1,89 @@
+/*
+ *
+ * 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_Baseport.h
+ * @brief
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ *             HyeYeon Chung (hyeon.chung@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_BASE_PORT
+#define SEC_OMX_BASE_PORT
+
+
+#include "OMX_Component.h"
+#include "SEC_OMX_Def.h"
+#include "SEC_OSAL_Queue.h"
+
+
+#define BUFFER_STATE_ALLOCATED  (1 << 0)
+#define BUFFER_STATE_ASSIGNED   (1 << 1)
+#define HEADER_STATE_ALLOCATED  (1 << 2)
+#define BUFFER_STATE_FREE        0
+
+#define MAX_BUFFER_NUM          20
+
+#define INPUT_PORT_INDEX    0
+#define OUTPUT_PORT_INDEX   1
+#define ALL_PORT_INDEX     -1
+#define ALL_PORT_NUM        2
+
+typedef struct _SEC_OMX_BASEPORT
+{
+    OMX_BUFFERHEADERTYPE         **bufferHeader;
+    OMX_U32                       *bufferStateAllocate;
+    OMX_PARAM_PORTDEFINITIONTYPE   portDefinition;
+    OMX_HANDLETYPE                 bufferSemID;
+    SEC_QUEUE                      bufferQ;
+    OMX_U32                        assignedBufferNum;
+    OMX_STATETYPE                  portState;
+    OMX_HANDLETYPE                 loadedResource;
+    OMX_HANDLETYPE                 unloadedResource;
+
+    OMX_BOOL                       bIsPortFlushed;
+    OMX_MARKTYPE                   markType;
+
+    /* Tunnel Info */
+    OMX_HANDLETYPE                 tunneledComponent;
+    OMX_U32                        tunneledPort;
+    OMX_U32                        tunnelBufferNum;
+    OMX_BUFFERSUPPLIERTYPE         bufferSupplier;
+    OMX_U32                        tunnelFlags;
+
+    OMX_VIDEO_CONTROLRATETYPE      eControlRate;
+} SEC_OMX_BASEPORT;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_ERRORTYPE SEC_OMX_PortEnableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex);
+OMX_ERRORTYPE SEC_OMX_PortDisableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex);
+OMX_ERRORTYPE SEC_OMX_BufferFlushProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex);
+OMX_ERRORTYPE SEC_OMX_BufferFlushProcessNoEvent(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex);
+
+#ifdef __cplusplus
+};
+#endif
+
+
+#endif
diff --git a/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.c b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.c
new file mode 100644
index 0000000..41673ad
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.c
@@ -0,0 +1,383 @@
+/*
+ *
+ * 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_Resourcemanager.c
+ * @brief
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OMX_Resourcemanager.h"
+#include "SEC_OMX_Basecomponent.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_RM"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+#define MAX_RESOURCE_VIDEO 4
+
+/* Max allowable video scheduler component instance */
+static SEC_OMX_RM_COMPONENT_LIST *gpVideoRMComponentList = NULL;
+static SEC_OMX_RM_COMPONENT_LIST *gpVideoRMWaitingList = NULL;
+static OMX_HANDLETYPE ghVideoRMComponentListMutex = NULL;
+
+
+OMX_ERRORTYPE addElementList(SEC_OMX_RM_COMPONENT_LIST **ppList, OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE              ret = OMX_ErrorNone;
+    SEC_OMX_RM_COMPONENT_LIST *pTempComp = NULL;
+    SEC_OMX_BASECOMPONENT     *pSECComponent = NULL;
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    if (*ppList != NULL) {
+        pTempComp = *ppList;
+        while (pTempComp->pNext != NULL) {
+            pTempComp = pTempComp->pNext;
+        }
+        pTempComp->pNext = (SEC_OMX_RM_COMPONENT_LIST *)SEC_OSAL_Malloc(sizeof(SEC_OMX_RM_COMPONENT_LIST));
+        if (pTempComp->pNext == NULL) {
+            ret = OMX_ErrorInsufficientResources;
+            goto EXIT;
+        }
+        ((SEC_OMX_RM_COMPONENT_LIST *)(pTempComp->pNext))->pNext = NULL;
+        ((SEC_OMX_RM_COMPONENT_LIST *)(pTempComp->pNext))->pOMXStandComp = pOMXComponent;
+        ((SEC_OMX_RM_COMPONENT_LIST *)(pTempComp->pNext))->groupPriority = pSECComponent->compPriority.nGroupPriority;
+        goto EXIT;
+    } else {
+        *ppList = (SEC_OMX_RM_COMPONENT_LIST *)SEC_OSAL_Malloc(sizeof(SEC_OMX_RM_COMPONENT_LIST));
+        if (*ppList == NULL) {
+            ret = OMX_ErrorInsufficientResources;
+            goto EXIT;
+        }
+        pTempComp = *ppList;
+        pTempComp->pNext = NULL;
+        pTempComp->pOMXStandComp = pOMXComponent;
+        pTempComp->groupPriority = pSECComponent->compPriority.nGroupPriority;
+    }
+
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE removeElementList(SEC_OMX_RM_COMPONENT_LIST **ppList, OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE              ret = OMX_ErrorNone;
+    SEC_OMX_RM_COMPONENT_LIST *pCurrComp = NULL;
+    SEC_OMX_RM_COMPONENT_LIST *pPrevComp = NULL;
+    OMX_BOOL                   bDetectComp = OMX_FALSE;
+
+    if (*ppList == NULL) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+
+    pCurrComp = *ppList;
+    while (pCurrComp != NULL) {
+        if (pCurrComp->pOMXStandComp == pOMXComponent) {
+            if (*ppList == pCurrComp) {
+                *ppList = pCurrComp->pNext;
+                SEC_OSAL_Free(pCurrComp);
+            } else {
+                pPrevComp->pNext = pCurrComp->pNext;
+                SEC_OSAL_Free(pCurrComp);
+            }
+            bDetectComp = OMX_TRUE;
+            break;
+        } else {
+            pPrevComp = pCurrComp;
+            pCurrComp = pCurrComp->pNext;
+        }
+    }
+
+    if (bDetectComp == OMX_FALSE)
+        ret = OMX_ErrorComponentNotFound;
+    else
+        ret = OMX_ErrorNone;
+
+EXIT:
+    return ret;
+}
+
+int searchLowPriority(SEC_OMX_RM_COMPONENT_LIST *RMComp_list, int inComp_priority, SEC_OMX_RM_COMPONENT_LIST **outLowComp)
+{
+    int ret = 0;
+    SEC_OMX_RM_COMPONENT_LIST *pTempComp = NULL;
+    SEC_OMX_RM_COMPONENT_LIST *pCandidateComp = NULL;
+
+    if (RMComp_list == NULL)
+        ret = -1;
+
+    pTempComp = RMComp_list;
+    *outLowComp = 0;
+
+    while (pTempComp != NULL) {
+        if (pTempComp->groupPriority > inComp_priority) {
+            if (pCandidateComp != NULL) {
+                if (pCandidateComp->groupPriority < pTempComp->groupPriority)
+                    pCandidateComp = pTempComp;
+            } else {
+                pCandidateComp = pTempComp;
+            }
+        }
+
+        pTempComp = pTempComp->pNext;
+    }
+
+    *outLowComp = pCandidateComp;
+    if (pCandidateComp == NULL)
+        ret = 0;
+    else
+        ret = 1;
+
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE removeComponent(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    if (pSECComponent->currentState == OMX_StateIdle) {
+        (*(pSECComponent->pCallbacks->EventHandler))
+            (pOMXComponent, pSECComponent->callbackData,
+            OMX_EventError, OMX_ErrorResourcesLost, 0, NULL);
+        ret = OMX_SendCommand(pOMXComponent, OMX_CommandStateSet, OMX_StateLoaded, NULL);
+        if (ret != OMX_ErrorNone) {
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+    } else if ((pSECComponent->currentState == OMX_StateExecuting) || (pSECComponent->currentState == OMX_StatePause)) {
+        /* Todo */
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    return ret;
+}
+
+
+OMX_ERRORTYPE SEC_OMX_ResourceManager_Init()
+{
+    FunctionIn();
+    SEC_OSAL_MutexCreate(&ghVideoRMComponentListMutex);
+    FunctionOut();
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OMX_ResourceManager_Deinit()
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    SEC_OMX_RM_COMPONENT_LIST *pCurrComponent;
+    SEC_OMX_RM_COMPONENT_LIST *pNextComponent;
+
+    FunctionIn();
+
+    SEC_OSAL_MutexLock(ghVideoRMComponentListMutex);
+
+    if (gpVideoRMComponentList) {
+        pCurrComponent = gpVideoRMComponentList;
+        while (pCurrComponent != NULL) {
+            pNextComponent = pCurrComponent->pNext;
+            SEC_OSAL_Free(pCurrComponent);
+            pCurrComponent = pNextComponent;
+        }
+        gpVideoRMComponentList = NULL;
+    }
+
+    if (gpVideoRMWaitingList) {
+        pCurrComponent = gpVideoRMWaitingList;
+        while (pCurrComponent != NULL) {
+            pNextComponent = pCurrComponent->pNext;
+            SEC_OSAL_Free(pCurrComponent);
+            pCurrComponent = pNextComponent;
+        }
+        gpVideoRMWaitingList = NULL;
+    }
+    SEC_OSAL_MutexUnlock(ghVideoRMComponentListMutex);
+
+    SEC_OSAL_MutexTerminate(ghVideoRMComponentListMutex);
+    ghVideoRMComponentListMutex = NULL;
+
+    ret = OMX_ErrorNone;
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_Get_Resource(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE              ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT     *pSECComponent = NULL;
+    SEC_OMX_RM_COMPONENT_LIST *pComponentTemp = NULL;
+    SEC_OMX_RM_COMPONENT_LIST *pComponentCandidate = NULL;
+    int numElem = 0;
+    int lowCompDetect = 0;
+
+    FunctionIn();
+
+    SEC_OSAL_MutexLock(ghVideoRMComponentListMutex);
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pComponentTemp = gpVideoRMComponentList;
+    if (pSECComponent->codecType == HW_VIDEO_CODEC) {
+        if (pComponentTemp != NULL) {
+            while (pComponentTemp) {
+                numElem++;
+                pComponentTemp = pComponentTemp->pNext;
+            }
+        } else {
+            numElem = 0;
+        }
+        if (numElem >= MAX_RESOURCE_VIDEO) {
+            lowCompDetect = searchLowPriority(gpVideoRMComponentList, pSECComponent->compPriority.nGroupPriority, &pComponentCandidate);
+            if (lowCompDetect <= 0) {
+                ret = OMX_ErrorInsufficientResources;
+                goto EXIT;
+            } else {
+                ret = removeComponent(pComponentCandidate->pOMXStandComp);
+                if (ret != OMX_ErrorNone) {
+                    ret = OMX_ErrorInsufficientResources;
+                    goto EXIT;
+                } else {
+                    ret = removeElementList(&gpVideoRMComponentList, pComponentCandidate->pOMXStandComp);
+                    ret = addElementList(&gpVideoRMComponentList, pOMXComponent);
+                    if (ret != OMX_ErrorNone) {
+                        ret = OMX_ErrorInsufficientResources;
+                        goto EXIT;
+                    }
+                }
+            }
+        } else {
+            ret = addElementList(&gpVideoRMComponentList, pOMXComponent);
+            if (ret != OMX_ErrorNone) {
+                ret = OMX_ErrorInsufficientResources;
+                goto EXIT;
+            }
+        }
+    }
+    ret = OMX_ErrorNone;
+
+EXIT:
+
+    SEC_OSAL_MutexUnlock(ghVideoRMComponentListMutex);
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_Release_Resource(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE              ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT     *pSECComponent = NULL;
+    SEC_OMX_RM_COMPONENT_LIST *pComponentTemp = NULL;
+    OMX_COMPONENTTYPE         *pOMXWaitComponent = NULL;
+    int numElem = 0;
+
+    FunctionIn();
+
+    SEC_OSAL_MutexLock(ghVideoRMComponentListMutex);
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pComponentTemp = gpVideoRMWaitingList;
+    if (pSECComponent->codecType == HW_VIDEO_CODEC) {
+        if (gpVideoRMComponentList == NULL) {
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+
+        ret = removeElementList(&gpVideoRMComponentList, pOMXComponent);
+        if (ret != OMX_ErrorNone) {
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+        while (pComponentTemp) {
+            numElem++;
+            pComponentTemp = pComponentTemp->pNext;
+        }
+        if (numElem > 0) {
+            pOMXWaitComponent = gpVideoRMWaitingList->pOMXStandComp;
+            removeElementList(&gpVideoRMWaitingList, pOMXWaitComponent);
+            ret = OMX_SendCommand(pOMXWaitComponent, OMX_CommandStateSet, OMX_StateIdle, NULL);
+            if (ret != OMX_ErrorNone) {
+                goto EXIT;
+            }
+        }
+    }
+
+EXIT:
+
+    SEC_OSAL_MutexUnlock(ghVideoRMComponentListMutex);
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_In_WaitForResource(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    SEC_OSAL_MutexLock(ghVideoRMComponentListMutex);
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    if (pSECComponent->codecType == HW_VIDEO_CODEC)
+        ret = addElementList(&gpVideoRMWaitingList, pOMXComponent);
+
+    SEC_OSAL_MutexUnlock(ghVideoRMComponentListMutex);
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_Out_WaitForResource(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    SEC_OSAL_MutexLock(ghVideoRMComponentListMutex);
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    if (pSECComponent->codecType == HW_VIDEO_CODEC)
+        ret = removeElementList(&gpVideoRMWaitingList, pOMXComponent);
+
+    SEC_OSAL_MutexUnlock(ghVideoRMComponentListMutex);
+
+    FunctionOut();
+
+    return ret;
+}
+
diff --git a/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.h b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.h
new file mode 100644
index 0000000..b958575
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.h
@@ -0,0 +1,59 @@
+/*
+ *
+ * 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_Resourcemanager.h
+ * @brief
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_RESOURCEMANAGER
+#define SEC_OMX_RESOURCEMANAGER
+
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Component.h"
+
+
+struct SEC_OMX_RM_COMPONENT_LIST;
+typedef struct _SEC_OMX_RM_COMPONENT_LIST
+{
+    OMX_COMPONENTTYPE         *pOMXStandComp;
+    OMX_U32                    groupPriority;
+    struct SEC_OMX_RM_COMPONENT_LIST *pNext;
+} SEC_OMX_RM_COMPONENT_LIST;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_ERRORTYPE SEC_OMX_ResourceManager_Init();
+OMX_ERRORTYPE SEC_OMX_ResourceManager_Deinit();
+OMX_ERRORTYPE SEC_OMX_Get_Resource(OMX_COMPONENTTYPE *pOMXComponent);
+OMX_ERRORTYPE SEC_OMX_Release_Resource(OMX_COMPONENTTYPE *pOMXComponent);
+OMX_ERRORTYPE SEC_OMX_In_WaitForResource(OMX_COMPONENTTYPE *pOMXComponent);
+OMX_ERRORTYPE SEC_OMX_Out_WaitForResource(OMX_COMPONENTTYPE *pOMXComponent);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.c b/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.c
new file mode 100644
index 0000000..580d821
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.c
@@ -0,0 +1,1279 @@
+/*
+ *
+ * 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_Vdec.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ *              HyeYeon Chung (hyeon.chung@samsung.com)
+ *              Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "SEC_OMX_Macros.h"
+#include "SEC_OSAL_Event.h"
+#include "SEC_OMX_Vdec.h"
+#include "SEC_OMX_Basecomponent.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_VIDEO_DEC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+#define ONE_FRAME_OUTPUT  /* only one frame output for Android */
+#define S5PC110_DECODE_OUT_DATA_BUFFER /* for Android s5pc110 0copy*/
+
+
+inline void SEC_UpdateFrameSize(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *secInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT      *secOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+
+    if ((secOutputPort->portDefinition.format.video.nFrameWidth !=
+            secInputPort->portDefinition.format.video.nFrameWidth) ||
+        (secOutputPort->portDefinition.format.video.nFrameHeight !=
+            secInputPort->portDefinition.format.video.nFrameHeight)) {
+        OMX_U32 width = 0, height = 0;
+
+        secOutputPort->portDefinition.format.video.nFrameWidth =
+            secInputPort->portDefinition.format.video.nFrameWidth;
+        secOutputPort->portDefinition.format.video.nFrameHeight =
+            secInputPort->portDefinition.format.video.nFrameHeight;
+        width = secOutputPort->portDefinition.format.video.nStride =
+            secInputPort->portDefinition.format.video.nStride;
+        height = secOutputPort->portDefinition.format.video.nSliceHeight =
+            secInputPort->portDefinition.format.video.nSliceHeight;
+
+        switch(secOutputPort->portDefinition.format.video.eColorFormat) {
+        case OMX_COLOR_FormatYUV420Planar:
+        case OMX_COLOR_FormatYUV420SemiPlanar:
+            if (width && height)
+                secOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
+            break;
+        default:
+            if (width && height)
+                secOutputPort->portDefinition.nBufferSize = width * height * 2;
+            break;
+        }
+    }
+
+  return ;
+}
+
+OMX_ERRORTYPE SEC_OMX_UseBuffer(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN OMX_U32                   nSizeBytes,
+    OMX_IN OMX_U8                   *pBuffer)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE  *temp_bufferHeader = NULL;
+    int                    i = 0;
+
+    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;
+
+    pSECPort = &pSECComponent->pSECPort[nPortIndex];
+    if (nPortIndex >= pSECComponent->portParam.nPorts) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+    if (pSECPort->portState != OMX_StateIdle) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+
+    if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
+    if (temp_bufferHeader == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
+
+    for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
+        if (pSECPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
+            pSECPort->bufferHeader[i] = temp_bufferHeader;
+            pSECPort->bufferStateAllocate[i] = (BUFFER_STATE_ASSIGNED | HEADER_STATE_ALLOCATED);
+            INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
+            temp_bufferHeader->pBuffer        = pBuffer;
+            temp_bufferHeader->nAllocLen      = nSizeBytes;
+            temp_bufferHeader->pAppPrivate    = pAppPrivate;
+            if ( nPortIndex == INPUT_PORT_INDEX)
+                temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
+            else
+                temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
+
+            pSECPort->assignedBufferNum++;
+            if (pSECPort->assignedBufferNum == pSECPort->portDefinition.nBufferCountActual) {
+                pSECPort->portDefinition.bPopulated = OMX_TRUE;
+                /* SEC_OSAL_MutexLock(pSECComponent->compMutex); */
+                SEC_OSAL_SemaphorePost(pSECPort->loadedResource);
+                /* SEC_OSAL_MutexUnlock(pSECComponent->compMutex); */
+            }
+            *ppBufferHdr = temp_bufferHeader;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+    }
+    ret = OMX_ErrorInsufficientResources;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_AllocateBuffer(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBuffer,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN OMX_U32                   nSizeBytes)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE  *temp_bufferHeader = NULL;
+    OMX_U8                *temp_buffer = NULL;
+    int                    i = 0;
+
+    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;
+
+    pSECPort = &pSECComponent->pSECPort[nPortIndex];
+    if (nPortIndex >= pSECComponent->portParam.nPorts) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+/*
+    if (pSECPort->portState != OMX_StateIdle ) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+*/
+    if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    temp_buffer = SEC_OSAL_Malloc(sizeof(OMX_U8) * nSizeBytes);
+    if (temp_buffer == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+
+    temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
+    if (temp_bufferHeader == NULL) {
+        SEC_OSAL_Free(temp_buffer);
+        temp_buffer = NULL;
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
+
+    for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
+        if (pSECPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
+            pSECPort->bufferHeader[i] = temp_bufferHeader;
+            pSECPort->bufferStateAllocate[i] = (BUFFER_STATE_ALLOCATED | HEADER_STATE_ALLOCATED);
+            INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
+            temp_bufferHeader->pBuffer        = temp_buffer;
+            temp_bufferHeader->nAllocLen      = nSizeBytes;
+            temp_bufferHeader->pAppPrivate    = pAppPrivate;
+            if ( nPortIndex == INPUT_PORT_INDEX)
+                temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
+            else
+                temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
+            pSECPort->assignedBufferNum++;
+            if (pSECPort->assignedBufferNum == pSECPort->portDefinition.nBufferCountActual) {
+                pSECPort->portDefinition.bPopulated = OMX_TRUE;
+                /* SEC_OSAL_MutexLock(pSECComponent->compMutex); */
+                SEC_OSAL_SemaphorePost(pSECPort->loadedResource);
+                /* SEC_OSAL_MutexUnlock(pSECComponent->compMutex); */
+            }
+            *ppBuffer = temp_bufferHeader;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+    }
+    ret = OMX_ErrorInsufficientResources;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_FreeBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_U32        nPortIndex,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE  *temp_bufferHeader = NULL;
+    OMX_U8                *temp_buffer = NULL;
+    int                    i = 0;
+
+    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;
+    pSECPort = &pSECComponent->pSECPort[nPortIndex];
+
+    if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    if ((pSECPort->portState != OMX_StateLoaded) && (pSECPort->portState != OMX_StateInvalid)) {
+        (*(pSECComponent->pCallbacks->EventHandler)) (pOMXComponent,
+                        pSECComponent->callbackData,
+                        (OMX_U32)OMX_EventError,
+                        (OMX_U32)OMX_ErrorPortUnpopulated,
+                        nPortIndex, NULL);
+    }
+
+    for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
+        if (((pSECPort->bufferStateAllocate[i] | BUFFER_STATE_FREE) != 0) && (pSECPort->bufferHeader[i] != NULL)) {
+            if (pSECPort->bufferHeader[i]->pBuffer == pBufferHdr->pBuffer) {
+                if (pSECPort->bufferStateAllocate[i] & BUFFER_STATE_ALLOCATED) {
+                    SEC_OSAL_Free(pSECPort->bufferHeader[i]->pBuffer);
+                    pSECPort->bufferHeader[i]->pBuffer = NULL;
+                    pBufferHdr->pBuffer = NULL;
+                } else if (pSECPort->bufferStateAllocate[i] & BUFFER_STATE_ASSIGNED) {
+                    ; /* None*/
+                }
+                pSECPort->assignedBufferNum--;
+                if (pSECPort->bufferStateAllocate[i] & HEADER_STATE_ALLOCATED) {
+                    SEC_OSAL_Free(pSECPort->bufferHeader[i]);
+                    pSECPort->bufferHeader[i] = NULL;
+                    pBufferHdr = NULL;
+                }
+                pSECPort->bufferStateAllocate[i] = BUFFER_STATE_FREE;
+                ret = OMX_ErrorNone;
+                goto EXIT;
+            }
+        }
+    }
+
+EXIT:
+    if (ret == OMX_ErrorNone) {
+        if ( pSECPort->assignedBufferNum == 0 ) {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "pSECPort->unloadedResource signal set");
+            /* SEC_OSAL_MutexLock(pSECComponent->compMutex); */
+            SEC_OSAL_SemaphorePost(pSECPort->unloadedResource);
+            /* SEC_OSAL_MutexUnlock(pSECComponent->compMutex); */
+            pSECPort->portDefinition.bPopulated = OMX_FALSE;
+        }
+    }
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_AllocateTunnelBuffer(SEC_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
+{
+    OMX_ERRORTYPE                 ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT             *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE         *temp_bufferHeader = NULL;
+    OMX_U8                       *temp_buffer = NULL;
+    OMX_U32                       bufferSize = 0;
+    OMX_PARAM_PORTDEFINITIONTYPE  portDefinition;
+
+    ret = OMX_ErrorTunnelingUnsupported;
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_FreeTunnelBuffer(SEC_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT* pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE* temp_bufferHeader = NULL;
+    OMX_U8 *temp_buffer = NULL;
+    OMX_U32 bufferSize = 0;
+
+    ret = OMX_ErrorTunnelingUnsupported;
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_ComponentTunnelRequest(
+    OMX_IN OMX_HANDLETYPE hComp,
+    OMX_IN OMX_U32        nPort,
+    OMX_IN OMX_HANDLETYPE hTunneledComp,
+    OMX_IN OMX_U32        nTunneledPort,
+    OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    ret = OMX_ErrorTunnelingUnsupported;
+EXIT:
+    return ret;
+}
+
+OMX_BOOL SEC_Check_BufferProcess_State(SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    if ((pSECComponent->currentState == OMX_StateExecuting) &&
+        (pSECComponent->pSECPort[INPUT_PORT_INDEX].portState == OMX_StateIdle) &&
+        (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portState == OMX_StateIdle) &&
+        (pSECComponent->transientState != SEC_OMX_TransStateExecutingToIdle) &&
+        (pSECComponent->transientState != SEC_OMX_TransStateIdleToExecuting)) {
+        return OMX_TRUE;
+    } else {
+        return OMX_FALSE;
+    }
+}
+
+static OMX_ERRORTYPE SEC_InputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *secOMXInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT      *secOMXOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATABUFFER    *dataBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+    OMX_BUFFERHEADERTYPE  *bufferHeader = dataBuffer->bufferHeader;
+
+    FunctionIn();
+
+    if (secOMXInputPort->markType.hMarkTargetComponent != NULL ) {
+        bufferHeader->hMarkTargetComponent      = secOMXInputPort->markType.hMarkTargetComponent;
+        bufferHeader->pMarkData                 = secOMXInputPort->markType.pMarkData;
+        secOMXInputPort->markType.hMarkTargetComponent = NULL;
+        secOMXInputPort->markType.pMarkData = NULL;
+    }
+
+    if (bufferHeader->hMarkTargetComponent != NULL) {
+        if (bufferHeader->hMarkTargetComponent == pOMXComponent) {
+            pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                            pSECComponent->callbackData,
+                            OMX_EventMark,
+                            0, 0, bufferHeader->pMarkData);
+        } else {
+            pSECComponent->propagateMarkType.hMarkTargetComponent = bufferHeader->hMarkTargetComponent;
+            pSECComponent->propagateMarkType.pMarkData = bufferHeader->pMarkData;
+        }
+    }
+
+    if ((pSECComponent->currentState == OMX_StatePause) &&
+        ((!CHECK_PORT_BEING_FLUSHED(secOMXInputPort) && !CHECK_PORT_BEING_FLUSHED(secOMXOutputPort)))) {
+        SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
+        SEC_OSAL_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
+    }
+
+    if (bufferHeader != NULL) {
+        if (CHECK_PORT_TUNNELED(secOMXInputPort)) {
+            OMX_FillThisBuffer(secOMXInputPort->tunneledComponent, bufferHeader);
+        } else {
+            bufferHeader->nFilledLen = 0;
+            pSECComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+        }
+    }
+    dataBuffer->dataValid     = OMX_FALSE;
+    dataBuffer->dataLen       = 0;
+    dataBuffer->remainDataLen = 0;
+    dataBuffer->usedDataLen   = 0;
+    dataBuffer->bufferHeader  = NULL;
+    dataBuffer->nFlags        = 0;
+    dataBuffer->timeStamp     = 0;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_InputBufferGetQueue(SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    OMX_ERRORTYPE       ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT   *pSECPort = NULL;
+    SEC_OMX_DATABUFFER *dataBuffer = NULL;
+    SEC_OMX_MESSAGE*    message = NULL;
+
+    FunctionIn();
+
+    pSECPort= &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    dataBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+
+    if (pSECComponent->currentState != OMX_StateExecuting) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    } else {
+        SEC_OSAL_SemaphoreWait(pSECPort->bufferSemID);
+        if (dataBuffer->dataValid != OMX_TRUE) {
+            message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+            if (message == NULL) {
+                ret = OMX_ErrorUndefined;
+                goto EXIT;
+            }
+
+            dataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
+            dataBuffer->allocSize = dataBuffer->bufferHeader->nAllocLen;
+            dataBuffer->dataLen = dataBuffer->bufferHeader->nFilledLen;
+            dataBuffer->remainDataLen = dataBuffer->dataLen;
+            dataBuffer->usedDataLen = 0;
+            dataBuffer->dataValid = OMX_TRUE;
+            dataBuffer->nFlags = dataBuffer->bufferHeader->nFlags;
+            dataBuffer->timeStamp = dataBuffer->bufferHeader->nTimeStamp;
+            SEC_OSAL_Free(message);
+
+            if (dataBuffer->allocSize <= dataBuffer->dataLen)
+                SEC_OSAL_Log(SEC_LOG_WARNING, "Input Buffer Full, Check input buffer size! allocSize:%d, dataLen:%d", dataBuffer->allocSize, dataBuffer->dataLen);
+        }
+        ret = OMX_ErrorNone;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_OutputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *secOMXInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT      *secOMXOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATABUFFER    *dataBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+    OMX_BUFFERHEADERTYPE  *bufferHeader = dataBuffer->bufferHeader;
+
+    FunctionIn();
+
+    bufferHeader->nFilledLen = dataBuffer->remainDataLen;
+    bufferHeader->nOffset    = 0;
+    bufferHeader->nFlags     = dataBuffer->nFlags;
+    bufferHeader->nTimeStamp = dataBuffer->timeStamp;
+
+    if (pSECComponent->propagateMarkType.hMarkTargetComponent != NULL) {
+        bufferHeader->hMarkTargetComponent = pSECComponent->propagateMarkType.hMarkTargetComponent;
+        bufferHeader->pMarkData = pSECComponent->propagateMarkType.pMarkData;
+        pSECComponent->propagateMarkType.hMarkTargetComponent = NULL;
+        pSECComponent->propagateMarkType.pMarkData = NULL;
+    }
+
+    if (bufferHeader->nFlags & OMX_BUFFERFLAG_EOS) {
+        pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                        pSECComponent->callbackData,
+                        OMX_EventBufferFlag,
+                        OUTPUT_PORT_INDEX,
+                        bufferHeader->nFlags, NULL);
+    }
+
+    if ((pSECComponent->currentState == OMX_StatePause) &&
+        ((!CHECK_PORT_BEING_FLUSHED(secOMXInputPort) && !CHECK_PORT_BEING_FLUSHED(secOMXOutputPort)))) {
+        SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
+        SEC_OSAL_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
+    }
+
+    if (bufferHeader != NULL) {
+        if (CHECK_PORT_TUNNELED(secOMXOutputPort)) {
+            OMX_EmptyThisBuffer(secOMXOutputPort->tunneledComponent, bufferHeader);
+        } else {
+            pSECComponent->pCallbacks->FillBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+        }
+    }
+    /* reset dataBuffer */
+    dataBuffer->dataValid     = OMX_FALSE;
+    dataBuffer->dataLen       = 0;
+    dataBuffer->remainDataLen = 0;
+    dataBuffer->usedDataLen   = 0;
+    dataBuffer->bufferHeader  = NULL;
+    dataBuffer->nFlags        = 0;
+    dataBuffer->timeStamp     = 0;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OutputBufferGetQueue(SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    OMX_ERRORTYPE       ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT   *pSECPort = NULL;
+    SEC_OMX_DATABUFFER *dataBuffer = NULL;
+    SEC_OMX_MESSAGE    *message = NULL;
+
+    FunctionIn();
+
+    pSECPort= &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    dataBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+
+    if (pSECComponent->currentState != OMX_StateExecuting) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    } else {
+        SEC_OSAL_SemaphoreWait(pSECPort->bufferSemID);
+        if (dataBuffer->dataValid != OMX_TRUE) {
+            message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+            if (message == NULL) {
+                ret = OMX_ErrorUndefined;
+                goto EXIT;
+            }
+
+            dataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
+            dataBuffer->allocSize = dataBuffer->bufferHeader->nAllocLen;
+            dataBuffer->dataLen = 0; //dataBuffer->bufferHeader->nFilledLen;
+            dataBuffer->remainDataLen = dataBuffer->dataLen;
+            dataBuffer->usedDataLen = 0; //dataBuffer->bufferHeader->nOffset;
+            dataBuffer->dataValid =OMX_TRUE;
+            /* dataBuffer->nFlags = dataBuffer->bufferHeader->nFlags; */
+            /* dataBuffer->nTimeStamp = dataBuffer->bufferHeader->nTimeStamp; */
+#ifdef S5PC110_DECODE_OUT_DATA_BUFFER
+            pSECComponent->processData[OUTPUT_PORT_INDEX].dataBuffer = dataBuffer->bufferHeader->pBuffer;
+            pSECComponent->processData[OUTPUT_PORT_INDEX].allocSize = dataBuffer->bufferHeader->nAllocLen;
+#endif
+            SEC_OSAL_Free(message);
+        }
+        ret = OMX_ErrorNone;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+
+}
+
+static OMX_ERRORTYPE SEC_BufferReset(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 portIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    /* SEC_OMX_BASEPORT      *pSECPort = &pSECComponent->pSECPort[portIndex]; */
+    SEC_OMX_DATABUFFER    *dataBuffer = &pSECComponent->secDataBuffer[portIndex];
+    /* OMX_BUFFERHEADERTYPE  *bufferHeader = dataBuffer->bufferHeader; */
+
+    dataBuffer->dataValid     = OMX_FALSE;
+    dataBuffer->dataLen       = 0;
+    dataBuffer->remainDataLen = 0;
+    dataBuffer->usedDataLen   = 0;
+    dataBuffer->bufferHeader  = NULL;
+    dataBuffer->nFlags        = 0;
+    dataBuffer->timeStamp     = 0;
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_DataDrop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 portIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    /* SEC_OMX_BASEPORT      *pSECPort = &pSECComponent->pSECPort[portIndex]; */
+    /* SEC_OMX_DATABUFFER    *dataBuffer = &pSECComponent->secDataBuffer[portIndex]; */
+    /* OMX_BUFFERHEADERTYPE  *bufferHeader = dataBuffer->bufferHeader; */
+    SEC_OMX_DATA          *processData = &pSECComponent->processData[portIndex];
+
+    if (portIndex == 0) {
+        processData->dataLen       = 0;
+        processData->remainDataLen = 0;
+        processData->usedDataLen   = 0;
+        processData->nFlags        = 0;
+        processData->timeStamp     = 0;
+    } else {
+        /* TBD */
+    }
+
+    return ret;
+}
+
+OMX_BOOL SEC_Preprocessor_InputData(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_BOOL               ret = OMX_FALSE;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_DATABUFFER    *inputUseBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+    SEC_OMX_DATA          *inputData = &pSECComponent->processData[INPUT_PORT_INDEX];
+    OMX_U32                copySize = 0;
+    OMX_BYTE               checkInputStream = NULL;
+    OMX_U32                checkInputStreamLen = 0;
+    OMX_U32                checkedSize = 0;
+    OMX_BOOL               flagEOF = OMX_FALSE;
+    OMX_BOOL               previousFrameEOF = OMX_FALSE;
+
+    if (inputUseBuffer->dataValid == OMX_TRUE) {
+        checkInputStream = inputUseBuffer->bufferHeader->pBuffer + inputUseBuffer->usedDataLen;
+        checkInputStreamLen = inputUseBuffer->remainDataLen;
+
+        if (inputData->dataLen == 0) {
+            previousFrameEOF = OMX_TRUE;
+        } else {
+            previousFrameEOF = OMX_FALSE;
+        }
+        if ((pSECComponent->bUseFlagEOF == OMX_TRUE) &&
+           !(inputUseBuffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG)) {
+            flagEOF = OMX_TRUE;
+            checkedSize = checkInputStreamLen;
+        } else {
+            pSECComponent->bUseFlagEOF = OMX_FALSE;
+            checkedSize = pSECComponent->sec_checkInputFrame(checkInputStream, checkInputStreamLen, inputUseBuffer->nFlags, previousFrameEOF, &flagEOF);
+        }
+
+        if (flagEOF == OMX_TRUE) {
+            copySize = checkedSize;
+            SEC_OSAL_Log(SEC_LOG_TRACE, "sec_checkInputFrame : OMX_TRUE");
+        } else {
+            copySize = checkInputStreamLen;
+            SEC_OSAL_Log(SEC_LOG_TRACE, "sec_checkInputFrame : OMX_FALSE");
+        }
+
+        if (inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS)
+            pSECComponent->bSaveFlagEOS = OMX_TRUE;
+
+        if (((inputData->allocSize) - (inputData->dataLen)) >= copySize) {
+            if (copySize > 0)
+                SEC_OSAL_Memcpy(inputData->dataBuffer + inputData->dataLen, checkInputStream, copySize);
+
+            inputUseBuffer->dataLen -= copySize;
+            inputUseBuffer->remainDataLen -= copySize;
+            inputUseBuffer->usedDataLen += copySize;
+
+            inputData->dataLen += copySize;
+            inputData->remainDataLen += copySize;
+
+            if (previousFrameEOF == OMX_TRUE)
+                inputData->timeStamp = inputUseBuffer->timeStamp;
+
+            if (pSECComponent->bUseFlagEOF == OMX_TRUE) {
+                inputData->nFlags = inputUseBuffer->nFlags;
+                if (pSECComponent->bSaveFlagEOS == OMX_TRUE) {
+                    inputData->nFlags |= OMX_BUFFERFLAG_EOS;
+                    flagEOF = OMX_TRUE;
+                    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+                }
+            } else {
+                if ((checkedSize == checkInputStreamLen) && (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
+                    inputData->nFlags |= OMX_BUFFERFLAG_EOS;
+                    flagEOF = OMX_TRUE;
+                    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+                } else {
+                    inputData->nFlags = inputUseBuffer->nFlags & (~OMX_BUFFERFLAG_EOS);
+                }
+            }
+        } else {
+            /*????????????????????????????????? Error ?????????????????????????????????*/
+            SEC_DataDrop(pOMXComponent, INPUT_PORT_INDEX);
+        }
+
+        if (inputUseBuffer->remainDataLen == 0)
+            SEC_InputBufferReturn(pOMXComponent);
+        else
+            inputUseBuffer->dataValid = OMX_TRUE;
+    }
+
+    if (flagEOF == OMX_TRUE)
+        ret = OMX_TRUE;
+    else
+        ret = OMX_FALSE;
+
+    return ret;
+}
+
+OMX_BOOL SEC_Postprocess_OutputData(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_BOOL               ret = OMX_FALSE;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_DATABUFFER    *outputUseBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATA          *outputData = &pSECComponent->processData[OUTPUT_PORT_INDEX];
+    OMX_U32                copySize = 0;
+
+    if (outputUseBuffer->dataValid == OMX_TRUE) {
+        if (outputData->remainDataLen <= (outputUseBuffer->allocSize - outputUseBuffer->dataLen)) {
+            copySize = outputData->remainDataLen;
+#ifndef S5PC110_DECODE_OUT_DATA_BUFFER
+            if (copySize > 0)
+                SEC_OSAL_Memcpy((outputUseBuffer->bufferHeader->pBuffer + outputUseBuffer->dataLen),
+                        (outputData->dataBuffer + outputData->usedDataLen),
+                         copySize);
+#endif
+
+            outputUseBuffer->dataLen += copySize;
+            outputUseBuffer->remainDataLen += copySize;
+            outputUseBuffer->nFlags = outputData->nFlags;
+            outputUseBuffer->timeStamp = outputData->timeStamp;
+
+            ret = OMX_TRUE;
+
+            /* reset outputData */
+            outputData->dataLen = 0;
+            outputData->remainDataLen = 0;
+            outputData->usedDataLen = 0;
+            outputData->nFlags = 0;
+            outputData->timeStamp = 0;
+
+#ifdef ONE_FRAME_OUTPUT  /* only one frame output for Android */
+            SEC_OutputBufferReturn(pOMXComponent);
+#else
+            if ((outputUseBuffer->remainDataLen > 0) ||
+                ((outputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
+                SEC_OutputBufferReturn(pOMXComponent);
+            } else {
+                outputUseBuffer->dataValid = OMX_TRUE;
+            }
+#endif
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "output buffer is smaller than decoded data size Out Length");
+
+            copySize = outputUseBuffer->allocSize - outputUseBuffer->dataLen;
+
+#ifndef S5PC110_DECODE_OUT_DATA_BUFFER
+            SEC_OSAL_Memcpy((outputUseBuffer->bufferHeader->pBuffer + outputUseBuffer->dataLen),
+                    (outputData->dataBuffer + outputData->usedDataLen),
+                     copySize);
+#endif
+            outputUseBuffer->dataLen += copySize;
+            outputUseBuffer->remainDataLen += copySize;
+            outputUseBuffer->nFlags = 0;
+            outputUseBuffer->timeStamp = outputData->timeStamp;
+
+            ret = OMX_FALSE;
+
+            outputData->remainDataLen -= copySize;
+            outputData->usedDataLen += copySize;
+
+            SEC_OutputBufferReturn(pOMXComponent);
+        }
+    } else {
+        ret = OMX_FALSE;
+    }
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_BufferProcess(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_BASEPORT      *secInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT      *secOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATABUFFER    *inputUseBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+    SEC_OMX_DATABUFFER    *outputUseBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATA          *inputData = &pSECComponent->processData[INPUT_PORT_INDEX];
+    SEC_OMX_DATA          *outputData = &pSECComponent->processData[OUTPUT_PORT_INDEX];
+    OMX_U32                copySize = 0;
+    OMX_BOOL               remainOutputData = OMX_FALSE;
+    OMX_BOOL               redecodeInputData = OMX_FALSE;
+
+    FunctionIn();
+
+    while (!pSECComponent->bExitBufferProcessThread) {
+        SEC_OSAL_SleepMillisec(0);
+
+        if (((pSECComponent->currentState == OMX_StatePause) ||
+            (pSECComponent->currentState == OMX_StateIdle) ||
+            (pSECComponent->transientState == SEC_OMX_TransStateLoadedToIdle) ||
+            (pSECComponent->transientState == SEC_OMX_TransStateExecutingToIdle)) &&
+            (pSECComponent->transientState != SEC_OMX_TransStateIdleToLoaded)&&
+            ((!CHECK_PORT_BEING_FLUSHED(secInputPort) && !CHECK_PORT_BEING_FLUSHED(secOutputPort)))) {
+            SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
+            SEC_OSAL_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
+        }
+
+        while (SEC_Check_BufferProcess_State(pSECComponent) && !pSECComponent->bExitBufferProcessThread) {
+            SEC_OSAL_SleepMillisec(0);
+
+            if (outputUseBuffer->dataValid != OMX_TRUE) {
+                ret = SEC_OutputBufferGetQueue(pSECComponent);
+                if ((ret == OMX_ErrorUndefined) ||
+                    (secInputPort->portState != OMX_StateIdle) ||
+                    (secOutputPort->portState != OMX_StateIdle)) {
+                    break;
+                }
+            }
+            if (remainOutputData == OMX_FALSE) {
+                if (redecodeInputData == OMX_FALSE) {
+                    SEC_OSAL_MutexLock(inputUseBuffer->bufferMutex);
+                    if (SEC_Preprocessor_InputData(pOMXComponent) == OMX_FALSE) {
+                            SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                            ret = SEC_InputBufferGetQueue(pSECComponent);
+                            break;
+                        }
+
+                    SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                }
+
+                ret = pSECComponent->sec_mfc_bufferProcess(pOMXComponent, inputData, outputData);
+                if (ret == OMX_ErrorInputDataDecodeYet)
+                    redecodeInputData = OMX_TRUE;
+                else
+                    redecodeInputData = OMX_FALSE;
+            }
+
+            SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+
+            if (SEC_Postprocess_OutputData(pOMXComponent) == OMX_FALSE)
+                remainOutputData = OMX_TRUE;
+            else
+                remainOutputData = OMX_FALSE;
+
+            SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+        }
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_VideoDecodeGetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nParamIndex,
+    OMX_INOUT OMX_PTR     ComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = 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 (pSECComponent->currentState == OMX_StateInvalid ) {
+        ret = OMX_StateInvalid;
+        goto EXIT;
+    }
+
+    if (ComponentParameterStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    switch (nParamIndex) {
+    case OMX_IndexParamVideoInit:
+    {
+        OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
+        ret = SEC_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        portParam->nPorts           = pSECComponent->portParam.nPorts;
+        portParam->nStartPortNumber = pSECComponent->portParam.nStartPortNumber;
+        ret = OMX_ErrorNone;
+    }
+        break;
+    case OMX_IndexParamVideoPortFormat:
+    {
+        OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
+        OMX_U32                         portIndex = portFormat->nPortIndex;
+        OMX_U32                         index    = portFormat->nIndex;
+        SEC_OMX_BASEPORT               *pSECPort = NULL;
+        OMX_PARAM_PORTDEFINITIONTYPE   *portDefinition = NULL;
+        OMX_U32                         supportFormatNum = 0; /* supportFormatNum = N-1 */
+
+        ret = SEC_OMX_Check_SizeVersion(portFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if ((portIndex >= pSECComponent->portParam.nPorts)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+
+        if (portIndex == INPUT_PORT_INDEX) {
+            supportFormatNum = INPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
+            if (index > supportFormatNum) {
+                ret = OMX_ErrorNoMore;
+                goto EXIT;
+            }
+
+            pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+            portDefinition = &pSECPort->portDefinition;
+
+            portFormat->eCompressionFormat = portDefinition->format.video.eCompressionFormat;
+            portFormat->eColorFormat       = portDefinition->format.video.eColorFormat;
+            portFormat->xFramerate           = portDefinition->format.video.xFramerate;
+        } else if (portIndex == OUTPUT_PORT_INDEX) {
+            supportFormatNum = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
+            if (index > supportFormatNum) {
+                ret = OMX_ErrorNoMore;
+                goto EXIT;
+            }
+
+            pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+            portDefinition = &pSECPort->portDefinition;
+
+            switch (index) {
+            case supportFormat_1:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_COLOR_FormatYUV420Planar;
+                portFormat->xFramerate           = portDefinition->format.video.xFramerate;
+                break;
+            case supportFormat_2:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_COLOR_FormatYUV420SemiPlanar;
+                portFormat->xFramerate         = portDefinition->format.video.xFramerate;
+                break;
+            case supportFormat_3:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = SEC_OMX_COLOR_FormatNV12PhysicalAddress;
+                portFormat->xFramerate           = portDefinition->format.video.xFramerate;
+                break;
+            }
+        }
+        ret = OMX_ErrorNone;
+    }
+        break;
+    case OMX_IndexParamVideoBitrate:
+    {
+        OMX_VIDEO_PARAM_BITRATETYPE  *videoRateControl = (OMX_VIDEO_PARAM_BITRATETYPE *)ComponentParameterStructure;
+        OMX_U32                       portIndex = videoRateControl->nPortIndex;
+        SEC_OMX_BASEPORT         *pSECPort = NULL;
+        OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
+
+        if ((portIndex != INPUT_PORT_INDEX)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        } else {
+            pSECPort = &pSECComponent->pSECPort[portIndex];
+            portDefinition = &pSECPort->portDefinition;
+
+            videoRateControl->eControlRate = pSECPort->eControlRate;
+            videoRateControl->nTargetBitrate = portDefinition->format.video.nBitrate;
+        }
+        ret = OMX_ErrorNone;
+    }
+        break;
+    default:
+    {
+        ret = SEC_OMX_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
+    }
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+OMX_ERRORTYPE SEC_OMX_VideoDecodeSetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nIndex,
+    OMX_IN OMX_PTR        ComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = 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 (pSECComponent->currentState == OMX_StateInvalid ) {
+        ret = OMX_StateInvalid;
+        goto EXIT;
+    }
+
+    if (ComponentParameterStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexParamVideoPortFormat:
+    {
+        OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
+        OMX_U32                         portIndex = portFormat->nPortIndex;
+        OMX_U32                         index    = portFormat->nIndex;
+        SEC_OMX_BASEPORT               *pSECPort = NULL;
+        OMX_PARAM_PORTDEFINITIONTYPE   *portDefinition = NULL;
+        OMX_U32                         supportFormatNum = 0;
+
+        ret = SEC_OMX_Check_SizeVersion(portFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if ((portIndex >= pSECComponent->portParam.nPorts)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        } else {
+            pSECPort = &pSECComponent->pSECPort[portIndex];
+            portDefinition = &pSECPort->portDefinition;
+
+            portDefinition->format.video.eColorFormat       = portFormat->eColorFormat;
+            portDefinition->format.video.eCompressionFormat = portFormat->eCompressionFormat;
+            portDefinition->format.video.xFramerate         = portFormat->xFramerate;
+        }
+    }
+        break;
+    case OMX_IndexParamVideoBitrate:
+    {
+        OMX_VIDEO_PARAM_BITRATETYPE  *videoRateControl = (OMX_VIDEO_PARAM_BITRATETYPE *)ComponentParameterStructure;
+        OMX_U32                       portIndex = videoRateControl->nPortIndex;
+        SEC_OMX_BASEPORT             *pSECPort = NULL;
+        OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
+
+        if ((portIndex != INPUT_PORT_INDEX)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        } else {
+            pSECPort = &pSECComponent->pSECPort[portIndex];
+            portDefinition = &pSECPort->portDefinition;
+
+            pSECPort->eControlRate = videoRateControl->eControlRate;
+            portDefinition->format.video.nBitrate = videoRateControl->nTargetBitrate;
+        }
+        ret = OMX_ErrorNone;
+    }
+        break;
+    default:
+    {
+        ret = SEC_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
+    }
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_VideoDecodeComponentInit(OMX_IN OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = 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) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    ret = SEC_OMX_BaseComponent_Constructor(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    ret = SEC_OMX_Port_Constructor(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        SEC_OMX_BaseComponent_Destructor(pOMXComponent);
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+
+    /* Input port */
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    pSECPort->portDefinition.nBufferCountActual = MAX_VIDEO_INPUTBUFFER_NUM;
+    pSECPort->portDefinition.nBufferCountMin = MAX_VIDEO_INPUTBUFFER_NUM;
+    pSECPort->portDefinition.nBufferSize = 0;
+    pSECPort->portDefinition.eDomain = OMX_PortDomainVideo;
+
+    pSECPort->portDefinition.format.video.cMIMEType = SEC_OSAL_Malloc(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.eCompressionFormat = OMX_VIDEO_CodingUnused;
+
+    pSECPort->portDefinition.format.video.nFrameWidth = 0;
+    pSECPort->portDefinition.format.video.nFrameHeight= 0;
+    pSECPort->portDefinition.format.video.nStride = 0;
+    pSECPort->portDefinition.format.video.nSliceHeight = 0;
+    pSECPort->portDefinition.format.video.nBitrate = 64000;
+    pSECPort->portDefinition.format.video.xFramerate = (15 << 16);
+    pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
+    pSECPort->portDefinition.format.video.pNativeWindow = NULL;
+
+    /* Output port */
+    pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    pSECPort->portDefinition.nBufferCountActual = MAX_VIDEO_OUTPUTBUFFER_NUM;
+    pSECPort->portDefinition.nBufferCountMin = MAX_VIDEO_OUTPUTBUFFER_NUM;
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
+    pSECPort->portDefinition.eDomain = OMX_PortDomainVideo;
+
+    pSECPort->portDefinition.format.video.cMIMEType = SEC_OSAL_Malloc(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.eCompressionFormat = OMX_VIDEO_CodingUnused;
+
+    pSECPort->portDefinition.format.video.nFrameWidth = 0;
+    pSECPort->portDefinition.format.video.nFrameHeight= 0;
+    pSECPort->portDefinition.format.video.nStride = 0;
+    pSECPort->portDefinition.format.video.nSliceHeight = 0;
+    pSECPort->portDefinition.format.video.nBitrate = 64000;
+    pSECPort->portDefinition.format.video.xFramerate = (15 << 16);
+    pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
+    pSECPort->portDefinition.format.video.pNativeWindow = NULL;
+
+    pOMXComponent->UseBuffer              = &SEC_OMX_UseBuffer;
+    pOMXComponent->AllocateBuffer         = &SEC_OMX_AllocateBuffer;
+    pOMXComponent->FreeBuffer             = &SEC_OMX_FreeBuffer;
+    pOMXComponent->ComponentTunnelRequest = &SEC_OMX_ComponentTunnelRequest;
+
+    pSECComponent->sec_AllocateTunnelBuffer = &SEC_OMX_AllocateTunnelBuffer;
+    pSECComponent->sec_FreeTunnelBuffer     = &SEC_OMX_FreeTunnelBuffer;
+    pSECComponent->sec_BufferProcess        = &SEC_OMX_BufferProcess;
+    pSECComponent->sec_BufferReset          = &SEC_BufferReset;
+    pSECComponent->sec_InputBufferReturn    = &SEC_InputBufferReturn;
+    pSECComponent->sec_OutputBufferReturn   = &SEC_OutputBufferReturn;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_VideoDecodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    int                    i = 0;
+
+    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;
+
+    for(i = 0; i < ALL_PORT_NUM; i++) {
+        pSECPort = &pSECComponent->pSECPort[i];
+        SEC_OSAL_Free(pSECPort->portDefinition.format.video.cMIMEType);
+        pSECPort->portDefinition.format.video.cMIMEType = NULL;
+    }
+
+    ret = SEC_OMX_Port_Destructor(pOMXComponent);
+
+    ret = SEC_OMX_BaseComponent_Destructor(hComponent);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.h b/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.h
new file mode 100644
index 0000000..eed16b2
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.h
@@ -0,0 +1,107 @@
+/*
+ *
+ * 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_Vdec.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ *              HyeYeon Chung (hyeon.chung@samsung.com)
+ *              Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_VIDEO_DECODE
+#define SEC_OMX_VIDEO_DECODE
+
+#include "OMX_Component.h"
+#include "SEC_OMX_Def.h"
+#include "SEC_OSAL_Queue.h"
+#include "SEC_OMX_Baseport.h"
+
+#define MAX_VIDEO_INPUTBUFFER_NUM    5
+#define MAX_VIDEO_OUTPUTBUFFER_NUM   2
+
+#define DEFAULT_FRAME_WIDTH          176 //1920
+#define DEFAULT_FRAME_HEIGHT         144 //1088
+
+#define DEFAULT_VIDEO_INPUT_BUFFER_SIZE    700 * 1024 //(DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT)
+#define DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE   (DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT * 3) / 2
+
+#define DEFAULT_MFC_INPUT_BUFFER_SIZE    DEFAULT_VIDEO_INPUT_BUFFER_SIZE
+
+#define INPUT_PORT_SUPPORTFORMAT_NUM_MAX    1
+#define OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX   3
+
+
+typedef struct
+{
+    void *pAddrY;
+    void *pAddrC;
+} MFC_DEC_ADDR_INFO;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_ERRORTYPE SEC_OMX_UseBuffer(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN OMX_U32                   nSizeBytes,
+    OMX_IN OMX_U8                   *pBuffer);
+OMX_ERRORTYPE SEC_OMX_AllocateBuffer(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBuffer,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN OMX_U32                   nSizeBytes);
+OMX_ERRORTYPE SEC_OMX_FreeBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_U32        nPortIndex,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr);
+OMX_ERRORTYPE SEC_OMX_AllocateTunnelBuffer(
+    SEC_OMX_BASEPORT *pOMXBasePort,
+    OMX_U32           nPortIndex);
+OMX_ERRORTYPE SEC_OMX_FreeTunnelBuffer(
+    SEC_OMX_BASEPORT *pOMXBasePort,
+    OMX_U32           nPortIndex);
+OMX_ERRORTYPE SEC_OMX_ComponentTunnelRequest(
+    OMX_IN  OMX_HANDLETYPE hComp,
+    OMX_IN OMX_U32         nPort,
+    OMX_IN OMX_HANDLETYPE  hTunneledComp,
+    OMX_IN OMX_U32         nTunneledPort,
+    OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup);
+OMX_ERRORTYPE SEC_OMX_BufferProcess(OMX_HANDLETYPE hComponent);
+OMX_ERRORTYPE SEC_OMX_VideoDecodeGetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nParamIndex,
+    OMX_INOUT OMX_PTR     ComponentParameterStructure);
+OMX_ERRORTYPE SEC_OMX_VideoDecodeSetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nIndex,
+    OMX_IN OMX_PTR        ComponentParameterStructure);
+OMX_ERRORTYPE SEC_OMX_VideoDecodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/Android.mk b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/Android.mk
new file mode 100644
index 0000000..baabbad
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/Android.mk
@@ -0,0 +1,30 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	../SEC_OMX_Vdec.c \
+	SEC_OMX_H264dec.c \
+	library_register.c
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libOMX.SEC.AVC.Decoder
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libsecosal libsecbasecomponent libsecmfcdecapi
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/sec_osal \
+	$(SEC_OMX_TOP)/sec_omx_core \
+	$(SEC_OMX_COMPONENT)/common \
+	$(SEC_OMX_COMPONENT)/video/dec \
+
+LOCAL_C_INCLUDES += $(SEC_OMX_TOP)/sec_codecs/video/mfc_c110/include
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.c b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.c
new file mode 100644
index 0000000..00aab39
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.c
@@ -0,0 +1,1114 @@
+/*
+ *
+ * Copyright 2010 Samsung Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * @file        SEC_OMX_H264dec.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OMX_Macros.h"
+#include "SEC_OMX_Basecomponent.h"
+#include "SEC_OMX_Baseport.h"
+#include "SEC_OMX_Vdec.h"
+#include "library_register.h"
+#include "SEC_OMX_H264dec.h"
+#include "SsbSipMfcApi.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_H264_DEC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+/* H.264 Decoder Supported Levels & profiles */
+SEC_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels[] ={
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel32},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel4},
+
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1b},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel11},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel12},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel13},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel2},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel21},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel22},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel3},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel31},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel32},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel4},
+
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1b},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel11},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel12},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel13},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel2},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel21},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel22},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel3},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel31},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel32},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel4}};
+
+
+static int Check_H264_Frame(OMX_U8 *pInputStream, int buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame)
+{
+    OMX_U32  preFourByte       = (OMX_U32)-1;
+    int      accessUnitSize    = 0;
+    int      frameTypeBoundary = 0;
+    int      nextNaluSize      = 0;
+    int      naluStart         = 0;
+
+    if (bPreviousFrameEOF == OMX_TRUE)
+        naluStart = 0;
+    else
+        naluStart = 1;
+
+    while (1) {
+        int inputOneByte = 0;
+
+        if (accessUnitSize == buffSize)
+            goto EXIT;
+
+        inputOneByte = *(pInputStream++);
+        accessUnitSize += 1;
+
+        if (preFourByte == 0x00000001 || (preFourByte << 8) == 0x00000100) {
+            int naluType = inputOneByte & 0x1F;
+
+            SEC_OSAL_Log(SEC_LOG_TRACE, "NaluType : %d", naluType);
+            if (naluStart == 0) {
+                if (naluType == 1 || naluType == 5 || naluType == 6 || naluType == 7 || naluType == 8)
+                    naluStart = 1;
+            } else {
+                frameTypeBoundary = (8 - naluType) & (naluType - 10); //AUD(9)
+                if (naluType == 1 || naluType == 5) {
+                    if (accessUnitSize == buffSize) {
+                        accessUnitSize--;
+                        goto EXIT;
+                    }
+                    inputOneByte = *pInputStream++;
+                    accessUnitSize += 1;
+
+                    if (inputOneByte >= 0x80)
+                        frameTypeBoundary = -1;
+                }
+                if (frameTypeBoundary < 0) {
+                    break;
+                }
+            }
+
+        }
+        preFourByte = (preFourByte << 8) + inputOneByte;
+    }
+
+    *pbEndOfFrame = OMX_TRUE;
+    nextNaluSize = -5;
+    if (frameTypeBoundary == -1)
+        nextNaluSize = -6;
+    if (preFourByte != 0x00000001)
+        nextNaluSize++;
+    return (accessUnitSize + nextNaluSize);
+
+EXIT:
+
+        *pbEndOfFrame = OMX_FALSE;
+
+    return accessUnitSize;
+}
+
+OMX_BOOL Check_H264_StartCode(OMX_U8 *pInputStream, OMX_U32 streamSize)
+{
+    if (streamSize < 4) {
+        return OMX_FALSE;
+    } else if ((pInputStream[0] == 0x00) &&
+              (pInputStream[1] == 0x00) &&
+              (pInputStream[2] == 0x00) &&
+              (pInputStream[3] != 0x00) &&
+              ((pInputStream[3] >> 3) == 0x00)) {
+        return OMX_TRUE;
+    } else if ((pInputStream[0] == 0x00) &&
+              (pInputStream[1] == 0x00) &&
+              (pInputStream[2] != 0x00) &&
+              ((pInputStream[2] >> 3) == 0x00)) {
+        return OMX_TRUE;
+    } else {
+        return OMX_FALSE;
+    }
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Dec_GetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nParamIndex,
+    OMX_INOUT OMX_PTR     pComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL || pComponentParameterStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    if (pSECComponent->currentState == OMX_StateInvalid ) {
+        ret = OMX_StateInvalid;
+        goto EXIT;
+    }
+
+    switch (nParamIndex) {
+    case OMX_IndexParamVideoAvc:
+    {
+        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
+        SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+        ret = SEC_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcAVCComponent = &pH264Dec->AVCComponent[pDstAVCComponent->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
+    }
+        break;
+    case OMX_IndexParamStandardComponentRole:
+    {
+        OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
+        ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPOMENT_H264_DEC_ROLE);
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelQuerySupported:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
+        SEC_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
+        OMX_U32 maxProfileLevelNum = 0;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pProfileLevel = supportedAVCProfileLevels;
+        maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
+
+        if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
+            ret = OMX_ErrorNoMore;
+            goto EXIT;
+        }
+
+        pProfileLevel += pDstProfileLevel->nProfileIndex;
+        pDstProfileLevel->eProfile = pProfileLevel->profile;
+        pDstProfileLevel->eLevel = pProfileLevel->level;
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
+        SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcAVCComponent = &pH264Dec->AVCComponent[pDstProfileLevel->nPortIndex];
+
+        pDstProfileLevel->eProfile = pSrcAVCComponent->eProfile;
+        pDstProfileLevel->eLevel = pSrcAVCComponent->eLevel;
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
+        SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
+
+        pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
+        pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
+        pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
+        pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
+        pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
+    }
+        break;
+    default:
+        ret = SEC_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
+        break;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Dec_SetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nIndex,
+    OMX_IN OMX_PTR        pComponentParameterStructure)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL || pComponentParameterStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    if (pSECComponent->currentState == OMX_StateInvalid ) {
+        ret = OMX_StateInvalid;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexParamVideoAvc:
+    {
+        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
+        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
+        SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+        ret = SEC_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+        pDstAVCComponent = &pH264Dec->AVCComponent[pSrcAVCComponent->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
+    }
+        break;
+    case OMX_IndexParamStandardComponentRole:
+    {
+        OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
+
+        ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
+            ret = OMX_ErrorIncorrectStateOperation;
+            goto EXIT;
+        }
+
+        if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPOMENT_H264_DEC_ROLE)) {
+            pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+        } else {
+            ret = OMX_ErrorBadParameter;
+            goto EXIT;
+        }
+    }
+        break;
+    case OMX_IndexParamPortDefinition:
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
+        OMX_U32                       portIndex = pPortDefinition->nPortIndex;
+        SEC_OMX_BASEPORT             *pSECPort;
+        OMX_U32 width, height, size;
+
+        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);
+
+        width = ((pSECPort->portDefinition.format.video.nFrameWidth + 15) & (~15));
+        height = ((pSECPort->portDefinition.format.video.nFrameHeight + 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;
+            if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar) {
+                pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
+            } else if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatYUV422Planar) {
+                pSECOutputPort->portDefinition.nBufferSize = width * height * 2;
+            }
+        }
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
+        SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone)
+            goto EXIT;
+
+        if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+
+        pDstAVCComponent = &pH264Dec->AVCComponent[pSrcProfileLevel->nPortIndex];
+        pDstAVCComponent->eProfile = pSrcProfileLevel->eProfile;
+        pDstAVCComponent->eLevel = pSrcProfileLevel->eLevel;
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
+        SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+        pDstErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
+
+        pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
+        pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
+        pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
+        pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
+        pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
+    }
+        break;
+    default:
+        ret = SEC_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
+        break;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Dec_SetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    if (pComponentConfigStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexVendorThumbnailMode:
+    {
+        SEC_H264DEC_HANDLE   *pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+
+        pH264Dec->hMFCH264Handle.bThumbnailMode = *((OMX_BOOL *)pComponentConfigStructure);
+
+        ret = OMX_ErrorNone;
+    }
+        break;
+    default:
+        ret = SEC_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Dec_GetExtensionIndex(
+    OMX_IN OMX_HANDLETYPE  hComponent,
+    OMX_IN OMX_STRING      cParameterName,
+    OMX_OUT OMX_INDEXTYPE *pIndexType)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    if ((cParameterName == NULL) || (pIndexType == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    if (SEC_OSAL_Strcmp(cParameterName, "OMX.SEC.index.ThumbnailMode") == 0) {
+        SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+
+        *pIndexType = OMX_IndexVendorThumbnailMode;
+
+        ret = OMX_ErrorNone;
+    } else {
+        ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+
+OMX_ERRORTYPE SEC_MFC_H264Dec_ComponentRoleEnum(OMX_HANDLETYPE hComponent, OMX_U8 *cRole, OMX_U32 nIndex)
+{
+    OMX_ERRORTYPE            ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE       *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT   *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (cRole == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
+        SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPOMENT_H264_DEC_ROLE);
+        ret = OMX_ErrorNone;
+    } else {
+        ret = OMX_ErrorNoMore;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Init */
+OMX_ERRORTYPE SEC_MFC_H264Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_H264DEC_HANDLE    *pH264Dec = NULL;
+
+    OMX_PTR hMFCHandle       = NULL;
+    OMX_PTR pStreamBuffer    = NULL;
+    OMX_PTR pStreamPhyBuffer = NULL;
+
+    pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+    pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_FALSE;
+    pSECComponent->bUseFlagEOF = OMX_FALSE;
+    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+
+    /* MFC(Multi Function Codec) decoder and CMM(Codec Memory Management) driver open */
+    hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen();
+    if (hMFCHandle == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pH264Dec->hMFCH264Handle.hMFCHandle = hMFCHandle;
+
+    /* Allocate decoder's input buffer */
+    pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE);
+    if (pStreamBuffer == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pH264Dec->hMFCH264Handle.pMFCStreamBuffer    = pStreamBuffer;
+    pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pStreamPhyBuffer;
+    pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pStreamBuffer;
+    pSECComponent->processData[INPUT_PORT_INDEX].allocSize = DEFAULT_MFC_INPUT_BUFFER_SIZE;
+
+    SEC_OSAL_Memset(pH264Dec->hMFCH264Handle.timeStamp, 0, sizeof(OMX_TICKS)*MAX_TIMESTAMP);
+    pH264Dec->hMFCH264Handle.indexTimestamp = 0;
+
+EXIT:
+    return ret;
+}
+
+/* MFC Terminate */
+OMX_ERRORTYPE SEC_MFC_H264Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_H264DEC_HANDLE    *pH264Dec = NULL;
+    OMX_PTR                hMFCHandle = NULL;
+
+    FunctionIn();
+
+    pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+    hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
+
+    pH264Dec->hMFCH264Handle.pMFCStreamBuffer    = NULL;
+    pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = NULL;
+    pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = NULL;
+    pSECComponent->processData[INPUT_PORT_INDEX].allocSize = 0;
+
+    if (hMFCHandle != NULL) {
+        SsbSipMfcDecClose(hMFCHandle);
+        hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle = NULL;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264_Decode(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
+{
+    OMX_ERRORTYPE              ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT     *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_H264DEC_HANDLE        *pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+    OMX_U32                    oneFrameSize = pInputData->dataLen;
+    SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
+    OMX_S32                    setConfVal = 0;
+    OMX_S32                    returnCodec = 0;
+    int                        bufWidth;
+    int                        bufHeight;
+
+    FunctionIn();
+
+    if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
+        SSBSIP_MFC_CODEC_TYPE eCodecType = H264_DEC;
+
+        setConfVal = 5;
+        SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &setConfVal);
+
+        /* Default number in the driver is optimized */
+        if (pH264Dec->hMFCH264Handle.bThumbnailMode == OMX_TRUE) {
+            setConfVal = 0;
+            SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
+        } else {
+            setConfVal = 8;
+            SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
+        }
+
+        returnCodec = SsbSipMfcDecInit(pH264Dec->hMFCH264Handle.hMFCHandle, eCodecType, oneFrameSize);
+        if (returnCodec == MFC_RET_OK) {
+            SSBSIP_MFC_IMG_RESOLUTION imgResol;
+            SEC_OMX_BASEPORT *secInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+
+            SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol);
+            SEC_OSAL_Log(SEC_LOG_TRACE, "set width height information : %d, %d", secInputPort->portDefinition.format.video.nFrameWidth, secInputPort->portDefinition.format.video.nFrameHeight);
+            SEC_OSAL_Log(SEC_LOG_TRACE, "mfc width height information : %d, %d", imgResol.width, imgResol.height);
+
+            /** Update Frame Size **/
+            if((secInputPort->portDefinition.format.video.nFrameWidth != imgResol.width) ||
+               (secInputPort->portDefinition.format.video.nFrameHeight != imgResol.height)) {
+                SEC_OSAL_Log(SEC_LOG_TRACE, "change width height information : OMX_EventPortSettingsChanged");
+                /* change width and height information */
+                secInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
+                secInputPort->portDefinition.format.video.nFrameHeight  = imgResol.height;
+                secInputPort->portDefinition.format.video.nStride      = ((imgResol.width + 15) & (~15));
+                secInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
+
+                SEC_UpdateFrameSize(pOMXComponent);
+
+                /** Send Port Settings changed call back */
+                (*(pSECComponent->pCallbacks->EventHandler))
+                      (pOMXComponent,
+                       pSECComponent->callbackData,
+                       OMX_EventPortSettingsChanged, /* The command was completed */
+                       OMX_DirOutput, /* This is the port index */
+                       0,
+                       NULL);
+            }
+
+            pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_TRUE;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        } else {
+            ret = OMX_ErrorMFCInit;
+            goto EXIT;
+        }
+    }
+
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE)) {
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+    }
+
+    pH264Dec->hMFCH264Handle.timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
+    SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pH264Dec->hMFCH264Handle.indexTimestamp));
+    pH264Dec->hMFCH264Handle.indexTimestamp++;
+    if (pH264Dec->hMFCH264Handle.indexTimestamp >= MAX_TIMESTAMP)
+        pH264Dec->hMFCH264Handle.indexTimestamp = 0;
+
+    if (oneFrameSize <= 0) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    returnCodec = SsbSipMfcDecExe(pH264Dec->hMFCH264Handle.hMFCHandle, oneFrameSize);
+    if (returnCodec == MFC_RET_OK) {
+        SSBSIP_MFC_DEC_OUTBUF_STATUS status;
+        OMX_S32 indexTimestamp = 0;
+
+        status = SsbSipMfcDecGetOutBuf(pH264Dec->hMFCH264Handle.hMFCHandle, &outputInfo);
+        bufWidth =    (outputInfo.img_width + 15) & (~15);
+        bufHeight =  (outputInfo.img_height + 15) & (~15);
+
+        if (SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+        } else {
+            pOutputData->timeStamp = pH264Dec->hMFCH264Handle.timeStamp[indexTimestamp];
+        }
+
+        if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
+            (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
+            switch(pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
+            case OMX_COLOR_FormatYUV420Planar:
+            case OMX_COLOR_FormatYUV420SemiPlanar:
+                pOutputData->dataLen = (bufWidth * bufHeight * 3) / 2;
+                break;
+            default:
+                pOutputData->dataLen = bufWidth * bufHeight * 2;
+                break;
+            }
+        }
+
+        if(status == MFC_GETOUTBUF_DISPLAY_ONLY) {
+            ret = OMX_ErrorInputDataDecodeYet;
+        }
+        if(status == MFC_GETOUTBUF_DECODING_ONLY) {
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+/*
+        if (status == MFC_GETOUTBUF_DISPLAY_END) {
+            inputData->nFlags |= OMX_BUFFERFLAG_EOS;
+            outputData->nFlags |= OMX_BUFFERFLAG_EOS;
+        }
+
+        if ((inputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)
+        {
+            set_conf_val = 1;
+            SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle,
+                MFC_DEC_SETCONF_IS_LAST_FRAME, &set_conf_val);
+        }
+*/
+    } else {
+        /* ret = OMX_ErrorUndefined; */ /* ????? */
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    /** Fill Output Buffer **/
+    if (pOutputData->dataLen > 0)
+    {
+        int frameSize = bufWidth * bufHeight;
+        void *pOutBuf = (void *)pOutputData->dataBuffer;
+
+#ifdef USE_SAMSUNG_COLORFORMAT
+        SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+
+        if ((pH264Dec->hMFCH264Handle.bThumbnailMode == OMX_FALSE) ||
+            (pSECOutputPort->portDefinition.format.video.eColorFormat == SEC_OMX_COLOR_FormatNV12PhysicalAddress))
+
+#else
+        if (pH264Dec->hMFCH264Handle.bThumbnailMode == OMX_FALSE)
+#endif
+        {
+            SEC_OSAL_Memcpy(pOutBuf, &frameSize, sizeof(frameSize));
+            SEC_OSAL_Memcpy(pOutBuf + sizeof(frameSize), &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
+            SEC_OSAL_Memcpy(pOutBuf + sizeof(frameSize) + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
+            SEC_OSAL_Memcpy(pOutBuf + sizeof(frameSize) + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
+            SEC_OSAL_Memcpy(pOutBuf + sizeof(frameSize) + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
+        } else {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 out for ThumbnailMode");
+            tile_to_linear_4x2(pOutBuf, (unsigned char *)outputInfo.YVirAddr, bufWidth, bufHeight);
+            tile_to_linear_4x2(pOutBuf + frameSize, (unsigned char *)outputInfo.CVirAddr, bufWidth, bufHeight / 2);
+        }
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Decode */
+OMX_ERRORTYPE SEC_MFC_H264Dec_bufferProcess(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT   *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_H264DEC_HANDLE      *pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+    SEC_OMX_BASEPORT        *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT        *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    OMX_BOOL                 endOfFrame = OMX_FALSE;
+
+    FunctionIn();
+
+    if ((!CHECK_PORT_ENABLED(pSECInputPort)) || (!CHECK_PORT_ENABLED(pSECOutputPort)) ||
+            (!CHECK_PORT_POPULATED(pSECInputPort)) || (!CHECK_PORT_POPULATED(pSECOutputPort))) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+    if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    if(pInputData->nFlags & OMX_BUFFERFLAG_EOS) {
+        pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
+    } else {
+        pOutputData->nFlags = pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS);
+    }
+
+    if(Check_H264_StartCode(pInputData->dataBuffer, pInputData->dataLen) == OMX_TRUE) {
+        ret = SEC_MFC_H264_Decode(pOMXComponent, pInputData, pOutputData);
+    } else {
+        ret = OMX_ErrorNone;
+    }
+    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->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_H264DEC_HANDLE      *pH264Dec = NULL;
+    int i = 0;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (componentName == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    if (SEC_OSAL_Strcmp(SEC_OMX_COMPOMENT_H264_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, "OMX_Error, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pSECComponent->codecType = HW_VIDEO_CODEC;
+
+    pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
+    if (pSECComponent->componentName == NULL) {
+        SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
+
+    pH264Dec = SEC_OSAL_Malloc(sizeof(SEC_H264DEC_HANDLE));
+    if (pH264Dec == NULL) {
+        SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pH264Dec, 0, sizeof(SEC_H264DEC_HANDLE));
+    pSECComponent->hCodecHandle = (OMX_HANDLETYPE)pH264Dec;
+
+    SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPOMENT_H264_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; /*DEFAULT_FRAME_WIDTH;*/
+    pSECPort->portDefinition.format.video.nSliceHeight = 0;
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
+    pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+    SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
+    SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/avc");
+    pSECPort->portDefinition.format.video.pNativeRender = 0;
+    pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
+    pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
+    pSECPort->portDefinition.bEnabled = OMX_TRUE;
+
+    /* Output port */
+    pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
+    pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
+    pSECPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
+    pSECPort->portDefinition.format.video.nSliceHeight = 0;
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
+    pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
+    SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
+    SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "raw/video");
+    pSECPort->portDefinition.format.video.pNativeRender = 0;
+    pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
+    pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
+    pSECPort->portDefinition.bEnabled = OMX_TRUE;
+
+    for(i = 0; i < ALL_PORT_NUM; i++) {
+        INIT_SET_SIZE_VERSION(&pH264Dec->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE);
+        pH264Dec->AVCComponent[i].nPortIndex = i;
+        pH264Dec->AVCComponent[i].eProfile   = OMX_VIDEO_AVCProfileBaseline;
+        pH264Dec->AVCComponent[i].eLevel     = OMX_VIDEO_AVCLevel4;
+    }
+
+    pOMXComponent->GetParameter      = &SEC_MFC_H264Dec_GetParameter;
+    pOMXComponent->SetParameter      = &SEC_MFC_H264Dec_SetParameter;
+    pOMXComponent->SetConfig         = &SEC_MFC_H264Dec_SetConfig;
+    pOMXComponent->GetExtensionIndex = &SEC_MFC_H264Dec_GetExtensionIndex;
+    pOMXComponent->ComponentRoleEnum = &SEC_MFC_H264Dec_ComponentRoleEnum;
+    pOMXComponent->ComponentDeInit   = &SEC_OMX_ComponentDeinit;
+
+    pSECComponent->sec_mfc_componentInit      = &SEC_MFC_H264Dec_Init;
+    pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_H264Dec_Terminate;
+    pSECComponent->sec_mfc_bufferProcess      = &SEC_MFC_H264Dec_bufferProcess;
+    pSECComponent->sec_checkInputFrame        = &Check_H264_Frame;
+
+    pSECComponent->currentState = OMX_StateLoaded;
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE            ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE       *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT   *pSECComponent = NULL;
+    SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    SEC_OSAL_Free(pSECComponent->componentName);
+    pSECComponent->componentName = NULL;
+
+    pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+    if (pH264Dec != NULL) {
+        SEC_OSAL_Free(pH264Dec);
+        pH264Dec = pSECComponent->hCodecHandle = NULL;
+    }
+
+    ret = SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
+    if(ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.h b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.h
new file mode 100644
index 0000000..0af04e0
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.h
@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2010 Samsung Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * @file    SEC_OMX_H264dec.h
+ * @brief
+ * @author    SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_H264_DEC_COMPONENT
+#define SEC_OMX_H264_DEC_COMPONENT
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Component.h"
+#include "OMX_Video.h"
+
+
+#define MAX_TIMESTAMP        16
+
+typedef struct _SEC_MFC_H264DEC_HANDLE
+{
+    OMX_HANDLETYPE hMFCHandle;
+    OMX_PTR pMFCStreamBuffer;
+    OMX_PTR pMFCStreamPhyBuffer;
+    OMX_TICKS timeStamp[MAX_TIMESTAMP];
+    OMX_U32    indexTimestamp;
+    OMX_BOOL bConfiguredMFC;
+    OMX_BOOL bThumbnailMode;
+} SEC_MFC_H264DEC_HANDLE;
+
+typedef struct _SEC_H264DEC_HANDLE
+{
+    /* OMX Codec specific */
+    OMX_VIDEO_PARAM_AVCTYPE AVCComponent[ALL_PORT_NUM];
+    OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType[ALL_PORT_NUM];
+
+    /* SEC MFC Codec specific */
+    SEC_MFC_H264DEC_HANDLE hMFCH264Handle;
+} SEC_H264DEC_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/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.c b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.c
new file mode 100644
index 0000000..f7bcf25
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.c
@@ -0,0 +1,55 @@
+/*
+ *
+ * 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    SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *   2010.7.15 : 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"
+#include "SEC_OSAL_Log.h"
+
+
+OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **secComponents)
+{
+    FunctionIn();
+
+    if (secComponents == NULL)
+        goto EXIT;
+
+    /* component 1 - video decoder H.264 */
+    SEC_OSAL_Strcpy(secComponents[0]->componentName, SEC_OMX_COMPOMENT_H264_DEC);
+    SEC_OSAL_Strcpy(secComponents[0]->roles[0], SEC_OMX_COMPOMENT_H264_DEC_ROLE);
+    secComponents[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+    FunctionOut();
+
+    return MAX_COMPONENT_NUM;
+}
+
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.h b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.h
new file mode 100644
index 0000000..cdbfaa4
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.h
@@ -0,0 +1,55 @@
+/*
+ *
+ * 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      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_H264_REG
+#define SEC_OMX_H264_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
+
+/* H.264 */
+#define SEC_OMX_COMPOMENT_H264_DEC "OMX.SEC.AVC.Decoder"
+#define SEC_OMX_COMPOMENT_H264_DEC_ROLE "video_decoder.avc"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **secComponents);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
+
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/Android.mk b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/Android.mk
new file mode 100644
index 0000000..36eae52
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/Android.mk
@@ -0,0 +1,30 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	../SEC_OMX_Vdec.c \
+	SEC_OMX_Mpeg4dec.c \
+	library_register.c
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libOMX.SEC.M4V.Decoder
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libsecosal libsecbasecomponent libsecmfcdecapi
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/sec_osal \
+	$(SEC_OMX_TOP)/sec_omx_core \
+	$(SEC_OMX_COMPONENT)/common \
+	$(SEC_OMX_COMPONENT)/video/dec
+
+LOCAL_C_INCLUDES += $(SEC_OMX_TOP)/sec_codecs/video/mfc_c110/include
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.c b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.c
new file mode 100644
index 0000000..1da8d0d
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.c
@@ -0,0 +1,1333 @@
+/*
+ *
+ * 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_Mpeg4dec.c
+ * @brief
+ * @author    Yunji Kim (yunji.kim@samsung.com)
+ * @version   1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OMX_Macros.h"
+#include "SEC_OMX_Basecomponent.h"
+#include "SEC_OMX_Baseport.h"
+#include "SEC_OMX_Vdec.h"
+#include "library_register.h"
+#include "SEC_OMX_Mpeg4dec.h"
+#include "SsbSipMfcApi.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_MPEG4_DEC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+/* MPEG4 Decoder Supported Levels & profiles */
+SEC_OMX_VIDEO_PROFILELEVEL supportedMPEG4ProfileLevels[] ={
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4a},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5}};
+
+/* H.263 Decoder Supported Levels & profiles */
+SEC_OMX_VIDEO_PROFILELEVEL supportedH263ProfileLevels[] = {
+    /* Baseline (Profile 0) */
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70},
+    /* Profile 1 */
+    {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level10},
+    {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level20},
+    {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level30},
+    {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level40},
+    {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level45},
+    {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level50},
+    {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level60},
+    {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level70},
+    /* Profile 2 */
+    {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level10},
+    {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level20},
+    {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level30},
+    {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level40},
+    {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level45},
+    {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level50},
+    {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level60},
+    {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level70},
+    /* Profile 3, restricted up to SD resolution */
+    {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level10},
+    {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level20},
+    {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level30},
+    {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level40},
+    {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level45},
+    {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level50},
+    {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level60},
+    {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level70}};
+
+static OMX_HANDLETYPE ghMFCHandle = NULL;
+static OMX_BOOL gbFIMV1 = OMX_FALSE;
+
+static int Check_Mpeg4_Frame(OMX_U8 *pInputStream, OMX_U32 buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame)
+{
+    int len, readStream;
+    unsigned startCode;
+    OMX_BOOL bFrameStart;
+
+    len = 0;
+    bFrameStart = OMX_FALSE;
+
+    if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
+        if (*pInputStream == 0x03) { /* FIMV1 */
+            if (ghMFCHandle != NULL) {
+                BitmapInfoHhr *pInfoHeader;
+                SSBSIP_MFC_IMG_RESOLUTION imgResolution;
+
+                pInfoHeader = (BitmapInfoHhr *)(pInputStream + 1);
+                imgResolution.width = pInfoHeader->BiWidth;
+                imgResolution.height = pInfoHeader->BiHeight;
+                SsbSipMfcDecSetConfig(ghMFCHandle, MFC_DEC_SETCONF_FIMV1_WIDTH_HEIGHT, &imgResolution);
+
+                SEC_OSAL_Log(SEC_LOG_TRACE, "width(%d), height(%d)", imgResolution.width, imgResolution.height);
+                gbFIMV1 = OMX_TRUE;
+                *pbEndOfFrame = OMX_TRUE;
+                return buffSize;
+            }
+        }
+    }
+
+    if (gbFIMV1) {
+        *pbEndOfFrame = OMX_TRUE;
+        return buffSize;
+    }
+
+    if (bPreviousFrameEOF == OMX_FALSE)
+        bFrameStart = OMX_TRUE;
+
+    startCode = 0xFFFFFFFF;
+    if (bFrameStart == OMX_FALSE) {
+        /* find VOP start code */
+        while(startCode != 0x1B6) {
+            readStream = *(pInputStream + len);
+            startCode = (startCode << 8) | readStream;
+            len++;
+            if (len > buffSize)
+                goto EXIT;
+        }
+    }
+
+    /* find next VOP start code */
+    startCode = 0xFFFFFFFF;
+    while ((startCode != 0x1B6)) {
+        readStream = *(pInputStream + len);
+        startCode = (startCode << 8) | readStream;
+        len++;
+        if (len > buffSize)
+            goto EXIT;
+    }
+
+    *pbEndOfFrame = OMX_TRUE;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "1. Check_Mpeg4_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
+
+    return len - 4;
+
+EXIT :
+    *pbEndOfFrame = OMX_FALSE;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "2. Check_Mpeg4_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 1, buffSize);
+
+    return --len;
+}
+
+static int Check_H263_Frame(OMX_U8 *pInputStream, OMX_U32 buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame)
+{
+    int len, readStream;
+    unsigned startCode;
+    OMX_BOOL bFrameStart = 0;
+
+    len = 0;
+    bFrameStart = OMX_FALSE;
+
+    if (bPreviousFrameEOF == OMX_FALSE)
+        bFrameStart = OMX_TRUE;
+
+    startCode = 0xFFFFFFFF;
+    if (bFrameStart == OMX_FALSE) {
+        /* find PSC(Picture Start Code) : 0000 0000 0000 0000 1000 00 */
+        while (((startCode << 8 >> 10) != 0x20)) {
+            readStream = *(pInputStream + len);
+            startCode = (startCode << 8) | readStream;
+            len++;
+            if (len > buffSize)
+                goto EXIT;
+        }
+    }
+
+    /* find next PSC */
+    startCode = 0xFFFFFFFF;
+    while (((startCode << 8 >> 10) != 0x20)) {
+        readStream = *(pInputStream + len);
+        startCode = (startCode << 8) | readStream;
+        len++;
+        if (len > buffSize)
+            goto EXIT;
+    }
+
+    *pbEndOfFrame = OMX_TRUE;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "1. Check_H263_Frame returned EOF = %d, len = %d, iBuffSize = %d", *pbEndOfFrame, len - 3, buffSize);
+
+    return len - 3;
+
+EXIT :
+
+    *pbEndOfFrame = OMX_FALSE;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "2. Check_H263_Frame returned EOF = %d, len = %d, iBuffSize = %d", *pbEndOfFrame, len - 1, buffSize);
+
+    return --len;
+}
+
+OMX_BOOL Check_Stream_PrefixCode(OMX_U8 *pInputStream, OMX_U32 streamSize, CODEC_TYPE codecType)
+{
+    switch (codecType) {
+    case CODEC_TYPE_MPEG4:
+        if (gbFIMV1) {
+            return OMX_TRUE;
+        } else {
+            if (streamSize < 3) {
+                return OMX_FALSE;
+            } else if ((pInputStream[0] == 0x00) &&
+                       (pInputStream[1] == 0x00) &&
+                       (pInputStream[2] == 0x01)) {
+                return OMX_TRUE;
+            } else {
+                return OMX_FALSE;
+            }
+        }
+        break;
+    case CODEC_TYPE_H263:
+        return OMX_TRUE;
+    default:
+        SEC_OSAL_Log(SEC_LOG_WARNING, "%s: undefined codec type (%d)", __FUNCTION__, codecType);
+        return OMX_FALSE;
+    }
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4Dec_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_StateInvalid;
+        goto EXIT;
+    }
+
+    switch (nParamIndex) {
+    case OMX_IndexParamVideoMpeg4:
+    {
+        OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
+        SEC_MPEG4_HANDLE          *pMpeg4Dec = NULL;
+        ret = SEC_OMX_Check_SizeVersion(pDstMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstMpeg4Param->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
+    }
+        break;
+    case OMX_IndexParamVideoH263:
+    {
+        OMX_VIDEO_PARAM_H263TYPE  *pDstH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_H263TYPE  *pSrcH263Param = NULL;
+        SEC_MPEG4_HANDLE          *pMpeg4Dec = NULL;
+        ret = SEC_OMX_Check_SizeVersion(pDstH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstH263Param->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcH263Param = &pMpeg4Dec->h263Component[pDstH263Param->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
+    }
+        break;
+    case OMX_IndexParamStandardComponentRole:
+    {
+        OMX_S32 codecType;
+        OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
+        ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        codecType = ((SEC_MPEG4_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
+        if (codecType == CODEC_TYPE_MPEG4)
+            SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPOMENT_MPEG4_DEC_ROLE);
+        else
+            SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPOMENT_H263_DEC_ROLE);
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelQuerySupported:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        SEC_OMX_VIDEO_PROFILELEVEL       *pProfileLevel = NULL;
+        OMX_U32                           maxProfileLevelNum = 0;
+        OMX_S32                           codecType;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        codecType = ((SEC_MPEG4_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
+        if (codecType == CODEC_TYPE_MPEG4) {
+            pProfileLevel = supportedMPEG4ProfileLevels;
+            maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
+        } else {
+            pProfileLevel = supportedH263ProfileLevels;
+            maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
+        }
+
+        if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
+            ret = OMX_ErrorNoMore;
+            goto EXIT;
+        }
+
+        pProfileLevel += pDstProfileLevel->nProfileIndex;
+        pDstProfileLevel->eProfile = pProfileLevel->profile;
+        pDstProfileLevel->eLevel = pProfileLevel->level;
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_MPEG4TYPE        *pSrcMpeg4Param = NULL;
+        OMX_VIDEO_PARAM_H263TYPE         *pSrcH263Param = NULL;
+        SEC_MPEG4_HANDLE                 *pMpeg4Dec = NULL;
+        OMX_S32                           codecType;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
+        if (codecType == CODEC_TYPE_MPEG4) {
+            pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstProfileLevel->nPortIndex];
+            pDstProfileLevel->eProfile = pSrcMpeg4Param->eProfile;
+            pDstProfileLevel->eLevel = pSrcMpeg4Param->eLevel;
+        } else {
+            pSrcH263Param = &pMpeg4Dec->h263Component[pDstProfileLevel->nPortIndex];
+            pDstProfileLevel->eProfile = pSrcH263Param->eProfile;
+            pDstProfileLevel->eLevel = pSrcH263Param->eLevel;
+        }
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
+        SEC_MPEG4_HANDLE                    *pMpeg4Dec = 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;
+        }
+
+        pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcErrorCorrectionType = &pMpeg4Dec->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_Mpeg4Dec_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_StateInvalid;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexParamVideoMpeg4:
+    {
+        OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
+        OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
+        SEC_MPEG4_HANDLE          *pMpeg4Dec = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcMpeg4Param->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
+    }
+        break;
+    case OMX_IndexParamVideoH263:
+    {
+        OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
+        OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
+        SEC_MPEG4_HANDLE         *pMpeg4Dec = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcH263Param->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        pDstH263Param = &pMpeg4Dec->h263Component[pSrcH263Param->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
+    }
+        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_COMPOMENT_MPEG4_DEC_ROLE)) {
+            pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+            //((SEC_MPEG4_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_MPEG4;
+        } else if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPOMENT_H263_DEC_ROLE)) {
+            pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
+            //((SEC_MPEG4_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_H263;
+        } 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;
+
+        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);
+
+        width = ((pSECPort->portDefinition.format.video.nFrameWidth + 15) & (~15));
+        height = ((pSECPort->portDefinition.format.video.nFrameHeight + 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;
+            if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar) {
+                pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
+            } else if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatYUV422Planar) {
+                pSECOutputPort->portDefinition.nBufferSize = width * height * 2;
+            }
+        }
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_MPEG4TYPE        *pDstMpeg4Param = NULL;
+        OMX_VIDEO_PARAM_H263TYPE         *pDstH263Param = NULL;
+        SEC_MPEG4_HANDLE                 *pMpeg4Dec = NULL;
+        OMX_S32                           codecType;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
+        if (codecType == CODEC_TYPE_MPEG4) {
+            /*
+             * To do: Check validity of profile & level parameters
+             */
+
+            pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcProfileLevel->nPortIndex];
+            pDstMpeg4Param->eProfile = pSrcProfileLevel->eProfile;
+            pDstMpeg4Param->eLevel = pSrcProfileLevel->eLevel;
+        } else {
+            /*
+             * To do: Check validity of profile & level parameters
+             */
+
+            pDstH263Param = &pMpeg4Dec->h263Component[pSrcProfileLevel->nPortIndex];
+            pDstH263Param->eProfile = pSrcProfileLevel->eProfile;
+            pDstH263Param->eLevel = pSrcProfileLevel->eLevel;
+        }
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
+        SEC_MPEG4_HANDLE                    *pMpeg4Dec = 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;
+        }
+
+        pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        pDstErrorCorrectionType = &pMpeg4Dec->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_Mpeg4Dec_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) {
+    case OMX_IndexVendorThumbnailMode:
+    {
+        SEC_MPEG4_HANDLE  *pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+
+        pMpeg4Dec->hMFCMpeg4Handle.bThumbnailMode = *((OMX_BOOL *)pComponentConfigStructure);
+    }
+        break;
+    default:
+        ret = SEC_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4Dec_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, "OMX.SEC.index.ThumbnailMode") == 0) {
+        SEC_MPEG4_HANDLE *pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+
+        *pIndexType = OMX_IndexVendorThumbnailMode;
+
+        ret = OMX_ErrorNone;
+    } else {
+        ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4Dec_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;
+    OMX_S32                  codecType;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (cRole == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) {
+        ret = OMX_ErrorNoMore;
+        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_StateInvalid;
+        goto EXIT;
+    }
+
+    codecType = ((SEC_MPEG4_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
+    if (codecType == CODEC_TYPE_MPEG4)
+        SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPOMENT_MPEG4_DEC_ROLE);
+    else
+        SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPOMENT_H263_DEC_ROLE);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Init */
+OMX_ERRORTYPE SEC_MFC_Mpeg4Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_MPEG4_HANDLE      *pMpeg4Dec = NULL;
+    OMX_HANDLETYPE         hMFCHandle = NULL;
+    OMX_PTR                pStreamBuffer = NULL;
+    OMX_PTR                pStreamPhyBuffer = NULL;
+
+    FunctionIn();
+
+    pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+    pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFC = OMX_FALSE;
+    pSECComponent->bUseFlagEOF = OMX_FALSE;
+    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+
+    /* MFC(Multi Format Codec) decoder and CMM(Codec Memory Management) driver open */
+    hMFCHandle = SsbSipMfcDecOpen();
+    if (hMFCHandle == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    ghMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = hMFCHandle;
+
+    /* Allocate decoder's input buffer */
+    pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE);
+    if (pStreamBuffer == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer    = pStreamBuffer;
+    pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer = pStreamPhyBuffer;
+    pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pStreamBuffer;
+    pSECComponent->processData[INPUT_PORT_INDEX].allocSize = DEFAULT_MFC_INPUT_BUFFER_SIZE;
+
+    SEC_OSAL_Memset(pMpeg4Dec->hMFCMpeg4Handle.timestamp, 0, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+    pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp = 0;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Terminate */
+OMX_ERRORTYPE SEC_MFC_Mpeg4Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_MPEG4_HANDLE      *pMpeg4Dec = NULL;
+    OMX_HANDLETYPE         hMFCHandle = NULL;
+
+    FunctionIn();
+
+    pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+    hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
+
+    pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer    = NULL;
+    pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer = NULL;
+    pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = NULL;
+    pSECComponent->processData[INPUT_PORT_INDEX].allocSize = 0;
+
+    if (hMFCHandle != NULL) {
+        SsbSipMfcDecClose(hMFCHandle);
+        pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = NULL;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4_Decode(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_MPEG4_HANDLE          *pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+    OMX_HANDLETYPE             hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
+    OMX_U32                    oneFrameSize = pInputData->dataLen;
+    SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
+    OMX_S32                    configValue;
+    OMX_S32                    returnCodec;
+    int                        bufWidth;
+    int                        bufHeight;
+
+    FunctionIn();
+
+    if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFC == OMX_FALSE) {
+        SSBSIP_MFC_CODEC_TYPE MFCCodecType;
+        if (pMpeg4Dec->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4) {
+            if (gbFIMV1)
+                MFCCodecType = FIMV1_DEC;
+            else
+                MFCCodecType = MPEG4_DEC;
+        } else {
+            MFCCodecType = H263_DEC;
+        }
+
+        /* Set the number of extra buffer to prevent tearing */
+        configValue = 5;
+        SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &configValue);
+
+        /* Set mpeg4 deblocking filter enable */
+        configValue = 1;
+        SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_POST_ENABLE, &configValue);
+
+        if (pMpeg4Dec->hMFCMpeg4Handle.bThumbnailMode == OMX_TRUE) {
+            configValue = 0;    // the number that you want to delay
+            SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &configValue);
+        }
+
+        returnCodec = SsbSipMfcDecInit(hMFCHandle, MFCCodecType, oneFrameSize);
+        if (returnCodec == MFC_RET_OK) {
+            SSBSIP_MFC_IMG_RESOLUTION imgResol;
+            SEC_OMX_BASEPORT *pInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+
+            if (SsbSipMfcDecGetConfig(hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol) != MFC_RET_OK) {
+                ret = OMX_ErrorMFCInit;
+                SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcDecGetConfig failed", __FUNCTION__);
+                goto EXIT;
+            }
+
+            /** Update Frame Size **/
+            if ((pInputPort->portDefinition.format.video.nFrameWidth != imgResol.width) ||
+               (pInputPort->portDefinition.format.video.nFrameHeight != imgResol.height)) {
+                /* change width and height information */
+                pInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
+                pInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
+                pInputPort->portDefinition.format.video.nStride      = ((imgResol.width + 15) & (~15));
+                pInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
+
+                SEC_UpdateFrameSize(pOMXComponent);
+
+                /* Send Port Settings changed call back */
+                (*(pSECComponent->pCallbacks->EventHandler))
+                      (pOMXComponent,
+                       pSECComponent->callbackData,
+                       OMX_EventPortSettingsChanged, // The command was completed
+                       OMX_DirOutput, // This is the port index
+                       0,
+                       NULL);
+            }
+
+            SEC_OSAL_Log(SEC_LOG_TRACE, "nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
+                    pInputPort->portDefinition.format.video.nFrameWidth,  pInputPort->portDefinition.format.video.nFrameHeight,
+                    pInputPort->portDefinition.format.video.nStride, pInputPort->portDefinition.format.video.nSliceHeight);
+
+            pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFC = OMX_TRUE;
+            if (pMpeg4Dec->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4) {
+                ret = OMX_ErrorNone;
+            } else {
+                pOutputData->dataLen = 0;
+                ret = OMX_ErrorInputDataDecodeYet;
+            }
+            goto EXIT;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcDecInit failed", __FUNCTION__);
+            ret = OMX_ErrorMFCInit;    /* OMX_ErrorUndefined */
+            goto EXIT;
+        }
+    }
+
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE)) {
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+    }
+
+    pMpeg4Dec->hMFCMpeg4Handle.timestamp[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pInputData->timeStamp;
+    SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp));
+    pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp++;
+    if (pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp >= MAX_TIMESTAMP)
+        pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp = 0;
+
+    if (oneFrameSize <= 0) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    returnCodec = SsbSipMfcDecExe(hMFCHandle, oneFrameSize);
+    if (returnCodec == MFC_RET_OK) {
+        SSBSIP_MFC_DEC_OUTBUF_STATUS status;
+        OMX_S32 indexTimestamp = 0;
+
+        status = SsbSipMfcDecGetOutBuf(hMFCHandle, &outputInfo);
+
+        bufWidth =  (outputInfo.img_width + 15) & (~15);
+        bufHeight =  (outputInfo.img_height + 15) & (~15);
+
+        if (SsbSipMfcDecGetConfig(hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) == MFC_RET_OK)
+            pOutputData->timeStamp = pMpeg4Dec->hMFCMpeg4Handle.timestamp[indexTimestamp];
+        else
+            pOutputData->timeStamp = pInputData->timeStamp;
+
+        if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
+            (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
+            switch(pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
+            case OMX_COLOR_FormatYUV420Planar:
+            case OMX_COLOR_FormatYUV420SemiPlanar:
+                pOutputData->dataLen = (bufWidth * bufHeight * 3) /2;
+                break;
+            default:
+                pOutputData->dataLen = bufWidth * bufHeight * 2;
+                break;
+            }
+        }
+
+        if (status == MFC_GETOUTBUF_DISPLAY_ONLY) {
+            ret = OMX_ErrorInputDataDecodeYet;
+        }
+        if (status == MFC_GETOUTBUF_DECODING_ONLY) {
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+    } else {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    /** Fill Output Buffer **/
+    if (pOutputData->dataLen > 0)
+    {
+        int frameSize = bufWidth * bufHeight;
+        void *pOutputBuf = (void *)pOutputData->dataBuffer;
+
+#ifdef USE_SAMSUNG_COLORFORMAT
+        SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+
+        if ((pMpeg4Dec->hMFCMpeg4Handle.bThumbnailMode == OMX_FALSE) ||
+            (pSECOutputPort->portDefinition.format.video.eColorFormat == SEC_OMX_COLOR_FormatNV12PhysicalAddress))
+
+#else
+        if (pMpeg4Dec->hMFCMpeg4Handle.bThumbnailMode == OMX_FALSE)
+#endif
+        {
+            /* if use Post copy address structure */
+            SEC_OSAL_Memcpy(pOutputBuf, &frameSize, sizeof(frameSize));
+            SEC_OSAL_Memcpy(pOutputBuf + sizeof(frameSize), &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
+            SEC_OSAL_Memcpy(pOutputBuf + sizeof(frameSize) + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
+            SEC_OSAL_Memcpy(pOutputBuf + sizeof(frameSize) + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
+            SEC_OSAL_Memcpy(pOutputBuf + sizeof(frameSize) + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
+        } else {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 out for ThumbnailMode");
+            tile_to_linear_4x2(pOutputBuf, (unsigned char *)outputInfo.YVirAddr, bufWidth, bufHeight);
+            tile_to_linear_4x2(pOutputBuf + frameSize, (unsigned char *)outputInfo.CVirAddr, bufWidth, bufHeight / 2);
+        }
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Decode */
+OMX_ERRORTYPE SEC_MFC_Mpeg4Dec_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_MPEG4_HANDLE        *pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+    SEC_OMX_BASEPORT        *pInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT        *pOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    OMX_BOOL                 bCheckPrefix = OMX_FALSE;
+
+    FunctionIn();
+
+    if ((!CHECK_PORT_ENABLED(pInputPort)) || (!CHECK_PORT_ENABLED(pOutputPort)) ||
+            (!CHECK_PORT_POPULATED(pInputPort)) || (!CHECK_PORT_POPULATED(pOutputPort))) {
+        goto EXIT;
+    }
+    if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
+        goto EXIT;
+    }
+
+    if (pInputData->nFlags & OMX_BUFFERFLAG_EOS) {
+        pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
+    } else {
+        pOutputData->nFlags = pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS);
+    }
+
+    bCheckPrefix = Check_Stream_PrefixCode(pInputData->dataBuffer, pInputData->dataLen, pMpeg4Dec->hMFCMpeg4Handle.codecType);
+
+    if (bCheckPrefix == OMX_TRUE) {
+        ret = SEC_MFC_Mpeg4_Decode(pOMXComponent, pInputData, pOutputData);
+    } else {
+        ret = OMX_ErrorNone;
+    }
+    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->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_MPEG4_HANDLE        *pMpeg4Dec = NULL;
+    OMX_S32                  codecType = -1;
+    int i = 0;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (componentName == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: parameters are null, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+    if (SEC_OSAL_Strcmp(SEC_OMX_COMPOMENT_MPEG4_DEC, componentName) == 0) {
+        codecType = CODEC_TYPE_MPEG4;
+    } else if (SEC_OSAL_Strcmp(SEC_OMX_COMPOMENT_H263_DEC, componentName) == 0) {
+        codecType = CODEC_TYPE_H263;
+    } else {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: componentName(%s) error, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_VideoDecodeComponentInit(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_OMX_VideoDecodeComponentInit error, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pSECComponent->codecType = HW_VIDEO_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, "%s: componentName alloc error, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
+
+    pMpeg4Dec = SEC_OSAL_Malloc(sizeof(SEC_MPEG4_HANDLE));
+    if (pMpeg4Dec == NULL) {
+        SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_MPEG4_HANDLE alloc error, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pMpeg4Dec, 0, sizeof(SEC_MPEG4_HANDLE));
+    pSECComponent->hCodecHandle = (OMX_HANDLETYPE)pMpeg4Dec;
+    pMpeg4Dec->hMFCMpeg4Handle.codecType = codecType;
+
+    if (codecType == CODEC_TYPE_MPEG4)
+        SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPOMENT_MPEG4_DEC);
+    else
+        SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPOMENT_H263_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;
+    if (codecType == CODEC_TYPE_MPEG4) {
+        pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+        SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
+        SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/mpeg4");
+    } else {
+        pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
+        SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
+        SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/h263");
+    }
+    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;
+
+    if (codecType == CODEC_TYPE_MPEG4) {
+        for(i = 0; i < ALL_PORT_NUM; i++) {
+            INIT_SET_SIZE_VERSION(&pMpeg4Dec->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
+            pMpeg4Dec->mpeg4Component[i].nPortIndex = i;
+            pMpeg4Dec->mpeg4Component[i].eProfile   = OMX_VIDEO_MPEG4ProfileSimple;
+            pMpeg4Dec->mpeg4Component[i].eLevel     = OMX_VIDEO_MPEG4Level3;
+        }
+    } else {
+        for(i = 0; i < ALL_PORT_NUM; i++) {
+            INIT_SET_SIZE_VERSION(&pMpeg4Dec->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
+            pMpeg4Dec->h263Component[i].nPortIndex = i;
+            pMpeg4Dec->h263Component[i].eProfile   = OMX_VIDEO_H263ProfileBaseline | OMX_VIDEO_H263ProfileISWV2;
+            pMpeg4Dec->h263Component[i].eLevel     = OMX_VIDEO_H263Level45;
+        }
+    }
+
+    pOMXComponent->GetParameter      = &SEC_MFC_Mpeg4Dec_GetParameter;
+    pOMXComponent->SetParameter      = &SEC_MFC_Mpeg4Dec_SetParameter;
+    pOMXComponent->SetConfig         = &SEC_MFC_Mpeg4Dec_SetConfig;
+    pOMXComponent->GetExtensionIndex = &SEC_MFC_Mpeg4Dec_GetExtensionIndex;
+    pOMXComponent->ComponentRoleEnum = &SEC_MFC_Mpeg4Dec_ComponentRoleEnum;
+    pOMXComponent->ComponentDeInit   = &SEC_OMX_ComponentDeinit;
+
+    pSECComponent->sec_mfc_componentInit      = &SEC_MFC_Mpeg4Dec_Init;
+    pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_Mpeg4Dec_Terminate;
+    pSECComponent->sec_mfc_bufferProcess      = &SEC_MFC_Mpeg4Dec_bufferProcess;
+    if (codecType == CODEC_TYPE_MPEG4)
+        pSECComponent->sec_checkInputFrame = &Check_Mpeg4_Frame;
+    else
+        pSECComponent->sec_checkInputFrame = &Check_H263_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_MPEG4_HANDLE        *pMpeg4Dec = 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;
+
+    pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+    if (pMpeg4Dec != NULL) {
+        SEC_OSAL_Free(pMpeg4Dec);
+        pSECComponent->hCodecHandle = NULL;
+    }
+
+    ret = SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.h b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.h
new file mode 100644
index 0000000..fbd8854
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.h
@@ -0,0 +1,94 @@
+/*
+ *
+ * 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_Mpeg4dec.h
+ * @brief
+ * @author      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_MPEG4_DEC_COMPONENT
+#define SEC_OMX_MPEG4_DEC_COMPONENT
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Component.h"
+
+#define MAX_TIMESTAMP        16
+
+
+typedef enum _CODEC_TYPE
+{
+    CODEC_TYPE_H263,
+    CODEC_TYPE_MPEG4
+} CODEC_TYPE;
+
+/*
+ * 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_MPEG4_HANDLE
+{
+    OMX_HANDLETYPE hMFCHandle;
+    OMX_PTR        pMFCStreamBuffer;
+    OMX_PTR        pMFCStreamPhyBuffer;
+    OMX_TICKS      timestamp[MAX_TIMESTAMP];
+    OMX_U32        indexTimestamp;
+    OMX_BOOL       bConfiguredMFC;
+    OMX_BOOL       bThumbnailMode;
+    CODEC_TYPE     codecType;
+} SEC_MFC_MPEG4_HANDLE;
+
+typedef struct _SEC_MPEG4_HANDLE
+{
+    /* OMX Codec specific */
+    OMX_VIDEO_PARAM_H263TYPE  h263Component[ALL_PORT_NUM];
+    OMX_VIDEO_PARAM_MPEG4TYPE mpeg4Component[ALL_PORT_NUM];
+    OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType[ALL_PORT_NUM];
+
+    /* SEC MFC Codec specific */
+    SEC_MFC_MPEG4_HANDLE      hMFCMpeg4Handle;
+} SEC_MPEG4_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/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.c b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.c
new file mode 100644
index 0000000..89b856d
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.c
@@ -0,0 +1,63 @@
+/*
+ *
+ * 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      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : 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_MPEG4_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 MPEG4 */
+    SEC_OSAL_Strcpy(ppSECComponent[0]->componentName, SEC_OMX_COMPOMENT_MPEG4_DEC);
+    SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPOMENT_MPEG4_DEC_ROLE);
+    ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+    /* component 2 - video decoder H.263 */
+    SEC_OSAL_Strcpy(ppSECComponent[1]->componentName, SEC_OMX_COMPOMENT_H263_DEC);
+    SEC_OSAL_Strcpy(ppSECComponent[1]->roles[0], SEC_OMX_COMPOMENT_H263_DEC_ROLE);
+    ppSECComponent[1]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+    FunctionOut();
+    return MAX_COMPONENT_NUM;
+}
+
diff --git a/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.h b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.h
new file mode 100644
index 0000000..e9bcfe8
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.h
@@ -0,0 +1,59 @@
+/*
+ *
+ * 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      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_MPEG4_DEC_REG
+#define SEC_OMX_MPEG4_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              2
+#define MAX_COMPONENT_ROLE_NUM    1
+
+/* MPEG4 */
+#define SEC_OMX_COMPOMENT_MPEG4_DEC         "OMX.SEC.MPEG4.Decoder"
+#define SEC_OMX_COMPOMENT_MPEG4_DEC_ROLE    "video_decoder.mpeg4"
+
+/* H.263 */
+#define SEC_OMX_COMPOMENT_H263_DEC          "OMX.SEC.H263.Decoder"
+#define SEC_OMX_COMPOMENT_H263_DEC_ROLE     "video_decoder.h263"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
+
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.c b/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.c
new file mode 100644
index 0000000..e5bd981
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.c
@@ -0,0 +1,1342 @@
+/*
+ *
+ * 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_Venc.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ *              Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "SEC_OMX_Macros.h"
+#include "SEC_OSAL_Event.h"
+#include "SEC_OMX_Venc.h"
+#include "SEC_OMX_Basecomponent.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_VIDEO_ENC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+#define ONE_FRAME_OUTPUT  /* only one frame output for Android */
+#define S5PC110_ENCODE_IN_DATA_BUFFER /* for Android s5pc110 0copy*/
+
+
+inline void SEC_UpdateFrameSize(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *secInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT      *secOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+
+    if ((secOutputPort->portDefinition.format.video.nFrameWidth !=
+            secInputPort->portDefinition.format.video.nFrameWidth) ||
+        (secOutputPort->portDefinition.format.video.nFrameHeight !=
+            secInputPort->portDefinition.format.video.nFrameHeight)) {
+        OMX_U32 width = 0, height = 0;
+
+        secOutputPort->portDefinition.format.video.nFrameWidth =
+            secInputPort->portDefinition.format.video.nFrameWidth;
+        secOutputPort->portDefinition.format.video.nFrameHeight =
+            secInputPort->portDefinition.format.video.nFrameHeight;
+        width = secOutputPort->portDefinition.format.video.nStride =
+            secInputPort->portDefinition.format.video.nStride;
+        height = secOutputPort->portDefinition.format.video.nSliceHeight =
+            secInputPort->portDefinition.format.video.nSliceHeight;
+
+        switch(secOutputPort->portDefinition.format.video.eColorFormat) {
+        case OMX_COLOR_FormatYUV420Planar:
+        case OMX_COLOR_FormatYUV420SemiPlanar:
+            if (width && height)
+                secOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
+            break;
+        default:
+            if (width && height)
+                secOutputPort->portDefinition.nBufferSize = width * height * 2;
+            break;
+        }
+    }
+
+  return ;
+}
+
+OMX_ERRORTYPE SEC_OMX_UseBuffer(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN OMX_U32                   nSizeBytes,
+    OMX_IN OMX_U8                   *pBuffer)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE  *temp_bufferHeader = NULL;
+    int                    i = 0;
+
+    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;
+
+    pSECPort = &pSECComponent->pSECPort[nPortIndex];
+    if (nPortIndex >= pSECComponent->portParam.nPorts) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+    if (pSECPort->portState != OMX_StateIdle) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+
+    if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
+    if (temp_bufferHeader == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
+
+    for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
+        if (pSECPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
+            pSECPort->bufferHeader[i] = temp_bufferHeader;
+            pSECPort->bufferStateAllocate[i] = (BUFFER_STATE_ASSIGNED | HEADER_STATE_ALLOCATED);
+            INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
+            temp_bufferHeader->pBuffer        = pBuffer;
+            temp_bufferHeader->nAllocLen        = nSizeBytes;
+            temp_bufferHeader->pAppPrivate        = pAppPrivate;
+            if (nPortIndex == INPUT_PORT_INDEX)
+                temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
+            else
+                temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
+
+            pSECPort->assignedBufferNum++;
+            if (pSECPort->assignedBufferNum == pSECPort->portDefinition.nBufferCountActual) {
+                pSECPort->portDefinition.bPopulated = OMX_TRUE;
+                /* SEC_OSAL_MutexLock(pSECComponent->compMutex); */
+                SEC_OSAL_SemaphorePost(pSECPort->loadedResource);
+                /* SEC_OSAL_MutexUnlock(pSECComponent->compMutex); */
+            }
+            *ppBufferHdr = temp_bufferHeader;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+    }
+    ret = OMX_ErrorInsufficientResources;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_AllocateBuffer(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBuffer,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN OMX_U32                   nSizeBytes)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE  *temp_bufferHeader = NULL;
+    OMX_U8                *temp_buffer = NULL;
+    int                    i = 0;
+
+    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;
+
+    pSECPort = &pSECComponent->pSECPort[nPortIndex];
+    if (nPortIndex >= pSECComponent->portParam.nPorts) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+/*
+    if (pSECPort->portState != OMX_StateIdle ) {
+        ret = OMX_ErrorIncorrectStateOperation;
+        goto EXIT;
+    }
+*/
+    if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    temp_buffer = SEC_OSAL_Malloc(sizeof(OMX_U8) * nSizeBytes);
+    if (temp_buffer == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+SEC_OSAL_Log(SEC_LOG_TRACE, "SEC_OMX_AllocateBuffer => port:%d, size:%d", nPortIndex, nSizeBytes);
+
+    temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
+    if (temp_bufferHeader == NULL) {
+        SEC_OSAL_Free(temp_buffer);
+        temp_buffer = NULL;
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
+
+    for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
+        if (pSECPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
+            pSECPort->bufferHeader[i] = temp_bufferHeader;
+            pSECPort->bufferStateAllocate[i] = (BUFFER_STATE_ALLOCATED | HEADER_STATE_ALLOCATED);
+            INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
+            temp_bufferHeader->pBuffer        = temp_buffer;
+            temp_bufferHeader->nAllocLen        = nSizeBytes;
+            temp_bufferHeader->pAppPrivate        = pAppPrivate;
+            if (nPortIndex == INPUT_PORT_INDEX)
+                temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
+            else
+                temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
+            pSECPort->assignedBufferNum++;
+            if (pSECPort->assignedBufferNum == pSECPort->portDefinition.nBufferCountActual) {
+                pSECPort->portDefinition.bPopulated = OMX_TRUE;
+                /* SEC_OSAL_MutexLock(pSECComponent->compMutex); */
+                SEC_OSAL_SemaphorePost(pSECPort->loadedResource);
+                /* SEC_OSAL_MutexUnlock(pSECComponent->compMutex); */
+            }
+            *ppBuffer = temp_bufferHeader;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+    }
+    ret = OMX_ErrorInsufficientResources;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_FreeBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_U32        nPortIndex,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE  *temp_bufferHeader = NULL;
+    OMX_U8                *temp_buffer = NULL;
+    int                    i = 0;
+
+    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;
+    pSECPort = &pSECComponent->pSECPort[nPortIndex];
+
+    if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
+        ret = OMX_ErrorBadPortIndex;
+        goto EXIT;
+    }
+
+    if ((pSECPort->portState != OMX_StateLoaded) && (pSECPort->portState != OMX_StateInvalid)) {
+        (*(pSECComponent->pCallbacks->EventHandler)) (pOMXComponent,
+                        pSECComponent->callbackData,
+                        (OMX_U32)OMX_EventError,
+                        (OMX_U32)OMX_ErrorPortUnpopulated,
+                        nPortIndex, NULL);
+    }
+
+    for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
+        if (((pSECPort->bufferStateAllocate[i] | BUFFER_STATE_FREE) != 0) && (pSECPort->bufferHeader[i] != NULL)) {
+            if (pSECPort->bufferHeader[i]->pBuffer == pBufferHdr->pBuffer) {
+                if (pSECPort->bufferStateAllocate[i] & BUFFER_STATE_ALLOCATED) {
+                    SEC_OSAL_Free(pSECPort->bufferHeader[i]->pBuffer);
+                    pSECPort->bufferHeader[i]->pBuffer = NULL;
+                    pBufferHdr->pBuffer = NULL;
+                } else if (pSECPort->bufferStateAllocate[i] & BUFFER_STATE_ASSIGNED) {
+                    ; /* None*/
+                }
+                pSECPort->assignedBufferNum--;
+                if (pSECPort->bufferStateAllocate[i] & HEADER_STATE_ALLOCATED) {
+                    SEC_OSAL_Free(pSECPort->bufferHeader[i]);
+                    pSECPort->bufferHeader[i] = NULL;
+                    pBufferHdr = NULL;
+                }
+                pSECPort->bufferStateAllocate[i] = BUFFER_STATE_FREE;
+                ret = OMX_ErrorNone;
+                goto EXIT;
+            }
+        }
+    }
+
+EXIT:
+    if (ret == OMX_ErrorNone) {
+        if (pSECPort->assignedBufferNum == 0 ) {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "pSECPort->unloadedResource signal set");
+            /* SEC_OSAL_MutexLock(pSECComponent->compMutex); */
+            SEC_OSAL_SemaphorePost(pSECPort->unloadedResource);
+            /* SEC_OSAL_MutexUnlock(pSECComponent->compMutex); */
+            pSECPort->portDefinition.bPopulated = OMX_FALSE;
+        }
+    }
+
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_AllocateTunnelBuffer(SEC_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
+{
+    OMX_ERRORTYPE                 ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT             *pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE         *temp_bufferHeader = NULL;
+    OMX_U8                       *temp_buffer = NULL;
+    OMX_U32                       bufferSize = 0;
+    OMX_PARAM_PORTDEFINITIONTYPE  portDefinition;
+
+    ret = OMX_ErrorTunnelingUnsupported;
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_FreeTunnelBuffer(SEC_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT* pSECPort = NULL;
+    OMX_BUFFERHEADERTYPE* temp_bufferHeader = NULL;
+    OMX_U8 *temp_buffer = NULL;
+    OMX_U32 bufferSize = 0;
+    OMX_PARAM_PORTDEFINITIONTYPE portDefinition;
+
+    ret = OMX_ErrorTunnelingUnsupported;
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_ComponentTunnelRequest(
+    OMX_IN OMX_HANDLETYPE hComp,
+    OMX_IN OMX_U32        nPort,
+    OMX_IN OMX_HANDLETYPE hTunneledComp,
+    OMX_IN OMX_U32        nTunneledPort,
+    OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    ret = OMX_ErrorTunnelingUnsupported;
+EXIT:
+    return ret;
+}
+
+OMX_BOOL SEC_Check_BufferProcess_State(SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    if ((pSECComponent->currentState == OMX_StateExecuting) &&
+        (pSECComponent->pSECPort[INPUT_PORT_INDEX].portState == OMX_StateIdle) &&
+        (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portState == OMX_StateIdle) &&
+        (pSECComponent->transientState != SEC_OMX_TransStateExecutingToIdle) &&
+        (pSECComponent->transientState != SEC_OMX_TransStateIdleToExecuting))
+        return OMX_TRUE;
+    else
+        return OMX_FALSE;
+}
+
+static OMX_ERRORTYPE SEC_InputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *secOMXInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT      *secOMXOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATABUFFER    *dataBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+    OMX_BUFFERHEADERTYPE  *bufferHeader = dataBuffer->bufferHeader;
+
+    FunctionIn();
+
+    if (secOMXInputPort->markType.hMarkTargetComponent != NULL ) {
+        bufferHeader->hMarkTargetComponent      = secOMXInputPort->markType.hMarkTargetComponent;
+        bufferHeader->pMarkData                 = secOMXInputPort->markType.pMarkData;
+        secOMXInputPort->markType.hMarkTargetComponent = NULL;
+        secOMXInputPort->markType.pMarkData = NULL;
+    }
+
+    if (bufferHeader->hMarkTargetComponent != NULL) {
+        if (bufferHeader->hMarkTargetComponent == pOMXComponent) {
+            pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                            pSECComponent->callbackData,
+                            OMX_EventMark,
+                            0, 0, bufferHeader->pMarkData);
+        } else {
+            pSECComponent->propagateMarkType.hMarkTargetComponent = bufferHeader->hMarkTargetComponent;
+            pSECComponent->propagateMarkType.pMarkData = bufferHeader->pMarkData;
+        }
+    }
+
+    if ((pSECComponent->currentState == OMX_StatePause) &&
+        ((!CHECK_PORT_BEING_FLUSHED(secOMXInputPort) && !CHECK_PORT_BEING_FLUSHED(secOMXOutputPort)))) {
+        SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
+        SEC_OSAL_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
+    }
+
+    if (bufferHeader != NULL) {
+        if (CHECK_PORT_TUNNELED(secOMXInputPort)) {
+            OMX_FillThisBuffer(secOMXInputPort->tunneledComponent, bufferHeader);
+        } else {
+            bufferHeader->nFilledLen = 0;
+            pSECComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+        }
+    }
+    dataBuffer->dataValid     = OMX_FALSE;
+    dataBuffer->dataLen       = 0;
+    dataBuffer->remainDataLen = 0;
+    dataBuffer->usedDataLen   = 0;
+    dataBuffer->bufferHeader  = NULL;
+    dataBuffer->nFlags        = 0;
+    dataBuffer->timeStamp     = 0;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_InputBufferGetQueue(SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    OMX_ERRORTYPE       ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT   *pSECPort = NULL;
+    SEC_OMX_DATABUFFER *dataBuffer = NULL;
+    SEC_OMX_MESSAGE*    message = NULL;
+
+    FunctionIn();
+
+    pSECPort= &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    dataBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+
+    if (pSECComponent->currentState != OMX_StateExecuting) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    } else {
+        SEC_OSAL_SemaphoreWait(pSECPort->bufferSemID);
+        if (dataBuffer->dataValid != OMX_TRUE)
+        {
+            message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+            if (message == NULL)
+            {
+                ret = OMX_ErrorUndefined;
+                goto EXIT;
+            }
+
+            dataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
+            dataBuffer->allocSize = dataBuffer->bufferHeader->nAllocLen;
+            dataBuffer->dataLen = dataBuffer->bufferHeader->nFilledLen;
+            dataBuffer->remainDataLen = dataBuffer->dataLen;
+            dataBuffer->usedDataLen = 0; //dataBuffer->bufferHeader->nOffset;
+            dataBuffer->dataValid = OMX_TRUE;
+            dataBuffer->nFlags = dataBuffer->bufferHeader->nFlags;
+            dataBuffer->timeStamp = dataBuffer->bufferHeader->nTimeStamp;
+#ifdef S5PC110_ENCODE_IN_DATA_BUFFER
+            pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = dataBuffer->bufferHeader->pBuffer;
+            pSECComponent->processData[INPUT_PORT_INDEX].allocSize = dataBuffer->bufferHeader->nAllocLen;
+#endif
+            SEC_OSAL_Free(message);
+        }
+        ret = OMX_ErrorNone;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_OutputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT      *secOMXInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT      *secOMXOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATABUFFER    *dataBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+    OMX_BUFFERHEADERTYPE  *bufferHeader = dataBuffer->bufferHeader;
+
+    FunctionIn();
+
+    bufferHeader->nFilledLen = dataBuffer->remainDataLen;
+    bufferHeader->nOffset    = 0;
+    bufferHeader->nFlags     = dataBuffer->nFlags;
+    bufferHeader->nTimeStamp = dataBuffer->timeStamp;
+
+     if (pSECComponent->propagateMarkType.hMarkTargetComponent != NULL) {
+        bufferHeader->hMarkTargetComponent = pSECComponent->propagateMarkType.hMarkTargetComponent;
+        bufferHeader->pMarkData = pSECComponent->propagateMarkType.pMarkData;
+        pSECComponent->propagateMarkType.hMarkTargetComponent = NULL;
+        pSECComponent->propagateMarkType.pMarkData = NULL;
+    }
+
+    if (bufferHeader->nFlags & OMX_BUFFERFLAG_EOS) {
+        pSECComponent->pCallbacks->EventHandler(pOMXComponent,
+                        pSECComponent->callbackData,
+                        OMX_EventBufferFlag,
+                        OUTPUT_PORT_INDEX,
+                        bufferHeader->nFlags, NULL);
+    }
+
+    if ((pSECComponent->currentState == OMX_StatePause) &&
+        ((!CHECK_PORT_BEING_FLUSHED(secOMXInputPort) && !CHECK_PORT_BEING_FLUSHED(secOMXOutputPort)))) {
+        SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
+        SEC_OSAL_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
+    }
+
+    if (bufferHeader != NULL) {
+        if (CHECK_PORT_TUNNELED(secOMXOutputPort)) {
+            OMX_EmptyThisBuffer(secOMXOutputPort->tunneledComponent, bufferHeader);
+        } else {
+            pSECComponent->pCallbacks->FillBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+        }
+    }
+    /* reset dataBuffer */
+    dataBuffer->dataValid     = OMX_FALSE;
+    dataBuffer->dataLen       = 0;
+    dataBuffer->remainDataLen = 0;
+    dataBuffer->usedDataLen   = 0;
+    dataBuffer->bufferHeader  = NULL;
+    dataBuffer->nFlags        = 0;
+    dataBuffer->timeStamp     = 0;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OutputBufferGetQueue(SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    OMX_ERRORTYPE       ret = OMX_ErrorNone;
+    SEC_OMX_BASEPORT   *pSECPort = NULL;
+    SEC_OMX_DATABUFFER *dataBuffer = NULL;
+    SEC_OMX_MESSAGE    *message = NULL;
+
+    FunctionIn();
+
+    pSECPort= &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    dataBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+
+    if (pSECComponent->currentState != OMX_StateExecuting) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    } else {
+        SEC_OSAL_SemaphoreWait(pSECPort->bufferSemID);
+        if (dataBuffer->dataValid != OMX_TRUE) {
+            message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+            if (message == NULL) {
+                ret = OMX_ErrorUndefined;
+                goto EXIT;
+            }
+
+            dataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
+            dataBuffer->allocSize = dataBuffer->bufferHeader->nAllocLen;
+            dataBuffer->dataLen = 0; //dataBuffer->bufferHeader->nFilledLen;
+            dataBuffer->remainDataLen = dataBuffer->dataLen;
+            dataBuffer->usedDataLen = 0; //dataBuffer->bufferHeader->nOffset;
+            dataBuffer->dataValid =OMX_TRUE;
+            /* dataBuffer->nFlags = dataBuffer->bufferHeader->nFlags; */
+            /* dataBuffer->nTimeStamp = dataBuffer->bufferHeader->nTimeStamp; */
+            SEC_OSAL_Free(message);
+        }
+        ret = OMX_ErrorNone;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+
+}
+
+static OMX_ERRORTYPE SEC_BufferReset(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 portIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    /* SEC_OMX_BASEPORT      *pSECPort = &pSECComponent->pSECPort[portIndex]; */
+    SEC_OMX_DATABUFFER    *dataBuffer = &pSECComponent->secDataBuffer[portIndex];
+    /* OMX_BUFFERHEADERTYPE  *bufferHeader = dataBuffer->bufferHeader; */
+
+    dataBuffer->dataValid     = OMX_FALSE;
+    dataBuffer->dataLen       = 0;
+    dataBuffer->remainDataLen = 0;
+    dataBuffer->usedDataLen   = 0;
+    dataBuffer->bufferHeader  = NULL;
+    dataBuffer->nFlags        = 0;
+    dataBuffer->timeStamp     = 0;
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SEC_DataDrop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 portIndex)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    /* SEC_OMX_BASEPORT      *pSECPort = &pSECComponent->pSECPort[portIndex]; */
+    /* SEC_OMX_DATABUFFER    *dataBuffer = &pSECComponent->secDataBuffer[portIndex]; */
+    /* OMX_BUFFERHEADERTYPE  *bufferHeader = dataBuffer->bufferHeader; */
+    SEC_OMX_DATA          *processData = &pSECComponent->processData[portIndex];
+
+    if (portIndex == 0) {
+        processData->dataLen       = 0;
+        processData->remainDataLen = 0;
+        processData->usedDataLen   = 0;
+        processData->nFlags        = 0;
+        processData->timeStamp     = 0;
+    } else {
+        /* TBD */
+    }
+
+    return ret;
+}
+
+OMX_BOOL SEC_Preprocessor_InputData(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_BOOL               ret = OMX_FALSE;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_DATABUFFER    *inputUseBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+    SEC_OMX_DATA          *inputData = &pSECComponent->processData[INPUT_PORT_INDEX];
+    OMX_U32                copySize = 0;
+    OMX_BYTE               checkInputStream = NULL;
+    OMX_U32                checkInputStreamLen = 0;
+    OMX_U32                checkedSize = 0;
+    OMX_BOOL               flagEOS = OMX_FALSE;
+    OMX_BOOL               flagEOF = OMX_FALSE;
+    OMX_BOOL               previousFrameEOF = OMX_FALSE;
+
+    if (inputUseBuffer->dataValid == OMX_TRUE) {
+        checkInputStream = inputUseBuffer->bufferHeader->pBuffer + inputUseBuffer->usedDataLen;
+        checkInputStreamLen = inputUseBuffer->remainDataLen;
+
+        if ((inputUseBuffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+            (pSECComponent->bUseFlagEOF == OMX_FALSE)) {
+            pSECComponent->bUseFlagEOF = OMX_TRUE;
+        }
+
+        if (inputData->dataLen == 0) {
+            previousFrameEOF = OMX_TRUE;
+        } else {
+            previousFrameEOF = OMX_FALSE;
+        }
+        if (pSECComponent->bUseFlagEOF == OMX_TRUE) {
+            flagEOF = OMX_TRUE;
+            checkedSize = checkInputStreamLen;
+            if (inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS) {
+                flagEOS = OMX_TRUE;
+            }
+        } else {
+            SEC_OMX_BASEPORT *pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+            int width = pSECPort->portDefinition.format.video.nFrameWidth;
+            int height = pSECPort->portDefinition.format.video.nFrameHeight;
+            int oneFrameSize = 0;
+
+            if (pSECPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatYUV420SemiPlanar)
+                oneFrameSize = (width * height * 3) / 2;
+            else if (pSECPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar)
+                oneFrameSize = (width * height * 3) / 2;
+            else if (pSECPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatYUV422Planar)
+                oneFrameSize = width * height * 2;
+
+            if (previousFrameEOF == OMX_TRUE) {
+                if (checkInputStreamLen >= oneFrameSize) {
+                    checkedSize = oneFrameSize;
+                    flagEOF = OMX_TRUE;
+                } else {
+                    flagEOF = OMX_FALSE;
+                }
+            } else {
+                if (checkInputStreamLen >= (oneFrameSize - inputData->dataLen)) {
+                    checkedSize = oneFrameSize - inputData->dataLen;
+                    flagEOF = OMX_TRUE;
+                } else {
+                    flagEOF = OMX_FALSE;
+                }
+            }
+
+            if ((flagEOF == OMX_FALSE) && (inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS)) {
+                flagEOF = OMX_TRUE;
+                flagEOS = OMX_TRUE;
+            }
+        }
+
+        if (flagEOF == OMX_TRUE) {
+            copySize = checkedSize;
+            SEC_OSAL_Log(SEC_LOG_TRACE, "sec_checkInputFrame : OMX_TRUE");
+        } else {
+            copySize = checkInputStreamLen;
+            SEC_OSAL_Log(SEC_LOG_TRACE, "sec_checkInputFrame : OMX_FALSE");
+        }
+
+        if (inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS)
+            pSECComponent->bSaveFlagEOS = OMX_TRUE;
+
+        if (((inputData->allocSize) - (inputData->dataLen)) >= copySize) {
+            SEC_OMX_BASEPORT *pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+
+#ifndef S5PC110_ENCODE_IN_DATA_BUFFER
+            if (copySize > 0) {
+                SEC_OSAL_Memcpy(inputData->dataBuffer + inputData->dataLen, checkInputStream, copySize);
+            }
+#else
+            if (pSECPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar) {
+                if (flagEOF == OMX_TRUE) {
+                    OMX_U32 width, height;
+
+                    width = pSECPort->portDefinition.format.video.nFrameWidth;
+                    height = pSECPort->portDefinition.format.video.nFrameHeight;
+
+                    SEC_OSAL_Log(SEC_LOG_TRACE, "inputData->specificBufferHeader.YVirAddr : 0x%x", inputData->specificBufferHeader.YVirAddr);
+                    SEC_OSAL_Log(SEC_LOG_TRACE, "inputData->specificBufferHeader.CVirAddr : 0x%x", inputData->specificBufferHeader.CVirAddr);
+
+                    SEC_OSAL_Log(SEC_LOG_TRACE, "width:%d, height:%d, Ysize:%d", width, height, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)));
+                    SEC_OSAL_Log(SEC_LOG_TRACE, "width:%d, height:%d, Csize:%d", width, height, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2)));
+
+                    SEC_OSAL_Memcpy(inputData->specificBufferHeader.YVirAddr, checkInputStream, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)));
+                    SEC_OSAL_Memcpy(inputData->specificBufferHeader.CVirAddr, checkInputStream + ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)), ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2)));
+                }
+            }
+#endif
+            inputUseBuffer->dataLen -= copySize;
+            inputUseBuffer->remainDataLen -= copySize;
+            inputUseBuffer->usedDataLen += copySize;
+
+            inputData->dataLen += copySize;
+            inputData->remainDataLen += copySize;
+
+            if (previousFrameEOF == OMX_TRUE) {
+                inputData->timeStamp = inputUseBuffer->timeStamp;
+            }
+
+            if (pSECComponent->bUseFlagEOF == OMX_TRUE) {
+                inputData->nFlags = inputUseBuffer->nFlags;
+                if (pSECComponent->bSaveFlagEOS == OMX_TRUE) {
+                    inputData->nFlags |= OMX_BUFFERFLAG_EOS;
+                    flagEOF = OMX_TRUE;
+                    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+                }
+            } else {
+                if ((checkedSize == checkInputStreamLen) && (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
+                    inputData->nFlags |= OMX_BUFFERFLAG_EOS;
+                    flagEOF = OMX_TRUE;
+                    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+                } else {
+                    inputData->nFlags = inputUseBuffer->nFlags & (~OMX_BUFFERFLAG_EOS);
+                }
+            }
+        } else {
+            /*????????????????????????????????? Error ?????????????????????????????????*/
+            SEC_DataDrop(pOMXComponent, INPUT_PORT_INDEX);
+        }
+
+        if (inputUseBuffer->remainDataLen == 0) {
+            SEC_InputBufferReturn(pOMXComponent);
+        } else {
+            inputUseBuffer->dataValid = OMX_TRUE;
+        }
+    }
+
+    if (flagEOF == OMX_TRUE) {
+        ret = OMX_TRUE;
+    } else {
+        ret = OMX_FALSE;
+    }
+
+    return ret;
+}
+
+OMX_BOOL SEC_Postprocess_OutputData(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_BOOL               ret = OMX_FALSE;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_DATABUFFER    *outputUseBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATA          *outputData = &pSECComponent->processData[OUTPUT_PORT_INDEX];
+    OMX_U32                copySize = 0;
+
+    if (outputUseBuffer->dataValid == OMX_TRUE) {
+        if (outputData->remainDataLen <= (outputUseBuffer->allocSize - outputUseBuffer->dataLen)) {
+            copySize = outputData->remainDataLen;
+            if (copySize > 0)
+                SEC_OSAL_Memcpy((outputUseBuffer->bufferHeader->pBuffer + outputUseBuffer->dataLen),
+                    (outputData->dataBuffer + outputData->usedDataLen),
+                     copySize);
+
+            outputUseBuffer->dataLen += copySize;
+            outputUseBuffer->remainDataLen += copySize;
+            outputUseBuffer->nFlags = outputData->nFlags;
+            outputUseBuffer->timeStamp = outputData->timeStamp;
+
+            ret = OMX_TRUE;
+
+            /* reset outputData */
+            outputData->dataLen = 0;
+            outputData->remainDataLen = 0;
+            outputData->usedDataLen = 0;
+            outputData->nFlags = 0;
+            outputData->timeStamp = 0;
+
+#ifdef ONE_FRAME_OUTPUT  /* only one frame output for Android */
+            if (outputUseBuffer->remainDataLen > 0)
+                SEC_OutputBufferReturn(pOMXComponent);
+#else
+            if ((outputUseBuffer->remainDataLen > 0) ||
+                ((outputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
+                SEC_OutputBufferReturn(pOMXComponent);
+            } else {
+                outputUseBuffer->dataValid = OMX_TRUE;
+            }
+#endif
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "output buffer is smaller than encoded data size Out Length");
+
+            copySize = outputUseBuffer->allocSize - outputUseBuffer->dataLen;
+
+            SEC_OSAL_Memcpy((outputUseBuffer->bufferHeader->pBuffer + outputUseBuffer->dataLen),
+                    (outputData->dataBuffer + outputData->usedDataLen),
+                     copySize);
+
+            outputUseBuffer->dataLen += copySize;
+            outputUseBuffer->remainDataLen += copySize;
+            outputUseBuffer->nFlags = 0;
+            outputUseBuffer->timeStamp = outputData->timeStamp;
+
+            ret = OMX_FALSE;
+
+            outputData->remainDataLen -= copySize;
+            outputData->usedDataLen += copySize;
+
+            SEC_OutputBufferReturn(pOMXComponent);
+        }
+    } else {
+        ret = OMX_FALSE;
+    }
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_BufferProcess(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_BASEPORT      *secInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT      *secOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATABUFFER    *inputUseBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+    SEC_OMX_DATABUFFER    *outputUseBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+    SEC_OMX_DATA          *inputData = &pSECComponent->processData[INPUT_PORT_INDEX];
+    SEC_OMX_DATA          *outputData = &pSECComponent->processData[OUTPUT_PORT_INDEX];
+    OMX_U32                copySize = 0;
+    OMX_BOOL               remainOutputData = OMX_FALSE;
+    OMX_BOOL               reencodeInputData = OMX_FALSE;
+
+    FunctionIn();
+
+    while (!pSECComponent->bExitBufferProcessThread) {
+        SEC_OSAL_SleepMillisec(0);
+
+        if (((pSECComponent->currentState == OMX_StatePause) ||
+            (pSECComponent->currentState == OMX_StateIdle) ||
+            (pSECComponent->transientState == SEC_OMX_TransStateLoadedToIdle) ||
+            (pSECComponent->transientState == SEC_OMX_TransStateExecutingToIdle)) &&
+            (pSECComponent->transientState != SEC_OMX_TransStateIdleToLoaded)&&
+            ((!CHECK_PORT_BEING_FLUSHED(secInputPort) && !CHECK_PORT_BEING_FLUSHED(secOutputPort)))) {
+            SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
+            SEC_OSAL_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
+        }
+
+        while (SEC_Check_BufferProcess_State(pSECComponent) && !pSECComponent->bExitBufferProcessThread) {
+            SEC_OSAL_SleepMillisec(0);
+
+            if (outputUseBuffer->dataValid != OMX_TRUE) {
+                ret = SEC_OutputBufferGetQueue(pSECComponent);
+                if ((ret == OMX_ErrorUndefined) ||
+                    (secInputPort->portState != OMX_StateIdle) ||
+                    (secOutputPort->portState != OMX_StateIdle)) {
+                    break;
+                }
+            }
+            if (remainOutputData == OMX_FALSE) {
+                if (reencodeInputData == OMX_FALSE) {
+                    SEC_OSAL_MutexLock(inputUseBuffer->bufferMutex);
+                    if (SEC_Preprocessor_InputData(pOMXComponent) == OMX_FALSE) {
+                            SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                            ret = SEC_InputBufferGetQueue(pSECComponent);
+                            break;
+                    }
+
+                    SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                }
+
+                ret = pSECComponent->sec_mfc_bufferProcess(pOMXComponent, inputData, outputData);
+                if (ret == OMX_ErrorInputDataEncodeYet) {
+                    reencodeInputData = OMX_TRUE;
+                } else {
+                    reencodeInputData = OMX_FALSE;
+                }
+            }
+
+            SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+
+            if (SEC_Postprocess_OutputData(pOMXComponent) == OMX_FALSE) {
+                remainOutputData = OMX_TRUE;
+            } else {
+                remainOutputData = OMX_FALSE;
+            }
+
+            SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+        }
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_VideoEncodeGetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nParamIndex,
+    OMX_INOUT OMX_PTR     ComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = 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 (pSECComponent->currentState == OMX_StateInvalid ) {
+        ret = OMX_StateInvalid;
+        goto EXIT;
+    }
+
+    if (ComponentParameterStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    switch (nParamIndex) {
+    case OMX_IndexParamVideoInit:
+    {
+        OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
+        ret = SEC_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        portParam->nPorts           = pSECComponent->portParam.nPorts;
+        portParam->nStartPortNumber = pSECComponent->portParam.nStartPortNumber;
+        ret = OMX_ErrorNone;
+    }
+        break;
+    case OMX_IndexParamVideoPortFormat:
+    {
+        OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
+        OMX_U32                         portIndex = portFormat->nPortIndex;
+        OMX_U32                         index    = portFormat->nIndex;
+        SEC_OMX_BASEPORT               *pSECPort = NULL;
+        OMX_PARAM_PORTDEFINITIONTYPE   *portDefinition = NULL;
+        OMX_U32                         supportFormatNum = 0;
+
+        ret = SEC_OMX_Check_SizeVersion(portFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if ((portIndex >= pSECComponent->portParam.nPorts)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+
+        if (portIndex == INPUT_PORT_INDEX) {
+            supportFormatNum = INPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
+            if (index > supportFormatNum) {
+                ret = OMX_ErrorNoMore;
+                goto EXIT;
+            }
+
+            pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+            portDefinition = &pSECPort->portDefinition;
+
+            switch (index) {
+            case supportFormat_1:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_COLOR_FormatYUV420Planar;
+                portFormat->xFramerate           = portDefinition->format.video.xFramerate;
+                break;
+            case supportFormat_2:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_COLOR_FormatYUV420SemiPlanar;
+                portFormat->xFramerate         = portDefinition->format.video.xFramerate;
+                break;
+            case supportFormat_3:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = SEC_OMX_COLOR_FormatNV12PhysicalAddress;
+                portFormat->xFramerate           = portDefinition->format.video.xFramerate;
+                break;
+            }
+        } else if (portIndex == OUTPUT_PORT_INDEX) {
+            supportFormatNum = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
+            if (index > supportFormatNum) {
+                ret = OMX_ErrorNoMore;
+                goto EXIT;
+            }
+
+            pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+            portDefinition = &pSECPort->portDefinition;
+
+            portFormat->eCompressionFormat = portDefinition->format.video.eCompressionFormat;
+            portFormat->eColorFormat       = portDefinition->format.video.eColorFormat;
+            portFormat->xFramerate           = portDefinition->format.video.xFramerate;
+        }
+        ret = OMX_ErrorNone;
+    }
+        break;
+    case OMX_IndexParamVideoBitrate:
+    {
+        OMX_VIDEO_PARAM_BITRATETYPE  *videoRateControl = (OMX_VIDEO_PARAM_BITRATETYPE *)ComponentParameterStructure;
+        OMX_U32                       portIndex = videoRateControl->nPortIndex;
+        SEC_OMX_BASEPORT         *pSECPort = NULL;
+        OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
+
+        if ((portIndex != OUTPUT_PORT_INDEX)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        } else {
+            pSECPort = &pSECComponent->pSECPort[portIndex];
+            portDefinition = &pSECPort->portDefinition;
+
+            videoRateControl->eControlRate = pSECPort->eControlRate;
+            videoRateControl->nTargetBitrate = portDefinition->format.video.nBitrate;
+        }
+        ret = OMX_ErrorNone;
+    }
+        break;
+    default:
+    {
+        ret = SEC_OMX_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
+    }
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+OMX_ERRORTYPE SEC_OMX_VideoEncodeSetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nIndex,
+    OMX_IN OMX_PTR        ComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = 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 (pSECComponent->currentState == OMX_StateInvalid ) {
+        ret = OMX_StateInvalid;
+        goto EXIT;
+    }
+
+    if (ComponentParameterStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexParamVideoPortFormat:
+    {
+        OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
+        OMX_U32                         portIndex = portFormat->nPortIndex;
+        OMX_U32                         index    = portFormat->nIndex;
+        SEC_OMX_BASEPORT               *pSECPort = NULL;
+        OMX_PARAM_PORTDEFINITIONTYPE   *portDefinition = NULL;
+        OMX_U32                         supportFormatNum = 0;
+
+        ret = SEC_OMX_Check_SizeVersion(portFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if ((portIndex >= pSECComponent->portParam.nPorts)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        } else {
+            pSECPort = &pSECComponent->pSECPort[portIndex];
+            portDefinition = &pSECPort->portDefinition;
+
+            portDefinition->format.video.eColorFormat       = portFormat->eColorFormat;
+            portDefinition->format.video.eCompressionFormat = portFormat->eCompressionFormat;
+            portDefinition->format.video.xFramerate         = portFormat->xFramerate;
+        }
+    }
+        break;
+    case OMX_IndexParamVideoBitrate:
+    {
+        OMX_VIDEO_PARAM_BITRATETYPE  *videoRateControl = (OMX_VIDEO_PARAM_BITRATETYPE *)ComponentParameterStructure;
+        OMX_U32                       portIndex = videoRateControl->nPortIndex;
+        SEC_OMX_BASEPORT             *pSECPort = NULL;
+        OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
+
+        if ((portIndex != OUTPUT_PORT_INDEX)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        } else {
+            pSECPort = &pSECComponent->pSECPort[portIndex];
+            portDefinition = &pSECPort->portDefinition;
+
+            pSECPort->eControlRate = videoRateControl->eControlRate;
+            portDefinition->format.video.nBitrate = videoRateControl->nTargetBitrate;
+        }
+        ret = OMX_ErrorNone;
+    }
+        break;
+    default:
+    {
+        ret = SEC_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
+    }
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_VideoEncodeComponentInit(OMX_IN OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = 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) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    ret = SEC_OMX_BaseComponent_Constructor(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    ret = SEC_OMX_Port_Constructor(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        SEC_OMX_BaseComponent_Destructor(pOMXComponent);
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+
+    /* Input port */
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    pSECPort->portDefinition.nBufferCountActual = MAX_VIDEO_INPUTBUFFER_NUM;
+    pSECPort->portDefinition.nBufferCountMin = MAX_VIDEO_INPUTBUFFER_NUM;
+    pSECPort->portDefinition.nBufferSize = 0;
+    pSECPort->portDefinition.eDomain = OMX_PortDomainVideo;
+
+    pSECPort->portDefinition.format.video.cMIMEType = SEC_OSAL_Malloc(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.eCompressionFormat = OMX_VIDEO_CodingUnused;
+
+    pSECPort->portDefinition.format.video.nFrameWidth = 0;
+    pSECPort->portDefinition.format.video.nFrameHeight= 0;
+    pSECPort->portDefinition.format.video.nStride = 0;
+    pSECPort->portDefinition.format.video.nSliceHeight = 0;
+    pSECPort->portDefinition.format.video.nBitrate = 64000;
+    pSECPort->portDefinition.format.video.xFramerate = (15 << 16);
+    pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
+    pSECPort->portDefinition.format.video.pNativeWindow = NULL;
+
+    /* Output port */
+    pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    pSECPort->portDefinition.nBufferCountActual = MAX_VIDEO_OUTPUTBUFFER_NUM;
+    pSECPort->portDefinition.nBufferCountMin = MAX_VIDEO_OUTPUTBUFFER_NUM;
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
+    pSECPort->portDefinition.eDomain = OMX_PortDomainVideo;
+
+    pSECPort->portDefinition.format.video.cMIMEType = SEC_OSAL_Malloc(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.eCompressionFormat = OMX_VIDEO_CodingUnused;
+
+    pSECPort->portDefinition.format.video.nFrameWidth = 0;
+    pSECPort->portDefinition.format.video.nFrameHeight= 0;
+    pSECPort->portDefinition.format.video.nStride = 0;
+    pSECPort->portDefinition.format.video.nSliceHeight = 0;
+    pSECPort->portDefinition.format.video.nBitrate = 64000;
+    pSECPort->portDefinition.format.video.xFramerate = (15 << 16);
+    pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
+    pSECPort->portDefinition.format.video.pNativeWindow = NULL;
+
+    pOMXComponent->UseBuffer              = &SEC_OMX_UseBuffer;
+    pOMXComponent->AllocateBuffer         = &SEC_OMX_AllocateBuffer;
+    pOMXComponent->FreeBuffer             = &SEC_OMX_FreeBuffer;
+    pOMXComponent->ComponentTunnelRequest = &SEC_OMX_ComponentTunnelRequest;
+
+    pSECComponent->sec_AllocateTunnelBuffer = &SEC_OMX_AllocateTunnelBuffer;
+    pSECComponent->sec_FreeTunnelBuffer     = &SEC_OMX_FreeTunnelBuffer;
+    pSECComponent->sec_BufferProcess        = &SEC_OMX_BufferProcess;
+    pSECComponent->sec_BufferReset          = &SEC_BufferReset;
+    pSECComponent->sec_InputBufferReturn    = &SEC_InputBufferReturn;
+    pSECComponent->sec_OutputBufferReturn   = &SEC_OutputBufferReturn;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_VideoEncodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    int                    i = 0;
+
+    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;
+
+    for(i = 0; i < ALL_PORT_NUM; i++) {
+        pSECPort = &pSECComponent->pSECPort[i];
+        SEC_OSAL_Free(pSECPort->portDefinition.format.video.cMIMEType);
+        pSECPort->portDefinition.format.video.cMIMEType = NULL;
+    }
+
+    ret = SEC_OMX_Port_Destructor(pOMXComponent);
+
+    ret = SEC_OMX_BaseComponent_Destructor(hComponent);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.h b/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.h
new file mode 100644
index 0000000..d7cbe4a
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.h
@@ -0,0 +1,106 @@
+/*
+ *
+ * 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_Venc.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ *              Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_VIDEO_ENCODE
+#define SEC_OMX_VIDEO_ENCODE
+
+#include "OMX_Component.h"
+#include "SEC_OMX_Def.h"
+#include "SEC_OSAL_Queue.h"
+#include "SEC_OMX_Baseport.h"
+
+#define MAX_VIDEO_INPUTBUFFER_NUM    5
+#define MAX_VIDEO_OUTPUTBUFFER_NUM   2
+
+#define DEFAULT_FRAME_WIDTH          176 //1920
+#define DEFAULT_FRAME_HEIGHT         144 //1088
+
+#define DEFAULT_VIDEO_INPUT_BUFFER_SIZE    ALIGN_TO_8KB(ALIGN_TO_128B(DEFAULT_FRAME_WIDTH) * ALIGN_TO_32B(DEFAULT_FRAME_HEIGHT)) \
+                                           + ALIGN_TO_8KB(ALIGN_TO_128B(DEFAULT_FRAME_WIDTH) * ALIGN_TO_32B(DEFAULT_FRAME_HEIGHT / 2))
+                                           //(DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT * 3) / 2
+#define DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE   700 * 1024 //(DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT)
+
+#define INPUT_PORT_SUPPORTFORMAT_NUM_MAX    3
+#define OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX   1
+
+
+typedef struct
+{
+    void *pAddrY;
+    void *pAddrC;
+} MFC_ENC_ADDR_INFO;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_ERRORTYPE SEC_OMX_UseBuffer(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN OMX_U32                   nSizeBytes,
+    OMX_IN OMX_U8                   *pBuffer);
+OMX_ERRORTYPE SEC_OMX_AllocateBuffer(
+    OMX_IN OMX_HANDLETYPE            hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBuffer,
+    OMX_IN OMX_U32                   nPortIndex,
+    OMX_IN OMX_PTR                   pAppPrivate,
+    OMX_IN OMX_U32                   nSizeBytes);
+OMX_ERRORTYPE SEC_OMX_FreeBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_U32        nPortIndex,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr);
+OMX_ERRORTYPE SEC_OMX_AllocateTunnelBuffer(
+    SEC_OMX_BASEPORT *pOMXBasePort,
+    OMX_U32           nPortIndex);
+OMX_ERRORTYPE SEC_OMX_FreeTunnelBuffer(
+    SEC_OMX_BASEPORT *pOMXBasePort,
+    OMX_U32           nPortIndex);
+OMX_ERRORTYPE SEC_OMX_ComponentTunnelRequest(
+    OMX_IN OMX_HANDLETYPE  hComp,
+    OMX_IN OMX_U32         nPort,
+    OMX_IN OMX_HANDLETYPE  hTunneledComp,
+    OMX_IN OMX_U32         nTunneledPort,
+    OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup);
+OMX_ERRORTYPE SEC_OMX_BufferProcess(OMX_HANDLETYPE hComponent);
+OMX_ERRORTYPE SEC_OMX_VideoEncodeGetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nParamIndex,
+    OMX_INOUT OMX_PTR     ComponentParameterStructure);
+OMX_ERRORTYPE SEC_OMX_VideoEncodeSetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE  nIndex,
+    OMX_IN OMX_PTR        ComponentParameterStructure);
+OMX_ERRORTYPE SEC_OMX_VideoEncodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/Android.mk b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/Android.mk
new file mode 100644
index 0000000..861896d
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/Android.mk
@@ -0,0 +1,30 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	../SEC_OMX_Venc.c \
+	SEC_OMX_H264enc.c \
+	library_register.c
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libOMX.SEC.AVC.Encoder
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libsecosal libsecbasecomponent libsecmfcencapi
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/sec_osal \
+	$(SEC_OMX_TOP)/sec_omx_core \
+	$(SEC_OMX_COMPONENT)/common \
+	$(SEC_OMX_COMPONENT)/video/enc \
+
+LOCAL_C_INCLUDES += $(SEC_OMX_TOP)/sec_codecs/video/mfc_c110/include
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.c b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.c
new file mode 100644
index 0000000..aca335a
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.c
@@ -0,0 +1,1024 @@
+/*
+ *
+ * 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_H264enc.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OMX_Macros.h"
+#include "SEC_OMX_Basecomponent.h"
+#include "SEC_OMX_Baseport.h"
+#include "SEC_OMX_Venc.h"
+#include "library_register.h"
+#include "SEC_OMX_H264enc.h"
+#include "SsbSipMfcApi.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_H264_ENC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+/* H.264 Encoder Supported Levels & profiles */
+SEC_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels[] ={
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel32},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel4},
+
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1b},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel11},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel12},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel13},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel2},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel21},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel22},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel3},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel31},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel32},
+    {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel4},
+
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1b},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel11},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel12},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel13},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel2},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel21},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel22},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel3},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel31},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel32},
+    {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel4}};
+
+
+OMX_U32 OMXAVCProfileToProfileIDC(OMX_VIDEO_AVCPROFILETYPE profile)
+{
+    OMX_U32 ret = 0; //default OMX_VIDEO_AVCProfileMain
+
+    if (profile == OMX_VIDEO_AVCProfileMain)
+        ret = 0;
+    else if (profile == OMX_VIDEO_AVCProfileHigh)
+        ret = 1;
+    else if (profile == OMX_VIDEO_AVCProfileBaseline)
+        ret = 2;
+
+    return ret;
+}
+
+OMX_U32 OMXAVCLevelToLevelIDC(OMX_VIDEO_AVCLEVELTYPE level)
+{
+    OMX_U32 ret = 40; //default OMX_VIDEO_AVCLevel4
+
+    if (level == OMX_VIDEO_AVCLevel1)
+        ret = 10;
+    else if (level == OMX_VIDEO_AVCLevel1b)
+        ret = 9;
+    else if (level == OMX_VIDEO_AVCLevel11)
+        ret = 11;
+    else if (level == OMX_VIDEO_AVCLevel12)
+        ret = 12;
+    else if (level == OMX_VIDEO_AVCLevel13)
+        ret = 13;
+    else if (level == OMX_VIDEO_AVCLevel2)
+        ret = 20;
+    else if (level == OMX_VIDEO_AVCLevel21)
+        ret = 21;
+    else if (level == OMX_VIDEO_AVCLevel22)
+        ret = 22;
+    else if (level == OMX_VIDEO_AVCLevel3)
+        ret = 30;
+    else if (level == OMX_VIDEO_AVCLevel31)
+        ret = 31;
+    else if (level == OMX_VIDEO_AVCLevel32)
+        ret = 32;
+    else if (level == OMX_VIDEO_AVCLevel4)
+        ret = 40;
+
+    return ret;
+}
+
+OMX_U8 *FindDelimiter(OMX_U8 *pBuffer, OMX_U32 size)
+{
+    int i;
+
+    for (i = 0; i < size - 3; i++) {
+        if ((pBuffer[i] == 0x00)   &&
+            (pBuffer[i+1] == 0x00) &&
+            (pBuffer[i+2] == 0x00) &&
+            (pBuffer[i+3] == 0x01))
+            return (pBuffer + i);
+    }
+
+    return NULL;
+}
+
+void H264PrintParams(SSBSIP_MFC_ENC_H264_PARAM h264Arg)
+{
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SourceWidth             : %d\n", h264Arg.SourceWidth);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SourceHeight            : %d\n", h264Arg.SourceHeight);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "ProfileIDC              : %d\n", h264Arg.ProfileIDC);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "LevelIDC                : %d\n", h264Arg.LevelIDC);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "IDRPeriod               : %d\n", h264Arg.IDRPeriod);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "NumberReferenceFrames   : %d\n", h264Arg.NumberReferenceFrames);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "NumberRefForPframes     : %d\n", h264Arg.NumberRefForPframes);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SliceMode               : %d\n", h264Arg.SliceMode);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SliceArgument           : %d\n", h264Arg.SliceArgument);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "NumberBFrames           : %d\n", h264Arg.NumberBFrames);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "LoopFilterDisable       : %d\n", h264Arg.LoopFilterDisable);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "LoopFilterAlphaC0Offset : %d\n", h264Arg.LoopFilterAlphaC0Offset);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "LoopFilterBetaOffset    : %d\n", h264Arg.LoopFilterBetaOffset);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SymbolMode              : %d\n", h264Arg.SymbolMode);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "PictureInterlace        : %d\n", h264Arg.PictureInterlace);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "Transform8x8Mode        : %d\n", h264Arg.Transform8x8Mode);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "RandomIntraMBRefresh    : %d\n", h264Arg.RandomIntraMBRefresh);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "PadControlOn            : %d\n", h264Arg.PadControlOn);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "LumaPadVal              : %d\n", h264Arg.LumaPadVal);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CbPadVal                : %d\n", h264Arg.CbPadVal);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CrPadVal                : %d\n", h264Arg.CrPadVal);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "EnableFRMRateControl    : %d\n", h264Arg.EnableFRMRateControl);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "EnableMBRateControl     : %d\n", h264Arg.EnableMBRateControl);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "FrameRate               : %d\n", h264Arg.FrameRate);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "Bitrate                 : %d\n", h264Arg.Bitrate);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp                 : %d\n", h264Arg.FrameQp);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMax               : %d\n", h264Arg.QSCodeMax);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMin               : %d\n", h264Arg.QSCodeMin);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CBRPeriodRf             : %d\n", h264Arg.CBRPeriodRf);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "DarkDisable             : %d\n", h264Arg.DarkDisable);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SmoothDisable           : %d\n", h264Arg.SmoothDisable);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "StaticDisable           : %d\n", h264Arg.StaticDisable);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "ActivityDisable         : %d\n", h264Arg.ActivityDisable);
+}
+
+void Set_H264ENC_Param(SSBSIP_MFC_ENC_H264_PARAM *pH264Arg, SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    SEC_OMX_BASEPORT          *pSECInputPort = NULL;
+    SEC_OMX_BASEPORT          *pSECOutputPort = NULL;
+    SEC_H264ENC_HANDLE        *pH264Enc = NULL;
+
+    pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+    pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+
+    pH264Arg->codecType    = H264_ENC;
+    pH264Arg->SourceWidth  = pSECOutputPort->portDefinition.format.video.nFrameWidth;
+    pH264Arg->SourceHeight = pSECOutputPort->portDefinition.format.video.nFrameHeight;
+    pH264Arg->IDRPeriod    = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1;
+    pH264Arg->SliceMode    = 0;
+    pH264Arg->RandomIntraMBRefresh = 0;
+    pH264Arg->EnableFRMRateControl = 1;        // 0: Disable, 1: Frame level RC
+    pH264Arg->Bitrate      = pSECOutputPort->portDefinition.format.video.nBitrate;
+    pH264Arg->FrameQp      = 20;
+    pH264Arg->FrameQp_P    = 20;
+    pH264Arg->QSCodeMax    = 30;
+    pH264Arg->QSCodeMin    = 10;
+    pH264Arg->CBRPeriodRf  = 100;
+    pH264Arg->PadControlOn = 0;             // 0: disable, 1: enable
+    pH264Arg->LumaPadVal   = 0;
+    pH264Arg->CbPadVal     = 0;
+    pH264Arg->CrPadVal     = 0;
+
+    pH264Arg->ProfileIDC   = OMXAVCProfileToProfileIDC(pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].eProfile); //0;  //(OMX_VIDEO_AVCProfileMain)
+    pH264Arg->LevelIDC     = OMXAVCLevelToLevelIDC(pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].eLevel);       //40; //(OMX_VIDEO_AVCLevel4)
+    pH264Arg->FrameQp_B    = 20;
+    pH264Arg->FrameRate    = (pSECInputPort->portDefinition.format.video.xFramerate) >> 16;
+    pH264Arg->SliceArgument = 0;          // Slice mb/byte size number
+    pH264Arg->NumberBFrames = 0;            // 0 ~ 2
+    pH264Arg->NumberReferenceFrames = 1;
+    pH264Arg->NumberRefForPframes   = 1;
+    pH264Arg->LoopFilterDisable     = 1;    // 1: Loop Filter Disable, 0: Filter Enable
+    pH264Arg->LoopFilterAlphaC0Offset = 0;
+    pH264Arg->LoopFilterBetaOffset    = 0;
+    pH264Arg->SymbolMode       = 0;         // 0: CAVLC, 1: CABAC
+    pH264Arg->PictureInterlace = 0;
+    pH264Arg->Transform8x8Mode = 0;         // 0: 4x4, 1: allow 8x8
+    pH264Arg->EnableMBRateControl = 0;        // 0: Disable, 1:MB level RC
+    pH264Arg->DarkDisable     = 1;
+    pH264Arg->SmoothDisable   = 1;
+    pH264Arg->StaticDisable   = 1;
+    pH264Arg->ActivityDisable = 1;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pSECPort->eControlRate: 0x%x", pSECOutputPort->eControlRate);
+    switch (pSECOutputPort->eControlRate) {
+    case OMX_Video_ControlRateDisable:
+        /* TBD */
+        break;
+    case OMX_Video_ControlRateVariable:
+        /* TBD */
+        break;
+    default:
+        break;
+    }
+
+
+    H264PrintParams(*pH264Arg);
+
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Enc_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_StateInvalid;
+        goto EXIT;
+    }
+
+    switch (nParamIndex) {
+    case OMX_IndexParamVideoAvc:
+    {
+        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
+        SEC_H264ENC_HANDLE      *pH264Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcAVCComponent = &pH264Enc->AVCComponent[pDstAVCComponent->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
+    }
+        break;
+    case OMX_IndexParamStandardComponentRole:
+    {
+        OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
+        ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPOMENT_H264_ENC_ROLE);
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelQuerySupported:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
+        SEC_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
+        OMX_U32 maxProfileLevelNum = 0;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pProfileLevel = supportedAVCProfileLevels;
+        maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
+
+        if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
+            ret = OMX_ErrorNoMore;
+            goto EXIT;
+        }
+
+        pProfileLevel += pDstProfileLevel->nProfileIndex;
+        pDstProfileLevel->eProfile = pProfileLevel->profile;
+        pDstProfileLevel->eLevel = pProfileLevel->level;
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
+        SEC_H264ENC_HANDLE        *pH264Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcAVCComponent = &pH264Enc->AVCComponent[pDstProfileLevel->nPortIndex];
+
+        pDstProfileLevel->eProfile = pSrcAVCComponent->eProfile;
+        pDstProfileLevel->eLevel = pSrcAVCComponent->eLevel;
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
+        SEC_H264ENC_HANDLE        *pH264Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcErrorCorrectionType = &pH264Enc->errorCorrectionType[OUTPUT_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_VideoEncodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
+        break;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Enc_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_StateInvalid;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexParamVideoAvc:
+    {
+        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
+        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
+        SEC_H264ENC_HANDLE      *pH264Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pDstAVCComponent = &pH264Enc->AVCComponent[pSrcAVCComponent->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
+    }
+        break;
+    case OMX_IndexParamStandardComponentRole:
+    {
+        OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
+
+        ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
+            ret = OMX_ErrorIncorrectStateOperation;
+            goto EXIT;
+        }
+
+        if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPOMENT_H264_ENC_ROLE)) {
+            pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+        } else {
+            ret = OMX_ErrorBadParameter;
+            goto EXIT;
+        }
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
+        SEC_H264ENC_HANDLE        *pH264Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+
+        pDstAVCComponent = &pH264Enc->AVCComponent[pSrcProfileLevel->nPortIndex];
+        pDstAVCComponent->eProfile = pSrcProfileLevel->eProfile;
+        pDstAVCComponent->eLevel = pSrcProfileLevel->eLevel;
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
+        SEC_H264ENC_HANDLE        *pH264Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pDstErrorCorrectionType = &pH264Enc->errorCorrectionType[OUTPUT_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_VideoEncodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
+        break;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Enc_SetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL || 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_SetConfig(hComponent, nIndex, pComponentConfigStructure);
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Enc_ComponentRoleEnum(OMX_HANDLETYPE hComponent, OMX_U8 *cRole, OMX_U32 nIndex)
+{
+    OMX_ERRORTYPE            ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE       *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT   *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (cRole == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
+        SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPOMENT_H264_ENC_ROLE);
+        ret = OMX_ErrorNone;
+    } else {
+        ret = OMX_ErrorNoMore;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+
+/* MFC Init */
+OMX_ERRORTYPE SEC_MFC_H264Enc_Init(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE              ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT     *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_H264ENC_HANDLE        *pH264Enc = NULL;
+    OMX_PTR                    hMFCHandle = NULL;
+    OMX_S32                    returnCodec = 0;
+
+    FunctionIn();
+
+    pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+    pH264Enc->hMFCH264Handle.bConfiguredMFC = OMX_FALSE;
+    pSECComponent->bUseFlagEOF = OMX_FALSE;
+    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+
+    /* MFC(Multi Function Codec) encoder and CMM(Codec Memory Management) driver open */
+    hMFCHandle = (OMX_PTR)SsbSipMfcEncOpen();
+    if (hMFCHandle == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pH264Enc->hMFCH264Handle.hMFCHandle = hMFCHandle;
+
+    Set_H264ENC_Param(&(pH264Enc->hMFCH264Handle.mfcVideoAvc), pSECComponent);
+
+    returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pH264Enc->hMFCH264Handle.mfcVideoAvc));
+    if (returnCodec != MFC_RET_OK) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+
+    /* Allocate encoder's input buffer */
+    returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pH264Enc->hMFCH264Handle.inputInfo));
+    if (returnCodec != MFC_RET_OK) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pH264Enc->hMFCH264Handle.inputInfo.YVirAddr : 0x%x", pH264Enc->hMFCH264Handle.inputInfo.YVirAddr);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pH264Enc->hMFCH264Handle.inputInfo.CVirAddr : 0x%x", pH264Enc->hMFCH264Handle.inputInfo.CVirAddr);
+
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.YPhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.CPhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr = pH264Enc->hMFCH264Handle.inputInfo.YVirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr = pH264Enc->hMFCH264Handle.inputInfo.CVirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YSize = pH264Enc->hMFCH264Handle.inputInfo.YSize;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CSize = pH264Enc->hMFCH264Handle.inputInfo.CSize;
+
+    SEC_OSAL_Memset(pH264Enc->hMFCH264Handle.timeStamp, 0, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+    pH264Enc->hMFCH264Handle.indexTimestamp = 0;
+
+EXIT:
+
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Terminate */
+OMX_ERRORTYPE SEC_MFC_H264Enc_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_H264ENC_HANDLE    *pH264Enc = NULL;
+    OMX_PTR                hMFCHandle = NULL;
+
+    FunctionIn();
+
+    pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+    hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
+
+    if (hMFCHandle != NULL) {
+        SsbSipMfcEncClose(hMFCHandle);
+        hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle = NULL;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264_Encode(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_H264ENC_HANDLE        *pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+    SSBSIP_MFC_ENC_INPUT_INFO *pInputInfo = &pH264Enc->hMFCH264Handle.inputInfo;
+    SSBSIP_MFC_ENC_OUTPUT_INFO outputInfo;
+    SEC_OMX_BASEPORT          *pSECPort = NULL;
+    MFC_ENC_ADDR_INFO          addrInfo;
+    OMX_U32                    oneFrameSize = pInputData->dataLen;
+    OMX_S32                    returnCodec = 0;
+
+    FunctionIn();
+
+    if (pH264Enc->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
+        returnCodec = SsbSipMfcEncGetOutBuf(pH264Enc->hMFCH264Handle.hMFCHandle, &outputInfo);
+        if (returnCodec != MFC_RET_OK)
+        {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "%s - SsbSipMfcEncGetOutBuf Failed\n", __func__);
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        } else {
+            char *p = NULL;
+            int iSpsSize = 0;
+            int iPpsSize = 0;
+
+            p = FindDelimiter((OMX_U8 *)outputInfo.StrmVirAddr + 4, outputInfo.headerSize - 4);
+
+            iSpsSize = (unsigned int)p - (unsigned int)outputInfo.StrmVirAddr;
+            pH264Enc->hMFCH264Handle.headerData.pHeaderSPS = (OMX_PTR)outputInfo.StrmVirAddr;
+            pH264Enc->hMFCH264Handle.headerData.SPSLen = iSpsSize;
+
+            iPpsSize = outputInfo.headerSize - iSpsSize;
+            pH264Enc->hMFCH264Handle.headerData.pHeaderPPS = outputInfo.StrmVirAddr + iSpsSize;
+            pH264Enc->hMFCH264Handle.headerData.PPSLen = iPpsSize;
+        }
+
+        /* SEC_OSAL_Memcpy((void*)(pOutputData->dataBuffer), (const void*)(outputInfo.StrmVirAddr), outputInfo.headerSize); */
+        pOutputData->dataBuffer = outputInfo.StrmVirAddr;
+        pOutputData->allocSize = outputInfo.headerSize;
+        pOutputData->dataLen = outputInfo.headerSize;
+        pOutputData->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
+        pOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
+
+        pH264Enc->hMFCH264Handle.bConfiguredMFC = OMX_TRUE;
+
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    pH264Enc->hMFCH264Handle.timeStamp[pH264Enc->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
+    SsbSipMfcEncSetConfig(pH264Enc->hMFCH264Handle.hMFCHandle, MFC_ENC_SETCONF_FRAME_TAG, &(pH264Enc->hMFCH264Handle.indexTimestamp));
+    pH264Enc->hMFCH264Handle.indexTimestamp++;
+    if (pH264Enc->hMFCH264Handle.indexTimestamp >= MAX_TIMESTAMP)
+        pH264Enc->hMFCH264Handle.indexTimestamp = 0;
+
+    if (oneFrameSize <= 0) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    if (pSECPort->portDefinition.format.video.eColorFormat == SEC_OMX_COLOR_FormatNV12PhysicalAddress) {
+#define USE_FIMC_FRAME_BUFFER
+#ifdef USE_FIMC_FRAME_BUFFER
+        SEC_OSAL_Memcpy(&addrInfo.pAddrY, pInputData->dataBuffer, sizeof(addrInfo.pAddrY));
+        SEC_OSAL_Memcpy(&addrInfo.pAddrC, pInputData->dataBuffer + sizeof(addrInfo.pAddrY), sizeof(addrInfo.pAddrC));
+        pInputInfo->YPhyAddr = addrInfo.pAddrY;
+        pInputInfo->CPhyAddr = addrInfo.pAddrC;
+        ret = SsbSipMfcEncSetInBuf(pH264Enc->hMFCH264Handle.hMFCHandle, pInputInfo);
+        if (ret != MFC_RET_OK) {
+            SEC_OSAL_Log(SEC_LOG_TRACE, "Error : SsbSipMfcEncSetInBuf() \n");
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+#else
+        OMX_U32 width, height;
+
+        width = pSECPort->portDefinition.format.video.nFrameWidth;
+        height = pSECPort->portDefinition.format.video.nFrameHeight;
+
+        SEC_OSAL_Memcpy(pInputInfo->YVirAddr, pInputData->dataBuffer, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)));
+        SEC_OSAL_Memcpy(pInputInfo->CVirAddr, pInputData->dataBuffer + ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)), ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2)));
+#endif
+    }
+
+    returnCodec = SsbSipMfcEncExe(pH264Enc->hMFCH264Handle.hMFCHandle);
+    if (returnCodec == MFC_RET_OK) {
+        OMX_S32 indexTimestamp = 0;
+
+        returnCodec = SsbSipMfcEncGetOutBuf(pH264Enc->hMFCH264Handle.hMFCHandle, &outputInfo);
+        if (SsbSipMfcEncGetConfig(pH264Enc->hMFCH264Handle.hMFCHandle, MFC_ENC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+        } else {
+            pOutputData->timeStamp = pH264Enc->hMFCH264Handle.timeStamp[indexTimestamp];
+        }
+
+        if (returnCodec == MFC_RET_OK) {
+            /** Fill Output Buffer **/
+            pOutputData->dataBuffer = outputInfo.StrmVirAddr;
+            pOutputData->allocSize = outputInfo.dataSize;
+            pOutputData->dataLen = outputInfo.dataSize;
+            pOutputData->usedDataLen = 0;
+
+            pOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
+            if (outputInfo.frameType == MFC_FRAME_TYPE_I_FRAME)
+                    pOutputData->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
+
+            SEC_OSAL_Log(SEC_LOG_TRACE, "MFC Encode OK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+
+            ret = OMX_ErrorNone;
+        }
+    }
+
+    if (returnCodec != MFC_RET_OK) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "In %s : SsbSipMfcEncExe OR SsbSipMfcEncGetOutBuf Failed!!!\n", __func__);
+        ret = OMX_ErrorUndefined;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Encode */
+OMX_ERRORTYPE SEC_MFC_H264Enc_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_H264ENC_HANDLE      *pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+    SEC_OMX_BASEPORT        *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT        *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    OMX_BOOL                 endOfFrame = OMX_FALSE;
+    OMX_BOOL                 flagEOS = OMX_FALSE;
+
+    FunctionIn();
+
+    if ((!CHECK_PORT_ENABLED(pSECInputPort)) || (!CHECK_PORT_ENABLED(pSECOutputPort)) ||
+            (!CHECK_PORT_POPULATED(pSECInputPort)) || (!CHECK_PORT_POPULATED(pSECOutputPort))) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+    if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    if (pInputData->nFlags & OMX_BUFFERFLAG_EOS)
+        pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
+    else
+        pOutputData->nFlags = pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS);
+
+    ret = SEC_MFC_H264_Encode(pOMXComponent, pInputData, pOutputData);
+    if (ret != OMX_ErrorNone) {
+        pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
+                                        pSECComponent->callbackData,
+                                        OMX_EventError, ret, 0, NULL);
+    } else {
+        pInputData->usedDataLen += pInputData->dataLen;
+        pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen;
+        pInputData->dataLen -= pInputData->usedDataLen;
+        pInputData->usedDataLen = 0;
+
+        /*pOutputData->usedDataLen = 0;*/
+        pOutputData->remainDataLen = pOutputData->dataLen - pOutputData->usedDataLen;
+    }
+
+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_H264ENC_HANDLE      *pH264Enc = NULL;
+    int i = 0;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (componentName == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    if (SEC_OSAL_Strcmp(SEC_OMX_COMPOMENT_H264_ENC, 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_VideoEncodeComponentInit(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pSECComponent->codecType = HW_VIDEO_CODEC;
+
+    pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
+    if (pSECComponent->componentName == NULL) {
+        SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
+
+    pH264Enc = SEC_OSAL_Malloc(sizeof(SEC_H264ENC_HANDLE));
+    if (pH264Enc == NULL) {
+        SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pH264Enc, 0, sizeof(SEC_H264ENC_HANDLE));
+    pSECComponent->hCodecHandle = (OMX_HANDLETYPE)pH264Enc;
+
+    SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPOMENT_H264_ENC);
+    /* Set componentVersion */
+    pSECComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
+    pSECComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
+    pSECComponent->componentVersion.s.nRevision     = REVISION_NUMBER;
+    pSECComponent->componentVersion.s.nStep         = STEP_NUMBER;
+    /* Set specVersion */
+    pSECComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
+    pSECComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
+    pSECComponent->specVersion.s.nRevision     = REVISION_NUMBER;
+    pSECComponent->specVersion.s.nStep         = STEP_NUMBER;
+
+    /* Android CapabilityFlags */
+    pSECComponent->capabilityFlags.iIsOMXComponentMultiThreaded                   = OMX_TRUE;
+    pSECComponent->capabilityFlags.iOMXComponentSupportsExternalInputBufferAlloc  = OMX_TRUE;
+    pSECComponent->capabilityFlags.iOMXComponentSupportsExternalOutputBufferAlloc = OMX_TRUE;
+    pSECComponent->capabilityFlags.iOMXComponentSupportsMovableInputBuffers       = OMX_FALSE;
+    pSECComponent->capabilityFlags.iOMXComponentSupportsPartialFrames             = OMX_FALSE;
+    pSECComponent->capabilityFlags.iOMXComponentUsesNALStartCodes                 = OMX_TRUE;
+    pSECComponent->capabilityFlags.iOMXComponentCanHandleIncompleteFrames         = OMX_TRUE;
+    pSECComponent->capabilityFlags.iOMXComponentUsesFullAVCFrames                 = OMX_TRUE;
+
+    /* Input port */
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
+    pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
+    pSECPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_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.eColorFormat = SEC_OMX_COLOR_FormatNV12PhysicalAddress;
+    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; /*DEFAULT_FRAME_WIDTH;*/
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
+    pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+    SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
+    SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/avc");
+    pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
+    pSECPort->portDefinition.bEnabled = OMX_TRUE;
+
+    for(i = 0; i < ALL_PORT_NUM; i++) {
+        INIT_SET_SIZE_VERSION(&pH264Enc->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE);
+        pH264Enc->AVCComponent[i].nPortIndex = i;
+        pH264Enc->AVCComponent[i].eProfile   = OMX_VIDEO_AVCProfileBaseline;
+        pH264Enc->AVCComponent[i].eLevel     = OMX_VIDEO_AVCLevel4;
+    }
+
+    pOMXComponent->GetParameter      = &SEC_MFC_H264Enc_GetParameter;
+    pOMXComponent->SetParameter      = &SEC_MFC_H264Enc_SetParameter;
+    pOMXComponent->SetConfig         = &SEC_MFC_H264Enc_SetConfig;
+    pOMXComponent->ComponentRoleEnum = &SEC_MFC_H264Enc_ComponentRoleEnum;
+    pOMXComponent->ComponentDeInit   = &SEC_OMX_ComponentDeinit;
+
+    pSECComponent->sec_mfc_componentInit      = &SEC_MFC_H264Enc_Init;
+    pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_H264Enc_Terminate;
+    pSECComponent->sec_mfc_bufferProcess      = &SEC_MFC_H264Enc_bufferProcess;
+    pSECComponent->sec_checkInputFrame        = NULL;
+
+    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_H264ENC_HANDLE      *pH264Dec = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    SEC_OSAL_Free(pSECComponent->componentName);
+    pSECComponent->componentName = NULL;
+
+    pH264Dec = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+    if (pH264Dec != NULL) {
+        SEC_OSAL_Free(pH264Dec);
+        pH264Dec = pSECComponent->hCodecHandle = NULL;
+    }
+
+    ret = SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.h b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.h
new file mode 100644
index 0000000..a90965f
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.h
@@ -0,0 +1,78 @@
+/*
+ *
+ * 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_H264enc.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_H264_ENC_COMPONENT
+#define SEC_OMX_H264_ENC_COMPONENT
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Component.h"
+#include "OMX_Video.h"
+#include "SsbSipMfcApi.h"
+
+#define MAX_TIMESTAMP        16
+
+typedef struct _EXTRA_DATA
+{
+    OMX_PTR pHeaderSPS;
+    OMX_U32 SPSLen;
+    OMX_PTR pHeaderPPS;
+    OMX_U32 PPSLen;
+} EXTRA_DATA;
+
+typedef struct _SEC_MFC_H264ENC_HANDLE
+{
+    OMX_HANDLETYPE hMFCHandle;
+    SSBSIP_MFC_ENC_H264_PARAM mfcVideoAvc;
+    SSBSIP_MFC_ENC_INPUT_INFO inputInfo;
+/*    SSBSIP_MFC_ENC_OUTPUT_INFO outputInfo; */
+    OMX_TICKS timeStamp[MAX_TIMESTAMP];
+    OMX_U32    indexTimestamp;
+    OMX_BOOL bConfiguredMFC;
+    EXTRA_DATA headerData;
+} SEC_MFC_H264ENC_HANDLE;
+
+typedef struct _SEC_H264ENC_HANDLE
+{
+    /* OMX Codec specific */
+    OMX_VIDEO_PARAM_AVCTYPE AVCComponent[ALL_PORT_NUM];
+    OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType[ALL_PORT_NUM];
+
+    /* SEC MFC Codec specific */
+    SEC_MFC_H264ENC_HANDLE hMFCH264Handle;
+} SEC_H264ENC_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/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.c b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.c
new file mode 100644
index 0000000..ee1ea0a
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.c
@@ -0,0 +1,55 @@
+/*
+ *
+ * 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      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : 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"
+#include "SEC_OSAL_Log.h"
+
+
+OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **secComponents)
+{
+	FunctionIn();
+
+	if (secComponents == NULL)
+		goto EXIT;
+
+	/* component 1 - video decoder H.264 */
+	SEC_OSAL_Strcpy(secComponents[0]->componentName, SEC_OMX_COMPOMENT_H264_ENC);
+	SEC_OSAL_Strcpy(secComponents[0]->roles[0], SEC_OMX_COMPOMENT_H264_ENC_ROLE);
+	secComponents[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+	FunctionOut();
+
+	return MAX_COMPONENT_NUM;
+}
+
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.h b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.h
new file mode 100644
index 0000000..71397ef
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.h
@@ -0,0 +1,55 @@
+/*
+ *
+ * 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      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_H264_REG
+#define SEC_OMX_H264_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
+
+/* H.264 */
+#define SEC_OMX_COMPOMENT_H264_ENC "OMX.SEC.AVC.Encoder"
+#define SEC_OMX_COMPOMENT_H264_ENC_ROLE "video_encoder.avc"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **secComponents);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
+
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/Android.mk b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/Android.mk
new file mode 100644
index 0000000..2ad28b8
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/Android.mk
@@ -0,0 +1,30 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	../SEC_OMX_Venc.c \
+	SEC_OMX_Mpeg4enc.c \
+	library_register.c
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libOMX.SEC.M4V.Encoder
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libsecosal libsecbasecomponent libsecmfcencapi
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/sec_osal \
+	$(SEC_OMX_TOP)/sec_omx_core \
+	$(SEC_OMX_COMPONENT)/common \
+	$(SEC_OMX_COMPONENT)/video/enc
+
+LOCAL_C_INCLUDES += $(SEC_OMX_TOP)/sec_codecs/video/mfc_c110/include
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.c b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.c
new file mode 100644
index 0000000..2135016
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.c
@@ -0,0 +1,1200 @@
+/*
+ *
+ * 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_Mpeg4enc.c
+ * @brief
+ * @author      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OMX_Macros.h"
+#include "SEC_OMX_Basecomponent.h"
+#include "SEC_OMX_Baseport.h"
+#include "SEC_OMX_Venc.h"
+#include "library_register.h"
+#include "SEC_OMX_Mpeg4enc.h"
+#include "SsbSipMfcApi.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_MPEG4_ENC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+/* MPEG4 Encoder Supported Levels & profiles */
+SEC_OMX_VIDEO_PROFILELEVEL supportedMPEG4ProfileLevels[] ={
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
+    {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4a},
+    {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5}};
+
+/* H.263 Encoder Supported Levels & profiles */
+SEC_OMX_VIDEO_PROFILELEVEL supportedH263ProfileLevels[] = {
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
+    {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70}};
+
+OMX_U32 OMXMpeg4ProfileToMFCProfile(OMX_VIDEO_MPEG4PROFILETYPE profile)
+{
+    OMX_U32 ret;
+
+    switch (profile) {
+    case OMX_VIDEO_MPEG4ProfileSimple:
+        ret = 0;
+        break;
+    case OMX_VIDEO_MPEG4ProfileAdvancedSimple:
+        ret = 1;
+        break;
+    default:
+        ret = 0;
+    };
+
+    return ret;
+}
+OMX_U32 OMXMpeg4LevelToMFCLevel(OMX_VIDEO_MPEG4LEVELTYPE level)
+{
+    OMX_U32 ret;
+
+    switch (level) {
+    case OMX_VIDEO_MPEG4Level0:
+        ret = 0;
+        break;
+    case OMX_VIDEO_MPEG4Level0b:
+        ret = 9;
+        break;
+    case OMX_VIDEO_MPEG4Level1:
+        ret = 1;
+        break;
+    case OMX_VIDEO_MPEG4Level2:
+        ret = 2;
+        break;
+    case OMX_VIDEO_MPEG4Level3:
+        ret = 3;
+        break;
+    case OMX_VIDEO_MPEG4Level4:
+    case OMX_VIDEO_MPEG4Level4a:
+        ret = 4;
+        break;
+    case OMX_VIDEO_MPEG4Level5:
+        ret = 5;
+        break;
+    default:
+        ret = 0;
+    };
+
+    return ret;
+}
+
+void Mpeg4PrintParams(SSBSIP_MFC_ENC_MPEG4_PARAM mpeg4Param)
+{
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SourceWidth             : %d\n", mpeg4Param.SourceWidth);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SourceHeight            : %d\n", mpeg4Param.SourceHeight);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "IDRPeriod               : %d\n", mpeg4Param.IDRPeriod);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SliceMode               : %d\n", mpeg4Param.SliceMode);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "RandomIntraMBRefresh    : %d\n", mpeg4Param.RandomIntraMBRefresh);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "EnableFRMRateControl    : %d\n", mpeg4Param.EnableFRMRateControl);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "Bitrate                 : %d\n", mpeg4Param.Bitrate);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp                 : %d\n", mpeg4Param.FrameQp);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp_P               : %d\n", mpeg4Param.FrameQp_P);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMax               : %d\n", mpeg4Param.QSCodeMax);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMin               : %d\n", mpeg4Param.QSCodeMin);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CBRPeriodRf             : %d\n", mpeg4Param.CBRPeriodRf);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "PadControlOn            : %d\n", mpeg4Param.PadControlOn);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "LumaPadVal              : %d\n", mpeg4Param.LumaPadVal);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CbPadVal                : %d\n", mpeg4Param.CbPadVal);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CrPadVal                : %d\n", mpeg4Param.CrPadVal);
+
+    /* MPEG4 specific parameters */
+    SEC_OSAL_Log(SEC_LOG_TRACE, "ProfileIDC              : %d\n", mpeg4Param.ProfileIDC);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "LevelIDC                : %d\n", mpeg4Param.LevelIDC);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp_B               : %d\n", mpeg4Param.FrameQp_B);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "TimeIncreamentRes       : %d\n", mpeg4Param.TimeIncreamentRes);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "VopTimeIncreament       : %d\n", mpeg4Param.VopTimeIncreament);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SliceArgument           : %d\n", mpeg4Param.SliceArgument);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "NumberBFrames           : %d\n", mpeg4Param.NumberBFrames);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "DisableQpelME           : %d\n", mpeg4Param.DisableQpelME);
+}
+
+void H263PrintParams(SSBSIP_MFC_ENC_H263_PARAM h263Param)
+{
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SourceWidth             : %d\n", h263Param.SourceWidth);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SourceHeight            : %d\n", h263Param.SourceHeight);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "IDRPeriod               : %d\n", h263Param.IDRPeriod);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "SliceMode               : %d\n", h263Param.SliceMode);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "RandomIntraMBRefresh    : %d\n", h263Param.RandomIntraMBRefresh);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "EnableFRMRateControl    : %d\n", h263Param.EnableFRMRateControl);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "Bitrate                 : %d\n", h263Param.Bitrate);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp                 : %d\n", h263Param.FrameQp);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp_P               : %d\n", h263Param.FrameQp_P);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMax               : %d\n", h263Param.QSCodeMax);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMin               : %d\n", h263Param.QSCodeMin);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CBRPeriodRf             : %d\n", h263Param.CBRPeriodRf);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "PadControlOn            : %d\n", h263Param.PadControlOn);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "LumaPadVal              : %d\n", h263Param.LumaPadVal);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CbPadVal                : %d\n", h263Param.CbPadVal);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "CrPadVal                : %d\n", h263Param.CrPadVal);
+
+    /* H.263 specific parameters */
+    SEC_OSAL_Log(SEC_LOG_TRACE, "FrameRate               : %d\n", h263Param.FrameRate);
+}
+
+void Set_Mpeg4Enc_Param(SSBSIP_MFC_ENC_MPEG4_PARAM *pMpeg4Param, SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    SEC_OMX_BASEPORT    *pSECInputPort = NULL;
+    SEC_OMX_BASEPORT    *pSECOutputPort = NULL;
+    SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
+
+    pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+    pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+
+    pMpeg4Param->codecType            = MPEG4_ENC;
+    pMpeg4Param->SourceWidth          = pSECOutputPort->portDefinition.format.video.nFrameWidth;
+    pMpeg4Param->SourceHeight         = pSECOutputPort->portDefinition.format.video.nFrameHeight;
+    pMpeg4Param->IDRPeriod            = pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1;
+    pMpeg4Param->SliceMode            = 0;
+    pMpeg4Param->RandomIntraMBRefresh = 0;
+    pMpeg4Param->EnableFRMRateControl = 1;    /* 0: disable, 1: enable */
+    pMpeg4Param->Bitrate              = pSECOutputPort->portDefinition.format.video.nBitrate;
+    pMpeg4Param->FrameQp              = 20;
+    pMpeg4Param->FrameQp_P            = 20;
+    pMpeg4Param->QSCodeMax            = 30;
+    pMpeg4Param->QSCodeMin            = 10;
+    pMpeg4Param->CBRPeriodRf          = 10;
+    pMpeg4Param->PadControlOn         = 0;    /* 0: Use boundary pixel, 1: Use the below setting value */
+    pMpeg4Param->LumaPadVal           = 0;
+    pMpeg4Param->CbPadVal             = 0;
+    pMpeg4Param->CrPadVal             = 0;
+
+    pMpeg4Param->ProfileIDC           = OMXMpeg4ProfileToMFCProfile(pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].eProfile);
+    pMpeg4Param->LevelIDC             = OMXMpeg4LevelToMFCLevel(pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].eLevel);
+    pMpeg4Param->FrameQp_B            = 20;
+    pMpeg4Param->TimeIncreamentRes    = (pSECInputPort->portDefinition.format.video.xFramerate) >> 16;
+    pMpeg4Param->VopTimeIncreament    = 1;
+    pMpeg4Param->SliceArgument        = 0;    /* MB number or byte number */
+    pMpeg4Param->NumberBFrames        = 0;    /* 0(not used) ~ 2 */
+    pMpeg4Param->DisableQpelME        = 1;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pSECPort->eControlRate: 0x%x", pSECOutputPort->eControlRate);
+    switch (pSECOutputPort->eControlRate) {
+    case OMX_Video_ControlRateDisable:
+        /* TBD */
+        break;
+    case OMX_Video_ControlRateVariable:
+        /* TBD */
+        break;
+    default:
+        break;
+    }
+
+    Mpeg4PrintParams(*pMpeg4Param);
+}
+
+void Set_H263Enc_Param(SSBSIP_MFC_ENC_H263_PARAM *pH263Param, SEC_OMX_BASECOMPONENT *pSECComponent)
+{
+    SEC_OMX_BASEPORT    *pSECInputPort = NULL;
+    SEC_OMX_BASEPORT    *pSECOutputPort = NULL;
+    SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
+
+    pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+    pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+
+    pH263Param->codecType            = H263_ENC;
+    pH263Param->SourceWidth          = pSECOutputPort->portDefinition.format.video.nFrameWidth;
+    pH263Param->SourceHeight         = pSECOutputPort->portDefinition.format.video.nFrameHeight;
+    pH263Param->IDRPeriod            = pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1;
+    pH263Param->SliceMode            = 0;
+    pH263Param->RandomIntraMBRefresh = 0;
+    pH263Param->EnableFRMRateControl = 1;    /* 0: disable, 1: enable */
+    pH263Param->Bitrate              = pSECOutputPort->portDefinition.format.video.nBitrate;
+    pH263Param->FrameQp              = 20;
+    pH263Param->FrameQp_P            = 20;
+    pH263Param->QSCodeMax            = 30;
+    pH263Param->QSCodeMin            = 10;
+    pH263Param->CBRPeriodRf          = 10;
+    pH263Param->PadControlOn         = 0;    /* 0: Use boundary pixel, 1: Use the below setting value */
+    pH263Param->LumaPadVal           = 0;
+    pH263Param->CbPadVal             = 0;
+    pH263Param->CrPadVal             = 0;
+
+    pH263Param->FrameRate            = (pSECInputPort->portDefinition.format.video.xFramerate) >> 16;
+
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pSECPort->eControlRate: 0x%x", pSECOutputPort->eControlRate);
+    switch (pSECOutputPort->eControlRate) {
+    case OMX_Video_ControlRateDisable:
+        /* TBD */
+        break;
+    case OMX_Video_ControlRateVariable:
+        /* TBD */
+        break;
+    default:
+        break;
+    }
+
+    H263PrintParams(*pH263Param);
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_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_StateInvalid;
+        goto EXIT;
+    }
+
+    switch (nParamIndex) {
+    case OMX_IndexParamVideoMpeg4:
+    {
+        OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
+        SEC_MPEG4ENC_HANDLE       *pMpeg4Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcMpeg4Param = &pMpeg4Enc->mpeg4Component[pDstMpeg4Param->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
+    }
+        break;
+    case OMX_IndexParamVideoH263:
+    {
+        OMX_VIDEO_PARAM_H263TYPE  *pDstH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_H263TYPE  *pSrcH263Param = NULL;
+        SEC_MPEG4ENC_HANDLE       *pMpeg4Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstH263Param->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcH263Param = &pMpeg4Enc->h263Component[pDstH263Param->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
+    }
+        break;
+    case OMX_IndexParamStandardComponentRole:
+    {
+        OMX_S32 codecType;
+        OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
+
+        ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        codecType = ((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
+        if (codecType == CODEC_TYPE_MPEG4)
+            SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPOMENT_MPEG4_ENC_ROLE);
+        else
+            SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPOMENT_H263_ENC_ROLE);
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelQuerySupported:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        SEC_OMX_VIDEO_PROFILELEVEL       *pProfileLevel = NULL;
+        OMX_U32                           maxProfileLevelNum = 0;
+        OMX_S32                           codecType;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        codecType = ((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
+        if (codecType == CODEC_TYPE_MPEG4) {
+            pProfileLevel = supportedMPEG4ProfileLevels;
+            maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
+        } else {
+            pProfileLevel = supportedH263ProfileLevels;
+            maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
+        }
+
+        if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
+            ret = OMX_ErrorNoMore;
+            goto EXIT;
+        }
+
+        pProfileLevel += pDstProfileLevel->nProfileIndex;
+        pDstProfileLevel->eProfile = pProfileLevel->profile;
+        pDstProfileLevel->eLevel = pProfileLevel->level;
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_MPEG4TYPE        *pSrcMpeg4Param = NULL;
+        OMX_VIDEO_PARAM_H263TYPE         *pSrcH263Param = NULL;
+        SEC_MPEG4ENC_HANDLE              *pMpeg4Enc = NULL;
+        OMX_S32                           codecType;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+        codecType = pMpeg4Enc->hMFCMpeg4Handle.codecType;
+        if (codecType == CODEC_TYPE_MPEG4) {
+            pSrcMpeg4Param = &pMpeg4Enc->mpeg4Component[pDstProfileLevel->nPortIndex];
+            pDstProfileLevel->eProfile = pSrcMpeg4Param->eProfile;
+            pDstProfileLevel->eLevel = pSrcMpeg4Param->eLevel;
+        } else {
+            pSrcH263Param = &pMpeg4Enc->h263Component[pDstProfileLevel->nPortIndex];
+            pDstProfileLevel->eProfile = pSrcH263Param->eProfile;
+            pDstProfileLevel->eLevel = pSrcH263Param->eLevel;
+        }
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
+        SEC_MPEG4ENC_HANDLE                 *pMpeg4Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pSrcErrorCorrectionType = &pMpeg4Enc->errorCorrectionType[OUTPUT_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_VideoEncodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
+        break;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_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_StateInvalid;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexParamVideoMpeg4:
+    {
+        OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
+        OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
+        SEC_MPEG4ENC_HANDLE       *pMpeg4Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pDstMpeg4Param = &pMpeg4Enc->mpeg4Component[pSrcMpeg4Param->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
+    }
+        break;
+    case OMX_IndexParamVideoH263:
+    {
+        OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
+        OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
+        SEC_MPEG4ENC_HANDLE      *pMpeg4Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcH263Param->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pDstH263Param = &pMpeg4Enc->h263Component[pSrcH263Param->nPortIndex];
+
+        SEC_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
+    }
+        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_COMPOMENT_MPEG4_ENC_ROLE)) {
+            pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+            //((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_MPEG4;
+        } else if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPOMENT_H263_ENC_ROLE)) {
+            pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
+            //((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_H263;
+        } else {
+            ret = OMX_ErrorBadParameter;
+            goto EXIT;
+        }
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_MPEG4TYPE        *pDstMpeg4Param = NULL;
+        OMX_VIDEO_PARAM_H263TYPE         *pDstH263Param = NULL;
+        SEC_MPEG4ENC_HANDLE              *pMpeg4Enc = NULL;
+        OMX_S32                           codecType;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+        codecType = pMpeg4Enc->hMFCMpeg4Handle.codecType;
+        if (codecType == CODEC_TYPE_MPEG4) {
+            /*
+             * To do: Check validity of profile & level parameters
+             */
+
+            pDstMpeg4Param = &pMpeg4Enc->mpeg4Component[pSrcProfileLevel->nPortIndex];
+            pDstMpeg4Param->eProfile = pSrcProfileLevel->eProfile;
+            pDstMpeg4Param->eLevel = pSrcProfileLevel->eLevel;
+        } else {
+            /*
+             * To do: Check validity of profile & level parameters
+             */
+
+            pDstH263Param = &pMpeg4Enc->h263Component[pSrcProfileLevel->nPortIndex];
+            pDstH263Param->eProfile = pSrcProfileLevel->eProfile;
+            pDstH263Param->eLevel = pSrcProfileLevel->eLevel;
+        }
+    }
+        break;
+    case OMX_IndexParamVideoErrorCorrection:
+    {
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
+        SEC_MPEG4ENC_HANDLE                 *pMpeg4Enc = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pSrcErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+        pDstErrorCorrectionType = &pMpeg4Enc->errorCorrectionType[OUTPUT_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_VideoEncodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
+        break;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_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_SetConfig(hComponent, nIndex, pComponentConfigStructure);
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_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;
+    OMX_S32                  codecType;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (cRole == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) {
+        ret = OMX_ErrorNoMore;
+        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_StateInvalid;
+        goto EXIT;
+    }
+
+    codecType = ((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
+    if (codecType == CODEC_TYPE_MPEG4)
+        SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPOMENT_MPEG4_ENC_ROLE);
+    else
+        SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPOMENT_H263_ENC_ROLE);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Init */
+OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_Init(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE              ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT     *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_OMX_BASEPORT          *pSECPort = NULL;
+    SEC_MPEG4ENC_HANDLE       *pMpeg4Enc = NULL;
+    OMX_HANDLETYPE             hMFCHandle = NULL;
+    OMX_S32                    returnCodec = 0;
+
+    FunctionIn();
+
+    pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+    pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFC = OMX_FALSE;
+    pSECComponent->bUseFlagEOF = OMX_FALSE;
+    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+
+    /* MFC(Multi Format Codec) encoder and CMM(Codec Memory Management) driver open */
+    hMFCHandle = SsbSipMfcEncOpen();
+    if (hMFCHandle == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = hMFCHandle;
+
+    /* set MFC ENC VIDEO PARAM and initialize MFC encoder instance */
+    if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4) {
+        Set_Mpeg4Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam), pSECComponent);
+        returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam));
+    } else {
+        Set_H263Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam), pSECComponent);
+        returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam));
+    }
+    if (returnCodec != MFC_RET_OK) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+
+    /* allocate encoder's input buffer */
+    returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.inputInfo));
+    if (returnCodec != MFC_RET_OK) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YPhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CPhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YSize;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CSize;
+
+    SEC_OSAL_Memset(pMpeg4Enc->hMFCMpeg4Handle.timestamp, 0, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+    pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp = 0;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Terminate */
+OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_MPEG4ENC_HANDLE   *pMpeg4Enc = NULL;
+    OMX_HANDLETYPE         hMFCHandle = NULL;
+
+    FunctionIn();
+
+    pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+    hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
+
+    if (hMFCHandle != NULL) {
+        SsbSipMfcEncClose(hMFCHandle);
+        pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = NULL;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_Mpeg4_Encode(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_MPEG4ENC_HANDLE       *pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+    OMX_HANDLETYPE             hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
+    SSBSIP_MFC_ENC_INPUT_INFO *pInputInfo = &(pMpeg4Enc->hMFCMpeg4Handle.inputInfo);
+    SSBSIP_MFC_ENC_OUTPUT_INFO outputInfo;
+    SEC_OMX_BASEPORT          *pSECPort = NULL;
+    MFC_ENC_ADDR_INFO          addrInfo;
+    OMX_U32                    oneFrameSize = pInputData->dataLen;
+    OMX_S32                    returnCodec = 0;
+
+    FunctionIn();
+
+    if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFC == OMX_FALSE) {
+        returnCodec = SsbSipMfcEncGetOutBuf(hMFCHandle, &outputInfo);
+        if (returnCodec != MFC_RET_OK)
+        {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncGetOutBuf failed, ret:%d", __FUNCTION__, returnCodec);
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+
+        pOutputData->dataBuffer = outputInfo.StrmVirAddr;
+        pOutputData->allocSize = outputInfo.headerSize;
+        pOutputData->dataLen = outputInfo.headerSize;
+        pOutputData->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
+        pOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
+
+        pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFC = OMX_TRUE;
+
+        if (pOutputData->dataLen > 0) {
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        } else {
+            ret = OMX_ErrorInputDataEncodeYet;
+            goto EXIT;
+        }
+    }
+
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE)) {
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+    }
+
+    pMpeg4Enc->hMFCMpeg4Handle.timestamp[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pInputData->timeStamp;
+    SsbSipMfcEncSetConfig(hMFCHandle, MFC_ENC_SETCONF_FRAME_TAG, &(pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp));
+    pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp++;
+    if (pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp >= MAX_TIMESTAMP)
+        pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp = 0;
+
+    if (oneFrameSize <= 0) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    if (pSECPort->portDefinition.format.video.eColorFormat == SEC_OMX_COLOR_FormatNV12PhysicalAddress) {
+    /* input data from Real camera */
+#define USE_FIMC_FRAME_BUFFER
+#ifdef USE_FIMC_FRAME_BUFFER
+        SEC_OSAL_Memcpy(&addrInfo.pAddrY, pInputData->dataBuffer, sizeof(addrInfo.pAddrY));
+        SEC_OSAL_Memcpy(&addrInfo.pAddrC, pInputData->dataBuffer + sizeof(addrInfo.pAddrY), sizeof(addrInfo.pAddrC));
+        pInputInfo->YPhyAddr = addrInfo.pAddrY;
+        pInputInfo->CPhyAddr = addrInfo.pAddrC;
+        returnCodec = SsbSipMfcEncSetInBuf(hMFCHandle, pInputInfo);
+        if (returnCodec != MFC_RET_OK) {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncSetInBuf failed, ret:%d", __FUNCTION__, returnCodec);
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+#else
+        OMX_U32 width, height;
+
+        width = pSECPort->portDefinition.format.video.nFrameWidth;
+        height = pSECPort->portDefinition.format.video.nFrameHeight;
+
+        SEC_OSAL_Memcpy(pInputInfo->YVirAddr, pInputData->dataBuffer, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)));
+        SEC_OSAL_Memcpy(pInputInfo->CVirAddr, pInputData->dataBuffer + ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)), ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2)));
+#endif
+    }
+
+    returnCodec = SsbSipMfcEncExe(hMFCHandle);
+    if (returnCodec == MFC_RET_OK) {
+        OMX_S32 indexTimestamp = 0;
+
+        returnCodec = SsbSipMfcEncGetOutBuf(hMFCHandle, &outputInfo);
+
+        if (SsbSipMfcEncGetConfig(hMFCHandle, MFC_ENC_GETCONF_FRAME_TAG, &indexTimestamp) == MFC_RET_OK)
+            pOutputData->timeStamp = pMpeg4Enc->hMFCMpeg4Handle.timestamp[indexTimestamp];
+        else
+            pOutputData->timeStamp = pInputData->timeStamp;
+
+        if (returnCodec == MFC_RET_OK) {
+            /** Fill Output Buffer **/
+            pOutputData->dataBuffer = outputInfo.StrmVirAddr;
+            pOutputData->allocSize = outputInfo.dataSize;
+            pOutputData->dataLen = outputInfo.dataSize;
+            pOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
+            if (outputInfo.frameType == MFC_FRAME_TYPE_I_FRAME)
+                    pOutputData->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
+
+            ret = OMX_ErrorNone;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncGetOutBuf failed, ret:%d", __FUNCTION__, returnCodec);
+            ret = OMX_ErrorUndefined;
+        }
+    } else {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncExe failed, ret:%d", __FUNCTION__, returnCodec);
+        ret = OMX_ErrorUndefined;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Encode */
+OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_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_OMX_BASEPORT        *pInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT        *pOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+
+    FunctionIn();
+
+    if ((!CHECK_PORT_ENABLED(pInputPort)) || (!CHECK_PORT_ENABLED(pOutputPort)) ||
+            (!CHECK_PORT_POPULATED(pInputPort)) || (!CHECK_PORT_POPULATED(pOutputPort))) {
+        goto EXIT;
+    }
+    if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
+        goto EXIT;
+    }
+
+    if (pInputData->nFlags & OMX_BUFFERFLAG_EOS)
+        pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
+    else
+        pOutputData->nFlags = pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS);
+
+    ret = SEC_MFC_Mpeg4_Encode(pOMXComponent, pInputData, pOutputData);
+    if (ret != OMX_ErrorNone) {
+        if (ret == OMX_ErrorInputDataEncodeYet) {
+            pOutputData->usedDataLen = 0;
+            pOutputData->remainDataLen = pOutputData->dataLen;
+        } else {
+        pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
+                                        pSECComponent->callbackData,
+                                        OMX_EventError, ret, 0, NULL);
+        }
+    } else {
+        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_MPEG4ENC_HANDLE     *pMpeg4Enc = NULL;
+    OMX_S32                  codecType = -1;
+    int i = 0;
+
+    FunctionIn();
+
+    if ((hComponent == NULL) || (componentName == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: parameters are null, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+    if (SEC_OSAL_Strcmp(SEC_OMX_COMPOMENT_MPEG4_ENC, componentName) == 0) {
+        codecType = CODEC_TYPE_MPEG4;
+    } else if (SEC_OSAL_Strcmp(SEC_OMX_COMPOMENT_H263_ENC, componentName) == 0) {
+        codecType = CODEC_TYPE_H263;
+    } else {
+        ret = OMX_ErrorBadParameter;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: componentName(%s) error, ret: %X", __FUNCTION__, componentName, ret);
+        goto EXIT;
+    }
+
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_VideoEncodeComponentInit(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_OMX_VideoDecodeComponentInit error, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pSECComponent->codecType = HW_VIDEO_CODEC;
+
+    pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
+    if (pSECComponent->componentName == NULL) {
+        SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: componentName alloc error, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
+
+    pMpeg4Enc = SEC_OSAL_Malloc(sizeof(SEC_MPEG4ENC_HANDLE));
+    if (pMpeg4Enc == NULL) {
+        SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
+        ret = OMX_ErrorInsufficientResources;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_MPEG4ENC_HANDLE alloc error, ret: %X", __FUNCTION__, ret);
+        goto EXIT;
+    }
+    SEC_OSAL_Memset(pMpeg4Enc, 0, sizeof(SEC_MPEG4ENC_HANDLE));
+    pSECComponent->hCodecHandle = (OMX_HANDLETYPE)pMpeg4Enc;
+    pMpeg4Enc->hMFCMpeg4Handle.codecType = codecType;
+
+    if (codecType == CODEC_TYPE_MPEG4)
+        SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPOMENT_MPEG4_ENC);
+    else
+        SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPOMENT_H263_ENC);
+
+    /* 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.nBitrate = 64000;
+    pSECPort->portDefinition.format.video.xFramerate= (15 << 16);
+    pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
+    pSECPort->portDefinition.format.video.pNativeRender = 0;
+    pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
+    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.eColorFormat = SEC_OMX_COLOR_FormatNV12PhysicalAddress;//OMX_COLOR_FormatYUV420SemiPlanar;
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
+    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.nBitrate = 64000;
+    pSECPort->portDefinition.format.video.xFramerate= (15 << 16);
+    if (codecType == CODEC_TYPE_MPEG4) {
+        pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+        SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
+        SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/mpeg4");
+    } else {
+        pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
+        SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
+        SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/h263");
+    }
+    pSECPort->portDefinition.format.video.pNativeRender = 0;
+    pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
+    pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
+    pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
+    pSECPort->portDefinition.bEnabled = OMX_TRUE;
+
+    if (codecType == CODEC_TYPE_MPEG4) {
+        for(i = 0; i < ALL_PORT_NUM; i++) {
+            INIT_SET_SIZE_VERSION(&pMpeg4Enc->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
+            pMpeg4Enc->mpeg4Component[i].nPortIndex = i;
+            pMpeg4Enc->mpeg4Component[i].eProfile   = OMX_VIDEO_MPEG4ProfileCore;
+            pMpeg4Enc->mpeg4Component[i].eLevel     = OMX_VIDEO_MPEG4Level2;
+
+            pMpeg4Enc->mpeg4Component[i].nPFrames = 10;
+            pMpeg4Enc->mpeg4Component[i].nBFrames = 0;          /* No support for B frames */
+            pMpeg4Enc->mpeg4Component[i].nMaxPacketSize = 256;  /* Default value */
+            pMpeg4Enc->mpeg4Component[i].nAllowedPictureTypes =  OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
+            pMpeg4Enc->mpeg4Component[i].bGov = OMX_FALSE;
+
+        }
+    } else {
+        for(i = 0; i < ALL_PORT_NUM; i++) {
+            INIT_SET_SIZE_VERSION(&pMpeg4Enc->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
+            pMpeg4Enc->h263Component[i].nPortIndex = i;
+            pMpeg4Enc->h263Component[i].eProfile   = OMX_VIDEO_H263ProfileBaseline;
+            pMpeg4Enc->h263Component[i].eLevel     = OMX_VIDEO_H263Level45;
+
+            pMpeg4Enc->h263Component[i].nPFrames = 20;
+            pMpeg4Enc->h263Component[i].nBFrames = 0;          /* No support for B frames */
+            pMpeg4Enc->h263Component[i].bPLUSPTYPEAllowed = OMX_FALSE;
+            pMpeg4Enc->h263Component[i].nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
+            pMpeg4Enc->h263Component[i].bForceRoundingTypeToZero = OMX_TRUE;
+            pMpeg4Enc->h263Component[i].nPictureHeaderRepetition = 0;
+            pMpeg4Enc->h263Component[i].nGOBHeaderInterval = 0;
+        }
+    }
+
+    pOMXComponent->GetParameter      = &SEC_MFC_Mpeg4Enc_GetParameter;
+    pOMXComponent->SetParameter      = &SEC_MFC_Mpeg4Enc_SetParameter;
+    pOMXComponent->SetConfig         = &SEC_MFC_Mpeg4Enc_SetConfig;
+    pOMXComponent->ComponentRoleEnum = &SEC_MFC_Mpeg4Enc_ComponentRoleEnum;
+    pOMXComponent->ComponentDeInit   = &SEC_OMX_ComponentDeinit;
+
+    pSECComponent->sec_mfc_componentInit      = &SEC_MFC_Mpeg4Enc_Init;
+    pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_Mpeg4Enc_Terminate;
+    pSECComponent->sec_mfc_bufferProcess      = &SEC_MFC_Mpeg4Enc_bufferProcess;
+    pSECComponent->sec_checkInputFrame        = NULL;
+
+    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_MPEG4ENC_HANDLE     *pMpeg4Enc = 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;
+
+    pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+    if (pMpeg4Enc != NULL) {
+        SEC_OSAL_Free(pMpeg4Enc);
+        pMpeg4Enc = pSECComponent->hCodecHandle = NULL;
+    }
+
+    ret = SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.h b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.h
new file mode 100644
index 0000000..57f3124
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.h
@@ -0,0 +1,79 @@
+/*
+ *
+ * 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_Mpeg4enc.h
+ * @brief
+ * @author      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_MPEG4_ENC_COMPONENT
+#define SEC_OMX_MPEG4_ENC_COMPONENT
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Component.h"
+#include "SsbSipMfcApi.h"
+
+#define MAX_TIMESTAMP        16
+
+
+typedef enum _CODEC_TYPE
+{
+    CODEC_TYPE_H263,
+    CODEC_TYPE_MPEG4
+} CODEC_TYPE;
+
+typedef struct _SEC_MFC_MPEG4ENC_HANDLE
+{
+    OMX_HANDLETYPE             hMFCHandle;
+    SSBSIP_MFC_ENC_MPEG4_PARAM mpeg4MFCParam;
+    SSBSIP_MFC_ENC_H263_PARAM  h263MFCParam;
+    SSBSIP_MFC_ENC_INPUT_INFO  inputInfo;
+    OMX_TICKS                  timestamp[MAX_TIMESTAMP];
+    OMX_U32                    indexTimestamp;
+    OMX_BOOL                   bConfiguredMFC;
+    CODEC_TYPE                 codecType;
+} SEC_MFC_MPEG4ENC_HANDLE;
+
+typedef struct _SEC_MPEG4ENC_HANDLE
+{
+    /* OMX Codec specific */
+    OMX_VIDEO_PARAM_H263TYPE  h263Component[ALL_PORT_NUM];
+    OMX_VIDEO_PARAM_MPEG4TYPE mpeg4Component[ALL_PORT_NUM];
+    OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType[ALL_PORT_NUM];
+
+    /* SEC MFC Codec specific */
+    SEC_MFC_MPEG4ENC_HANDLE   hMFCMpeg4Handle;
+} SEC_MPEG4ENC_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/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.c b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.c
new file mode 100644
index 0000000..20e4eb8
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.c
@@ -0,0 +1,64 @@
+/*
+ *
+ * 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      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : 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_MPEG4_ENC"
+#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 encoder MPEG4 */
+	SEC_OSAL_Strcpy(ppSECComponent[0]->componentName, SEC_OMX_COMPOMENT_MPEG4_ENC);
+	SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPOMENT_MPEG4_ENC_ROLE);
+	ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+	/* component 2 - video encoder H.263 */
+	SEC_OSAL_Strcpy(ppSECComponent[1]->componentName, SEC_OMX_COMPOMENT_H263_ENC);
+	SEC_OSAL_Strcpy(ppSECComponent[1]->roles[0], SEC_OMX_COMPOMENT_H263_ENC_ROLE);
+	ppSECComponent[1]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+	FunctionOut();
+	return MAX_COMPONENT_NUM;
+}
+
diff --git a/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.h b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.h
new file mode 100644
index 0000000..3b23011
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.h
@@ -0,0 +1,59 @@
+/*
+ *
+ * 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      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_MPEG4_ENC_REG
+#define SEC_OMX_MPEG4_ENC_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       2
+#define MAX_COMPONENT_ROLE_NUM  1
+
+/* MPEG4 */
+#define SEC_OMX_COMPOMENT_MPEG4_ENC         "OMX.SEC.MPEG4.Encoder"
+#define SEC_OMX_COMPOMENT_MPEG4_ENC_ROLE    "video_encoder.mpeg4"
+
+/* H.263 */
+#define SEC_OMX_COMPOMENT_H263_ENC          "OMX.SEC.H263.Encoder"
+#define SEC_OMX_COMPOMENT_H263_ENC_ROLE     "video_encoder.h263"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
+
diff --git a/sec_mm/sec_omx/sec_omx_core/Android.mk b/sec_mm/sec_omx/sec_omx_core/Android.mk
new file mode 100644
index 0000000..dc2e3ee
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_core/Android.mk
@@ -0,0 +1,25 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := SEC_OMX_Component_Register.c \
+	SEC_OMX_Core.c
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libSEC_OMX_Core
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libsecosal libsecbasecomponent
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/sec_osal \
+	$(SEC_OMX_TOP)/sec_omx_component/common
+
+include $(BUILD_SHARED_LIBRARY)
+
diff --git a/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.c b/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.c
new file mode 100644
index 0000000..1464397
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.c
@@ -0,0 +1,269 @@
+/*
+ *
+ * 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_Component_Register.c
+ * @brief      SEC OpenMAX IL Component Register
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "OMX_Component.h"
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_ETC.h"
+#include "SEC_OSAL_Library.h"
+#include "SEC_OMX_Component_Register.h"
+#include "SEC_OMX_Macros.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_COMP_REGS"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+#define REGISTRY_FILENAME "secomxregistry"
+
+
+OMX_ERRORTYPE SEC_OMX_Component_Register(SEC_OMX_COMPONENT_REGLIST **compList, OMX_U32 *compNum)
+{
+    OMX_ERRORTYPE  ret = OMX_ErrorNone;
+    int            componentNum = 0, roleNum = 0, totalCompNum = 0;
+    int            read;
+    char          *omxregistryfile = NULL;
+    char          *line = NULL;
+    char          *libName;
+    FILE          *omxregistryfp;
+    size_t         len;
+    OMX_HANDLETYPE soHandle;
+    const char    *errorMsg;
+    int (*SEC_OMX_COMPONENT_Library_Register)(SECRegisterComponentType **secComponents);
+    SECRegisterComponentType **secComponentsTemp;
+    SEC_OMX_COMPONENT_REGLIST *componentList;
+
+    FunctionIn();
+
+    omxregistryfile = SEC_OSAL_Malloc(strlen("/system/etc/") + strlen(REGISTRY_FILENAME) + 2);
+    SEC_OSAL_Strcpy(omxregistryfile, "/system/etc/");
+    SEC_OSAL_Strcat(omxregistryfile, REGISTRY_FILENAME);
+
+    omxregistryfp = fopen(omxregistryfile, "r");
+    if (omxregistryfp == NULL) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+    SEC_OSAL_Free(omxregistryfile);
+
+    fseek(omxregistryfp, 0, 0);
+    componentList = (SEC_OMX_COMPONENT_REGLIST *)SEC_OSAL_Malloc(sizeof(SEC_OMX_COMPONENT_REGLIST) * MAX_OMX_COMPONENT_NUM);
+    SEC_OSAL_Memset(componentList, 0, sizeof(SEC_OMX_COMPONENT_REGLIST) * MAX_OMX_COMPONENT_NUM);
+    libName = SEC_OSAL_Malloc(MAX_OMX_COMPONENT_LIBNAME_SIZE);
+
+    while ((read = getline(&line, &len, omxregistryfp)) != -1) {
+        if ((*line == 'l') && (*(line + 1) == 'i') && (*(line + 2) == 'b') &&
+            (*(line + 3) == 'O') && (*(line + 4) == 'M') && (*(line + 5) == 'X')) {
+            SEC_OSAL_Memset(libName, 0, MAX_OMX_COMPONENT_LIBNAME_SIZE);
+            SEC_OSAL_Strncpy(libName, line, SEC_OSAL_Strlen(line)-1);
+            SEC_OSAL_Log(SEC_LOG_TRACE, "libName : %s", libName);
+
+            if ((soHandle = SEC_OSAL_dlopen(libName, RTLD_NOW)) != NULL) {
+                SEC_OSAL_dlerror();    /* clear error*/
+                if ((SEC_OMX_COMPONENT_Library_Register = SEC_OSAL_dlsym(soHandle, "SEC_OMX_COMPONENT_Library_Register")) != NULL) {
+                    int i = 0, j = 0;
+
+                    componentNum = (*SEC_OMX_COMPONENT_Library_Register)(NULL);
+                    secComponentsTemp = (SECRegisterComponentType **)SEC_OSAL_Malloc(sizeof(SECRegisterComponentType*) * componentNum);
+                    for (i = 0; i < componentNum; i++) {
+                        secComponentsTemp[i] = SEC_OSAL_Malloc(sizeof(SECRegisterComponentType));
+                        SEC_OSAL_Memset(secComponentsTemp[i], 0, sizeof(SECRegisterComponentType));
+                    }
+                    (*SEC_OMX_COMPONENT_Library_Register)(secComponentsTemp);
+
+                    for (i = 0; i < componentNum; i++) {
+                        SEC_OSAL_Strcpy(componentList[totalCompNum].component.componentName, secComponentsTemp[i]->componentName);
+                        for (j = 0; j < secComponentsTemp[i]->totalRoleNum; j++)
+                            SEC_OSAL_Strcpy(componentList[totalCompNum].component.roles[j], secComponentsTemp[i]->roles[j]);
+                        componentList[totalCompNum].component.totalRoleNum = secComponentsTemp[i]->totalRoleNum;
+
+                        SEC_OSAL_Strcpy(componentList[totalCompNum].libName, libName);
+
+                        totalCompNum++;
+                    }
+                    for (i = 0; i < componentNum; i++) {
+                        SEC_OSAL_Free(secComponentsTemp[i]);
+                    }
+
+                    SEC_OSAL_Free(secComponentsTemp);
+                } else {
+                    if ((errorMsg = SEC_OSAL_dlerror()) != NULL)
+                        SEC_OSAL_Log(SEC_LOG_WARNING, "dlsym failed: %s", errorMsg);
+                }
+                SEC_OSAL_dlclose(soHandle);
+            } else {
+                SEC_OSAL_Log(SEC_LOG_WARNING, "dlopen failed: %s", SEC_OSAL_dlerror());
+            }
+        } else {
+            /* not a component name line. skip */
+            continue;
+        }
+    }
+
+    SEC_OSAL_Free(libName);
+    fclose(omxregistryfp);
+
+    *compList = componentList;
+    *compNum = totalCompNum;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_Component_Unregister(SEC_OMX_COMPONENT_REGLIST *componentList)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    SEC_OSAL_Memset(componentList, 0, sizeof(SEC_OMX_COMPONENT_REGLIST) * MAX_OMX_COMPONENT_NUM);
+    SEC_OSAL_Free(componentList);
+
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_ComponentAPICheck(OMX_COMPONENTTYPE component)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    if ((NULL == component.GetComponentVersion)    ||
+        (NULL == component.SendCommand)            ||
+        (NULL == component.GetParameter)           ||
+        (NULL == component.SetParameter)           ||
+        (NULL == component.GetConfig)              ||
+        (NULL == component.SetConfig)              ||
+        (NULL == component.GetExtensionIndex)      ||
+        (NULL == component.GetState)               ||
+        (NULL == component.ComponentTunnelRequest) ||
+        (NULL == component.UseBuffer)              ||
+        (NULL == component.AllocateBuffer)         ||
+        (NULL == component.FreeBuffer)             ||
+        (NULL == component.EmptyThisBuffer)        ||
+        (NULL == component.FillThisBuffer)         ||
+        (NULL == component.SetCallbacks)           ||
+        (NULL == component.ComponentDeInit)        ||
+        (NULL == component.UseEGLImage)            ||
+        (NULL == component.ComponentRoleEnum))
+        ret = OMX_ErrorInvalidComponent;
+    else
+        ret = OMX_ErrorNone;
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_ComponentLoad(SEC_OMX_COMPONENT *sec_component)
+{
+    OMX_ERRORTYPE      ret = OMX_ErrorNone;
+    OMX_HANDLETYPE     libHandle;
+    OMX_COMPONENTTYPE *pOMXComponent;
+
+    FunctionIn();
+
+    OMX_ERRORTYPE (*SEC_OMX_ComponentInit)(OMX_HANDLETYPE hComponent, OMX_STRING componentName);
+
+    libHandle = SEC_OSAL_dlopen(sec_component->libName, RTLD_NOW);
+    if (!libHandle) {
+        ret = OMX_ErrorInvalidComponentName;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponentName, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    SEC_OMX_ComponentInit = SEC_OSAL_dlsym(libHandle, "SEC_OMX_ComponentInit");
+    if (!SEC_OMX_ComponentInit) {
+        SEC_OSAL_dlclose(libHandle);
+        ret = OMX_ErrorInvalidComponent;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__);
+        goto EXIT;
+    }
+
+    pOMXComponent = (OMX_COMPONENTTYPE *)SEC_OSAL_Malloc(sizeof(OMX_COMPONENTTYPE));
+    INIT_SET_SIZE_VERSION(pOMXComponent, OMX_COMPONENTTYPE);
+    ret = (*SEC_OMX_ComponentInit)((OMX_HANDLETYPE)pOMXComponent, sec_component->componentName);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Free(pOMXComponent);
+        SEC_OSAL_dlclose(libHandle);
+        ret = OMX_ErrorInvalidComponent;
+        SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__);
+        goto EXIT;
+    } else {
+        if (SEC_OMX_ComponentAPICheck(*pOMXComponent) != OMX_ErrorNone) {
+            SEC_OSAL_Free(pOMXComponent);
+            SEC_OSAL_dlclose(libHandle);
+            if (NULL != pOMXComponent->ComponentDeInit)
+                pOMXComponent->ComponentDeInit(pOMXComponent);
+            ret = OMX_ErrorInvalidComponent;
+            SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__);
+            goto EXIT;
+        }
+        sec_component->libHandle = libHandle;
+        sec_component->pOMXComponent = pOMXComponent;
+        ret = OMX_ErrorNone;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_ComponentUnload(SEC_OMX_COMPONENT *sec_component)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE *pOMXComponent = NULL;
+
+    FunctionIn();
+
+    if (!sec_component) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pOMXComponent = sec_component->pOMXComponent;
+    if (pOMXComponent != NULL) {
+        pOMXComponent->ComponentDeInit(pOMXComponent);
+        SEC_OSAL_Free(pOMXComponent);
+        sec_component->pOMXComponent = NULL;
+    }
+
+    if (sec_component->libHandle != NULL) {
+        SEC_OSAL_dlclose(sec_component->libHandle);
+        sec_component->libHandle = NULL;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.h b/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.h
new file mode 100644
index 0000000..66580bd
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.h
@@ -0,0 +1,75 @@
+/*
+ *
+ * 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_Component_Register.h
+ * @brief      SEC OpenMAX IL Component Register
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_COMPONENT_REG
+#define SEC_OMX_COMPONENT_REG
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Types.h"
+#include "OMX_Core.h"
+#include "OMX_Component.h"
+
+
+typedef struct _SECRegisterComponentType
+{
+    OMX_U8  componentName[MAX_OMX_COMPONENT_NAME_SIZE];
+    OMX_U8  roles[MAX_OMX_COMPONENT_ROLE_NUM][MAX_OMX_COMPONENT_ROLE_SIZE];
+    OMX_U32 totalRoleNum;
+} SECRegisterComponentType;
+
+typedef struct _SEC_OMX_COMPONENT_REGLIST
+{
+    SECRegisterComponentType component;
+    OMX_U8  libName[MAX_OMX_COMPONENT_LIBNAME_SIZE];
+} SEC_OMX_COMPONENT_REGLIST;
+
+struct SEC_OMX_COMPONENT;
+typedef struct _SEC_OMX_COMPONENT
+{
+    OMX_U8                    componentName[MAX_OMX_COMPONENT_NAME_SIZE];
+    OMX_U8                    libName[MAX_OMX_COMPONENT_LIBNAME_SIZE];
+    OMX_HANDLETYPE            libHandle;
+    OMX_COMPONENTTYPE        *pOMXComponent;
+    struct SEC_OMX_COMPONENT *nextOMXComp;
+} SEC_OMX_COMPONENT;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+OMX_ERRORTYPE SEC_OMX_Component_Register(SEC_OMX_COMPONENT_REGLIST **compList, OMX_U32 *compNum);
+OMX_ERRORTYPE SEC_OMX_Component_Unregister(SEC_OMX_COMPONENT_REGLIST *componentList);
+OMX_ERRORTYPE SEC_OMX_ComponentLoad(SEC_OMX_COMPONENT *sec_component);
+OMX_ERRORTYPE SEC_OMX_ComponentUnload(SEC_OMX_COMPONENT *sec_component);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.c b/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.c
new file mode 100644
index 0000000..fe84d8d
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.c
@@ -0,0 +1,354 @@
+/*
+ *
+ * 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_Core.c
+ * @brief      SEC OpenMAX IL Core
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ *             HyeYeon Chung (hyeon.chung@samsung.com)
+ *             Yunji Kim (yunji.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OMX_Core.h"
+#include "SEC_OMX_Component_Register.h"
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OMX_Resourcemanager.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_OMX_CORE"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+static int gInitialized = 0;
+static int gComponentNum = 0;
+
+static SEC_OMX_COMPONENT_REGLIST *gComponentList = NULL;
+static SEC_OMX_COMPONENT *gLoadComponentList = NULL;
+static OMX_HANDLETYPE ghLoadComponentListMutex = NULL;
+
+
+OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_Init(void)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+
+    if (gInitialized == 0) {
+        if (SEC_OMX_Component_Register(&gComponentList, &gComponentNum)) {
+            ret = OMX_ErrorInsufficientResources;
+            SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_Init : %s", "OMX_ErrorInsufficientResources");
+            goto EXIT;
+        }
+
+        SEC_OMX_ResourceManager_Init();
+
+        SEC_OSAL_MutexCreate(&ghLoadComponentListMutex);
+
+        gInitialized = 1;
+        SEC_OSAL_Log(SEC_LOG_TRACE, "SEC_OMX_Init : %s", "OMX_ErrorNone");
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_Deinit(void)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+
+    SEC_OSAL_MutexTerminate(ghLoadComponentListMutex);
+    ghLoadComponentListMutex = NULL;
+
+    SEC_OMX_ResourceManager_Deinit();
+
+    if (OMX_ErrorNone != SEC_OMX_Component_Unregister(gComponentList)) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+    gComponentList = NULL;
+    gComponentNum = 0;
+    gInitialized = 0;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_ComponentNameEnum(
+    OMX_OUT OMX_STRING cComponentName,
+    OMX_IN  OMX_U32 nNameLength,
+    OMX_IN  OMX_U32 nIndex)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+
+    if (nIndex >= gComponentNum) {
+        ret = OMX_ErrorNoMore;
+        goto EXIT;
+    }
+
+    sprintf(cComponentName, "%s", gComponentList[nIndex].component.componentName);
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_GetHandle(
+    OMX_OUT OMX_HANDLETYPE *pHandle,
+    OMX_IN  OMX_STRING cComponentName,
+    OMX_IN  OMX_PTR pAppData,
+    OMX_IN  OMX_CALLBACKTYPE *pCallBacks)
+{
+    OMX_ERRORTYPE      ret = OMX_ErrorNone;
+    SEC_OMX_COMPONENT *loadComponent;
+    SEC_OMX_COMPONENT *currentComponent;
+    int i = 0;
+
+    FunctionIn();
+
+    if (gInitialized != 1) {
+        ret = OMX_ErrorNotReady;
+        goto EXIT;
+    }
+
+    if ((pHandle == NULL) || (cComponentName == NULL) || (pCallBacks == NULL)) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    SEC_OSAL_Log(SEC_LOG_TRACE, "ComponentName : %s", cComponentName);
+
+    for (i = 0; i < gComponentNum; i++) {
+        if (SEC_OSAL_Strcmp(cComponentName, gComponentList[i].component.componentName) == 0) {
+            loadComponent = SEC_OSAL_Malloc(sizeof(SEC_OMX_COMPONENT));
+            SEC_OSAL_Memset(loadComponent, 0, sizeof(SEC_OMX_COMPONENT));
+
+            SEC_OSAL_Strcpy(loadComponent->libName, gComponentList[i].libName);
+            SEC_OSAL_Strcpy(loadComponent->componentName, gComponentList[i].component.componentName);
+            ret = SEC_OMX_ComponentLoad(loadComponent);
+            if (ret != OMX_ErrorNone) {
+                SEC_OSAL_Free(loadComponent);
+                SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+                goto EXIT;
+            }
+
+            ret = loadComponent->pOMXComponent->SetCallbacks(loadComponent->pOMXComponent, pCallBacks, pAppData);
+            if (ret != OMX_ErrorNone) {
+                SEC_OMX_ComponentUnload(loadComponent);
+                SEC_OSAL_Free(loadComponent);
+                SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
+                goto EXIT;
+            }
+
+            SEC_OSAL_MutexLock(ghLoadComponentListMutex);
+            if (gLoadComponentList == NULL) {
+                gLoadComponentList = loadComponent;
+            } else {
+                currentComponent = gLoadComponentList;
+                while (currentComponent->nextOMXComp != NULL) {
+                    currentComponent = currentComponent->nextOMXComp;
+                }
+                currentComponent->nextOMXComp = loadComponent;
+            }
+            SEC_OSAL_MutexUnlock(ghLoadComponentListMutex);
+
+            *pHandle = loadComponent->pOMXComponent;
+            ret = OMX_ErrorNone;
+            SEC_OSAL_Log(SEC_LOG_TRACE, "SEC_OMX_GetHandle : %s", "OMX_ErrorNone");
+            goto EXIT;
+        }
+    }
+
+    ret = OMX_ErrorComponentNotFound;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_FreeHandle(OMX_IN OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE      ret = OMX_ErrorNone;
+    SEC_OMX_COMPONENT *currentComponent;
+    SEC_OMX_COMPONENT *deleteComponent;
+
+    FunctionIn();
+
+    if (gInitialized != 1) {
+        ret = OMX_ErrorNotReady;
+        goto EXIT;
+    }
+
+    if (!hComponent) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    SEC_OSAL_MutexLock(ghLoadComponentListMutex);
+    currentComponent = gLoadComponentList;
+    if (gLoadComponentList->pOMXComponent == hComponent) {
+        deleteComponent = gLoadComponentList;
+        gLoadComponentList = gLoadComponentList->nextOMXComp;
+    } else {
+        while ((currentComponent != NULL) && (((SEC_OMX_COMPONENT *)(currentComponent->nextOMXComp))->pOMXComponent != hComponent))
+            currentComponent = currentComponent->nextOMXComp;
+
+        if (((SEC_OMX_COMPONENT *)(currentComponent->nextOMXComp))->pOMXComponent == hComponent) {
+            deleteComponent = currentComponent->nextOMXComp;
+            currentComponent->nextOMXComp = deleteComponent->nextOMXComp;
+        } else if (currentComponent == NULL) {
+            ret = OMX_ErrorComponentNotFound;
+            SEC_OSAL_MutexUnlock(ghLoadComponentListMutex);
+            goto EXIT;
+        }
+    }
+    SEC_OSAL_MutexUnlock(ghLoadComponentListMutex);
+
+    SEC_OMX_ComponentUnload(deleteComponent);
+    SEC_OSAL_Free(deleteComponent);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_SetupTunnel(
+    OMX_IN OMX_HANDLETYPE hOutput,
+    OMX_IN OMX_U32 nPortOutput,
+    OMX_IN OMX_HANDLETYPE hInput,
+    OMX_IN OMX_U32 nPortInput)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNotImplemented;
+
+EXIT:
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE SEC_OMX_GetContentPipe(
+    OMX_OUT OMX_HANDLETYPE *hPipe,
+    OMX_IN  OMX_STRING szURI)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNotImplemented;
+
+EXIT:
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE SEC_OMX_GetComponentsOfRole (
+    OMX_IN    OMX_STRING role,
+    OMX_INOUT OMX_U32 *pNumComps,
+    OMX_INOUT OMX_U8  **compNames)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    int           max_role_num = 0;
+    OMX_STRING    RoleString[MAX_OMX_COMPONENT_ROLE_SIZE];
+    int i = 0, j = 0;
+
+    FunctionIn();
+
+    if (gInitialized != 1) {
+        ret = OMX_ErrorNotReady;
+        goto EXIT;
+    }
+
+    *pNumComps = 0;
+
+    for (i = 0; i < MAX_OMX_COMPONENT_NUM; i++) {
+        max_role_num = gComponentList[i].component.totalRoleNum;
+
+        for (j = 0; j < max_role_num; j++) {
+            if (SEC_OSAL_Strcmp(gComponentList[i].component.roles[j], role) == 0) {
+                if (compNames != NULL) {
+                    SEC_OSAL_Strcpy((OMX_STRING)compNames[*pNumComps], gComponentList[i].component.componentName);
+                }
+                *pNumComps = (*pNumComps + 1);
+            }
+        }
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE SEC_OMX_GetRolesOfComponent (
+    OMX_IN    OMX_STRING compName,
+    OMX_INOUT OMX_U32 *pNumRoles,
+    OMX_OUT   OMX_U8 **roles)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_BOOL      detectComp = OMX_FALSE;
+    int           compNum = 0, totalRoleNum = 0;
+    int i = 0;
+
+    FunctionIn();
+
+    if (gInitialized != 1) {
+        ret = OMX_ErrorNotReady;
+        goto EXIT;
+    }
+
+    for (i = 0; i < MAX_OMX_COMPONENT_NUM; i++) {
+        if (gComponentList != NULL) {
+            if (SEC_OSAL_Strcmp(gComponentList[i].component.componentName, compName) == 0) {
+                *pNumRoles = totalRoleNum = gComponentList[i].component.totalRoleNum;
+                compNum = i;
+                detectComp = OMX_TRUE;
+                break;
+            }
+        } else {
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+    }
+
+    if (detectComp == OMX_FALSE) {
+        *pNumRoles = 0;
+        ret = OMX_ErrorComponentNotFound;
+        goto EXIT;
+    }
+
+    if (roles != NULL) {
+        for (i = 0; i < totalRoleNum; i++) {
+            SEC_OSAL_Strcpy(roles[i], gComponentList[compNum].component.roles[i]);
+        }
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.h b/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.h
new file mode 100644
index 0000000..87f561c
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.h
@@ -0,0 +1,78 @@
+/*
+ *
+ * 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_Core.h
+ * @brief      SEC OpenMAX IL Core
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ *             HyeYeon Chung (hyeon.chung@samsung.com)
+ *             Yunji Kim (yunji.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_CORE
+#define SEC_OMX_CORE
+
+#include "SEC_OMX_Def.h"
+#include "OMX_Types.h"
+#include "OMX_Core.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_Init(void);
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_Deinit(void);
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_ComponentNameEnum(
+    OMX_OUT   OMX_STRING        cComponentName,
+    OMX_IN    OMX_U32           nNameLength,
+    OMX_IN    OMX_U32           nIndex);
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_GetHandle(
+    OMX_OUT   OMX_HANDLETYPE   *pHandle,
+    OMX_IN    OMX_STRING        cComponentName,
+    OMX_IN    OMX_PTR           pAppData,
+    OMX_IN    OMX_CALLBACKTYPE *pCallBacks);
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_FreeHandle(
+    OMX_IN    OMX_HANDLETYPE    hComponent);
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_SetupTunnel(
+    OMX_IN    OMX_HANDLETYPE    hOutput,
+    OMX_IN    OMX_U32           nPortOutput,
+    OMX_IN    OMX_HANDLETYPE    hInput,
+    OMX_IN    OMX_U32           nPortInput);
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE              SEC_OMX_GetContentPipe(
+    OMX_OUT   OMX_HANDLETYPE   *hPipe,
+    OMX_IN    OMX_STRING        szURI);
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE              SEC_OMX_GetComponentsOfRole(
+    OMX_IN    OMX_STRING        role,
+    OMX_INOUT OMX_U32          *pNumComps,
+    OMX_INOUT OMX_U8          **compNames);
+SEC_EXPORT_REF OMX_API OMX_ERRORTYPE              SEC_OMX_GetRolesOfComponent(
+    OMX_IN    OMX_STRING        compName,
+    OMX_INOUT OMX_U32          *pNumRoles,
+    OMX_OUT   OMX_U8          **roles);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/sec_mm/sec_omx/sec_omx_core/secomxregistry b/sec_mm/sec_omx/sec_omx_core/secomxregistry
new file mode 100644
index 0000000..9baeba2
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_core/secomxregistry
@@ -0,0 +1,4 @@
+libOMX.SEC.AVC.Decoder.so
+libOMX.SEC.M4V.Decoder.so
+libOMX.SEC.AVC.Encoder.so
+libOMX.SEC.M4V.Encoder.so
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Audio.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Audio.h
new file mode 100644
index 0000000..04f1a99
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Audio.h
@@ -0,0 +1,1311 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** @file OMX_Audio.h - OpenMax IL version 1.1.2
+ *  The structures needed by Audio components to exchange
+ *  parameters and configuration data with the componenmilts.
+ */
+
+#ifndef OMX_Audio_h
+#define OMX_Audio_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header must include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+
+#include <OMX_Core.h>
+
+/** @defgroup midi MIDI
+ * @ingroup audio
+ */
+ 
+/** @defgroup effects Audio effects
+ * @ingroup audio
+ */
+
+/** @defgroup audio OpenMAX IL Audio Domain
+ * Structures for OpenMAX IL Audio domain
+ * @{
+ */
+
+/** Enumeration used to define the possible audio codings.  
+ *  If "OMX_AUDIO_CodingUnused" is selected, the coding selection must 
+ *  be done in a vendor specific way.  Since this is for an audio 
+ *  processing element this enum is relevant.  However, for another 
+ *  type of component other enums would be in this area.
+ */
+typedef enum OMX_AUDIO_CODINGTYPE {
+    OMX_AUDIO_CodingUnused = 0,  /**< Placeholder value when coding is N/A  */
+    OMX_AUDIO_CodingAutoDetect,  /**< auto detection of audio format */
+    OMX_AUDIO_CodingPCM,         /**< Any variant of PCM coding */
+    OMX_AUDIO_CodingADPCM,       /**< Any variant of ADPCM encoded data */
+    OMX_AUDIO_CodingAMR,         /**< Any variant of AMR encoded data */
+    OMX_AUDIO_CodingGSMFR,       /**< Any variant of GSM fullrate (i.e. GSM610) */
+    OMX_AUDIO_CodingGSMEFR,      /**< Any variant of GSM Enhanced Fullrate encoded data*/
+    OMX_AUDIO_CodingGSMHR,       /**< Any variant of GSM Halfrate encoded data */
+    OMX_AUDIO_CodingPDCFR,       /**< Any variant of PDC Fullrate encoded data */
+    OMX_AUDIO_CodingPDCEFR,      /**< Any variant of PDC Enhanced Fullrate encoded data */
+    OMX_AUDIO_CodingPDCHR,       /**< Any variant of PDC Halfrate encoded data */
+    OMX_AUDIO_CodingTDMAFR,      /**< Any variant of TDMA Fullrate encoded data (TIA/EIA-136-420) */
+    OMX_AUDIO_CodingTDMAEFR,     /**< Any variant of TDMA Enhanced Fullrate encoded data (TIA/EIA-136-410) */
+    OMX_AUDIO_CodingQCELP8,      /**< Any variant of QCELP 8kbps encoded data */
+    OMX_AUDIO_CodingQCELP13,     /**< Any variant of QCELP 13kbps encoded data */
+    OMX_AUDIO_CodingEVRC,        /**< Any variant of EVRC encoded data */
+    OMX_AUDIO_CodingSMV,         /**< Any variant of SMV encoded data */
+    OMX_AUDIO_CodingG711,        /**< Any variant of G.711 encoded data */
+    OMX_AUDIO_CodingG723,        /**< Any variant of G.723 dot 1 encoded data */
+    OMX_AUDIO_CodingG726,        /**< Any variant of G.726 encoded data */
+    OMX_AUDIO_CodingG729,        /**< Any variant of G.729 encoded data */
+    OMX_AUDIO_CodingAAC,         /**< Any variant of AAC encoded data */
+    OMX_AUDIO_CodingMP3,         /**< Any variant of MP3 encoded data */
+    OMX_AUDIO_CodingSBC,         /**< Any variant of SBC encoded data */
+    OMX_AUDIO_CodingVORBIS,      /**< Any variant of VORBIS encoded data */
+    OMX_AUDIO_CodingWMA,         /**< Any variant of WMA encoded data */
+    OMX_AUDIO_CodingRA,          /**< Any variant of RA encoded data */
+    OMX_AUDIO_CodingMIDI,        /**< Any variant of MIDI encoded data */
+    OMX_AUDIO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_CodingMax = 0x7FFFFFFF
+} OMX_AUDIO_CODINGTYPE;
+
+
+/** The PortDefinition structure is used to define all of the parameters 
+ *  necessary for the compliant component to setup an input or an output audio 
+ *  path.  If additional information is needed to define the parameters of the
+ *  port (such as frequency), additional structures must be sent such as the
+ *  OMX_AUDIO_PARAM_PCMMODETYPE structure to supply the extra parameters for the port.
+ */
+typedef struct OMX_AUDIO_PORTDEFINITIONTYPE {
+    OMX_STRING cMIMEType;            /**< MIME type of data for the port */
+    OMX_NATIVE_DEVICETYPE pNativeRender; /** < platform specific reference
+                                               for an output device, 
+                                               otherwise this field is 0 */
+    OMX_BOOL bFlagErrorConcealment;  /**< Turns on error concealment if it is 
+                                          supported by the OMX component */
+    OMX_AUDIO_CODINGTYPE eEncoding;  /**< Type of data expected for this 
+                                          port (e.g. PCM, AMR, MP3, etc) */
+} OMX_AUDIO_PORTDEFINITIONTYPE;
+
+
+/**  Port format parameter.  This structure is used to enumerate
+  *  the various data input/output format supported by the port.
+  */
+typedef struct OMX_AUDIO_PARAM_PORTFORMATTYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_U32 nPortIndex;             /**< Indicates which port to set */
+    OMX_U32 nIndex;                 /**< Indicates the enumeration index for the format from 0x0 to N-1 */
+    OMX_AUDIO_CODINGTYPE eEncoding; /**< Type of data expected for this port (e.g. PCM, AMR, MP3, etc) */
+} OMX_AUDIO_PARAM_PORTFORMATTYPE;
+
+
+/** PCM mode type  */ 
+typedef enum OMX_AUDIO_PCMMODETYPE { 
+    OMX_AUDIO_PCMModeLinear = 0,  /**< Linear PCM encoded data */ 
+    OMX_AUDIO_PCMModeALaw,        /**< A law PCM encoded data (G.711) */ 
+    OMX_AUDIO_PCMModeMULaw,       /**< Mu law PCM encoded data (G.711)  */ 
+    OMX_AUDIO_PCMModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_PCMModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_PCMModeMax = 0x7FFFFFFF 
+} OMX_AUDIO_PCMMODETYPE; 
+
+
+typedef enum OMX_AUDIO_CHANNELTYPE {
+    OMX_AUDIO_ChannelNone = 0x0,    /**< Unused or empty */
+    OMX_AUDIO_ChannelLF   = 0x1,    /**< Left front */
+    OMX_AUDIO_ChannelRF   = 0x2,    /**< Right front */
+    OMX_AUDIO_ChannelCF   = 0x3,    /**< Center front */
+    OMX_AUDIO_ChannelLS   = 0x4,    /**< Left surround */
+    OMX_AUDIO_ChannelRS   = 0x5,    /**< Right surround */
+    OMX_AUDIO_ChannelLFE  = 0x6,    /**< Low frequency effects */
+    OMX_AUDIO_ChannelCS   = 0x7,    /**< Back surround */
+    OMX_AUDIO_ChannelLR   = 0x8,    /**< Left rear. */
+    OMX_AUDIO_ChannelRR   = 0x9,    /**< Right rear. */
+    OMX_AUDIO_ChannelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_ChannelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_ChannelMax  = 0x7FFFFFFF 
+} OMX_AUDIO_CHANNELTYPE;
+
+#define OMX_AUDIO_MAXCHANNELS 16  /**< maximum number distinct audio channels that a buffer may contain */
+#define OMX_MIN_PCMPAYLOAD_MSEC 5 /**< Minimum audio buffer payload size for uncompressed (PCM) audio */
+
+/** PCM format description */ 
+typedef struct OMX_AUDIO_PARAM_PCMMODETYPE { 
+    OMX_U32 nSize;                    /**< Size of this structure, in Bytes */ 
+    OMX_VERSIONTYPE nVersion;         /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;               /**< port that this structure applies to */ 
+    OMX_U32 nChannels;                /**< Number of channels (e.g. 2 for stereo) */ 
+    OMX_NUMERICALDATATYPE eNumData;   /**< indicates PCM data as signed or unsigned */ 
+    OMX_ENDIANTYPE eEndian;           /**< indicates PCM data as little or big endian */ 
+    OMX_BOOL bInterleaved;            /**< True for normal interleaved data; false for 
+                                           non-interleaved data (e.g. block data) */ 
+    OMX_U32 nBitPerSample;            /**< Bit per sample */ 
+    OMX_U32 nSamplingRate;            /**< Sampling rate of the source data.  Use 0 for 
+                                           variable or unknown sampling rate. */ 
+    OMX_AUDIO_PCMMODETYPE ePCMMode;   /**< PCM mode enumeration */ 
+    OMX_AUDIO_CHANNELTYPE eChannelMapping[OMX_AUDIO_MAXCHANNELS]; /**< Slot i contains channel defined by eChannelMap[i] */
+
+} OMX_AUDIO_PARAM_PCMMODETYPE; 
+
+
+/** Audio channel mode.  This is used by both AAC and MP3, although the names are more appropriate
+ * for the MP3.  For example, JointStereo for MP3 is CouplingChannels for AAC. 
+ */
+typedef enum OMX_AUDIO_CHANNELMODETYPE {
+    OMX_AUDIO_ChannelModeStereo = 0,  /**< 2 channels, the bitrate allocation between those 
+                                          two channels changes accordingly to each channel information */
+    OMX_AUDIO_ChannelModeJointStereo, /**< mode that takes advantage of what is common between 
+                                           2 channels for higher compression gain */
+    OMX_AUDIO_ChannelModeDual,        /**< 2 mono-channels, each channel is encoded with half 
+                                           the bitrate of the overall bitrate */
+    OMX_AUDIO_ChannelModeMono,        /**< Mono channel mode */
+    OMX_AUDIO_ChannelModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_ChannelModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_ChannelModeMax = 0x7FFFFFFF
+} OMX_AUDIO_CHANNELMODETYPE;
+
+
+typedef enum OMX_AUDIO_MP3STREAMFORMATTYPE {
+    OMX_AUDIO_MP3StreamFormatMP1Layer3 = 0, /**< MP3 Audio MPEG 1 Layer 3 Stream format */
+    OMX_AUDIO_MP3StreamFormatMP2Layer3,     /**< MP3 Audio MPEG 2 Layer 3 Stream format */
+    OMX_AUDIO_MP3StreamFormatMP2_5Layer3,   /**< MP3 Audio MPEG2.5 Layer 3 Stream format */
+    OMX_AUDIO_MP3StreamFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_MP3StreamFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_MP3StreamFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_MP3STREAMFORMATTYPE;
+
+/** MP3 params */
+typedef struct OMX_AUDIO_PARAM_MP3TYPE {
+    OMX_U32 nSize;                 /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
+    OMX_U32 nPortIndex;            /**< port that this structure applies to */
+    OMX_U32 nChannels;             /**< Number of channels */
+    OMX_U32 nBitRate;              /**< Bit rate of the input data.  Use 0 for variable
+                                        rate or unknown bit rates */
+    OMX_U32 nSampleRate;           /**< Sampling rate of the source data.  Use 0 for
+                                        variable or unknown sampling rate. */
+    OMX_U32 nAudioBandWidth;       /**< Audio band width (in Hz) to which an encoder should
+                                        limit the audio signal. Use 0 to let encoder decide */
+    OMX_AUDIO_CHANNELMODETYPE eChannelMode;   /**< Channel mode enumeration */
+    OMX_AUDIO_MP3STREAMFORMATTYPE eFormat;  /**< MP3 stream format */
+} OMX_AUDIO_PARAM_MP3TYPE;
+
+
+typedef enum OMX_AUDIO_AACSTREAMFORMATTYPE {
+    OMX_AUDIO_AACStreamFormatMP2ADTS = 0, /**< AAC Audio Data Transport Stream 2 format */
+    OMX_AUDIO_AACStreamFormatMP4ADTS,     /**< AAC Audio Data Transport Stream 4 format */
+    OMX_AUDIO_AACStreamFormatMP4LOAS,     /**< AAC Low Overhead Audio Stream format */
+    OMX_AUDIO_AACStreamFormatMP4LATM,     /**< AAC Low overhead Audio Transport Multiplex */
+    OMX_AUDIO_AACStreamFormatADIF,        /**< AAC Audio Data Interchange Format */
+    OMX_AUDIO_AACStreamFormatMP4FF,       /**< AAC inside MPEG-4/ISO File Format */
+    OMX_AUDIO_AACStreamFormatRAW,         /**< AAC Raw Format */
+    OMX_AUDIO_AACStreamFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_AACStreamFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_AACStreamFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_AACSTREAMFORMATTYPE;
+
+
+/** AAC mode type.  Note that the term profile is used with the MPEG-2
+ * standard and the term object type and profile is used with MPEG-4 */
+typedef enum OMX_AUDIO_AACPROFILETYPE{
+  OMX_AUDIO_AACObjectNull = 0,      /**< Null, not used */
+  OMX_AUDIO_AACObjectMain = 1,      /**< AAC Main object */
+  OMX_AUDIO_AACObjectLC,            /**< AAC Low Complexity object (AAC profile) */
+  OMX_AUDIO_AACObjectSSR,           /**< AAC Scalable Sample Rate object */
+  OMX_AUDIO_AACObjectLTP,           /**< AAC Long Term Prediction object */
+  OMX_AUDIO_AACObjectHE,            /**< AAC High Efficiency (object type SBR, HE-AAC profile) */
+  OMX_AUDIO_AACObjectScalable,      /**< AAC Scalable object */
+  OMX_AUDIO_AACObjectERLC = 17,     /**< ER AAC Low Complexity object (Error Resilient AAC-LC) */
+  OMX_AUDIO_AACObjectLD = 23,       /**< AAC Low Delay object (Error Resilient) */
+  OMX_AUDIO_AACObjectHE_PS = 29,    /**< AAC High Efficiency with Parametric Stereo coding (HE-AAC v2, object type PS) */
+  OMX_AUDIO_AACObjectKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_AACObjectVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_AACObjectMax = 0x7FFFFFFF
+} OMX_AUDIO_AACPROFILETYPE;
+
+
+/** AAC tool usage (for nAACtools in OMX_AUDIO_PARAM_AACPROFILETYPE).
+ * Required for encoder configuration and optional as decoder info output.
+ * For MP3, OMX_AUDIO_CHANNELMODETYPE is sufficient. */
+#define OMX_AUDIO_AACToolNone 0x00000000 /**< no AAC tools allowed (encoder config) or active (decoder info output) */
+#define OMX_AUDIO_AACToolMS   0x00000001 /**< MS: Mid/side joint coding tool allowed or active */
+#define OMX_AUDIO_AACToolIS   0x00000002 /**< IS: Intensity stereo tool allowed or active */
+#define OMX_AUDIO_AACToolTNS  0x00000004 /**< TNS: Temporal Noise Shaping tool allowed or active */
+#define OMX_AUDIO_AACToolPNS  0x00000008 /**< PNS: MPEG-4 Perceptual Noise substitution tool allowed or active */
+#define OMX_AUDIO_AACToolLTP  0x00000010 /**< LTP: MPEG-4 Long Term Prediction tool allowed or active */
+#define OMX_AUDIO_AACToolAll  0x7FFFFFFF /**< all AAC tools allowed or active (*/
+
+/** MPEG-4 AAC error resilience (ER) tool usage (for nAACERtools in OMX_AUDIO_PARAM_AACPROFILETYPE).
+ * Required for ER encoder configuration and optional as decoder info output */
+#define OMX_AUDIO_AACERNone  0x00000000  /**< no AAC ER tools allowed/used */
+#define OMX_AUDIO_AACERVCB11 0x00000001  /**< VCB11: Virtual Code Books for AAC section data */
+#define OMX_AUDIO_AACERRVLC  0x00000002  /**< RVLC: Reversible Variable Length Coding */
+#define OMX_AUDIO_AACERHCR   0x00000004  /**< HCR: Huffman Codeword Reordering */
+#define OMX_AUDIO_AACERAll   0x7FFFFFFF  /**< all AAC ER tools allowed/used */
+
+
+/** AAC params */
+typedef struct OMX_AUDIO_PARAM_AACPROFILETYPE {
+    OMX_U32 nSize;                 /**< Size of this structure, in Bytes */
+    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
+    OMX_U32 nPortIndex;            /**< Port that this structure applies to */
+    OMX_U32 nChannels;             /**< Number of channels */
+    OMX_U32 nSampleRate;           /**< Sampling rate of the source data.  Use 0 for
+                                        variable or unknown sampling rate. */
+    OMX_U32 nBitRate;              /**< Bit rate of the input data.  Use 0 for variable
+                                        rate or unknown bit rates */
+    OMX_U32 nAudioBandWidth;       /**< Audio band width (in Hz) to which an encoder should
+                                        limit the audio signal. Use 0 to let encoder decide */
+    OMX_U32 nFrameLength;          /**< Frame length (in audio samples per channel) of the codec.
+                                        Can be 1024 or 960 (AAC-LC), 2048 (HE-AAC), 480 or 512 (AAC-LD).
+                                        Use 0 to let encoder decide */
+    OMX_U32 nAACtools;             /**< AAC tool usage */
+    OMX_U32 nAACERtools;           /**< MPEG-4 AAC error resilience tool usage */
+    OMX_AUDIO_AACPROFILETYPE eAACProfile;   /**< AAC profile enumeration */
+    OMX_AUDIO_AACSTREAMFORMATTYPE eAACStreamFormat; /**< AAC stream format enumeration */
+    OMX_AUDIO_CHANNELMODETYPE eChannelMode;   /**< Channel mode enumeration */
+} OMX_AUDIO_PARAM_AACPROFILETYPE;
+
+
+/** VORBIS params */
+typedef struct OMX_AUDIO_PARAM_VORBISTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_U32 nChannels;        /**< Number of channels */
+    OMX_U32 nBitRate;         /**< Bit rate of the encoded data data.  Use 0 for variable
+                                   rate or unknown bit rates. Encoding is set to the
+                                   bitrate closest to specified  value (in bps) */
+    OMX_U32 nMinBitRate;      /**< Sets minimum bitrate (in bps). */
+    OMX_U32 nMaxBitRate;      /**< Sets maximum bitrate (in bps). */
+
+    OMX_U32 nSampleRate;      /**< Sampling rate of the source data.  Use 0 for
+                                   variable or unknown sampling rate. */
+    OMX_U32 nAudioBandWidth;  /**< Audio band width (in Hz) to which an encoder should
+                                   limit the audio signal. Use 0 to let encoder decide */
+    OMX_S32 nQuality;		  /**< Sets encoding quality to n, between -1 (low) and 10 (high).
+                                   In the default mode of operation, teh quality level is 3.
+                                   Normal quality range is 0 - 10. */
+    OMX_BOOL bManaged;		  /**< Set  bitrate  management  mode. This turns off the
+                                   normal VBR encoding, but allows hard or soft bitrate
+                                   constraints to be enforced by the encoder. This mode can
+                                   be slower, and may also be lower quality. It is
+                                   primarily useful for streaming. */
+    OMX_BOOL bDownmix;		  /**< Downmix input from stereo to mono (has no effect on 
+                                   non-stereo streams). Useful for lower-bitrate encoding. */     
+} OMX_AUDIO_PARAM_VORBISTYPE;
+
+
+/** WMA Version */
+typedef enum OMX_AUDIO_WMAFORMATTYPE {
+  OMX_AUDIO_WMAFormatUnused = 0, /**< format unused or unknown */
+  OMX_AUDIO_WMAFormat7,          /**< Windows Media Audio format 7 */
+  OMX_AUDIO_WMAFormat8,          /**< Windows Media Audio format 8 */
+  OMX_AUDIO_WMAFormat9,          /**< Windows Media Audio format 9 */
+  OMX_AUDIO_WMAFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_WMAFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_WMAFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_WMAFORMATTYPE;
+
+
+/** WMA Profile */
+typedef enum OMX_AUDIO_WMAPROFILETYPE {
+  OMX_AUDIO_WMAProfileUnused = 0,  /**< profile unused or unknown */
+  OMX_AUDIO_WMAProfileL1,          /**< Windows Media audio version 9 profile L1 */
+  OMX_AUDIO_WMAProfileL2,          /**< Windows Media audio version 9 profile L2 */
+  OMX_AUDIO_WMAProfileL3,          /**< Windows Media audio version 9 profile L3 */
+  OMX_AUDIO_WMAProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_WMAProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_WMAProfileMax = 0x7FFFFFFF
+} OMX_AUDIO_WMAPROFILETYPE;
+
+
+/** WMA params */
+typedef struct OMX_AUDIO_PARAM_WMATYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_U16 nChannels;        /**< Number of channels */
+    OMX_U32 nBitRate;         /**< Bit rate of the input data.  Use 0 for variable
+                                   rate or unknown bit rates */
+    OMX_AUDIO_WMAFORMATTYPE eFormat; /**< Version of WMA stream / data */
+	OMX_AUDIO_WMAPROFILETYPE eProfile;  /**< Profile of WMA stream / data */
+    OMX_U32 nSamplingRate;    /**< Sampling rate of the source data */
+    OMX_U16 nBlockAlign;      /**< is the block alignment, or block size, in bytes of the audio codec */
+    OMX_U16 nEncodeOptions;   /**< WMA Type-specific data */
+    OMX_U32 nSuperBlockAlign; /**< WMA Type-specific data */
+} OMX_AUDIO_PARAM_WMATYPE;
+
+/** 
+ * RealAudio format
+ */
+typedef enum OMX_AUDIO_RAFORMATTYPE {
+    OMX_AUDIO_RAFormatUnused = 0, /**< Format unused or unknown */
+    OMX_AUDIO_RA8,                /**< RealAudio 8 codec */
+    OMX_AUDIO_RA9,                /**< RealAudio 9 codec */
+    OMX_AUDIO_RA10_AAC,           /**< MPEG-4 AAC codec for bitrates of more than 128kbps */
+    OMX_AUDIO_RA10_CODEC,         /**< RealAudio codec for bitrates less than 128 kbps */
+    OMX_AUDIO_RA10_LOSSLESS,      /**< RealAudio Lossless */
+    OMX_AUDIO_RA10_MULTICHANNEL,  /**< RealAudio Multichannel */
+    OMX_AUDIO_RA10_VOICE,         /**< RealAudio Voice for bitrates below 15 kbps */
+    OMX_AUDIO_RAFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_RAFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_RAFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_RAFORMATTYPE;
+
+/** RA (Real Audio) params */ 
+typedef struct OMX_AUDIO_PARAM_RATYPE { 
+    OMX_U32 nSize;              /**< Size of this structure, in Bytes */ 
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;         /**< Port that this structure applies to */ 
+    OMX_U32 nChannels;          /**< Number of channels */ 
+    OMX_U32 nSamplingRate;      /**< is the sampling rate of the source data */ 
+    OMX_U32 nBitsPerFrame;      /**< is the value for bits per frame  */ 
+    OMX_U32 nSamplePerFrame;    /**< is the value for samples per frame */ 
+    OMX_U32 nCouplingQuantBits; /**< is the number of coupling quantization bits in the stream */ 
+    OMX_U32 nCouplingStartRegion;   /**< is the coupling start region in the stream  */ 
+    OMX_U32 nNumRegions;        /**< is the number of regions value */ 
+    OMX_AUDIO_RAFORMATTYPE eFormat; /**< is the RealAudio audio format */
+} OMX_AUDIO_PARAM_RATYPE; 
+
+
+/** SBC Allocation Method Type */
+typedef enum OMX_AUDIO_SBCALLOCMETHODTYPE {
+  OMX_AUDIO_SBCAllocMethodLoudness, /**< Loudness allocation method */
+  OMX_AUDIO_SBCAllocMethodSNR,      /**< SNR allocation method */
+  OMX_AUDIO_SBCAllocMethodKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_SBCAllocMethodVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_SBCAllocMethodMax = 0x7FFFFFFF
+} OMX_AUDIO_SBCALLOCMETHODTYPE;
+
+
+/** SBC params */
+typedef struct OMX_AUDIO_PARAM_SBCTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_U32 nChannels;         /**< Number of channels */
+    OMX_U32 nBitRate;          /**< Bit rate of the input data.  Use 0 for variable
+                                    rate or unknown bit rates */
+    OMX_U32 nSampleRate;       /**< Sampling rate of the source data.  Use 0 for
+                                    variable or unknown sampling rate. */
+    OMX_U32 nBlocks;           /**< Number of blocks */
+    OMX_U32 nSubbands;         /**< Number of subbands */
+    OMX_U32 nBitPool;          /**< Bitpool value */
+    OMX_BOOL bEnableBitrate;   /**< Use bitrate value instead of bitpool */
+    OMX_AUDIO_CHANNELMODETYPE eChannelMode; /**< Channel mode enumeration */
+    OMX_AUDIO_SBCALLOCMETHODTYPE eSBCAllocType;   /**< SBC Allocation method type */
+} OMX_AUDIO_PARAM_SBCTYPE;
+
+
+/** ADPCM stream format parameters */ 
+typedef struct OMX_AUDIO_PARAM_ADPCMTYPE { 
+    OMX_U32 nSize;              /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */ 
+    OMX_U32 nChannels;          /**< Number of channels in the data stream (not 
+                                     necessarily the same as the number of channels 
+                                     to be rendered. */ 
+    OMX_U32 nBitsPerSample;     /**< Number of bits in each sample */ 
+    OMX_U32 nSampleRate;        /**< Sampling rate of the source data.  Use 0 for 
+                                    variable or unknown sampling rate. */ 
+} OMX_AUDIO_PARAM_ADPCMTYPE; 
+
+
+/** G723 rate */
+typedef enum OMX_AUDIO_G723RATE {
+    OMX_AUDIO_G723ModeUnused = 0,  /**< AMRNB Mode unused / unknown */
+    OMX_AUDIO_G723ModeLow,         /**< 5300 bps */
+    OMX_AUDIO_G723ModeHigh,        /**< 6300 bps */
+    OMX_AUDIO_G723ModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_G723ModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_G723ModeMax = 0x7FFFFFFF
+} OMX_AUDIO_G723RATE;
+
+
+/** G723 - Sample rate must be 8 KHz */
+typedef struct OMX_AUDIO_PARAM_G723TYPE { 
+    OMX_U32 nSize;                /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */ 
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not 
+                                       necessarily the same as the number of channels 
+                                       to be rendered. */ 
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */ 
+    OMX_AUDIO_G723RATE eBitRate;  /**< todo: Should this be moved to a config? */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */ 
+    OMX_BOOL bPostFilter;         /**< Enable Post Filter */ 
+} OMX_AUDIO_PARAM_G723TYPE; 
+
+
+/** ITU G726 (ADPCM) rate */
+typedef enum OMX_AUDIO_G726MODE {
+    OMX_AUDIO_G726ModeUnused = 0,  /**< G726 Mode unused / unknown */
+    OMX_AUDIO_G726Mode16,          /**< 16 kbps */
+    OMX_AUDIO_G726Mode24,          /**< 24 kbps */
+    OMX_AUDIO_G726Mode32,          /**< 32 kbps, most common rate, also G721 */
+    OMX_AUDIO_G726Mode40,          /**< 40 kbps */
+    OMX_AUDIO_G726ModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_G726ModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_G726ModeMax = 0x7FFFFFFF
+} OMX_AUDIO_G726MODE;
+
+
+/** G.726 stream format parameters - must be at 8KHz */ 
+typedef struct OMX_AUDIO_PARAM_G726TYPE { 
+    OMX_U32 nSize;              /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */ 
+    OMX_U32 nChannels;          /**< Number of channels in the data stream (not 
+                                     necessarily the same as the number of channels 
+                                     to be rendered. */ 
+     OMX_AUDIO_G726MODE eG726Mode;
+} OMX_AUDIO_PARAM_G726TYPE; 
+
+
+/** G729 coder type */
+typedef enum OMX_AUDIO_G729TYPE {
+    OMX_AUDIO_G729 = 0,           /**< ITU G.729  encoded data */
+    OMX_AUDIO_G729A,              /**< ITU G.729 annex A  encoded data */
+    OMX_AUDIO_G729B,              /**< ITU G.729 with annex B encoded data */
+    OMX_AUDIO_G729AB,             /**< ITU G.729 annexes A and B encoded data */
+    OMX_AUDIO_G729KhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_G729VendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_G729Max = 0x7FFFFFFF
+} OMX_AUDIO_G729TYPE;
+
+
+/** G729 stream format parameters - fixed 6KHz sample rate */
+typedef struct OMX_AUDIO_PARAM_G729TYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_U32 nChannels;        /**< Number of channels in the data stream (not
+                                   necessarily the same as the number of channels
+                                   to be rendered. */
+    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
+    OMX_AUDIO_G729TYPE eBitType;
+} OMX_AUDIO_PARAM_G729TYPE;
+
+
+/** AMR Frame format */ 
+typedef enum OMX_AUDIO_AMRFRAMEFORMATTYPE { 
+    OMX_AUDIO_AMRFrameFormatConformance = 0,  /**< Frame Format is AMR Conformance 
+                                                   (Standard) Format */ 
+    OMX_AUDIO_AMRFrameFormatIF1,              /**< Frame Format is AMR Interface 
+                                                   Format 1 */ 
+    OMX_AUDIO_AMRFrameFormatIF2,              /**< Frame Format is AMR Interface 
+                                                   Format 2*/ 
+    OMX_AUDIO_AMRFrameFormatFSF,              /**< Frame Format is AMR File Storage 
+                                                   Format */ 
+    OMX_AUDIO_AMRFrameFormatRTPPayload,       /**< Frame Format is AMR Real-Time 
+                                                   Transport Protocol Payload Format */ 
+    OMX_AUDIO_AMRFrameFormatITU,              /**< Frame Format is ITU Format (added at Motorola request) */ 
+    OMX_AUDIO_AMRFrameFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_AMRFrameFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_AMRFrameFormatMax = 0x7FFFFFFF 
+} OMX_AUDIO_AMRFRAMEFORMATTYPE; 
+
+
+/** AMR band mode */
+typedef enum OMX_AUDIO_AMRBANDMODETYPE {
+    OMX_AUDIO_AMRBandModeUnused = 0,          /**< AMRNB Mode unused / unknown */
+    OMX_AUDIO_AMRBandModeNB0,                 /**< AMRNB Mode 0 =  4750 bps */
+    OMX_AUDIO_AMRBandModeNB1,                 /**< AMRNB Mode 1 =  5150 bps */
+    OMX_AUDIO_AMRBandModeNB2,                 /**< AMRNB Mode 2 =  5900 bps */ 
+    OMX_AUDIO_AMRBandModeNB3,                 /**< AMRNB Mode 3 =  6700 bps */
+    OMX_AUDIO_AMRBandModeNB4,                 /**< AMRNB Mode 4 =  7400 bps */
+    OMX_AUDIO_AMRBandModeNB5,                 /**< AMRNB Mode 5 =  7950 bps */
+    OMX_AUDIO_AMRBandModeNB6,                 /**< AMRNB Mode 6 = 10200 bps */
+    OMX_AUDIO_AMRBandModeNB7,                 /**< AMRNB Mode 7 = 12200 bps */
+    OMX_AUDIO_AMRBandModeWB0,                 /**< AMRWB Mode 0 =  6600 bps */
+    OMX_AUDIO_AMRBandModeWB1,                 /**< AMRWB Mode 1 =  8850 bps */
+    OMX_AUDIO_AMRBandModeWB2,                 /**< AMRWB Mode 2 = 12650 bps */ 
+    OMX_AUDIO_AMRBandModeWB3,                 /**< AMRWB Mode 3 = 14250 bps */ 
+    OMX_AUDIO_AMRBandModeWB4,                 /**< AMRWB Mode 4 = 15850 bps */
+    OMX_AUDIO_AMRBandModeWB5,                 /**< AMRWB Mode 5 = 18250 bps */
+    OMX_AUDIO_AMRBandModeWB6,                 /**< AMRWB Mode 6 = 19850 bps */
+    OMX_AUDIO_AMRBandModeWB7,                 /**< AMRWB Mode 7 = 23050 bps */
+    OMX_AUDIO_AMRBandModeWB8,                 /**< AMRWB Mode 8 = 23850 bps */      
+    OMX_AUDIO_AMRBandModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_AMRBandModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_AMRBandModeMax = 0x7FFFFFFF
+} OMX_AUDIO_AMRBANDMODETYPE;
+     
+
+/** AMR Discontinuous Transmission mode */ 
+typedef enum OMX_AUDIO_AMRDTXMODETYPE { 
+    OMX_AUDIO_AMRDTXModeOff = 0,        /**< AMR Discontinuous Transmission Mode is disabled */ 
+    OMX_AUDIO_AMRDTXModeOnVAD1,         /**< AMR Discontinuous Transmission Mode using 
+                                             Voice Activity Detector 1 (VAD1) is enabled */ 
+    OMX_AUDIO_AMRDTXModeOnVAD2,         /**< AMR Discontinuous Transmission Mode using 
+                                             Voice Activity Detector 2 (VAD2) is enabled */       
+    OMX_AUDIO_AMRDTXModeOnAuto,         /**< The codec will automatically select between 
+                                             Off, VAD1 or VAD2 modes */ 
+
+    OMX_AUDIO_AMRDTXasEFR,             /**< DTX as EFR instead of AMR standard (3GPP 26.101, frame type =8,9,10) */
+
+    OMX_AUDIO_AMRDTXModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_AMRDTXModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_AMRDTXModeMax = 0x7FFFFFFF 
+} OMX_AUDIO_AMRDTXMODETYPE; 
+ 
+
+/** AMR params */
+typedef struct OMX_AUDIO_PARAM_AMRTYPE {
+    OMX_U32 nSize;                          /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;               /**< OMX specification version information */
+    OMX_U32 nPortIndex;                     /**< port that this structure applies to */
+    OMX_U32 nChannels;                      /**< Number of channels */
+    OMX_U32 nBitRate;                       /**< Bit rate read only field */
+    OMX_AUDIO_AMRBANDMODETYPE eAMRBandMode; /**< AMR Band Mode enumeration */ 
+    OMX_AUDIO_AMRDTXMODETYPE  eAMRDTXMode;  /**< AMR DTX Mode enumeration */
+    OMX_AUDIO_AMRFRAMEFORMATTYPE eAMRFrameFormat; /**< AMR frame format enumeration */
+} OMX_AUDIO_PARAM_AMRTYPE;
+
+
+/** GSM_FR (ETSI 06.10, 3GPP 46.010) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_GSMFRTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_GSMFRTYPE;
+
+
+/** GSM-HR (ETSI 06.20, 3GPP 46.020) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_GSMHRTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_GSMHRTYPE;
+
+
+/** GSM-EFR (ETSI 06.60, 3GPP 46.060) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_GSMEFRTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_GSMEFRTYPE;
+
+
+/** TDMA FR (TIA/EIA-136-420, VSELP 7.95kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_TDMAFRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_TDMAFRTYPE;
+
+
+/** TDMA EFR (TIA/EIA-136-410, ACELP 7.4kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_TDMAEFRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_TDMAEFRTYPE;
+
+
+/** PDC FR ( RCR-27, VSELP 6.7kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_PDCFRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_PDCFRTYPE;
+
+
+/** PDC EFR ( RCR-27, ACELP 6.7kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_PDCEFRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_PDCEFRTYPE;
+
+/** PDC HR ( RCR-27, PSI-CELP 3.45kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_PDCHRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_PDCHRTYPE;
+
+
+/** CDMA Rate types */
+typedef enum OMX_AUDIO_CDMARATETYPE {
+    OMX_AUDIO_CDMARateBlank = 0,          /**< CDMA encoded frame is blank */
+    OMX_AUDIO_CDMARateFull,               /**< CDMA encoded frame in full rate */
+    OMX_AUDIO_CDMARateHalf,               /**< CDMA encoded frame in half rate */
+    OMX_AUDIO_CDMARateQuarter,            /**< CDMA encoded frame in quarter rate */
+    OMX_AUDIO_CDMARateEighth,             /**< CDMA encoded frame in eighth rate (DTX)*/
+    OMX_AUDIO_CDMARateErasure,            /**< CDMA erasure frame */
+    OMX_AUDIO_CDMARateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_CDMARateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_CDMARateMax = 0x7FFFFFFF
+} OMX_AUDIO_CDMARATETYPE;
+
+
+/** QCELP8 (TIA/EIA-96, up to 8kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_QCELP8TYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_U32 nBitRate;             /**< Bit rate of the input data.  Use 0 for variable
+                                       rate or unknown bit rates */
+    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
+    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
+    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
+} OMX_AUDIO_PARAM_QCELP8TYPE;
+
+
+/** QCELP13 ( CDMA, EIA/TIA-733, 13.3kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_QCELP13TYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
+    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
+    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
+} OMX_AUDIO_PARAM_QCELP13TYPE;
+
+
+/** EVRC ( CDMA, EIA/TIA-127, RCELP up to 8.55kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_EVRCTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< actual Frame rate */
+    OMX_BOOL bRATE_REDUCon;       /**< RATE_REDUCtion is requested for this frame */
+    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
+    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
+    OMX_BOOL bHiPassFilter;       /**< Enable encoder's High Pass Filter */
+    OMX_BOOL bNoiseSuppressor;    /**< Enable encoder's noise suppressor pre-processing */
+    OMX_BOOL bPostFilter;         /**< Enable decoder's post Filter */
+} OMX_AUDIO_PARAM_EVRCTYPE;
+
+
+/** SMV ( up to 8.55kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_SMVTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
+    OMX_BOOL bRATE_REDUCon;           /**< RATE_REDUCtion is requested for this frame */
+    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 ??*/
+    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 ??*/
+    OMX_BOOL bHiPassFilter;       /**< Enable encoder's High Pass Filter ??*/
+    OMX_BOOL bNoiseSuppressor;    /**< Enable encoder's noise suppressor pre-processing */
+    OMX_BOOL bPostFilter;         /**< Enable decoder's post Filter ??*/
+} OMX_AUDIO_PARAM_SMVTYPE;
+
+
+/** MIDI Format 
+ * @ingroup midi
+ */
+typedef enum OMX_AUDIO_MIDIFORMATTYPE
+{
+    OMX_AUDIO_MIDIFormatUnknown = 0, /**< MIDI Format unknown or don't care */
+    OMX_AUDIO_MIDIFormatSMF0,        /**< Standard MIDI File Type 0 */
+    OMX_AUDIO_MIDIFormatSMF1,        /**< Standard MIDI File Type 1 */
+    OMX_AUDIO_MIDIFormatSMF2,        /**< Standard MIDI File Type 2 */
+    OMX_AUDIO_MIDIFormatSPMIDI,      /**< SP-MIDI */
+    OMX_AUDIO_MIDIFormatXMF0,        /**< eXtensible Music Format type 0 */
+    OMX_AUDIO_MIDIFormatXMF1,        /**< eXtensible Music Format type 1 */
+    OMX_AUDIO_MIDIFormatMobileXMF,   /**< Mobile XMF (eXtensible Music Format type 2) */
+    OMX_AUDIO_MIDIFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_MIDIFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_MIDIFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_MIDIFORMATTYPE;
+
+
+/** MIDI params 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_PARAM_MIDITYPE {
+    OMX_U32 nSize;                 /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
+    OMX_U32 nPortIndex;            /**< port that this structure applies to */
+    OMX_U32 nFileSize;             /**< size of the MIDI file in bytes, where the entire 
+                                        MIDI file passed in, otherwise if 0x0, the MIDI data 
+                                        is merged and streamed (instead of passed as an 
+                                        entire MIDI file) */
+    OMX_BU32 sMaxPolyphony;        /**< Specifies the maximum simultaneous polyphonic 
+                                        voices. A value of zero indicates that the default 
+                                        polyphony of the device is used  */                                    
+    OMX_BOOL bLoadDefaultSound;    /**< Whether to load default sound 
+                                        bank at initialization */
+    OMX_AUDIO_MIDIFORMATTYPE eMidiFormat; /**< Version of the MIDI file */                                                                           
+} OMX_AUDIO_PARAM_MIDITYPE;
+
+
+/** Type of the MIDI sound bank 
+ * @ingroup midi
+ */
+typedef enum OMX_AUDIO_MIDISOUNDBANKTYPE {
+    OMX_AUDIO_MIDISoundBankUnused = 0,           /**< unused/unknown soundbank type */
+    OMX_AUDIO_MIDISoundBankDLS1,                 /**< DLS version 1 */
+    OMX_AUDIO_MIDISoundBankDLS2,                 /**< DLS version 2 */
+    OMX_AUDIO_MIDISoundBankMobileDLSBase,        /**< Mobile DLS, using the base functionality */
+    OMX_AUDIO_MIDISoundBankMobileDLSPlusOptions, /**< Mobile DLS, using the specification-defined optional feature set */
+    OMX_AUDIO_MIDISoundBankKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_MIDISoundBankVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_MIDISoundBankMax = 0x7FFFFFFF
+} OMX_AUDIO_MIDISOUNDBANKTYPE;
+
+
+/** Bank Layout describes how bank MSB & LSB are used in the DLS instrument definitions sound bank 
+ * @ingroup midi
+ */
+typedef enum OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE {
+   OMX_AUDIO_MIDISoundBankLayoutUnused = 0,   /**< unused/unknown soundbank type */
+   OMX_AUDIO_MIDISoundBankLayoutGM,           /**< GS layout (based on bank MSB 0x00) */
+   OMX_AUDIO_MIDISoundBankLayoutGM2,          /**< General MIDI 2 layout (using MSB 0x78/0x79, LSB 0x00) */
+   OMX_AUDIO_MIDISoundBankLayoutUser,         /**< Does not conform to any bank numbering standards */
+   OMX_AUDIO_MIDISoundBankLayoutKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+   OMX_AUDIO_MIDISoundBankLayoutVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+   OMX_AUDIO_MIDISoundBankLayoutMax = 0x7FFFFFFF
+} OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE;
+
+
+/** MIDI params to load/unload user soundbank 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_U32 nDLSIndex;        /**< DLS file index to be loaded */
+    OMX_U32 nDLSSize;         /**< Size in bytes */
+    OMX_PTR pDLSData;         /**< Pointer to DLS file data */
+    OMX_AUDIO_MIDISOUNDBANKTYPE eMidiSoundBank;   /**< Midi sound bank type enumeration */
+    OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE eMidiSoundBankLayout; /**< Midi sound bank layout enumeration */
+} OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE;
+
+
+/** Structure for Live MIDI events and MIP messages. 
+ * (MIP = Maximum Instantaneous Polyphony; part of the SP-MIDI standard.) 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< Port that this structure applies to */
+    OMX_U32 nMidiEventSize;   /**< Size of immediate MIDI events or MIP message in bytes  */
+    OMX_U8 nMidiEvents[1];    /**< MIDI event array to be rendered immediately, or an
+                                   array for the MIP message buffer, where the size is 
+                                   indicated by nMidiEventSize */
+} OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE;
+
+
+/** MIDI sound bank/ program pair in a given channel 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port that this structure applies to */
+    OMX_U32 nChannel;           /**< Valid channel values range from 1 to 16 */
+    OMX_U16 nIDProgram;         /**< Valid program ID range is 1 to 128 */
+    OMX_U16 nIDSoundBank;       /**< Sound bank ID */
+    OMX_U32 nUserSoundBankIndex;/**< User soundbank index, easier to access soundbanks 
+                                     by index if multiple banks are present */
+} OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE;
+
+
+/** MIDI control 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDICONTROLTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_BS32 sPitchTransposition; /**< Pitch transposition in semitones, stored as Q22.10 
+                                       format based on JAVA MMAPI (JSR-135) requirement */
+    OMX_BU32 sPlayBackRate;       /**< Relative playback rate, stored as Q14.17 fixed-point
+                                       number based on JSR-135 requirement */
+    OMX_BU32 sTempo ;             /**< Tempo in beats per minute (BPM), stored as Q22.10 
+                                       fixed-point number based on JSR-135 requirement */
+    OMX_U32 nMaxPolyphony;        /**< Specifies the maximum simultaneous polyphonic 
+                                       voices. A value of zero indicates that the default 
+                                       polyphony of the device is used  */
+    OMX_U32 nNumRepeat;           /**< Number of times to repeat playback */
+    OMX_U32 nStopTime;            /**< Time in milliseconds to indicate when playback 
+                                       will stop automatically.  Set to zero if not used */
+    OMX_U16 nChannelMuteMask;     /**< 16 bit mask for channel mute status */
+    OMX_U16 nChannelSoloMask;     /**< 16 bit mask for channel solo status */
+    OMX_U32 nTrack0031MuteMask;   /**< 32 bit mask for track mute status. Note: This is for tracks 0-31 */
+    OMX_U32 nTrack3263MuteMask;   /**< 32 bit mask for track mute status. Note: This is for tracks 32-63 */
+    OMX_U32 nTrack0031SoloMask;   /**< 32 bit mask for track solo status. Note: This is for tracks 0-31 */
+    OMX_U32 nTrack3263SoloMask;   /**< 32 bit mask for track solo status. Note: This is for tracks 32-63 */
+
+} OMX_AUDIO_CONFIG_MIDICONTROLTYPE;
+
+
+/** MIDI Playback States 
+ * @ingroup midi
+ */
+typedef enum OMX_AUDIO_MIDIPLAYBACKSTATETYPE {
+  OMX_AUDIO_MIDIPlayBackStateUnknown = 0,      /**< Unknown state or state does not map to 
+  													other defined states */
+  OMX_AUDIO_MIDIPlayBackStateClosedEngaged,    /**< No MIDI resource is currently open. 
+                                                    The MIDI engine is currently processing 
+                                                    MIDI events. */
+  OMX_AUDIO_MIDIPlayBackStateParsing,          /**< A MIDI resource is open and is being 
+                                                    primed. The MIDI engine is currently 
+                                                    processing MIDI events. */
+  OMX_AUDIO_MIDIPlayBackStateOpenEngaged,      /**< A MIDI resource is open and primed but 
+                                                    not playing. The MIDI engine is currently
+                                                    processing MIDI events. The transition to
+                                                    this state is only possible from the 
+                                                    OMX_AUDIO_MIDIPlayBackStatePlaying state,
+                                                    when the 'playback head' reaches the end
+                                                    of media data or the playback stops due
+                                                    to stop time set.*/
+  OMX_AUDIO_MIDIPlayBackStatePlaying,          /**< A MIDI resource is open and currently
+                                                    playing. The MIDI engine is currently
+                                                    processing MIDI events.*/
+  OMX_AUDIO_MIDIPlayBackStatePlayingPartially, /**< Best-effort playback due to SP-MIDI/DLS
+                                                    resource constraints */
+  OMX_AUDIO_MIDIPlayBackStatePlayingSilently,  /**< Due to system resource constraints and
+                                                    SP-MIDI content constraints, there is
+                                                    no audible MIDI content during playback
+                                                    currently. The situation may change if
+                                                    resources are freed later.*/
+  OMX_AUDIO_MIDIPlayBackStateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_MIDIPlayBackStateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_MIDIPlayBackStateMax = 0x7FFFFFFF
+} OMX_AUDIO_MIDIPLAYBACKSTATETYPE;
+
+
+/** MIDI status 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDISTATUSTYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */
+    OMX_U16 nNumTracks;         /**< Number of MIDI tracks in the file, read only field. 
+                                     NOTE: May not return a meaningful value until the entire 
+                                     file is parsed and buffered.  */
+    OMX_U32 nDuration;          /**< The length of the currently open MIDI resource 
+                                     in milliseconds. NOTE: May not return a meaningful value 
+                                     until the entire file is parsed and buffered.  */  
+    OMX_U32 nPosition;          /**< Current Position of the MIDI resource being played 
+                                     in milliseconds */
+    OMX_BOOL bVibra;            /**< Does Vibra track exist? NOTE: May not return a meaningful 
+                                     value until the entire file is parsed and buffered. */
+    OMX_U32 nNumMetaEvents;     /**< Total number of MIDI Meta Events in the currently 
+                                     open MIDI resource. NOTE: May not return a meaningful value 
+                                     until the entire file is parsed and buffered.  */
+    OMX_U32 nNumActiveVoices;   /**< Number of active voices in the currently playing 
+                                     MIDI resource. NOTE: May not return a meaningful value until 
+                                     the entire file is parsed and buffered. */
+    OMX_AUDIO_MIDIPLAYBACKSTATETYPE eMIDIPlayBackState;  /**< MIDI playback state enumeration, read only field */
+} OMX_AUDIO_CONFIG_MIDISTATUSTYPE;
+
+
+/** MIDI Meta Event structure one per Meta Event.
+ *  MIDI Meta Events are like audio metadata, except that they are interspersed 
+ *  with the MIDI content throughout the file and are not localized in the header. 
+ *  As such, it is necessary to retrieve information about these Meta Events from 
+ *  the engine, as it encounters these Meta Events within the MIDI content. 
+ *  For example, SMF files can have up to 14 types of MIDI Meta Events (copyright, 
+ *  author, default tempo, etc.) scattered throughout the file. 
+ *  @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE{ 
+    OMX_U32 nSize;            /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */ 
+    OMX_U32 nIndex;           /**< Index of Meta Event */ 
+    OMX_U8 nMetaEventType;    /**< Meta Event Type, 7bits (i.e. 0 - 127) */ 
+    OMX_U32 nMetaEventSize;   /**< size of the Meta Event in bytes */ 
+    OMX_U32 nTrack;           /**< track number for the meta event */
+    OMX_U32 nPosition;        /**< Position of the meta-event in milliseconds */
+} OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE; 
+
+
+/** MIDI Meta Event Data structure - one per Meta Event. 
+ * @ingroup midi
+ */ 
+typedef struct OMX_AUDIO_CONFIG_MIDIMETAEVENTDATATYPE{ 
+    OMX_U32 nSize;            /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */ 
+    OMX_U32 nIndex;           /**< Index of Meta Event */ 
+    OMX_U32 nMetaEventSize;   /**< size of the Meta Event in bytes */ 
+    OMX_U8 nData[1];          /**< array of one or more bytes of meta data 
+                                   as indicated by the nMetaEventSize field */ 
+} OMX_AUDIO_CONFIG__MIDIMETAEVENTDATATYPE; 
+
+
+/** Audio Volume adjustment for a port */
+typedef struct OMX_AUDIO_CONFIG_VOLUMETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port index indicating which port to 
+                                     set.  Select the input port to set 
+                                     just that port's volume.  Select the 
+                                     output port to adjust the master 
+                                     volume. */
+    OMX_BOOL bLinear;           /**< Is the volume to be set in linear (0.100) 
+                                     or logarithmic scale (mB) */
+    OMX_BS32 sVolume;           /**< Volume linear setting in the 0..100 range, OR
+                                     Volume logarithmic setting for this port.  The values
+                                     for volume are in mB (millibels = 1/100 dB) relative
+                                     to a gain of 1 (e.g. the output is the same as the 
+                                     input level).  Values are in mB from nMax 
+                                     (maximum volume) to nMin mB (typically negative).
+                                     Since the volume is "voltage"
+                                     and not a "power", it takes a setting of
+                                     -600 mB to decrease the volume by 1/2.  If
+                                     a component cannot accurately set the 
+                                     volume to the requested value, it must
+                                     set the volume to the closest value BELOW
+                                     the requested value.  When getting the
+                                     volume setting, the current actual volume
+                                     must be returned. */
+} OMX_AUDIO_CONFIG_VOLUMETYPE;
+
+
+/** Audio Volume adjustment for a channel */
+typedef struct OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port index indicating which port to 
+                                     set.  Select the input port to set 
+                                     just that port's volume.  Select the 
+                                     output port to adjust the master 
+                                     volume. */
+    OMX_U32 nChannel;           /**< channel to select from 0 to N-1, 
+                                     using OMX_ALL to apply volume settings
+                                     to all channels */
+    OMX_BOOL bLinear;           /**< Is the volume to be set in linear (0.100) or 
+                                     logarithmic scale (mB) */
+    OMX_BS32 sVolume;           /**< Volume linear setting in the 0..100 range, OR
+                                     Volume logarithmic setting for this port.  
+                                     The values for volume are in mB 
+                                     (millibels = 1/100 dB) relative to a gain
+                                     of 1 (e.g. the output is the same as the 
+                                     input level).  Values are in mB from nMax 
+                                     (maximum volume) to nMin mB (typically negative).  
+                                     Since the volume is "voltage"
+                                     and not a "power", it takes a setting of
+                                     -600 mB to decrease the volume by 1/2.  If
+                                     a component cannot accurately set the 
+                                     volume to the requested value, it must
+                                     set the volume to the closest value BELOW
+                                     the requested value.  When getting the
+                                     volume setting, the current actual volume
+                                     must be returned. */
+    OMX_BOOL bIsMIDI;           /**< TRUE if nChannel refers to a MIDI channel,
+                                     FALSE otherwise */
+} OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE;
+
+
+/** Audio balance setting */
+typedef struct OMX_AUDIO_CONFIG_BALANCETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port index indicating which port to 
+                                     set.  Select the input port to set 
+                                     just that port's balance.  Select the 
+                                     output port to adjust the master 
+                                     balance. */
+    OMX_S32 nBalance;           /**< balance setting for this port 
+                                     (-100 to 100, where -100 indicates
+                                     all left, and no right */
+} OMX_AUDIO_CONFIG_BALANCETYPE;
+
+
+/** Audio Port mute */
+typedef struct OMX_AUDIO_CONFIG_MUTETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port index indicating which port to 
+                                     set.  Select the input port to set 
+                                     just that port's mute.  Select the 
+                                     output port to adjust the master 
+                                     mute. */
+    OMX_BOOL bMute;             /**< Mute setting for this port */
+} OMX_AUDIO_CONFIG_MUTETYPE;
+
+
+/** Audio Channel mute */
+typedef struct OMX_AUDIO_CONFIG_CHANNELMUTETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */
+    OMX_U32 nChannel;           /**< channel to select from 0 to N-1, 
+                                     using OMX_ALL to apply mute settings
+                                     to all channels */
+    OMX_BOOL bMute;             /**< Mute setting for this channel */
+    OMX_BOOL bIsMIDI;           /**< TRUE if nChannel refers to a MIDI channel,
+                                     FALSE otherwise */ 
+} OMX_AUDIO_CONFIG_CHANNELMUTETYPE;
+
+
+
+/** Enable / Disable for loudness control, which boosts bass and to a 
+ *  smaller extent high end frequencies to compensate for hearing
+ *  ability at the extreme ends of the audio spectrum
+ */ 
+typedef struct OMX_AUDIO_CONFIG_LOUDNESSTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bLoudness;        /**< Enable/disable for loudness */
+} OMX_AUDIO_CONFIG_LOUDNESSTYPE;
+
+
+/** Enable / Disable for bass, which controls low frequencies
+ */ 
+typedef struct OMX_AUDIO_CONFIG_BASSTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for bass control */
+    OMX_S32 nBass;             /**< bass setting for the port, as a 
+                                    continuous value from -100 to 100  
+                                    (0 means no change in bass level)*/
+} OMX_AUDIO_CONFIG_BASSTYPE;
+
+
+/** Enable / Disable for treble, which controls high frequencies tones
+ */ 
+typedef struct OMX_AUDIO_CONFIG_TREBLETYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for treble control */
+    OMX_S32  nTreble;          /**< treble setting for the port, as a
+                                    continuous value from -100 to 100  
+                                    (0 means no change in treble level) */
+} OMX_AUDIO_CONFIG_TREBLETYPE;
+
+
+/** An equalizer is typically used for two reasons: to compensate for an 
+ *  sub-optimal frequency response of a system to make it sound more natural 
+ *  or to create intentionally some unnatural coloring to the sound to create
+ *  an effect.
+ *  @ingroup effects
+ */
+typedef struct OMX_AUDIO_CONFIG_EQUALIZERTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for equalizer */
+    OMX_BU32 sBandIndex;       /**< Band number to be set.  Upper Limit is 
+                                    N-1, where N is the number of bands, lower limit is 0 */
+    OMX_BU32 sCenterFreq;      /**< Center frequecies in Hz.  This is a
+                                    read only element and is used to determine 
+                                    the lower, center and upper frequency of 
+                                    this band.  */
+    OMX_BS32 sBandLevel;       /**< band level in millibels */
+} OMX_AUDIO_CONFIG_EQUALIZERTYPE;
+
+
+/** Stereo widening mode type 
+ * @ingroup effects
+ */ 
+typedef enum OMX_AUDIO_STEREOWIDENINGTYPE {
+    OMX_AUDIO_StereoWideningHeadphones,    /**< Stereo widening for loudspeakers */
+    OMX_AUDIO_StereoWideningLoudspeakers,  /**< Stereo widening for closely spaced loudspeakers */
+    OMX_AUDIO_StereoWideningKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_StereoWideningVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_StereoWideningMax = 0x7FFFFFFF
+} OMX_AUDIO_STEREOWIDENINGTYPE;
+
+
+/** Control for stereo widening, which is a special 2-channel
+ *  case of the audio virtualizer effect. For example, for 5.1-channel 
+ *  output, it translates to virtual surround sound. 
+ * @ingroup effects
+ */ 
+typedef struct OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for stereo widening control */
+    OMX_AUDIO_STEREOWIDENINGTYPE eWideningType; /**< Stereo widening algorithm type */
+    OMX_U32  nStereoWidening;  /**< stereo widening setting for the port,
+                                    as a continuous value from 0 to 100  */
+} OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE;
+
+
+/** The chorus effect (or ``choralizer'') is any signal processor which makes
+ *  one sound source (such as a voice) sound like many such sources singing 
+ *  (or playing) in unison. Since performance in unison is never exact, chorus 
+ *  effects simulate this by making independently modified copies of the input 
+ *  signal. Modifications may include (1) delay, (2) frequency shift, and 
+ *  (3) amplitude modulation.
+ * @ingroup effects
+ */
+typedef struct OMX_AUDIO_CONFIG_CHORUSTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for chorus */
+    OMX_BU32 sDelay;           /**< average delay in milliseconds */
+    OMX_BU32 sModulationRate;  /**< rate of modulation in millihertz */
+    OMX_U32 nModulationDepth;  /**< depth of modulation as a percentage of 
+                                    delay (i.e. 0 to 100) */
+    OMX_BU32 nFeedback;        /**< Feedback from chorus output to input in percentage */
+} OMX_AUDIO_CONFIG_CHORUSTYPE;
+
+
+/** Reverberation is part of the reflected sound that follows the early 
+ *  reflections. In a typical room, this consists of a dense succession of 
+ *  echoes whose energy decays exponentially. The reverberation effect structure 
+ *  as defined here includes both (early) reflections as well as (late) reverberations. 
+ * @ingroup effects
+ */
+typedef struct OMX_AUDIO_CONFIG_REVERBERATIONTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_BOOL bEnable;             /**< Enable/disable for reverberation control */
+    OMX_BS32 sRoomLevel;          /**< Intensity level for the whole room effect 
+                                       (i.e. both early reflections and late 
+                                       reverberation) in millibels */
+    OMX_BS32 sRoomHighFreqLevel;  /**< Attenuation at high frequencies
+                                       relative to the intensity at low
+                                       frequencies in millibels */
+    OMX_BS32 sReflectionsLevel;   /**< Intensity level of early reflections
+                                       (relative to room value), in millibels */
+    OMX_BU32 sReflectionsDelay;   /**< Delay time of the first reflection relative 
+                                       to the direct path, in milliseconds */
+    OMX_BS32 sReverbLevel;        /**< Intensity level of late reverberation
+                                       relative to room level, in millibels */
+    OMX_BU32 sReverbDelay;        /**< Time delay from the first early reflection 
+                                       to the beginning of the late reverberation 
+                                       section, in milliseconds */
+    OMX_BU32 sDecayTime;          /**< Late reverberation decay time at low
+                                       frequencies, in milliseconds */
+    OMX_BU32 nDecayHighFreqRatio; /**< Ratio of high frequency decay time relative 
+                                       to low frequency decay time in percent  */
+    OMX_U32 nDensity;             /**< Modal density in the late reverberation decay,
+                                       in percent (i.e. 0 - 100) */
+    OMX_U32 nDiffusion;           /**< Echo density in the late reverberation decay,
+                                       in percent (i.e. 0 - 100) */
+    OMX_BU32 sReferenceHighFreq;  /**< Reference high frequency in Hertz. This is 
+                                       the frequency used as the reference for all 
+                                       the high-frequency settings above */
+
+} OMX_AUDIO_CONFIG_REVERBERATIONTYPE;
+
+
+/** Possible settings for the Echo Cancelation structure to use 
+ * @ingroup effects
+ */
+typedef enum OMX_AUDIO_ECHOCANTYPE {
+   OMX_AUDIO_EchoCanOff = 0,    /**< Echo Cancellation is disabled */
+   OMX_AUDIO_EchoCanNormal,     /**< Echo Cancellation normal operation - 
+                                     echo from plastics and face */
+   OMX_AUDIO_EchoCanHFree,      /**< Echo Cancellation optimized for 
+                                     Hands Free operation */
+   OMX_AUDIO_EchoCanCarKit,    /**< Echo Cancellation optimized for 
+                                     Car Kit (longer echo) */
+   OMX_AUDIO_EchoCanKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+   OMX_AUDIO_EchoCanVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+   OMX_AUDIO_EchoCanMax = 0x7FFFFFFF
+} OMX_AUDIO_ECHOCANTYPE;
+
+
+/** Enable / Disable for echo cancelation, which removes undesired echo's
+ *  from the audio
+ * @ingroup effects
+ */ 
+typedef struct OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_AUDIO_ECHOCANTYPE eEchoCancelation; /**< Echo cancelation settings */
+} OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE;
+
+
+/** Enable / Disable for noise reduction, which undesired noise from
+ * the audio
+ * @ingroup effects
+ */ 
+typedef struct OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bNoiseReduction;  /**< Enable/disable for noise reduction */
+} OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE;
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
+
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Component.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Component.h
new file mode 100644
index 0000000..d595640
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Component.h
@@ -0,0 +1,579 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** OMX_Component.h - OpenMax IL version 1.1.2
+ *  The OMX_Component header file contains the definitions used to define
+ *  the public interface of a component.  This header file is intended to
+ *  be used by both the application and the component.
+ */
+
+#ifndef OMX_Component_h
+#define OMX_Component_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+/* Each OMX header must include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+
+#include <OMX_Audio.h>
+#include <OMX_Video.h>
+#include <OMX_Image.h>
+#include <OMX_Other.h>
+
+/** @ingroup comp */
+typedef enum OMX_PORTDOMAINTYPE { 
+    OMX_PortDomainAudio, 
+    OMX_PortDomainVideo, 
+    OMX_PortDomainImage, 
+    OMX_PortDomainOther,
+    OMX_PortDomainKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_PortDomainVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_PortDomainMax = 0x7ffffff
+} OMX_PORTDOMAINTYPE;
+
+/** @ingroup comp */
+typedef struct OMX_PARAM_PORTDEFINITIONTYPE {
+    OMX_U32 nSize;                 /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
+    OMX_U32 nPortIndex;            /**< Port number the structure applies to */
+    OMX_DIRTYPE eDir;              /**< Direction (input or output) of this port */
+    OMX_U32 nBufferCountActual;    /**< The actual number of buffers allocated on this port */
+    OMX_U32 nBufferCountMin;       /**< The minimum number of buffers this port requires */
+    OMX_U32 nBufferSize;           /**< Size, in bytes, for buffers to be used for this channel */
+    OMX_BOOL bEnabled;             /**< Ports default to enabled and are enabled/disabled by
+                                        OMX_CommandPortEnable/OMX_CommandPortDisable.
+                                        When disabled a port is unpopulated. A disabled port
+                                        is not populated with buffers on a transition to IDLE. */
+    OMX_BOOL bPopulated;           /**< Port is populated with all of its buffers as indicated by
+                                        nBufferCountActual. A disabled port is always unpopulated. 
+                                        An enabled port is populated on a transition to OMX_StateIdle
+                                        and unpopulated on a transition to loaded. */
+    OMX_PORTDOMAINTYPE eDomain;    /**< Domain of the port. Determines the contents of metadata below. */
+    union {
+        OMX_AUDIO_PORTDEFINITIONTYPE audio;
+        OMX_VIDEO_PORTDEFINITIONTYPE video;
+        OMX_IMAGE_PORTDEFINITIONTYPE image;
+        OMX_OTHER_PORTDEFINITIONTYPE other;
+    } format;
+    OMX_BOOL bBuffersContiguous;
+    OMX_U32 nBufferAlignment;
+} OMX_PARAM_PORTDEFINITIONTYPE;
+
+/** @ingroup comp */
+typedef struct OMX_PARAM_U32TYPE { 
+    OMX_U32 nSize;                    /**< Size of this structure, in Bytes */ 
+    OMX_VERSIONTYPE nVersion;         /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;               /**< port that this structure applies to */ 
+    OMX_U32 nU32;                     /**< U32 value */
+} OMX_PARAM_U32TYPE;
+
+/** @ingroup rpm */
+typedef enum OMX_SUSPENSIONPOLICYTYPE {
+    OMX_SuspensionDisabled, /**< No suspension; v1.0 behavior */
+    OMX_SuspensionEnabled,  /**< Suspension allowed */   
+    OMX_SuspensionPolicyKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_SuspensionPolicyStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_SuspensionPolicyMax = 0x7fffffff
+} OMX_SUSPENSIONPOLICYTYPE;
+
+/** @ingroup rpm */
+typedef struct OMX_PARAM_SUSPENSIONPOLICYTYPE {
+    OMX_U32 nSize;                  
+    OMX_VERSIONTYPE nVersion;        
+    OMX_SUSPENSIONPOLICYTYPE ePolicy;
+} OMX_PARAM_SUSPENSIONPOLICYTYPE;
+
+/** @ingroup rpm */
+typedef enum OMX_SUSPENSIONTYPE {
+    OMX_NotSuspended, /**< component is not suspended */
+    OMX_Suspended,    /**< component is suspended */
+    OMX_SuspensionKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_SuspensionVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_SuspendMax = 0x7FFFFFFF
+} OMX_SUSPENSIONTYPE;
+
+/** @ingroup rpm */
+typedef struct OMX_PARAM_SUSPENSIONTYPE {
+    OMX_U32 nSize;                  
+    OMX_VERSIONTYPE nVersion;       
+    OMX_SUSPENSIONTYPE eType;             
+} OMX_PARAM_SUSPENSIONTYPE ;
+
+typedef struct OMX_CONFIG_BOOLEANTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_BOOL bEnabled;    
+} OMX_CONFIG_BOOLEANTYPE;
+
+/* Parameter specifying the content uri to use. */
+/** @ingroup cp */
+typedef struct OMX_PARAM_CONTENTURITYPE
+{
+    OMX_U32 nSize;                      /**< size of the structure in bytes, including
+                                             actual URI name */
+    OMX_VERSIONTYPE nVersion;           /**< OMX specification version information */
+    OMX_U8 contentURI[1];               /**< The URI name */
+} OMX_PARAM_CONTENTURITYPE;
+
+/* Parameter specifying the pipe to use. */
+/** @ingroup cp */
+typedef struct OMX_PARAM_CONTENTPIPETYPE
+{
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_HANDLETYPE hPipe;       /**< The pipe handle*/
+} OMX_PARAM_CONTENTPIPETYPE;
+
+/** @ingroup rpm */
+typedef struct OMX_RESOURCECONCEALMENTTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_BOOL bResourceConcealmentForbidden; /**< disallow the use of resource concealment 
+                                            methods (like degrading algorithm quality to 
+                                            lower resource consumption or functional bypass) 
+                                            on a component as a resolution to resource conflicts. */
+} OMX_RESOURCECONCEALMENTTYPE;
+
+
+/** @ingroup metadata */
+typedef enum OMX_METADATACHARSETTYPE {
+    OMX_MetadataCharsetUnknown = 0,
+    OMX_MetadataCharsetASCII,
+    OMX_MetadataCharsetBinary,
+    OMX_MetadataCharsetCodePage1252,
+    OMX_MetadataCharsetUTF8,
+    OMX_MetadataCharsetJavaConformantUTF8,
+    OMX_MetadataCharsetUTF7,
+    OMX_MetadataCharsetImapUTF7,
+    OMX_MetadataCharsetUTF16LE, 
+    OMX_MetadataCharsetUTF16BE,
+    OMX_MetadataCharsetGB12345,
+    OMX_MetadataCharsetHZGB2312,
+    OMX_MetadataCharsetGB2312,
+    OMX_MetadataCharsetGB18030,
+    OMX_MetadataCharsetGBK,
+    OMX_MetadataCharsetBig5,
+    OMX_MetadataCharsetISO88591,
+    OMX_MetadataCharsetISO88592,
+    OMX_MetadataCharsetISO88593,
+    OMX_MetadataCharsetISO88594,
+    OMX_MetadataCharsetISO88595,
+    OMX_MetadataCharsetISO88596,
+    OMX_MetadataCharsetISO88597,
+    OMX_MetadataCharsetISO88598,
+    OMX_MetadataCharsetISO88599,
+    OMX_MetadataCharsetISO885910,
+    OMX_MetadataCharsetISO885913,
+    OMX_MetadataCharsetISO885914,
+    OMX_MetadataCharsetISO885915,
+    OMX_MetadataCharsetShiftJIS,
+    OMX_MetadataCharsetISO2022JP,
+    OMX_MetadataCharsetISO2022JP1,
+    OMX_MetadataCharsetISOEUCJP,
+    OMX_MetadataCharsetSMS7Bit,
+    OMX_MetadataCharsetKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MetadataCharsetVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_MetadataCharsetTypeMax= 0x7FFFFFFF
+} OMX_METADATACHARSETTYPE;
+
+/** @ingroup metadata */
+typedef enum OMX_METADATASCOPETYPE
+{
+    OMX_MetadataScopeAllLevels,
+    OMX_MetadataScopeTopLevel,
+    OMX_MetadataScopePortLevel,
+    OMX_MetadataScopeNodeLevel,
+    OMX_MetadataScopeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MetadataScopeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_MetadataScopeTypeMax = 0x7fffffff
+} OMX_METADATASCOPETYPE;
+
+/** @ingroup metadata */
+typedef enum OMX_METADATASEARCHMODETYPE
+{
+    OMX_MetadataSearchValueSizeByIndex,
+    OMX_MetadataSearchItemByIndex,
+    OMX_MetadataSearchNextItemByKey,
+    OMX_MetadataSearchKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MetadataSearchVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_MetadataSearchTypeMax = 0x7fffffff
+} OMX_METADATASEARCHMODETYPE;
+/** @ingroup metadata */
+typedef struct OMX_CONFIG_METADATAITEMCOUNTTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_METADATASCOPETYPE eScopeMode;
+    OMX_U32 nScopeSpecifier;
+    OMX_U32 nMetadataItemCount;
+} OMX_CONFIG_METADATAITEMCOUNTTYPE;
+
+/** @ingroup metadata */
+typedef struct OMX_CONFIG_METADATAITEMTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_METADATASCOPETYPE eScopeMode;
+    OMX_U32 nScopeSpecifier;
+    OMX_U32 nMetadataItemIndex;  
+    OMX_METADATASEARCHMODETYPE eSearchMode;
+    OMX_METADATACHARSETTYPE eKeyCharset;
+    OMX_U8 nKeySizeUsed;
+    OMX_U8 nKey[128];
+    OMX_METADATACHARSETTYPE eValueCharset;
+    OMX_STRING sLanguageCountry;
+    OMX_U32 nValueMaxSize;
+    OMX_U32 nValueSizeUsed;
+    OMX_U8 nValue[1];
+} OMX_CONFIG_METADATAITEMTYPE;
+
+/* @ingroup metadata */
+typedef struct OMX_CONFIG_CONTAINERNODECOUNTTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_BOOL bAllKeys;
+    OMX_U32 nParentNodeID;
+    OMX_U32 nNumNodes;
+} OMX_CONFIG_CONTAINERNODECOUNTTYPE;
+
+/** @ingroup metadata */
+typedef struct OMX_CONFIG_CONTAINERNODEIDTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_BOOL bAllKeys;
+    OMX_U32 nParentNodeID;
+    OMX_U32 nNodeIndex; 
+    OMX_U32 nNodeID; 
+    OMX_STRING cNodeName;
+    OMX_BOOL bIsLeafType;
+} OMX_CONFIG_CONTAINERNODEIDTYPE;
+
+/** @ingroup metadata */
+typedef struct OMX_PARAM_METADATAFILTERTYPE 
+{ 
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion; 
+    OMX_BOOL bAllKeys;	/* if true then this structure refers to all keys and 
+                         * the three key fields below are ignored */
+    OMX_METADATACHARSETTYPE eKeyCharset;
+    OMX_U32 nKeySizeUsed; 
+    OMX_U8   nKey [128]; 
+    OMX_U32 nLanguageCountrySizeUsed;
+    OMX_U8 nLanguageCountry[128];
+    OMX_BOOL bEnabled;	/* if true then key is part of filter (e.g. 
+                         * retained for query later). If false then
+                         * key is not part of filter */
+} OMX_PARAM_METADATAFILTERTYPE; 
+
+/** The OMX_HANDLETYPE structure defines the component handle.  The component 
+ *  handle is used to access all of the component's public methods and also
+ *  contains pointers to the component's private data area.  The component
+ *  handle is initialized by the OMX core (with help from the component)
+ *  during the process of loading the component.  After the component is
+ *  successfully loaded, the application can safely access any of the
+ *  component's public functions (although some may return an error because
+ *  the state is inappropriate for the access).
+ * 
+ *  @ingroup comp
+ */
+typedef struct OMX_COMPONENTTYPE
+{
+    /** The size of this structure, in bytes.  It is the responsibility
+        of the allocator of this structure to fill in this value.  Since
+        this structure is allocated by the GetHandle function, this
+        function will fill in this value. */
+    OMX_U32 nSize;
+
+    /** nVersion is the version of the OMX specification that the structure 
+        is built against.  It is the responsibility of the creator of this 
+        structure to initialize this value and every user of this structure 
+        should verify that it knows how to use the exact version of 
+        this structure found herein. */
+    OMX_VERSIONTYPE nVersion;
+
+    /** pComponentPrivate is a pointer to the component private data area.  
+        This member is allocated and initialized by the component when the 
+        component is first loaded.  The application should not access this 
+        data area. */
+    OMX_PTR pComponentPrivate;
+
+    /** pApplicationPrivate is a pointer that is a parameter to the 
+        OMX_GetHandle method, and contains an application private value 
+        provided by the IL client.  This application private data is 
+        returned to the IL Client by OMX in all callbacks */
+    OMX_PTR pApplicationPrivate;
+
+    /** refer to OMX_GetComponentVersion in OMX_core.h or the OMX IL 
+        specification for details on the GetComponentVersion method.
+     */
+    OMX_ERRORTYPE (*GetComponentVersion)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_OUT OMX_STRING pComponentName,
+            OMX_OUT OMX_VERSIONTYPE* pComponentVersion,
+            OMX_OUT OMX_VERSIONTYPE* pSpecVersion,
+            OMX_OUT OMX_UUIDTYPE* pComponentUUID);
+
+    /** refer to OMX_SendCommand in OMX_core.h or the OMX IL 
+        specification for details on the SendCommand method.
+     */
+    OMX_ERRORTYPE (*SendCommand)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_COMMANDTYPE Cmd,
+            OMX_IN  OMX_U32 nParam1,
+            OMX_IN  OMX_PTR pCmdData);
+
+    /** refer to OMX_GetParameter in OMX_core.h or the OMX IL 
+        specification for details on the GetParameter method.
+     */
+    OMX_ERRORTYPE (*GetParameter)(
+            OMX_IN  OMX_HANDLETYPE hComponent, 
+            OMX_IN  OMX_INDEXTYPE nParamIndex,  
+            OMX_INOUT OMX_PTR pComponentParameterStructure);
+
+
+    /** refer to OMX_SetParameter in OMX_core.h or the OMX IL 
+        specification for details on the SetParameter method.
+     */
+    OMX_ERRORTYPE (*SetParameter)(
+            OMX_IN  OMX_HANDLETYPE hComponent, 
+            OMX_IN  OMX_INDEXTYPE nIndex,
+            OMX_IN  OMX_PTR pComponentParameterStructure);
+
+
+    /** refer to OMX_GetConfig in OMX_core.h or the OMX IL 
+        specification for details on the GetConfig method.
+     */
+    OMX_ERRORTYPE (*GetConfig)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_INDEXTYPE nIndex, 
+            OMX_INOUT OMX_PTR pComponentConfigStructure);
+
+
+    /** refer to OMX_SetConfig in OMX_core.h or the OMX IL 
+        specification for details on the SetConfig method.
+     */
+    OMX_ERRORTYPE (*SetConfig)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_INDEXTYPE nIndex, 
+            OMX_IN  OMX_PTR pComponentConfigStructure);
+
+
+    /** refer to OMX_GetExtensionIndex in OMX_core.h or the OMX IL 
+        specification for details on the GetExtensionIndex method.
+     */
+    OMX_ERRORTYPE (*GetExtensionIndex)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_STRING cParameterName,
+            OMX_OUT OMX_INDEXTYPE* pIndexType);
+
+
+    /** refer to OMX_GetState in OMX_core.h or the OMX IL 
+        specification for details on the GetState method.
+     */
+    OMX_ERRORTYPE (*GetState)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_OUT OMX_STATETYPE* pState);
+
+    
+    /** The ComponentTunnelRequest method will interact with another OMX
+        component to determine if tunneling is possible and to setup the
+        tunneling.  The return codes for this method can be used to 
+        determine if tunneling is not possible, or if tunneling is not
+        supported.  
+        
+        Base profile components (i.e. non-interop) do not support this
+        method and should return OMX_ErrorNotImplemented 
+
+        The interop profile component MUST support tunneling to another 
+        interop profile component with a compatible port parameters.  
+        A component may also support proprietary communication.
+        
+        If proprietary communication is supported the negotiation of 
+        proprietary communication is done outside of OMX in a vendor 
+        specific way. It is only required that the proper result be 
+        returned and the details of how the setup is done is left 
+        to the component implementation.  
+    
+        When this method is invoked when nPort in an output port, the
+        component will:
+        1.  Populate the pTunnelSetup structure with the output port's 
+            requirements and constraints for the tunnel.
+
+        When this method is invoked when nPort in an input port, the
+        component will:
+        1.  Query the necessary parameters from the output port to 
+            determine if the ports are compatible for tunneling
+        2.  If the ports are compatible, the component should store
+            the tunnel step provided by the output port
+        3.  Determine which port (either input or output) is the buffer
+            supplier, and call OMX_SetParameter on the output port to
+            indicate this selection.
+        
+        The component will return from this call within 5 msec.
+    
+        @param [in] hComp
+            Handle of the component to be accessed.  This is the component
+            handle returned by the call to the OMX_GetHandle method.
+        @param [in] nPort
+            nPort is used to select the port on the component to be used
+            for tunneling.
+        @param [in] hTunneledComp
+            Handle of the component to tunnel with.  This is the component 
+            handle returned by the call to the OMX_GetHandle method.  When
+            this parameter is 0x0 the component should setup the port for
+            communication with the application / IL Client.
+        @param [in] nPortOutput
+            nPortOutput is used indicate the port the component should
+            tunnel with.
+        @param [in] pTunnelSetup
+            Pointer to the tunnel setup structure.  When nPort is an output port
+            the component should populate the fields of this structure.  When
+            When nPort is an input port the component should review the setup
+            provided by the component with the output port.
+        @return OMX_ERRORTYPE
+            If the command successfully executes, the return code will be
+            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+        @ingroup tun
+    */
+
+    OMX_ERRORTYPE (*ComponentTunnelRequest)(
+        OMX_IN  OMX_HANDLETYPE hComp,
+        OMX_IN  OMX_U32 nPort,
+        OMX_IN  OMX_HANDLETYPE hTunneledComp,
+        OMX_IN  OMX_U32 nTunneledPort,
+        OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup); 
+
+    /** refer to OMX_UseBuffer in OMX_core.h or the OMX IL 
+        specification for details on the UseBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*UseBuffer)(
+            OMX_IN OMX_HANDLETYPE hComponent,
+            OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
+            OMX_IN OMX_U32 nPortIndex,
+            OMX_IN OMX_PTR pAppPrivate,
+            OMX_IN OMX_U32 nSizeBytes,
+            OMX_IN OMX_U8* pBuffer);
+
+    /** refer to OMX_AllocateBuffer in OMX_core.h or the OMX IL 
+        specification for details on the AllocateBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*AllocateBuffer)(
+            OMX_IN OMX_HANDLETYPE hComponent,
+            OMX_INOUT OMX_BUFFERHEADERTYPE** ppBuffer,
+            OMX_IN OMX_U32 nPortIndex,
+            OMX_IN OMX_PTR pAppPrivate,
+            OMX_IN OMX_U32 nSizeBytes);
+
+    /** refer to OMX_FreeBuffer in OMX_core.h or the OMX IL 
+        specification for details on the FreeBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*FreeBuffer)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_U32 nPortIndex,
+            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
+
+    /** refer to OMX_EmptyThisBuffer in OMX_core.h or the OMX IL 
+        specification for details on the EmptyThisBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*EmptyThisBuffer)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
+
+    /** refer to OMX_FillThisBuffer in OMX_core.h or the OMX IL 
+        specification for details on the FillThisBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*FillThisBuffer)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
+
+    /** The SetCallbacks method is used by the core to specify the callback
+        structure from the application to the component.  This is a blocking
+        call.  The component will return from this call within 5 msec.
+        @param [in] hComponent
+            Handle of the component to be accessed.  This is the component
+            handle returned by the call to the GetHandle function.
+        @param [in] pCallbacks
+            pointer to an OMX_CALLBACKTYPE structure used to provide the 
+            callback information to the component
+        @param [in] pAppData
+            pointer to an application defined value.  It is anticipated that 
+            the application will pass a pointer to a data structure or a "this
+            pointer" in this area to allow the callback (in the application)
+            to determine the context of the call
+        @return OMX_ERRORTYPE
+            If the command successfully executes, the return code will be
+            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+     */
+    OMX_ERRORTYPE (*SetCallbacks)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_CALLBACKTYPE* pCallbacks, 
+            OMX_IN  OMX_PTR pAppData);
+
+    /** ComponentDeInit method is used to deinitialize the component
+        providing a means to free any resources allocated at component
+        initialization.  NOTE:  After this call the component handle is
+        not valid for further use.
+        @param [in] hComponent
+            Handle of the component to be accessed.  This is the component
+            handle returned by the call to the GetHandle function.
+        @return OMX_ERRORTYPE
+            If the command successfully executes, the return code will be
+            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+     */
+    OMX_ERRORTYPE (*ComponentDeInit)(
+            OMX_IN  OMX_HANDLETYPE hComponent);
+
+    /** @ingroup buf */
+    OMX_ERRORTYPE (*UseEGLImage)(
+            OMX_IN OMX_HANDLETYPE hComponent,
+            OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
+            OMX_IN OMX_U32 nPortIndex,
+            OMX_IN OMX_PTR pAppPrivate,
+            OMX_IN void* eglImage);
+
+    OMX_ERRORTYPE (*ComponentRoleEnum)(
+        OMX_IN OMX_HANDLETYPE hComponent,
+		OMX_OUT OMX_U8 *cRole,
+		OMX_IN OMX_U32 nIndex);
+
+} OMX_COMPONENTTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_ContentPipe.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_ContentPipe.h
new file mode 100644
index 0000000..5f6310c
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_ContentPipe.h
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** OMX_ContentPipe.h - OpenMax IL version 1.1.2
+ *  The OMX_ContentPipe header file contains the definitions used to define
+ *  the public interface for content piples.  This header file is intended to
+ *  be used by the component.
+ */
+
+#ifndef OMX_CONTENTPIPE_H
+#define OMX_CONTENTPIPE_H
+
+#ifndef KD_EACCES
+/* OpenKODE error codes. CPResult values may be zero (indicating success
+   or one of the following values) */
+#define KD_EACCES (1)
+#define KD_EADDRINUSE (2)
+#define KD_EAGAIN (5)
+#define KD_EBADF (7)
+#define KD_EBUSY (8)
+#define KD_ECONNREFUSED (9)
+#define KD_ECONNRESET (10)
+#define KD_EDEADLK (11)
+#define KD_EDESTADDRREQ (12)
+#define KD_ERANGE (35)
+#define KD_EEXIST (13)
+#define KD_EFBIG (14)
+#define KD_EHOSTUNREACH (15)
+#define KD_EINVAL (17)
+#define KD_EIO (18)
+#define KD_EISCONN (20)
+#define KD_EISDIR (21)
+#define KD_EMFILE (22)
+#define KD_ENAMETOOLONG (23)
+#define KD_ENOENT (24)
+#define KD_ENOMEM (25)
+#define KD_ENOSPC (26)
+#define KD_ENOSYS (27)
+#define KD_ENOTCONN (28)
+#define KD_EPERM (33)
+#define KD_ETIMEDOUT (36)
+#define KD_EILSEQ (19)
+#endif
+
+/** Map types from OMX standard types only here so interface is as generic as possible. */
+typedef OMX_U32    CPresult;
+typedef char *     CPstring;  
+typedef void *     CPhandle;
+typedef OMX_U32    CPuint;
+typedef OMX_S32    CPint;  
+typedef char       CPbyte;  
+typedef OMX_BOOL   CPbool;
+
+/** enumeration of origin types used in the CP_PIPETYPE's Seek function 
+ * @ingroup cp
+ */
+typedef enum CP_ORIGINTYPE {
+    CP_OriginBegin,      
+    CP_OriginCur,      
+    CP_OriginEnd,      
+    CP_OriginKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    CP_OriginVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    CP_OriginMax = 0X7FFFFFFF
+} CP_ORIGINTYPE;
+
+/** enumeration of contact access types used in the CP_PIPETYPE's Open function 
+ * @ingroup cp
+ */
+typedef enum CP_ACCESSTYPE {
+    CP_AccessRead,      
+    CP_AccessWrite,  
+    CP_AccessReadWrite ,  
+    CP_AccessKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    CP_AccessVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    CP_AccessMax = 0X7FFFFFFF
+} CP_ACCESSTYPE;
+
+/** enumeration of results returned by the CP_PIPETYPE's CheckAvailableBytes function 
+ * @ingroup cp
+ */
+typedef enum CP_CHECKBYTESRESULTTYPE
+{
+    CP_CheckBytesOk,                    /**< There are at least the request number 
+                                              of bytes available */
+    CP_CheckBytesNotReady,              /**< The pipe is still retrieving bytes 
+                                              and presently lacks sufficient bytes. 
+                                              Client will be called when they are 
+                                              sufficient bytes are available. */
+    CP_CheckBytesInsufficientBytes  ,     /**< The pipe has retrieved all bytes 
+                                              but those available are less than those 
+                                              requested */
+    CP_CheckBytesAtEndOfStream,         /**< The pipe has reached the end of stream
+                                              and no more bytes are available. */
+    CP_CheckBytesOutOfBuffers,          /**< All read/write buffers are currently in use. */
+    CP_CheckBytesKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    CP_CheckBytesVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    CP_CheckBytesMax = 0X7FFFFFFF
+} CP_CHECKBYTESRESULTTYPE;
+
+/** enumeration of content pipe events sent to the client callback. 
+ * @ingroup cp
+ */
+typedef enum CP_EVENTTYPE{
+    CP_BytesAvailable,      	    /** bytes requested in a CheckAvailableBytes call are now available*/
+    CP_Overflow,  		           /** enumeration of content pipe events sent to the client callback*/
+    CP_PipeDisconnected  ,  		    /** enumeration of content pipe events sent to the client callback*/
+    CP_EventKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    CP_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    CP_EventMax = 0X7FFFFFFF
+} CP_EVENTTYPE;
+
+/** content pipe definition 
+ * @ingroup cp
+ */
+typedef struct CP_PIPETYPE
+{
+    /** Open a content stream for reading or writing. */ 
+    CPresult (*Open)( CPhandle* hContent, CPstring szURI, CP_ACCESSTYPE eAccess );
+
+    /** Close a content stream. */ 
+    CPresult (*Close)( CPhandle hContent );
+
+    /** Create a content source and open it for writing. */ 
+    CPresult (*Create)( CPhandle *hContent, CPstring szURI );
+
+    /** Check the that specified number of bytes are available for reading or writing (depending on access type).*/
+    CPresult (*CheckAvailableBytes)( CPhandle hContent, CPuint nBytesRequested, CP_CHECKBYTESRESULTTYPE *eResult );
+
+    /** Seek to certain position in the content relative to the specified origin. */
+    CPresult (*SetPosition)( CPhandle  hContent, CPint nOffset, CP_ORIGINTYPE eOrigin);
+
+    /** Retrieve the current position relative to the start of the content. */
+    CPresult (*GetPosition)( CPhandle hContent, CPuint *pPosition);
+
+    /** Retrieve data of the specified size from the content stream (advance content pointer by size of data).
+       Note: pipe client provides pointer. This function is appropriate for small high frequency reads. */
+    CPresult (*Read)( CPhandle hContent, CPbyte *pData, CPuint nSize); 
+
+    /** Retrieve a buffer allocated by the pipe that contains the requested number of bytes. 
+       Buffer contains the next block of bytes, as specified by nSize, of the content. nSize also
+       returns the size of the block actually read. Content pointer advances the by the returned size. 
+       Note: pipe provides pointer. This function is appropriate for large reads. The client must call 
+       ReleaseReadBuffer when done with buffer. 
+
+       In some cases the requested block may not reside in contiguous memory within the
+       pipe implementation. For instance if the pipe leverages a circular buffer then the requested 
+       block may straddle the boundary of the circular buffer. By default a pipe implementation 
+       performs a copy in this case to provide the block to the pipe client in one contiguous buffer.
+       If, however, the client sets bForbidCopy, then the pipe returns only those bytes preceding the memory 
+       boundary. Here the client may retrieve the data in segments over successive calls. */
+    CPresult (*ReadBuffer)( CPhandle hContent, CPbyte **ppBuffer, CPuint *nSize, CPbool bForbidCopy);
+
+    /** Release a buffer obtained by ReadBuffer back to the pipe. */
+    CPresult (*ReleaseReadBuffer)(CPhandle hContent, CPbyte *pBuffer);
+
+    /** Write data of the specified size to the content (advance content pointer by size of data).
+       Note: pipe client provides pointer. This function is appropriate for small high frequency writes. */
+    CPresult (*Write)( CPhandle hContent, CPbyte *data, CPuint nSize); 
+
+    /** Retrieve a buffer allocated by the pipe used to write data to the content. 
+       Client will fill buffer with output data. Note: pipe provides pointer. This function is appropriate
+       for large writes. The client must call WriteBuffer when done it has filled the buffer with data.*/
+    CPresult (*GetWriteBuffer)( CPhandle hContent, CPbyte **ppBuffer, CPuint nSize);
+
+    /** Deliver a buffer obtained via GetWriteBuffer to the pipe. Pipe will write the 
+       the contents of the buffer to content and advance content pointer by the size of the buffer */
+    CPresult (*WriteBuffer)( CPhandle hContent, CPbyte *pBuffer, CPuint nFilledSize);
+
+    /** Register a per-handle client callback with the content pipe. */
+    CPresult (*RegisterCallback)( CPhandle hContent, CPresult (*ClientCallback)(CP_EVENTTYPE eEvent, CPuint iParam));
+
+} CP_PIPETYPE;
+
+#endif
+
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Core.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Core.h
new file mode 100644
index 0000000..a076f2f
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Core.h
@@ -0,0 +1,1431 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** OMX_Core.h - OpenMax IL version 1.1.2
+ *  The OMX_Core header file contains the definitions used by both the
+ *  application and the component to access common items.
+ */
+
+#ifndef OMX_Core_h
+#define OMX_Core_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header shall include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+
+#include <OMX_Index.h>
+
+
+/** The OMX_COMMANDTYPE enumeration is used to specify the action in the
+ *  OMX_SendCommand macro.  
+ *  @ingroup core
+ */
+typedef enum OMX_COMMANDTYPE
+{
+    OMX_CommandStateSet,    /**< Change the component state */
+    OMX_CommandFlush,       /**< Flush the data queue(s) of a component */
+    OMX_CommandPortDisable, /**< Disable a port on a component. */
+    OMX_CommandPortEnable,  /**< Enable a port on a component. */
+    OMX_CommandMarkBuffer,  /**< Mark a component/buffer for observation */
+    OMX_CommandKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_CommandVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_CommandMax = 0X7FFFFFFF
+} OMX_COMMANDTYPE;
+
+
+
+/** The OMX_STATETYPE enumeration is used to indicate or change the component
+ *  state.  This enumeration reflects the current state of the component when
+ *  used with the OMX_GetState macro or becomes the parameter in a state change
+ *  command when used with the OMX_SendCommand macro.
+ *
+ *  The component will be in the Loaded state after the component is initially
+ *  loaded into memory.  In the Loaded state, the component is not allowed to
+ *  allocate or hold resources other than to build it's internal parameter
+ *  and configuration tables.  The application will send one or more
+ *  SetParameters/GetParameters and SetConfig/GetConfig commands to the
+ *  component and the component will record each of these parameter and
+ *  configuration changes for use later.  When the application sends the
+ *  Idle command, the component will acquire the resources needed for the
+ *  specified configuration and will transition to the idle state if the
+ *  allocation is successful.  If the component cannot successfully
+ *  transition to the idle state for any reason, the state of the component
+ *  shall be fully rolled back to the Loaded state (e.g. all allocated 
+ *  resources shall be released).  When the component receives the command
+ *  to go to the Executing state, it shall begin processing buffers by
+ *  sending all input buffers it holds to the application.  While
+ *  the component is in the Idle state, the application may also send the
+ *  Pause command.  If the component receives the pause command while in the
+ *  Idle state, the component shall send all input buffers it holds to the 
+ *  application, but shall not begin processing buffers.  This will allow the
+ *  application to prefill buffers.
+ * 
+ *  @ingroup comp
+ */
+
+typedef enum OMX_STATETYPE
+{
+    OMX_StateInvalid,      /**< component has detected that it's internal data 
+                                structures are corrupted to the point that
+                                it cannot determine it's state properly */
+    OMX_StateLoaded,      /**< component has been loaded but has not completed
+                                initialization.  The OMX_SetParameter macro
+                                and the OMX_GetParameter macro are the only 
+                                valid macros allowed to be sent to the 
+                                component in this state. */
+    OMX_StateIdle,        /**< component initialization has been completed
+                                successfully and the component is ready to
+                                to start. */
+    OMX_StateExecuting,   /**< component has accepted the start command and
+                                is processing data (if data is available) */
+    OMX_StatePause,       /**< component has received pause command */
+    OMX_StateWaitForResources, /**< component is waiting for resources, either after 
+                                preemption or before it gets the resources requested.
+                                See specification for complete details. */
+    OMX_StateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_StateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_StateMax = 0X7FFFFFFF
+} OMX_STATETYPE;
+
+/** The OMX_ERRORTYPE enumeration defines the standard OMX Errors.  These 
+ *  errors should cover most of the common failure cases.  However, 
+ *  vendors are free to add additional error messages of their own as 
+ *  long as they follow these rules:
+ *  1.  Vendor error messages shall be in the range of 0x90000000 to
+ *      0x9000FFFF.
+ *  2.  Vendor error messages shall be defined in a header file provided
+ *      with the component.  No error messages are allowed that are
+ *      not defined.
+ */
+typedef enum OMX_ERRORTYPE
+{
+  OMX_ErrorNone = 0,
+
+  /** There were insufficient resources to perform the requested operation */
+  OMX_ErrorInsufficientResources = (OMX_S32) 0x80001000,
+
+  /** There was an error, but the cause of the error could not be determined */
+  OMX_ErrorUndefined = (OMX_S32) 0x80001001,
+
+  /** The component name string was not valid */
+  OMX_ErrorInvalidComponentName = (OMX_S32) 0x80001002,
+
+  /** No component with the specified name string was found */
+  OMX_ErrorComponentNotFound = (OMX_S32) 0x80001003,
+
+  /** The component specified did not have a "OMX_ComponentInit" or
+      "OMX_ComponentDeInit entry point */
+  OMX_ErrorInvalidComponent = (OMX_S32) 0x80001004,
+
+  /** One or more parameters were not valid */
+  OMX_ErrorBadParameter = (OMX_S32) 0x80001005,
+
+  /** The requested function is not implemented */
+  OMX_ErrorNotImplemented = (OMX_S32) 0x80001006,
+
+  /** The buffer was emptied before the next buffer was ready */
+  OMX_ErrorUnderflow = (OMX_S32) 0x80001007,
+
+  /** The buffer was not available when it was needed */
+  OMX_ErrorOverflow = (OMX_S32) 0x80001008,
+
+  /** The hardware failed to respond as expected */
+  OMX_ErrorHardware = (OMX_S32) 0x80001009,
+
+  /** The component is in the state OMX_StateInvalid */
+  OMX_ErrorInvalidState = (OMX_S32) 0x8000100A,
+
+  /** Stream is found to be corrupt */
+  OMX_ErrorStreamCorrupt = (OMX_S32) 0x8000100B,
+
+  /** Ports being connected are not compatible */
+  OMX_ErrorPortsNotCompatible = (OMX_S32) 0x8000100C,
+
+  /** Resources allocated to an idle component have been
+      lost resulting in the component returning to the loaded state */
+  OMX_ErrorResourcesLost = (OMX_S32) 0x8000100D,
+
+  /** No more indicies can be enumerated */
+  OMX_ErrorNoMore = (OMX_S32) 0x8000100E,
+
+  /** The component detected a version mismatch */
+  OMX_ErrorVersionMismatch = (OMX_S32) 0x8000100F,
+
+  /** The component is not ready to return data at this time */
+  OMX_ErrorNotReady = (OMX_S32) 0x80001010,
+
+  /** There was a timeout that occurred */
+  OMX_ErrorTimeout = (OMX_S32) 0x80001011,
+
+  /** This error occurs when trying to transition into the state you are already in */
+  OMX_ErrorSameState = (OMX_S32) 0x80001012,
+
+  /** Resources allocated to an executing or paused component have been 
+      preempted, causing the component to return to the idle state */
+  OMX_ErrorResourcesPreempted = (OMX_S32) 0x80001013, 
+
+  /** A non-supplier port sends this error to the IL client (via the EventHandler callback) 
+      during the allocation of buffers (on a transition from the LOADED to the IDLE state or
+      on a port restart) when it deems that it has waited an unusually long time for the supplier 
+      to send it an allocated buffer via a UseBuffer call. */
+  OMX_ErrorPortUnresponsiveDuringAllocation = (OMX_S32) 0x80001014,
+
+  /** A non-supplier port sends this error to the IL client (via the EventHandler callback) 
+      during the deallocation of buffers (on a transition from the IDLE to LOADED state or 
+      on a port stop) when it deems that it has waited an unusually long time for the supplier 
+      to request the deallocation of a buffer header via a FreeBuffer call. */
+  OMX_ErrorPortUnresponsiveDuringDeallocation = (OMX_S32) 0x80001015,
+
+  /** A supplier port sends this error to the IL client (via the EventHandler callback) 
+      during the stopping of a port (either on a transition from the IDLE to LOADED 
+      state or a port stop) when it deems that it has waited an unusually long time for 
+      the non-supplier to return a buffer via an EmptyThisBuffer or FillThisBuffer call. */
+  OMX_ErrorPortUnresponsiveDuringStop = (OMX_S32) 0x80001016,
+
+  /** Attempting a state transtion that is not allowed */
+  OMX_ErrorIncorrectStateTransition = (OMX_S32) 0x80001017,
+
+  /* Attempting a command that is not allowed during the present state. */
+  OMX_ErrorIncorrectStateOperation = (OMX_S32) 0x80001018, 
+
+  /** The values encapsulated in the parameter or config structure are not supported. */
+  OMX_ErrorUnsupportedSetting = (OMX_S32) 0x80001019,
+
+  /** The parameter or config indicated by the given index is not supported. */
+  OMX_ErrorUnsupportedIndex = (OMX_S32) 0x8000101A,
+
+  /** The port index supplied is incorrect. */
+  OMX_ErrorBadPortIndex = (OMX_S32) 0x8000101B,
+
+  /** The port has lost one or more of its buffers and it thus unpopulated. */
+  OMX_ErrorPortUnpopulated = (OMX_S32) 0x8000101C,
+
+  /** Component suspended due to temporary loss of resources */
+  OMX_ErrorComponentSuspended = (OMX_S32) 0x8000101D,
+
+  /** Component suspended due to an inability to acquire dynamic resources */
+  OMX_ErrorDynamicResourcesUnavailable = (OMX_S32) 0x8000101E,
+
+  /** When the macroblock error reporting is enabled the component returns new error 
+  for every frame that has errors */
+  OMX_ErrorMbErrorsInFrame = (OMX_S32) 0x8000101F,
+
+  /** A component reports this error when it cannot parse or determine the format of an input stream. */
+  OMX_ErrorFormatNotDetected = (OMX_S32) 0x80001020, 
+
+  /** The content open operation failed. */
+  OMX_ErrorContentPipeOpenFailed = (OMX_S32) 0x80001021,
+
+  /** The content creation operation failed. */
+  OMX_ErrorContentPipeCreationFailed = (OMX_S32) 0x80001022,
+
+  /** Separate table information is being used */
+  OMX_ErrorSeperateTablesUsed = (OMX_S32) 0x80001023,
+
+  /** Tunneling is unsupported by the component*/
+  OMX_ErrorTunnelingUnsupported = (OMX_S32) 0x80001024,
+
+  OMX_ErrorKhronosExtensions = (OMX_S32)0x8F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_ErrorVendorStartUnused = (OMX_S32)0x90000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_ErrorMax = 0x7FFFFFFF
+} OMX_ERRORTYPE;
+
+/** @ingroup core */
+typedef OMX_ERRORTYPE (* OMX_COMPONENTINITTYPE)(OMX_IN  OMX_HANDLETYPE hComponent);
+
+/** @ingroup core */
+typedef struct OMX_COMPONENTREGISTERTYPE
+{
+  const char          * pName;       /* Component name, 128 byte limit (including '\0') applies */
+  OMX_COMPONENTINITTYPE pInitialize; /* Component instance initialization function */
+} OMX_COMPONENTREGISTERTYPE;
+
+/** @ingroup core */
+extern OMX_COMPONENTREGISTERTYPE OMX_ComponentRegistered[];
+
+/** @ingroup rpm */
+typedef struct OMX_PRIORITYMGMTTYPE {
+ OMX_U32 nSize;             /**< size of the structure in bytes */
+ OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+ OMX_U32 nGroupPriority;            /**< Priority of the component group */
+ OMX_U32 nGroupID;                  /**< ID of the component group */
+} OMX_PRIORITYMGMTTYPE;
+
+/* Component name and Role names are limited to 128 characters including the terminating '\0'. */
+#define OMX_MAX_STRINGNAME_SIZE 128
+
+/** @ingroup comp */
+typedef struct OMX_PARAM_COMPONENTROLETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U8 cRole[OMX_MAX_STRINGNAME_SIZE];  /**< name of standard component which defines component role */
+} OMX_PARAM_COMPONENTROLETYPE;
+
+/** End of Stream Buffer Flag: 
+  *
+  * A component sets EOS when it has no more data to emit on a particular 
+  * output port. Thus an output port shall set EOS on the last buffer it 
+  * emits. A component's determination of when an output port should 
+  * cease sending data is implemenation specific.
+  * @ingroup buf
+  */
+
+#define OMX_BUFFERFLAG_EOS 0x00000001 
+
+/** Start Time Buffer Flag: 
+ *
+ * The source of a stream (e.g. a demux component) sets the STARTTIME
+ * flag on the buffer that contains the starting timestamp for the
+ * stream. The starting timestamp corresponds to the first data that
+ * should be displayed at startup or after a seek.
+ * The first timestamp of the stream is not necessarily the start time.
+ * For instance, in the case of a seek to a particular video frame, 
+ * the target frame may be an interframe. Thus the first buffer of 
+ * the stream will be the intra-frame preceding the target frame and
+ * the starttime will occur with the target frame (with any other
+ * required frames required to reconstruct the target intervening).
+ *
+ * The STARTTIME flag is directly associated with the buffer's 
+ * timestamp ' thus its association to buffer data and its 
+ * propagation is identical to the timestamp's.
+ *
+ * When a Sync Component client receives a buffer with the 
+ * STARTTIME flag it shall perform a SetConfig on its sync port 
+ * using OMX_ConfigTimeClientStartTime and passing the buffer's
+ * timestamp.
+ * 
+ * @ingroup buf
+ */
+
+#define OMX_BUFFERFLAG_STARTTIME 0x00000002
+
+ 
+
+/** Decode Only Buffer Flag: 
+ *
+ * The source of a stream (e.g. a demux component) sets the DECODEONLY
+ * flag on any buffer that should shall be decoded but should not be
+ * displayed. This flag is used, for instance, when a source seeks to 
+ * a target interframe that requires the decode of frames preceding the 
+ * target to facilitate the target's reconstruction. In this case the 
+ * source would emit the frames preceding the target downstream 
+ * but mark them as decode only.
+ *
+ * The DECODEONLY is associated with buffer data and propagated in a 
+ * manner identical to the buffer timestamp.
+ *
+ * A component that renders data should ignore all buffers with 
+ * the DECODEONLY flag set.
+ * 
+ * @ingroup buf
+ */
+
+#define OMX_BUFFERFLAG_DECODEONLY 0x00000004
+
+
+/* Data Corrupt Flag: This flag is set when the IL client believes the data in the associated buffer is corrupt 
+ * @ingroup buf
+ */
+
+#define OMX_BUFFERFLAG_DATACORRUPT 0x00000008
+
+/* End of Frame: The buffer contains exactly one end of frame and no data
+ *  occurs after the end of frame. This flag is an optional hint. The absence
+ *  of this flag does not imply the absence of an end of frame within the buffer. 
+ * @ingroup buf
+*/
+#define OMX_BUFFERFLAG_ENDOFFRAME 0x00000010
+
+/* Sync Frame Flag: This flag is set when the buffer content contains a coded sync frame ' 
+ *  a frame that has no dependency on any other frame information 
+ *  @ingroup buf
+ */
+#define OMX_BUFFERFLAG_SYNCFRAME 0x00000020
+
+/* Extra data present flag: there is extra data appended to the data stream
+ * residing in the buffer 
+ * @ingroup buf  
+ */
+#define OMX_BUFFERFLAG_EXTRADATA 0x00000040
+
+/** Codec Config Buffer Flag: 
+* OMX_BUFFERFLAG_CODECCONFIG is an optional flag that is set by an
+* output port when all bytes in the buffer form part or all of a set of
+* codec specific configuration data.  Examples include SPS/PPS nal units
+* for OMX_VIDEO_CodingAVC or AudioSpecificConfig data for
+* OMX_AUDIO_CodingAAC.  Any component that for a given stream sets 
+* OMX_BUFFERFLAG_CODECCONFIG shall not mix codec configuration bytes
+* with frame data in the same buffer, and shall send all buffers
+* containing codec configuration bytes before any buffers containing
+* frame data that those configurations bytes describe.
+* If the stream format for a particular codec has a frame specific
+* header at the start of each frame, for example OMX_AUDIO_CodingMP3 or
+* OMX_AUDIO_CodingAAC in ADTS mode, then these shall be presented as
+* normal without setting OMX_BUFFERFLAG_CODECCONFIG.
+ * @ingroup buf
+ */
+#define OMX_BUFFERFLAG_CODECCONFIG 0x00000080
+
+
+
+/** @ingroup buf */
+typedef struct OMX_BUFFERHEADERTYPE
+{
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U8* pBuffer;            /**< Pointer to actual block of memory 
+                                     that is acting as the buffer */
+    OMX_U32 nAllocLen;          /**< size of the buffer allocated, in bytes */
+    OMX_U32 nFilledLen;         /**< number of bytes currently in the 
+                                     buffer */
+    OMX_U32 nOffset;            /**< start offset of valid data in bytes from
+                                     the start of the buffer */
+    OMX_PTR pAppPrivate;        /**< pointer to any data the application
+                                     wants to associate with this buffer */
+    OMX_PTR pPlatformPrivate;   /**< pointer to any data the platform
+                                     wants to associate with this buffer */ 
+    OMX_PTR pInputPortPrivate;  /**< pointer to any data the input port
+                                     wants to associate with this buffer */
+    OMX_PTR pOutputPortPrivate; /**< pointer to any data the output port
+                                     wants to associate with this buffer */
+    OMX_HANDLETYPE hMarkTargetComponent; /**< The component that will generate a 
+                                              mark event upon processing this buffer. */
+    OMX_PTR pMarkData;          /**< Application specific data associated with 
+                                     the mark sent on a mark event to disambiguate 
+                                     this mark from others. */
+    OMX_U32 nTickCount;         /**< Optional entry that the component and
+                                     application can update with a tick count
+                                     when they access the component.  This
+                                     value should be in microseconds.  Since
+                                     this is a value relative to an arbitrary
+                                     starting point, this value cannot be used 
+                                     to determine absolute time.  This is an
+                                     optional entry and not all components
+                                     will update it.*/
+ OMX_TICKS nTimeStamp;          /**< Timestamp corresponding to the sample 
+                                     starting at the first logical sample 
+                                     boundary in the buffer. Timestamps of 
+                                     successive samples within the buffer may
+                                     be inferred by adding the duration of the 
+                                     of the preceding buffer to the timestamp
+                                     of the preceding buffer.*/
+  OMX_U32     nFlags;           /**< buffer specific flags */
+  OMX_U32 nOutputPortIndex;     /**< The index of the output port (if any) using 
+                                     this buffer */
+  OMX_U32 nInputPortIndex;      /**< The index of the input port (if any) using
+                                     this buffer */
+} OMX_BUFFERHEADERTYPE;
+
+/** The OMX_EXTRADATATYPE enumeration is used to define the 
+ * possible extra data payload types.
+ * NB: this enum is binary backwards compatible with the previous
+ * OMX_EXTRADATA_QUANT define.  This should be replaced with
+ * OMX_ExtraDataQuantization.
+ */
+typedef enum OMX_EXTRADATATYPE
+{
+   OMX_ExtraDataNone = 0,                       /**< Indicates that no more extra data sections follow */        
+   OMX_ExtraDataQuantization,                   /**< The data payload contains quantization data */
+   OMX_ExtraDataKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+   OMX_ExtraDataVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+   OMX_ExtraDataMax = 0x7FFFFFFF
+} OMX_EXTRADATATYPE;
+
+
+typedef struct OMX_OTHER_EXTRADATATYPE  {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;               
+    OMX_U32 nPortIndex;
+    OMX_EXTRADATATYPE eType;       /* Extra Data type */
+    OMX_U32 nDataSize;   /* Size of the supporting data to follow */
+    OMX_U8  data[1];     /* Supporting data hint  */
+} OMX_OTHER_EXTRADATATYPE;
+
+/** @ingroup comp */
+typedef struct OMX_PORT_PARAM_TYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPorts;             /**< The number of ports for this component */
+    OMX_U32 nStartPortNumber;   /** first port number for this type of port */
+} OMX_PORT_PARAM_TYPE; 
+
+/** @ingroup comp */
+typedef enum OMX_EVENTTYPE
+{
+    OMX_EventCmdComplete,         /**< component has sucessfully completed a command */
+    OMX_EventError,               /**< component has detected an error condition */
+    OMX_EventMark,                /**< component has detected a buffer mark */
+    OMX_EventPortSettingsChanged, /**< component is reported a port settings change */
+    OMX_EventBufferFlag,          /**< component has detected an EOS */ 
+    OMX_EventResourcesAcquired,   /**< component has been granted resources and is
+                                       automatically starting the state change from
+                                       OMX_StateWaitForResources to OMX_StateIdle. */
+   OMX_EventComponentResumed,     /**< Component resumed due to reacquisition of resources */
+   OMX_EventDynamicResourcesAvailable, /**< Component has acquired previously unavailable dynamic resources */
+   OMX_EventPortFormatDetected,      /**< Component has detected a supported format. */
+   OMX_EventKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+   OMX_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+   OMX_EventMax = 0x7FFFFFFF
+} OMX_EVENTTYPE;
+
+typedef struct OMX_CALLBACKTYPE
+{
+    /** The EventHandler method is used to notify the application when an
+        event of interest occurs.  Events are defined in the OMX_EVENTTYPE
+        enumeration.  Please see that enumeration for details of what will
+        be returned for each type of event. Callbacks should not return
+        an error to the component, so if an error occurs, the application 
+        shall handle it internally.  This is a blocking call.
+
+        The application should return from this call within 5 msec to avoid
+        blocking the component for an excessively long period of time.
+
+        @param hComponent
+            handle of the component to access.  This is the component
+            handle returned by the call to the GetHandle function.
+        @param pAppData
+            pointer to an application defined value that was provided in the 
+            pAppData parameter to the OMX_GetHandle method for the component.
+            This application defined value is provided so that the application 
+            can have a component specific context when receiving the callback.
+        @param eEvent
+            Event that the component wants to notify the application about.
+        @param nData1
+            nData will be the OMX_ERRORTYPE for an error event and will be 
+            an OMX_COMMANDTYPE for a command complete event and OMX_INDEXTYPE for a OMX_PortSettingsChanged event.
+         @param nData2
+            nData2 will hold further information related to the event. Can be OMX_STATETYPE for
+            a OMX_CommandStateSet command or port index for a OMX_PortSettingsChanged event.
+            Default value is 0 if not used. )
+        @param pEventData
+            Pointer to additional event-specific data (see spec for meaning).
+      */
+
+   OMX_ERRORTYPE (*EventHandler)(
+        OMX_IN OMX_HANDLETYPE hComponent,
+        OMX_IN OMX_PTR pAppData,
+        OMX_IN OMX_EVENTTYPE eEvent,
+        OMX_IN OMX_U32 nData1,
+        OMX_IN OMX_U32 nData2,
+        OMX_IN OMX_PTR pEventData);
+
+    /** The EmptyBufferDone method is used to return emptied buffers from an
+        input port back to the application for reuse.  This is a blocking call 
+        so the application should not attempt to refill the buffers during this
+        call, but should queue them and refill them in another thread.  There
+        is no error return, so the application shall handle any errors generated
+        internally.  
+        
+        The application should return from this call within 5 msec.
+        
+        @param hComponent
+            handle of the component to access.  This is the component
+            handle returned by the call to the GetHandle function.
+        @param pAppData
+            pointer to an application defined value that was provided in the 
+            pAppData parameter to the OMX_GetHandle method for the component.
+            This application defined value is provided so that the application 
+            can have a component specific context when receiving the callback.
+        @param pBuffer
+            pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+            or AllocateBuffer indicating the buffer that was emptied.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*EmptyBufferDone)(
+        OMX_IN OMX_HANDLETYPE hComponent,
+        OMX_IN OMX_PTR pAppData,
+        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
+
+    /** The FillBufferDone method is used to return filled buffers from an
+        output port back to the application for emptying and then reuse.  
+        This is a blocking call so the application should not attempt to 
+        empty the buffers during this call, but should queue the buffers 
+        and empty them in another thread.  There is no error return, so 
+        the application shall handle any errors generated internally.  The 
+        application shall also update the buffer header to indicate the
+        number of bytes placed into the buffer.  
+
+        The application should return from this call within 5 msec.
+        
+        @param hComponent
+            handle of the component to access.  This is the component
+            handle returned by the call to the GetHandle function.
+        @param pAppData
+            pointer to an application defined value that was provided in the 
+            pAppData parameter to the OMX_GetHandle method for the component.
+            This application defined value is provided so that the application 
+            can have a component specific context when receiving the callback.
+        @param pBuffer
+            pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+            or AllocateBuffer indicating the buffer that was filled.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*FillBufferDone)(
+        OMX_OUT OMX_HANDLETYPE hComponent,
+        OMX_OUT OMX_PTR pAppData,
+        OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer);
+
+} OMX_CALLBACKTYPE;
+
+/** The OMX_BUFFERSUPPLIERTYPE enumeration is used to dictate port supplier
+    preference when tunneling between two ports.
+    @ingroup tun buf
+*/
+typedef enum OMX_BUFFERSUPPLIERTYPE
+{
+    OMX_BufferSupplyUnspecified = 0x0, /**< port supplying the buffers is unspecified,
+                                              or don't care */
+    OMX_BufferSupplyInput,             /**< input port supplies the buffers */
+    OMX_BufferSupplyOutput,            /**< output port supplies the buffers */
+    OMX_BufferSupplyKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_BufferSupplyVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_BufferSupplyMax = 0x7FFFFFFF
+} OMX_BUFFERSUPPLIERTYPE;
+
+
+/** buffer supplier parameter 
+ * @ingroup tun
+ */
+typedef struct OMX_PARAM_BUFFERSUPPLIERTYPE {
+    OMX_U32 nSize; /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex; /**< port that this structure applies to */
+    OMX_BUFFERSUPPLIERTYPE eBufferSupplier; /**< buffer supplier */
+} OMX_PARAM_BUFFERSUPPLIERTYPE;
+
+
+/**< indicates that buffers received by an input port of a tunnel 
+     may not modify the data in the buffers 
+     @ingroup tun
+ */
+#define OMX_PORTTUNNELFLAG_READONLY 0x00000001 
+
+
+/** The OMX_TUNNELSETUPTYPE structure is used to pass data from an output
+    port to an input port as part the two ComponentTunnelRequest calls
+    resulting from a OMX_SetupTunnel call from the IL Client. 
+    @ingroup tun
+ */   
+typedef struct OMX_TUNNELSETUPTYPE
+{
+    OMX_U32 nTunnelFlags;             /**< bit flags for tunneling */
+    OMX_BUFFERSUPPLIERTYPE eSupplier; /**< supplier preference */
+} OMX_TUNNELSETUPTYPE; 
+
+/* OMX Component headers is included to enable the core to use
+   macros for functions into the component for OMX release 1.0.  
+   Developers should not access any structures or data from within
+   the component header directly */
+/* TO BE REMOVED - #include <OMX_Component.h> */
+
+/** GetComponentVersion will return information about the component.  
+    This is a blocking call.  This macro will go directly from the
+    application to the component (via a core macro).  The
+    component will return from this call within 5 msec.
+    @param [in] hComponent
+        handle of component to execute the command
+    @param [out] pComponentName
+        pointer to an empty string of length 128 bytes.  The component 
+        will write its name into this string.  The name will be 
+        terminated by a single zero byte.  The name of a component will 
+        be 127 bytes or less to leave room for the trailing zero byte.  
+        An example of a valid component name is "OMX.ABC.ChannelMixer\0".
+    @param [out] pComponentVersion
+        pointer to an OMX Version structure that the component will fill 
+        in.  The component will fill in a value that indicates the 
+        component version.  NOTE: the component version is NOT the same 
+        as the OMX Specification version (found in all structures).  The 
+        component version is defined by the vendor of the component and 
+        its value is entirely up to the component vendor.
+    @param [out] pSpecVersion
+        pointer to an OMX Version structure that the component will fill 
+        in.  The SpecVersion is the version of the specification that the 
+        component was built against.  Please note that this value may or 
+        may not match the structure's version.  For example, if the 
+        component was built against the 2.0 specification, but the 
+        application (which creates the structure is built against the 
+        1.0 specification the versions would be different.
+    @param [out] pComponentUUID
+        pointer to the UUID of the component which will be filled in by 
+        the component.  The UUID is a unique identifier that is set at 
+        RUN time for the component and is unique to each instantion of 
+        the component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_GetComponentVersion(                            \
+        hComponent,                                         \
+        pComponentName,                                     \
+        pComponentVersion,                                  \
+        pSpecVersion,                                       \
+        pComponentUUID)                                     \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetComponentVersion(  \
+        hComponent,                                         \
+        pComponentName,                                     \
+        pComponentVersion,                                  \
+        pSpecVersion,                                       \
+        pComponentUUID)                 /* Macro End */
+
+
+/** Send a command to the component.  This call is a non-blocking call.
+    The component should check the parameters and then queue the command
+    to the component thread to be executed.  The component thread shall 
+    send the EventHandler() callback at the conclusion of the command. 
+    This macro will go directly from the application to the component (via
+    a core macro).  The component will return from this call within 5 msec.
+    
+    When the command is "OMX_CommandStateSet" the component will queue a
+    state transition to the new state idenfied in nParam.
+    
+    When the command is "OMX_CommandFlush", to flush a port's buffer queues,
+    the command will force the component to return all buffers NOT CURRENTLY 
+    BEING PROCESSED to the application, in the order in which the buffers 
+    were received.
+    
+    When the command is "OMX_CommandPortDisable" or 
+    "OMX_CommandPortEnable", the component's port (given by the value of
+    nParam) will be stopped or restarted. 
+    
+    When the command "OMX_CommandMarkBuffer" is used to mark a buffer, the
+    pCmdData will point to a OMX_MARKTYPE structure containing the component
+    handle of the component to examine the buffer chain for the mark.  nParam1
+    contains the index of the port on which the buffer mark is applied.
+
+    Specification text for more details. 
+    
+    @param [in] hComponent
+        handle of component to execute the command
+    @param [in] Cmd
+        Command for the component to execute
+    @param [in] nParam
+        Parameter for the command to be executed.  When Cmd has the value 
+        OMX_CommandStateSet, value is a member of OMX_STATETYPE.  When Cmd has 
+        the value OMX_CommandFlush, value of nParam indicates which port(s) 
+        to flush. -1 is used to flush all ports a single port index will 
+        only flush that port.  When Cmd has the value "OMX_CommandPortDisable"
+        or "OMX_CommandPortEnable", the component's port is given by 
+        the value of nParam.  When Cmd has the value "OMX_CommandMarkBuffer"
+        the components pot is given by the value of nParam.
+    @param [in] pCmdData
+        Parameter pointing to the OMX_MARKTYPE structure when Cmd has the value
+        "OMX_CommandMarkBuffer".     
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_SendCommand(                                    \
+         hComponent,                                        \
+         Cmd,                                               \
+         nParam,                                            \
+         pCmdData)                                          \
+     ((OMX_COMPONENTTYPE*)hComponent)->SendCommand(         \
+         hComponent,                                        \
+         Cmd,                                               \
+         nParam,                                            \
+         pCmdData)                          /* Macro End */
+
+
+/** The OMX_GetParameter macro will get one of the current parameter 
+    settings from the component.  This macro cannot only be invoked when 
+    the component is in the OMX_StateInvalid state.  The nParamIndex
+    parameter is used to indicate which structure is being requested from
+    the component.  The application shall allocate the correct structure 
+    and shall fill in the structure size and version information before 
+    invoking this macro.  When the parameter applies to a port, the
+    caller shall fill in the appropriate nPortIndex value indicating the
+    port on which the parameter applies. If the component has not had 
+    any settings changed, then the component should return a set of 
+    valid DEFAULT  parameters for the component.  This is a blocking 
+    call.  
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nParamIndex
+        Index of the structure to be filled.  This value is from the
+        OMX_INDEXTYPE enumeration.
+    @param [in,out] pComponentParameterStructure
+        Pointer to application allocated structure to be filled by the 
+        component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_GetParameter(                                   \
+        hComponent,                                         \
+        nParamIndex,                                        \
+        pComponentParameterStructure)                        \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetParameter(         \
+        hComponent,                                         \
+        nParamIndex,                                        \
+        pComponentParameterStructure)    /* Macro End */
+
+
+/** The OMX_SetParameter macro will send an initialization parameter
+    structure to a component.  Each structure shall be sent one at a time,
+    in a separate invocation of the macro.  This macro can only be
+    invoked when the component is in the OMX_StateLoaded state, or the
+    port is disabled (when the parameter applies to a port). The 
+    nParamIndex parameter is used to indicate which structure is being
+    passed to the component.  The application shall allocate the 
+    correct structure and shall fill in the structure size and version 
+    information (as well as the actual data) before invoking this macro.
+    The application is free to dispose of this structure after the call
+    as the component is required to copy any data it shall retain.  This 
+    is a blocking call.  
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nIndex
+        Index of the structure to be sent.  This value is from the
+        OMX_INDEXTYPE enumeration.
+    @param [in] pComponentParameterStructure
+        pointer to application allocated structure to be used for
+        initialization by the component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_SetParameter(                                   \
+        hComponent,                                         \
+        nParamIndex,                                        \
+        pComponentParameterStructure)                        \
+    ((OMX_COMPONENTTYPE*)hComponent)->SetParameter(         \
+        hComponent,                                         \
+        nParamIndex,                                        \
+        pComponentParameterStructure)    /* Macro End */
+
+
+/** The OMX_GetConfig macro will get one of the configuration structures 
+    from a component.  This macro can be invoked anytime after the 
+    component has been loaded.  The nParamIndex call parameter is used to 
+    indicate which structure is being requested from the component.  The 
+    application shall allocate the correct structure and shall fill in the 
+    structure size and version information before invoking this macro.  
+    If the component has not had this configuration parameter sent before, 
+    then the component should return a set of valid DEFAULT values for the 
+    component.  This is a blocking call.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nIndex
+        Index of the structure to be filled.  This value is from the
+        OMX_INDEXTYPE enumeration.
+    @param [in,out] pComponentConfigStructure
+        pointer to application allocated structure to be filled by the 
+        component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+*/        
+#define OMX_GetConfig(                                      \
+        hComponent,                                         \
+        nConfigIndex,                                       \
+        pComponentConfigStructure)                           \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetConfig(            \
+        hComponent,                                         \
+        nConfigIndex,                                       \
+        pComponentConfigStructure)       /* Macro End */
+
+
+/** The OMX_SetConfig macro will send one of the configuration 
+    structures to a component.  Each structure shall be sent one at a time,
+    each in a separate invocation of the macro.  This macro can be invoked 
+    anytime after the component has been loaded.  The application shall 
+    allocate the correct structure and shall fill in the structure size 
+    and version information (as well as the actual data) before invoking 
+    this macro.  The application is free to dispose of this structure after 
+    the call as the component is required to copy any data it shall retain.  
+    This is a blocking call.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nConfigIndex
+        Index of the structure to be sent.  This value is from the
+        OMX_INDEXTYPE enumeration above.
+    @param [in] pComponentConfigStructure
+        pointer to application allocated structure to be used for
+        initialization by the component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_SetConfig(                                      \
+        hComponent,                                         \
+        nConfigIndex,                                       \
+        pComponentConfigStructure)                           \
+    ((OMX_COMPONENTTYPE*)hComponent)->SetConfig(            \
+        hComponent,                                         \
+        nConfigIndex,                                       \
+        pComponentConfigStructure)       /* Macro End */
+
+
+/** The OMX_GetExtensionIndex macro will invoke a component to translate 
+    a vendor specific configuration or parameter string into an OMX 
+    structure index.  There is no requirement for the vendor to support 
+    this command for the indexes already found in the OMX_INDEXTYPE 
+    enumeration (this is done to save space in small components).  The 
+    component shall support all vendor supplied extension indexes not found
+    in the master OMX_INDEXTYPE enumeration.  This is a blocking call.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the GetHandle function.
+    @param [in] cParameterName
+        OMX_STRING that shall be less than 128 characters long including
+        the trailing null byte.  This is the string that will get 
+        translated by the component into a configuration index.
+    @param [out] pIndexType
+        a pointer to a OMX_INDEXTYPE to receive the index value.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_GetExtensionIndex(                              \
+        hComponent,                                         \
+        cParameterName,                                     \
+        pIndexType)                                         \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetExtensionIndex(    \
+        hComponent,                                         \
+        cParameterName,                                     \
+        pIndexType)                     /* Macro End */
+
+
+/** The OMX_GetState macro will invoke the component to get the current 
+    state of the component and place the state value into the location
+    pointed to by pState.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [out] pState
+        pointer to the location to receive the state.  The value returned
+        is one of the OMX_STATETYPE members 
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_GetState(                                       \
+        hComponent,                                         \
+        pState)                                             \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetState(             \
+        hComponent,                                         \
+        pState)                         /* Macro End */
+
+
+/** The OMX_UseBuffer macro will request that the component use
+    a buffer (and allocate its own buffer header) already allocated 
+    by another component, or by the IL Client. This is a blocking 
+    call.
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [out] ppBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure used to receive the 
+        pointer to the buffer header
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+
+#define OMX_UseBuffer(                                      \
+           hComponent,                                      \
+           ppBufferHdr,                                     \
+           nPortIndex,                                      \
+           pAppPrivate,                                     \
+           nSizeBytes,                                      \
+           pBuffer)                                         \
+    ((OMX_COMPONENTTYPE*)hComponent)->UseBuffer(            \
+           hComponent,                                      \
+           ppBufferHdr,                                     \
+           nPortIndex,                                      \
+           pAppPrivate,                                     \
+           nSizeBytes,                                      \
+           pBuffer)
+
+
+/** The OMX_AllocateBuffer macro will request that the component allocate 
+    a new buffer and buffer header.  The component will allocate the 
+    buffer and the buffer header and return a pointer to the buffer 
+    header.  This is a blocking call.
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [out] ppBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure used to receive 
+        the pointer to the buffer header
+    @param [in] nPortIndex
+        nPortIndex is used to select the port on the component the buffer will
+        be used with.  The port can be found by using the nPortIndex
+        value as an index into the Port Definition array of the component.
+    @param [in] pAppPrivate
+        pAppPrivate is used to initialize the pAppPrivate member of the 
+        buffer header structure.
+    @param [in] nSizeBytes
+        size of the buffer to allocate.  Used when bAllocateNew is true.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */    
+#define OMX_AllocateBuffer(                                 \
+        hComponent,                                         \
+        ppBuffer,                                           \
+        nPortIndex,                                         \
+        pAppPrivate,                                        \
+        nSizeBytes)                                         \
+    ((OMX_COMPONENTTYPE*)hComponent)->AllocateBuffer(       \
+        hComponent,                                         \
+        ppBuffer,                                           \
+        nPortIndex,                                         \
+        pAppPrivate,                                        \
+        nSizeBytes)                     /* Macro End */
+
+
+/** The OMX_FreeBuffer macro will release a buffer header from the component
+    which was allocated using either OMX_AllocateBuffer or OMX_UseBuffer. If  
+    the component allocated the buffer (see the OMX_UseBuffer macro) then 
+    the component shall free the buffer and buffer header. This is a 
+    blocking call. 
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nPortIndex
+        nPortIndex is used to select the port on the component the buffer will
+        be used with.
+    @param [in] pBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+        or AllocateBuffer.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+#define OMX_FreeBuffer(                                     \
+        hComponent,                                         \
+        nPortIndex,                                         \
+        pBuffer)                                            \
+    ((OMX_COMPONENTTYPE*)hComponent)->FreeBuffer(           \
+        hComponent,                                         \
+        nPortIndex,                                         \
+        pBuffer)                        /* Macro End */
+
+
+/** The OMX_EmptyThisBuffer macro will send a buffer full of data to an 
+    input port of a component.  The buffer will be emptied by the component
+    and returned to the application via the EmptyBufferDone call back.
+    This is a non-blocking call in that the component will record the buffer
+    and return immediately and then empty the buffer, later, at the proper 
+    time.  As expected, this macro may be invoked only while the component 
+    is in the OMX_StateExecuting.  If nPortIndex does not specify an input
+    port, the component shall return an error.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] pBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+        or AllocateBuffer.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+#define OMX_EmptyThisBuffer(                                \
+        hComponent,                                         \
+        pBuffer)                                            \
+    ((OMX_COMPONENTTYPE*)hComponent)->EmptyThisBuffer(      \
+        hComponent,                                         \
+        pBuffer)                        /* Macro End */
+
+
+/** The OMX_FillThisBuffer macro will send an empty buffer to an 
+    output port of a component.  The buffer will be filled by the component
+    and returned to the application via the FillBufferDone call back.
+    This is a non-blocking call in that the component will record the buffer
+    and return immediately and then fill the buffer, later, at the proper 
+    time.  As expected, this macro may be invoked only while the component 
+    is in the OMX_ExecutingState.  If nPortIndex does not specify an output
+    port, the component shall return an error.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] pBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+        or AllocateBuffer.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+#define OMX_FillThisBuffer(                                 \
+        hComponent,                                         \
+        pBuffer)                                            \
+    ((OMX_COMPONENTTYPE*)hComponent)->FillThisBuffer(       \
+        hComponent,                                         \
+        pBuffer)                        /* Macro End */
+
+
+
+/** The OMX_UseEGLImage macro will request that the component use
+    a EGLImage provided by EGL (and allocate its own buffer header)
+    This is a blocking call.
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [out] ppBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure used to receive the 
+        pointer to the buffer header.  Note that the memory location used
+        for this buffer is NOT visible to the IL Client.
+    @param [in] nPortIndex
+        nPortIndex is used to select the port on the component the buffer will
+        be used with.  The port can be found by using the nPortIndex
+        value as an index into the Port Definition array of the component.
+    @param [in] pAppPrivate
+        pAppPrivate is used to initialize the pAppPrivate member of the 
+        buffer header structure.
+    @param [in] eglImage
+        eglImage contains the handle of the EGLImage to use as a buffer on the
+        specified port.  The component is expected to validate properties of 
+        the EGLImage against the configuration of the port to ensure the component
+        can use the EGLImage as a buffer.          
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+#define OMX_UseEGLImage(                                    \
+           hComponent,                                      \
+           ppBufferHdr,                                     \
+           nPortIndex,                                      \
+           pAppPrivate,                                     \
+           eglImage)                                        \
+    ((OMX_COMPONENTTYPE*)hComponent)->UseEGLImage(          \
+           hComponent,                                      \
+           ppBufferHdr,                                     \
+           nPortIndex,                                      \
+           pAppPrivate,                                     \
+           eglImage)
+
+/** The OMX_Init method is used to initialize the OMX core.  It shall be the
+    first call made into OMX and it should only be executed one time without
+    an interviening OMX_Deinit call.  
+    
+    The core should return from this call within 20 msec.
+
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Init(void);
+
+
+/** The OMX_Deinit method is used to deinitialize the OMX core.  It shall be 
+    the last call made into OMX. In the event that the core determines that 
+    thare are components loaded when this call is made, the core may return 
+    with an error rather than try to unload the components.
+        
+    The core should return from this call within 20 msec.
+    
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Deinit(void);
+
+
+/** The OMX_ComponentNameEnum method will enumerate through all the names of
+    recognised valid components in the system. This function is provided
+    as a means to detect all the components in the system run-time. There is
+    no strict ordering to the enumeration order of component names, although
+    each name will only be enumerated once.  If the OMX core supports run-time
+    installation of new components, it is only requried to detect newly
+    installed components when the first call to enumerate component names
+    is made (i.e. when nIndex is 0x0).
+    
+    The core should return from this call in 20 msec.
+    
+    @param [out] cComponentName
+        pointer to a null terminated string with the component name.  The
+        names of the components are strings less than 127 bytes in length
+        plus the trailing null for a maximum size of 128 bytes.  An example 
+        of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0".  Names are 
+        assigned by the vendor, but shall start with "OMX." and then have 
+        the Vendor designation next.
+    @param [in] nNameLength
+        number of characters in the cComponentName string.  With all 
+        component name strings restricted to less than 128 characters 
+        (including the trailing null) it is recomended that the caller
+        provide a input string for the cComponentName of 128 characters.
+    @param [in] nIndex
+        number containing the enumeration index for the component. 
+        Multiple calls to OMX_ComponentNameEnum with increasing values
+        of nIndex will enumerate through the component names in the
+        system until OMX_ErrorNoMore is returned.  The value of nIndex
+        is 0 to (N-1), where N is the number of valid installed components
+        in the system.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  When the value of nIndex exceeds the number of 
+        components in the system minus 1, OMX_ErrorNoMore will be
+        returned. Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_ComponentNameEnum(
+    OMX_OUT OMX_STRING cComponentName,
+    OMX_IN  OMX_U32 nNameLength,
+    OMX_IN  OMX_U32 nIndex);
+
+
+/** The OMX_GetHandle method will locate the component specified by the
+    component name given, load that component into memory and then invoke
+    the component's methods to create an instance of the component.  
+    
+    The core should return from this call within 20 msec.
+    
+    @param [out] pHandle
+        pointer to an OMX_HANDLETYPE pointer to be filled in by this method.
+    @param [in] cComponentName
+        pointer to a null terminated string with the component name.  The
+        names of the components are strings less than 127 bytes in length
+        plus the trailing null for a maximum size of 128 bytes.  An example 
+        of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0".  Names are 
+        assigned by the vendor, but shall start with "OMX." and then have 
+        the Vendor designation next.
+    @param [in] pAppData
+        pointer to an application defined value that will be returned
+        during callbacks so that the application can identify the source
+        of the callback.
+    @param [in] pCallBacks
+        pointer to a OMX_CALLBACKTYPE structure that will be passed to the
+        component to initialize it with.  
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_GetHandle(
+    OMX_OUT OMX_HANDLETYPE* pHandle, 
+    OMX_IN  OMX_STRING cComponentName,
+    OMX_IN  OMX_PTR pAppData,
+    OMX_IN  OMX_CALLBACKTYPE* pCallBacks);
+
+
+/** The OMX_FreeHandle method will free a handle allocated by the OMX_GetHandle 
+    method.  If the component reference count goes to zero, the component will
+    be unloaded from memory.  
+    
+    The core should return from this call within 20 msec when the component is 
+    in the OMX_StateLoaded state.
+
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the GetHandle function.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_FreeHandle(
+    OMX_IN  OMX_HANDLETYPE hComponent);
+
+
+
+/** The OMX_SetupTunnel method will handle the necessary calls to the components
+    to setup the specified tunnel the two components.  NOTE: This is
+    an actual method (not a #define macro).  This method will make calls into
+    the component ComponentTunnelRequest method to do the actual tunnel 
+    connection.  
+
+    The ComponentTunnelRequest method on both components will be called. 
+    This method shall not be called unless the component is in the 
+    OMX_StateLoaded state except when the ports used for the tunnel are
+    disabled. In this case, the component may be in the OMX_StateExecuting,
+    OMX_StatePause, or OMX_StateIdle states. 
+
+    The core should return from this call within 20 msec.
+    
+    @param [in] hOutput
+        Handle of the component to be accessed.  Also this is the handle
+        of the component whose port, specified in the nPortOutput parameter
+        will be used the source for the tunnel. This is the component handle
+        returned by the call to the OMX_GetHandle function.  There is a 
+        requirement that hOutput be the source for the data when
+        tunelling (i.e. nPortOutput is an output port).  If 0x0, the component
+        specified in hInput will have it's port specified in nPortInput
+        setup for communication with the application / IL client.
+    @param [in] nPortOutput
+        nPortOutput is used to select the source port on component to be
+        used in the tunnel. 
+    @param [in] hInput
+        This is the component to setup the tunnel with. This is the handle
+        of the component whose port, specified in the nPortInput parameter
+        will be used the destination for the tunnel. This is the component handle
+        returned by the call to the OMX_GetHandle function.  There is a 
+        requirement that hInput be the destination for the data when
+        tunelling (i.e. nPortInut is an input port).   If 0x0, the component
+        specified in hOutput will have it's port specified in nPortPOutput
+        setup for communication with the application / IL client.
+    @param [in] nPortInput
+        nPortInput is used to select the destination port on component to be
+        used in the tunnel.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+        When OMX_ErrorNotImplemented is returned, one or both components is 
+        a non-interop component and does not support tunneling.
+        
+        On failure, the ports of both components are setup for communication
+        with the application / IL Client.
+    @ingroup core tun
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_SetupTunnel(
+    OMX_IN  OMX_HANDLETYPE hOutput,
+    OMX_IN  OMX_U32 nPortOutput,
+    OMX_IN  OMX_HANDLETYPE hInput,
+    OMX_IN  OMX_U32 nPortInput);
+    
+/** @ingroup cp */
+OMX_API OMX_ERRORTYPE   OMX_GetContentPipe(
+    OMX_OUT OMX_HANDLETYPE *hPipe,
+    OMX_IN OMX_STRING szURI);
+
+/** The OMX_GetComponentsOfRole method will return the number of components that support the given
+    role and (if the compNames field is non-NULL) the names of those components. The call will fail if 
+    an insufficiently sized array of names is supplied. To ensure the array is sufficiently sized the
+    client should:
+        * first call this function with the compNames field NULL to determine the number of component names
+        * second call this function with the compNames field pointing to an array of names allocated 
+          according to the number returned by the first call.
+
+    The core should return from this call within 5 msec.
+    
+    @param [in] role
+        This is generic standard component name consisting only of component class 
+        name and the type within that class (e.g. 'audio_decoder.aac').
+    @param [inout] pNumComps
+        This is used both as input and output. 
+ 
+        If compNames is NULL, the input is ignored and the output specifies how many components support
+        the given role.
+     
+        If compNames is not NULL, on input it bounds the size of the input structure and 
+        on output, it specifies the number of components string names listed within the compNames parameter.
+    @param [inout] compNames
+        If NULL this field is ignored. If non-NULL this points to an array of 128-byte strings which accepts 
+        a list of the names of all physical components that implement the specified standard component name. 
+        Each name is NULL terminated. numComps indicates the number of names.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_GetComponentsOfRole ( 
+	OMX_IN      OMX_STRING role,
+    OMX_INOUT   OMX_U32 *pNumComps,
+    OMX_INOUT   OMX_U8  **compNames);
+
+/** The OMX_GetRolesOfComponent method will return the number of roles supported by the given
+    component and (if the roles field is non-NULL) the names of those roles. The call will fail if 
+    an insufficiently sized array of names is supplied. To ensure the array is sufficiently sized the
+    client should:
+        * first call this function with the roles field NULL to determine the number of role names
+        * second call this function with the roles field pointing to an array of names allocated 
+          according to the number returned by the first call.
+
+    The core should return from this call within 5 msec.
+
+    @param [in] compName
+        This is the name of the component being queried about.
+    @param [inout] pNumRoles
+        This is used both as input and output. 
+ 
+        If roles is NULL, the input is ignored and the output specifies how many roles the component supports.
+     
+        If compNames is not NULL, on input it bounds the size of the input structure and 
+        on output, it specifies the number of roles string names listed within the roles parameter.
+    @param [out] roles
+        If NULL this field is ignored. If non-NULL this points to an array of 128-byte strings 
+        which accepts a list of the names of all standard components roles implemented on the 
+        specified component name. numComps indicates the number of names.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_GetRolesOfComponent ( 
+	OMX_IN      OMX_STRING compName, 
+    OMX_INOUT   OMX_U32 *pNumRoles,
+    OMX_OUT     OMX_U8 **roles);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
+
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_IVCommon.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_IVCommon.h
new file mode 100644
index 0000000..4c4995c
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_IVCommon.h
@@ -0,0 +1,920 @@
+/**
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** 
+ * @file OMX_IVCommon.h - OpenMax IL version 1.1.2
+ *  The structures needed by Video and Image components to exchange
+ *  parameters and configuration data with the components.
+ */
+#ifndef OMX_IVCommon_h
+#define OMX_IVCommon_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * Each OMX header must include all required header files to allow the header
+ * to compile without errors.  The includes below are required for this header
+ * file to compile successfully 
+ */
+
+#include <OMX_Core.h>
+
+/** @defgroup iv OpenMAX IL Imaging and Video Domain
+ * Common structures for OpenMAX IL Imaging and Video domains
+ * @{
+ */
+
+
+/** 
+ * Enumeration defining possible uncompressed image/video formats. 
+ *
+ * ENUMS:
+ *  Unused                 : Placeholder value when format is N/A
+ *  Monochrome             : black and white
+ *  8bitRGB332             : Red 7:5, Green 4:2, Blue 1:0
+ *  12bitRGB444            : Red 11:8, Green 7:4, Blue 3:0
+ *  16bitARGB4444          : Alpha 15:12, Red 11:8, Green 7:4, Blue 3:0
+ *  16bitARGB1555          : Alpha 15, Red 14:10, Green 9:5, Blue 4:0
+ *  16bitRGB565            : Red 15:11, Green 10:5, Blue 4:0
+ *  16bitBGR565            : Blue 15:11, Green 10:5, Red 4:0
+ *  18bitRGB666            : Red 17:12, Green 11:6, Blue 5:0
+ *  18bitARGB1665          : Alpha 17, Red 16:11, Green 10:5, Blue 4:0
+ *  19bitARGB1666          : Alpha 18, Red 17:12, Green 11:6, Blue 5:0
+ *  24bitRGB888            : Red 24:16, Green 15:8, Blue 7:0
+ *  24bitBGR888            : Blue 24:16, Green 15:8, Red 7:0
+ *  24bitARGB1887          : Alpha 23, Red 22:15, Green 14:7, Blue 6:0
+ *  25bitARGB1888          : Alpha 24, Red 23:16, Green 15:8, Blue 7:0
+ *  32bitBGRA8888          : Blue 31:24, Green 23:16, Red 15:8, Alpha 7:0
+ *  32bitARGB8888          : Alpha 31:24, Red 23:16, Green 15:8, Blue 7:0
+ *  YUV411Planar           : U,Y are subsampled by a factor of 4 horizontally
+ *  YUV411PackedPlanar     : packed per payload in planar slices
+ *  YUV420Planar           : Three arrays Y,U,V.
+ *  YUV420PackedPlanar     : packed per payload in planar slices
+ *  YUV420SemiPlanar       : Two arrays, one is all Y, the other is U and V
+ *  YUV422Planar           : Three arrays Y,U,V.
+ *  YUV422PackedPlanar     : packed per payload in planar slices
+ *  YUV422SemiPlanar       : Two arrays, one is all Y, the other is U and V
+ *  YCbYCr                 : Organized as 16bit YUYV (i.e. YCbYCr)
+ *  YCrYCb                 : Organized as 16bit YVYU (i.e. YCrYCb)
+ *  CbYCrY                 : Organized as 16bit UYVY (i.e. CbYCrY)
+ *  CrYCbY                 : Organized as 16bit VYUY (i.e. CrYCbY)
+ *  YUV444Interleaved      : Each pixel contains equal parts YUV
+ *  RawBayer8bit           : SMIA camera output format
+ *  RawBayer10bit          : SMIA camera output format
+ *  RawBayer8bitcompressed : SMIA camera output format
+ */
+typedef enum OMX_COLOR_FORMATTYPE {
+    OMX_COLOR_FormatUnused,
+    OMX_COLOR_FormatMonochrome,
+    OMX_COLOR_Format8bitRGB332,
+    OMX_COLOR_Format12bitRGB444,
+    OMX_COLOR_Format16bitARGB4444,
+    OMX_COLOR_Format16bitARGB1555,
+    OMX_COLOR_Format16bitRGB565,
+    OMX_COLOR_Format16bitBGR565,
+    OMX_COLOR_Format18bitRGB666,
+    OMX_COLOR_Format18bitARGB1665,
+    OMX_COLOR_Format19bitARGB1666, 
+    OMX_COLOR_Format24bitRGB888,
+    OMX_COLOR_Format24bitBGR888,
+    OMX_COLOR_Format24bitARGB1887,
+    OMX_COLOR_Format25bitARGB1888,
+    OMX_COLOR_Format32bitBGRA8888,
+    OMX_COLOR_Format32bitARGB8888,
+    OMX_COLOR_FormatYUV411Planar,
+    OMX_COLOR_FormatYUV411PackedPlanar,
+    OMX_COLOR_FormatYUV420Planar,
+    OMX_COLOR_FormatYUV420PackedPlanar,
+    OMX_COLOR_FormatYUV420SemiPlanar,
+    OMX_COLOR_FormatYUV422Planar,
+    OMX_COLOR_FormatYUV422PackedPlanar,
+    OMX_COLOR_FormatYUV422SemiPlanar,
+    OMX_COLOR_FormatYCbYCr,
+    OMX_COLOR_FormatYCrYCb,
+    OMX_COLOR_FormatCbYCrY,
+    OMX_COLOR_FormatCrYCbY,
+    OMX_COLOR_FormatYUV444Interleaved,
+    OMX_COLOR_FormatRawBayer8bit,
+    OMX_COLOR_FormatRawBayer10bit,
+    OMX_COLOR_FormatRawBayer8bitcompressed,
+    OMX_COLOR_FormatL2, 
+    OMX_COLOR_FormatL4, 
+    OMX_COLOR_FormatL8, 
+    OMX_COLOR_FormatL16, 
+    OMX_COLOR_FormatL24, 
+    OMX_COLOR_FormatL32,
+    OMX_COLOR_FormatYUV420PackedSemiPlanar,
+    OMX_COLOR_FormatYUV422PackedSemiPlanar,
+    OMX_COLOR_Format18BitBGR666,
+    OMX_COLOR_Format24BitARGB6666,
+    OMX_COLOR_Format24BitABGR6666,
+    OMX_COLOR_FormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_COLOR_FormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_COLOR_FormatMax = 0x7FFFFFFF
+} OMX_COLOR_FORMATTYPE;
+
+
+/** 
+ * Defines the matrix for conversion from RGB to YUV or vice versa.
+ * iColorMatrix should be initialized with the fixed point values 
+ * used in converting between formats.
+ */
+typedef struct OMX_CONFIG_COLORCONVERSIONTYPE {
+    OMX_U32 nSize;              /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version info */ 
+    OMX_U32 nPortIndex;         /**< Port that this struct applies to */
+    OMX_S32 xColorMatrix[3][3]; /**< Stored in signed Q16 format */
+    OMX_S32 xColorOffset[4];    /**< Stored in signed Q16 format */
+}OMX_CONFIG_COLORCONVERSIONTYPE;
+
+
+/** 
+ * Structure defining percent to scale each frame dimension.  For example:  
+ * To make the width 50% larger, use fWidth = 1.5 and to make the width
+ * 1/2 the original size, use fWidth = 0.5
+ */
+typedef struct OMX_CONFIG_SCALEFACTORTYPE {
+    OMX_U32 nSize;            /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version info */ 
+    OMX_U32 nPortIndex;       /**< Port that this struct applies to */
+    OMX_S32 xWidth;           /**< Fixed point value stored as Q16 */
+    OMX_S32 xHeight;          /**< Fixed point value stored as Q16 */
+}OMX_CONFIG_SCALEFACTORTYPE;
+
+
+/** 
+ * Enumeration of possible image filter types 
+ */
+typedef enum OMX_IMAGEFILTERTYPE {
+    OMX_ImageFilterNone,
+    OMX_ImageFilterNoise,
+    OMX_ImageFilterEmboss,
+    OMX_ImageFilterNegative,
+    OMX_ImageFilterSketch,
+    OMX_ImageFilterOilPaint,
+    OMX_ImageFilterHatch,
+    OMX_ImageFilterGpen,
+    OMX_ImageFilterAntialias, 
+    OMX_ImageFilterDeRing,       
+    OMX_ImageFilterSolarize,
+    OMX_ImageFilterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_ImageFilterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_ImageFilterMax = 0x7FFFFFFF
+} OMX_IMAGEFILTERTYPE;
+
+
+/** 
+ * Image filter configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes       
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to 
+ *  eImageFilter : Image filter type enumeration      
+ */
+typedef struct OMX_CONFIG_IMAGEFILTERTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGEFILTERTYPE eImageFilter;
+} OMX_CONFIG_IMAGEFILTERTYPE;
+
+
+/** 
+ * Customized U and V for color enhancement 
+ *
+ * STRUCT MEMBERS:
+ *  nSize             : Size of the structure in bytes
+ *  nVersion          : OMX specification version information 
+ *  nPortIndex        : Port that this structure applies to
+ *  bColorEnhancement : Enable/disable color enhancement
+ *  nCustomizedU      : Practical values: 16-240, range: 0-255, value set for 
+ *                      U component
+ *  nCustomizedV      : Practical values: 16-240, range: 0-255, value set for 
+ *                      V component
+ */
+typedef struct OMX_CONFIG_COLORENHANCEMENTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;
+    OMX_BOOL bColorEnhancement;
+    OMX_U8 nCustomizedU;
+    OMX_U8 nCustomizedV;
+} OMX_CONFIG_COLORENHANCEMENTTYPE;
+
+
+/** 
+ * Define color key and color key mask 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to
+ *  nARGBColor : 32bit Alpha, Red, Green, Blue Color
+ *  nARGBMask  : 32bit Mask for Alpha, Red, Green, Blue channels
+ */
+typedef struct OMX_CONFIG_COLORKEYTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nARGBColor;
+    OMX_U32 nARGBMask;
+} OMX_CONFIG_COLORKEYTYPE;
+
+
+/** 
+ * List of color blend types for pre/post processing 
+ *
+ * ENUMS:
+ *  None          : No color blending present
+ *  AlphaConstant : Function is (alpha_constant * src) + 
+ *                  (1 - alpha_constant) * dst)
+ *  AlphaPerPixel : Function is (alpha * src) + (1 - alpha) * dst)
+ *  Alternate     : Function is alternating pixels from src and dst
+ *  And           : Function is (src & dst)
+ *  Or            : Function is (src | dst)
+ *  Invert        : Function is ~src
+ */
+typedef enum OMX_COLORBLENDTYPE {
+    OMX_ColorBlendNone,
+    OMX_ColorBlendAlphaConstant,
+    OMX_ColorBlendAlphaPerPixel,
+    OMX_ColorBlendAlternate,
+    OMX_ColorBlendAnd,
+    OMX_ColorBlendOr,
+    OMX_ColorBlendInvert,
+    OMX_ColorBlendKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_ColorBlendVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_ColorBlendMax = 0x7FFFFFFF
+} OMX_COLORBLENDTYPE;
+
+
+/** 
+ * Color blend configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize             : Size of the structure in bytes                        
+ *  nVersion          : OMX specification version information                
+ *  nPortIndex        : Port that this structure applies to                   
+ *  nRGBAlphaConstant : Constant global alpha values when global alpha is used
+ *  eColorBlend       : Color blend type enumeration                         
+ */
+typedef struct OMX_CONFIG_COLORBLENDTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nRGBAlphaConstant;
+    OMX_COLORBLENDTYPE  eColorBlend;
+} OMX_CONFIG_COLORBLENDTYPE;
+
+
+/** 
+ * Hold frame dimension
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes      
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to     
+ *  nWidth     : Frame width in pixels                 
+ *  nHeight    : Frame height in pixels                
+ */
+typedef struct OMX_FRAMESIZETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+} OMX_FRAMESIZETYPE;
+
+
+/**
+ * Rotation configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes             
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nRotation  : +/- integer rotation value               
+ */
+typedef struct OMX_CONFIG_ROTATIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nRotation; 
+} OMX_CONFIG_ROTATIONTYPE;
+
+
+/** 
+ * Possible mirroring directions for pre/post processing 
+ *
+ * ENUMS:
+ *  None       : No mirroring                         
+ *  Vertical   : Vertical mirroring, flip on X axis   
+ *  Horizontal : Horizontal mirroring, flip on Y axis  
+ *  Both       : Both vertical and horizontal mirroring
+ */
+typedef enum OMX_MIRRORTYPE {
+    OMX_MirrorNone = 0,
+    OMX_MirrorVertical,
+    OMX_MirrorHorizontal,
+    OMX_MirrorBoth, 
+    OMX_MirrorKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MirrorVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_MirrorMax = 0x7FFFFFFF   
+} OMX_MIRRORTYPE;
+
+
+/** 
+ * Mirroring configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes      
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to  
+ *  eMirror    : Mirror type enumeration              
+ */
+typedef struct OMX_CONFIG_MIRRORTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;
+    OMX_MIRRORTYPE  eMirror;
+} OMX_CONFIG_MIRRORTYPE;
+
+
+/** 
+ * Position information only 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes               
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nX         : X coordinate for the point                     
+ *  nY         : Y coordinate for the point 
+ */                      
+typedef struct OMX_CONFIG_POINTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nX;
+    OMX_S32 nY;
+} OMX_CONFIG_POINTTYPE;
+
+
+/** 
+ * Frame size plus position 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes                    
+ *  nVersion   : OMX specification version information      
+ *  nPortIndex : Port that this structure applies to    
+ *  nLeft      : X Coordinate of the top left corner of the rectangle
+ *  nTop       : Y Coordinate of the top left corner of the rectangle
+ *  nWidth     : Width of the rectangle                              
+ *  nHeight    : Height of the rectangle                             
+ */
+typedef struct OMX_CONFIG_RECTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;  
+    OMX_U32 nPortIndex; 
+    OMX_S32 nLeft; 
+    OMX_S32 nTop;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+} OMX_CONFIG_RECTTYPE;
+
+
+/** 
+ * Deblocking state; it is required to be set up before starting the codec 
+ *
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes      
+ *  nVersion    : OMX specification version information 
+ *  nPortIndex  : Port that this structure applies to
+ *  bDeblocking : Enable/disable deblocking mode    
+ */
+typedef struct OMX_PARAM_DEBLOCKINGTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bDeblocking;
+} OMX_PARAM_DEBLOCKINGTYPE;
+
+
+/** 
+ * Stabilization state 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes          
+ *  nVersion   : OMX specification version information    
+ *  nPortIndex : Port that this structure applies to   
+ *  bStab      : Enable/disable frame stabilization state
+ */
+typedef struct OMX_CONFIG_FRAMESTABTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bStab;
+} OMX_CONFIG_FRAMESTABTYPE;
+
+
+/** 
+ * White Balance control type 
+ *
+ * STRUCT MEMBERS:
+ *  SunLight : Referenced in JSR-234
+ *  Flash    : Optimal for device's integrated flash
+ */
+typedef enum OMX_WHITEBALCONTROLTYPE {
+    OMX_WhiteBalControlOff = 0,
+    OMX_WhiteBalControlAuto,
+    OMX_WhiteBalControlSunLight,
+    OMX_WhiteBalControlCloudy,
+    OMX_WhiteBalControlShade,
+    OMX_WhiteBalControlTungsten,
+    OMX_WhiteBalControlFluorescent,
+    OMX_WhiteBalControlIncandescent,
+    OMX_WhiteBalControlFlash,
+    OMX_WhiteBalControlHorizon,
+    OMX_WhiteBalControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_WhiteBalControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_WhiteBalControlMax = 0x7FFFFFFF
+} OMX_WHITEBALCONTROLTYPE;
+
+
+/** 
+ * White Balance control configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize            : Size of the structure in bytes       
+ *  nVersion         : OMX specification version information
+ *  nPortIndex       : Port that this structure applies to                 
+ *  eWhiteBalControl : White balance enumeration            
+ */
+typedef struct OMX_CONFIG_WHITEBALCONTROLTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_WHITEBALCONTROLTYPE eWhiteBalControl;
+} OMX_CONFIG_WHITEBALCONTROLTYPE;
+
+
+/** 
+ * Exposure control type 
+ */
+typedef enum OMX_EXPOSURECONTROLTYPE {
+    OMX_ExposureControlOff = 0,
+    OMX_ExposureControlAuto,
+    OMX_ExposureControlNight,
+    OMX_ExposureControlBackLight,
+    OMX_ExposureControlSpotLight,
+    OMX_ExposureControlSports,
+    OMX_ExposureControlSnow,
+    OMX_ExposureControlBeach,
+    OMX_ExposureControlLargeAperture,
+    OMX_ExposureControlSmallApperture,
+    OMX_ExposureControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_ExposureControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_ExposureControlMax = 0x7FFFFFFF
+} OMX_EXPOSURECONTROLTYPE;
+
+
+/** 
+ * White Balance control configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize            : Size of the structure in bytes      
+ *  nVersion         : OMX specification version information
+ *  nPortIndex       : Port that this structure applies to                
+ *  eExposureControl : Exposure control enumeration         
+ */
+typedef struct OMX_CONFIG_EXPOSURECONTROLTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_EXPOSURECONTROLTYPE eExposureControl;
+} OMX_CONFIG_EXPOSURECONTROLTYPE;
+
+
+/** 
+ * Defines sensor supported mode. 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes           
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to 
+ *  nFrameRate : Single shot mode is indicated by a 0     
+ *  bOneShot   : Enable for single shot, disable for streaming
+ *  sFrameSize : Framesize                                          
+ */
+typedef struct OMX_PARAM_SENSORMODETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nFrameRate;
+    OMX_BOOL bOneShot;
+    OMX_FRAMESIZETYPE sFrameSize;
+} OMX_PARAM_SENSORMODETYPE;
+
+
+/** 
+ * Defines contrast level 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes                              
+ *  nVersion   : OMX specification version information                
+ *  nPortIndex : Port that this structure applies to                 
+ *  nContrast  : Values allowed for contrast -100 to 100, zero means no change
+ */
+typedef struct OMX_CONFIG_CONTRASTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nContrast;
+} OMX_CONFIG_CONTRASTTYPE;
+
+
+/** 
+ * Defines brightness level 
+ *
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes          
+ *  nVersion    : OMX specification version information 
+ *  nPortIndex  : Port that this structure applies to 
+ *  nBrightness : 0-100%        
+ */
+typedef struct OMX_CONFIG_BRIGHTNESSTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nBrightness;
+} OMX_CONFIG_BRIGHTNESSTYPE;
+
+
+/** 
+ * Defines backlight level configuration for a video sink, e.g. LCD panel 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to
+ *  nBacklight : Values allowed for backlight 0-100%
+ *  nTimeout   : Number of milliseconds before backlight automatically turns 
+ *               off.  A value of 0x0 disables backight timeout 
+ */
+typedef struct OMX_CONFIG_BACKLIGHTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nBacklight;
+    OMX_U32 nTimeout;
+} OMX_CONFIG_BACKLIGHTTYPE;
+
+
+/** 
+ * Defines setting for Gamma 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to
+ *  nGamma     : Values allowed for gamma -100 to 100, zero means no change
+ */
+typedef struct OMX_CONFIG_GAMMATYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nGamma;
+} OMX_CONFIG_GAMMATYPE;
+
+
+/** 
+ * Define for setting saturation 
+ * 
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes
+ *  nVersion    : OMX specification version information
+ *  nPortIndex  : Port that this structure applies to
+ *  nSaturation : Values allowed for saturation -100 to 100, zero means 
+ *                no change
+ */
+typedef struct OMX_CONFIG_SATURATIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nSaturation;
+} OMX_CONFIG_SATURATIONTYPE;
+
+
+/** 
+ * Define for setting Lightness 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nLightness : Values allowed for lightness -100 to 100, zero means no 
+ *               change
+ */
+typedef struct OMX_CONFIG_LIGHTNESSTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nLightness;
+} OMX_CONFIG_LIGHTNESSTYPE;
+
+
+/** 
+ * Plane blend configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes 
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Index of input port associated with the plane.
+ *  nDepth     : Depth of the plane in relation to the screen. Higher 
+ *               numbered depths are "behind" lower number depths.  
+ *               This number defaults to the Port Index number.
+ *  nAlpha     : Transparency blending component for the entire plane.  
+ *               See blending modes for more detail.
+ */
+typedef struct OMX_CONFIG_PLANEBLENDTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nDepth;
+    OMX_U32 nAlpha;
+} OMX_CONFIG_PLANEBLENDTYPE;
+
+
+/** 
+ * Define interlace type
+ *
+ * STRUCT MEMBERS:
+ *  nSize                 : Size of the structure in bytes 
+ *  nVersion              : OMX specification version information 
+ *  nPortIndex            : Port that this structure applies to
+ *  bEnable               : Enable control variable for this functionality 
+ *                          (see below)
+ *  nInterleavePortIndex  : Index of input or output port associated with  
+ *                          the interleaved plane. 
+ *  pPlanarPortIndexes[4] : Index of input or output planar ports.
+ */
+typedef struct OMX_PARAM_INTERLEAVETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnable;
+    OMX_U32 nInterleavePortIndex;
+} OMX_PARAM_INTERLEAVETYPE;
+
+
+/** 
+ * Defines the picture effect used for an input picture 
+ */
+typedef enum OMX_TRANSITIONEFFECTTYPE {
+    OMX_EffectNone,
+    OMX_EffectFadeFromBlack,
+    OMX_EffectFadeToBlack,
+    OMX_EffectUnspecifiedThroughConstantColor,
+    OMX_EffectDissolve,
+    OMX_EffectWipe,
+    OMX_EffectUnspecifiedMixOfTwoScenes,
+    OMX_EffectKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_EffectVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_EffectMax = 0x7FFFFFFF
+} OMX_TRANSITIONEFFECTTYPE;
+
+
+/** 
+ * Structure used to configure current transition effect 
+ *
+ * STRUCT MEMBERS:
+ * nSize      : Size of the structure in bytes
+ * nVersion   : OMX specification version information 
+ * nPortIndex : Port that this structure applies to
+ * eEffect    : Effect to enable
+ */
+typedef struct OMX_CONFIG_TRANSITIONEFFECTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TRANSITIONEFFECTTYPE eEffect;
+} OMX_CONFIG_TRANSITIONEFFECTTYPE;
+
+
+/** 
+ * Defines possible data unit types for encoded video data. The data unit 
+ * types are used both for encoded video input for playback as well as
+ * encoded video output from recording. 
+ */
+typedef enum OMX_DATAUNITTYPE {
+    OMX_DataUnitCodedPicture,
+    OMX_DataUnitVideoSegment,
+    OMX_DataUnitSeveralSegments,
+    OMX_DataUnitArbitraryStreamSection,
+    OMX_DataUnitKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_DataUnitVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_DataUnitMax = 0x7FFFFFFF
+} OMX_DATAUNITTYPE;
+
+
+/** 
+ * Defines possible encapsulation types for coded video data unit. The 
+ * encapsulation information is used both for encoded video input for 
+ * playback as well as encoded video output from recording. 
+ */
+typedef enum OMX_DATAUNITENCAPSULATIONTYPE {
+    OMX_DataEncapsulationElementaryStream,
+    OMX_DataEncapsulationGenericPayload,
+    OMX_DataEncapsulationRtpPayload,
+    OMX_DataEncapsulationKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_DataEncapsulationVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_DataEncapsulationMax = 0x7FFFFFFF
+} OMX_DATAUNITENCAPSULATIONTYPE;
+
+
+/** 
+ * Structure used to configure the type of being decoded/encoded 
+ */
+typedef struct OMX_PARAM_DATAUNITTYPE {
+    OMX_U32 nSize;            /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;       /**< Port that this structure applies to */
+    OMX_DATAUNITTYPE eUnitType;
+    OMX_DATAUNITENCAPSULATIONTYPE eEncapsulationType;
+} OMX_PARAM_DATAUNITTYPE;
+
+
+/**
+ * Defines dither types 
+ */
+typedef enum OMX_DITHERTYPE {
+    OMX_DitherNone,
+    OMX_DitherOrdered,
+    OMX_DitherErrorDiffusion,
+    OMX_DitherOther,
+    OMX_DitherKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_DitherVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_DitherMax = 0x7FFFFFFF
+} OMX_DITHERTYPE;
+
+
+/** 
+ * Structure used to configure current type of dithering 
+ */
+typedef struct OMX_CONFIG_DITHERTYPE {
+    OMX_U32 nSize;            /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;       /**< Port that this structure applies to */
+    OMX_DITHERTYPE eDither;   /**< Type of dithering to use */
+} OMX_CONFIG_DITHERTYPE;
+
+typedef struct OMX_CONFIG_CAPTUREMODETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;     /**< Port that this structure applies to */
+    OMX_BOOL bContinuous;   /**< If true then ignore frame rate and emit capture 
+                             *   data as fast as possible (otherwise obey port's frame rate). */
+    OMX_BOOL bFrameLimited; /**< If true then terminate capture after the port emits the 
+                             *   specified number of frames (otherwise the port does not 
+                             *   terminate the capture until instructed to do so by the client). 
+                             *   Even if set, the client may manually terminate the capture prior 
+                             *   to reaching the limit. */
+    OMX_U32 nFrameLimit;      /**< Limit on number of frames emitted during a capture (only
+                               *   valid if bFrameLimited is set). */
+} OMX_CONFIG_CAPTUREMODETYPE;
+
+typedef enum OMX_METERINGTYPE {
+ 
+    OMX_MeteringModeAverage,     /**< Center-weighted average metering. */
+    OMX_MeteringModeSpot,  	      /**< Spot (partial) metering. */
+    OMX_MeteringModeMatrix,      /**< Matrix or evaluative metering. */
+ 
+    OMX_MeteringKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MeteringVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_EVModeMax = 0x7fffffff
+} OMX_METERINGTYPE;
+ 
+typedef struct OMX_CONFIG_EXPOSUREVALUETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_METERINGTYPE eMetering;
+    OMX_S32 xEVCompensation;      /**< Fixed point value stored as Q16 */
+    OMX_U32 nApertureFNumber;     /**< e.g. nApertureFNumber = 2 implies "f/2" - Q16 format */
+    OMX_BOOL bAutoAperture;		/**< Whether aperture number is defined automatically */
+    OMX_U32 nShutterSpeedMsec;    /**< Shutterspeed in milliseconds */ 
+    OMX_BOOL bAutoShutterSpeed;	/**< Whether shutter speed is defined automatically */ 
+    OMX_U32 nSensitivity;         /**< e.g. nSensitivity = 100 implies "ISO 100" */
+    OMX_BOOL bAutoSensitivity;	/**< Whether sensitivity is defined automatically */
+} OMX_CONFIG_EXPOSUREVALUETYPE;
+
+/** 
+ * Focus region configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize           : Size of the structure in bytes
+ *  nVersion        : OMX specification version information
+ *  nPortIndex      : Port that this structure applies to
+ *  bCenter         : Use center region as focus region of interest
+ *  bLeft           : Use left region as focus region of interest
+ *  bRight          : Use right region as focus region of interest
+ *  bTop            : Use top region as focus region of interest
+ *  bBottom         : Use bottom region as focus region of interest
+ *  bTopLeft        : Use top left region as focus region of interest
+ *  bTopRight       : Use top right region as focus region of interest
+ *  bBottomLeft     : Use bottom left region as focus region of interest
+ *  bBottomRight    : Use bottom right region as focus region of interest
+ */
+typedef struct OMX_CONFIG_FOCUSREGIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bCenter;
+    OMX_BOOL bLeft;
+    OMX_BOOL bRight;
+    OMX_BOOL bTop;
+    OMX_BOOL bBottom;
+    OMX_BOOL bTopLeft;
+    OMX_BOOL bTopRight;
+    OMX_BOOL bBottomLeft;
+    OMX_BOOL bBottomRight;
+} OMX_CONFIG_FOCUSREGIONTYPE;
+
+/** 
+ * Focus Status type 
+ */
+typedef enum OMX_FOCUSSTATUSTYPE {
+    OMX_FocusStatusOff = 0,
+    OMX_FocusStatusRequest,
+    OMX_FocusStatusReached,
+    OMX_FocusStatusUnableToReach,
+    OMX_FocusStatusLost,
+    OMX_FocusStatusKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_FocusStatusVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_FocusStatusMax = 0x7FFFFFFF
+} OMX_FOCUSSTATUSTYPE;
+
+/** 
+ * Focus status configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize               : Size of the structure in bytes
+ *  nVersion            : OMX specification version information
+ *  nPortIndex          : Port that this structure applies to
+ *  eFocusStatus        : Specifies the focus status
+ *  bCenterStatus       : Use center region as focus region of interest
+ *  bLeftStatus         : Use left region as focus region of interest
+ *  bRightStatus        : Use right region as focus region of interest
+ *  bTopStatus          : Use top region as focus region of interest
+ *  bBottomStatus       : Use bottom region as focus region of interest
+ *  bTopLeftStatus      : Use top left region as focus region of interest
+ *  bTopRightStatus     : Use top right region as focus region of interest
+ *  bBottomLeftStatus   : Use bottom left region as focus region of interest
+ *  bBottomRightStatus  : Use bottom right region as focus region of interest
+ */
+typedef struct OMX_PARAM_FOCUSSTATUSTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_FOCUSSTATUSTYPE eFocusStatus;
+    OMX_BOOL bCenterStatus;
+    OMX_BOOL bLeftStatus;
+    OMX_BOOL bRightStatus;
+    OMX_BOOL bTopStatus;
+    OMX_BOOL bBottomStatus;
+    OMX_BOOL bTopLeftStatus;
+    OMX_BOOL bTopRightStatus;
+    OMX_BOOL bBottomLeftStatus;
+    OMX_BOOL bBottomRightStatus;
+} OMX_PARAM_FOCUSSTATUSTYPE;
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Image.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Image.h
new file mode 100644
index 0000000..a6d4666
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Image.h
@@ -0,0 +1,328 @@
+/**
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ */
+
+/** 
+ * @file OMX_Image.h - OpenMax IL version 1.1.2
+ * The structures needed by Image components to exchange parameters and 
+ * configuration data with the components.
+ */
+#ifndef OMX_Image_h
+#define OMX_Image_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/**
+ * Each OMX header must include all required header files to allow the 
+ * header to compile without errors.  The includes below are required  
+ * for this header file to compile successfully 
+ */
+
+#include <OMX_IVCommon.h>
+
+/** @defgroup imaging OpenMAX IL Imaging Domain
+ * @ingroup iv
+ * Structures for OpenMAX IL Imaging domain
+ * @{
+ */
+
+/** 
+ * Enumeration used to define the possible image compression coding. 
+ */
+typedef enum OMX_IMAGE_CODINGTYPE {
+    OMX_IMAGE_CodingUnused,      /**< Value when format is N/A */
+    OMX_IMAGE_CodingAutoDetect,  /**< Auto detection of image format */
+    OMX_IMAGE_CodingJPEG,        /**< JPEG/JFIF image format */
+    OMX_IMAGE_CodingJPEG2K,      /**< JPEG 2000 image format */
+    OMX_IMAGE_CodingEXIF,        /**< EXIF image format */
+    OMX_IMAGE_CodingTIFF,        /**< TIFF image format */
+    OMX_IMAGE_CodingGIF,         /**< Graphics image format */
+    OMX_IMAGE_CodingPNG,         /**< PNG image format */
+    OMX_IMAGE_CodingLZW,         /**< LZW image format */
+    OMX_IMAGE_CodingBMP,         /**< Windows Bitmap format */
+    OMX_IMAGE_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_CodingMax = 0x7FFFFFFF
+} OMX_IMAGE_CODINGTYPE;
+
+
+/**
+ * Data structure used to define an image path. The number of image paths 
+ * for input and output will vary by type of the image component.  
+ * 
+ *  Input (aka Source) : Zero Inputs, one Output,
+ *  Splitter           : One Input, 2 or more Outputs,
+ *  Processing Element : One Input, one output,
+ *  Mixer              : 2 or more inputs, one output,
+ *  Output (aka Sink)  : One Input, zero outputs.
+ * 
+ * The PortDefinition structure is used to define all of the parameters 
+ * necessary for the compliant component to setup an input or an output  
+ * image path.  If additional vendor specific data is required, it should  
+ * be transmitted to the component using the CustomCommand function.   
+ * Compliant components will prepopulate this structure with optimal  
+ * values during the OMX_GetParameter() command.
+ *
+ * STRUCT MEMBERS:
+ *  cMIMEType             : MIME type of data for the port
+ *  pNativeRender         : Platform specific reference for a display if a 
+ *                          sync, otherwise this field is 0
+ *  nFrameWidth           : Width of frame to be used on port if 
+ *                          uncompressed format is used.  Use 0 for 
+ *                          unknown, don't care or variable
+ *  nFrameHeight          : Height of frame to be used on port if 
+ *                          uncompressed format is used. Use 0 for 
+ *                          unknown, don't care or variable
+ *  nStride               : Number of bytes per span of an image (i.e. 
+ *                          indicates the number of bytes to get from
+ *                          span N to span N+1, where negative stride 
+ *                          indicates the image is bottom up
+ *  nSliceHeight          : Height used when encoding in slices
+ *  bFlagErrorConcealment : Turns on error concealment if it is supported by 
+ *                          the OMX component
+ *  eCompressionFormat    : Compression format used in this instance of  
+ *                          the component. When OMX_IMAGE_CodingUnused is 
+ *                          specified, eColorFormat is valid
+ *  eColorFormat          : Decompressed format used by this component
+ *  pNativeWindow         : Platform specific reference for a window object if a 
+ *                          display sink , otherwise this field is 0x0. 
+ */
+typedef struct OMX_IMAGE_PORTDEFINITIONTYPE {
+    OMX_STRING cMIMEType;
+    OMX_NATIVE_DEVICETYPE pNativeRender;
+    OMX_U32 nFrameWidth; 
+    OMX_U32 nFrameHeight;
+    OMX_S32 nStride;     
+    OMX_U32 nSliceHeight;
+    OMX_BOOL bFlagErrorConcealment;
+    OMX_IMAGE_CODINGTYPE eCompressionFormat;
+    OMX_COLOR_FORMATTYPE eColorFormat;
+    OMX_NATIVE_WINDOWTYPE pNativeWindow;
+} OMX_IMAGE_PORTDEFINITIONTYPE;
+
+
+/**  
+ * Port format parameter.  This structure is used to enumerate the various 
+ * data input/output format supported by the port.
+ * 
+ * STRUCT MEMBERS:
+ *  nSize              : Size of the structure in bytes
+ *  nVersion           : OMX specification version information
+ *  nPortIndex         : Indicates which port to set
+ *  nIndex             : Indicates the enumeration index for the format from 
+ *                       0x0 to N-1
+ *  eCompressionFormat : Compression format used in this instance of the 
+ *                       component. When OMX_IMAGE_CodingUnused is specified, 
+ *                       eColorFormat is valid
+ *  eColorFormat       : Decompressed format used by this component
+ */
+typedef struct OMX_IMAGE_PARAM_PORTFORMATTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nIndex;
+    OMX_IMAGE_CODINGTYPE eCompressionFormat;
+    OMX_COLOR_FORMATTYPE eColorFormat;
+} OMX_IMAGE_PARAM_PORTFORMATTYPE;
+
+
+/** 
+ * Flash control type 
+ *
+ * ENUMS
+ *  Torch : Flash forced constantly on
+ */
+typedef enum OMX_IMAGE_FLASHCONTROLTYPE {
+    OMX_IMAGE_FlashControlOn = 0,
+    OMX_IMAGE_FlashControlOff,
+    OMX_IMAGE_FlashControlAuto,
+    OMX_IMAGE_FlashControlRedEyeReduction,
+    OMX_IMAGE_FlashControlFillin,
+    OMX_IMAGE_FlashControlTorch,
+    OMX_IMAGE_FlashControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_FlashControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_FlashControlMax = 0x7FFFFFFF
+} OMX_IMAGE_FLASHCONTROLTYPE;
+
+
+/** 
+ * Flash control configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize         : Size of the structure in bytes
+ *  nVersion      : OMX specification version information
+ *  nPortIndex    : Port that this structure applies to
+ *  eFlashControl : Flash control type
+ */
+typedef struct OMX_IMAGE_PARAM_FLASHCONTROLTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGE_FLASHCONTROLTYPE eFlashControl;
+} OMX_IMAGE_PARAM_FLASHCONTROLTYPE;
+
+
+/** 
+ * Focus control type 
+ */
+typedef enum OMX_IMAGE_FOCUSCONTROLTYPE {
+    OMX_IMAGE_FocusControlOn = 0,
+    OMX_IMAGE_FocusControlOff,
+    OMX_IMAGE_FocusControlAuto,
+    OMX_IMAGE_FocusControlAutoLock,
+    OMX_IMAGE_FocusControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_FocusControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_FocusControlMax = 0x7FFFFFFF
+} OMX_IMAGE_FOCUSCONTROLTYPE;
+
+ 
+/** 
+ * Focus control configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize           : Size of the structure in bytes
+ *  nVersion        : OMX specification version information
+ *  nPortIndex      : Port that this structure applies to
+ *  eFocusControl   : Focus control
+ *  nFocusSteps     : Focus can take on values from 0 mm to infinity. 
+ *                    Interest is only in number of steps over this range.
+ *  nFocusStepIndex : Current focus step index
+ */
+typedef struct OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGE_FOCUSCONTROLTYPE eFocusControl;
+    OMX_U32 nFocusSteps;
+    OMX_U32 nFocusStepIndex;
+} OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE;
+
+
+/** 
+ * Q Factor for JPEG compression, which controls the tradeoff between image
+ * quality and size.  Q Factor provides a more simple means of controlling
+ * JPEG compression quality, without directly programming Quantization
+ * tables for chroma and luma 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes         
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to 
+ *  nQFactor   : JPEG Q factor value in the range of 1-100. A factor of 1 
+ *               produces the smallest, worst quality images, and a factor 
+ *               of 100 produces the largest, best quality images.  A 
+ *               typical default is 75 for small good quality images               
+ */
+typedef struct OMX_IMAGE_PARAM_QFACTORTYPE {
+    OMX_U32 nSize;            
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;       
+    OMX_U32 nQFactor;                                        
+} OMX_IMAGE_PARAM_QFACTORTYPE;
+
+/** 
+ * Quantization table type 
+ */
+
+typedef enum OMX_IMAGE_QUANTIZATIONTABLETYPE {
+    OMX_IMAGE_QuantizationTableLuma = 0,
+    OMX_IMAGE_QuantizationTableChroma,
+    OMX_IMAGE_QuantizationTableChromaCb,
+    OMX_IMAGE_QuantizationTableChromaCr,
+    OMX_IMAGE_QuantizationTableKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_QuantizationTableVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_QuantizationTableMax = 0x7FFFFFFF
+} OMX_IMAGE_QUANTIZATIONTABLETYPE;
+
+/** 
+ * JPEG quantization tables are used to determine DCT compression for
+ * YUV data, as an alternative to specifying Q factor, providing exact 
+ * control of compression 
+ *
+ * STRUCT MEMBERS:
+ *  nSize                   : Size of the structure in bytes
+ *  nVersion                : OMX specification version information 
+ *  nPortIndex              : Port that this structure applies to
+ *  eQuantizationTable      : Quantization table type
+ *  nQuantizationMatrix[64] : JPEG quantization table of coefficients stored 
+ *                            in increasing columns then by rows of data (i.e. 
+ *                            row 1, ... row 8). Quantization values are in 
+ *                            the range 0-255 and stored in linear order
+ *                            (i.e. the component will zig-zag the 
+ *                            quantization table data if required internally) 
+ */
+typedef struct OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGE_QUANTIZATIONTABLETYPE eQuantizationTable;
+    OMX_U8 nQuantizationMatrix[64];
+} OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE;
+
+
+/** 
+ * Huffman table type, the same Huffman table is applied for chroma and 
+ * luma component 
+ */
+typedef enum OMX_IMAGE_HUFFMANTABLETYPE {
+    OMX_IMAGE_HuffmanTableAC = 0,
+    OMX_IMAGE_HuffmanTableDC,
+    OMX_IMAGE_HuffmanTableACLuma,
+    OMX_IMAGE_HuffmanTableACChroma,
+    OMX_IMAGE_HuffmanTableDCLuma,
+    OMX_IMAGE_HuffmanTableDCChroma,
+    OMX_IMAGE_HuffmanTableKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_HuffmanTableVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_HuffmanTableMax = 0x7FFFFFFF
+} OMX_IMAGE_HUFFMANTABLETYPE;
+
+/** 
+ * JPEG Huffman table 
+ *
+ * STRUCT MEMBERS:
+ *  nSize                            : Size of the structure in bytes
+ *  nVersion                         : OMX specification version information
+ *  nPortIndex                       : Port that this structure applies to
+ *  eHuffmanTable                    : Huffman table type
+ *  nNumberOfHuffmanCodeOfLength[16] : 0-16, number of Huffman codes of each 
+ *                                     possible length
+ *  nHuffmanTable[256]               : 0-255, the size used for AC and DC 
+ *                                     HuffmanTable are 16 and 162 
+ */
+typedef struct OMX_IMAGE_PARAM_HUFFMANTTABLETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGE_HUFFMANTABLETYPE eHuffmanTable;
+    OMX_U8 nNumberOfHuffmanCodeOfLength[16];
+    OMX_U8 nHuffmanTable[256];
+}OMX_IMAGE_PARAM_HUFFMANTTABLETYPE;
+
+/** @} */
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Index.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Index.h
new file mode 100644
index 0000000..44d4ea7
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Index.h
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** @file OMX_Index.h - OpenMax IL version 1.1.2
+ *  The OMX_Index header file contains the definitions for both applications
+ *  and components .
+ */
+
+
+#ifndef OMX_Index_h
+#define OMX_Index_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header must include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+#include <OMX_Types.h>
+
+
+/** The OMX_INDEXTYPE enumeration is used to select a structure when either
+ *  getting or setting parameters and/or configuration data.  Each entry in 
+ *  this enumeration maps to an OMX specified structure.  When the 
+ *  OMX_GetParameter, OMX_SetParameter, OMX_GetConfig or OMX_SetConfig methods
+ *  are used, the second parameter will always be an entry from this enumeration
+ *  and the third entry will be the structure shown in the comments for the entry.
+ *  For example, if the application is initializing a cropping function, the 
+ *  OMX_SetConfig command would have OMX_IndexConfigCommonInputCrop as the second parameter 
+ *  and would send a pointer to an initialized OMX_RECTTYPE structure as the 
+ *  third parameter.
+ *  
+ *  The enumeration entries named with the OMX_Config prefix are sent using
+ *  the OMX_SetConfig command and the enumeration entries named with the
+ *  OMX_PARAM_ prefix are sent using the OMX_SetParameter command.
+ */
+typedef enum OMX_INDEXTYPE {
+
+    OMX_IndexComponentStartUnused = 0x01000000,
+    OMX_IndexParamPriorityMgmt,             /**< reference: OMX_PRIORITYMGMTTYPE */
+    OMX_IndexParamAudioInit,                /**< reference: OMX_PORT_PARAM_TYPE */
+    OMX_IndexParamImageInit,                /**< reference: OMX_PORT_PARAM_TYPE */
+    OMX_IndexParamVideoInit,                /**< reference: OMX_PORT_PARAM_TYPE */
+    OMX_IndexParamOtherInit,                /**< reference: OMX_PORT_PARAM_TYPE */
+    OMX_IndexParamNumAvailableStreams,      /**< reference: OMX_PARAM_U32TYPE */
+    OMX_IndexParamActiveStream,             /**< reference: OMX_PARAM_U32TYPE */
+    OMX_IndexParamSuspensionPolicy,         /**< reference: OMX_PARAM_SUSPENSIONPOLICYTYPE */
+    OMX_IndexParamComponentSuspended,       /**< reference: OMX_PARAM_SUSPENSIONTYPE */
+    OMX_IndexConfigCapturing,               /**< reference: OMX_CONFIG_BOOLEANTYPE */ 
+    OMX_IndexConfigCaptureMode,             /**< reference: OMX_CONFIG_CAPTUREMODETYPE */ 
+    OMX_IndexAutoPauseAfterCapture,         /**< reference: OMX_CONFIG_BOOLEANTYPE */ 
+    OMX_IndexParamContentURI,               /**< reference: OMX_PARAM_CONTENTURITYPE */
+    OMX_IndexParamCustomContentPipe,        /**< reference: OMX_PARAM_CONTENTPIPETYPE */ 
+    OMX_IndexParamDisableResourceConcealment, /**< reference: OMX_RESOURCECONCEALMENTTYPE */
+    OMX_IndexConfigMetadataItemCount,       /**< reference: OMX_CONFIG_METADATAITEMCOUNTTYPE */
+    OMX_IndexConfigContainerNodeCount,      /**< reference: OMX_CONFIG_CONTAINERNODECOUNTTYPE */
+    OMX_IndexConfigMetadataItem,            /**< reference: OMX_CONFIG_METADATAITEMTYPE */
+    OMX_IndexConfigCounterNodeID,           /**< reference: OMX_CONFIG_CONTAINERNODEIDTYPE */
+    OMX_IndexParamMetadataFilterType,       /**< reference: OMX_PARAM_METADATAFILTERTYPE */
+    OMX_IndexParamMetadataKeyFilter,        /**< reference: OMX_PARAM_METADATAFILTERTYPE */
+    OMX_IndexConfigPriorityMgmt,            /**< reference: OMX_PRIORITYMGMTTYPE */
+    OMX_IndexParamStandardComponentRole,    /**< reference: OMX_PARAM_COMPONENTROLETYPE */
+
+    OMX_IndexPortStartUnused = 0x02000000,
+    OMX_IndexParamPortDefinition,           /**< reference: OMX_PARAM_PORTDEFINITIONTYPE */
+    OMX_IndexParamCompBufferSupplier,       /**< reference: OMX_PARAM_BUFFERSUPPLIERTYPE */ 
+    OMX_IndexReservedStartUnused = 0x03000000,
+
+    /* Audio parameters and configurations */
+    OMX_IndexAudioStartUnused = 0x04000000,
+    OMX_IndexParamAudioPortFormat,          /**< reference: OMX_AUDIO_PARAM_PORTFORMATTYPE */
+    OMX_IndexParamAudioPcm,                 /**< reference: OMX_AUDIO_PARAM_PCMMODETYPE */
+    OMX_IndexParamAudioAac,                 /**< reference: OMX_AUDIO_PARAM_AACPROFILETYPE */
+    OMX_IndexParamAudioRa,                  /**< reference: OMX_AUDIO_PARAM_RATYPE */
+    OMX_IndexParamAudioMp3,                 /**< reference: OMX_AUDIO_PARAM_MP3TYPE */
+    OMX_IndexParamAudioAdpcm,               /**< reference: OMX_AUDIO_PARAM_ADPCMTYPE */
+    OMX_IndexParamAudioG723,                /**< reference: OMX_AUDIO_PARAM_G723TYPE */
+    OMX_IndexParamAudioG729,                /**< reference: OMX_AUDIO_PARAM_G729TYPE */
+    OMX_IndexParamAudioAmr,                 /**< reference: OMX_AUDIO_PARAM_AMRTYPE */
+    OMX_IndexParamAudioWma,                 /**< reference: OMX_AUDIO_PARAM_WMATYPE */
+    OMX_IndexParamAudioSbc,                 /**< reference: OMX_AUDIO_PARAM_SBCTYPE */
+    OMX_IndexParamAudioMidi,                /**< reference: OMX_AUDIO_PARAM_MIDITYPE */
+    OMX_IndexParamAudioGsm_FR,              /**< reference: OMX_AUDIO_PARAM_GSMFRTYPE */
+    OMX_IndexParamAudioMidiLoadUserSound,   /**< reference: OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE */
+    OMX_IndexParamAudioG726,                /**< reference: OMX_AUDIO_PARAM_G726TYPE */
+    OMX_IndexParamAudioGsm_EFR,             /**< reference: OMX_AUDIO_PARAM_GSMEFRTYPE */
+    OMX_IndexParamAudioGsm_HR,              /**< reference: OMX_AUDIO_PARAM_GSMHRTYPE */
+    OMX_IndexParamAudioPdc_FR,              /**< reference: OMX_AUDIO_PARAM_PDCFRTYPE */
+    OMX_IndexParamAudioPdc_EFR,             /**< reference: OMX_AUDIO_PARAM_PDCEFRTYPE */
+    OMX_IndexParamAudioPdc_HR,              /**< reference: OMX_AUDIO_PARAM_PDCHRTYPE */
+    OMX_IndexParamAudioTdma_FR,             /**< reference: OMX_AUDIO_PARAM_TDMAFRTYPE */
+    OMX_IndexParamAudioTdma_EFR,            /**< reference: OMX_AUDIO_PARAM_TDMAEFRTYPE */
+    OMX_IndexParamAudioQcelp8,              /**< reference: OMX_AUDIO_PARAM_QCELP8TYPE */
+    OMX_IndexParamAudioQcelp13,             /**< reference: OMX_AUDIO_PARAM_QCELP13TYPE */
+    OMX_IndexParamAudioEvrc,                /**< reference: OMX_AUDIO_PARAM_EVRCTYPE */
+    OMX_IndexParamAudioSmv,                 /**< reference: OMX_AUDIO_PARAM_SMVTYPE */
+    OMX_IndexParamAudioVorbis,              /**< reference: OMX_AUDIO_PARAM_VORBISTYPE */
+
+    OMX_IndexConfigAudioMidiImmediateEvent, /**< reference: OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE */
+    OMX_IndexConfigAudioMidiControl,        /**< reference: OMX_AUDIO_CONFIG_MIDICONTROLTYPE */
+    OMX_IndexConfigAudioMidiSoundBankProgram, /**< reference: OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE */
+    OMX_IndexConfigAudioMidiStatus,         /**< reference: OMX_AUDIO_CONFIG_MIDISTATUSTYPE */
+    OMX_IndexConfigAudioMidiMetaEvent,      /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE */
+    OMX_IndexConfigAudioMidiMetaEventData,  /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTDATATYPE */
+    OMX_IndexConfigAudioVolume,             /**< reference: OMX_AUDIO_CONFIG_VOLUMETYPE */
+    OMX_IndexConfigAudioBalance,            /**< reference: OMX_AUDIO_CONFIG_BALANCETYPE */
+    OMX_IndexConfigAudioChannelMute,        /**< reference: OMX_AUDIO_CONFIG_CHANNELMUTETYPE */
+    OMX_IndexConfigAudioMute,               /**< reference: OMX_AUDIO_CONFIG_MUTETYPE */
+    OMX_IndexConfigAudioLoudness,           /**< reference: OMX_AUDIO_CONFIG_LOUDNESSTYPE */
+    OMX_IndexConfigAudioEchoCancelation,    /**< reference: OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE */
+    OMX_IndexConfigAudioNoiseReduction,     /**< reference: OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE */
+    OMX_IndexConfigAudioBass,               /**< reference: OMX_AUDIO_CONFIG_BASSTYPE */
+    OMX_IndexConfigAudioTreble,             /**< reference: OMX_AUDIO_CONFIG_TREBLETYPE */
+    OMX_IndexConfigAudioStereoWidening,     /**< reference: OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE */
+    OMX_IndexConfigAudioChorus,             /**< reference: OMX_AUDIO_CONFIG_CHORUSTYPE */
+    OMX_IndexConfigAudioEqualizer,          /**< reference: OMX_AUDIO_CONFIG_EQUALIZERTYPE */
+    OMX_IndexConfigAudioReverberation,      /**< reference: OMX_AUDIO_CONFIG_REVERBERATIONTYPE */
+    OMX_IndexConfigAudioChannelVolume,      /**< reference: OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE */
+
+    /* Image specific parameters and configurations */
+    OMX_IndexImageStartUnused = 0x05000000,
+    OMX_IndexParamImagePortFormat,          /**< reference: OMX_IMAGE_PARAM_PORTFORMATTYPE */
+    OMX_IndexParamFlashControl,             /**< reference: OMX_IMAGE_PARAM_FLASHCONTROLTYPE */
+    OMX_IndexConfigFocusControl,            /**< reference: OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE */
+    OMX_IndexParamQFactor,                  /**< reference: OMX_IMAGE_PARAM_QFACTORTYPE */
+    OMX_IndexParamQuantizationTable,        /**< reference: OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE */
+    OMX_IndexParamHuffmanTable,             /**< reference: OMX_IMAGE_PARAM_HUFFMANTTABLETYPE */
+    OMX_IndexConfigFlashControl,            /**< reference: OMX_IMAGE_PARAM_FLASHCONTROLTYPE */
+
+    /* Video specific parameters and configurations */
+    OMX_IndexVideoStartUnused = 0x06000000,
+    OMX_IndexParamVideoPortFormat,          /**< reference: OMX_VIDEO_PARAM_PORTFORMATTYPE */
+    OMX_IndexParamVideoQuantization,        /**< reference: OMX_VIDEO_PARAM_QUANTIZATIONTYPE */
+    OMX_IndexParamVideoFastUpdate,          /**< reference: OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE */
+    OMX_IndexParamVideoBitrate,             /**< reference: OMX_VIDEO_PARAM_BITRATETYPE */
+    OMX_IndexParamVideoMotionVector,        /**< reference: OMX_VIDEO_PARAM_MOTIONVECTORTYPE */
+    OMX_IndexParamVideoIntraRefresh,        /**< reference: OMX_VIDEO_PARAM_INTRAREFRESHTYPE */
+    OMX_IndexParamVideoErrorCorrection,     /**< reference: OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE */
+    OMX_IndexParamVideoVBSMC,               /**< reference: OMX_VIDEO_PARAM_VBSMCTYPE */
+    OMX_IndexParamVideoMpeg2,               /**< reference: OMX_VIDEO_PARAM_MPEG2TYPE */
+    OMX_IndexParamVideoMpeg4,               /**< reference: OMX_VIDEO_PARAM_MPEG4TYPE */
+    OMX_IndexParamVideoWmv,                 /**< reference: OMX_VIDEO_PARAM_WMVTYPE */
+    OMX_IndexParamVideoRv,                  /**< reference: OMX_VIDEO_PARAM_RVTYPE */
+    OMX_IndexParamVideoAvc,                 /**< reference: OMX_VIDEO_PARAM_AVCTYPE */
+    OMX_IndexParamVideoH263,                /**< reference: OMX_VIDEO_PARAM_H263TYPE */
+    OMX_IndexParamVideoProfileLevelQuerySupported, /**< reference: OMX_VIDEO_PARAM_PROFILELEVELTYPE */
+    OMX_IndexParamVideoProfileLevelCurrent, /**< reference: OMX_VIDEO_PARAM_PROFILELEVELTYPE */
+    OMX_IndexConfigVideoBitrate,            /**< reference: OMX_VIDEO_CONFIG_BITRATETYPE */
+    OMX_IndexConfigVideoFramerate,          /**< reference: OMX_CONFIG_FRAMERATETYPE */
+    OMX_IndexConfigVideoIntraVOPRefresh,    /**< reference: OMX_CONFIG_INTRAREFRESHVOPTYPE */
+    OMX_IndexConfigVideoIntraMBRefresh,     /**< reference: OMX_CONFIG_MACROBLOCKERRORMAPTYPE */
+    OMX_IndexConfigVideoMBErrorReporting,   /**< reference: OMX_CONFIG_MBERRORREPORTINGTYPE */
+    OMX_IndexParamVideoMacroblocksPerFrame, /**< reference: OMX_PARAM_MACROBLOCKSTYPE */
+    OMX_IndexConfigVideoMacroBlockErrorMap, /**< reference: OMX_CONFIG_MACROBLOCKERRORMAPTYPE */
+    OMX_IndexParamVideoSliceFMO,            /**< reference: OMX_VIDEO_PARAM_AVCSLICEFMO */
+    OMX_IndexConfigVideoAVCIntraPeriod,     /**< reference: OMX_VIDEO_CONFIG_AVCINTRAPERIOD */
+    OMX_IndexConfigVideoNalSize,            /**< reference: OMX_VIDEO_CONFIG_NALSIZE */
+
+    /* Image & Video common Configurations */
+    OMX_IndexCommonStartUnused = 0x07000000,
+    OMX_IndexParamCommonDeblocking,         /**< reference: OMX_PARAM_DEBLOCKINGTYPE */
+    OMX_IndexParamCommonSensorMode,         /**< reference: OMX_PARAM_SENSORMODETYPE */
+    OMX_IndexParamCommonInterleave,         /**< reference: OMX_PARAM_INTERLEAVETYPE */
+    OMX_IndexConfigCommonColorFormatConversion, /**< reference: OMX_CONFIG_COLORCONVERSIONTYPE */
+    OMX_IndexConfigCommonScale,             /**< reference: OMX_CONFIG_SCALEFACTORTYPE */
+    OMX_IndexConfigCommonImageFilter,       /**< reference: OMX_CONFIG_IMAGEFILTERTYPE */
+    OMX_IndexConfigCommonColorEnhancement,  /**< reference: OMX_CONFIG_COLORENHANCEMENTTYPE */
+    OMX_IndexConfigCommonColorKey,          /**< reference: OMX_CONFIG_COLORKEYTYPE */
+    OMX_IndexConfigCommonColorBlend,        /**< reference: OMX_CONFIG_COLORBLENDTYPE */
+    OMX_IndexConfigCommonFrameStabilisation,/**< reference: OMX_CONFIG_FRAMESTABTYPE */
+    OMX_IndexConfigCommonRotate,            /**< reference: OMX_CONFIG_ROTATIONTYPE */
+    OMX_IndexConfigCommonMirror,            /**< reference: OMX_CONFIG_MIRRORTYPE */
+    OMX_IndexConfigCommonOutputPosition,    /**< reference: OMX_CONFIG_POINTTYPE */
+    OMX_IndexConfigCommonInputCrop,         /**< reference: OMX_CONFIG_RECTTYPE */
+    OMX_IndexConfigCommonOutputCrop,        /**< reference: OMX_CONFIG_RECTTYPE */
+    OMX_IndexConfigCommonDigitalZoom,       /**< reference: OMX_CONFIG_SCALEFACTORTYPE */
+    OMX_IndexConfigCommonOpticalZoom,       /**< reference: OMX_CONFIG_SCALEFACTORTYPE*/
+    OMX_IndexConfigCommonWhiteBalance,      /**< reference: OMX_CONFIG_WHITEBALCONTROLTYPE */
+    OMX_IndexConfigCommonExposure,          /**< reference: OMX_CONFIG_EXPOSURECONTROLTYPE */
+    OMX_IndexConfigCommonContrast,          /**< reference: OMX_CONFIG_CONTRASTTYPE */
+    OMX_IndexConfigCommonBrightness,        /**< reference: OMX_CONFIG_BRIGHTNESSTYPE */
+    OMX_IndexConfigCommonBacklight,         /**< reference: OMX_CONFIG_BACKLIGHTTYPE */
+    OMX_IndexConfigCommonGamma,             /**< reference: OMX_CONFIG_GAMMATYPE */
+    OMX_IndexConfigCommonSaturation,        /**< reference: OMX_CONFIG_SATURATIONTYPE */
+    OMX_IndexConfigCommonLightness,         /**< reference: OMX_CONFIG_LIGHTNESSTYPE */
+    OMX_IndexConfigCommonExclusionRect,     /**< reference: OMX_CONFIG_RECTTYPE */
+    OMX_IndexConfigCommonDithering,         /**< reference: OMX_CONFIG_DITHERTYPE */
+    OMX_IndexConfigCommonPlaneBlend,        /**< reference: OMX_CONFIG_PLANEBLENDTYPE */
+    OMX_IndexConfigCommonExposureValue,     /**< reference: OMX_CONFIG_EXPOSUREVALUETYPE */
+    OMX_IndexConfigCommonOutputSize,        /**< reference: OMX_FRAMESIZETYPE */
+    OMX_IndexParamCommonExtraQuantData,     /**< reference: OMX_OTHER_EXTRADATATYPE */
+    OMX_IndexConfigCommonFocusRegion,       /**< reference: OMX_CONFIG_FOCUSREGIONTYPE */
+    OMX_IndexConfigCommonFocusStatus,       /**< reference: OMX_PARAM_FOCUSSTATUSTYPE */
+    OMX_IndexConfigCommonTransitionEffect,  /**< reference: OMX_CONFIG_TRANSITIONEFFECTTYPE */
+
+    /* Reserved Configuration range */
+    OMX_IndexOtherStartUnused = 0x08000000,
+    OMX_IndexParamOtherPortFormat,          /**< reference: OMX_OTHER_PARAM_PORTFORMATTYPE */
+    OMX_IndexConfigOtherPower,              /**< reference: OMX_OTHER_CONFIG_POWERTYPE */
+    OMX_IndexConfigOtherStats,              /**< reference: OMX_OTHER_CONFIG_STATSTYPE */
+
+
+    /* Reserved Time range */
+    OMX_IndexTimeStartUnused = 0x09000000,
+    OMX_IndexConfigTimeScale,               /**< reference: OMX_TIME_CONFIG_SCALETYPE */
+    OMX_IndexConfigTimeClockState,          /**< reference: OMX_TIME_CONFIG_CLOCKSTATETYPE */
+    OMX_IndexConfigTimeActiveRefClock,      /**< reference: OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE */
+    OMX_IndexConfigTimeCurrentMediaTime,    /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only) */
+    OMX_IndexConfigTimeCurrentWallTime,     /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only) */
+    OMX_IndexConfigTimeCurrentAudioReference, /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
+    OMX_IndexConfigTimeCurrentVideoReference, /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
+    OMX_IndexConfigTimeMediaTimeRequest,    /**< reference: OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE (write only) */
+    OMX_IndexConfigTimeClientStartTime,     /**<reference:  OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
+    OMX_IndexConfigTimePosition,            /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE */
+    OMX_IndexConfigTimeSeekMode,            /**< reference: OMX_TIME_CONFIG_SEEKMODETYPE */
+
+
+    OMX_IndexKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    /* Vendor specific area */
+    OMX_IndexVendorStartUnused = 0x7F000000,
+    /* Vendor specific structures should be in the range of 0x7F000000 
+       to 0x7FFFFFFE.  This range is not broken out by vendor, so
+       private indexes are not guaranteed unique and therefore should
+       only be sent to the appropriate component. */
+
+    OMX_IndexMax = 0x7FFFFFFF
+
+} OMX_INDEXTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Other.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Other.h
new file mode 100644
index 0000000..caf7f38
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Other.h
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** @file OMX_Other.h - OpenMax IL version 1.1.2
+ *  The structures needed by Other components to exchange
+ *  parameters and configuration data with the components.
+ */
+
+#ifndef OMX_Other_h
+#define OMX_Other_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header must include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+
+#include <OMX_Core.h>
+
+
+/** 
+ * Enumeration of possible data types which match to multiple domains or no
+ * domain at all.  For types which are vendor specific, a value above
+ * OMX_OTHER_VENDORTSTART should be used.
+ */
+typedef enum OMX_OTHER_FORMATTYPE {
+    OMX_OTHER_FormatTime = 0, /**< Transmission of various timestamps, elapsed time, 
+                                   time deltas, etc */
+    OMX_OTHER_FormatPower,    /**< Perhaps used for enabling/disabling power 
+                                   management, setting clocks? */
+    OMX_OTHER_FormatStats,    /**< Could be things such as frame rate, frames 
+                                   dropped, etc */
+    OMX_OTHER_FormatBinary,   /**< Arbitrary binary data */
+    OMX_OTHER_FormatVendorReserved = 1000, /**< Starting value for vendor specific 
+                                                formats */
+
+    OMX_OTHER_FormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_OTHER_FormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_OTHER_FormatMax = 0x7FFFFFFF
+} OMX_OTHER_FORMATTYPE;
+
+/** 
+ * Enumeration of seek modes.
+ */
+typedef enum OMX_TIME_SEEKMODETYPE {
+    OMX_TIME_SeekModeFast = 0, /**< Prefer seeking to an approximation
+                                * of the requested seek position over   
+                                * the actual seek position if it
+                                * results in a faster seek. */
+    OMX_TIME_SeekModeAccurate, /**< Prefer seeking to the actual seek 
+                                * position over an approximation
+                                * of the requested seek position even
+                                * if it results in a slower seek. */
+    OMX_TIME_SeekModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_TIME_SeekModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_TIME_SeekModeMax = 0x7FFFFFFF
+} OMX_TIME_SEEKMODETYPE;
+
+/* Structure representing the seekmode of the component */
+typedef struct OMX_TIME_CONFIG_SEEKMODETYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_TIME_SEEKMODETYPE eType;    /**< The seek mode */
+} OMX_TIME_CONFIG_SEEKMODETYPE;
+
+/** Structure representing a time stamp used with the following configs 
+ * on the Clock Component (CC):
+ * 
+ * OMX_IndexConfigTimeCurrentWallTime: query of the CC’s current wall  
+ *     time
+ * OMX_IndexConfigTimeCurrentMediaTime: query of the CC’s current media
+ *     time
+ * OMX_IndexConfigTimeCurrentAudioReference and  
+ * OMX_IndexConfigTimeCurrentVideoReference: audio/video reference 
+ *     clock sending SC its reference time
+ * OMX_IndexConfigTimeClientStartTime: a Clock Component client sends 
+ *     this structure to the Clock Component via a SetConfig on its 
+ *     client port when it receives a buffer with
+ *     OMX_BUFFERFLAG_STARTTIME set. It must use the timestamp
+ *     specified by that buffer for nStartTimestamp. 
+ *
+ * It’s also used with the following config on components in general:
+ *
+ * OMX_IndexConfigTimePosition: IL client querying component position 
+ * (GetConfig) or commanding a component to seek to the given location
+ * (SetConfig)
+ */	
+typedef struct OMX_TIME_CONFIG_TIMESTAMPTYPE {
+    OMX_U32 nSize;               /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;    /**< OMX specification version
+                                  *   information */
+    OMX_U32 nPortIndex;     /**< port that this structure applies to */
+    OMX_TICKS nTimestamp;  	     /**< timestamp .*/ 
+} OMX_TIME_CONFIG_TIMESTAMPTYPE;  
+
+/** Enumeration of possible reference clocks to the media time. */
+typedef enum OMX_TIME_UPDATETYPE {
+      OMX_TIME_UpdateRequestFulfillment,    /**< Update is the fulfillment of a media time request. */
+      OMX_TIME_UpdateScaleChanged,	        /**< Update was generated because the scale chagned. */
+      OMX_TIME_UpdateClockStateChanged,     /**< Update was generated because the clock state changed. */
+      OMX_TIME_UpdateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+      OMX_TIME_UpdateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+      OMX_TIME_UpdateMax = 0x7FFFFFFF
+} OMX_TIME_UPDATETYPE;
+
+/** Enumeration of possible reference clocks to the media time. */
+typedef enum OMX_TIME_REFCLOCKTYPE {
+      OMX_TIME_RefClockNone,    /**< Use no references. */
+      OMX_TIME_RefClockAudio,	/**< Use references sent through OMX_IndexConfigTimeCurrentAudioReference */
+      OMX_TIME_RefClockVideo,   /**< Use references sent through OMX_IndexConfigTimeCurrentVideoReference */
+      OMX_TIME_RefClockKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+      OMX_TIME_RefClockVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+      OMX_TIME_RefClockMax = 0x7FFFFFFF
+} OMX_TIME_REFCLOCKTYPE;
+
+/** Enumeration of clock states. */
+typedef enum OMX_TIME_CLOCKSTATE {
+      OMX_TIME_ClockStateRunning,             /**< Clock running. */
+      OMX_TIME_ClockStateWaitingForStartTime, /**< Clock waiting until the 
+                                               *   prescribed clients emit their
+                                               *   start time. */
+      OMX_TIME_ClockStateStopped,             /**< Clock stopped. */
+      OMX_TIME_ClockStateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+      OMX_TIME_ClockStateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+      OMX_TIME_ClockStateMax = 0x7FFFFFFF
+} OMX_TIME_CLOCKSTATE;
+
+/** Structure representing a media time request to the clock component.
+ *
+ *  A client component sends this structure to the Clock Component via a SetConfig
+ *  on its client port to specify a media timestamp the Clock Component
+ *  should emit.  The Clock Component should fulfill the request by sending a
+ *  OMX_TIME_MEDIATIMETYPE when its media clock matches the requested 
+ *  timestamp.
+ *
+ *  The client may require a media time request be fulfilled slightly
+ *  earlier than the media time specified. In this case the client specifies 
+ *  an offset which is equal to the difference between wall time corresponding 
+ *  to the requested media time and the wall time when it will be 
+ *  fulfilled. 
+ *
+ *  A client component may uses these requests and the OMX_TIME_MEDIATIMETYPE to
+ *  time events according to timestamps. If a client must perform an operation O at
+ *  a time T (e.g. deliver a video frame at its corresponding timestamp), it makes a 
+ *  media time request at T (perhaps specifying an offset to ensure the request fulfillment
+ *  is a little early). When the clock component passes the resulting OMX_TIME_MEDIATIMETYPE
+ *  structure back to the client component, the client may perform operation O (perhaps having
+ *  to wait a slight amount more time itself as specified by the return values).
+ */
+
+typedef struct OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */
+    OMX_PTR pClientPrivate;     /**< Client private data to disabiguate this media time 
+                                 *   from others (e.g. the number of the frame to deliver). 
+                                 *   Duplicated in the media time structure that fulfills 
+                                 *   this request. A value of zero is reserved for time scale 
+                                 *   updates. */
+    OMX_TICKS nMediaTimestamp;  /**< Media timestamp requested.*/ 
+    OMX_TICKS nOffset;          /**< Amount of wall clock time by which this
+                                 *   request should be fulfilled early */
+} OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE;
+
+/**< Structure sent from the clock component client either when fulfilling 
+ *   a media time request or when the time scale has changed. 
+ *
+ *   In the former case the Clock Component fills this structure and times its emission 
+ *   to a client component (via the client port) according to the corresponding media 
+ *   time request sent by the client. The Clock Component should time the emission to occur
+ *   when the requested timestamp matches the Clock Component's media time but also the 
+ *   prescribed offset early. 
+ *
+ *   Upon scale changes the clock component clears the nClientPrivate data, sends the current
+ *   media time and sets the nScale to the new scale via the client port. It emits a 
+ *   OMX_TIME_MEDIATIMETYPE to all clients independent of any requests. This allows clients to 
+ *   alter processing to accomodate scaling. For instance a video component might skip inter-frames 
+ *   in the case of extreme fastforward. Likewise an audio component might add or remove samples 
+ *   from an audio frame to scale audio data. 
+ *
+ *   It is expected that some clock components may not be able to fulfill requests
+ *   at exactly the prescribed time. This is acceptable so long as the request is 
+ *   fulfilled at least as early as described and not later. This structure provides 
+ *   fields the client may use to wait for the remaining time.
+ *
+ *   The client may use either the nOffset or nWallTimeAtMedia fields to determine the 
+ *   wall time until the nMediaTimestamp actually occurs. In the latter case the
+ *   client can get a more accurate value for offset by getting the current wall
+ *   from the cloc component and subtracting it from nWallTimeAtMedia. 
+ */
+
+typedef struct OMX_TIME_MEDIATIMETYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_U32 nClientPrivate;         /**< Client private data to disabiguate this media time 
+                                     *   from others. Copied from the media time request. 
+                                     *   A value of zero is reserved for time scale updates. */
+    OMX_TIME_UPDATETYPE eUpdateType; /**< Reason for the update */
+    OMX_TICKS nMediaTimestamp;      /**< Media time requested. If no media time was 
+                                     *   requested then this is the current media time. */ 
+    OMX_TICKS nOffset;              /**< Amount of wall clock time by which this
+                                     *   request was actually fulfilled early */
+
+    OMX_TICKS nWallTimeAtMediaTime; /**< Wall time corresponding to nMediaTimeStamp.
+                                     *   A client may compare this value to current
+                                     *   media time obtained from the Clock Component to determine
+                                     *   the wall time until the media timestamp is really
+                                     *   current. */
+    OMX_S32 xScale;                 /**< Current media time scale in Q16 format. */
+    OMX_TIME_CLOCKSTATE eState;     /* Seeking Change. Added 7/12.*/
+                                    /**< State of the media time. */
+} OMX_TIME_MEDIATIMETYPE;  
+
+/** Structure representing the current media time scale factor. Applicable only to clock 
+ *  component, other components see scale changes via OMX_TIME_MEDIATIMETYPE buffers sent via
+ *  the clock component client ports. Upon recieving this config the clock component changes 
+ *  the rate by which the media time increases or decreases effectively implementing trick modes. 
+ */ 
+typedef struct OMX_TIME_CONFIG_SCALETYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_S32 xScale;                 /**< This is a value in Q16 format which is used for
+                                     * scaling the media time */
+} OMX_TIME_CONFIG_SCALETYPE;
+ 
+/** Bits used to identify a clock port. Used in OMX_TIME_CONFIG_CLOCKSTATETYPE’s nWaitMask field */
+#define OMX_CLOCKPORT0 0x00000001
+#define OMX_CLOCKPORT1 0x00000002
+#define OMX_CLOCKPORT2 0x00000004
+#define OMX_CLOCKPORT3 0x00000008
+#define OMX_CLOCKPORT4 0x00000010
+#define OMX_CLOCKPORT5 0x00000020
+#define OMX_CLOCKPORT6 0x00000040
+#define OMX_CLOCKPORT7 0x00000080
+
+/** Structure representing the current mode of the media clock. 
+ *  IL Client uses this config to change or query the mode of the 
+ *  media clock of the clock component. Applicable only to clock
+ *  component. 
+ *  
+ *  On a SetConfig if eState is OMX_TIME_ClockStateRunning media time
+ *  starts immediately at the prescribed start time. If
+ *  OMX_TIME_ClockStateWaitingForStartTime the Clock Component ignores
+ *  the given nStartTime and waits for all clients specified in the 
+ *  nWaitMask to send starttimes (via 
+ *  OMX_IndexConfigTimeClientStartTime). The Clock Component then starts 
+ *  the media clock using the earliest start time supplied. */    
+typedef struct OMX_TIME_CONFIG_CLOCKSTATETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version 
+                                 *   information */
+    OMX_TIME_CLOCKSTATE eState; /**< State of the media time. */
+    OMX_TICKS nStartTime;       /**< Start time of the media time. */
+    OMX_TICKS nOffset;          /**< Time to offset the media time by 
+                                 * (e.g. preroll). Media time will be
+                                 * reported to be nOffset ticks earlier.     
+                                 */
+    OMX_U32 nWaitMask;          /**< Mask of OMX_CLOCKPORT values. */
+} OMX_TIME_CONFIG_CLOCKSTATETYPE;
+
+/** Structure representing the reference clock currently being used to
+ *  compute media time. IL client uses this config to change or query the 
+ *  clock component's active reference clock */
+typedef struct OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_TIME_REFCLOCKTYPE eClock;   /**< Reference clock used to compute media time */                        
+} OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE;
+
+/** Descriptor for setting specifics of power type.
+ *  Note: this structure is listed for backwards compatibility. */
+typedef struct OMX_OTHER_CONFIG_POWERTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_BOOL bEnablePM;       /**< Flag to enable Power Management */
+} OMX_OTHER_CONFIG_POWERTYPE;
+
+
+/** Descriptor for setting specifics of stats type.
+ *  Note: this structure is listed for backwards compatibility. */
+typedef struct OMX_OTHER_CONFIG_STATSTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    /* what goes here */
+} OMX_OTHER_CONFIG_STATSTYPE;
+
+
+/**
+ * The PortDefinition structure is used to define all of the parameters 
+ * necessary for the compliant component to setup an input or an output other 
+ * path.
+ */
+typedef struct OMX_OTHER_PORTDEFINITIONTYPE {
+    OMX_OTHER_FORMATTYPE eFormat;  /**< Type of data expected for this channel */
+} OMX_OTHER_PORTDEFINITIONTYPE;
+
+/**  Port format parameter.  This structure is used to enumerate
+  *  the various data input/output format supported by the port.
+  */
+typedef struct OMX_OTHER_PARAM_PORTFORMATTYPE {
+    OMX_U32 nSize; /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex; /**< Indicates which port to set */
+    OMX_U32 nIndex; /**< Indicates the enumeration index for the format from 0x0 to N-1 */
+    OMX_OTHER_FORMATTYPE eFormat; /**< Type of data expected for this channel */
+} OMX_OTHER_PARAM_PORTFORMATTYPE; 
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Types.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Types.h
new file mode 100644
index 0000000..31be916
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Types.h
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** OMX_Types.h - OpenMax IL version 1.1.2
+ *  The OMX_Types header file contains the primitive type definitions used by 
+ *  the core, the application and the component.  This file may need to be
+ *  modified to be used on systems that do not have "char" set to 8 bits, 
+ *  "short" set to 16 bits and "long" set to 32 bits.
+ */
+
+#ifndef OMX_Types_h
+#define OMX_Types_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/** The OMX_API and OMX_APIENTRY are platform specific definitions used
+ *  to declare OMX function prototypes.  They are modified to meet the
+ *  requirements for a particular platform */
+#ifdef __SYMBIAN32__   
+#   ifdef __OMX_EXPORTS
+#       define OMX_API __declspec(dllexport)
+#   else
+#       ifdef _WIN32
+#           define OMX_API __declspec(dllexport) 
+#       else
+#           define OMX_API __declspec(dllimport)
+#       endif
+#   endif
+#else
+#   ifdef _WIN32
+#      ifdef __OMX_EXPORTS
+#          define OMX_API __declspec(dllexport)
+#      else
+#          define OMX_API __declspec(dllimport)
+#      endif
+#   else
+#      ifdef __OMX_EXPORTS
+#          define OMX_API
+#      else
+#          define OMX_API extern
+#      endif
+#   endif
+#endif
+
+#ifndef OMX_APIENTRY
+#define OMX_APIENTRY 
+#endif 
+
+/** OMX_IN is used to identify inputs to an OMX function.  This designation 
+    will also be used in the case of a pointer that points to a parameter 
+    that is used as an output. */
+#ifndef OMX_IN
+#define OMX_IN
+#endif
+
+/** OMX_OUT is used to identify outputs from an OMX function.  This 
+    designation will also be used in the case of a pointer that points 
+    to a parameter that is used as an input. */
+#ifndef OMX_OUT
+#define OMX_OUT
+#endif
+
+
+/** OMX_INOUT is used to identify parameters that may be either inputs or
+    outputs from an OMX function at the same time.  This designation will 
+    also be used in the case of a pointer that  points to a parameter that 
+    is used both as an input and an output. */
+#ifndef OMX_INOUT
+#define OMX_INOUT
+#endif
+
+/** OMX_ALL is used to as a wildcard to select all entities of the same type
+ *  when specifying the index, or referring to a object by an index.  (i.e.
+ *  use OMX_ALL to indicate all N channels). When used as a port index
+ *  for a config or parameter this OMX_ALL denotes that the config or
+ *  parameter applies to the entire component not just one port. */
+#define OMX_ALL 0xFFFFFFFF
+
+/** In the following we define groups that help building doxygen documentation */
+
+/** @defgroup core OpenMAX IL core
+ * Functions and structure related to the OMX IL core
+ */
+ 
+ /** @defgroup comp OpenMAX IL component
+ * Functions and structure related to the OMX IL component
+ */
+ 
+/** @defgroup rpm Resource and Policy Management 
+ * Structures for resource and policy management of components
+ */
+
+/** @defgroup buf Buffer Management
+ * Buffer handling functions and structures
+ */
+  
+/** @defgroup tun Tunneling
+ * @ingroup core comp
+ * Structures and functions to manage tunnels among component ports
+ */
+ 
+/** @defgroup cp Content Pipes
+ *  @ingroup core
+ */
+ 
+ /** @defgroup metadata Metadata handling
+  * 
+  */ 
+
+/** OMX_U8 is an 8 bit unsigned quantity that is byte aligned */
+typedef unsigned char OMX_U8;
+
+/** OMX_S8 is an 8 bit signed quantity that is byte aligned */
+typedef signed char OMX_S8;
+
+/** OMX_U16 is a 16 bit unsigned quantity that is 16 bit word aligned */
+typedef unsigned short OMX_U16;
+
+/** OMX_S16 is a 16 bit signed quantity that is 16 bit word aligned */
+typedef signed short OMX_S16;
+
+/** OMX_U32 is a 32 bit unsigned quantity that is 32 bit word aligned */
+typedef unsigned long OMX_U32;
+
+/** OMX_S32 is a 32 bit signed quantity that is 32 bit word aligned */
+typedef signed long OMX_S32;
+
+
+/* Users with compilers that cannot accept the "long long" designation should
+   define the OMX_SKIP64BIT macro.  It should be noted that this may cause 
+   some components to fail to compile if the component was written to require
+   64 bit integral types.  However, these components would NOT compile anyway
+   since the compiler does not support the way the component was written.
+*/
+#ifndef OMX_SKIP64BIT
+#ifdef __SYMBIAN32__
+/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
+typedef unsigned long long OMX_U64;
+
+/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
+typedef signed long long OMX_S64;
+
+#elif defined(WIN32)
+
+/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */   
+typedef unsigned __int64  OMX_U64;
+
+/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
+typedef signed   __int64  OMX_S64;
+
+#else /* WIN32 */
+
+/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
+typedef unsigned long long OMX_U64;
+
+/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
+typedef signed long long OMX_S64;
+
+#endif /* WIN32 */
+#endif
+
+
+/** The OMX_BOOL type is intended to be used to represent a true or a false 
+    value when passing parameters to and from the OMX core and components.  The
+    OMX_BOOL is a 32 bit quantity and is aligned on a 32 bit word boundary.
+ */
+typedef enum OMX_BOOL {
+    OMX_FALSE = 0,
+    OMX_TRUE = !OMX_FALSE,
+    OMX_BOOL_MAX = 0x7FFFFFFF
+} OMX_BOOL; 
+ 
+/** The OMX_PTR type is intended to be used to pass pointers between the OMX
+    applications and the OMX Core and components.  This is a 32 bit pointer and
+    is aligned on a 32 bit boundary.
+ */
+typedef void* OMX_PTR;
+
+/** The OMX_STRING type is intended to be used to pass "C" type strings between
+    the application and the core and component.  The OMX_STRING type is a 32 
+    bit pointer to a zero terminated string.  The  pointer is word aligned and 
+    the string is byte aligned.  
+ */
+typedef char* OMX_STRING;
+
+/** The OMX_BYTE type is intended to be used to pass arrays of bytes such as
+    buffers between the application and the component and core.  The OMX_BYTE 
+    type is a 32 bit pointer to a zero terminated string.  The  pointer is word
+    aligned and the string is byte aligned.
+ */
+typedef unsigned char* OMX_BYTE;
+
+/** OMX_UUIDTYPE is a very long unique identifier to uniquely identify
+    at runtime.  This identifier should be generated by a component in a way
+    that guarantees that every instance of the identifier running on the system
+    is unique. */
+typedef unsigned char OMX_UUIDTYPE[128];
+
+/** The OMX_DIRTYPE enumeration is used to indicate if a port is an input or
+    an output port.  This enumeration is common across all component types.    
+ */
+typedef enum OMX_DIRTYPE
+{
+    OMX_DirInput,              /**< Port is an input port */
+    OMX_DirOutput,             /**< Port is an output port */
+    OMX_DirMax = 0x7FFFFFFF
+} OMX_DIRTYPE;
+
+/** The OMX_ENDIANTYPE enumeration is used to indicate the bit ordering 
+    for numerical data (i.e. big endian, or little endian).    
+ */
+typedef enum OMX_ENDIANTYPE
+{
+    OMX_EndianBig, /**< big endian */
+    OMX_EndianLittle, /**< little endian */
+    OMX_EndianMax = 0x7FFFFFFF
+} OMX_ENDIANTYPE;
+
+
+/** The OMX_NUMERICALDATATYPE enumeration is used to indicate if data 
+    is signed or unsigned
+ */
+typedef enum OMX_NUMERICALDATATYPE
+{
+    OMX_NumericalDataSigned, /**< signed data */
+    OMX_NumericalDataUnsigned, /**< unsigned data */
+    OMX_NumercialDataMax = 0x7FFFFFFF
+} OMX_NUMERICALDATATYPE;
+
+
+/** Unsigned bounded value type */
+typedef struct OMX_BU32 {
+    OMX_U32 nValue; /**< actual value */
+    OMX_U32 nMin;   /**< minimum for value (i.e. nValue >= nMin) */
+    OMX_U32 nMax;   /**< maximum for value (i.e. nValue <= nMax) */
+} OMX_BU32;
+
+
+/** Signed bounded value type */
+typedef struct OMX_BS32 {
+    OMX_S32 nValue; /**< actual value */
+    OMX_S32 nMin;   /**< minimum for value (i.e. nValue >= nMin) */
+    OMX_S32 nMax;   /**< maximum for value (i.e. nValue <= nMax) */
+} OMX_BS32;
+
+
+/** Structure representing some time or duration in microseconds. This structure
+  *  must be interpreted as a signed 64 bit value. The quantity is signed to accommodate 
+  *  negative deltas and preroll scenarios. The quantity is represented in microseconds 
+  *  to accomodate high resolution timestamps (e.g. DVD presentation timestamps based
+  *  on a 90kHz clock) and to allow more accurate and synchronized delivery (e.g. 
+  *  individual audio samples delivered at 192 kHz). The quantity is 64 bit to 
+  *  accommodate a large dynamic range (signed 32 bit values would allow only for plus
+  *  or minus 35 minutes).
+  *
+  *  Implementations with limited precision may convert the signed 64 bit value to 
+  *  a signed 32 bit value internally but risk loss of precision.  
+  */
+#ifndef OMX_SKIP64BIT
+typedef OMX_S64 OMX_TICKS;
+#else
+typedef struct OMX_TICKS
+{
+    OMX_U32 nLowPart;    /** low bits of the signed 64 bit tick value */
+    OMX_U32 nHighPart;   /** high bits of the signed 64 bit tick value */
+} OMX_TICKS;
+#endif
+#define OMX_TICKS_PER_SECOND 1000000
+
+/** Define the public interface for the OMX Handle.  The core will not use
+    this value internally, but the application should only use this value.
+ */
+typedef void* OMX_HANDLETYPE;
+
+typedef struct OMX_MARKTYPE
+{
+    OMX_HANDLETYPE hMarkTargetComponent;   /**< The component that will 
+                                                generate a mark event upon 
+                                                processing the mark. */
+    OMX_PTR pMarkData;   /**< Application specific data associated with 
+                              the mark sent on a mark event to disambiguate 
+                              this mark from others. */
+} OMX_MARKTYPE;
+
+
+/** OMX_NATIVE_DEVICETYPE is used to map a OMX video port to the
+ *  platform & operating specific object used to reference the display 
+ *  or can be used by a audio port for native audio rendering */
+typedef void* OMX_NATIVE_DEVICETYPE;
+
+/** OMX_NATIVE_WINDOWTYPE is used to map a OMX video port to the
+ *  platform & operating specific object used to reference the window */
+typedef void* OMX_NATIVE_WINDOWTYPE;
+
+/** The OMX_VERSIONTYPE union is used to specify the version for
+    a structure or component.  For a component, the version is entirely
+    specified by the component vendor.  Components doing the same function
+    from different vendors may or may not have the same version.  For 
+    structures, the version shall be set by the entity that allocates the
+    structure.  For structures specified in the OMX 1.1 specification, the
+    value of the version shall be set to 1.1.0.0 in all cases.  Access to the
+    OMX_VERSIONTYPE can be by a single 32 bit access (e.g. by nVersion) or
+    by accessing one of the structure elements to, for example, check only
+    the Major revision.
+ */
+typedef union OMX_VERSIONTYPE
+{
+    struct
+    {
+        OMX_U8 nVersionMajor;   /**< Major version accessor element */
+        OMX_U8 nVersionMinor;   /**< Minor version accessor element */
+        OMX_U8 nRevision;       /**< Revision version accessor element */
+        OMX_U8 nStep;           /**< Step version accessor element */
+    } s;
+    OMX_U32 nVersion;           /**< 32 bit value to make accessing the
+                                    version easily done in a single word
+                                    size copy/compare operation */
+} OMX_VERSIONTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Video.h b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Video.h
new file mode 100644
index 0000000..163e450
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Video.h
@@ -0,0 +1,1060 @@
+/**
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** 
+ *  @file OMX_Video.h - OpenMax IL version 1.1.2
+ *  The structures is needed by Video components to exchange parameters 
+ *  and configuration data with OMX components.
+ */
+#ifndef OMX_Video_h
+#define OMX_Video_h
+
+/** @defgroup video OpenMAX IL Video Domain
+ * @ingroup iv
+ * Structures for OpenMAX IL Video domain
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/**
+ * Each OMX header must include all required header files to allow the
+ * header to compile without errors.  The includes below are required
+ * for this header file to compile successfully 
+ */
+
+#include <OMX_IVCommon.h>
+
+
+/**
+ * Enumeration used to define the possible video compression codings.  
+ * NOTE:  This essentially refers to file extensions. If the coding is 
+ *        being used to specify the ENCODE type, then additional work 
+ *        must be done to configure the exact flavor of the compression 
+ *        to be used.  For decode cases where the user application can 
+ *        not differentiate between MPEG-4 and H.264 bit streams, it is 
+ *        up to the codec to handle this.
+ */
+typedef enum OMX_VIDEO_CODINGTYPE {
+    OMX_VIDEO_CodingUnused,     /**< Value when coding is N/A */
+    OMX_VIDEO_CodingAutoDetect, /**< Autodetection of coding type */
+    OMX_VIDEO_CodingMPEG2,      /**< AKA: H.262 */
+    OMX_VIDEO_CodingH263,       /**< H.263 */
+    OMX_VIDEO_CodingMPEG4,      /**< MPEG-4 */
+    OMX_VIDEO_CodingWMV,        /**< all versions of Windows Media Video */
+    OMX_VIDEO_CodingRV,         /**< all versions of Real Video */
+    OMX_VIDEO_CodingAVC,        /**< H.264/AVC */
+    OMX_VIDEO_CodingMJPEG,      /**< Motion JPEG */
+    OMX_VIDEO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_CodingMax = 0x7FFFFFFF
+} OMX_VIDEO_CODINGTYPE;
+
+
+/**
+ * Data structure used to define a video path.  The number of Video paths for 
+ * input and output will vary by type of the Video component.  
+ * 
+ *    Input (aka Source) : zero Inputs, one Output,
+ *    Splitter           : one Input, 2 or more Outputs,
+ *    Processing Element : one Input, one output,
+ *    Mixer              : 2 or more inputs, one output,
+ *    Output (aka Sink)  : one Input, zero outputs.
+ * 
+ * The PortDefinition structure is used to define all of the parameters 
+ * necessary for the compliant component to setup an input or an output video 
+ * path.  If additional vendor specific data is required, it should be 
+ * transmitted to the component using the CustomCommand function.  Compliant 
+ * components will prepopulate this structure with optimal values during the 
+ * GetDefaultInitParams command.
+ *
+ * STRUCT MEMBERS:
+ *  cMIMEType             : MIME type of data for the port
+ *  pNativeRender         : Platform specific reference for a display if a 
+ *                          sync, otherwise this field is 0
+ *  nFrameWidth           : Width of frame to be used on channel if 
+ *                          uncompressed format is used.  Use 0 for unknown,
+ *                          don't care or variable
+ *  nFrameHeight          : Height of frame to be used on channel if 
+ *                          uncompressed format is used. Use 0 for unknown,
+ *                          don't care or variable
+ *  nStride               : Number of bytes per span of an image 
+ *                          (i.e. indicates the number of bytes to get
+ *                          from span N to span N+1, where negative stride
+ *                          indicates the image is bottom up
+ *  nSliceHeight          : Height used when encoding in slices
+ *  nBitrate              : Bit rate of frame to be used on channel if 
+ *                          compressed format is used. Use 0 for unknown, 
+ *                          don't care or variable
+ *  xFramerate            : Frame rate to be used on channel if uncompressed 
+ *                          format is used. Use 0 for unknown, don't care or 
+ *                          variable.  Units are Q16 frames per second.
+ *  bFlagErrorConcealment : Turns on error concealment if it is supported by 
+ *                          the OMX component
+ *  eCompressionFormat    : Compression format used in this instance of the 
+ *                          component. When OMX_VIDEO_CodingUnused is 
+ *                          specified, eColorFormat is used
+ *  eColorFormat : Decompressed format used by this component
+ *  pNativeWindow : Platform specific reference for a window object if a 
+ *                          display sink , otherwise this field is 0x0. 
+ */
+typedef struct OMX_VIDEO_PORTDEFINITIONTYPE {
+    OMX_STRING cMIMEType;
+    OMX_NATIVE_DEVICETYPE pNativeRender;
+    OMX_U32 nFrameWidth;
+    OMX_U32 nFrameHeight;
+    OMX_S32 nStride;
+    OMX_U32 nSliceHeight;
+    OMX_U32 nBitrate;
+    OMX_U32 xFramerate;
+    OMX_BOOL bFlagErrorConcealment;
+    OMX_VIDEO_CODINGTYPE eCompressionFormat;
+    OMX_COLOR_FORMATTYPE eColorFormat;
+    OMX_NATIVE_WINDOWTYPE pNativeWindow;
+} OMX_VIDEO_PORTDEFINITIONTYPE;
+
+/**  
+ * Port format parameter.  This structure is used to enumerate the various 
+ * data input/output format supported by the port.
+ * 
+ * STRUCT MEMBERS:
+ *  nSize              : Size of the structure in bytes
+ *  nVersion           : OMX specification version information
+ *  nPortIndex         : Indicates which port to set
+ *  nIndex             : Indicates the enumeration index for the format from 
+ *                       0x0 to N-1
+ *  eCompressionFormat : Compression format used in this instance of the 
+ *                       component. When OMX_VIDEO_CodingUnused is specified, 
+ *                       eColorFormat is used 
+ *  eColorFormat       : Decompressed format used by this component
+ *  xFrameRate         : Indicates the video frame rate in Q16 format
+ */
+typedef struct OMX_VIDEO_PARAM_PORTFORMATTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nIndex;
+    OMX_VIDEO_CODINGTYPE eCompressionFormat; 
+    OMX_COLOR_FORMATTYPE eColorFormat;
+    OMX_U32 xFramerate;
+} OMX_VIDEO_PARAM_PORTFORMATTYPE;
+
+
+/**
+ * This is a structure for configuring video compression quantization 
+ * parameter values.  Codecs may support different QP values for different
+ * frame types.
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version info
+ *  nPortIndex : Port that this structure applies to
+ *  nQpI       : QP value to use for index frames
+ *  nQpP       : QP value to use for P frames
+ *  nQpB       : QP values to use for bidirectional frames 
+ */
+typedef struct OMX_VIDEO_PARAM_QUANTIZATIONTYPE {
+    OMX_U32 nSize;            
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nQpI;
+    OMX_U32 nQpP;
+    OMX_U32 nQpB;
+} OMX_VIDEO_PARAM_QUANTIZATIONTYPE;
+
+
+/** 
+ * Structure for configuration of video fast update parameters. 
+ *  
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version info 
+ *  nPortIndex : Port that this structure applies to
+ *  bEnableVFU : Enable/Disable video fast update
+ *  nFirstGOB  : Specifies the number of the first macroblock row
+ *  nFirstMB   : specifies the first MB relative to the specified first GOB
+ *  nNumMBs    : Specifies the number of MBs to be refreshed from nFirstGOB 
+ *               and nFirstMB
+ */
+typedef struct OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE {
+    OMX_U32 nSize;            
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;       
+    OMX_BOOL bEnableVFU;      
+    OMX_U32 nFirstGOB;                            
+    OMX_U32 nFirstMB;                            
+    OMX_U32 nNumMBs;                                  
+} OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE;
+
+
+/** 
+ * Enumeration of possible bitrate control types 
+ */
+typedef enum OMX_VIDEO_CONTROLRATETYPE {
+    OMX_Video_ControlRateDisable,
+    OMX_Video_ControlRateVariable,
+    OMX_Video_ControlRateConstant,
+    OMX_Video_ControlRateVariableSkipFrames,
+    OMX_Video_ControlRateConstantSkipFrames,
+    OMX_Video_ControlRateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_Video_ControlRateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_Video_ControlRateMax = 0x7FFFFFFF
+} OMX_VIDEO_CONTROLRATETYPE;
+
+
+/** 
+ * Structure for configuring bitrate mode of a codec. 
+ *
+ * STRUCT MEMBERS:
+ *  nSize          : Size of the struct in bytes
+ *  nVersion       : OMX spec version info
+ *  nPortIndex     : Port that this struct applies to
+ *  eControlRate   : Control rate type enum
+ *  nTargetBitrate : Target bitrate to encode with
+ */
+typedef struct OMX_VIDEO_PARAM_BITRATETYPE {
+    OMX_U32 nSize;                          
+    OMX_VERSIONTYPE nVersion;               
+    OMX_U32 nPortIndex;                     
+    OMX_VIDEO_CONTROLRATETYPE eControlRate; 
+    OMX_U32 nTargetBitrate;                 
+} OMX_VIDEO_PARAM_BITRATETYPE;
+
+
+/** 
+ * Enumeration of possible motion vector (MV) types 
+ */
+typedef enum OMX_VIDEO_MOTIONVECTORTYPE {
+    OMX_Video_MotionVectorPixel,
+    OMX_Video_MotionVectorHalfPel,
+    OMX_Video_MotionVectorQuarterPel,
+    OMX_Video_MotionVectorEighthPel,
+    OMX_Video_MotionVectorKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_Video_MotionVectorVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_Video_MotionVectorMax = 0x7FFFFFFF
+} OMX_VIDEO_MOTIONVECTORTYPE;
+
+
+/**
+ * Structure for configuring the number of motion vectors used as well
+ * as their accuracy.
+ * 
+ * STRUCT MEMBERS:
+ *  nSize            : Size of the struct in bytes
+ *  nVersion         : OMX spec version info
+ *  nPortIndex       : port that this structure applies to
+ *  eAccuracy        : Enumerated MV accuracy
+ *  bUnrestrictedMVs : Allow unrestricted MVs
+ *  bFourMV          : Allow use of 4 MVs
+ *  sXSearchRange    : Search range in horizontal direction for MVs
+ *  sYSearchRange    : Search range in vertical direction for MVs
+ */
+typedef struct OMX_VIDEO_PARAM_MOTIONVECTORTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEO_MOTIONVECTORTYPE eAccuracy;
+    OMX_BOOL bUnrestrictedMVs;
+    OMX_BOOL bFourMV;
+    OMX_S32 sXSearchRange;
+    OMX_S32 sYSearchRange;
+} OMX_VIDEO_PARAM_MOTIONVECTORTYPE;
+
+
+/** 
+ * Enumeration of possible methods to use for Intra Refresh 
+ */
+typedef enum OMX_VIDEO_INTRAREFRESHTYPE {
+    OMX_VIDEO_IntraRefreshCyclic,
+    OMX_VIDEO_IntraRefreshAdaptive,
+    OMX_VIDEO_IntraRefreshBoth,
+    OMX_VIDEO_IntraRefreshKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_IntraRefreshVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_IntraRefreshMax = 0x7FFFFFFF
+} OMX_VIDEO_INTRAREFRESHTYPE;
+
+
+/**
+ * Structure for configuring intra refresh mode 
+ * 
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  eRefreshMode : Cyclic, Adaptive, or Both
+ *  nAirMBs      : Number of intra macroblocks to refresh in a frame when 
+ *                 AIR is enabled
+ *  nAirRef      : Number of times a motion marked macroblock has to be  
+ *                 intra coded
+ *  nCirMBs      : Number of consecutive macroblocks to be coded as "intra"  
+ *                 when CIR is enabled
+ */
+typedef struct OMX_VIDEO_PARAM_INTRAREFRESHTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEO_INTRAREFRESHTYPE eRefreshMode;
+    OMX_U32 nAirMBs;
+    OMX_U32 nAirRef;
+    OMX_U32 nCirMBs;
+} OMX_VIDEO_PARAM_INTRAREFRESHTYPE;
+
+
+/**
+ * Structure for enabling various error correction methods for video 
+ * compression.
+ *
+ * STRUCT MEMBERS:
+ *  nSize                   : Size of the structure in bytes
+ *  nVersion                : OMX specification version information 
+ *  nPortIndex              : Port that this structure applies to 
+ *  bEnableHEC              : Enable/disable header extension codes (HEC)
+ *  bEnableResync           : Enable/disable resynchronization markers
+ *  nResynchMarkerSpacing   : Resynch markers interval (in bits) to be 
+ *                            applied in the stream 
+ *  bEnableDataPartitioning : Enable/disable data partitioning 
+ *  bEnableRVLC             : Enable/disable reversible variable length 
+ *                            coding
+ */
+typedef struct OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnableHEC;
+    OMX_BOOL bEnableResync;
+    OMX_U32  nResynchMarkerSpacing;
+    OMX_BOOL bEnableDataPartitioning;
+    OMX_BOOL bEnableRVLC;
+} OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE;
+
+
+/** 
+ * Configuration of variable block-size motion compensation (VBSMC) 
+ * 
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to
+ *  b16x16     : Enable inter block search 16x16
+ *  b16x8      : Enable inter block search 16x8
+ *  b8x16      : Enable inter block search 8x16
+ *  b8x8       : Enable inter block search 8x8
+ *  b8x4       : Enable inter block search 8x4
+ *  b4x8       : Enable inter block search 4x8
+ *  b4x4       : Enable inter block search 4x4
+ */
+typedef struct OMX_VIDEO_PARAM_VBSMCTYPE {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;       
+    OMX_BOOL b16x16; 
+    OMX_BOOL b16x8; 
+    OMX_BOOL b8x16;
+    OMX_BOOL b8x8;
+    OMX_BOOL b8x4;
+    OMX_BOOL b4x8;
+    OMX_BOOL b4x4;
+} OMX_VIDEO_PARAM_VBSMCTYPE;
+
+
+/** 
+ * H.263 profile types, each profile indicates support for various 
+ * performance bounds and different annexes.
+ *
+ * ENUMS:
+ *  Baseline           : Baseline Profile: H.263 (V1), no optional modes                                                    
+ *  H320 Coding        : H.320 Coding Efficiency Backward Compatibility 
+ *                       Profile: H.263+ (V2), includes annexes I, J, L.4
+ *                       and T
+ *  BackwardCompatible : Backward Compatibility Profile: H.263 (V1), 
+ *                       includes annex F                                    
+ *  ISWV2              : Interactive Streaming Wireless Profile: H.263+ 
+ *                       (V2), includes annexes I, J, K and T                 
+ *  ISWV3              : Interactive Streaming Wireless Profile: H.263++  
+ *                       (V3), includes profile 3 and annexes V and W.6.3.8   
+ *  HighCompression    : Conversational High Compression Profile: H.263++  
+ *                       (V3), includes profiles 1 & 2 and annexes D and U   
+ *  Internet           : Conversational Internet Profile: H.263++ (V3),  
+ *                       includes profile 5 and annex K                       
+ *  Interlace          : Conversational Interlace Profile: H.263++ (V3),  
+ *                       includes profile 5 and annex W.6.3.11               
+ *  HighLatency        : High Latency Profile: H.263++ (V3), includes  
+ *                       profile 6 and annexes O.1 and P.5                       
+ */
+typedef enum OMX_VIDEO_H263PROFILETYPE {
+    OMX_VIDEO_H263ProfileBaseline            = 0x01,        
+    OMX_VIDEO_H263ProfileH320Coding          = 0x02,          
+    OMX_VIDEO_H263ProfileBackwardCompatible  = 0x04,  
+    OMX_VIDEO_H263ProfileISWV2               = 0x08,               
+    OMX_VIDEO_H263ProfileISWV3               = 0x10,               
+    OMX_VIDEO_H263ProfileHighCompression     = 0x20,     
+    OMX_VIDEO_H263ProfileInternet            = 0x40,            
+    OMX_VIDEO_H263ProfileInterlace           = 0x80,           
+    OMX_VIDEO_H263ProfileHighLatency         = 0x100,         
+    OMX_VIDEO_H263ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_H263ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_H263ProfileMax                 = 0x7FFFFFFF  
+} OMX_VIDEO_H263PROFILETYPE;
+
+
+/** 
+ * H.263 level types, each level indicates support for various frame sizes, 
+ * bit rates, decoder frame rates.
+ */
+typedef enum OMX_VIDEO_H263LEVELTYPE {
+    OMX_VIDEO_H263Level10  = 0x01,  
+    OMX_VIDEO_H263Level20  = 0x02,      
+    OMX_VIDEO_H263Level30  = 0x04,      
+    OMX_VIDEO_H263Level40  = 0x08,      
+    OMX_VIDEO_H263Level45  = 0x10,      
+    OMX_VIDEO_H263Level50  = 0x20,      
+    OMX_VIDEO_H263Level60  = 0x40,      
+    OMX_VIDEO_H263Level70  = 0x80, 
+    OMX_VIDEO_H263LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_H263LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_H263LevelMax = 0x7FFFFFFF  
+} OMX_VIDEO_H263LEVELTYPE;
+
+
+/** 
+ * Specifies the picture type. These values should be OR'd to signal all 
+ * pictures types which are allowed.
+ *
+ * ENUMS:
+ *  Generic Picture Types:          I, P and B
+ *  H.263 Specific Picture Types:   SI and SP
+ *  H.264 Specific Picture Types:   EI and EP
+ *  MPEG-4 Specific Picture Types:  S
+ */
+typedef enum OMX_VIDEO_PICTURETYPE {
+    OMX_VIDEO_PictureTypeI   = 0x01,
+    OMX_VIDEO_PictureTypeP   = 0x02,
+    OMX_VIDEO_PictureTypeB   = 0x04,
+    OMX_VIDEO_PictureTypeSI  = 0x08,
+    OMX_VIDEO_PictureTypeSP  = 0x10,
+    OMX_VIDEO_PictureTypeEI  = 0x11,
+    OMX_VIDEO_PictureTypeEP  = 0x12,
+    OMX_VIDEO_PictureTypeS   = 0x14,
+    OMX_VIDEO_PictureTypeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_PictureTypeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_PictureTypeMax = 0x7FFFFFFF
+} OMX_VIDEO_PICTURETYPE;
+
+
+/** 
+ * H.263 Params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize                    : Size of the structure in bytes
+ *  nVersion                 : OMX specification version information 
+ *  nPortIndex               : Port that this structure applies to
+ *  nPFrames                 : Number of P frames between each I frame
+ *  nBFrames                 : Number of B frames between each I frame
+ *  eProfile                 : H.263 profile(s) to use
+ *  eLevel                   : H.263 level(s) to use
+ *  bPLUSPTYPEAllowed        : Indicating that it is allowed to use PLUSPTYPE 
+ *                             (specified in the 1998 version of H.263) to 
+ *                             indicate custom picture sizes or clock 
+ *                             frequencies 
+ *  nAllowedPictureTypes     : Specifies the picture types allowed in the 
+ *                             bitstream
+ *  bForceRoundingTypeToZero : value of the RTYPE bit (bit 6 of MPPTYPE) is 
+ *                             not constrained. It is recommended to change 
+ *                             the value of the RTYPE bit for each reference 
+ *                             picture in error-free communication
+ *  nPictureHeaderRepetition : Specifies the frequency of picture header 
+ *                             repetition
+ *  nGOBHeaderInterval       : Specifies the interval of non-empty GOB  
+ *                             headers in units of GOBs
+ */
+typedef struct OMX_VIDEO_PARAM_H263TYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nPFrames;
+    OMX_U32 nBFrames;
+    OMX_VIDEO_H263PROFILETYPE eProfile;
+	OMX_VIDEO_H263LEVELTYPE eLevel;
+    OMX_BOOL bPLUSPTYPEAllowed;
+    OMX_U32 nAllowedPictureTypes;
+    OMX_BOOL bForceRoundingTypeToZero;
+    OMX_U32 nPictureHeaderRepetition;
+    OMX_U32 nGOBHeaderInterval;
+} OMX_VIDEO_PARAM_H263TYPE;
+
+
+/** 
+ * MPEG-2 profile types, each profile indicates support for various 
+ * performance bounds and different annexes.
+ */
+typedef enum OMX_VIDEO_MPEG2PROFILETYPE {
+    OMX_VIDEO_MPEG2ProfileSimple = 0,  /**< Simple Profile */
+    OMX_VIDEO_MPEG2ProfileMain,        /**< Main Profile */
+    OMX_VIDEO_MPEG2Profile422,         /**< 4:2:2 Profile */
+    OMX_VIDEO_MPEG2ProfileSNR,         /**< SNR Profile */
+    OMX_VIDEO_MPEG2ProfileSpatial,     /**< Spatial Profile */
+    OMX_VIDEO_MPEG2ProfileHigh,        /**< High Profile */
+    OMX_VIDEO_MPEG2ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_MPEG2ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_MPEG2ProfileMax = 0x7FFFFFFF  
+} OMX_VIDEO_MPEG2PROFILETYPE;
+
+
+/** 
+ * MPEG-2 level types, each level indicates support for various frame 
+ * sizes, bit rates, decoder frame rates.  No need 
+ */
+typedef enum OMX_VIDEO_MPEG2LEVELTYPE {
+    OMX_VIDEO_MPEG2LevelLL = 0,  /**< Low Level */ 
+    OMX_VIDEO_MPEG2LevelML,      /**< Main Level */ 
+    OMX_VIDEO_MPEG2LevelH14,     /**< High 1440 */ 
+    OMX_VIDEO_MPEG2LevelHL,      /**< High Level */   
+    OMX_VIDEO_MPEG2LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_MPEG2LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_MPEG2LevelMax = 0x7FFFFFFF  
+} OMX_VIDEO_MPEG2LEVELTYPE;
+
+
+/** 
+ * MPEG-2 params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nPFrames   : Number of P frames between each I frame
+ *  nBFrames   : Number of B frames between each I frame
+ *  eProfile   : MPEG-2 profile(s) to use
+ *  eLevel     : MPEG-2 levels(s) to use
+ */
+typedef struct OMX_VIDEO_PARAM_MPEG2TYPE {
+    OMX_U32 nSize;           
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;      
+    OMX_U32 nPFrames;        
+    OMX_U32 nBFrames;        
+    OMX_VIDEO_MPEG2PROFILETYPE eProfile;
+	OMX_VIDEO_MPEG2LEVELTYPE eLevel;   
+} OMX_VIDEO_PARAM_MPEG2TYPE;
+
+
+/** 
+ * MPEG-4 profile types, each profile indicates support for various 
+ * performance bounds and different annexes.
+ * 
+ * ENUMS:
+ *  - Simple Profile, Levels 1-3
+ *  - Simple Scalable Profile, Levels 1-2
+ *  - Core Profile, Levels 1-2
+ *  - Main Profile, Levels 2-4
+ *  - N-bit Profile, Level 2
+ *  - Scalable Texture Profile, Level 1
+ *  - Simple Face Animation Profile, Levels 1-2
+ *  - Simple Face and Body Animation (FBA) Profile, Levels 1-2
+ *  - Basic Animated Texture Profile, Levels 1-2
+ *  - Hybrid Profile, Levels 1-2
+ *  - Advanced Real Time Simple Profiles, Levels 1-4
+ *  - Core Scalable Profile, Levels 1-3
+ *  - Advanced Coding Efficiency Profile, Levels 1-4
+ *  - Advanced Core Profile, Levels 1-2
+ *  - Advanced Scalable Texture, Levels 2-3
+ */
+typedef enum OMX_VIDEO_MPEG4PROFILETYPE {
+    OMX_VIDEO_MPEG4ProfileSimple           = 0x01,        
+    OMX_VIDEO_MPEG4ProfileSimpleScalable   = 0x02,    
+    OMX_VIDEO_MPEG4ProfileCore             = 0x04,              
+    OMX_VIDEO_MPEG4ProfileMain             = 0x08,             
+    OMX_VIDEO_MPEG4ProfileNbit             = 0x10,              
+    OMX_VIDEO_MPEG4ProfileScalableTexture  = 0x20,   
+    OMX_VIDEO_MPEG4ProfileSimpleFace       = 0x40,        
+    OMX_VIDEO_MPEG4ProfileSimpleFBA        = 0x80,         
+    OMX_VIDEO_MPEG4ProfileBasicAnimated    = 0x100,     
+    OMX_VIDEO_MPEG4ProfileHybrid           = 0x200,            
+    OMX_VIDEO_MPEG4ProfileAdvancedRealTime = 0x400,  
+    OMX_VIDEO_MPEG4ProfileCoreScalable     = 0x800,      
+    OMX_VIDEO_MPEG4ProfileAdvancedCoding   = 0x1000,    
+    OMX_VIDEO_MPEG4ProfileAdvancedCore     = 0x2000,      
+    OMX_VIDEO_MPEG4ProfileAdvancedScalable = 0x4000,
+    OMX_VIDEO_MPEG4ProfileAdvancedSimple   = 0x8000,
+    OMX_VIDEO_MPEG4ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_MPEG4ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_MPEG4ProfileMax              = 0x7FFFFFFF  
+} OMX_VIDEO_MPEG4PROFILETYPE;
+
+
+/** 
+ * MPEG-4 level types, each level indicates support for various frame 
+ * sizes, bit rates, decoder frame rates.  No need 
+ */
+typedef enum OMX_VIDEO_MPEG4LEVELTYPE {
+    OMX_VIDEO_MPEG4Level0  = 0x01,   /**< Level 0 */   
+    OMX_VIDEO_MPEG4Level0b = 0x02,   /**< Level 0b */   
+    OMX_VIDEO_MPEG4Level1  = 0x04,   /**< Level 1 */ 
+    OMX_VIDEO_MPEG4Level2  = 0x08,   /**< Level 2 */ 
+    OMX_VIDEO_MPEG4Level3  = 0x10,   /**< Level 3 */ 
+    OMX_VIDEO_MPEG4Level4  = 0x20,   /**< Level 4 */  
+    OMX_VIDEO_MPEG4Level4a = 0x40,   /**< Level 4a */  
+    OMX_VIDEO_MPEG4Level5  = 0x80,   /**< Level 5 */  
+    OMX_VIDEO_MPEG4LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_MPEG4LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_MPEG4LevelMax = 0x7FFFFFFF  
+} OMX_VIDEO_MPEG4LEVELTYPE;
+
+
+/** 
+ * MPEG-4 configuration.  This structure handles configuration options
+ * which are specific to MPEG4 algorithms
+ *
+ * STRUCT MEMBERS:
+ *  nSize                : Size of the structure in bytes
+ *  nVersion             : OMX specification version information
+ *  nPortIndex           : Port that this structure applies to
+ *  nSliceHeaderSpacing  : Number of macroblocks between slice header (H263+ 
+ *                         Annex K). Put zero if not used
+ *  bSVH                 : Enable Short Video Header mode
+ *  bGov                 : Flag to enable GOV
+ *  nPFrames             : Number of P frames between each I frame (also called 
+ *                         GOV period)
+ *  nBFrames             : Number of B frames between each I frame
+ *  nIDCVLCThreshold     : Value of intra DC VLC threshold
+ *  bACPred              : Flag to use ac prediction
+ *  nMaxPacketSize       : Maximum size of packet in bytes.
+ *  nTimeIncRes          : Used to pass VOP time increment resolution for MPEG4. 
+ *                         Interpreted as described in MPEG4 standard.
+ *  eProfile             : MPEG-4 profile(s) to use.
+ *  eLevel               : MPEG-4 level(s) to use.
+ *  nAllowedPictureTypes : Specifies the picture types allowed in the bitstream
+ *  nHeaderExtension     : Specifies the number of consecutive video packet
+ *                         headers within a VOP
+ *  bReversibleVLC       : Specifies whether reversible variable length coding 
+ *                         is in use
+ */
+typedef struct OMX_VIDEO_PARAM_MPEG4TYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nSliceHeaderSpacing;
+    OMX_BOOL bSVH;
+    OMX_BOOL bGov;
+    OMX_U32 nPFrames;
+    OMX_U32 nBFrames;
+    OMX_U32 nIDCVLCThreshold;
+    OMX_BOOL bACPred;
+    OMX_U32 nMaxPacketSize;
+    OMX_U32 nTimeIncRes;
+    OMX_VIDEO_MPEG4PROFILETYPE eProfile;
+    OMX_VIDEO_MPEG4LEVELTYPE eLevel;
+    OMX_U32 nAllowedPictureTypes;
+    OMX_U32 nHeaderExtension;
+    OMX_BOOL bReversibleVLC;
+} OMX_VIDEO_PARAM_MPEG4TYPE;
+
+
+/** 
+ * WMV Versions 
+ */
+typedef enum OMX_VIDEO_WMVFORMATTYPE {
+    OMX_VIDEO_WMVFormatUnused = 0x01,   /**< Format unused or unknown */
+    OMX_VIDEO_WMVFormat7      = 0x02,   /**< Windows Media Video format 7 */
+    OMX_VIDEO_WMVFormat8      = 0x04,   /**< Windows Media Video format 8 */
+    OMX_VIDEO_WMVFormat9      = 0x08,   /**< Windows Media Video format 9 */
+    OMX_VIDEO_WMFFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_WMFFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_WMVFormatMax    = 0x7FFFFFFF
+} OMX_VIDEO_WMVFORMATTYPE;
+
+
+/** 
+ * WMV Params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  eFormat    : Version of WMV stream / data
+ */
+typedef struct OMX_VIDEO_PARAM_WMVTYPE {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEO_WMVFORMATTYPE eFormat;
+} OMX_VIDEO_PARAM_WMVTYPE;
+
+
+/** 
+ * Real Video Version 
+ */
+typedef enum OMX_VIDEO_RVFORMATTYPE {
+    OMX_VIDEO_RVFormatUnused = 0, /**< Format unused or unknown */
+    OMX_VIDEO_RVFormat8,          /**< Real Video format 8 */
+    OMX_VIDEO_RVFormat9,          /**< Real Video format 9 */
+    OMX_VIDEO_RVFormatG2,         /**< Real Video Format G2 */
+    OMX_VIDEO_RVFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_RVFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_RVFormatMax = 0x7FFFFFFF
+} OMX_VIDEO_RVFORMATTYPE;
+
+
+/** 
+ * Real Video Params 
+ *
+ * STUCT MEMBERS:
+ *  nSize              : Size of the structure in bytes
+ *  nVersion           : OMX specification version information 
+ *  nPortIndex         : Port that this structure applies to
+ *  eFormat            : Version of RV stream / data
+ *  nBitsPerPixel      : Bits per pixel coded in the frame
+ *  nPaddedWidth       : Padded width in pixel of a video frame
+ *  nPaddedHeight      : Padded Height in pixels of a video frame
+ *  nFrameRate         : Rate of video in frames per second
+ *  nBitstreamFlags    : Flags which internal information about the bitstream
+ *  nBitstreamVersion  : Bitstream version
+ *  nMaxEncodeFrameSize: Max encoded frame size
+ *  bEnablePostFilter  : Turn on/off post filter
+ *  bEnableTemporalInterpolation : Turn on/off temporal interpolation
+ *  bEnableLatencyMode : When enabled, the decoder does not display a decoded 
+ *                       frame until it has detected that no enhancement layer 
+ *  					 frames or dependent B frames will be coming. This 
+ *  					 detection usually occurs when a subsequent non-B 
+ *  					 frame is encountered 
+ */
+typedef struct OMX_VIDEO_PARAM_RVTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEO_RVFORMATTYPE eFormat;
+    OMX_U16 nBitsPerPixel;
+    OMX_U16 nPaddedWidth;
+    OMX_U16 nPaddedHeight;
+    OMX_U32 nFrameRate;
+    OMX_U32 nBitstreamFlags;
+    OMX_U32 nBitstreamVersion;
+    OMX_U32 nMaxEncodeFrameSize;
+    OMX_BOOL bEnablePostFilter;
+    OMX_BOOL bEnableTemporalInterpolation;
+    OMX_BOOL bEnableLatencyMode;
+} OMX_VIDEO_PARAM_RVTYPE;
+
+
+/** 
+ * AVC profile types, each profile indicates support for various 
+ * performance bounds and different annexes.
+ */
+typedef enum OMX_VIDEO_AVCPROFILETYPE {
+    OMX_VIDEO_AVCProfileBaseline = 0x01,   /**< Baseline profile */
+    OMX_VIDEO_AVCProfileMain     = 0x02,   /**< Main profile */
+    OMX_VIDEO_AVCProfileExtended = 0x04,   /**< Extended profile */
+    OMX_VIDEO_AVCProfileHigh     = 0x08,   /**< High profile */
+    OMX_VIDEO_AVCProfileHigh10   = 0x10,   /**< High 10 profile */
+    OMX_VIDEO_AVCProfileHigh422  = 0x20,   /**< High 4:2:2 profile */
+    OMX_VIDEO_AVCProfileHigh444  = 0x40,   /**< High 4:4:4 profile */
+    OMX_VIDEO_AVCProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_AVCProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_AVCProfileMax      = 0x7FFFFFFF  
+} OMX_VIDEO_AVCPROFILETYPE;
+
+
+/** 
+ * AVC level types, each level indicates support for various frame sizes, 
+ * bit rates, decoder frame rates.  No need 
+ */
+typedef enum OMX_VIDEO_AVCLEVELTYPE {
+    OMX_VIDEO_AVCLevel1   = 0x01,     /**< Level 1 */
+    OMX_VIDEO_AVCLevel1b  = 0x02,     /**< Level 1b */
+    OMX_VIDEO_AVCLevel11  = 0x04,     /**< Level 1.1 */
+    OMX_VIDEO_AVCLevel12  = 0x08,     /**< Level 1.2 */
+    OMX_VIDEO_AVCLevel13  = 0x10,     /**< Level 1.3 */
+    OMX_VIDEO_AVCLevel2   = 0x20,     /**< Level 2 */
+    OMX_VIDEO_AVCLevel21  = 0x40,     /**< Level 2.1 */
+    OMX_VIDEO_AVCLevel22  = 0x80,     /**< Level 2.2 */
+    OMX_VIDEO_AVCLevel3   = 0x100,    /**< Level 3 */
+    OMX_VIDEO_AVCLevel31  = 0x200,    /**< Level 3.1 */
+    OMX_VIDEO_AVCLevel32  = 0x400,    /**< Level 3.2 */
+    OMX_VIDEO_AVCLevel4   = 0x800,    /**< Level 4 */
+    OMX_VIDEO_AVCLevel41  = 0x1000,   /**< Level 4.1 */
+    OMX_VIDEO_AVCLevel42  = 0x2000,   /**< Level 4.2 */
+    OMX_VIDEO_AVCLevel5   = 0x4000,   /**< Level 5 */
+    OMX_VIDEO_AVCLevel51  = 0x8000,   /**< Level 5.1 */
+    OMX_VIDEO_AVCLevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_AVCLevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_AVCLevelMax = 0x7FFFFFFF  
+} OMX_VIDEO_AVCLEVELTYPE;
+
+
+/** 
+ * AVC loop filter modes 
+ *
+ * OMX_VIDEO_AVCLoopFilterEnable               : Enable
+ * OMX_VIDEO_AVCLoopFilterDisable              : Disable
+ * OMX_VIDEO_AVCLoopFilterDisableSliceBoundary : Disabled on slice boundaries
+ */
+typedef enum OMX_VIDEO_AVCLOOPFILTERTYPE {
+    OMX_VIDEO_AVCLoopFilterEnable = 0,
+    OMX_VIDEO_AVCLoopFilterDisable,
+    OMX_VIDEO_AVCLoopFilterDisableSliceBoundary,
+    OMX_VIDEO_AVCLoopFilterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_AVCLoopFilterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_AVCLoopFilterMax = 0x7FFFFFFF
+} OMX_VIDEO_AVCLOOPFILTERTYPE;
+
+
+/** 
+ * AVC params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize                     : Size of the structure in bytes
+ *  nVersion                  : OMX specification version information
+ *  nPortIndex                : Port that this structure applies to
+ *  nSliceHeaderSpacing       : Number of macroblocks between slice header, put  
+ *                              zero if not used
+ *  nPFrames                  : Number of P frames between each I frame
+ *  nBFrames                  : Number of B frames between each I frame
+ *  bUseHadamard              : Enable/disable Hadamard transform
+ *  nRefFrames                : Max number of reference frames to use for inter
+ *                              motion search (1-16)
+ *  nRefIdxTrailing           : Pic param set ref frame index (index into ref
+ *                              frame buffer of trailing frames list), B frame
+ *                              support
+ *  nRefIdxForward            : Pic param set ref frame index (index into ref
+ *                              frame buffer of forward frames list), B frame
+ *                              support
+ *  bEnableUEP                : Enable/disable unequal error protection. This 
+ *                              is only valid of data partitioning is enabled.
+ *  bEnableFMO                : Enable/disable flexible macroblock ordering
+ *  bEnableASO                : Enable/disable arbitrary slice ordering
+ *  bEnableRS                 : Enable/disable sending of redundant slices
+ *  eProfile                  : AVC profile(s) to use
+ *  eLevel                    : AVC level(s) to use
+ *  nAllowedPictureTypes      : Specifies the picture types allowed in the 
+ *                              bitstream
+ *  bFrameMBsOnly             : specifies that every coded picture of the 
+ *                              coded video sequence is a coded frame 
+ *                              containing only frame macroblocks
+ *  bMBAFF                    : Enable/disable switching between frame and 
+ *                              field macroblocks within a picture
+ *  bEntropyCodingCABAC       : Entropy decoding method to be applied for the 
+ *                              syntax elements for which two descriptors appear 
+ *                              in the syntax tables
+ *  bWeightedPPrediction      : Enable/disable weighted prediction shall not 
+ *                              be applied to P and SP slices
+ *  nWeightedBipredicitonMode : Default weighted prediction is applied to B 
+ *                              slices 
+ *  bconstIpred               : Enable/disable intra prediction
+ *  bDirect8x8Inference       : Specifies the method used in the derivation 
+ *                              process for luma motion vectors for B_Skip, 
+ *                              B_Direct_16x16 and B_Direct_8x8 as specified 
+ *                              in subclause 8.4.1.2 of the AVC spec 
+ *  bDirectSpatialTemporal    : Flag indicating spatial or temporal direct
+ *                              mode used in B slice coding (related to 
+ *                              bDirect8x8Inference) . Spatial direct mode is 
+ *                              more common and should be the default.
+ *  nCabacInitIdx             : Index used to init CABAC contexts
+ *  eLoopFilterMode           : Enable/disable loop filter
+ */
+typedef struct OMX_VIDEO_PARAM_AVCTYPE {
+    OMX_U32 nSize;                 
+    OMX_VERSIONTYPE nVersion;      
+    OMX_U32 nPortIndex;            
+    OMX_U32 nSliceHeaderSpacing;  
+    OMX_U32 nPFrames;     
+    OMX_U32 nBFrames;     
+    OMX_BOOL bUseHadamard;
+    OMX_U32 nRefFrames;  
+	OMX_U32 nRefIdx10ActiveMinus1;
+	OMX_U32 nRefIdx11ActiveMinus1;
+    OMX_BOOL bEnableUEP;  
+    OMX_BOOL bEnableFMO;  
+    OMX_BOOL bEnableASO;  
+    OMX_BOOL bEnableRS;   
+    OMX_VIDEO_AVCPROFILETYPE eProfile;
+	OMX_VIDEO_AVCLEVELTYPE eLevel; 
+    OMX_U32 nAllowedPictureTypes;  
+	OMX_BOOL bFrameMBsOnly;        									
+    OMX_BOOL bMBAFF;               
+    OMX_BOOL bEntropyCodingCABAC;  
+    OMX_BOOL bWeightedPPrediction; 
+    OMX_U32 nWeightedBipredicitonMode; 
+    OMX_BOOL bconstIpred ;
+    OMX_BOOL bDirect8x8Inference;  
+	OMX_BOOL bDirectSpatialTemporal;
+	OMX_U32 nCabacInitIdc;
+	OMX_VIDEO_AVCLOOPFILTERTYPE eLoopFilterMode;
+} OMX_VIDEO_PARAM_AVCTYPE;
+
+typedef struct OMX_VIDEO_PARAM_PROFILELEVELTYPE {
+   OMX_U32 nSize;                 
+   OMX_VERSIONTYPE nVersion;      
+   OMX_U32 nPortIndex;            
+   OMX_U32 eProfile;      /**< type is OMX_VIDEO_AVCPROFILETYPE, OMX_VIDEO_H263PROFILETYPE, 
+                                 or OMX_VIDEO_MPEG4PROFILETYPE depending on context */
+   OMX_U32 eLevel;        /**< type is OMX_VIDEO_AVCLEVELTYPE, OMX_VIDEO_H263LEVELTYPE, 
+                                 or OMX_VIDEO_MPEG4PROFILETYPE depending on context */
+   OMX_U32 nProfileIndex; /**< Used to query for individual profile support information,
+                               This parameter is valid only for 
+                               OMX_IndexParamVideoProfileLevelQuerySupported index,
+                               For all other indices this parameter is to be ignored. */
+} OMX_VIDEO_PARAM_PROFILELEVELTYPE;
+
+/** 
+ * Structure for dynamically configuring bitrate mode of a codec. 
+ *
+ * STRUCT MEMBERS:
+ *  nSize          : Size of the struct in bytes
+ *  nVersion       : OMX spec version info
+ *  nPortIndex     : Port that this struct applies to
+ *  nEncodeBitrate : Target average bitrate to be generated in bps
+ */
+typedef struct OMX_VIDEO_CONFIG_BITRATETYPE {
+    OMX_U32 nSize;                          
+    OMX_VERSIONTYPE nVersion;               
+    OMX_U32 nPortIndex;                     
+    OMX_U32 nEncodeBitrate;                 
+} OMX_VIDEO_CONFIG_BITRATETYPE;
+
+/** 
+ * Defines Encoder Frame Rate setting
+ *
+ * STRUCT MEMBERS:
+ *  nSize            : Size of the structure in bytes
+ *  nVersion         : OMX specification version information 
+ *  nPortIndex       : Port that this structure applies to
+ *  xEncodeFramerate : Encoding framerate represented in Q16 format
+ */
+typedef struct OMX_CONFIG_FRAMERATETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 xEncodeFramerate; /* Q16 format */
+} OMX_CONFIG_FRAMERATETYPE;
+
+typedef struct OMX_CONFIG_INTRAREFRESHVOPTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL IntraRefreshVOP;
+} OMX_CONFIG_INTRAREFRESHVOPTYPE;
+
+typedef struct OMX_CONFIG_MACROBLOCKERRORMAPTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nErrMapSize;           /* Size of the Error Map in bytes */
+    OMX_U8  ErrMap[1];             /* Error map hint */
+} OMX_CONFIG_MACROBLOCKERRORMAPTYPE;
+
+typedef struct OMX_CONFIG_MBERRORREPORTINGTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnabled;
+} OMX_CONFIG_MBERRORREPORTINGTYPE;
+
+typedef struct OMX_PARAM_MACROBLOCKSTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nMacroblocks;
+} OMX_PARAM_MACROBLOCKSTYPE;
+
+/** 
+ * AVC Slice Mode modes 
+ *
+ * OMX_VIDEO_SLICEMODE_AVCDefault   : Normal frame encoding, one slice per frame
+ * OMX_VIDEO_SLICEMODE_AVCMBSlice   : NAL mode, number of MBs per frame
+ * OMX_VIDEO_SLICEMODE_AVCByteSlice : NAL mode, number of bytes per frame
+ */
+typedef enum OMX_VIDEO_AVCSLICEMODETYPE {
+    OMX_VIDEO_SLICEMODE_AVCDefault = 0,
+    OMX_VIDEO_SLICEMODE_AVCMBSlice,
+    OMX_VIDEO_SLICEMODE_AVCByteSlice,
+    OMX_VIDEO_SLICEMODE_AVCKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_SLICEMODE_AVCVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_SLICEMODE_AVCLevelMax = 0x7FFFFFFF
+} OMX_VIDEO_AVCSLICEMODETYPE;
+
+/** 
+ * AVC FMO Slice Mode Params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nNumSliceGroups : Specifies the number of slice groups
+ *  nSliceGroupMapType : Specifies the type of slice groups
+ *  eSliceMode : Specifies the type of slice
+ */
+typedef struct OMX_VIDEO_PARAM_AVCSLICEFMO {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U8 nNumSliceGroups;
+    OMX_U8 nSliceGroupMapType;
+    OMX_VIDEO_AVCSLICEMODETYPE eSliceMode;
+} OMX_VIDEO_PARAM_AVCSLICEFMO;
+
+/** 
+ * AVC IDR Period Configs
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nIDRPeriod : Specifies periodicity of IDR frames
+ *  nPFrames : Specifies internal of coding Intra frames
+ */
+typedef struct OMX_VIDEO_CONFIG_AVCINTRAPERIOD {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nIDRPeriod;
+    OMX_U32 nPFrames;
+} OMX_VIDEO_CONFIG_AVCINTRAPERIOD;
+
+/** 
+ * AVC NAL Size Configs
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nNaluBytes : Specifies the NAL unit size
+ */
+typedef struct OMX_VIDEO_CONFIG_NALSIZE {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nNaluBytes;
+} OMX_VIDEO_CONFIG_NALSIZE;
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
+
diff --git a/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Def.h b/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Def.h
new file mode 100644
index 0000000..229accd
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Def.h
@@ -0,0 +1,135 @@
+/*
+ *
+ * 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_Def.h
+ * @brief	SEC_OMX specific define
+ * @author	SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version	1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_DEF
+#define SEC_OMX_DEF
+
+#include "OMX_Types.h"
+#include "OMX_IVCommon.h"
+
+#define VERSIONMAJOR_NUMBER                1
+#define VERSIONMINOR_NUMBER                0
+#define REVISION_NUMBER                    0
+#define STEP_NUMBER                        0
+
+
+#define MAX_OMX_COMPONENT_NUM              20
+#define MAX_OMX_COMPONENT_ROLE_NUM         10
+#define MAX_OMX_COMPONENT_NAME_SIZE        OMX_MAX_STRINGNAME_SIZE
+#define MAX_OMX_COMPONENT_ROLE_SIZE        OMX_MAX_STRINGNAME_SIZE
+#define MAX_OMX_COMPONENT_LIBNAME_SIZE     OMX_MAX_STRINGNAME_SIZE * 2
+#define MAX_OMX_MIMETYPE_SIZE              OMX_MAX_STRINGNAME_SIZE
+
+
+typedef enum _SEC_CODEC_TYPE
+{
+	SW_CODEC,
+	HW_VIDEO_CODEC,
+	HW_AUDIO_CODEC
+} SEC_CODEC_TYPE;
+
+typedef struct _SEC_OMX_PRIORITYMGMTTYPE
+{
+	OMX_U32 nGroupPriority; /* the value 0 represents the highest priority */
+				/* for a group of components                   */
+	OMX_U32 nGroupID;
+} SEC_OMX_PRIORITYMGMTTYPE;
+
+typedef enum _SEC_OMX_INDEXTYPE
+{
+	OMX_IndexVendorThumbnailMode        = 0x7F000001,
+	OMX_COMPONENT_CAPABILITY_TYPE_INDEX = 0xFF7A347 /*for Android*/
+} SEC_OMX_INDEXTYPE;
+
+typedef enum _SEC_OMX_ERRORTYPE
+{
+	OMX_ErrorNoEOF = 0x90000001,
+	OMX_ErrorInputDataDecodeYet,
+	OMX_ErrorInputDataEncodeYet,
+	OMX_ErrorMFCInit
+} SEC_OMX_ERRORTYPE;
+
+typedef enum _SEC_OMX_COMMANDTYPE
+{
+	SEC_OMX_CommandComponentDeInit = 0x7F000001,
+	SEC_OMX_CommandEmptyBuffer,
+	SEC_OMX_CommandFillBuffer
+} SEC_OMX_COMMANDTYPE;
+
+typedef enum _SEC_OMX_TRANS_STATETYPE {
+	SEC_OMX_TransStateInvalid,
+	SEC_OMX_TransStateLoadedToIdle,
+	SEC_OMX_TransStateIdleToExecuting,
+	SEC_OMX_TransStateExecutingToIdle,
+	SEC_OMX_TransStateIdleToLoaded,
+	SEC_OMX_TransStateMax = 0X7FFFFFFF
+} SEC_OMX_TRANS_STATETYPE;
+
+typedef enum _SEC_OMX_COLOR_FORMATTYPE {
+#ifndef USE_SAMSUNG_COLORFORMAT
+	SEC_OMX_COLOR_FormatNV12PhysicalAddress = OMX_COLOR_FormatYUV420SemiPlanar
+#else
+    SEC_OMX_COLOR_FormatNV12PhysicalAddress = 0x7F000001 /**< Reserved region for introducing Vendor Extensions */
+#endif
+}SEC_OMX_COLOR_FORMATTYPE;
+
+typedef enum _SEC_OMX_SUPPORTFORMAT_TYPE
+{
+	supportFormat_1 = 0x00,
+	supportFormat_2,
+	supportFormat_3,
+	supportFormat_4
+} SEC_OMX_SUPPORTFORMAT_TYPE;
+
+
+/* for Android */
+typedef struct _OMXComponentCapabilityFlagsType
+{
+	/* OMX COMPONENT CAPABILITY RELATED MEMBERS */
+	OMX_BOOL iIsOMXComponentMultiThreaded;
+	OMX_BOOL iOMXComponentSupportsExternalOutputBufferAlloc;
+	OMX_BOOL iOMXComponentSupportsExternalInputBufferAlloc;
+	OMX_BOOL iOMXComponentSupportsMovableInputBuffers;
+	OMX_BOOL iOMXComponentSupportsPartialFrames;
+	OMX_BOOL iOMXComponentUsesNALStartCodes;
+	OMX_BOOL iOMXComponentCanHandleIncompleteFrames;
+	OMX_BOOL iOMXComponentUsesFullAVCFrames;
+} OMXComponentCapabilityFlagsType;
+
+typedef struct _SEC_OMX_VIDEO_PROFILELEVEL
+{
+    OMX_S32  profile;
+    OMX_S32  level;
+} SEC_OMX_VIDEO_PROFILELEVEL;
+
+
+#ifndef __OMX_EXPORTS
+#define __OMX_EXPORTS
+#define SEC_EXPORT_REF __attribute__((visibility("default")))
+#define SEC_IMPORT_REF __attribute__((visibility("default")))
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Macros.h b/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Macros.h
new file mode 100644
index 0000000..ff883c1
--- /dev/null
+++ b/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Macros.h
@@ -0,0 +1,63 @@
+/*
+ *
+ * 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_Macros.h
+ * @brief	Macros
+ * @author	SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version	1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OMX_MACROS
+#define SEC_OMX_MACROS
+
+#include "SEC_OMX_Def.h"
+#include "SEC_OSAL_Memory.h"
+
+
+/*
+ * MACROS
+ */
+#define ALIGN_TO_32B(x)   ((((x) + (1 <<  5) - 1) >>  5) <<  5)
+#define ALIGN_TO_128B(x)  ((((x) + (1 <<  7) - 1) >>  7) <<  7)
+#define ALIGN_TO_8KB(x)   ((((x) + (1 << 13) - 1) >> 13) << 13)
+
+#define INIT_SET_SIZE_VERSION(_struct_, _structType_)                       \
+	do {                                                                \
+		SEC_OSAL_Memset((_struct_), 0, sizeof(_structType_));       \
+		(_struct_)->nSize = sizeof(_structType_);                   \
+		(_struct_)->nVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER; \
+		(_struct_)->nVersion.s.nVersionMinor = VERSIONMINOR_NUMBER; \
+		(_struct_)->nVersion.s.nRevision = REVISION_NUMBER;         \
+		(_struct_)->nVersion.s.nStep = STEP_NUMBER;                 \
+	} while (0)
+
+/*
+ * Port Specific
+ */
+#define SEC_TUNNEL_ESTABLISHED 0x0001
+#define SEC_TUNNEL_IS_SUPPLIER 0x0002
+
+#define CHECK_PORT_BEING_FLUSHED(port)                 (port->bIsPortFlushed == OMX_TRUE)
+#define CHECK_PORT_ENABLED(port)                       (port->portDefinition.bEnabled == OMX_TRUE)
+#define CHECK_PORT_POPULATED(port)                     (port->portDefinition.bPopulated == OMX_TRUE)
+#define CHECK_PORT_TUNNELED(port)                      (port->tunnelFlags & SEC_TUNNEL_ESTABLISHED)
+#define CHECK_PORT_BUFFER_SUPPLIER(port)               (port->tunnelFlags & SEC_TUNNEL_IS_SUPPLIER)
+
+#endif
diff --git a/sec_mm/sec_omx/sec_osal/Android.mk b/sec_mm/sec_omx/sec_osal/Android.mk
new file mode 100644
index 0000000..9bd2a5d
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/Android.mk
@@ -0,0 +1,29 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+	SEC_OSAL_Event.c \
+	SEC_OSAL_Queue.c \
+	SEC_OSAL_ETC.c \
+	SEC_OSAL_Mutex.c \
+	SEC_OSAL_Thread.c \
+	SEC_OSAL_Memory.c \
+	SEC_OSAL_Semaphore.c \
+	SEC_OSAL_Library.c \
+	SEC_OSAL_Log.c
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libsecosal
+
+LOCAL_CFLAGS :=
+
+LOCAL_STATIC_LIBRARIES :=
+LOCAL_SHARED_LIBRARIES := libcutils libutils
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/sec_osal
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.c
new file mode 100644
index 0000000..66f8355
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.c
@@ -0,0 +1,144 @@
+/*
+ *
+ * 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_OSAL_ETC.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_ETC.h"
+
+
+#ifndef HAVE_GETLINE
+ssize_t getline(char **ppLine, size_t *pLen, FILE *pStream)
+{
+    char *pCurrentPointer = NULL;
+    size_t const chunk = 512;
+
+    size_t defaultBufferSize = chunk + 1;
+    size_t retSize = 0;
+
+    if (*ppLine == NULL) {
+        *ppLine = (char *)malloc(defaultBufferSize);
+        if (*ppLine == NULL) {
+            retSize = -1;
+            goto EXIT;
+        }
+        *pLen = defaultBufferSize;
+    }
+    else {
+        if (*pLen < defaultBufferSize) {
+            *ppLine = (char *)realloc(*ppLine, defaultBufferSize);
+            if (*ppLine == NULL) {
+                retSize = -1;
+                goto EXIT;
+            }
+            *pLen = defaultBufferSize;
+        }
+    }
+
+    while (1) {
+        size_t i;
+        size_t j = 0;
+        size_t readByte = 0;
+
+        pCurrentPointer = *ppLine + readByte;
+
+        i = fread(pCurrentPointer, 1, chunk, pStream);
+        if (i < chunk && ferror(pStream)) {
+            retSize = -1;
+            goto EXIT;
+        }
+        while (j < i) {
+            ++j;
+            if (*pCurrentPointer++ == (char)'\n') {
+                *pCurrentPointer = '\0';
+                if (j != i) {
+                    if (fseek(pStream, j - i, SEEK_CUR)) {
+                        retSize = -1;
+                        goto EXIT;
+                }
+                    if (feof(pStream))
+                        clearerr(pStream);
+                }
+                readByte += j;
+                retSize = readByte;
+                goto EXIT;
+            }
+        }
+
+        readByte += j;
+        if (feof(pStream)) {
+            if (readByte) {
+                retSize = readByte;
+                goto EXIT;
+            }
+            if (!i) {
+                retSize = -1;
+                goto EXIT;
+            }
+        }
+
+        i = ((readByte + (chunk * 2)) / chunk) * chunk;
+        if (i != *pLen) {
+            *ppLine = (char *)realloc(*ppLine, i);
+            if (*ppLine == NULL) {
+                retSize = -1;
+                goto EXIT;
+        }
+            *pLen = i;
+        }
+    }
+
+EXIT:
+    return retSize;
+}
+#endif /* HAVE_GETLINE */
+
+OMX_PTR SEC_OSAL_Strcpy(OMX_PTR dest, OMX_PTR src)
+{
+    return strcpy(dest, src);
+}
+
+OMX_PTR SEC_OSAL_Strncpy(OMX_PTR dest, OMX_PTR src, size_t num)
+{
+    return strncpy(dest, src, num);
+}
+
+OMX_S32 SEC_OSAL_Strcmp(OMX_PTR str1, OMX_PTR str2)
+{
+    return strcmp(str1, str2);
+}
+
+OMX_PTR SEC_OSAL_Strcat(OMX_PTR dest, OMX_PTR src)
+{
+    return strcat(dest, src);
+}
+
+size_t SEC_OSAL_Strlen(const char *str)
+{
+    return strlen(str);
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.h
new file mode 100644
index 0000000..6c6ede7
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.h
@@ -0,0 +1,48 @@
+/*
+ *
+ * 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_OSAL_ETC.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OSAL_ETC
+#define SEC_OSAL_ETC
+
+#include "OMX_Types.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_PTR SEC_OSAL_Strcpy(OMX_PTR dest, OMX_PTR src);
+OMX_PTR SEC_OSAL_Strncpy(OMX_PTR dest, OMX_PTR src, size_t num);
+OMX_S32 SEC_OSAL_Strcmp(OMX_PTR str1, OMX_PTR str2);
+OMX_PTR SEC_OSAL_Strcat(OMX_PTR dest, OMX_PTR src);
+size_t SEC_OSAL_Strlen(const char *str);
+ssize_t getline(char **ppLine, size_t *len, FILE *stream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.c
new file mode 100644
index 0000000..51b3ca2
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.c
@@ -0,0 +1,217 @@
+/*
+ *
+ * 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_OSAL_Event.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <errno.h>
+
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_Mutex.h"
+#include "SEC_OSAL_Event.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_OSAL_EVENT"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+OMX_ERRORTYPE SEC_OSAL_SignalCreate(OMX_HANDLETYPE *eventHandle)
+{
+    SEC_OSAL_THREADEVENT *event;
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    event = (SEC_OSAL_THREADEVENT *)SEC_OSAL_Malloc(sizeof(SEC_OSAL_THREADEVENT));
+    if (!event) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+
+    SEC_OSAL_Memset(event, 0, sizeof(SEC_OSAL_THREADEVENT));
+    event->signal = OMX_FALSE;
+
+    ret = SEC_OSAL_MutexCreate(&event->mutex);
+    if (ret != OMX_ErrorNone) {
+        SEC_OSAL_Free(event);
+        goto EXIT;
+    }
+
+    if (pthread_cond_init(&event->condition, NULL)) {
+        SEC_OSAL_MutexTerminate(event->mutex);
+        SEC_OSAL_Free(event);
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+
+    *eventHandle = (OMX_HANDLETYPE)event;
+    ret = OMX_ErrorNone;
+
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OSAL_SignalTerminate(OMX_HANDLETYPE eventHandle)
+{
+    SEC_OSAL_THREADEVENT *event = (SEC_OSAL_THREADEVENT *)eventHandle;
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    if (!event) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    ret = SEC_OSAL_MutexLock(event->mutex);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    if (pthread_cond_destroy(&event->condition)) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+
+    ret = SEC_OSAL_MutexUnlock(event->mutex);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+
+    ret = SEC_OSAL_MutexTerminate(event->mutex);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+
+    SEC_OSAL_Free(event);
+
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OSAL_SignalReset(OMX_HANDLETYPE eventHandle)
+{
+    SEC_OSAL_THREADEVENT *event = (SEC_OSAL_THREADEVENT *)eventHandle;
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    if (!event) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    ret = SEC_OSAL_MutexLock(event->mutex);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    event->signal = OMX_FALSE;
+
+    SEC_OSAL_MutexUnlock(event->mutex);
+
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OSAL_SignalSet(OMX_HANDLETYPE eventHandle)
+{
+    SEC_OSAL_THREADEVENT *event = (SEC_OSAL_THREADEVENT *)eventHandle;
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    if (!event) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    ret = SEC_OSAL_MutexLock(event->mutex);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    event->signal = OMX_TRUE;
+    pthread_cond_signal(&event->condition);
+
+    SEC_OSAL_MutexUnlock(event->mutex);
+
+EXIT:
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OSAL_SignalWait(OMX_HANDLETYPE eventHandle, OMX_U32 ms)
+{
+    SEC_OSAL_THREADEVENT *event = (SEC_OSAL_THREADEVENT *)eventHandle;
+    OMX_ERRORTYPE         ret = OMX_ErrorNone;
+    struct timespec       timeout;
+    struct timeval        now;
+    int                   funcret = 0;
+    OMX_U32               tv_us;
+
+    FunctionIn();
+
+    if (!event) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    gettimeofday(&now, NULL);
+
+    tv_us = now.tv_usec + ms * 1000;
+    timeout.tv_sec = now.tv_sec + tv_us / 1000000;
+    timeout.tv_nsec = (tv_us % 1000000) * 1000;
+
+    ret = SEC_OSAL_MutexLock(event->mutex);
+    if (ret != OMX_ErrorNone) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    if (ms == 0) {
+        if (!event->signal)
+            ret = OMX_ErrorTimeout;
+    } else if (ms == DEF_MAX_WAIT_TIME) {
+        while (!event->signal)
+            pthread_cond_wait(&event->condition, (pthread_mutex_t *)(event->mutex));
+        ret = OMX_ErrorNone;
+    } else {
+        while (!event->signal) {
+            funcret = pthread_cond_timedwait(&event->condition, (pthread_mutex_t *)(event->mutex), &timeout);
+            if ((!event->signal) && (funcret == ETIMEDOUT)) {
+                ret = OMX_ErrorTimeout;
+                break;
+            }
+        }
+    }
+
+    SEC_OSAL_MutexUnlock(event->mutex);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.h
new file mode 100644
index 0000000..640d2cc
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.h
@@ -0,0 +1,61 @@
+/*
+ *
+ * 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_OSAL_Event.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OSAL_EVENT
+#define SEC_OSAL_EVENT
+
+#include <pthread.h>
+#include "OMX_Types.h"
+#include "OMX_Core.h"
+
+
+#define DEF_MAX_WAIT_TIME 0xFFFFFFFF
+
+typedef struct _SEC_OSAL_THREADEVENT
+{
+    OMX_BOOL       signal;
+    OMX_HANDLETYPE mutex;
+    pthread_cond_t condition;
+} SEC_OSAL_THREADEVENT;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+OMX_ERRORTYPE SEC_OSAL_SignalCreate(OMX_HANDLETYPE *eventHandle);
+OMX_ERRORTYPE SEC_OSAL_SignalTerminate(OMX_HANDLETYPE eventHandle);
+OMX_ERRORTYPE SEC_OSAL_SignalReset(OMX_HANDLETYPE eventHandle);
+OMX_ERRORTYPE SEC_OSAL_SignalSet(OMX_HANDLETYPE eventHandle);
+OMX_ERRORTYPE SEC_OSAL_SignalWait(OMX_HANDLETYPE eventHandle, OMX_U32 ms);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.c
new file mode 100644
index 0000000..06ac712
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.c
@@ -0,0 +1,54 @@
+/*
+ *
+ * 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_OSAL_Library.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dlfcn.h>
+
+#include "SEC_OSAL_Library.h"
+
+
+void *SEC_OSAL_dlopen(const char *filename, int flag)
+{
+    return dlopen(filename, flag);
+}
+
+void *SEC_OSAL_dlsym(void *handle, const char *symbol)
+{
+    return dlsym(handle, symbol);
+}
+
+int SEC_OSAL_dlclose(void *handle)
+{
+    return dlclose(handle);
+}
+
+const char *SEC_OSAL_dlerror(void)
+{
+    return dlerror();
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.h
new file mode 100644
index 0000000..687cecd
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.h
@@ -0,0 +1,46 @@
+/*
+ *
+ * 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_OSAL_Library.h
+ * @brief
+ * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *    2010.7.15 : Create
+ */
+
+#ifndef SEC_OSAL_LIBRARY
+#define SEC_OSAL_LIBRARY
+
+#include "OMX_Types.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void *SEC_OSAL_dlopen(const char *filename, int flag);
+void *SEC_OSAL_dlsym(void *handle, const char *symbol);
+int   SEC_OSAL_dlclose(void *handle);
+const char *SEC_OSAL_dlerror(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.c
new file mode 100644
index 0000000..bae4974
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.c
@@ -0,0 +1,53 @@
+/*
+ *
+ * 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_OSAL_Log.c
+ * @brief
+ * @author      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <utils/Log.h>
+
+#include "SEC_OSAL_Log.h"
+
+
+void _SEC_OSAL_Log(SEC_LOG_LEVEL logLevel, const char *tag, const char *msg, ...)
+{
+    va_list argptr;
+
+    va_start(argptr, msg);
+
+    switch (logLevel) {
+    case SEC_LOG_TRACE:
+        __android_log_vprint(ANDROID_LOG_DEBUG, tag, msg, argptr);
+        break;
+    case SEC_LOG_WARNING:
+        __android_log_vprint(ANDROID_LOG_WARN, tag, msg, argptr);
+        break;
+    case SEC_LOG_ERROR:
+        __android_log_vprint(ANDROID_LOG_ERROR, tag, msg, argptr);
+        break;
+    default:
+        __android_log_vprint(ANDROID_LOG_VERBOSE, tag, msg, argptr);
+    }
+
+    va_end(argptr);
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.h
new file mode 100644
index 0000000..2f8a6ce
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.h
@@ -0,0 +1,78 @@
+/*
+ *
+ * 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_OSAL_Log.h
+ * @brief
+ * @author      Yunji Kim (yunji.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ *   2010.8.27 : Add trace function
+ */
+
+#ifndef SEC_OSAL_LOG
+#define SEC_OSAL_LOG
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef SEC_LOG_OFF
+#define SEC_LOG
+#endif
+
+#ifndef SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_LOG"
+#endif
+
+#ifdef SEC_TRACE_ON
+#define SEC_TRACE
+#endif
+
+typedef enum _LOG_LEVEL
+{
+    SEC_LOG_TRACE,
+    SEC_LOG_WARNING,
+    SEC_LOG_ERROR
+} SEC_LOG_LEVEL;
+
+#ifdef SEC_LOG
+#define SEC_OSAL_Log(a, ...)    ((void)_SEC_OSAL_Log(a, SEC_LOG_TAG, __VA_ARGS__))
+#else
+#define SEC_OSAL_Log(a, ...)                                                \
+    do {                                                                \
+        if (a == SEC_LOG_ERROR)                                     \
+            ((void)_SEC_OSAL_Log(a, SEC_LOG_TAG, __VA_ARGS__)); \
+    } while (0)
+#endif
+
+#ifdef SEC_TRACE
+#define FunctionIn() _SEC_OSAL_Log(SEC_LOG_TRACE, SEC_LOG_TAG, "%s In , Line: %d", __FUNCTION__, __LINE__)
+#define FunctionOut() _SEC_OSAL_Log(SEC_LOG_TRACE, SEC_LOG_TAG, "%s Out , Line: %d", __FUNCTION__, __LINE__)
+#else
+#define FunctionIn() ((void *)0)
+#define FunctionOut() ((void *)0)
+#endif
+
+extern void _SEC_OSAL_Log(SEC_LOG_LEVEL logLevel, const char *tag, const char *msg, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.c
new file mode 100644
index 0000000..3579d92
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.c
@@ -0,0 +1,71 @@
+/*
+ *
+ * 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_OSAL_Memory.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OSAL_Memory.h"
+
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+static int mem_cnt = 0;
+
+OMX_PTR SEC_OSAL_Malloc(OMX_U32 size)
+{
+    mem_cnt++;
+    SEC_OSAL_Log(SEC_LOG_TRACE, "alloc count: %d", mem_cnt);
+
+    return (OMX_PTR)malloc(size);
+}
+
+void SEC_OSAL_Free(OMX_PTR addr)
+{
+    mem_cnt--;
+    SEC_OSAL_Log(SEC_LOG_TRACE, "free count: %d", mem_cnt);
+
+    if (addr)
+        free(addr);
+
+    return;
+}
+
+OMX_PTR SEC_OSAL_Memset(OMX_PTR dest, OMX_S32 c, OMX_S32 n)
+{
+    return memset(dest, c, n);
+}
+
+OMX_PTR SEC_OSAL_Memcpy(OMX_PTR dest, OMX_PTR src, OMX_S32 n)
+{
+    return memcpy(dest, src, n);
+}
+
+OMX_PTR SEC_OSAL_Memmove(OMX_PTR dest, OMX_PTR src, OMX_S32 n)
+{
+    return memmove(dest, src, n);
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.h
new file mode 100644
index 0000000..3a12838
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.h
@@ -0,0 +1,47 @@
+/*
+ *
+ * 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_OSAL_Memory.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OSAL_MEMORY
+#define SEC_OSAL_MEMORY
+
+#include "OMX_Types.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_PTR SEC_OSAL_Malloc(OMX_U32 size);
+void    SEC_OSAL_Free(OMX_PTR addr);
+OMX_PTR SEC_OSAL_Memset(OMX_PTR dest, OMX_S32 c, OMX_S32 n);
+OMX_PTR SEC_OSAL_Memcpy(OMX_PTR dest, OMX_PTR src, OMX_S32 n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.c
new file mode 100644
index 0000000..146809c
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.c
@@ -0,0 +1,91 @@
+/*
+ *
+ * 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_OSAL_Mutex.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_Mutex.h"
+
+
+OMX_ERRORTYPE SEC_OSAL_MutexCreate(OMX_HANDLETYPE *mutexHandle)
+{
+    pthread_mutex_t *mutex;
+
+    mutex = (pthread_mutex_t *)SEC_OSAL_Malloc(sizeof(pthread_mutex_t));
+    if (!mutex)
+        return OMX_ErrorInsufficientResources;
+
+    if (pthread_mutex_init(mutex, NULL) != 0)
+        return OMX_ErrorUndefined;
+
+    *mutexHandle = (OMX_HANDLETYPE)mutex;
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_MutexTerminate(OMX_HANDLETYPE mutexHandle)
+{
+    pthread_mutex_t *mutex = (pthread_mutex_t *)mutexHandle;
+
+    if (mutex == NULL)
+        return OMX_ErrorBadParameter;
+
+    if (pthread_mutex_destroy(mutex) != 0)
+        return OMX_ErrorUndefined;
+
+    SEC_OSAL_Free(mutex);
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_MutexLock(OMX_HANDLETYPE mutexHandle)
+{
+    pthread_mutex_t *mutex = (pthread_mutex_t *)mutexHandle;
+    int result;
+
+    if (mutex == NULL)
+        return OMX_ErrorBadParameter;
+
+    if (pthread_mutex_lock(mutex) != 0)
+        return OMX_ErrorUndefined;
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_MutexUnlock(OMX_HANDLETYPE mutexHandle)
+{
+    pthread_mutex_t *mutex = (pthread_mutex_t *)mutexHandle;
+    int result;
+
+    if (mutex == NULL)
+        return OMX_ErrorBadParameter;
+
+    if (pthread_mutex_unlock(mutex) != 0)
+        return OMX_ErrorUndefined;
+
+    return OMX_ErrorNone;
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.h
new file mode 100644
index 0000000..70dcd9d
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.h
@@ -0,0 +1,47 @@
+/*
+ *
+ * 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_OSAL_Mutex.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+*/
+
+#ifndef SEC_OSAL_MUTEX
+#define SEC_OSAL_MUTEX
+
+#include "OMX_Types.h"
+#include "OMX_Core.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_ERRORTYPE SEC_OSAL_MutexCreate(OMX_HANDLETYPE *mutexHandle);
+OMX_ERRORTYPE SEC_OSAL_MutexTerminate(OMX_HANDLETYPE mutexHandle);
+OMX_ERRORTYPE SEC_OSAL_MutexLock(OMX_HANDLETYPE mutexHandle);
+OMX_ERRORTYPE SEC_OSAL_MutexUnlock(OMX_HANDLETYPE mutexHandle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.c
new file mode 100644
index 0000000..8f26387
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.c
@@ -0,0 +1,161 @@
+/*
+ *
+ * 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_OSAL_Queue.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_Mutex.h"
+#include "SEC_OSAL_Queue.h"
+
+
+OMX_ERRORTYPE SEC_OSAL_QueueCreate(SEC_QUEUE *queueHandle)
+{
+    int i = 0;
+    SEC_QElem *newqelem = NULL;
+    SEC_QElem *currentqelem = NULL;
+    SEC_QUEUE *queue = (SEC_QUEUE *)queueHandle;
+
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    if (!queue)
+        return OMX_ErrorBadParameter;
+
+    ret = SEC_OSAL_MutexCreate(&queue->qMutex);
+    if (ret != OMX_ErrorNone)
+        return ret;
+
+    queue->first = (SEC_QElem *)SEC_OSAL_Malloc(sizeof(SEC_QElem));
+    if (queue->first == NULL)
+        return OMX_ErrorInsufficientResources;
+
+    SEC_OSAL_Memset(queue->first, 0, sizeof(SEC_QElem));
+    currentqelem = queue->last = queue->first;
+    queue->numElem = 0;
+
+    for (i = 0; i < (MAX_QUEUE_ELEMENTS - 2); i++) {
+        newqelem = (SEC_QElem *)SEC_OSAL_Malloc(sizeof(SEC_QElem));
+        if (newqelem == NULL) {
+            while (queue->first != NULL) {
+                currentqelem = queue->first->qNext;
+                SEC_OSAL_Free((OMX_PTR)queue->first);
+                queue->first = currentqelem;
+            }
+            return OMX_ErrorInsufficientResources;
+        } else {
+            SEC_OSAL_Memset(newqelem, 0, sizeof(SEC_QElem));
+            currentqelem->qNext = newqelem;
+            currentqelem = newqelem;
+        }
+    }
+
+    currentqelem->qNext = queue->first;
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_QueueTerminate(SEC_QUEUE *queueHandle)
+{
+    int i = 0;
+    SEC_QElem *currentqelem = NULL;
+    SEC_QUEUE *queue = (SEC_QUEUE *)queueHandle;
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    if (!queue)
+        return OMX_ErrorBadParameter;
+
+    for ( i = 0; i < (MAX_QUEUE_ELEMENTS - 2); i++) {
+        currentqelem = queue->first->qNext;
+        SEC_OSAL_Free(queue->first);
+        queue->first = currentqelem;
+    }
+
+    if(queue->first) {
+        SEC_OSAL_Free(queue->first);
+        queue->first = NULL;
+    }
+
+    ret = SEC_OSAL_MutexTerminate(queue->qMutex);
+
+    return ret;
+}
+
+int SEC_OSAL_Queue(SEC_QUEUE *queueHandle, void *data)
+{
+    SEC_QUEUE *queue = (SEC_QUEUE *)queueHandle;
+    if (queue == NULL)
+        return -1;
+
+    SEC_OSAL_MutexLock(queue->qMutex);
+
+    if ((queue->last->data != NULL) || (queue->numElem >= MAX_QUEUE_ELEMENTS)) {
+        SEC_OSAL_MutexUnlock(queue->qMutex);
+        return -1;
+    }
+    queue->last->data = data;
+    queue->last = queue->last->qNext;
+    queue->numElem++;
+
+    SEC_OSAL_MutexUnlock(queue->qMutex);
+    return 0;
+}
+
+void *SEC_OSAL_Dequeue(SEC_QUEUE *queueHandle)
+{
+    void *data = NULL;
+    SEC_QUEUE *queue = (SEC_QUEUE *)queueHandle;
+    if (queue == NULL)
+        return NULL;
+
+    SEC_OSAL_MutexLock(queue->qMutex);
+
+    if ((queue->first->data == NULL) || (queue->numElem <= 0)) {
+        SEC_OSAL_MutexUnlock(queue->qMutex);
+        return NULL;
+    }
+    data = queue->first->data;
+    queue->first->data = NULL;
+    queue->first = queue->first->qNext;
+    queue->numElem--;
+
+    SEC_OSAL_MutexUnlock(queue->qMutex);
+    return data;
+}
+
+int SEC_OSAL_GetElemNum(SEC_QUEUE *queueHandle)
+{
+    int ElemNum = 0;
+    SEC_QUEUE *queue = (SEC_QUEUE *)queueHandle;
+    if (queue == NULL)
+        return -1;
+
+    SEC_OSAL_MutexLock(queue->qMutex);
+    ElemNum = queue->numElem;
+    SEC_OSAL_MutexUnlock(queue->qMutex);
+    return ElemNum;
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.h
new file mode 100644
index 0000000..0f119e8
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.h
@@ -0,0 +1,66 @@
+/*
+ *
+ * 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_OSAL_Queue.h
+ * @brief
+ * @author    SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version    1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OSAL_QUEUE
+#define SEC_OSAL_QUEUE
+
+#include "OMX_Types.h"
+#include "OMX_Core.h"
+
+
+#define MAX_QUEUE_ELEMENTS    10
+
+struct SEC_QElem;
+typedef struct _SEC_QElem
+{
+    void             *data;
+    struct SEC_QElem *qNext;
+} SEC_QElem;
+
+typedef struct _SEC_QUEUE
+{
+    SEC_QElem     *first;
+    SEC_QElem     *last;
+    int            numElem;
+    OMX_HANDLETYPE qMutex;
+} SEC_QUEUE;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_ERRORTYPE SEC_OSAL_QueueCreate(SEC_QUEUE *queueHandle);
+OMX_ERRORTYPE SEC_OSAL_QueueTerminate(SEC_QUEUE *queueHandle);
+int           SEC_OSAL_Queue(SEC_QUEUE *queueHandle, void *data);
+void         *SEC_OSAL_Dequeue(SEC_QUEUE *queueHandle);
+int           SEC_OSAL_GetElemNum(SEC_QUEUE *queueHandle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.c
new file mode 100644
index 0000000..17a29a0
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.c
@@ -0,0 +1,132 @@
+/*
+ *
+ * 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_OSAL_Semaphore.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_Semaphore.h"
+
+#undef SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_LOG_SEMA"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+OMX_ERRORTYPE SEC_OSAL_SemaphoreCreate(OMX_HANDLETYPE *semaphoreHandle)
+{
+    sem_t *sema;
+
+    sema = (sem_t *)SEC_OSAL_Malloc(sizeof(sema));
+    if (!sema)
+        return OMX_ErrorInsufficientResources;
+
+    if (sem_init(sema, 0, 0) != 0)
+        return OMX_ErrorUndefined;
+
+    *semaphoreHandle = (OMX_HANDLETYPE)sema;
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_SemaphoreTerminate(OMX_HANDLETYPE semaphoreHandle)
+{
+    sem_t *sema = (sem_t *)semaphoreHandle;
+
+    if (sema == NULL)
+        return OMX_ErrorBadParameter;
+
+    if (sem_destroy(sema) != 0)
+        return OMX_ErrorUndefined;
+
+    SEC_OSAL_Free(sema);
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_SemaphoreWait(OMX_HANDLETYPE semaphoreHandle)
+{
+    sem_t *sema = (sem_t *)semaphoreHandle;
+
+    FunctionIn();
+
+    if (sema == NULL)
+        return OMX_ErrorBadParameter;
+
+    if (sem_wait(sema) != 0)
+        return OMX_ErrorUndefined;
+
+    FunctionOut();
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_SemaphorePost(OMX_HANDLETYPE semaphoreHandle)
+{
+    sem_t *sema = (sem_t *)semaphoreHandle;
+
+    FunctionIn();
+
+    if (sema == NULL)
+        return OMX_ErrorBadParameter;
+
+    if (sem_post(sema) != 0)
+        return OMX_ErrorUndefined;
+
+    FunctionOut();
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_Set_SemaphoreCount(OMX_HANDLETYPE semaphoreHandle, OMX_S32 val)
+{
+    sem_t *sema = (sem_t *)semaphoreHandle;
+
+    if (sema == NULL)
+        return OMX_ErrorBadParameter;
+
+    if (sem_init(sema, 0, val) != 0)
+        return OMX_ErrorUndefined;
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SEC_OSAL_Get_SemaphoreCount(OMX_HANDLETYPE semaphoreHandle, OMX_S32 *val)
+{
+    sem_t *sema = (sem_t *)semaphoreHandle;
+    OMX_U32 semaVal = 0;
+
+    if (sema == NULL)
+        return OMX_ErrorBadParameter;
+
+    if (sem_getvalue(sema, &semaVal) != 0)
+        return OMX_ErrorUndefined;
+
+    *val = semaVal;
+
+    return OMX_ErrorNone;
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.h
new file mode 100644
index 0000000..f23d3d6
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.h
@@ -0,0 +1,49 @@
+/*
+ *
+ * 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_OSAL_Semaphore.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OSAL_SEMAPHORE
+#define SEC_OSAL_SEMAPHORE
+
+#include "OMX_Types.h"
+#include "OMX_Core.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_ERRORTYPE SEC_OSAL_SemaphoreCreate(OMX_HANDLETYPE *semaphoreHandle);
+OMX_ERRORTYPE SEC_OSAL_SemaphoreTerminate(OMX_HANDLETYPE semaphoreHandle);
+OMX_ERRORTYPE SEC_OSAL_SemaphoreWait(OMX_HANDLETYPE semaphoreHandle);
+OMX_ERRORTYPE SEC_OSAL_SemaphorePost(OMX_HANDLETYPE semaphoreHandle);
+OMX_ERRORTYPE SEC_OSAL_Set_SemaphoreCount(OMX_HANDLETYPE semaphoreHandle, OMX_S32 val);
+OMX_ERRORTYPE SEC_OSAL_Get_SemaphoreCount(OMX_HANDLETYPE semaphoreHandle, OMX_S32 *val);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.c b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.c
new file mode 100644
index 0000000..d488885
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.c
@@ -0,0 +1,153 @@
+/*
+ *
+ * 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_OSAL_Thread.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <errno.h>
+
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_Thread.h"
+
+#undef SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_LOG_THREAD"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+typedef struct _SEC_THREAD_HANDLE_TYPE
+{
+    pthread_t          pthread;
+    pthread_attr_t     attr;
+    struct sched_param schedparam;
+    int                stack_size;
+} SEC_THREAD_HANDLE_TYPE;
+
+
+OMX_ERRORTYPE SEC_OSAL_ThreadCreate(OMX_HANDLETYPE *threadHandle, OMX_PTR function_name, OMX_PTR argument)
+{
+    FunctionIn();
+
+    int result = 0;
+    int detach_ret = 0;
+    SEC_THREAD_HANDLE_TYPE *thread;
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    thread = SEC_OSAL_Malloc(sizeof(SEC_THREAD_HANDLE_TYPE));
+    SEC_OSAL_Memset(thread, 0, sizeof(SEC_THREAD_HANDLE_TYPE));
+
+    pthread_attr_init(&thread->attr);
+    if (thread->stack_size != 0)
+        pthread_attr_setstacksize(&thread->attr, thread->stack_size);
+
+    /* set priority */
+    if (thread->schedparam.sched_priority != 0)
+        pthread_attr_setschedparam(&thread->attr, &thread->schedparam);
+
+    detach_ret = pthread_attr_setdetachstate(&thread->attr, PTHREAD_CREATE_JOINABLE);
+    if (detach_ret != 0) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+
+    result = pthread_create(&thread->pthread, &thread->attr, function_name, (void *)argument);
+    /* pthread_setschedparam(thread->pthread, SCHED_RR, &thread->schedparam); */
+
+    switch (result) {
+    case 0:
+        *threadHandle = (OMX_HANDLETYPE)thread;
+        ret = OMX_ErrorNone;
+        break;
+    case EAGAIN:
+        *threadHandle = NULL;
+        ret = OMX_ErrorInsufficientResources;
+        break;
+    default:
+        *threadHandle = NULL;
+        ret = OMX_ErrorUndefined;
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OSAL_ThreadTerminate(OMX_HANDLETYPE threadHandle)
+{
+    FunctionIn();
+
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    SEC_THREAD_HANDLE_TYPE *thread = (SEC_THREAD_HANDLE_TYPE *)threadHandle;
+
+    if (!thread) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pthread_join(thread->pthread, NULL) != 0) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+
+    SEC_OSAL_Free(thread);
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+
+}
+
+OMX_ERRORTYPE SEC_OSAL_ThreadCancle(OMX_HANDLETYPE threadHandle)
+{
+    SEC_THREAD_HANDLE_TYPE *thread = (SEC_THREAD_HANDLE_TYPE *)threadHandle;
+
+    if (!thread)
+        return OMX_ErrorBadParameter;
+
+    /* thread_cancel(thread->pthread); */
+    pthread_exit(thread->pthread);
+    pthread_join(thread->pthread, NULL);
+
+    SEC_OSAL_Free(thread);
+    return OMX_ErrorNone;
+}
+
+void SEC_OSAL_TheadExit(void *value_ptr)
+{
+    pthread_exit(value_ptr);
+    return;
+}
+
+void SEC_OSAL_SleepMillisec(OMX_U32 ms)
+{
+    usleep(ms * 1000);
+    return;
+}
diff --git a/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.h b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.h
new file mode 100644
index 0000000..b932aef
--- /dev/null
+++ b/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.h
@@ -0,0 +1,48 @@
+/*
+ *
+ * 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_OSAL_Thread.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ * @version     1.0
+ * @history
+ *   2010.7.15 : Create
+ */
+
+#ifndef SEC_OSAL_THREAD
+#define SEC_OSAL_THREAD
+
+#include "OMX_Types.h"
+#include "OMX_Core.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+OMX_ERRORTYPE SEC_OSAL_ThreadCreate(OMX_HANDLETYPE *threadHandle, OMX_PTR function_name, OMX_PTR argument);
+OMX_ERRORTYPE SEC_OSAL_ThreadTerminate(OMX_HANDLETYPE threadHandle);
+OMX_ERRORTYPE SEC_OSAL_ThreadCancle(OMX_HANDLETYPE threadHandle);
+void          SEC_OSAL_TheadExit(void *value_ptr);
+void          SEC_OSAL_SleepMillisec(OMX_U32 ms);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif