exynos3: initial commit

Patch Set 2: removed unused files,
as audio, camera and sensors are device specific

Patch Set 3: aries OMX

Patch Set 5: liblight patch for epic

Patch Set 9: liblight(s) is device specific, rmed it from here.

Change-Id: I57a3d5714037836bab441ee5a3e772c260fb21d4

112 files changed, 34058 insertions, 0 deletions

diff --git a/Android.mk b/Android.mk
index 451b72f..fe7addf 100644
--- a/Android.mk
+++ b/Android.mk
@@ -20,3 +20,9 @@ ifeq ($(TARGET_SOC),exynos4x12)
 include hardware/samsung/exynos4x12.mk
 endif
 endif
+
+ifeq ($(TARGET_BOARD_PLATFORM),s5pc110)
+ifneq ($(TARGET_BOOTLOADER_BOARD_NAME),herring)
+include hardware/samsung/s5pc110.mk
+endif
+endif
diff --git a/exynos3/s5pc110/Android.mk b/exynos3/s5pc110/Android.mk
new file mode 100644
index 0000000..5c2775a
--- /dev/null
+++ b/exynos3/s5pc110/Android.mk
@@ -0,0 +1,24 @@
+#
+# Copyright (C) 2012 The Android Open Source Project
+#
+# 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.
+#
+
+ifeq ($(TARGET_BOARD_PLATFORM),s5pc110)
+
+# audio, camera, sensor and light HALs are device specifc
+s5pc110_dirs := libhwcomposer libs3cjpeg libstagefrighthw sec_mm
+
+include $(call all-named-subdir-makefiles,$(s5pc110_dirs))
+
+endif
diff --git a/exynos3/s5pc110/include/hal_public.h b/exynos3/s5pc110/include/hal_public.h
new file mode 100644
index 0000000..60f33a9
--- /dev/null
+++ b/exynos3/s5pc110/include/hal_public.h
@@ -0,0 +1,171 @@
+/* Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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.
+ */
+
+#ifndef HAL_PUBLIC_H
+#define HAL_PUBLIC_H
+
+/* Authors of third party hardware composer (HWC) modules will need to include
+ * this header to access functionality in the gralloc and framebuffer HALs.
+ */
+
+#include <hardware/gralloc.h>
+
+#define ALIGN(x,a) (((x) + (a) - 1L) & ~((a) - 1L))
+#define HW_ALIGN   32
+
+/* This can be tuned down as appropriate for the SOC.
+ *
+ * IMG formats are usually a single sub-alloc.
+ * Some OEM video formats are two sub-allocs (Y, UV planes).
+ * Future OEM video formats might be three sub-allocs (Y, U, V planes).
+ */
+#define MAX_SUB_ALLOCS 3
+
+typedef struct
+{
+    native_handle_t base;
+
+    /* These fields can be sent cross process. They are also valid
+     * to duplicate within the same process.
+     *
+     * A table is stored within psPrivateData on gralloc_module_t (this
+     * is obviously per-process) which maps stamps to a mapped
+     * PVRSRV_CLIENT_MEM_INFO in that process. Each map entry has a lock
+     * count associated with it, satisfying the requirements of the
+     * Android API. This also prevents us from leaking maps/allocations.
+     *
+     * This table has entries inserted either by alloc()
+     * (alloc_device_t) or map() (gralloc_module_t). Entries are removed
+     * by free() (alloc_device_t) and unmap() (gralloc_module_t).
+     *
+     * As a special case for framebuffer_device_t, framebuffer_open()
+     * will add and framebuffer_close() will remove from this table.
+     */
+
+#define IMG_NATIVE_HANDLE_NUMFDS MAX_SUB_ALLOCS
+    /* The `fd' field is used to "export" a meminfo to another process.
+     * Therefore, it is allocated by alloc_device_t, and consumed by
+     * gralloc_module_t. The framebuffer_device_t does not need a handle,
+     * and the special value IMG_FRAMEBUFFER_FD is used instead.
+     */
+    int fd[MAX_SUB_ALLOCS];
+
+#define IMG_NATIVE_HANDLE_NUMINTS ((sizeof(unsigned long long) / sizeof(int)) + 5)
+    /* A KERNEL unique identifier for any exported kernel meminfo. Each
+     * exported kernel meminfo will have a unique stamp, but note that in
+     * userspace, several meminfos across multiple processes could have
+     * the same stamp. As the native_handle can be dup(2)'d, there could be
+     * multiple handles with the same stamp but different file descriptors.
+     */
+    unsigned long long ui64Stamp;
+
+    /* This is used for buffer usage validation when locking a buffer,
+     * and also in WSEGL (for the composition bypass feature).
+     */
+    int usage;
+
+    //int dummy;
+    /* In order to do efficient cache flushes we need the buffer dimensions
+     * and format. These are available on the ANativeWindowBuffer,
+     * but the platform doesn't pass them down to the graphics HAL.
+     *
+     * These fields are also used in the composition bypass. In this
+     * capacity, these are the "real" values for the backing allocation.
+     */
+    int iWidth;
+    int iHeight;
+    int iFormat;
+    unsigned int uiBpp;
+}
+__attribute__((aligned(sizeof(int)),packed)) IMG_native_handle_t;
+
+typedef struct
+{
+    framebuffer_device_t base;
+
+    /* The HWC was loaded. post() is no longer responsible for presents */
+    int bBypassPost;
+
+    /* Custom-blit components in lieu of overlay hardware */
+    int (*Blit)(framebuffer_device_t *device, buffer_handle_t src,
+                buffer_handle_t dest, int w, int h, int x, int y);
+
+    /* HWC path for present posts */
+    int (*Post2)(framebuffer_device_t *fb, buffer_handle_t *buffers,
+                 int num_buffers, void *data, int data_length);
+}
+IMG_framebuffer_device_public_t;
+
+typedef struct IMG_gralloc_module_public_t
+{
+    gralloc_module_t base;
+
+    /* If the framebuffer has been opened, this will point to the
+     * framebuffer device data required by the allocator, WSEGL
+     * modules and composerhal.
+     */
+    IMG_framebuffer_device_public_t *psFrameBufferDevice;
+
+    int (*GetPhyAddrs)(struct IMG_gralloc_module_public_t const* module,
+                       buffer_handle_t handle,
+                       unsigned int auiPhyAddr[MAX_SUB_ALLOCS]);
+	/* Custom-blit components in lieu of overlay hardware */
+	int (*Blit)(struct IMG_gralloc_module_public_t const *module,
+				buffer_handle_t src,
+				void *dest[MAX_SUB_ALLOCS], int format);
+
+	int (*Blit2)(struct IMG_gralloc_module_public_t const *module,
+				 buffer_handle_t src, buffer_handle_t dest,
+				 int w, int h, int x, int y);
+}
+IMG_gralloc_module_public_t;
+
+typedef struct
+{
+    int l, t, w, h;
+}
+IMG_write_lock_rect_t;
+
+typedef struct IMG_buffer_format_public_t
+{
+    /* Buffer formats are returned as a linked list */
+    struct IMG_buffer_format_public_t *psNext;
+
+    /* HAL_PIXEL_FORMAT_... enumerant */
+    int iHalPixelFormat;
+
+    /* WSEGL_PIXELFORMAT_... enumerant */
+    int iWSEGLPixelFormat;
+
+    /* Friendly name for format */
+    const char *const szName;
+
+    /* Bits (not bytes) per pixel */
+    unsigned int uiBpp;
+
+    /* GPU output format (creates EGLConfig for format) */
+    int bGPURenderable;
+}
+IMG_buffer_format_public_t;
+
+#endif /* HAL_PUBLIC_H */
diff --git a/exynos3/s5pc110/include/s3c_bc.h b/exynos3/s5pc110/include/s3c_bc.h
new file mode 100755
index 0000000..afab544
--- /dev/null
+++ b/exynos3/s5pc110/include/s3c_bc.h
@@ -0,0 +1,63 @@
+/*!****************************************************************************
+@File           s3c_bc.h
+
+@Title          s3c_bc kernel driver parameters
+
+@Author         Imagination Technologies
+		Samsung Electronics Co. LTD
+
+@Date           03/03/2010
+
+@Copyright      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.
+
+@Platform       Generic
+
+@Description    s3c_bc kernel driver parameters
+
+@DoxygenVer
+
+******************************************************************************/
+
+/******************************************************************************
+Modifications :-
+$Log: s3c_bc.h $
+******************************************************************************/
+#ifndef __S3C_BC_H__
+#define __S3C_BC_H__
+
+#include <linux/ioctl.h>
+
+#define S3C_BC_DEVICE_NAME					"s3c_bc"
+
+#define S3C_BC_DEVICE_ID					0
+#define S3C_BC_DEVICE_BUFFER_COUNT			4								/* TODO: Modify this accordingly. */
+
+#define S3C_BC_DEVICE_PHYS_PAGE_SIZE		0x1000							/* 4KB */
+
+typedef struct S3C_BC_ioctl_package_TAG
+{
+	int inputparam;
+	int outputparam;
+} S3C_BC_ioctl_package, *PS3C_BC_ioctl_package;
+
+/*!< Nov 2006: according to ioctl-number.txt 'g' wasn't in use. */
+#define S3C_BC_IOC_GID      'g'
+
+#define S3C_BC_IOWR(INDEX)  _IOWR(S3C_BC_IOC_GID, INDEX, S3C_BC_ioctl_package)
+
+#define S3C_BC_ioctl_get_physical_base_address		S3C_BC_IOWR(0)
+
+#endif /* __S3C_BC__H__ */
+/******************************************************************************
+ End of file (s3c_bc.h)
+******************************************************************************/
diff --git a/exynos3/s5pc110/include/s3c_mem.h b/exynos3/s5pc110/include/s3c_mem.h
new file mode 100755
index 0000000..d51398a
--- /dev/null
+++ b/exynos3/s5pc110/include/s3c_mem.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright@ 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 _S3C_MEM_COMMON_H_
+#define _S3C_MEM_COMMON_H_
+
+#define MEM_IOCTL_MAGIC			'M'
+
+#define S3C_MEM_ALLOC			_IOWR(MEM_IOCTL_MAGIC, 310, struct s3c_mem_alloc)
+#define S3C_MEM_FREE			_IOWR(MEM_IOCTL_MAGIC, 311, struct s3c_mem_alloc)
+
+#define S3C_MEM_SHARE_ALLOC		_IOWR(MEM_IOCTL_MAGIC, 314, struct s3c_mem_alloc)
+#define S3C_MEM_SHARE_FREE		_IOWR(MEM_IOCTL_MAGIC, 315, struct s3c_mem_alloc)
+
+#define S3C_MEM_CACHEABLE_ALLOC		_IOWR(MEM_IOCTL_MAGIC, 316, struct s3c_mem_alloc)
+#define S3C_MEM_CACHEABLE_SHARE_ALLOC	_IOWR(MEM_IOCTL_MAGIC, 317, struct s3c_mem_alloc)
+
+#define S3C_MEM_DMA_COPY		_IOWR(MEM_IOCTL_MAGIC, 318, struct s3c_mem_dma_param)
+#define S3C_MEM_DMA_SET			_IOWR(MEM_IOCTL_MAGIC, 319, struct s3c_mem_dma_param)
+
+#define S3C_MEM_CACHE_INV			_IOWR(MEM_IOCTL_MAGIC, 330, struct s3c_mem_dma_param)
+
+
+struct s3c_mem_alloc {
+	int		size;
+	unsigned int 	vir_addr;
+	unsigned int 	phy_addr;
+};
+
+struct s3c_mem_dma_param {
+	int		size;
+	unsigned int 	src_addr;
+	unsigned int 	dst_addr;
+	int		cfg;
+};
+
+#if 0
+typedef struct _s3c_mem_t{
+     int     dev_fd;
+     struct  s3c_mem_alloc       mem_alloc_info;
+}s3c_mem_t;
+#endif
+#endif // _S3C_MEM_COMMON_H_
diff --git a/exynos3/s5pc110/include/s5p_fimc.h b/exynos3/s5pc110/include/s5p_fimc.h
new file mode 100755
index 0000000..d2c760c
--- /dev/null
+++ b/exynos3/s5pc110/include/s5p_fimc.h
@@ -0,0 +1,153 @@
+/*
+ * Copyright@ 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 _S5P_FIMC_H_
+#define _S5P_FIMC_H_
+
+#include <linux/videodev2.h>
+
+/*
+ * G E N E R A L S
+ *
+*/
+#define MIN(x, y)		((x < y) ? x : y)
+
+/*
+ * P I X E L   F O R M A T   G U I D E
+ *
+ * The 'x' means 'DO NOT CARE'
+ * The '*' means 'FIMC SPECIFIC'
+ * For some fimc formats, we couldn't find equivalent format in the V4L2 FOURCC.
+ *
+ * FIMC TYPE	PLANES	ORDER		V4L2_PIX_FMT
+ * ---------------------------------------------------------
+ * RGB565	x	x		V4L2_PIX_FMT_RGB565
+ * RGB888	x	x		V4L2_PIX_FMT_RGB24
+ * YUV420	2	LSB_CBCR	V4L2_PIX_FMT_NV12
+ * YUV420	2	LSB_CRCB	V4L2_PIX_FMT_NV21
+ * YUV420	2	MSB_CBCR	V4L2_PIX_FMT_NV21X*
+ * YUV420	2	MSB_CRCB	V4L2_PIX_FMT_NV12X*
+ * YUV420	3	x		V4L2_PIX_FMT_YUV420
+ * YUV422	1	YCBYCR		V4L2_PIX_FMT_YUYV
+ * YUV422	1	YCRYCB		V4L2_PIX_FMT_YVYU
+ * YUV422	1	CBYCRY		V4L2_PIX_FMT_UYVY
+ * YUV422	1	CRYCBY		V4L2_PIX_FMT_VYUY*
+ * YUV422	2	LSB_CBCR	V4L2_PIX_FMT_NV16*
+ * YUV422	2	LSB_CRCB	V4L2_PIX_FMT_NV61*
+ * YUV422	2	MSB_CBCR	V4L2_PIX_FMT_NV16X*
+ * YUV422	2	MSB_CRCB	V4L2_PIX_FMT_NV61X*
+ * YUV422	3	x		V4L2_PIX_FMT_YUV422P
+ *
+*/
+
+/*
+ * V 4 L 2   F I M C   E X T E N S I O N S
+ *
+*/
+#define V4L2_PIX_FMT_YVYU		v4l2_fourcc('Y', 'V', 'Y', 'U')
+
+/* FOURCC for FIMC specific */
+#define V4L2_PIX_FMT_NV12X		v4l2_fourcc('N', '1', '2', 'X')
+#define V4L2_PIX_FMT_NV21X		v4l2_fourcc('N', '2', '1', 'X')
+#define V4L2_PIX_FMT_VYUY		v4l2_fourcc('V', 'Y', 'U', 'Y')
+#define V4L2_PIX_FMT_NV16		v4l2_fourcc('N', 'V', '1', '6')
+#define V4L2_PIX_FMT_NV61		v4l2_fourcc('N', 'V', '6', '1')
+#define V4L2_PIX_FMT_NV16X		v4l2_fourcc('N', '1', '6', 'X')
+#define V4L2_PIX_FMT_NV61X		v4l2_fourcc('N', '6', '1', 'X')
+
+#define V4L2_PIX_FMT_NV12T    	v4l2_fourcc('T', 'V', '1', '2') /* 12  Y/CbCr 4:2:0 64x32 macroblocks */
+
+/* CID extensions */
+#define V4L2_CID_ROTATION		(V4L2_CID_PRIVATE_BASE + 0)
+#define V4L2_CID_RESERVED_MEM_BASE_ADDR	(V4L2_CID_PRIVATE_BASE + 20)
+#define V4L2_CID_FIMC_VERSION		(V4L2_CID_PRIVATE_BASE + 21)
+/*
+ * U S E R   D E F I N E D   T Y P E S
+ *
+*/
+
+typedef unsigned int dma_addr_t;
+
+struct fimc_buf {
+	dma_addr_t	base[3];
+ 	size_t		length[3];
+};
+
+struct fimc_buffer {
+	void	*virt_addr;
+	void	*phys_addr;
+	size_t	length;
+};
+
+struct yuv_fmt_list {
+	const char 		*name;
+	const char 		*desc;
+	unsigned int 	fmt;
+	int				bpp;
+	int				planes;
+};
+
+struct img_offset {
+    int y_h;
+    int y_v;
+    int cb_h;
+    int cb_v;
+    int cr_h;
+    int cr_v;
+};
+
+//------------ STRUCT ---------------------------------------------------------//
+
+typedef	struct
+{
+	unsigned int full_width;			// Source Image Full Width (Virtual screen size)
+	unsigned int full_height;			// Source Image Full Height (Virtual screen size)
+	unsigned int start_x;				// Source Image Start width offset
+	unsigned int start_y;				// Source Image Start height offset
+	unsigned int width;					// Source Image Width
+	unsigned int height;				// Source Image Height
+	unsigned int buf_addr_phy_rgb_y;	// Base Address of the Source Image (RGB or Y): Physical Address
+	unsigned int buf_addr_phy_cb;		// Base Address of the Source Image (CB Component) : Physical Address
+	unsigned int buf_addr_phy_cr;		// Base Address of the Source Image (CR Component) : Physical Address
+	unsigned int color_space;			// Color Space of the Source Image
+} s5p_fimc_img_info;
+
+typedef struct 
+{
+	s5p_fimc_img_info	src;
+	s5p_fimc_img_info	dst;
+} s5p_fimc_params_t;
+
+typedef struct _s5p_fimc_t {
+    int                dev_fd;
+    struct fimc_buffer  out_buf;
+
+    s5p_fimc_params_t   params;
+
+    int                 use_ext_out_mem;
+    unsigned int        hw_ver;
+}s5p_fimc_t;
+
+//------------------------  functions for v4l2 ------------------------------//
+int fimc_v4l2_set_src(int fd, unsigned int hw_ver, s5p_fimc_img_info *src);
+int fimc_v4l2_set_dst(int fd, s5p_fimc_img_info *dst, int rotation, unsigned int addr);
+int fimc_v4l2_stream_on(int fd, enum v4l2_buf_type type);
+int fimc_v4l2_queue(int fd, struct fimc_buf *fimc_buf);
+int fimc_v4l2_dequeue(int fd);
+int fimc_v4l2_stream_off(int fd);
+int fimc_v4l2_clr_buf(int fd);
+int fimc_handle_oneshot(int fd, struct fimc_buf *fimc_buf);
+#endif
diff --git a/exynos3/s5pc110/include/sec_format.h b/exynos3/s5pc110/include/sec_format.h
new file mode 100755
index 0000000..99a47bf
--- /dev/null
+++ b/exynos3/s5pc110/include/sec_format.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright@ 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 _SEC_FORMAT_H_
+#define _SEC_FORMAT_H_
+
+/* enum related to pixel format */
+
+enum {
+    HAL_PIXEL_FORMAT_YCbCr_420_SP        = 0x100,
+    HAL_PIXEL_FORMAT_YCbCr_420_P         = 0x101,
+    HAL_PIXEL_FORMAT_YCbCr_420_I         = 0x102,
+    HAL_PIXEL_FORMAT_CbYCrY_422_I        = 0x103,
+    HAL_PIXEL_FORMAT_CbYCrY_420_I        = 0x104,
+    HAL_PIXEL_FORMAT_YCbCr_422_P         = 0x105,
+    HAL_PIXEL_FORMAT_YCrCb_422_SP        = 0x106,
+    // support custom format for zero copy
+    HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP = 0x110,
+    HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP = 0x111,
+    HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED = 0x112,
+    HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_SP = 0x113,
+    HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_SP = 0x114,
+    HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_I  = 0x115,
+    HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_I  = 0x116,
+    HAL_PIXEL_FORMAT_CUSTOM_CbYCrY_422_I = 0x117,
+    HAL_PIXEL_FORMAT_CUSTOM_CrYCbY_422_I = 0x118,
+    HAL_PIXEL_FORMAT_CUSTOM_MAX
+};
+
+#endif
diff --git a/exynos3/s5pc110/include/sec_lcd.h b/exynos3/s5pc110/include/sec_lcd.h
new file mode 100755
index 0000000..6a3a34a
--- /dev/null
+++ b/exynos3/s5pc110/include/sec_lcd.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright@ 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 _SEC_FB_LCD_
+#define _SEC_FB_LCD_
+
+/*
+ * S T R U C T U R E S  F O R  C U S T O M  I O C T L S
+ *
+*/
+struct secfb_user_window {
+    int x;
+    int y;
+};
+
+/*
+ * C U S T O M  I O C T L S
+ *
+*/
+
+#define FBIO_WAITFORVSYNC       _IO  ('F', 32)
+#define SECFB_WIN_POSITION      _IOW ('F', 203, struct secfb_user_window)
+#define S3CFB_SET_VSYNC_INT     _IOW ('F', 206, uint32_t)
+
+#define DEFAULT_LCD_WIDTH   (480)
+#define DEFAULT_LCD_HEIGHT  (800)
+#define DEFAULT_LCD_BPP     (32)
+
+/***************** LCD frame buffer *****************/
+#define FB0_NAME    "/dev/fb0"
+#define FB1_NAME    "/dev/fb1"
+#define FB2_NAME    "/dev/fb2"
+#define FB3_NAME    "/dev/fb3"
+#define FB4_NAME    "/dev/fb4"
+
+#endif
diff --git a/exynos3/s5pc110/include/sec_utils.h b/exynos3/s5pc110/include/sec_utils.h
new file mode 100644
index 0000000..3e41afe
--- /dev/null
+++ b/exynos3/s5pc110/include/sec_utils.h
@@ -0,0 +1,331 @@
+/*
+ * Copyright@ 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 __SAMSUNG_SYSLSI_SEC_COMMON_H__
+#define __SAMSUNG_SYSLSI_SEC_COMMON_H__
+
+//---------------------------------------------------------//
+// Include
+//---------------------------------------------------------//
+
+#include <hardware/hardware.h>
+#include "sec_format.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <linux/videodev2.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+//---------------------------------------------------------//
+// Common structure                                        //
+//---------------------------------------------------------//
+struct ADDRS {
+    unsigned int addr_y;
+    unsigned int addr_cbcr;
+    unsigned int buf_idx;
+    unsigned int reserved;
+};
+
+//---------------------------------------------------------//
+// Common function                                         //
+//---------------------------------------------------------//
+inline int HAL_PIXEL_FORMAT_2_V4L2_PIX(int HAL_PIXEL_FORMAT)
+{
+    int V4L2_PIX = -1;
+
+    switch (HAL_PIXEL_FORMAT) {
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+        V4L2_PIX = V4L2_PIX_FMT_RGB32;
+        break;
+
+    case HAL_PIXEL_FORMAT_RGB_888:
+        V4L2_PIX = V4L2_PIX_FMT_RGB24;
+        break;
+
+    case HAL_PIXEL_FORMAT_RGB_565:
+        V4L2_PIX = V4L2_PIX_FMT_RGB565;
+        break;
+
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+        //V4L2_PIX = V4L2_PIX_FMT_BGR32; // this is not proper on fimc.
+        V4L2_PIX = V4L2_PIX_FMT_RGB32;
+        break;
+
+    case HAL_PIXEL_FORMAT_RGBA_5551:
+        V4L2_PIX = V4L2_PIX_FMT_RGB555X;
+        break;
+
+    case HAL_PIXEL_FORMAT_RGBA_4444:
+        V4L2_PIX = V4L2_PIX_FMT_RGB444;
+        break;
+
+    case HAL_PIXEL_FORMAT_YV12:
+    case HAL_PIXEL_FORMAT_YCbCr_420_P:
+        V4L2_PIX = V4L2_PIX_FMT_YUV420;
+        break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_SP:
+        V4L2_PIX = V4L2_PIX_FMT_NV61;
+        break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP:
+        V4L2_PIX = V4L2_PIX_FMT_NV12;
+        break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_422_I:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_I:
+        V4L2_PIX = V4L2_PIX_FMT_YUYV;
+        break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_422_P:
+        V4L2_PIX = V4L2_PIX_FMT_YUV422P;
+        break;
+
+    case HAL_PIXEL_FORMAT_CbYCrY_422_I:
+    case HAL_PIXEL_FORMAT_CUSTOM_CbYCrY_422_I:
+        V4L2_PIX = V4L2_PIX_FMT_UYVY;
+        break;
+
+    case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_SP:
+        V4L2_PIX = V4L2_PIX_FMT_NV16;
+        break;
+
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP:
+        V4L2_PIX = V4L2_PIX_FMT_NV21;
+        break;
+
+    case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED:
+        V4L2_PIX = V4L2_PIX_FMT_NV12T;
+        break;
+
+   case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_I:
+        V4L2_PIX = V4L2_PIX_FMT_YVYU;
+        break;
+
+   case HAL_PIXEL_FORMAT_CUSTOM_CrYCbY_422_I:
+        V4L2_PIX = V4L2_PIX_FMT_VYUY;
+        break;
+
+    default:
+        ALOGE("%s::unmatched HAL_PIXEL_FORMAT color_space(0x%x)\n",
+                __func__, HAL_PIXEL_FORMAT);
+        break;
+    }
+
+    return V4L2_PIX;
+}
+
+inline int V4L2_PIX_2_HAL_PIXEL_FORMAT(int V4L2_PIX)
+{
+    int HAL_PIXEL_FORMAT = -1;
+
+    switch (V4L2_PIX) {
+    case V4L2_PIX_FMT_RGB32:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_RGBA_8888;
+        //HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_RGBX_8888;
+        break;
+
+    case V4L2_PIX_FMT_RGB24:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_RGB_888;
+        break;
+
+    case V4L2_PIX_FMT_RGB565:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_RGB_565;
+        break;
+
+    case V4L2_PIX_FMT_BGR32:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_BGRA_8888;
+        break;
+
+    case V4L2_PIX_FMT_RGB555X:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_RGBA_5551;
+        break;
+
+    case V4L2_PIX_FMT_RGB444:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_RGBA_4444;
+        break;
+
+    case V4L2_PIX_FMT_YUV420:
+        //HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_YV12;
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_YCbCr_420_P;
+        break;
+
+    case V4L2_PIX_FMT_NV16:
+        //HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_YCrCb_422_SP;
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_SP;
+        break;
+
+    case V4L2_PIX_FMT_NV12:
+        //HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_YCrCb_420_SP;
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP;
+        break;
+
+    case V4L2_PIX_FMT_YUYV:
+        //HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_YCbCr_422_I;
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_I;
+        break;
+
+    case V4L2_PIX_FMT_YUV422P:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_YCbCr_422_P;
+        break;
+
+    case V4L2_PIX_FMT_UYVY:
+        //HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CbYCrY_422_I;
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_CbYCrY_422_I;
+        break;
+
+    case V4L2_PIX_FMT_NV21:
+        //HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_YCbCr_420_SP;
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP;
+        break;
+
+    case V4L2_PIX_FMT_NV12T:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED;
+        break;
+
+    case V4L2_PIX_FMT_NV61:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_SP;
+        break;
+
+    case V4L2_PIX_FMT_YVYU:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_I;
+        break;
+
+    case V4L2_PIX_FMT_VYUY:
+        HAL_PIXEL_FORMAT = HAL_PIXEL_FORMAT_CUSTOM_CrYCbY_422_I;
+        break;
+
+    default:
+        ALOGE("%s::unmatched V4L2_PIX color_space(%d)\n",
+                __func__, V4L2_PIX);
+        break;
+    }
+
+    return HAL_PIXEL_FORMAT;
+}
+
+#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 GET_32BPP_FRAME_SIZE(w, h)  (((w) * (h)) << 2)
+#define GET_24BPP_FRAME_SIZE(w, h)  (((w) * (h)) * 3)
+#define GET_16BPP_FRAME_SIZE(w, h)  (((w) * (h)) << 1)
+
+inline unsigned int FRAME_SIZE(int HAL_PIXEL_FORMAT, int w, int h)
+{
+    unsigned int frame_size = 0;
+    unsigned int size       = 0;
+
+    switch (HAL_PIXEL_FORMAT) {
+    // 16bpp
+    case HAL_PIXEL_FORMAT_RGB_565:
+    case HAL_PIXEL_FORMAT_RGBA_5551:
+    //case HAL_PIXEL_FORMAT_ARGB_1555:
+    //case HAL_PIXEL_FORMAT_BGRA_5551:
+    //case HAL_PIXEL_FORMAT_ABGR_1555:
+
+    //case HAL_PIXEL_FORMAT_RGBX_5551:
+    //case HAL_PIXEL_FORMAT_XRGB_1555:
+    //case HAL_PIXEL_FORMAT_BGRX_5551:
+    //case HAL_PIXEL_FORMAT_XBGR_1555:
+
+    case HAL_PIXEL_FORMAT_RGBA_4444:
+    //case HAL_PIXEL_FORMAT_ARGB_4444:
+    //case HAL_PIXEL_FORMAT_BGRA_4444:
+    //case HAL_PIXEL_FORMAT_ABGR_4444:
+
+    //case HAL_PIXEL_FORMAT_RGBX_4444:
+    //case HAL_PIXEL_FORMAT_XRGB_4444:
+    //case HAL_PIXEL_FORMAT_BGRX_4444:
+    //case HAL_PIXEL_FORMAT_XBGR_4444:
+        frame_size = GET_16BPP_FRAME_SIZE(w, h);
+        break;
+
+    // 24bpp
+    case HAL_PIXEL_FORMAT_RGB_888:
+        frame_size = GET_24BPP_FRAME_SIZE(w, h);
+        break;
+
+    // 32bpp
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+    //case HAL_PIXEL_FORMAT_ARGB_8888:
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+    //case HAL_PIXEL_FORMAT_ABGR_8888:
+
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+    //case HAL_PIXEL_FORMAT_XRGB_8888:
+    //case HAL_PIXEL_FORMAT_BGRX_8888:
+    //case HAL_PIXEL_FORMAT_XBGR_8888:
+        frame_size = GET_32BPP_FRAME_SIZE(w, h);
+        break;
+
+    // 12bpp
+    case HAL_PIXEL_FORMAT_YV12:
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+    case HAL_PIXEL_FORMAT_YCbCr_420_P:
+    case HAL_PIXEL_FORMAT_YCbCr_420_I:
+    case HAL_PIXEL_FORMAT_CbYCrY_420_I:
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP:
+        size = w * h;
+        // frame_size = width * height * 3 / 2;
+        // sw5771.park : very curious...
+        // frame_size = size + ((size / 4) * 2);
+        frame_size = size + ((size >> 2) << 1);
+        break;
+
+    case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED:
+        frame_size =   ALIGN_TO_8KB(ALIGN_TO_128B(w) * ALIGN_TO_32B(h))
+                     + ALIGN_TO_8KB(ALIGN_TO_128B(w) * ALIGN_TO_32B(h >> 1));
+        break;
+
+    // 16bpp
+    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+    case HAL_PIXEL_FORMAT_YCbCr_422_I:
+    case HAL_PIXEL_FORMAT_YCbCr_422_P:
+    case HAL_PIXEL_FORMAT_CbYCrY_422_I:
+    case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_SP:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_I:
+    case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_I:
+    case HAL_PIXEL_FORMAT_CUSTOM_CbYCrY_422_I:
+    case HAL_PIXEL_FORMAT_CUSTOM_CrYCbY_422_I:
+        frame_size = GET_16BPP_FRAME_SIZE(w, h);
+        break;
+
+    default:
+        ALOGD("%s::no matching source colorformat(0x%x), w(%d), h(%d) fail\n",
+                __func__, HAL_PIXEL_FORMAT, w, h);
+        break;
+    }
+
+    return frame_size;
+}
+
+#endif //__SAMSUNG_SYSLSI_SEC_COMMON_H__
diff --git a/exynos3/s5pc110/include/videodev2_samsung.h b/exynos3/s5pc110/include/videodev2_samsung.h
new file mode 100755
index 0000000..0d4dcc9
--- /dev/null
+++ b/exynos3/s5pc110/include/videodev2_samsung.h
@@ -0,0 +1,636 @@
+/*
+ * Video for Linux Two header file for samsung
+ *
+ * Copyright (C) 2009, Samsung Electronics
+ *
+ * This header file contains several v4l2 APIs to be proposed to v4l2
+ * community and until bein accepted, will be used restrictly in Samsung's
+ * camera interface driver FIMC.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, 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 __LINUX_VIDEODEV2_SAMSUNG_H
+#define __LINUX_VIDEODEV2_SAMSUNG_H
+
+/* Values for 'capabilities' field */
+/* Object detection device */
+#define V4L2_CAP_OBJ_RECOGNITION	0x10000000
+/* strobe control */
+#define V4L2_CAP_STROBE			0x20000000
+
+#define V4L2_CID_FOCUS_MODE		(V4L2_CID_CAMERA_CLASS_BASE + 17)
+/* Focus Methods */
+enum v4l2_focus_mode {
+	V4L2_FOCUS_MODE_AUTO		= 0,
+	V4L2_FOCUS_MODE_MACRO		= 1,
+	V4L2_FOCUS_MODE_MANUAL		= 2,
+	V4L2_FOCUS_MODE_LASTP		= 2,
+};
+
+#define V4L2_CID_ZOOM_MODE		(V4L2_CID_CAMERA_CLASS_BASE + 18)
+/* Zoom Methods */
+enum v4l2_zoom_mode {
+	V4L2_ZOOM_MODE_CONTINUOUS	= 0,
+	V4L2_ZOOM_MODE_OPTICAL		= 1,
+	V4L2_ZOOM_MODE_DIGITAL		= 2,
+	V4L2_ZOOM_MODE_LASTP		= 2,
+};
+
+/* Exposure Methods */
+#define V4L2_CID_PHOTOMETRY		(V4L2_CID_CAMERA_CLASS_BASE + 19)
+enum v4l2_photometry_mode {
+	V4L2_PHOTOMETRY_MULTISEG = 0,	/*Multi Segment */
+	V4L2_PHOTOMETRY_CWA	= 1,	/*Centre Weighted Average */
+	V4L2_PHOTOMETRY_SPOT	= 2,
+	V4L2_PHOTOMETRY_AFSPOT	= 3,	/*Spot metering on focused point */
+	V4L2_PHOTOMETRY_LASTP = V4L2_PHOTOMETRY_AFSPOT,
+};
+
+/* Manual exposure control items menu type: iris, shutter, iso */
+#define V4L2_CID_CAM_APERTURE	(V4L2_CID_CAMERA_CLASS_BASE + 20)
+#define V4L2_CID_CAM_SHUTTER	(V4L2_CID_CAMERA_CLASS_BASE + 21)
+#define V4L2_CID_CAM_ISO	(V4L2_CID_CAMERA_CLASS_BASE + 22)
+
+/* Following CIDs are menu type */
+#define V4L2_CID_SCENEMODE	(V4L2_CID_CAMERA_CLASS_BASE + 23)
+#define V4L2_CID_CAM_STABILIZE	(V4L2_CID_CAMERA_CLASS_BASE + 24)
+#define V4L2_CID_CAM_MULTISHOT	(V4L2_CID_CAMERA_CLASS_BASE + 25)
+
+/* Control dynamic range */
+#define V4L2_CID_CAM_DR		(V4L2_CID_CAMERA_CLASS_BASE + 26)
+
+/* White balance preset control */
+#define V4L2_CID_WHITE_BALANCE_PRESET	(V4L2_CID_CAMERA_CLASS_BASE + 27)
+
+/* CID extensions */
+#define V4L2_CID_ROTATION		(V4L2_CID_PRIVATE_BASE + 0)
+#define V4L2_CID_PADDR_Y		(V4L2_CID_PRIVATE_BASE + 1)
+#define V4L2_CID_PADDR_CB		(V4L2_CID_PRIVATE_BASE + 2)
+#define V4L2_CID_PADDR_CR		(V4L2_CID_PRIVATE_BASE + 3)
+#define V4L2_CID_PADDR_CBCR		(V4L2_CID_PRIVATE_BASE + 4)
+#define V4L2_CID_OVERLAY_AUTO		(V4L2_CID_PRIVATE_BASE + 5)
+#define V4L2_CID_OVERLAY_VADDR0		(V4L2_CID_PRIVATE_BASE + 6)
+#define V4L2_CID_OVERLAY_VADDR1		(V4L2_CID_PRIVATE_BASE + 7)
+#define V4L2_CID_OVERLAY_VADDR2		(V4L2_CID_PRIVATE_BASE + 8)
+#define V4L2_CID_OVLY_MODE		(V4L2_CID_PRIVATE_BASE + 9)
+#define V4L2_CID_DST_INFO		(V4L2_CID_PRIVATE_BASE + 10)
+#define V4L2_CID_IMAGE_EFFECT_FN	(V4L2_CID_PRIVATE_BASE + 16)
+#define V4L2_CID_IMAGE_EFFECT_APPLY	(V4L2_CID_PRIVATE_BASE + 17)
+#define V4L2_CID_IMAGE_EFFECT_CB	(V4L2_CID_PRIVATE_BASE + 18)
+#define V4L2_CID_IMAGE_EFFECT_CR	(V4L2_CID_PRIVATE_BASE + 19)
+#define V4L2_CID_RESERVED_MEM_BASE_ADDR	(V4L2_CID_PRIVATE_BASE + 20)
+#define V4L2_CID_FIMC_VERSION		(V4L2_CID_PRIVATE_BASE + 21)
+
+#define V4L2_CID_STREAM_PAUSE			(V4L2_CID_PRIVATE_BASE + 53)
+
+/* CID Extensions for camera sensor operations */
+#define V4L2_CID_CAM_PREVIEW_ONOFF		(V4L2_CID_PRIVATE_BASE + 64)
+#define V4L2_CID_CAM_CAPTURE			(V4L2_CID_PRIVATE_BASE + 65)
+#define V4L2_CID_CAM_JPEG_MEMSIZE		(V4L2_CID_PRIVATE_BASE + 66)
+
+#define V4L2_CID_CAM_DATE_INFO_YEAR		(V4L2_CID_PRIVATE_BASE + 14)
+#define V4L2_CID_CAM_DATE_INFO_MONTH		(V4L2_CID_PRIVATE_BASE + 15)
+#define V4L2_CID_CAM_DATE_INFO_DATE		(V4L2_CID_PRIVATE_BASE + 22)
+#define V4L2_CID_CAM_SENSOR_VER			(V4L2_CID_PRIVATE_BASE + 23)
+#define V4L2_CID_CAM_FW_MINOR_VER		(V4L2_CID_PRIVATE_BASE + 24)
+#define V4L2_CID_CAM_FW_MAJOR_VER		(V4L2_CID_PRIVATE_BASE + 25)
+#define V4L2_CID_CAM_PRM_MINOR_VER		(V4L2_CID_PRIVATE_BASE + 26)
+#define V4L2_CID_CAM_PRM_MAJOR_VER		(V4L2_CID_PRIVATE_BASE + 27)
+#define V4L2_CID_CAM_FW_VER			(V4L2_CID_PRIVATE_BASE + 28)
+#define V4L2_CID_CAM_SET_FW_ADDR		(V4L2_CID_PRIVATE_BASE + 29)
+#define V4L2_CID_CAM_SET_FW_SIZE		(V4L2_CID_PRIVATE_BASE + 30)
+#define V4L2_CID_CAM_UPDATE_FW			(V4L2_CID_PRIVATE_BASE + 31)
+#define V4L2_CID_CAM_JPEG_MAIN_SIZE		(V4L2_CID_PRIVATE_BASE + 32)
+#define V4L2_CID_CAM_JPEG_MAIN_OFFSET		(V4L2_CID_PRIVATE_BASE + 33)
+#define V4L2_CID_CAM_JPEG_THUMB_SIZE		(V4L2_CID_PRIVATE_BASE + 34)
+#define V4L2_CID_CAM_JPEG_THUMB_OFFSET		(V4L2_CID_PRIVATE_BASE + 35)
+#define V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET	(V4L2_CID_PRIVATE_BASE + 36)
+#define V4L2_CID_CAM_JPEG_QUALITY		(V4L2_CID_PRIVATE_BASE + 37)
+#define V4L2_CID_CAM_SENSOR_MAKER		(V4L2_CID_PRIVATE_BASE + 38)
+#define V4L2_CID_CAM_SENSOR_OPTICAL		(V4L2_CID_PRIVATE_BASE + 39)
+#define V4L2_CID_CAM_AF_VER_LOW			(V4L2_CID_PRIVATE_BASE + 40)
+#define V4L2_CID_CAM_AF_VER_HIGH		(V4L2_CID_PRIVATE_BASE + 41)
+#define V4L2_CID_CAM_GAMMA_RG_LOW		(V4L2_CID_PRIVATE_BASE + 42)
+#define V4L2_CID_CAM_GAMMA_RG_HIGH		(V4L2_CID_PRIVATE_BASE + 43)
+#define V4L2_CID_CAM_GAMMA_BG_LOW		(V4L2_CID_PRIVATE_BASE + 44)
+#define V4L2_CID_CAM_GAMMA_BG_HIGH		(V4L2_CID_PRIVATE_BASE + 45)
+#define V4L2_CID_CAM_DUMP_FW			(V4L2_CID_PRIVATE_BASE + 46)
+#define V4L2_CID_CAM_GET_DUMP_SIZE		(V4L2_CID_PRIVATE_BASE + 47)
+#define V4L2_CID_CAMERA_VT_MODE			(V4L2_CID_PRIVATE_BASE + 48)
+#define V4L2_CID_CAMERA_VGA_BLUR		(V4L2_CID_PRIVATE_BASE + 49)
+#define V4L2_CID_CAMERA_CAPTURE			(V4L2_CID_PRIVATE_BASE + 50)
+
+#define V4L2_CID_MAIN_SW_DATE_INFO_YEAR		(V4L2_CID_PRIVATE_BASE + 54)
+#define V4L2_CID_MAIN_SW_DATE_INFO_MONTH	(V4L2_CID_PRIVATE_BASE + 55)
+#define V4L2_CID_MAIN_SW_DATE_INFO_DATE		(V4L2_CID_PRIVATE_BASE + 56)
+#define V4L2_CID_MAIN_SW_FW_MINOR_VER		(V4L2_CID_PRIVATE_BASE + 57)
+#define V4L2_CID_MAIN_SW_FW_MAJOR_VER		(V4L2_CID_PRIVATE_BASE + 58)
+#define V4L2_CID_MAIN_SW_PRM_MINOR_VER		(V4L2_CID_PRIVATE_BASE + 59)
+#define V4L2_CID_MAIN_SW_PRM_MAJOR_VER		(V4L2_CID_PRIVATE_BASE + 60)
+
+enum v4l2_blur {
+	BLUR_LEVEL_0 = 0,
+	BLUR_LEVEL_1,
+	BLUR_LEVEL_2,
+	BLUR_LEVEL_3,
+	BLUR_LEVEL_MAX,
+};
+
+#define V4L2_CID_CAMERA_SCENE_MODE		(V4L2_CID_PRIVATE_BASE + 70)
+enum v4l2_scene_mode {
+	SCENE_MODE_BASE,
+	SCENE_MODE_NONE,
+	SCENE_MODE_PORTRAIT,
+	SCENE_MODE_NIGHTSHOT,
+	SCENE_MODE_BACK_LIGHT,
+	SCENE_MODE_LANDSCAPE,
+	SCENE_MODE_SPORTS,
+	SCENE_MODE_PARTY_INDOOR,
+	SCENE_MODE_BEACH_SNOW,
+	SCENE_MODE_SUNSET,
+	SCENE_MODE_DUST_DAWN,
+	SCENE_MODE_FALL_COLOR,
+	SCENE_MODE_FIREWORKS,
+	SCENE_MODE_TEXT,
+	SCENE_MODE_CANDLE_LIGHT,
+	SCENE_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_FLASH_MODE		(V4L2_CID_PRIVATE_BASE + 71)
+enum v4l2_flash_mode {
+	FLASH_MODE_BASE,
+	FLASH_MODE_OFF,
+	FLASH_MODE_AUTO,
+	FLASH_MODE_ON,
+	FLASH_MODE_TORCH,
+	FLASH_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BRIGHTNESS		(V4L2_CID_PRIVATE_BASE + 72)
+enum v4l2_ev_mode {
+	EV_MINUS_4 = 0,
+	EV_MINUS_3,
+	EV_MINUS_2,
+	EV_MINUS_1,
+	EV_DEFAULT,
+	EV_PLUS_1,
+	EV_PLUS_2,
+	EV_PLUS_3,
+	EV_PLUS_4,
+	EV_MAX,
+};
+
+#define V4L2_CID_CAMERA_WHITE_BALANCE		(V4L2_CID_PRIVATE_BASE + 73)
+enum v4l2_wb_mode {
+	WHITE_BALANCE_BASE = 0,
+	WHITE_BALANCE_AUTO,
+	WHITE_BALANCE_SUNNY,
+	WHITE_BALANCE_CLOUDY,
+	WHITE_BALANCE_TUNGSTEN,
+	WHITE_BALANCE_FLUORESCENT,
+	WHITE_BALANCE_MAX,
+};
+
+#define V4L2_CID_CAMERA_EFFECT			(V4L2_CID_PRIVATE_BASE + 74)
+enum v4l2_effect_mode {
+	IMAGE_EFFECT_BASE = 0,
+	IMAGE_EFFECT_NONE,
+	IMAGE_EFFECT_BNW,
+	IMAGE_EFFECT_SEPIA,
+	IMAGE_EFFECT_AQUA,
+	IMAGE_EFFECT_ANTIQUE,
+	IMAGE_EFFECT_NEGATIVE,
+	IMAGE_EFFECT_SHARPEN,
+	IMAGE_EFFECT_MAX,
+};
+
+#define V4L2_CID_CAMERA_ISO			(V4L2_CID_PRIVATE_BASE + 75)
+enum v4l2_iso_mode {
+	ISO_AUTO = 0,
+	ISO_50,
+	ISO_100,
+	ISO_200,
+	ISO_400,
+	ISO_800,
+	ISO_1600,
+	ISO_SPORTS,
+	ISO_NIGHT,
+	ISO_MOVIE,
+	ISO_MAX,
+};
+
+#define V4L2_CID_CAMERA_METERING		(V4L2_CID_PRIVATE_BASE + 76)
+enum v4l2_metering_mode {
+	METERING_BASE = 0,
+	METERING_MATRIX,
+	METERING_CENTER,
+	METERING_SPOT,
+	METERING_MAX,
+};
+
+#define V4L2_CID_CAMERA_CONTRAST		(V4L2_CID_PRIVATE_BASE + 77)
+enum v4l2_contrast_mode {
+	CONTRAST_MINUS_2 = 0,
+	CONTRAST_MINUS_1,
+	CONTRAST_DEFAULT,
+	CONTRAST_PLUS_1,
+	CONTRAST_PLUS_2,
+	CONTRAST_MAX,
+};
+
+#define V4L2_CID_CAMERA_SATURATION		(V4L2_CID_PRIVATE_BASE + 78)
+enum v4l2_saturation_mode {
+	SATURATION_MINUS_2 = 0,
+	SATURATION_MINUS_1,
+	SATURATION_DEFAULT,
+	SATURATION_PLUS_1,
+	SATURATION_PLUS_2,
+	SATURATION_MAX,
+};
+
+#define V4L2_CID_CAMERA_SHARPNESS		(V4L2_CID_PRIVATE_BASE + 79)
+enum v4l2_sharpness_mode {
+	SHARPNESS_MINUS_2 = 0,
+	SHARPNESS_MINUS_1,
+	SHARPNESS_DEFAULT,
+	SHARPNESS_PLUS_1,
+	SHARPNESS_PLUS_2,
+	SHARPNESS_MAX,
+};
+
+#define V4L2_CID_CAMERA_WDR			(V4L2_CID_PRIVATE_BASE + 80)
+enum v4l2_wdr_mode {
+	WDR_OFF,
+	WDR_ON,
+	WDR_MAX,
+};
+
+#define V4L2_CID_CAMERA_ANTI_SHAKE		(V4L2_CID_PRIVATE_BASE + 81)
+enum v4l2_anti_shake_mode {
+	ANTI_SHAKE_OFF,
+	ANTI_SHAKE_STILL_ON,
+	ANTI_SHAKE_MOVIE_ON,
+	ANTI_SHAKE_MAX,
+};
+
+#define V4L2_CID_CAMERA_TOUCH_AF_START_STOP	(V4L2_CID_PRIVATE_BASE + 82)
+enum v4l2_touch_af {
+	TOUCH_AF_STOP = 0,
+	TOUCH_AF_START,
+	TOUCH_AF_MAX,
+};
+
+#define V4L2_CID_CAMERA_SMART_AUTO		(V4L2_CID_PRIVATE_BASE + 83)
+enum v4l2_smart_auto {
+	SMART_AUTO_OFF = 0,
+	SMART_AUTO_ON,
+	SMART_AUTO_MAX,
+};
+
+#define V4L2_CID_CAMERA_VINTAGE_MODE		(V4L2_CID_PRIVATE_BASE + 84)
+enum v4l2_vintage_mode {
+	VINTAGE_MODE_BASE,
+	VINTAGE_MODE_OFF,
+	VINTAGE_MODE_NORMAL,
+	VINTAGE_MODE_WARM,
+	VINTAGE_MODE_COOL,
+	VINTAGE_MODE_BNW,
+	VINTAGE_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_JPEG_QUALITY	(V4L2_CID_PRIVATE_BASE + 85)
+#define V4L2_CID_CAMERA_GPS_LATITUDE	(V4L2_CID_CAMERA_CLASS_BASE + 30)
+#define V4L2_CID_CAMERA_GPS_LONGITUDE	(V4L2_CID_CAMERA_CLASS_BASE + 31)
+#define V4L2_CID_CAMERA_GPS_TIMESTAMP	(V4L2_CID_CAMERA_CLASS_BASE + 32)
+#define V4L2_CID_CAMERA_GPS_ALTITUDE	(V4L2_CID_CAMERA_CLASS_BASE + 33)
+#define V4L2_CID_CAMERA_EXIF_TIME_INFO	(V4L2_CID_CAMERA_CLASS_BASE + 34)
+#define V4L2_CID_CAMERA_ZOOM		(V4L2_CID_PRIVATE_BASE + 90)
+enum v4l2_zoom_level {
+	ZOOM_LEVEL_0 = 0,
+	ZOOM_LEVEL_1,
+	ZOOM_LEVEL_2,
+	ZOOM_LEVEL_3,
+	ZOOM_LEVEL_4,
+	ZOOM_LEVEL_5,
+	ZOOM_LEVEL_6,
+	ZOOM_LEVEL_7,
+	ZOOM_LEVEL_8,
+	ZOOM_LEVEL_9,
+	ZOOM_LEVEL_10,
+	ZOOM_LEVEL_11,
+	ZOOM_LEVEL_12,
+	ZOOM_LEVEL_MAX,
+};
+
+#define V4L2_CID_CAMERA_FACE_DETECTION		(V4L2_CID_PRIVATE_BASE + 91)
+enum v4l2_face_detection {
+	FACE_DETECTION_OFF = 0,
+	FACE_DETECTION_ON,
+	FACE_DETECTION_NOLINE,
+	FACE_DETECTION_ON_BEAUTY,
+	FACE_DETECTION_MAX,
+};
+
+#define V4L2_CID_CAMERA_SMART_AUTO_STATUS	(V4L2_CID_PRIVATE_BASE + 92)
+enum v4l2_smart_auto_status {
+	SMART_AUTO_STATUS_AUTO = 0,
+	SMART_AUTO_STATUS_LANDSCAPE,
+	SMART_AUTO_STATUS_PORTRAIT,
+	SMART_AUTO_STATUS_MACRO,
+	SMART_AUTO_STATUS_NIGHT,
+	SMART_AUTO_STATUS_PORTRAIT_NIGHT,
+	SMART_AUTO_STATUS_BACKLIT,
+	SMART_AUTO_STATUS_PORTRAIT_BACKLIT,
+	SMART_AUTO_STATUS_ANTISHAKE,
+	SMART_AUTO_STATUS_PORTRAIT_ANTISHAKE,
+	SMART_AUTO_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_SET_AUTO_FOCUS		(V4L2_CID_PRIVATE_BASE + 93)
+enum v4l2_auto_focus {
+	AUTO_FOCUS_OFF = 0,
+	AUTO_FOCUS_ON,
+	AUTO_FOCUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_BEAUTY_SHOT		(V4L2_CID_PRIVATE_BASE + 94)
+enum v4l2_beauty_shot {
+	BEAUTY_SHOT_OFF = 0,
+	BEAUTY_SHOT_ON,
+	BEAUTY_SHOT_MAX,
+};
+
+#define V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK	(V4L2_CID_PRIVATE_BASE + 95)
+enum v4l2_ae_awb_lockunlock {
+	AE_UNLOCK_AWB_UNLOCK = 0,
+	AE_LOCK_AWB_UNLOCK,
+	AE_UNLOCK_AWB_LOCK,
+	AE_LOCK_AWB_LOCK,
+	AE_AWB_MAX
+};
+
+#define V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK	(V4L2_CID_PRIVATE_BASE + 96)
+enum v4l2_face_lock {
+	FACE_LOCK_OFF = 0,
+	FACE_LOCK_ON,
+	FIRST_FACE_TRACKING,
+	FACE_LOCK_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJECT_POSITION_X	(V4L2_CID_PRIVATE_BASE + 97)
+#define V4L2_CID_CAMERA_OBJECT_POSITION_Y	(V4L2_CID_PRIVATE_BASE + 98)
+#define V4L2_CID_CAMERA_FOCUS_MODE		(V4L2_CID_PRIVATE_BASE + 99)
+enum v4l2_focusmode {
+	FOCUS_MODE_AUTO = 0,
+	FOCUS_MODE_MACRO,
+	FOCUS_MODE_FACEDETECT,
+	FOCUS_MODE_AUTO_DEFAULT,
+	FOCUS_MODE_MACRO_DEFAULT,
+	FOCUS_MODE_FACEDETECT_DEFAULT,
+	FOCUS_MODE_INFINITY,
+	FOCUS_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJ_TRACKING_STATUS	(V4L2_CID_PRIVATE_BASE + 100)
+enum v4l2_obj_tracking_status {
+	OBJECT_TRACKING_STATUS_BASE,
+	OBJECT_TRACKING_STATUS_PROGRESSING,
+	OBJECT_TRACKING_STATUS_SUCCESS,
+	OBJECT_TRACKING_STATUS_FAIL,
+	OBJECT_TRACKING_STATUS_MISSING,
+	OBJECT_TRACKING_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP	(V4L2_CID_PRIVATE_BASE + 101)
+enum v4l2_ot_start_stop {
+	OT_STOP = 0,
+	OT_START,
+	OT_MAX,
+};
+
+#define V4L2_CID_CAMERA_CAF_START_STOP		(V4L2_CID_PRIVATE_BASE + 102)
+enum v4l2_caf_start_stop {
+	CAF_STOP = 0,
+	CAF_START,
+	CAF_MAX,
+};
+
+#define V4L2_CID_CAMERA_AUTO_FOCUS_RESULT_FIRST	(V4L2_CID_PRIVATE_BASE + 103)
+#define V4L2_CID_CAMERA_AUTO_FOCUS_RESULT_SECOND	(V4L2_CID_PRIVATE_BASE + 120)
+#define V4L2_CID_CAMERA_FINISH_AUTO_FOCUS	(V4L2_CID_PRIVATE_BASE + 121)
+
+#define V4L2_CID_CAMERA_FRAME_RATE		(V4L2_CID_PRIVATE_BASE + 104)
+enum v4l2_frame_rate {
+	FRAME_RATE_AUTO	= 0,
+	FRAME_RATE_7	= 7,
+	FRAME_RATE_15	= 15,
+	FRAME_RATE_30	= 30,
+	FRAME_RATE_60	= 60,
+	FRAME_RATE_120	= 120,
+	FRAME_RATE_MAX
+};
+
+#define V4L2_CID_CAMERA_ANTI_BANDING		(V4L2_CID_PRIVATE_BASE + 105)
+enum v4l2_anti_banding {
+	ANTI_BANDING_AUTO	= 0,
+	ANTI_BANDING_50HZ	= 1,
+	ANTI_BANDING_60HZ	= 2,
+	ANTI_BANDING_OFF	= 3,
+};
+
+#define V4L2_CID_CAMERA_SET_GAMMA		(V4L2_CID_PRIVATE_BASE + 106)
+enum v4l2_gamma_mode {
+	GAMMA_OFF	= 0,
+	GAMMA_ON	= 1,
+	GAMMA_MAX,
+};
+
+#define V4L2_CID_CAMERA_SET_SLOW_AE		(V4L2_CID_PRIVATE_BASE + 107)
+enum v4l2_slow_ae_mode {
+	SLOW_AE_OFF,
+	SLOW_AE_ON,
+	SLOW_AE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BATCH_REFLECTION	(V4L2_CID_PRIVATE_BASE + 108)
+#define V4L2_CID_CAMERA_EXIF_ORIENTATION	(V4L2_CID_PRIVATE_BASE + 109)
+
+#define V4L2_CID_CAMERA_RESET			(V4L2_CID_PRIVATE_BASE + 111)
+#define V4L2_CID_CAMERA_CHECK_DATALINE		(V4L2_CID_PRIVATE_BASE + 112)
+#define V4L2_CID_CAMERA_CHECK_DATALINE_STOP	(V4L2_CID_PRIVATE_BASE + 113)
+#define V4L2_CID_CAMERA_GET_ISO			(V4L2_CID_PRIVATE_BASE + 114)
+#define V4L2_CID_CAMERA_GET_SHT_TIME		(V4L2_CID_PRIVATE_BASE + 115)
+#define V4L2_CID_CAMERA_SENSOR_MODE		(V4L2_CID_PRIVATE_BASE + 116)
+#define V4L2_CID_ESD_INT			(V4L2_CID_PRIVATE_BASE + 117)
+#define V4L2_CID_CAMERA_GET_FLASH_ONOFF		(V4L2_CID_PRIVATE_BASE + 118)
+#define V4L2_CID_CAMERA_RETURN_FOCUS		(V4L2_CID_PRIVATE_BASE + 119)
+
+/* Pixel format FOURCC depth Description */
+/* 12  Y/CbCr 4:2:0 64x32 macroblocks */
+#define V4L2_PIX_FMT_NV12T    v4l2_fourcc('T', 'V', '1', '2')
+
+/*
+ *  * V4L2 extention for digital camera
+ *   */
+/* Strobe flash light */
+enum v4l2_strobe_control {
+	/* turn off the flash light */
+	V4L2_STROBE_CONTROL_OFF		= 0,
+	/* turn on the flash light */
+	V4L2_STROBE_CONTROL_ON		= 1,
+	/* act guide light before splash */
+	V4L2_STROBE_CONTROL_AFGUIDE	= 2,
+	/* charge the flash light */
+	V4L2_STROBE_CONTROL_CHARGE	= 3,
+};
+
+enum v4l2_strobe_conf {
+	V4L2_STROBE_OFF			= 0,	/* Always off */
+	V4L2_STROBE_ON			= 1,	/* Always splashes */
+	/* Auto control presets */
+	V4L2_STROBE_AUTO		= 2,
+	V4L2_STROBE_REDEYE_REDUCTION	= 3,
+	V4L2_STROBE_SLOW_SYNC		= 4,
+	V4L2_STROBE_FRONT_CURTAIN	= 5,
+	V4L2_STROBE_REAR_CURTAIN	= 6,
+	/* Extra manual control presets */
+	/* keep turned on until turning off */
+	V4L2_STROBE_PERMANENT		= 7,
+	V4L2_STROBE_EXTERNAL		= 8,
+};
+
+enum v4l2_strobe_status {
+	V4L2_STROBE_STATUS_OFF		= 0,
+	/* while processing configurations */
+	V4L2_STROBE_STATUS_BUSY		= 1,
+	V4L2_STROBE_STATUS_ERR		= 2,
+	V4L2_STROBE_STATUS_CHARGING	= 3,
+	V4L2_STROBE_STATUS_CHARGED	= 4,
+};
+
+/* capabilities field */
+/* No strobe supported */
+#define V4L2_STROBE_CAP_NONE		0x0000
+/* Always flash off mode */
+#define V4L2_STROBE_CAP_OFF		0x0001
+/* Always use flash light mode */
+#define V4L2_STROBE_CAP_ON		0x0002
+/* Flashlight works automatic */
+#define V4L2_STROBE_CAP_AUTO		0x0004
+/* Red-eye reduction */
+#define V4L2_STROBE_CAP_REDEYE		0x0008
+/* Slow sync */
+#define V4L2_STROBE_CAP_SLOWSYNC	0x0010
+/* Front curtain */
+#define V4L2_STROBE_CAP_FRONT_CURTAIN	0x0020
+/* Rear curtain */
+#define V4L2_STROBE_CAP_REAR_CURTAIN	0x0040
+/* keep turned on until turning off */
+#define V4L2_STROBE_CAP_PERMANENT	0x0080
+/* use external strobe */
+#define V4L2_STROBE_CAP_EXTERNAL	0x0100
+
+/* Set mode and Get status */
+struct v4l2_strobe {
+	/* off/on/charge:0/1/2 */
+	enum v4l2_strobe_control control;
+	/* supported strobe capabilities */
+	__u32 capabilities;
+	enum v4l2_strobe_conf mode;
+	enum v4l2_strobe_status status;	/* read only */
+	/* default is 0 and range of value varies from each models */
+	__u32 flash_ev;
+	__u32 reserved[4];
+};
+
+#define VIDIOC_S_STROBE     _IOWR('V', 83, struct v4l2_strobe)
+#define VIDIOC_G_STROBE     _IOR('V', 84, struct v4l2_strobe)
+
+/* Object recognition and collateral actions */
+enum v4l2_recog_mode {
+	V4L2_RECOGNITION_MODE_OFF	= 0,
+	V4L2_RECOGNITION_MODE_ON	= 1,
+	V4L2_RECOGNITION_MODE_LOCK	= 2,
+};
+
+enum v4l2_recog_action {
+	V4L2_RECOGNITION_ACTION_NONE	= 0,	/* only recognition */
+	V4L2_RECOGNITION_ACTION_BLINK	= 1,	/* Capture on blinking */
+	V4L2_RECOGNITION_ACTION_SMILE	= 2,	/* Capture on smiling */
+};
+
+enum v4l2_recog_pattern {
+	V4L2_RECOG_PATTERN_FACE		= 0,	/* Face */
+	V4L2_RECOG_PATTERN_HUMAN	= 1,	/* Human */
+	V4L2_RECOG_PATTERN_CHAR		= 2,	/* Character */
+};
+
+struct v4l2_recog_rect {
+	enum v4l2_recog_pattern p;	/* detected pattern */
+	struct v4l2_rect o;		/* detected area */
+	__u32 reserved[4];
+};
+
+struct v4l2_recog_data {
+	__u8 detect_cnt;	/* detected object counter */
+	struct v4l2_rect o;	/* detected area */
+	__u32 reserved[4];
+};
+
+struct v4l2_recognition {
+	enum v4l2_recog_mode mode;
+
+	/* Which pattern to detect */
+	enum v4l2_recog_pattern pattern;
+
+	/* How many object to detect */
+	__u8 obj_num;
+
+	/* select detected object */
+	__u32 detect_idx;
+
+	/* read only :Get object coordination */
+	struct v4l2_recog_data data;
+
+	enum v4l2_recog_action action;
+	__u32 reserved[4];
+};
+
+#define VIDIOC_S_RECOGNITION	_IOWR('V', 85, struct v4l2_recognition)
+#define VIDIOC_G_RECOGNITION	_IOR('V', 86, struct v4l2_recognition)
+
+/* We use this struct as the v4l2_streamparm raw_data for
+ * VIDIOC_G_PARM and VIDIOC_S_PARM
+ */
+struct sec_cam_parm {
+	struct v4l2_captureparm capture;
+	int contrast;
+	int effects;
+	int brightness;
+	int flash_mode;
+	int focus_mode;
+	int iso;
+	int metering;
+	int saturation;
+	int scene_mode;
+	int sharpness;
+	int white_balance;
+};
+
+#endif /* __LINUX_VIDEODEV2_SAMSUNG_H */
diff --git a/exynos3/s5pc110/libhwcomposer/Android.mk b/exynos3/s5pc110/libhwcomposer/Android.mk
new file mode 100644
index 0000000..defda3e
--- /dev/null
+++ b/exynos3/s5pc110/libhwcomposer/Android.mk
@@ -0,0 +1,32 @@
+# Copyright (C) 2008 The Android Open Source Project
+#
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+# HAL module implemenation, not prelinked and stored in
+# hw/<COPYPIX_HARDWARE_MODULE_ID>.<ro.product.board>.so
+
+include $(CLEAR_VARS)
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_SHARED_LIBRARIES := liblog libcutils libEGL libGLESv1_CM libhardware libhardware_legacy
+LOCAL_CFLAGS += -DLOG_TAG=\"hwcomposer\"
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/../include
+
+LOCAL_SRC_FILES := SecHWCUtils.cpp SecHWC.cpp
+
+LOCAL_MODULE := hwcomposer.$(TARGET_BOARD_PLATFORM)
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos3/s5pc110/libhwcomposer/SecHWC.cpp b/exynos3/s5pc110/libhwcomposer/SecHWC.cpp
new file mode 100644
index 0000000..dda1108
--- /dev/null
+++ b/exynos3/s5pc110/libhwcomposer/SecHWC.cpp
@@ -0,0 +1,688 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.
+ */
+
+/*
+ *
+ * @author Rama, Meka(v.meka@samsung.com)
+           Sangwoo, Park(sw5771.park@samsung.com)
+           Jamie Oh (jung-min.oh@samsung.com)
+ * @date   2011-07-28
+ *
+ */
+
+#include <sys/resource.h>
+#include <cutils/log.h>
+#include <cutils/atomic.h>
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+#include <hardware_legacy/uevent.h>
+#include "SecHWCUtils.h"
+
+static IMG_gralloc_module_public_t *gpsGrallocModule;
+
+static int hwc_device_open(const struct hw_module_t* module, const char* name,
+                           struct hw_device_t** device);
+
+static struct hw_module_methods_t hwc_module_methods = {
+    open: hwc_device_open
+};
+
+hwc_module_t HAL_MODULE_INFO_SYM = {
+    common: {
+        tag: HARDWARE_MODULE_TAG,
+        module_api_version: HWC_MODULE_API_VERSION_0_1,
+        hal_api_version: HARDWARE_HAL_API_VERSION,
+        id: HWC_HARDWARE_MODULE_ID,
+        name: "Samsung S5PC11X hwcomposer module",
+        author: "SAMSUNG",
+        methods: &hwc_module_methods,
+    }
+};
+
+static void dump_layer(hwc_layer_t const* l) {
+    ALOGD("\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, {%d,%d,%d,%d}, {%d,%d,%d,%d}",
+            l->compositionType, l->flags, l->handle, l->transform, l->blending,
+            l->sourceCrop.left,
+            l->sourceCrop.top,
+            l->sourceCrop.right,
+            l->sourceCrop.bottom,
+            l->displayFrame.left,
+            l->displayFrame.top,
+            l->displayFrame.right,
+            l->displayFrame.bottom);
+}
+
+static int set_src_dst_info(hwc_layer_t *cur,
+                            struct hwc_win_info_t *win,
+                            struct sec_img *src_img,
+                            struct sec_img *dst_img,
+                            struct sec_rect *src_rect,
+                            struct sec_rect *dst_rect,
+                            int win_idx)
+{
+    IMG_native_handle_t *prev_handle = (IMG_native_handle_t *)(cur->handle);
+
+    // set src image
+    src_img->w       = prev_handle->iWidth;
+    src_img->h       = prev_handle->iHeight;
+    src_img->format  = prev_handle->iFormat;
+    src_img->base    = NULL;
+    src_img->offset  = 0;
+    src_img->mem_id  =0;
+
+    src_img->mem_type = HWC_PHYS_MEM_TYPE;
+    src_img->w = (src_img->w + 15) & (~15);
+    src_img->h = (src_img->h + 1) & (~1) ;
+
+    //set src rect
+    src_rect->x = SEC_MAX(cur->sourceCrop.left, 0);
+    src_rect->y = SEC_MAX(cur->sourceCrop.top, 0);
+    src_rect->w = SEC_MAX(cur->sourceCrop.right - cur->sourceCrop.left, 0);
+    src_rect->w = SEC_MIN(src_rect->w, src_img->w - src_rect->x);
+    src_rect->h = SEC_MAX(cur->sourceCrop.bottom - cur->sourceCrop.top, 0);
+    src_rect->h = SEC_MIN(src_rect->h, src_img->h - src_rect->y);
+
+    //set dst image
+    dst_img->w = win->lcd_info.xres;
+    dst_img->h = win->lcd_info.yres;
+
+    switch (win->lcd_info.bits_per_pixel) {
+    case 32:
+        dst_img->format = HAL_PIXEL_FORMAT_RGBX_8888;
+        break;
+    default:
+        dst_img->format = HAL_PIXEL_FORMAT_RGB_565;
+        break;
+    }
+
+    dst_img->base     = win->addr[win->buf_index];
+    dst_img->offset   = 0;
+    dst_img->mem_id   = 0;
+    dst_img->mem_type = HWC_PHYS_MEM_TYPE;
+
+    //set dst rect
+    //fimc dst image will be stored from left top corner
+    dst_rect->x = 0;
+    dst_rect->y = 0;
+    dst_rect->w = win->rect_info.w;
+    dst_rect->h = win->rect_info.h;
+
+    ALOGV("%s::sr_x %d sr_y %d sr_w %d sr_h %d dr_x %d dr_y %d dr_w %d dr_h %d ",
+            __func__, src_rect->x, src_rect->y, src_rect->w, src_rect->h,
+            dst_rect->x, dst_rect->y, dst_rect->w, dst_rect->h);
+
+    return 0;
+}
+
+static int get_hwc_compos_decision(hwc_layer_t* cur)
+{
+    if(cur->flags & HWC_SKIP_LAYER || !cur->handle) {
+        ALOGV("%s::is_skip_layer %d cur->handle %x",
+                __func__, cur->flags & HWC_SKIP_LAYER, (uint32_t)cur->handle);
+        return HWC_FRAMEBUFFER;
+    }
+
+    IMG_native_handle_t *prev_handle = (IMG_native_handle_t *)(cur->handle);
+    int compositionType = HWC_FRAMEBUFFER;
+
+    /* check here....if we have any resolution constraints */
+    if (((cur->sourceCrop.right - cur->sourceCrop.left) < 16) ||
+        ((cur->sourceCrop.bottom - cur->sourceCrop.top) < 8))
+        return compositionType;
+
+    if ((cur->transform == HAL_TRANSFORM_ROT_90) ||
+        (cur->transform == HAL_TRANSFORM_ROT_270)) {
+        if(((cur->displayFrame.right - cur->displayFrame.left) < 4)||
+           ((cur->displayFrame.bottom - cur->displayFrame.top) < 8))
+            return compositionType;
+        } else if (((cur->displayFrame.right - cur->displayFrame.left) < 8) ||
+                   ((cur->displayFrame.bottom - cur->displayFrame.top) < 4))
+         return compositionType;
+
+    if((prev_handle->usage & GRALLOC_USAGE_PHYS_CONTIG) &&
+       (cur->blending == HWC_BLENDING_NONE))
+        compositionType = HWC_OVERLAY;
+    else
+        compositionType = HWC_FRAMEBUFFER;
+
+    ALOGV("%s::compositionType %d bpp %d format %x usage %x",
+            __func__,compositionType, prev_handle->uiBpp, prev_handle->iFormat,
+            prev_handle->usage & GRALLOC_USAGE_PHYS_CONTIG);
+
+    return  compositionType;
+}
+
+static int assign_overlay_window(struct hwc_context_t *ctx,
+                                 hwc_layer_t *cur,
+                                 int win_idx,
+                                 int layer_idx)
+{
+    struct hwc_win_info_t *win;
+    sec_rect rect;
+    int ret = 0;
+
+    if(NUM_OF_WIN <= win_idx)
+        return -1;
+
+    win = &ctx->win[win_idx];
+
+    rect.x = SEC_MAX(cur->displayFrame.left, 0);
+    rect.y = SEC_MAX(cur->displayFrame.top, 0);
+    rect.w = SEC_MIN(cur->displayFrame.right - rect.x, win->lcd_info.xres - rect.x);
+    rect.h = SEC_MIN(cur->displayFrame.bottom - rect.y, win->lcd_info.yres - rect.y);
+    win->set_win_flag = 0;
+
+    if((rect.x != win->rect_info.x) || (rect.y != win->rect_info.y) ||
+       (rect.w != win->rect_info.w) || (rect.h != win->rect_info.h)){
+            win->rect_info.x = rect.x;
+            win->rect_info.y = rect.y;
+            win->rect_info.w = rect.w;
+            win->rect_info.h = rect.h;
+            win->set_win_flag = 1;
+            win->layer_prev_buf = 0;
+    }
+
+    win->layer_index = layer_idx;
+    win->status = HWC_WIN_RESERVED;
+
+    ALOGV("%s:: win_x %d win_y %d win_w %d win_h %d lay_idx %d win_idx %d",
+            __func__, win->rect_info.x, win->rect_info.y, win->rect_info.w,
+            win->rect_info.h, win->layer_index, win_idx );
+
+    return 0;
+}
+
+static void reset_win_rect_info(hwc_win_info_t *win)
+{
+    win->rect_info.x = 0;
+    win->rect_info.y = 0;
+    win->rect_info.w = 0;
+    win->rect_info.h = 0;
+    return;
+}
+
+static int hwc_prepare(hwc_composer_device_t *dev, hwc_layer_list_t* list)
+{
+
+    struct hwc_context_t* ctx = (struct hwc_context_t*)dev;
+    int overlay_win_cnt = 0;
+    int compositionType = 0;
+    int ret;
+
+    //if geometry is not changed, there is no need to do any work here
+    if( !list || (!(list->flags & HWC_GEOMETRY_CHANGED)))
+        return 0;
+
+    //all the windows are free here....
+    for (int i = 0; i < NUM_OF_WIN; i++) {
+        ctx->win[i].status = HWC_WIN_FREE;
+        ctx->win[i].buf_index = 0;
+    }
+    ctx->num_of_hwc_layer = 0;
+    ctx->num_of_fb_layer = 0;
+    ALOGV("%s:: hwc_prepare list->numHwLayers %d", __func__, list->numHwLayers);
+
+    for (int i = 0; i < list->numHwLayers ; i++) {
+        hwc_layer_t* cur = &list->hwLayers[i];
+
+        if (overlay_win_cnt < NUM_OF_WIN) {
+            compositionType = get_hwc_compos_decision(cur);
+
+            if (compositionType == HWC_FRAMEBUFFER) {
+                cur->compositionType = HWC_FRAMEBUFFER;
+                ctx->num_of_fb_layer++;
+            } else {
+                ret = assign_overlay_window(ctx, cur, overlay_win_cnt, i);
+                if (ret != 0) {
+                    cur->compositionType = HWC_FRAMEBUFFER;
+                    ctx->num_of_fb_layer++;
+                    continue;
+                }
+
+                cur->compositionType = HWC_OVERLAY;
+                cur->hints = HWC_HINT_CLEAR_FB;
+                overlay_win_cnt++;
+                ctx->num_of_hwc_layer++;
+            }
+        } else {
+            cur->compositionType = HWC_FRAMEBUFFER;
+            ctx->num_of_fb_layer++;
+        }
+    }
+
+    if(list->numHwLayers != (ctx->num_of_fb_layer + ctx->num_of_hwc_layer))
+        ALOGV("%s:: numHwLayers %d num_of_fb_layer %d num_of_hwc_layer %d ",
+                __func__, list->numHwLayers, ctx->num_of_fb_layer,
+                ctx->num_of_hwc_layer);
+
+    if (overlay_win_cnt < NUM_OF_WIN) {
+        //turn off the free windows
+        for (int i = overlay_win_cnt; i < NUM_OF_WIN; i++) {
+            window_hide(&ctx->win[i]);
+            reset_win_rect_info(&ctx->win[i]);
+        }
+    }
+    return 0;
+}
+
+static int hwc_set(hwc_composer_device_t *dev,
+                   hwc_display_t dpy,
+                   hwc_surface_t sur,
+                   hwc_layer_list_t* list)
+{
+    struct hwc_context_t *ctx = (struct hwc_context_t *)dev;
+    unsigned int phyAddr[MAX_NUM_PLANES];
+    int skipped_window_mask = 0;
+    hwc_layer_t* cur;
+    struct hwc_win_info_t *win;
+    int ret;
+    struct sec_img src_img;
+    struct sec_img dst_img;
+    struct sec_rect src_rect;
+    struct sec_rect dst_rect;
+
+    if (dpy == NULL && sur == NULL && list == NULL) {
+        // release our resources, the screen is turning off
+        // in our case, there is nothing to do.
+        ctx->num_of_fb_layer_prev = 0;
+        return 0;
+    }
+
+    bool need_swap_buffers = ctx->num_of_fb_layer > 0;
+
+    /*
+     * H/W composer documentation states:
+     * There is an implicit layer containing opaque black
+     * pixels behind all the layers in the list.
+     * It is the responsibility of the hwcomposer module to make
+     * sure black pixels are output (or blended from).
+     *
+     * Since we're using a blitter, we need to erase the frame-buffer when
+     * switching to all-overlay mode.
+     *
+     */
+    if (ctx->num_of_hwc_layer &&
+        ctx->num_of_fb_layer==0 && ctx->num_of_fb_layer_prev) {
+        /* we're clearing the screen using GLES here, this is very
+         * hack-ish, ideal we would use the fimc (if it can do it) */
+        glDisable(GL_SCISSOR_TEST);
+        glClearColor(0, 0, 0, 0);
+        glClear(GL_COLOR_BUFFER_BIT);
+        glEnable(GL_SCISSOR_TEST);
+        need_swap_buffers = true;
+    }
+
+    ctx->num_of_fb_layer_prev = ctx->num_of_fb_layer;
+
+    if (need_swap_buffers || !list) {
+        EGLBoolean sucess = eglSwapBuffers((EGLDisplay)dpy, (EGLSurface)sur);
+        if (!sucess) {
+            return HWC_EGL_ERROR;
+        }
+    }
+
+    if (!list) {
+        /* turn off the all windows */
+        for (int i = 0; i < NUM_OF_WIN; i++) {
+            window_hide(&ctx->win[i]);
+            reset_win_rect_info(&ctx->win[i]);
+            ctx->win[i].status = HWC_WIN_FREE;
+        }
+        ctx->num_of_hwc_layer = 0;
+        return 0;
+    }
+
+    if(ctx->num_of_hwc_layer > NUM_OF_WIN)
+        ctx->num_of_hwc_layer = NUM_OF_WIN;
+
+    /* compose hardware layers here */
+    for (uint32_t i = 0; i < ctx->num_of_hwc_layer; i++) {
+        win = &ctx->win[i];
+        if (win->status == HWC_WIN_RESERVED) {
+            cur = &list->hwLayers[win->layer_index];
+
+            if (cur->compositionType == HWC_OVERLAY) {
+
+                ret = gpsGrallocModule->GetPhyAddrs(gpsGrallocModule,
+                        cur->handle, phyAddr);
+                if (ret) {
+                    ALOGE("%s::GetPhyAddrs fail : ret=%d\n", __func__, ret);
+                    skipped_window_mask |= (1 << i);
+                    continue;
+                }
+
+                /* initialize the src & dist context for fimc */
+                set_src_dst_info (cur, win, &src_img, &dst_img, &src_rect,
+                        &dst_rect, i);
+
+                ret = runFimc(ctx, &src_img, &src_rect, &dst_img, &dst_rect,
+                        phyAddr, cur->transform);
+                if (ret < 0){
+                   ALOGE("%s::runFimc fail : ret=%d\n", __func__, ret);
+                   skipped_window_mask |= (1 << i);
+                   continue;
+                }
+
+                if (win->set_win_flag == 1) {
+                    /* turnoff the window and set the window position with new conf... */
+                    if (window_set_pos(win) < 0) {
+                        ALOGE("%s::window_set_pos is failed : %s", __func__,
+                                strerror(errno));
+                        skipped_window_mask |= (1 << i);
+                        continue;
+                    }
+                    win->set_win_flag = 0;
+                }
+
+                /* is the frame didn't change, it needs to be composited
+                 * because something else below it could have changed, however
+                 * it doesn't need to be swapped.
+                 */
+                if (win->layer_prev_buf != (uint32_t)cur->handle) {
+                    win->layer_prev_buf = (uint32_t)cur->handle;
+                    window_pan_display(win);
+                    win->buf_index = (win->buf_index + 1) % NUM_OF_WIN_BUF;
+                }
+
+                if(win->power_state == 0)
+                    window_show(win);
+
+            } else {
+                ALOGE("%s:: error : layer %d compositionType should have been \
+                        HWC_OVERLAY", __func__, win->layer_index);
+                skipped_window_mask |= (1 << i);
+                continue;
+            }
+         } else {
+             ALOGE("%s:: error : window status should have been HWC_WIN_RESERVED \
+                     by now... ", __func__);
+             skipped_window_mask |= (1 << i);
+             continue;
+         }
+    }
+
+    if (skipped_window_mask) {
+        //turn off the free windows
+        for (int i = 0; i < NUM_OF_WIN; i++) {
+            if (skipped_window_mask & (1 << i))
+                window_hide(&ctx->win[i]);
+        }
+    }
+
+    return 0;
+}
+
+static void hwc_registerProcs(struct hwc_composer_device* dev,
+        hwc_procs_t const* procs)
+{
+    struct hwc_context_t* ctx = (struct hwc_context_t*)dev;
+    ctx->procs = const_cast<hwc_procs_t *>(procs);
+}
+
+static int hwc_query(struct hwc_composer_device* dev,
+        int what, int* value)
+{
+    struct hwc_context_t* ctx = (struct hwc_context_t*)dev;
+
+    switch (what) {
+    case HWC_BACKGROUND_LAYER_SUPPORTED:
+        // we don't support the background layer yet
+        value[0] = 0;
+        break;
+    case HWC_VSYNC_PERIOD:
+        // vsync period in nanosecond
+        value[0] = 1000000000.0 / gpsGrallocModule->psFrameBufferDevice->base.fps;
+        break;
+    default:
+        // unsupported query
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int hwc_eventControl(struct hwc_composer_device* dev,
+        int event, int enabled)
+{
+    struct hwc_context_t* ctx = (struct hwc_context_t*)dev;
+
+    switch (event) {
+    case HWC_EVENT_VSYNC:
+        int val = !!enabled;
+        int err = ioctl(ctx->global_lcd_win.fd, S3CFB_SET_VSYNC_INT, &val);
+        if (err < 0)
+            return -errno;
+
+        return 0;
+    }
+
+    return -EINVAL;
+}
+
+void handle_vsync_uevent(hwc_context_t *ctx, const char *buff, int len)
+{
+    uint64_t timestamp = 0;
+    const char *s = buff;
+
+    if(!ctx->procs || !ctx->procs->vsync)
+       return;
+
+    s += strlen(s) + 1;
+
+    while(*s) {
+        if (!strncmp(s, "VSYNC=", strlen("VSYNC=")))
+            timestamp = strtoull(s + strlen("VSYNC="), NULL, 0);
+
+        s += strlen(s) + 1;
+        if (s - buff >= len)
+            break;
+    }
+
+    ctx->procs->vsync(ctx->procs, 0, timestamp);
+}
+
+static void *hwc_vsync_thread(void *data)
+{
+    hwc_context_t *ctx = (hwc_context_t *)(data);
+    char uevent_desc[4096];
+    memset(uevent_desc, 0, sizeof(uevent_desc));
+
+    setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
+
+    uevent_init();
+    while(true) {
+        int len = uevent_next_event(uevent_desc, sizeof(uevent_desc) - 2);
+
+        bool vsync = !strcmp(uevent_desc, "change@/devices/platform/s3cfb");
+        if(vsync)
+            handle_vsync_uevent(ctx, uevent_desc, len);
+    }
+
+    return NULL;
+}
+
+static int hwc_device_close(struct hw_device_t *dev)
+{
+    struct hwc_context_t* ctx = (struct hwc_context_t*)dev;
+    int ret = 0;
+    int i;
+
+    if (ctx) {
+        if (destroyFimc(&ctx->fimc) < 0) {
+            ALOGE("%s::destroyFimc fail", __func__);
+            ret = -1;
+        }
+
+        if (window_close(&ctx->global_lcd_win) < 0) {
+            ALOGE("%s::window_close() fail", __func__);
+            ret = -1;
+        }
+
+        for (i = 0; i < NUM_OF_WIN; i++) {
+            if (window_close(&ctx->win[i]) < 0) {
+                ALOGE("%s::window_close() fail", __func__);
+                ret = -1;
+            }
+        }
+
+        // TODO: stop vsync_thread
+
+        free(ctx);
+    }
+    return ret;
+}
+
+static const struct hwc_methods hwc_methods = {
+    eventControl: hwc_eventControl
+};
+
+static int hwc_device_open(const struct hw_module_t* module, const char* name,
+        struct hw_device_t** device)
+{
+    int status = 0;
+    int err;
+    struct hwc_win_info_t *win;
+
+    if(hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
+                (const hw_module_t**)&gpsGrallocModule))
+        return -EINVAL;
+
+    if(strcmp(gpsGrallocModule->base.common.author, "Imagination Technologies"))
+        return -EINVAL;
+
+    if (strcmp(name, HWC_HARDWARE_COMPOSER))
+        return -EINVAL;
+
+    struct hwc_context_t *dev;
+    dev = (hwc_context_t*)malloc(sizeof(*dev));
+
+    /* initialize our state here */
+    memset(dev, 0, sizeof(*dev));
+
+    /* initialize the procs */
+    dev->device.common.tag = HARDWARE_DEVICE_TAG;
+    dev->device.common.version = HWC_DEVICE_API_VERSION_0_3;
+    dev->device.common.module = const_cast<hw_module_t*>(module);
+    dev->device.common.close = hwc_device_close;
+
+    dev->device.prepare = hwc_prepare;
+    dev->device.set = hwc_set;
+    dev->device.registerProcs = hwc_registerProcs;
+    dev->device.query = hwc_query;
+    dev->device.methods = &hwc_methods;
+
+    *device = &dev->device.common;
+
+    /* initializing */
+    memset(&(dev->fimc), 0, sizeof(s5p_fimc_t));
+    dev->fimc.dev_fd = -1;
+
+    /* open WIN0 & WIN1 here */
+    for (int i = 0; i < NUM_OF_WIN; i++) {
+        if (window_open(&(dev->win[i]), i) < 0) {
+             ALOGE("%s:: Failed to open window %d device ", __func__, i);
+             status = -EINVAL;
+             goto err;
+        }
+    }
+
+    /* open window 2, used to query global LCD info */
+    if (window_open(&dev->global_lcd_win, 2) < 0) {
+        ALOGE("%s:: Failed to open window 2 device ", __func__);
+        status = -EINVAL;
+        goto err;
+    }
+
+    /* get default window config */
+    if (window_get_global_lcd_info(dev) < 0) {
+        ALOGE("%s::window_get_global_lcd_info is failed : %s",
+                __func__, strerror(errno));
+        status = -EINVAL;
+        goto err;
+    }
+
+    dev->lcd_info.yres_virtual = dev->lcd_info.yres * NUM_OF_WIN_BUF;
+
+    /* initialize the window context */
+    for (int i = 0; i < NUM_OF_WIN; i++) {
+        win = &dev->win[i];
+        memcpy(&win->lcd_info, &dev->lcd_info, sizeof(struct fb_var_screeninfo));
+        memcpy(&win->var_info, &dev->lcd_info, sizeof(struct fb_var_screeninfo));
+
+        win->rect_info.x = 0;
+        win->rect_info.y = 0;
+        win->rect_info.w = win->var_info.xres;
+        win->rect_info.h = win->var_info.yres;
+
+        if (window_set_pos(win) < 0) {
+            ALOGE("%s::window_set_pos is failed : %s",
+                    __func__, strerror(errno));
+            status = -EINVAL;
+            goto err;
+        }
+
+        if (window_get_info(win) < 0) {
+            ALOGE("%s::window_get_info is failed : %s",
+                    __func__, strerror(errno));
+            status = -EINVAL;
+            goto err;
+        }
+
+        win->size = win->fix_info.line_length * win->var_info.yres;
+
+        if (!win->fix_info.smem_start){
+            ALOGE("%s:: win-%d failed to get the reserved memory", __func__, i);
+            status = -EINVAL;
+            goto err;
+        }
+
+        for (int j = 0; j < NUM_OF_WIN_BUF; j++) {
+            win->addr[j] = win->fix_info.smem_start + (win->size * j);
+            ALOGI("%s::win-%d add[%d] %x ", __func__, i, j, win->addr[j]);
+        }
+    }
+
+    /* open pp */
+    if (createFimc(&dev->fimc) < 0) {
+        ALOGE("%s::creatFimc() fail", __func__);
+        status = -EINVAL;
+        goto err;
+    }
+
+    err = pthread_create(&dev->vsync_thread, NULL, hwc_vsync_thread, dev);
+    if (err) {
+        ALOGE("%s::pthread_create() failed : %s", __func__, strerror(err));
+        status = -err;
+        goto err;
+    }
+
+    ALOGD("%s:: success\n", __func__);
+
+    return 0;
+
+err:
+    if (destroyFimc(&dev->fimc) < 0)
+        ALOGE("%s::destroyFimc() fail", __func__);
+
+    if (window_close(&dev->global_lcd_win) < 0)
+        ALOGE("%s::window_close() fail", __func__);
+
+    for (int i = 0; i < NUM_OF_WIN; i++) {
+        if (window_close(&dev->win[i]) < 0)
+            ALOGE("%s::window_close() fail", __func__);
+    }
+
+    return status;
+}
diff --git a/exynos3/s5pc110/libhwcomposer/SecHWCUtils.cpp b/exynos3/s5pc110/libhwcomposer/SecHWCUtils.cpp
new file mode 100644
index 0000000..2b3f09f
--- /dev/null
+++ b/exynos3/s5pc110/libhwcomposer/SecHWCUtils.cpp
@@ -0,0 +1,880 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.
+ */
+
+/*
+ *
+ * @author Rama, Meka(v.meka@samsung.com)
+           Sangwoo, Park(sw5771.park@samsung.com)
+           Jamie Oh (jung-min.oh@samsung.com)
+ * @date   2011-07-28
+ *
+ */
+
+#include "SecHWCUtils.h"
+
+int window_open(struct hwc_win_info_t *win, int id)
+{
+    char name[64];
+
+    char const * const device_template = "/dev/graphics/fb%u";
+    /* window & FB maping
+       fb0 -> win-id : 2
+       fb1 -> win-id : 3
+       fb2 -> win-id : 4
+       fb3 -> win-id : 0
+       fb4 -> win_id : 1
+       it is pre assumed that ...win0 or win1 is used here..
+	 */
+    switch (id) {
+    case 0:
+    case 1:
+    case 2:
+        break;
+    default:
+        ALOGE("%s::id(%d) is weird", __func__, id);
+        goto error;
+    }
+
+    snprintf(name, 64, device_template, (id + 3)%5);
+
+    win->fd = open(name, O_RDWR);
+    if (win->fd < 0) {
+		ALOGE("%s::Failed to open window device (%s) : %s",
+				__func__, strerror(errno), device_template);
+        goto error;
+    }
+
+    return 0;
+
+error:
+    if (0 <= win->fd)
+        close(win->fd);
+    win->fd = -1;
+
+    return -1;
+}
+
+int window_close(struct hwc_win_info_t *win)
+{
+    int ret = 0;
+
+    if (0 <= win->fd)
+        ret = close(win->fd);
+    win->fd = -1;
+
+    return ret;
+}
+
+int window_set_pos(struct hwc_win_info_t *win)
+{
+    struct secfb_user_window window;
+
+    /* before changing the screen configuration...powerdown the window */
+    if(window_hide(win) != 0)
+        return -1;
+
+    win->var_info.xres = win->rect_info.w;
+    win->var_info.yres = win->rect_info.h;
+
+    win->var_info.activate &= ~FB_ACTIVATE_MASK;
+    win->var_info.activate |= FB_ACTIVATE_FORCE;
+
+    if (ioctl(win->fd, FBIOPUT_VSCREENINFO, &(win->var_info)) < 0) {
+        ALOGE("%s::FBIOPUT_VSCREENINFO(%d, %d) fail",
+          		__func__, win->rect_info.w, win->rect_info.h);
+        return -1;
+    }
+
+    window.x = win->rect_info.x;
+    window.y = win->rect_info.y;
+
+    if (ioctl(win->fd, SECFB_WIN_POSITION, &window) < 0) {
+        ALOGE("%s::S3CFB_WIN_POSITION(%d, %d) fail",
+            	__func__, window.x, window.y);
+      return -1;
+    }
+
+    return 0;
+}
+
+int window_get_info(struct hwc_win_info_t *win)
+{
+    if (ioctl(win->fd, FBIOGET_FSCREENINFO, &win->fix_info) < 0) {
+        ALOGE("FBIOGET_FSCREENINFO failed : %s", strerror(errno));
+        goto error;
+    }
+
+    return 0;
+
+error:
+    win->fix_info.smem_start = 0;
+
+    return -1;
+}
+
+int window_pan_display(struct hwc_win_info_t *win)
+{
+    struct fb_var_screeninfo *lcd_info = &(win->lcd_info);
+
+    lcd_info->yoffset = lcd_info->yres * win->buf_index;
+
+    if (ioctl(win->fd, FBIOPAN_DISPLAY, lcd_info) < 0) {
+        ALOGE("%s::FBIOPAN_DISPLAY(%d / %d / %d) fail(%s)",
+            	__func__, lcd_info->yres, win->buf_index, lcd_info->yres_virtual,
+            strerror(errno));
+        return -1;
+    }
+    return 0;
+}
+
+int window_show(struct hwc_win_info_t *win)
+{
+    if(win->power_state == 0) {
+        if (ioctl(win->fd, FBIOBLANK, FB_BLANK_UNBLANK) < 0) {
+            ALOGE("%s: FBIOBLANK failed : (%d:%s)", __func__, win->fd,
+                    strerror(errno));
+            return -1;
+        }
+        win->power_state = 1;
+    }
+    return 0;
+}
+
+int window_hide(struct hwc_win_info_t *win)
+{
+    if (win->power_state == 1) {
+        if (ioctl(win->fd, FBIOBLANK, FB_BLANK_POWERDOWN) < 0) {
+            ALOGE("%s::FBIOBLANK failed : (%d:%s)",
+             		__func__, win->fd, strerror(errno));
+            return -1;
+        }
+        win->power_state = 0;
+    }
+    return 0;
+}
+
+int window_get_global_lcd_info(struct hwc_context_t *ctx)
+{
+    struct hwc_win_info_t win;
+    int ret = 0;
+
+    if (ioctl(ctx->global_lcd_win.fd, FBIOGET_VSCREENINFO, &ctx->lcd_info) < 0) {
+        ALOGE("FBIOGET_VSCREENINFO failed : %s", strerror(errno));
+        return -1;
+    }
+
+    if (ctx->lcd_info.xres == 0) {
+        ctx->lcd_info.xres = DEFAULT_LCD_WIDTH;
+        ctx->lcd_info.xres_virtual = DEFAULT_LCD_WIDTH;
+    }
+
+    if (ctx->lcd_info.yres == 0) {
+        ctx->lcd_info.yres = DEFAULT_LCD_HEIGHT;
+        ctx->lcd_info.yres_virtual = DEFAULT_LCD_HEIGHT * NUM_OF_WIN_BUF;
+    }
+
+    if (ctx->lcd_info.bits_per_pixel == 0)
+        ctx->lcd_info.bits_per_pixel = DEFAULT_LCD_BPP;
+
+    return 0;
+}
+
+int fimc_v4l2_set_src(int fd, unsigned int hw_ver, s5p_fimc_img_info *src)
+{
+    struct v4l2_format  fmt;
+    struct v4l2_cropcap cropcap;
+    struct v4l2_crop    crop;
+    struct v4l2_requestbuffers req;
+
+    /*
+     * To set size & format for source image (DMA-INPUT)
+     */
+    fmt.type                = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    fmt.fmt.pix.width       = src->full_width;
+    fmt.fmt.pix.height      = src->full_height;
+    fmt.fmt.pix.pixelformat = src->color_space;
+    fmt.fmt.pix.field       = V4L2_FIELD_NONE;
+
+    if (ioctl (fd, VIDIOC_S_FMT, &fmt) < 0) {
+        ALOGE("VIDIOC_S_FMT failed : errno=%d (%s) : fd=%d", errno,
+                strerror(errno), fd);
+        return -1;
+    }
+
+    /*
+     * crop input size
+     */
+    crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    if (0x50 == hw_ver) {
+        crop.c.left   = src->start_x;
+        crop.c.top    = src->start_y;
+    } else {
+        crop.c.left   = 0;
+        crop.c.top    = 0;
+    }
+    crop.c.width  = src->width;
+    crop.c.height = src->height;
+    if (ioctl(fd, VIDIOC_S_CROP, &crop) < 0) {
+        ALOGE("Error in video VIDIOC_S_CROP (%d, %d, %d, %d)",
+                crop.c.left, crop.c.top, crop.c.width, crop.c.height);
+        return -1;
+    }
+
+    /*
+     * input buffer type
+     */
+    req.count       = 1;
+    req.type        = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    req.memory      = V4L2_MEMORY_USERPTR;
+
+    if (ioctl (fd, VIDIOC_REQBUFS, &req) < 0) {
+        ALOGE("Error in VIDIOC_REQBUFS");
+        return -1;
+    }
+
+    return 0;
+}
+
+int fimc_v4l2_set_dst(int fd,
+                      s5p_fimc_img_info *dst,
+                      int rotation,
+                      int flag_h_flip,
+                      int flag_v_flip,
+                      unsigned int addr)
+{
+    struct v4l2_format      sFormat;
+    struct v4l2_control     vc;
+    struct v4l2_framebuffer fbuf;
+
+    /*
+     * set rotation configuration
+     */
+    vc.id = V4L2_CID_HFLIP;
+    vc.value = flag_h_flip;
+    if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
+        ALOGE("Error in video VIDIOC_S_CTRL - flag_h_flip (%d)", flag_h_flip);
+        return -1;
+    }
+
+    vc.id = V4L2_CID_VFLIP;
+    vc.value = flag_v_flip;
+    if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
+        ALOGE("Error in video VIDIOC_S_CTRL - flag_v_flip (%d)", flag_v_flip);
+        return -1;
+    }
+
+    vc.id = V4L2_CID_ROTATION;
+    vc.value = rotation;
+    if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
+        ALOGE("Error in video VIDIOC_S_CTRL - rotation (%d)", rotation);
+        return -1;
+    }
+
+    /*
+     * set size, format & address for destination image (DMA-OUTPUT)
+     */
+    if (ioctl (fd, VIDIOC_G_FBUF, &fbuf) < 0) {
+        ALOGE("Error in video VIDIOC_G_FBUF");
+        return -1;
+    }
+
+    fbuf.base            = (void *)addr;
+    fbuf.fmt.width       = dst->full_width;
+    fbuf.fmt.height      = dst->full_height;
+    fbuf.fmt.pixelformat = dst->color_space;
+    if (ioctl (fd, VIDIOC_S_FBUF, &fbuf) < 0) {
+        ALOGE("Error in video VIDIOC_S_FBUF 0x%x %d %d %d",
+                (void *)addr, dst->full_width, dst->full_height,
+                dst->color_space);
+        return -1;
+    }
+
+    /*
+     * set destination window
+     */
+    sFormat.type             = V4L2_BUF_TYPE_VIDEO_OVERLAY;
+    sFormat.fmt.win.w.left   = dst->start_x;
+    sFormat.fmt.win.w.top    = dst->start_y;
+    sFormat.fmt.win.w.width  = dst->width;
+    sFormat.fmt.win.w.height = dst->height;
+    if (ioctl(fd, VIDIOC_S_FMT, &sFormat) < 0) {
+        ALOGE("Error in video VIDIOC_S_FMT %d %d %d %d",
+                dst->start_x, dst->start_y, dst->width, dst->height);
+        return -1;
+    }
+
+    return 0;
+}
+
+int fimc_v4l2_stream_on(int fd, enum v4l2_buf_type type)
+{
+    if (ioctl (fd, VIDIOC_STREAMON, &type) < 0) {
+        ALOGE("Error in VIDIOC_STREAMON");
+        return -1;
+    }
+
+    return 0;
+}
+
+int fimc_v4l2_queue(int fd, struct fimc_buf *fimc_buf)
+{
+    struct v4l2_buffer buf;
+
+    buf.type        = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    buf.memory      = V4L2_MEMORY_USERPTR;
+    buf.m.userptr   = (unsigned long)fimc_buf;
+    buf.length      = 0;
+    buf.index       = 0;
+
+    if (ioctl (fd, VIDIOC_QBUF, &buf) < 0) {
+        ALOGE("Error in VIDIOC_QBUF");
+        return -1;
+    }
+
+    return 0;
+}
+
+int fimc_v4l2_dequeue(int fd)
+{
+    struct v4l2_buffer buf;
+
+    buf.type        = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    buf.memory      = V4L2_MEMORY_USERPTR;
+
+    if (ioctl (fd, VIDIOC_DQBUF, &buf) < 0) {
+        ALOGE("Error in VIDIOC_DQBUF");
+        return -1;
+    }
+
+    return buf.index;
+}
+
+int fimc_v4l2_stream_off(int fd)
+{
+    enum v4l2_buf_type type;
+    type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+
+    if (ioctl (fd, VIDIOC_STREAMOFF, &type) < 0) {
+        ALOGE("Error in VIDIOC_STREAMOFF");
+        return -1;
+    }
+
+    return 0;
+}
+
+int fimc_v4l2_clr_buf(int fd)
+{
+    struct v4l2_requestbuffers req;
+
+    req.count   = 0;
+    req.type    = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    req.memory  = V4L2_MEMORY_USERPTR;
+
+    if (ioctl (fd, VIDIOC_REQBUFS, &req) < 0) {
+        ALOGE("Error in VIDIOC_REQBUFS");
+    }
+
+    return 0;
+}
+
+int fimc_handle_oneshot(int fd, struct fimc_buf *fimc_buf)
+{
+    int ret =0;
+
+    if (fimc_v4l2_stream_on(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT) < 0) {
+        ALOGE("Fail : v4l2_stream_on()");
+        return -1;
+    }
+
+    if (fimc_v4l2_queue(fd, fimc_buf) < 0) {
+        ALOGE("Fail : v4l2_queue()");
+        ret = -1;
+        goto stream_off;
+    }
+
+    if (fimc_v4l2_dequeue(fd) < 0) {
+        ALOGE("Fail : v4l2_dequeue()");
+        ret = -1;
+        goto stream_off;
+    }
+
+stream_off:
+    if (fimc_v4l2_stream_off(fd) < 0) {
+        ALOGE("Fail : v4l2_stream_off()");
+        return -1;
+    }
+
+    if (fimc_v4l2_clr_buf(fd) < 0) {
+        ALOGE("Fail : v4l2_clr_buf()");
+        return -1;
+    }
+
+    return ret;
+}
+
+static int get_src_phys_addr(struct hwc_context_t *ctx,
+                             sec_img *src_img,
+                             unsigned int *phyAddr)
+{
+    s5p_fimc_t *fimc = &ctx->fimc;
+
+   if(src_img->mem_type == HWC_PHYS_MEM_TYPE) {
+        switch(src_img->format) {
+        case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+            fimc->params.src.buf_addr_phy_rgb_y = phyAddr[0];
+            fimc->params.src.buf_addr_phy_cb    = phyAddr[1];
+            break;
+        default:
+            ALOGE("%s format error (format=0x%x)", __func__,
+                    src_img->format);
+            return -1;
+        }
+    } else {
+        ALOGE("%s mem_type error (mem_type=%d)", __func__, src_img->mem_type);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int get_dst_phys_addr(struct hwc_context_t *ctx,
+                             sec_img *dst_img)
+{
+    unsigned int dst_phys_addr  = 0;
+
+    if (HWC_PHYS_MEM_TYPE == dst_img->mem_type && 0 != dst_img->base)
+        dst_phys_addr = dst_img->base;
+    else {
+        ALOGE("%s::get_dst_phys_addr fail ", __func__);
+        dst_phys_addr = 0;
+    }
+    return dst_phys_addr;
+}
+
+static inline int rotateValueHAL2PP(unsigned char transform,
+                                    int *flag_h_flip,
+                                    int *flag_v_flip)
+{
+    int rotate_result = 0;
+    int rotate_flag = transform & 0x7;
+
+    switch (rotate_flag) {
+    case HAL_TRANSFORM_ROT_90:
+        rotate_result = 90;
+        break;
+    case HAL_TRANSFORM_ROT_180:
+        rotate_result = 180;
+        break;
+    case HAL_TRANSFORM_ROT_270:
+        rotate_result = 270;
+        break;
+    }
+
+    switch (rotate_flag) {
+    case HAL_TRANSFORM_FLIP_H:
+        *flag_h_flip = 1;
+        *flag_v_flip = 0;
+        break;
+    case HAL_TRANSFORM_FLIP_V:
+        *flag_h_flip = 0;
+        *flag_v_flip = 1;
+        break;
+    default:
+        *flag_h_flip = 0;
+        *flag_v_flip = 0;
+        break;
+    }
+
+    return rotate_result;
+}
+
+static inline int multipleOfN(int number, int N)
+{
+    int result = number;
+    switch (N) {
+    case 1:
+    case 2:
+    case 4:
+    case 8:
+    case 16:
+    case 32:
+    case 64:
+    case 128:
+    case 256:
+        result = (number - (number & (N-1)));
+        break;
+    default:
+        result = number - (number % N);
+        break;
+    }
+    return result;
+}
+
+static inline int widthOfPP(unsigned int ver,
+                            int pp_color_format,
+                            int number)
+{
+    if (0x50 == ver) {
+        switch(pp_color_format) {
+        /* 422 1/2/3 plane */
+        case V4L2_PIX_FMT_YUYV:
+        case V4L2_PIX_FMT_UYVY:
+        case V4L2_PIX_FMT_NV61:
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_YUV422P:
+
+        /* 420 2/3 plane */
+        case V4L2_PIX_FMT_NV21:
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV12T:
+        case V4L2_PIX_FMT_YUV420:
+            return multipleOfN(number, 2);
+
+        default :
+            return number;
+        }
+    } else {
+        switch(pp_color_format) {
+        case V4L2_PIX_FMT_RGB565:
+            return multipleOfN(number, 8);
+
+        case V4L2_PIX_FMT_RGB32:
+            return multipleOfN(number, 4);
+
+        case V4L2_PIX_FMT_YUYV:
+        case V4L2_PIX_FMT_UYVY:
+            return multipleOfN(number, 4);
+
+        case V4L2_PIX_FMT_NV61:
+        case V4L2_PIX_FMT_NV16:
+            return multipleOfN(number, 8);
+
+        case V4L2_PIX_FMT_YUV422P:
+            return multipleOfN(number, 16);
+
+        case V4L2_PIX_FMT_NV21:
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV12T:
+            return multipleOfN(number, 8);
+
+        case V4L2_PIX_FMT_YUV420:
+            return multipleOfN(number, 16);
+
+        default :
+            return number;
+        }
+    }
+    return number;
+}
+
+static inline int heightOfPP(int pp_color_format,
+                             int number)
+{
+    switch(pp_color_format) {
+    case V4L2_PIX_FMT_NV21:
+    case V4L2_PIX_FMT_NV12:
+    case V4L2_PIX_FMT_NV12T:
+    case V4L2_PIX_FMT_YUV420:
+        return multipleOfN(number, 2);
+
+    default :
+        return number;
+    }
+    return number;
+}
+
+static int runcFimcCore(struct hwc_context_t *ctx,
+                        sec_img *src_img,
+                        sec_rect *src_rect,
+                        uint32_t src_color_space,
+                        unsigned int dst_phys_addr,
+                        sec_img *dst_img,
+                        sec_rect *dst_rect,
+                        uint32_t dst_color_space,
+                        int transform)
+{
+    s5p_fimc_t        * fimc = &ctx->fimc;
+    s5p_fimc_params_t * params = &(fimc->params);
+
+    unsigned int    frame_size = 0;
+    struct fimc_buf fimc_src_buf;
+
+    int src_bpp, src_planes;
+    int flag_h_flip = 0;
+    int flag_v_flip = 0;
+    int rotate_value = rotateValueHAL2PP(transform, &flag_h_flip, &flag_v_flip);
+
+    /* set post processor configuration */
+    params->src.full_width  = src_img->w;
+    params->src.full_height = src_img->h;
+    params->src.start_x     = src_rect->x;
+    params->src.start_y     = src_rect->y;
+    params->src.width       = widthOfPP(fimc->hw_ver, src_color_space, src_rect->w);
+    params->src.height      = heightOfPP(src_color_space, src_rect->h);
+    params->src.color_space = src_color_space;
+
+
+    /* check minimum */
+    if (src_rect->w < 16 || src_rect->h < 8) {
+        ALOGE("%s src size is not supported by fimc : f_w=%d f_h=%d x=%d y=%d \
+            	w=%d h=%d (ow=%d oh=%d) format=0x%x", __func__,
+				params->src.full_width, params->src.full_height,
+				params->src.start_x, params->src.start_y, params->src.width,
+				params->src.height, src_rect->w, src_rect->h,
+				params->src.color_space);
+        return -1;
+    }
+
+switch (rotate_value) {
+    case 0:
+        params->dst.full_width  = dst_img->w;
+        params->dst.full_height = dst_img->h;
+
+        params->dst.start_x     = dst_rect->x;
+        params->dst.start_y     = dst_rect->y;
+
+        params->dst.width       =
+            widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
+        params->dst.height      = heightOfPP(dst_color_space, dst_rect->h);
+        break;
+    case 90:
+        params->dst.full_width  = dst_img->h;
+        params->dst.full_height = dst_img->w;
+
+        params->dst.start_x     = dst_rect->y;
+        params->dst.start_y     = dst_img->w - (dst_rect->x + dst_rect->w);
+
+        params->dst.width       =
+            widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->h);
+        params->dst.height      =
+            widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
+
+        if (0x50 > fimc->hw_ver)
+            params->dst.start_y += (dst_rect->w - params->dst.height);
+        break;
+    case 180:
+        params->dst.full_width  = dst_img->w;
+        params->dst.full_height = dst_img->h;
+
+        params->dst.start_x     = dst_img->w - (dst_rect->x + dst_rect->w);
+        params->dst.start_y     = dst_img->h - (dst_rect->y + dst_rect->h);
+
+        params->dst.width       =
+            widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
+        params->dst.height      = heightOfPP(dst_color_space, dst_rect->h);
+        break;
+    case 270:
+        params->dst.full_width  = dst_img->h;
+        params->dst.full_height = dst_img->w;
+
+        params->dst.start_x     = dst_img->h - (dst_rect->y + dst_rect->h);
+        params->dst.start_y     = dst_rect->x;
+
+        params->dst.width       =
+            widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->h);
+        params->dst.height      =
+            widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
+
+        if (0x50 > fimc->hw_ver)
+            params->dst.start_y += (dst_rect->w - params->dst.height);
+        break;
+    }
+
+
+    params->dst.color_space = dst_color_space;
+
+    /* check minimum */
+    if (dst_rect->w  < 8 || dst_rect->h < 4) {
+        ALOGE("%s dst size is not supported by fimc : \
+				f_w=%d f_h=%d x=%d y=%d w=%d h=%d (ow=%d oh=%d) format=0x%x",
+				__func__, params->dst.full_width, params->dst.full_height,
+				params->dst.start_x, params->dst.start_y, params->dst.width,
+				params->dst.height, dst_rect->w, dst_rect->h,
+				params->dst.color_space);
+        return -1;
+    }
+
+    /* check scaling limit
+     * the scaling limie must not be more than MAX_RESIZING_RATIO_LIMIT
+     */
+    if (((src_rect->w > dst_rect->w) &&
+        ((src_rect->w / dst_rect->w) > MAX_RESIZING_RATIO_LIMIT)) ||
+        ((dst_rect->w > src_rect->w) &&
+        ((dst_rect->w / src_rect->w) > MAX_RESIZING_RATIO_LIMIT))) {
+        ALOGE("%s over scaling limit : src.w=%d dst.w=%d (limit=%d)",
+            	__func__, src_rect->w, dst_rect->w, MAX_RESIZING_RATIO_LIMIT);
+        return -1;
+    }
+
+
+    /* set configuration related to destination (DMA-OUT)
+     *   - set input format & size
+     *   - crop input size
+     *   - set input buffer
+     *   - set buffer type (V4L2_MEMORY_USERPTR)
+     */
+    if (fimc_v4l2_set_dst(fimc->dev_fd,
+                          &params->dst,
+                          rotate_value,
+                          flag_h_flip,
+                          flag_v_flip,
+                          dst_phys_addr) < 0) {
+        return -1;
+    }
+
+    /* set configuration related to source (DMA-INPUT)
+     *   - set input format & size
+     *   - crop input size
+     *   - set input buffer
+     *   - set buffer type (V4L2_MEMORY_USERPTR)
+     */
+    if (fimc_v4l2_set_src(fimc->dev_fd, fimc->hw_ver, &params->src) < 0)
+        return -1;
+
+    /* set input dma address (Y/RGB, Cb, Cr) */
+    switch (src_img->format) {
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+        /* for video display zero copy case */
+        fimc_src_buf.base[0] = params->src.buf_addr_phy_rgb_y;
+        fimc_src_buf.base[1] = params->src.buf_addr_phy_cb;
+        break;
+
+    default:
+        /* set source image */
+        fimc_src_buf.base[0] = params->src.buf_addr_phy_rgb_y;
+        break;
+    }
+
+    if (fimc_handle_oneshot(fimc->dev_fd, &fimc_src_buf) < 0) {
+        fimc_v4l2_clr_buf(fimc->dev_fd);
+        return -1;
+    }
+
+    return 0;
+}
+
+int createFimc(s5p_fimc_t *fimc)
+{
+    struct v4l2_capability cap;
+    struct v4l2_format fmt;
+    struct v4l2_control vc;
+
+    #define  PP_DEVICE_DEV_NAME  "/dev/video1"
+
+    /* open device file */
+    if(fimc->dev_fd < 0) {
+        fimc->dev_fd = open(PP_DEVICE_DEV_NAME, O_RDWR);
+
+        if (fimc->dev_fd < 0) {
+            ALOGE("%s::Post processor open error (%d)", __func__, errno);
+            goto err;
+        }
+    }
+
+    /* check capability */
+    if (ioctl(fimc->dev_fd, VIDIOC_QUERYCAP, &cap) < 0) {
+        ALOGE("VIDIOC_QUERYCAP failed");
+        goto err;
+    }
+
+    if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
+        ALOGE("%d has no streaming support", fimc->dev_fd);
+        goto err;
+    }
+
+    if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
+        ALOGE("%d is no video output", fimc->dev_fd);
+        goto err;
+    }
+
+    /*
+     * malloc fimc_outinfo structure
+     */
+    fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    if (ioctl(fimc->dev_fd, VIDIOC_G_FMT, &fmt) < 0) {
+        ALOGE("%s::Error in video VIDIOC_G_FMT", __func__);
+        goto err;
+    }
+
+    vc.id = V4L2_CID_FIMC_VERSION;
+    vc.value = 0;
+
+    if (ioctl(fimc->dev_fd, VIDIOC_G_CTRL, &vc) < 0) {
+        ALOGE("%s::Error in video VIDIOC_G_CTRL", __func__);
+        goto err;
+    }
+    fimc->hw_ver = vc.value;
+
+    return 0;
+
+err:
+    if (0 <= fimc->dev_fd)
+        close(fimc->dev_fd);
+    fimc->dev_fd = -1;
+
+    return -1;
+}
+
+int destroyFimc(s5p_fimc_t *fimc)
+{
+    if (fimc->out_buf.virt_addr != NULL) {
+        fimc->out_buf.virt_addr = NULL;
+        fimc->out_buf.length = 0;
+    }
+
+    /* close */
+    if (0 <= fimc->dev_fd)
+        close(fimc->dev_fd);
+    fimc->dev_fd = -1;
+
+    return 0;
+}
+
+int runFimc(struct hwc_context_t *ctx,
+            struct sec_img *src_img,
+            struct sec_rect *src_rect,
+            struct sec_img *dst_img,
+            struct sec_rect *dst_rect,
+            unsigned int *phyAddr,
+            uint32_t transform)
+{
+    s5p_fimc_t *fimc = &ctx->fimc;
+    unsigned int dst_phys_addr = 0;
+    int32_t      src_color_space;
+    int32_t      dst_color_space;
+
+    /* 1 : source address and size */
+
+    if(0 > get_src_phys_addr(ctx, src_img, phyAddr))
+        return -1;
+
+    /* 2 : destination address and size */
+    if(0 == (dst_phys_addr = get_dst_phys_addr(ctx, dst_img)))
+        return -2;
+
+    /* check whether fimc supports the src format */
+    if (0 > (src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format)))
+        return -3;
+
+   if (0 > (dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format)))
+        return -4;
+
+   if(runcFimcCore(ctx, src_img, src_rect, (uint32_t)src_color_space,
+         dst_phys_addr, dst_img, dst_rect, (uint32_t)dst_color_space, transform) < 0)
+        return -5;
+
+    return 0;
+}
diff --git a/exynos3/s5pc110/libhwcomposer/SecHWCUtils.h b/exynos3/s5pc110/libhwcomposer/SecHWCUtils.h
new file mode 100644
index 0000000..d59c120
--- /dev/null
+++ b/exynos3/s5pc110/libhwcomposer/SecHWCUtils.h
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.
+ */
+
+/*
+ *
+ * @author Rama, Meka(v.meka@samsung.com)
+           Sangwoo, Park(sw5771.park@samsung.com)
+           Jamie, Oh (jung-min.oh@samsung.com)
+ * @date   2011-07-28
+ *
+ */
+
+#ifndef ANDROID_SEC_HWC_UTILS_H_
+#define ANDROID_SEC_HWC_UTILS_H_
+#include <fcntl.h>
+#include <errno.h>
+#include <cutils/log.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include "linux/fb.h"
+#include <linux/videodev.h>
+
+#include <hardware/gralloc.h>
+#include <hardware/hardware.h>
+#include <hardware/hwcomposer.h>
+
+#include "s5p_fimc.h"
+#include "sec_lcd.h"
+#include "sec_format.h"
+#include "sec_utils.h"
+#include "hal_public.h"
+
+#define GRALLOC_USAGE_PHYS_CONTIG GRALLOC_USAGE_PRIVATE_1
+
+#define NUM_OF_WIN          (1)
+#define NUM_OF_WIN_BUF      (3)
+#define NUM_OF_MEM_OBJ      (1)
+#define MAX_NUM_PLANES      (3)
+
+#define MAX_RESIZING_RATIO_LIMIT  (63)
+
+struct sec_rect {
+    uint32_t x;
+    uint32_t y;
+    uint32_t w;
+    uint32_t h;
+};
+
+struct sec_img {
+    uint32_t w;
+    uint32_t h;
+    uint32_t format;
+    uint32_t base;
+    uint32_t offset;
+    int      mem_id;
+    int      mem_type;
+};
+
+inline int SEC_MIN(int x, int y) {
+    return ((x < y) ? x : y);
+}
+
+inline int SEC_MAX(int x, int y) {
+    return ((x > y) ? x : y);
+}
+
+struct hwc_win_info_t {
+    int        fd;
+    int        size;
+    sec_rect   rect_info;
+    uint32_t   addr[NUM_OF_WIN_BUF];
+    int        buf_index;
+    int        power_state;
+    int        blending;
+    int        layer_index;
+    uint32_t   layer_prev_buf;
+    int        set_win_flag;
+    int        status;
+    int        vsync;
+
+    struct fb_fix_screeninfo fix_info;
+    struct fb_var_screeninfo var_info;
+    struct fb_var_screeninfo lcd_info;
+};
+
+enum {
+    HWC_WIN_FREE = 0,
+    HWC_WIN_RESERVED,
+};
+
+enum {
+    HWC_UNKNOWN_MEM_TYPE = 0,
+    HWC_PHYS_MEM_TYPE,
+    HWC_VIRT_MEM_TYPE,
+};
+
+struct hwc_context_t {
+    hwc_composer_device_t     device;
+
+    /* our private state goes below here */
+    struct hwc_win_info_t     win[NUM_OF_WIN];
+    struct hwc_win_info_t     global_lcd_win;
+    struct fb_var_screeninfo  lcd_info;
+    s5p_fimc_t                fimc;
+    hwc_procs_t               *procs;
+    pthread_t                 vsync_thread;
+    unsigned int              num_of_fb_layer;
+    unsigned int              num_of_hwc_layer;
+    unsigned int              num_of_fb_layer_prev;
+};
+
+int window_open(struct hwc_win_info_t *win, int id);
+int window_close(struct hwc_win_info_t *win);
+int window_set_pos(struct hwc_win_info_t *win);
+int window_get_info(struct hwc_win_info_t *win);
+int window_pan_display(struct hwc_win_info_t *win);
+int window_show(struct hwc_win_info_t *win);
+int window_hide(struct hwc_win_info_t *win);
+int window_get_global_lcd_info(struct hwc_context_t *ctx);
+
+int createFimc(s5p_fimc_t *fimc);
+int destroyFimc(s5p_fimc_t *fimc);
+int runFimc(struct hwc_context_t *ctx,
+            struct sec_img *src_img, struct sec_rect *src_rect,
+            struct sec_img *dst_img, struct sec_rect *dst_rect,
+            unsigned int *phyAddr,
+            uint32_t transform);
+#endif /* ANDROID_SEC_HWC_UTILS_H_*/
+
diff --git a/exynos3/s5pc110/libs3cjpeg/Android.mk b/exynos3/s5pc110/libs3cjpeg/Android.mk
new file mode 100644
index 0000000..d515e99
--- /dev/null
+++ b/exynos3/s5pc110/libs3cjpeg/Android.mk
@@ -0,0 +1,31 @@
+# Copyright (C) 2008 The Android Open Source Project
+#
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
+
+LOCAL_SRC_FILES:= \
+	JpegEncoder.cpp
+
+LOCAL_SHARED_LIBRARIES:= liblog
+LOCAL_SHARED_LIBRARIES+= libdl
+
+LOCAL_MODULE:= libs3cjpeg
+
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos3/s5pc110/libs3cjpeg/Exif.h b/exynos3/s5pc110/libs3cjpeg/Exif.h
new file mode 100644
index 0000000..96e11dd
--- /dev/null
+++ b/exynos3/s5pc110/libs3cjpeg/Exif.h
@@ -0,0 +1,233 @@
+/*
+ * Copyright Samsung Electronics Co.,LTD.
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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 ANDROID_HARDWARE_EXIF_H
+#define ANDROID_HARDWARE_EXIF_H
+
+#include <math.h>
+
+#define EXIF_LOG2(x)                    (log((double)(x)) / log(2.0))
+#define APEX_FNUM_TO_APERTURE(x)        ((int)(EXIF_LOG2((double)(x)) * 2 + 0.5))
+#define APEX_EXPOSURE_TO_SHUTTER(x)     ((x) >= 1 ?                                 \
+                                        (int)(-(EXIF_LOG2((double)(x)) + 0.5)) :    \
+                                        (int)(-(EXIF_LOG2((double)(x)) - 0.5)))
+#define APEX_ISO_TO_FILMSENSITIVITY(x)  ((int)(EXIF_LOG2((x) / 3.125) + 0.5))
+
+#define NUM_SIZE                    2
+#define IFD_SIZE                    12
+#define OFFSET_SIZE                 4
+
+#define NUM_0TH_IFD_TIFF            10
+#define NUM_0TH_IFD_EXIF            22
+#define NUM_0TH_IFD_GPS             10
+#define NUM_1TH_IFD_TIFF            9
+
+/* Type */
+#define EXIF_TYPE_BYTE              1
+#define EXIF_TYPE_ASCII             2
+#define EXIF_TYPE_SHORT             3
+#define EXIF_TYPE_LONG              4
+#define EXIF_TYPE_RATIONAL          5
+#define EXIF_TYPE_UNDEFINED         7
+#define EXIF_TYPE_SLONG             9
+#define EXIF_TYPE_SRATIONAL         10
+
+#define EXIF_FILE_SIZE              28800
+
+/* 0th IFD TIFF Tags */
+#define EXIF_TAG_IMAGE_WIDTH                    0x0100
+#define EXIF_TAG_IMAGE_HEIGHT                   0x0101
+#define EXIF_TAG_MAKE                           0x010f
+#define EXIF_TAG_MODEL                          0x0110
+#define EXIF_TAG_ORIENTATION                    0x0112
+#define EXIF_TAG_SOFTWARE                       0x0131
+#define EXIF_TAG_DATE_TIME                      0x0132
+#define EXIF_TAG_YCBCR_POSITIONING              0x0213
+#define EXIF_TAG_EXIF_IFD_POINTER               0x8769
+#define EXIF_TAG_GPS_IFD_POINTER                0x8825
+
+/* 0th IFD Exif Private Tags */
+#define EXIF_TAG_EXPOSURE_TIME                  0x829A
+#define EXIF_TAG_FNUMBER                        0x829D
+#define EXIF_TAG_EXPOSURE_PROGRAM               0x8822
+#define EXIF_TAG_ISO_SPEED_RATING               0x8827
+#define EXIF_TAG_EXIF_VERSION                   0x9000
+#define EXIF_TAG_DATE_TIME_ORG                  0x9003
+#define EXIF_TAG_DATE_TIME_DIGITIZE             0x9004
+#define EXIF_TAG_SHUTTER_SPEED                  0x9201
+#define EXIF_TAG_APERTURE                       0x9202
+#define EXIF_TAG_BRIGHTNESS                     0x9203
+#define EXIF_TAG_EXPOSURE_BIAS                  0x9204
+#define EXIF_TAG_MAX_APERTURE                   0x9205
+#define EXIF_TAG_METERING_MODE                  0x9207
+#define EXIF_TAG_FLASH                          0x9209
+#define EXIF_TAG_FOCAL_LENGTH                   0x920A
+#define EXIF_TAG_USER_COMMENT                   0x9286
+#define EXIF_TAG_COLOR_SPACE                    0xA001
+#define EXIF_TAG_PIXEL_X_DIMENSION              0xA002
+#define EXIF_TAG_PIXEL_Y_DIMENSION              0xA003
+#define EXIF_TAG_EXPOSURE_MODE                  0xA402
+#define EXIF_TAG_WHITE_BALANCE                  0xA403
+#define EXIF_TAG_SCENCE_CAPTURE_TYPE            0xA406
+
+/* 0th IFD GPS Info Tags */
+#define EXIF_TAG_GPS_VERSION_ID                 0x0000
+#define EXIF_TAG_GPS_LATITUDE_REF               0x0001
+#define EXIF_TAG_GPS_LATITUDE                   0x0002
+#define EXIF_TAG_GPS_LONGITUDE_REF              0x0003
+#define EXIF_TAG_GPS_LONGITUDE                  0x0004
+#define EXIF_TAG_GPS_ALTITUDE_REF               0x0005
+#define EXIF_TAG_GPS_ALTITUDE                   0x0006
+#define EXIF_TAG_GPS_TIMESTAMP                  0x0007
+#define EXIF_TAG_GPS_PROCESSING_METHOD          0x001B
+#define EXIF_TAG_GPS_DATESTAMP                  0x001D
+
+/* 1th IFD TIFF Tags */
+#define EXIF_TAG_COMPRESSION_SCHEME             0x0103
+#define EXIF_TAG_X_RESOLUTION                   0x011A
+#define EXIF_TAG_Y_RESOLUTION                   0x011B
+#define EXIF_TAG_RESOLUTION_UNIT                0x0128
+#define EXIF_TAG_JPEG_INTERCHANGE_FORMAT        0x0201
+#define EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN    0x0202
+
+
+typedef enum {
+    EXIF_ORIENTATION_UP     = 1,
+    EXIF_ORIENTATION_90     = 6,
+    EXIF_ORIENTATION_180    = 3,
+    EXIF_ORIENTATION_270    = 8,
+} ExifOrientationType;
+
+typedef enum {
+    EXIF_SCENE_STANDARD,
+    EXIF_SCENE_LANDSCAPE,
+    EXIF_SCENE_PORTRAIT,
+    EXIF_SCENE_NIGHT,
+} CamExifSceneCaptureType;
+
+typedef enum {
+    EXIF_METERING_UNKNOWN,
+    EXIF_METERING_AVERAGE,
+    EXIF_METERING_CENTER,
+    EXIF_METERING_SPOT,
+    EXIF_METERING_MULTISPOT,
+    EXIF_METERING_PATTERN,
+    EXIF_METERING_PARTIAL,
+    EXIF_METERING_OTHER     = 255,
+} CamExifMeteringModeType;
+
+typedef enum {
+    EXIF_EXPOSURE_AUTO,
+    EXIF_EXPOSURE_MANUAL,
+    EXIF_EXPOSURE_AUTO_BRACKET,
+} CamExifExposureModeType;
+
+typedef enum {
+    EXIF_WB_AUTO,
+    EXIF_WB_MANUAL,
+} CamExifWhiteBalanceType;
+
+/* Values */
+#define EXIF_DEF_MAKER          "SAMSUNG"
+#define EXIF_DEF_MODEL          "GT-I9020"
+#define EXIF_DEF_SOFTWARE       "CRESPOJH2"
+#define EXIF_DEF_EXIF_VERSION   "0220"
+#define EXIF_DEF_USERCOMMENTS   "User comments"
+
+#define EXIF_DEF_YCBCR_POSITIONING  1   /* centered */
+#define EXIF_DEF_FNUMBER_NUM        26  /* 2.6 */
+#define EXIF_DEF_FNUMBER_DEN        10
+#define EXIF_DEF_EXPOSURE_PROGRAM   3   /* aperture priority */
+#define EXIF_DEF_FOCAL_LEN_NUM      278 /* 2.78mm */
+#define EXIF_DEF_FOCAL_LEN_DEN      100
+#define EXIF_DEF_FLASH              0   /* O: off, 1: on*/
+#define EXIF_DEF_COLOR_SPACE        1
+#define EXIF_DEF_EXPOSURE_MODE      EXIF_EXPOSURE_AUTO
+#define EXIF_DEF_APEX_DEN           10
+
+#define EXIF_DEF_COMPRESSION        6
+#define EXIF_DEF_RESOLUTION_NUM     72
+#define EXIF_DEF_RESOLUTION_DEN     1
+#define EXIF_DEF_RESOLUTION_UNIT    2   /* inches */
+
+typedef struct {
+    uint32_t num;
+    uint32_t den;
+} rational_t;
+
+typedef struct {
+    int32_t num;
+    int32_t den;
+} srational_t;
+
+typedef struct {
+    bool enableGps;
+    bool enableThumb;
+
+    unsigned char maker[32];
+    unsigned char model[32];
+    unsigned char software[32];
+    unsigned char exif_version[4];
+    unsigned char date_time[20];
+    unsigned char user_comment[150];
+
+    uint32_t width;
+    uint32_t height;
+    uint32_t widthThumb;
+    uint32_t heightThumb;
+
+    uint16_t orientation;
+    uint16_t ycbcr_positioning;
+    uint16_t exposure_program;
+    uint16_t iso_speed_rating;
+    uint16_t metering_mode;
+    uint16_t flash;
+    uint16_t color_space;
+    uint16_t exposure_mode;
+    uint16_t white_balance;
+    uint16_t scene_capture_type;
+
+    rational_t exposure_time;
+    rational_t fnumber;
+    rational_t aperture;
+    rational_t max_aperture;
+    rational_t focal_length;
+
+    srational_t shutter_speed;
+    srational_t brightness;
+    srational_t exposure_bias;
+
+    unsigned char gps_latitude_ref[2];
+    unsigned char gps_longitude_ref[2];
+
+    uint8_t gps_version_id[4];
+    uint8_t gps_altitude_ref;
+
+    rational_t gps_latitude[3];
+    rational_t gps_longitude[3];
+    rational_t gps_altitude;
+    rational_t gps_timestamp[3];
+    unsigned char gps_datestamp[11];
+    unsigned char gps_processing_method[100];
+
+    rational_t x_resolution;
+    rational_t y_resolution;
+    uint16_t resolution_unit;
+    uint16_t compression_scheme;
+} exif_attribute_t;
+
+
+#endif /* ANDROID_HARDWARE_EXIF_H */
diff --git a/exynos3/s5pc110/libs3cjpeg/JpegEncoder.cpp b/exynos3/s5pc110/libs3cjpeg/JpegEncoder.cpp
new file mode 100644
index 0000000..d2b6a6f
--- /dev/null
+++ b/exynos3/s5pc110/libs3cjpeg/JpegEncoder.cpp
@@ -0,0 +1,796 @@
+/*
+ * Copyright Samsung Electronics Co.,LTD.
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.
+ *
+ * JPEG DRIVER MODULE (JpegEncoder.cpp)
+ * Author  : ge.lee       -- initial version
+ * Date    : 03 June 2010
+ * Purpose : This file implements the JPEG encoder APIs as needed by Camera HAL
+ */
+#define LOG_TAG "JpegEncoder"
+#define MAIN_DUMP  0
+#define THUMB_DUMP 0
+
+#include <utils/Log.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+#include "JpegEncoder.h"
+
+static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };
+
+namespace android {
+JpegEncoder::JpegEncoder() : available(false)
+{
+    mArgs.mmapped_addr = (char *)MAP_FAILED;
+    mArgs.enc_param       = NULL;
+    mArgs.thumb_enc_param = NULL;
+
+    mDevFd = open(JPG_DRIVER_NAME, O_RDWR);
+    if (mDevFd < 0) {
+        ALOGE("Failed to open the device");
+        return;
+    }
+
+    mArgs.mmapped_addr = (char *)mmap(0,
+                                      JPG_TOTAL_BUF_SIZE,
+                                      PROT_READ | PROT_WRITE,
+                                      MAP_SHARED,
+                                      mDevFd,
+                                      0);
+
+    if (mArgs.mmapped_addr == MAP_FAILED) {
+        ALOGE("Failed to mmap");
+        return;
+    }
+
+    mArgs.enc_param = new jpg_enc_proc_param;
+    if (mArgs.enc_param == NULL) {
+        ALOGE("Failed to allocate the memory for enc_param");
+        return;
+    }
+    memset(mArgs.enc_param, 0, sizeof(jpg_enc_proc_param));
+
+    mArgs.thumb_enc_param = new jpg_enc_proc_param;
+    if (mArgs.thumb_enc_param == NULL) {
+        ALOGE("Failed to allocate the memory for thumb_enc_param");
+    delete mArgs.enc_param;
+        return;
+    }
+    memset(mArgs.thumb_enc_param, 0, sizeof(jpg_enc_proc_param));
+
+    mArgs.enc_param->sample_mode = JPG_420;
+    mArgs.enc_param->enc_type = JPG_MAIN;
+    mArgs.thumb_enc_param->sample_mode = JPG_420;
+    mArgs.thumb_enc_param->enc_type = JPG_THUMBNAIL;
+
+    available = true;
+}
+
+JpegEncoder::~JpegEncoder()
+{
+    if (mArgs.mmapped_addr != (char*)MAP_FAILED)
+        munmap(mArgs.mmapped_addr, JPG_TOTAL_BUF_SIZE);
+
+    delete mArgs.enc_param;
+
+    delete mArgs.thumb_enc_param;
+
+    if (mDevFd > 0)
+        close(mDevFd);
+}
+
+jpg_return_status JpegEncoder::setConfig(jpeg_conf type, int32_t value)
+{
+    if (!available)
+        return JPG_FAIL;
+
+    jpg_return_status ret = JPG_SUCCESS;
+
+    switch (type) {
+    case JPEG_SET_ENCODE_WIDTH:
+        if (value < 0 || value > MAX_JPG_WIDTH)
+            ret = JPG_FAIL;
+        else
+            mArgs.enc_param->width = value;
+        break;
+
+    case JPEG_SET_ENCODE_HEIGHT:
+        if (value < 0 || value > MAX_JPG_HEIGHT)
+            ret = JPG_FAIL;
+        else
+            mArgs.enc_param->height = value;
+        break;
+
+    case JPEG_SET_ENCODE_QUALITY:
+        if (value < JPG_QUALITY_LEVEL_1 || value > JPG_QUALITY_LEVEL_4)
+            ret = JPG_FAIL;
+        else
+            mArgs.enc_param->quality = (image_quality_type_t)value;
+        break;
+
+    case JPEG_SET_ENCODE_IN_FORMAT:
+        if (value != JPG_MODESEL_YCBCR && value != JPG_MODESEL_RGB) {
+            ret = JPG_FAIL;
+        } else {
+            mArgs.enc_param->in_format = (in_mode_t)value;
+            mArgs.thumb_enc_param->in_format = (in_mode_t)value;
+        }
+        break;
+
+    case JPEG_SET_SAMPING_MODE:
+        if (value != JPG_420 && value != JPG_422) {
+            ret = JPG_FAIL;
+        } else {
+            mArgs.enc_param->sample_mode = (sample_mode_t)value;
+            mArgs.thumb_enc_param->sample_mode = (sample_mode_t)value;
+        }
+        break;
+
+    case JPEG_SET_THUMBNAIL_WIDTH:
+        if (value < 0 || value > MAX_JPG_THUMBNAIL_WIDTH)
+            ret = JPG_FAIL;
+        else
+            mArgs.thumb_enc_param->width = value;
+        break;
+
+    case JPEG_SET_THUMBNAIL_HEIGHT:
+        if (value < 0 || value > MAX_JPG_THUMBNAIL_HEIGHT)
+            ret = JPG_FAIL;
+        else
+            mArgs.thumb_enc_param->height = value;
+        break;
+
+    default:
+        ALOGE("Invalid Config type");
+        ret = ERR_UNKNOWN;
+    }
+
+    if (ret == JPG_FAIL)
+        ALOGE("Invalid value(%d) for %d type", value, type);
+
+    return ret;
+}
+
+void* JpegEncoder::getInBuf(uint64_t size)
+{
+    if (!available)
+        return NULL;
+
+    if (size > JPG_FRAME_BUF_SIZE) {
+        ALOGE("The buffer size requested is too large");
+        return NULL;
+    }
+    mArgs.in_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_FRMBUF, mArgs.mmapped_addr);
+    return (void *)(mArgs.in_buf);
+}
+
+void* JpegEncoder::getOutBuf(uint64_t *size)
+{
+    if (!available)
+        return NULL;
+
+    if (mArgs.enc_param->file_size <= 0) {
+        ALOGE("The buffer requested doesn't have data");
+        return NULL;
+    }
+    mArgs.out_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_STRBUF, mArgs.mmapped_addr);
+    *size = mArgs.enc_param->file_size;
+    return (void *)(mArgs.out_buf);
+}
+
+void* JpegEncoder::getThumbInBuf(uint64_t size)
+{
+    if (!available)
+        return NULL;
+
+    if (size > JPG_FRAME_THUMB_BUF_SIZE) {
+        ALOGE("The buffer size requested is too large");
+        return NULL;
+    }
+    mArgs.in_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_FRMBUF, mArgs.mmapped_addr);
+    return (void *)(mArgs.in_thumb_buf);
+}
+
+void* JpegEncoder::getThumbOutBuf(uint64_t *size)
+{
+    if (!available)
+        return NULL;
+
+    if (mArgs.thumb_enc_param->file_size <= 0) {
+        ALOGE("The buffer requested doesn't have data");
+        return NULL;
+    }
+    mArgs.out_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_STRBUF, mArgs.mmapped_addr);
+    *size = mArgs.thumb_enc_param->file_size;
+    return (void *)(mArgs.out_thumb_buf);
+}
+
+jpg_return_status JpegEncoder::encode(unsigned int *size, exif_attribute_t *exifInfo)
+{
+    if (!available)
+        return JPG_FAIL;
+
+    ALOGD("encode E");
+
+    jpg_return_status ret = JPG_FAIL;
+    unsigned char *exifOut = NULL;
+    jpg_enc_proc_param *param = mArgs.enc_param;
+
+    ret = checkMcu(param->sample_mode, param->width, param->height, false);
+    if (ret != JPG_SUCCESS)
+        return ret;
+
+    param->enc_type = JPG_MAIN;
+    ret = (jpg_return_status)ioctl(mDevFd, IOCTL_JPG_ENCODE, &mArgs);
+    if (ret != JPG_SUCCESS) {
+        ALOGE("Failed to encode main image");
+        return ret;
+    }
+
+    mArgs.out_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_STRBUF, mArgs.mmapped_addr);
+
+    if (exifInfo) {
+        unsigned int thumbLen, exifLen;
+
+        uint_t bufSize = 0;
+        if (exifInfo->enableThumb) {
+            ret = encodeThumbImg(&thumbLen);
+            if (ret != JPG_SUCCESS) {
+                ALOGE("Failed to encode for thumbnail image");
+                bufSize = EXIF_FILE_SIZE;
+                exifInfo->enableThumb = false;
+            } else {
+                bufSize = EXIF_FILE_SIZE + thumbLen;
+            }
+        } else {
+            bufSize = EXIF_FILE_SIZE;
+        }
+
+        if (mArgs.enc_param->file_size + bufSize > JPG_TOTAL_BUF_SIZE)
+            return ret;
+
+        exifOut = new unsigned char[bufSize];
+        if (exifOut == NULL) {
+            ALOGE("Failed to allocate for exifOut");
+            return ret;
+        }
+        memset(exifOut, 0, bufSize);
+
+        ret = makeExif (exifOut, exifInfo, &exifLen);
+        if (ret != JPG_SUCCESS) {
+            ALOGE("Failed to make EXIF");
+            delete[] exifOut;
+            return ret;
+        }
+
+        memmove(&mArgs.out_buf[exifLen + 2], &mArgs.out_buf[2], param->file_size - 2);
+        memcpy(&mArgs.out_buf[2], exifOut, exifLen);
+        param->file_size += exifLen;
+    }
+
+    delete[] exifOut;
+
+    *size = param->file_size;
+
+#if MAIN_DUMP
+    FILE *fout = NULL;
+    char file_name[50] = "/data/main.jpg";
+    fout = fopen(file_name, "wb");
+    if (!fout)
+        perror(&file_name[0]);
+    size_t nwrite = fwrite(mArgs.out_buf, sizeof(char), param->file_size, fout);
+    fclose(fout);
+#endif
+
+    ALOGD("encode X");
+
+    return ret;
+}
+
+jpg_return_status JpegEncoder::encodeThumbImg(unsigned int *size, bool useMain)
+{
+    if (!available)
+        return JPG_FAIL;
+
+    ALOGD("encodeThumbImg E");
+
+    jpg_return_status ret = JPG_FAIL;
+    jpg_enc_proc_param *param = mArgs.thumb_enc_param;
+
+    if (useMain) {
+        mArgs.in_thumb_buf = (char *)getThumbInBuf(param->width*param->height*2);
+        if (mArgs.in_thumb_buf == NULL) {
+            ALOGE("Failed to get the buffer for thumbnail");
+            return JPG_FAIL;
+        }
+
+        ret = (jpg_return_status)scaleDownYuv422(mArgs.in_buf,
+                                                 mArgs.enc_param->width,
+                                                 mArgs.enc_param->height,
+                                                 mArgs.in_thumb_buf,
+                                                 param->width,
+                                                 param->height);
+        if (ret != JPG_SUCCESS)
+            return JPG_FAIL;
+    }
+
+    ret = checkMcu(param->sample_mode, param->width, param->height, true);
+    if (ret != JPG_SUCCESS)
+        return JPG_FAIL;
+
+    mArgs.enc_param->enc_type = JPG_THUMBNAIL;
+    ret = (jpg_return_status)ioctl(mDevFd, IOCTL_JPG_ENCODE, &mArgs);
+    if (ret != JPG_SUCCESS) {
+        ALOGE("Failed to encode for thumbnail");
+        return JPG_FAIL;
+    }
+
+    mArgs.out_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_STRBUF, mArgs.mmapped_addr);
+
+#if THUMB_DUMP
+    FILE *fout = NULL;
+    char file_name[50] = "/data/thumb.jpg";
+    fout = fopen(file_name, "wb");
+    if (!fout)
+        perror(&file_name[0]);
+    size_t nwrite = fwrite(mArgs.out_thumb_buf, sizeof(char), param->file_size, fout);
+    fclose(fout);
+#endif
+
+    ALOGD("encodeThumbImg X");
+
+    return JPG_SUCCESS;
+}
+
+jpg_return_status JpegEncoder::makeExif (unsigned char *exifOut,
+                                        exif_attribute_t *exifInfo,
+                                        unsigned int *size,
+                                        bool useMainbufForThumb)
+{
+    if (!available)
+        return JPG_FAIL;
+
+    ALOGD("makeExif E");
+
+    unsigned char *pCur, *pApp1Start, *pIfdStart, *pGpsIfdPtr, *pNextIfdOffset;
+    unsigned int tmp, LongerTagOffest = 0;
+    pApp1Start = pCur = exifOut;
+
+    //2 Exif Identifier Code & TIFF Header
+    pCur += 4;  // Skip 4 Byte for APP1 marker and length
+    unsigned char ExifIdentifierCode[6] = { 0x45, 0x78, 0x69, 0x66, 0x00, 0x00 };
+    memcpy(pCur, ExifIdentifierCode, 6);
+    pCur += 6;
+
+    /* Byte Order - little endian, Offset of IFD - 0x00000008.H */
+    unsigned char TiffHeader[8] = { 0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00 };
+    memcpy(pCur, TiffHeader, 8);
+    pIfdStart = pCur;
+    pCur += 8;
+
+    //2 0th IFD TIFF Tags
+    if (exifInfo->enableGps)
+        tmp = NUM_0TH_IFD_TIFF;
+    else
+        tmp = NUM_0TH_IFD_TIFF - 1;
+
+    memcpy(pCur, &tmp, NUM_SIZE);
+    pCur += NUM_SIZE;
+
+    LongerTagOffest += 8 + NUM_SIZE + tmp*IFD_SIZE + OFFSET_SIZE;
+
+    writeExifIfd(&pCur, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG,
+                 1, exifInfo->width);
+    writeExifIfd(&pCur, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG,
+                 1, exifInfo->height);
+    writeExifIfd(&pCur, EXIF_TAG_MAKE, EXIF_TYPE_ASCII,
+                 strlen((char *)exifInfo->maker) + 1, exifInfo->maker, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_MODEL, EXIF_TYPE_ASCII,
+                 strlen((char *)exifInfo->model) + 1, exifInfo->model, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT,
+                 1, exifInfo->orientation);
+    writeExifIfd(&pCur, EXIF_TAG_SOFTWARE, EXIF_TYPE_ASCII,
+                 strlen((char *)exifInfo->software) + 1, exifInfo->software, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_DATE_TIME, EXIF_TYPE_ASCII,
+                 20, exifInfo->date_time, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_YCBCR_POSITIONING, EXIF_TYPE_SHORT,
+                 1, exifInfo->ycbcr_positioning);
+    writeExifIfd(&pCur, EXIF_TAG_EXIF_IFD_POINTER, EXIF_TYPE_LONG,
+                 1, LongerTagOffest);
+    if (exifInfo->enableGps) {
+        pGpsIfdPtr = pCur;
+        pCur += IFD_SIZE;   // Skip a ifd size for gps IFD pointer
+    }
+
+    pNextIfdOffset = pCur;  // Skip a offset size for next IFD offset
+    pCur += OFFSET_SIZE;
+
+    //2 0th IFD Exif Private Tags
+    pCur = pIfdStart + LongerTagOffest;
+
+    tmp = NUM_0TH_IFD_EXIF;
+    memcpy(pCur, &tmp , NUM_SIZE);
+    pCur += NUM_SIZE;
+
+    LongerTagOffest += NUM_SIZE + NUM_0TH_IFD_EXIF*IFD_SIZE + OFFSET_SIZE;
+
+    writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_TIME, EXIF_TYPE_RATIONAL,
+                 1, &exifInfo->exposure_time, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_FNUMBER, EXIF_TYPE_RATIONAL,
+                 1, &exifInfo->fnumber, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_PROGRAM, EXIF_TYPE_SHORT,
+                 1, exifInfo->exposure_program);
+    writeExifIfd(&pCur, EXIF_TAG_ISO_SPEED_RATING, EXIF_TYPE_SHORT,
+                 1, exifInfo->iso_speed_rating);
+    writeExifIfd(&pCur, EXIF_TAG_EXIF_VERSION, EXIF_TYPE_UNDEFINED,
+                 4, exifInfo->exif_version);
+    writeExifIfd(&pCur, EXIF_TAG_DATE_TIME_ORG, EXIF_TYPE_ASCII,
+                 20, exifInfo->date_time, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_DATE_TIME_DIGITIZE, EXIF_TYPE_ASCII,
+                 20, exifInfo->date_time, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_SHUTTER_SPEED, EXIF_TYPE_SRATIONAL,
+                 1, (rational_t *)&exifInfo->shutter_speed, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_APERTURE, EXIF_TYPE_RATIONAL,
+                 1, &exifInfo->aperture, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_BRIGHTNESS, EXIF_TYPE_SRATIONAL,
+                 1, (rational_t *)&exifInfo->brightness, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_BIAS, EXIF_TYPE_SRATIONAL,
+                 1, (rational_t *)&exifInfo->exposure_bias, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_MAX_APERTURE, EXIF_TYPE_RATIONAL,
+                 1, &exifInfo->max_aperture, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_METERING_MODE, EXIF_TYPE_SHORT,
+                 1, exifInfo->metering_mode);
+    writeExifIfd(&pCur, EXIF_TAG_FLASH, EXIF_TYPE_SHORT,
+                 1, exifInfo->flash);
+    writeExifIfd(&pCur, EXIF_TAG_FOCAL_LENGTH, EXIF_TYPE_RATIONAL,
+                 1, &exifInfo->focal_length, &LongerTagOffest, pIfdStart);
+    char code[8] = { 0x00, 0x00, 0x00, 0x49, 0x49, 0x43, 0x53, 0x41 };
+    int commentsLen = strlen((char *)exifInfo->user_comment) + 1;
+    memmove(exifInfo->user_comment + sizeof(code), exifInfo->user_comment, commentsLen);
+    memcpy(exifInfo->user_comment, code, sizeof(code));
+    writeExifIfd(&pCur, EXIF_TAG_USER_COMMENT, EXIF_TYPE_UNDEFINED,
+                 commentsLen + sizeof(code), exifInfo->user_comment, &LongerTagOffest, pIfdStart);
+    writeExifIfd(&pCur, EXIF_TAG_COLOR_SPACE, EXIF_TYPE_SHORT,
+                 1, exifInfo->color_space);
+    writeExifIfd(&pCur, EXIF_TAG_PIXEL_X_DIMENSION, EXIF_TYPE_LONG,
+                 1, exifInfo->width);
+    writeExifIfd(&pCur, EXIF_TAG_PIXEL_Y_DIMENSION, EXIF_TYPE_LONG,
+                 1, exifInfo->height);
+    writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_MODE, EXIF_TYPE_LONG,
+                 1, exifInfo->exposure_mode);
+    writeExifIfd(&pCur, EXIF_TAG_WHITE_BALANCE, EXIF_TYPE_LONG,
+                 1, exifInfo->white_balance);
+    writeExifIfd(&pCur, EXIF_TAG_SCENCE_CAPTURE_TYPE, EXIF_TYPE_LONG,
+                 1, exifInfo->scene_capture_type);
+    tmp = 0;
+    memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset
+    pCur += OFFSET_SIZE;
+
+    //2 0th IFD GPS Info Tags
+    if (exifInfo->enableGps) {
+        writeExifIfd(&pGpsIfdPtr, EXIF_TAG_GPS_IFD_POINTER, EXIF_TYPE_LONG,
+                     1, LongerTagOffest); // GPS IFD pointer skipped on 0th IFD
+
+        pCur = pIfdStart + LongerTagOffest;
+
+        if (exifInfo->gps_processing_method[0] == 0) {
+            // don't create GPS_PROCESSING_METHOD tag if there isn't any
+            tmp = NUM_0TH_IFD_GPS - 1;
+        } else {
+            tmp = NUM_0TH_IFD_GPS;
+        }
+        memcpy(pCur, &tmp, NUM_SIZE);
+        pCur += NUM_SIZE;
+
+        LongerTagOffest += NUM_SIZE + tmp*IFD_SIZE + OFFSET_SIZE;
+
+        writeExifIfd(&pCur, EXIF_TAG_GPS_VERSION_ID, EXIF_TYPE_BYTE,
+                     4, exifInfo->gps_version_id);
+        writeExifIfd(&pCur, EXIF_TAG_GPS_LATITUDE_REF, EXIF_TYPE_ASCII,
+                     2, exifInfo->gps_latitude_ref);
+        writeExifIfd(&pCur, EXIF_TAG_GPS_LATITUDE, EXIF_TYPE_RATIONAL,
+                     3, exifInfo->gps_latitude, &LongerTagOffest, pIfdStart);
+        writeExifIfd(&pCur, EXIF_TAG_GPS_LONGITUDE_REF, EXIF_TYPE_ASCII,
+                     2, exifInfo->gps_longitude_ref);
+        writeExifIfd(&pCur, EXIF_TAG_GPS_LONGITUDE, EXIF_TYPE_RATIONAL,
+                     3, exifInfo->gps_longitude, &LongerTagOffest, pIfdStart);
+        writeExifIfd(&pCur, EXIF_TAG_GPS_ALTITUDE_REF, EXIF_TYPE_BYTE,
+                     1, exifInfo->gps_altitude_ref);
+        writeExifIfd(&pCur, EXIF_TAG_GPS_ALTITUDE, EXIF_TYPE_RATIONAL,
+                     1, &exifInfo->gps_altitude, &LongerTagOffest, pIfdStart);
+        writeExifIfd(&pCur, EXIF_TAG_GPS_TIMESTAMP, EXIF_TYPE_RATIONAL,
+                     3, exifInfo->gps_timestamp, &LongerTagOffest, pIfdStart);
+        tmp = strlen((char*)exifInfo->gps_processing_method);
+	if (tmp > 0) {
+            if (tmp > 100) {
+                tmp = 100;
+            }
+            unsigned char tmp_buf[100+sizeof(ExifAsciiPrefix)];
+            memcpy(tmp_buf, ExifAsciiPrefix, sizeof(ExifAsciiPrefix));
+            memcpy(&tmp_buf[sizeof(ExifAsciiPrefix)], exifInfo->gps_processing_method, tmp);
+            writeExifIfd(&pCur, EXIF_TAG_GPS_PROCESSING_METHOD, EXIF_TYPE_UNDEFINED,
+                         tmp+sizeof(ExifAsciiPrefix), tmp_buf, &LongerTagOffest, pIfdStart);
+        }
+        writeExifIfd(&pCur, EXIF_TAG_GPS_DATESTAMP, EXIF_TYPE_ASCII,
+                     11, exifInfo->gps_datestamp, &LongerTagOffest, pIfdStart);
+        tmp = 0;
+        memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset
+        pCur += OFFSET_SIZE;
+    }
+
+    //2 1th IFD TIFF Tags
+    char *thumbBuf;
+    int thumbSize;
+
+    if (useMainbufForThumb) {
+        thumbBuf = mArgs.out_buf;
+        thumbSize = mArgs.enc_param->file_size;
+    } else {
+        thumbBuf = mArgs.out_thumb_buf;
+        thumbSize = mArgs.thumb_enc_param->file_size;
+    }
+
+    if (exifInfo->enableThumb && (thumbBuf != NULL) && (thumbSize > 0)) {
+        tmp = LongerTagOffest;
+        memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE);  // NEXT IFD offset skipped on 0th IFD
+
+        pCur = pIfdStart + LongerTagOffest;
+
+        tmp = NUM_1TH_IFD_TIFF;
+        memcpy(pCur, &tmp, NUM_SIZE);
+        pCur += NUM_SIZE;
+
+        LongerTagOffest += NUM_SIZE + NUM_1TH_IFD_TIFF*IFD_SIZE + OFFSET_SIZE;
+
+        writeExifIfd(&pCur, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG,
+                     1, exifInfo->widthThumb);
+        writeExifIfd(&pCur, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG,
+                     1, exifInfo->heightThumb);
+        writeExifIfd(&pCur, EXIF_TAG_COMPRESSION_SCHEME, EXIF_TYPE_SHORT,
+                     1, exifInfo->compression_scheme);
+        writeExifIfd(&pCur, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT,
+                     1, exifInfo->orientation);
+        writeExifIfd(&pCur, EXIF_TAG_X_RESOLUTION, EXIF_TYPE_RATIONAL,
+                     1, &exifInfo->x_resolution, &LongerTagOffest, pIfdStart);
+        writeExifIfd(&pCur, EXIF_TAG_Y_RESOLUTION, EXIF_TYPE_RATIONAL,
+                     1, &exifInfo->y_resolution, &LongerTagOffest, pIfdStart);
+        writeExifIfd(&pCur, EXIF_TAG_RESOLUTION_UNIT, EXIF_TYPE_SHORT,
+                     1, exifInfo->resolution_unit);
+        writeExifIfd(&pCur, EXIF_TAG_JPEG_INTERCHANGE_FORMAT, EXIF_TYPE_LONG,
+                     1, LongerTagOffest);
+        writeExifIfd(&pCur, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN, EXIF_TYPE_LONG,
+                     1, thumbSize);
+
+        tmp = 0;
+        memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset
+        pCur += OFFSET_SIZE;
+
+        memcpy(pIfdStart + LongerTagOffest,
+               thumbBuf, thumbSize);
+        LongerTagOffest += thumbSize;
+    } else {
+        tmp = 0;
+        memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE);  // NEXT IFD offset skipped on 0th IFD
+    }
+
+    unsigned char App1Marker[2] = { 0xff, 0xe1 };
+    memcpy(pApp1Start, App1Marker, 2);
+    pApp1Start += 2;
+
+    *size = 10 + LongerTagOffest;
+    tmp = *size - 2;    // APP1 Maker isn't counted
+    unsigned char size_mm[2] = {(tmp >> 8) & 0xFF, tmp & 0xFF};
+    memcpy(pApp1Start, size_mm, 2);
+
+    ALOGD("makeExif X");
+
+    return JPG_SUCCESS;
+}
+
+jpg_return_status JpegEncoder::checkMcu(sample_mode_t sampleMode,
+                                        uint32_t width, uint32_t height, bool isThumb)
+{
+    if (!available)
+        return JPG_FAIL;
+
+    uint32_t expectedWidth = width;
+    uint32_t expectedHeight = height;
+
+    switch (sampleMode){
+    case JPG_422:
+        if (width % 16 != 0)
+            expectedWidth = width + 16 - (width % 16);
+        if (height % 8 != 0)
+            expectedHeight = height + 8 - (height % 8);
+        break;
+
+    case JPG_420:
+        if (width % 16 != 0)
+            expectedWidth = width + 16 - (width % 16);
+        if (height % 16 != 0)
+            expectedHeight = height + 16 - (height % 16);
+        break;
+
+    default:
+        ALOGE("Invaild sample mode");
+        return JPG_FAIL;
+    }
+
+    if (expectedWidth == width && expectedHeight == height)
+        return JPG_SUCCESS;
+
+    ALOGW("The image is not matched for MCU");
+
+    uint32_t size = width*height * 2;
+    char *srcBuf, *dstBuf;
+
+    if ((srcBuf = new char[size]) == NULL) {
+        ALOGE("Failed to allocate for srcBuf");
+        return JPG_FAIL;
+    }
+
+    if (!isThumb)
+        dstBuf = mArgs.in_buf;
+    else
+        dstBuf = mArgs.in_thumb_buf;
+
+    memcpy(srcBuf, dstBuf, size);
+    bool ret = pad(srcBuf, width, height, dstBuf, expectedWidth, expectedHeight);
+
+    delete[] srcBuf;
+
+    return JPG_SUCCESS;
+}
+
+bool JpegEncoder::pad(char *srcBuf, uint32_t srcWidth, uint32_t srcHight,
+                        char *dstBuf, uint32_t dstWidth, uint32_t dstHight)
+{
+    if (!available)
+        return false;
+
+    if (srcBuf == NULL || dstBuf == NULL) {
+        ALOGE("srcBuf or dstBuf is NULL");
+        return false;
+    }
+
+    int padW = dstWidth - srcWidth;
+    int padH = dstHight - srcHight;
+
+    if ((int)(dstWidth - srcWidth) < 0 ||
+            (int)(dstHight - srcHight) < 0) {
+        ALOGE("dstSize is smaller than srcSize");
+        return false;
+    }
+    memset(dstBuf, 0, dstWidth*dstHight * 2);
+
+    for (uint32_t i = 0; i < srcHight; i++)
+        memcpy(dstBuf + i * dstWidth * 2, srcBuf + i * srcWidth * 2, srcWidth * 2);
+
+    return true;
+}
+
+bool JpegEncoder::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHight,
+                                  char *dstBuf, uint32_t dstWidth, uint32_t dstHight)
+{
+    if (!available)
+        return false;
+
+    int32_t step_x, step_y;
+    int32_t iXsrc, iXdst;
+    int32_t x, y, src_y_start_pos, dst_pos, src_pos;
+
+    if (dstWidth % 2 != 0 || dstHight % 2 != 0){
+        ALOGE("scale_down_yuv422: invalid width, height for scaling");
+        return false;
+    }
+
+    step_x = srcWidth / dstWidth;
+    step_y = srcHight / dstHight;
+
+    dst_pos = 0;
+    for (uint32_t y = 0; y < dstHight; y++) {
+        src_y_start_pos = (y * step_y * (srcWidth * 2));
+
+        for (uint32_t x = 0; x < dstWidth; x += 2) {
+            src_pos = src_y_start_pos + (x * (step_x * 2));
+
+            dstBuf[dst_pos++] = srcBuf[src_pos    ];
+            dstBuf[dst_pos++] = srcBuf[src_pos + 1];
+            dstBuf[dst_pos++] = srcBuf[src_pos + 2];
+            dstBuf[dst_pos++] = srcBuf[src_pos + 3];
+        }
+    }
+
+    return true;
+}
+
+inline void JpegEncoder::writeExifIfd(unsigned char **pCur,
+                                         unsigned short tag,
+                                         unsigned short type,
+                                         unsigned int count,
+                                         uint32_t value)
+{
+    memcpy(*pCur, &tag, 2);
+    *pCur += 2;
+    memcpy(*pCur, &type, 2);
+    *pCur += 2;
+    memcpy(*pCur, &count, 4);
+    *pCur += 4;
+    memcpy(*pCur, &value, 4);
+    *pCur += 4;
+}
+
+inline void JpegEncoder::writeExifIfd(unsigned char **pCur,
+                                         unsigned short tag,
+                                         unsigned short type,
+                                         unsigned int count,
+                                         unsigned char *pValue)
+{
+    char buf[4] = { 0,};
+
+    memcpy(buf, pValue, count);
+    memcpy(*pCur, &tag, 2);
+    *pCur += 2;
+    memcpy(*pCur, &type, 2);
+    *pCur += 2;
+    memcpy(*pCur, &count, 4);
+    *pCur += 4;
+    memcpy(*pCur, buf, 4);
+    *pCur += 4;
+}
+
+
+inline void JpegEncoder::writeExifIfd(unsigned char **pCur,
+                                         unsigned short tag,
+                                         unsigned short type,
+                                         unsigned int count,
+                                         unsigned char *pValue,
+                                         unsigned int *offset,
+                                         unsigned char *start)
+{
+    memcpy(*pCur, &tag, 2);
+    *pCur += 2;
+    memcpy(*pCur, &type, 2);
+    *pCur += 2;
+    memcpy(*pCur, &count, 4);
+    *pCur += 4;
+    memcpy(*pCur, offset, 4);
+    *pCur += 4;
+    memcpy(start + *offset, pValue, count);
+    *offset += count;
+}
+
+inline void JpegEncoder::writeExifIfd(unsigned char **pCur,
+                                         unsigned short tag,
+                                         unsigned short type,
+                                         unsigned int count,
+                                         rational_t *pValue,
+                                         unsigned int *offset,
+                                         unsigned char *start)
+{
+    memcpy(*pCur, &tag, 2);
+    *pCur += 2;
+    memcpy(*pCur, &type, 2);
+    *pCur += 2;
+    memcpy(*pCur, &count, 4);
+    *pCur += 4;
+    memcpy(*pCur, offset, 4);
+    *pCur += 4;
+    memcpy(start + *offset, pValue, 8 * count);
+    *offset += 8 * count;
+}
+
+};
diff --git a/exynos3/s5pc110/libs3cjpeg/JpegEncoder.h b/exynos3/s5pc110/libs3cjpeg/JpegEncoder.h
new file mode 100644
index 0000000..b95b1b1
--- /dev/null
+++ b/exynos3/s5pc110/libs3cjpeg/JpegEncoder.h
@@ -0,0 +1,240 @@
+/*
+ * Copyright Samsung Electronics Co.,LTD.
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.
+ *
+ * JPEG DRIVER MODULE (JpegEncoder.h)
+ * Author  : ge.lee       -- initial version
+ * Date    : 03 June 2010
+ * Purpose : This file implements the JPEG encoder APIs as needed by Camera HAL
+ */
+#ifndef __JPG_API_H__
+#define __JPG_API_H__
+
+#include <stdint.h>
+#include <sys/ioctl.h>
+
+#include "Exif.h"
+
+namespace android {
+#define MAX_JPG_WIDTH                   800
+#define MAX_JPG_HEIGHT                  480
+#define MAX_JPG_RESOLUTION              (MAX_JPG_WIDTH * MAX_JPG_HEIGHT)
+
+#define MAX_JPG_THUMBNAIL_WIDTH         320
+#define MAX_JPG_THUMBNAIL_HEIGHT        240
+#define MAX_JPG_THUMBNAIL_RESOLUTION    (MAX_JPG_THUMBNAIL_WIDTH *  \
+                                            MAX_JPG_THUMBNAIL_HEIGHT)
+
+#define MAX_RGB_WIDTH                   800
+#define MAX_RGB_HEIGHT                  480
+#define MAX_RGB_RESOLUTION              (MAX_RGB_WIDTH * MAX_RGB_HEIGHT)
+
+/*******************************************************************************/
+/* define JPG & image memory */
+/* memory area is 4k(PAGE_SIZE) aligned because of VirtualCopyEx() */
+#define JPG_STREAM_BUF_SIZE     \
+        (MAX_JPG_RESOLUTION / PAGE_SIZE + 1) * PAGE_SIZE
+#define JPG_STREAM_THUMB_BUF_SIZE   \
+        (MAX_JPG_THUMBNAIL_RESOLUTION / PAGE_SIZE + 1) * PAGE_SIZE
+#define JPG_FRAME_BUF_SIZE  \
+        ((MAX_JPG_RESOLUTION * 3) / PAGE_SIZE + 1) * PAGE_SIZE
+#define JPG_FRAME_THUMB_BUF_SIZE    \
+        ((MAX_JPG_THUMBNAIL_RESOLUTION * 3) / PAGE_SIZE + 1) * PAGE_SIZE
+#define JPG_RGB_BUF_SIZE    \
+        ((MAX_RGB_RESOLUTION * 4) / PAGE_SIZE + 1) * PAGE_SIZE
+
+#define JPG_TOTAL_BUF_SIZE  (JPG_STREAM_BUF_SIZE + \
+                             JPG_STREAM_THUMB_BUF_SIZE + \
+                             JPG_FRAME_BUF_SIZE + \
+                             JPG_FRAME_THUMB_BUF_SIZE + \
+                             JPG_RGB_BUF_SIZE)
+
+#define JPG_MAIN_START      0x00
+#define JPG_THUMB_START     JPG_STREAM_BUF_SIZE
+#define IMG_MAIN_START      (JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE)
+#define IMG_THUMB_START     (IMG_MAIN_START + JPG_FRAME_BUF_SIZE)
+/*******************************************************************************/
+
+#define JPG_DRIVER_NAME     "/dev/s3c-jpg"
+
+#define JPEG_IOCTL_MAGIC                'J'
+#define IOCTL_JPG_DECODE                _IO(JPEG_IOCTL_MAGIC, 1)
+#define IOCTL_JPG_ENCODE                _IO(JPEG_IOCTL_MAGIC, 2)
+#define IOCTL_JPG_GET_STRBUF            _IO(JPEG_IOCTL_MAGIC, 3)
+#define IOCTL_JPG_GET_FRMBUF            _IO(JPEG_IOCTL_MAGIC, 4)
+#define IOCTL_JPG_GET_THUMB_STRBUF      _IO(JPEG_IOCTL_MAGIC, 5)
+#define IOCTL_JPG_GET_THUMB_FRMBUF      _IO(JPEG_IOCTL_MAGIC, 6)
+#define IOCTL_JPG_GET_PHY_FRMBUF        _IO(JPEG_IOCTL_MAGIC, 7)
+#define IOCTL_JPG_GET_PHY_THUMB_FRMBUF  _IO(JPEG_IOCTL_MAGIC, 8)
+
+typedef enum {
+    JPEG_SET_ENCODE_WIDTH,
+    JPEG_SET_ENCODE_HEIGHT,
+    JPEG_SET_ENCODE_QUALITY,
+    JPEG_SET_ENCODE_IN_FORMAT,
+    JPEG_SET_SAMPING_MODE,
+    JPEG_SET_THUMBNAIL_WIDTH,
+    JPEG_SET_THUMBNAIL_HEIGHT
+} jpeg_conf;
+
+typedef enum {
+    JPG_FAIL,
+    JPG_SUCCESS,
+    OK_HD_PARSING,
+    ERR_HD_PARSING,
+    OK_ENC_OR_DEC,
+    ERR_ENC_OR_DEC,
+    ERR_UNKNOWN
+} jpg_return_status;
+
+typedef enum {
+    JPG_RGB16,
+    JPG_YCBYCR,
+    JPG_TYPE_UNKNOWN
+} image_type_t;
+
+typedef enum {
+    JPG_444,
+    JPG_422,
+    JPG_420,
+    JPG_400,
+    RESERVED1,
+    RESERVED2,
+    JPG_411,
+    JPG_SAMPLE_UNKNOWN
+} sample_mode_t;
+
+typedef enum {
+    YCBCR_422,
+    YCBCR_420,
+    YCBCR_SAMPLE_UNKNOWN
+} out_mode_t;
+
+typedef enum {
+    JPG_MODESEL_YCBCR = 1,
+    JPG_MODESEL_RGB,
+    JPG_MODESEL_UNKNOWN
+} in_mode_t;
+
+typedef enum {
+    JPG_MAIN,
+    JPG_THUMBNAIL
+} encode_type_t;
+
+typedef enum {
+    JPG_QUALITY_LEVEL_1,        /* high */
+    JPG_QUALITY_LEVEL_2,
+    JPG_QUALITY_LEVEL_3,
+    JPG_QUALITY_LEVEL_4         /* low */
+} image_quality_type_t;
+
+typedef struct {
+    sample_mode_t   sample_mode;
+    encode_type_t   dec_type;
+    out_mode_t      out_format;
+    uint32_t        width;
+    uint32_t        height;
+    uint32_t        data_size;
+    uint32_t        file_size;
+} jpg_dec_proc_param;
+
+typedef struct {
+    sample_mode_t       sample_mode;
+    encode_type_t       enc_type;
+    in_mode_t           in_format;
+    image_quality_type_t quality;
+    uint32_t            width;
+    uint32_t            height;
+    uint32_t            data_size;
+    uint32_t            file_size;
+    uint32_t            set_framebuf;
+} jpg_enc_proc_param;
+
+typedef struct {
+    char    *in_buf;
+    char    *phy_in_buf;
+    int     in_buf_size;
+    char    *out_buf;
+    char    *phy_out_buf;
+    int     out_buf_size;
+    char    *in_thumb_buf;
+    char    *phy_in_thumb_buf;
+    int     in_thumb_buf_size;
+    char    *out_thumb_buf;
+    char    *phy_out_thumb_buf;
+    int     out_thumb_buf_size;
+    char    *mmapped_addr;
+    jpg_dec_proc_param  *dec_param;
+    jpg_enc_proc_param  *enc_param;
+    jpg_enc_proc_param  *thumb_enc_param;
+} jpg_args;
+
+class JpegEncoder {
+public:
+    JpegEncoder();
+    virtual ~JpegEncoder();
+
+    int openHardware();
+    jpg_return_status setConfig(jpeg_conf type, int32_t value);
+    void *getInBuf(uint64_t size);
+    void *getOutBuf(uint64_t *size);
+    void *getThumbInBuf(uint64_t size);
+    void *getThumbOutBuf(uint64_t *size);
+    jpg_return_status encode(unsigned int *size, exif_attribute_t *exifInfo);
+    jpg_return_status encodeThumbImg(unsigned int *size, bool useMain = true);
+    jpg_return_status makeExif(unsigned char *exifOut,
+                               exif_attribute_t *exifIn,
+                               unsigned int *size,
+                               bool useMainbufForThumb = false);
+
+private:
+    jpg_return_status checkMcu(sample_mode_t sampleMode, uint32_t width, uint32_t height, bool isThumb);
+    bool pad(char *srcBuf, uint32_t srcWidth, uint32_t srcHight,
+             char *dstBuf, uint32_t dstWidth, uint32_t dstHight);
+    bool scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHight,
+                         char *dstBuf, uint32_t dstWidth, uint32_t dstHight);
+
+    inline void writeExifIfd(unsigned char **pCur,
+                                 unsigned short tag,
+                                 unsigned short type,
+                                 unsigned int count,
+                                 uint32_t value);
+    inline void writeExifIfd(unsigned char **pCur,
+                                 unsigned short tag,
+                                 unsigned short type,
+                                 unsigned int count,
+                                 unsigned char *pValue);
+    inline void writeExifIfd(unsigned char **pCur,
+                                 unsigned short tag,
+                                 unsigned short type,
+                                 unsigned int count,
+                                 rational_t *pValue,
+                                 unsigned int *offset,
+                                 unsigned char *start);
+    inline void writeExifIfd(unsigned char **pCur,
+                                 unsigned short tag,
+                                 unsigned short type,
+                                 unsigned int count,
+                                 unsigned char *pValue,
+                                 unsigned int *offset,
+                                 unsigned char *start);
+    int mDevFd;
+    jpg_args mArgs;
+
+    bool available;
+
+};
+};
+#endif /* __JPG_API_H__ */
diff --git a/exynos3/s5pc110/libstagefrighthw/Android.mk b/exynos3/s5pc110/libstagefrighthw/Android.mk
new file mode 100644
index 0000000..2e299a5
--- /dev/null
+++ b/exynos3/s5pc110/libstagefrighthw/Android.mk
@@ -0,0 +1,25 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+    SEC_OMX_Plugin.cpp
+
+LOCAL_CFLAGS += $(PV_CFLAGS_MINUS_VISIBILITY)
+
+LOCAL_C_INCLUDES:= \
+      $(TOP)/frameworks/native/include/media/openmax \
+      $(TOP)/frameworks/native/include/media/hardware \
+      $(LOCAL_PATH)/../include \
+
+LOCAL_SHARED_LIBRARIES :=    \
+        libbinder            \
+        libutils             \
+        libcutils            \
+        libui                \
+        libdl                \
+
+LOCAL_MODULE := libstagefrighthw
+
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_SHARED_LIBRARY)
+
diff --git a/exynos3/s5pc110/libstagefrighthw/SEC_OMX_Plugin.cpp b/exynos3/s5pc110/libstagefrighthw/SEC_OMX_Plugin.cpp
new file mode 100644
index 0000000..8347c63
--- /dev/null
+++ b/exynos3/s5pc110/libstagefrighthw/SEC_OMX_Plugin.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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 "SEC_OMX_Plugin.h"
+
+#include <dlfcn.h>
+
+#include <HardwareAPI.h>
+
+namespace android {
+
+OMXPluginBase *createOMXPlugin() {
+    return new SECOMXPlugin;
+}
+
+SECOMXPlugin::SECOMXPlugin()
+    : mLibHandle(dlopen("libSEC_OMX_Core.so", RTLD_NOW)),
+      mInit(NULL),
+      mDeinit(NULL),
+      mComponentNameEnum(NULL),
+      mGetHandle(NULL),
+      mFreeHandle(NULL),
+      mGetRolesOfComponentHandle(NULL) {
+    if (mLibHandle != NULL) {
+        mInit = (InitFunc)dlsym(mLibHandle, "SEC_OMX_Init");
+        mDeinit = (DeinitFunc)dlsym(mLibHandle, "SEC_OMX_Deinit");
+
+        mComponentNameEnum =
+            (ComponentNameEnumFunc)dlsym(mLibHandle, "SEC_OMX_ComponentNameEnum");
+
+        mGetHandle = (GetHandleFunc)dlsym(mLibHandle, "SEC_OMX_GetHandle");
+        mFreeHandle = (FreeHandleFunc)dlsym(mLibHandle, "SEC_OMX_FreeHandle");
+
+        mGetRolesOfComponentHandle =
+            (GetRolesOfComponentFunc)dlsym(
+                    mLibHandle, "SEC_OMX_GetRolesOfComponent");
+
+        (*mInit)();
+
+    }
+}
+
+SECOMXPlugin::~SECOMXPlugin() {
+    if (mLibHandle != NULL) {
+        (*mDeinit)();
+
+        dlclose(mLibHandle);
+        mLibHandle = NULL;
+    }
+}
+
+OMX_ERRORTYPE SECOMXPlugin::makeComponentInstance(
+        const char *name,
+        const OMX_CALLBACKTYPE *callbacks,
+        OMX_PTR appData,
+        OMX_COMPONENTTYPE **component) {
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mGetHandle)(
+            reinterpret_cast<OMX_HANDLETYPE *>(component),
+            const_cast<char *>(name),
+            appData, const_cast<OMX_CALLBACKTYPE *>(callbacks));
+}
+
+OMX_ERRORTYPE SECOMXPlugin::destroyComponentInstance(
+        OMX_COMPONENTTYPE *component) {
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mFreeHandle)(reinterpret_cast<OMX_HANDLETYPE *>(component));
+}
+
+OMX_ERRORTYPE SECOMXPlugin::enumerateComponents(
+        OMX_STRING name,
+        size_t size,
+        OMX_U32 index) {
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mComponentNameEnum)(name, size, index);
+}
+
+OMX_ERRORTYPE SECOMXPlugin::getRolesOfComponent(
+        const char *name,
+        Vector<String8> *roles) {
+    roles->clear();
+
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    OMX_U32 numRoles;
+    OMX_ERRORTYPE err = (*mGetRolesOfComponentHandle)(
+            const_cast<OMX_STRING>(name), &numRoles, NULL);
+
+    if (err != OMX_ErrorNone) {
+        return err;
+    }
+
+    if (numRoles > 0) {
+        OMX_U8 **array = new OMX_U8 *[numRoles];
+        for (OMX_U32 i = 0; i < numRoles; ++i) {
+            array[i] = new OMX_U8[OMX_MAX_STRINGNAME_SIZE];
+        }
+
+        OMX_U32 numRoles2;
+        err = (*mGetRolesOfComponentHandle)(
+                const_cast<OMX_STRING>(name), &numRoles2, array);
+
+        if (err == OMX_ErrorNone && numRoles != numRoles2) {
+            err = OMX_ErrorUndefined;
+        }
+
+        for (OMX_U32 i = 0; i < numRoles; ++i) {
+            if (err == OMX_ErrorNone) {
+                String8 s((const char *)array[i]);
+                roles->push(s);
+            }
+
+            delete[] array[i];
+            array[i] = NULL;
+        }
+
+        delete[] array;
+        array = NULL;
+    }
+
+    return err;
+}
+
+}  // namespace android
+
diff --git a/exynos3/s5pc110/libstagefrighthw/SEC_OMX_Plugin.h b/exynos3/s5pc110/libstagefrighthw/SEC_OMX_Plugin.h
new file mode 100644
index 0000000..3d640db
--- /dev/null
+++ b/exynos3/s5pc110/libstagefrighthw/SEC_OMX_Plugin.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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 SEC_OMX_PLUGIN
+
+#define SEC_OMX_PLUGIN
+
+#include <OMXPluginBase.h>
+
+namespace android {
+
+struct SECOMXPlugin : public OMXPluginBase {
+    SECOMXPlugin();
+    virtual ~SECOMXPlugin();
+
+    virtual OMX_ERRORTYPE makeComponentInstance(
+            const char *name,
+            const OMX_CALLBACKTYPE *callbacks,
+            OMX_PTR appData,
+            OMX_COMPONENTTYPE **component);
+
+    virtual OMX_ERRORTYPE destroyComponentInstance(
+            OMX_COMPONENTTYPE *component);
+
+    virtual OMX_ERRORTYPE enumerateComponents(
+            OMX_STRING name,
+            size_t size,
+            OMX_U32 index);
+
+    virtual OMX_ERRORTYPE getRolesOfComponent(
+            const char *name,
+            Vector<String8> *roles);
+
+private:
+    void *mLibHandle;
+
+    typedef OMX_ERRORTYPE (*InitFunc)();
+    typedef OMX_ERRORTYPE (*DeinitFunc)();
+    typedef OMX_ERRORTYPE (*ComponentNameEnumFunc)(
+            OMX_STRING, OMX_U32, OMX_U32);
+
+    typedef OMX_ERRORTYPE (*GetHandleFunc)(
+            OMX_HANDLETYPE *, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE *);
+
+    typedef OMX_ERRORTYPE (*FreeHandleFunc)(OMX_HANDLETYPE *);
+
+    typedef OMX_ERRORTYPE (*GetRolesOfComponentFunc)(
+            OMX_STRING, OMX_U32 *, OMX_U8 **);
+
+    InitFunc mInit;
+    DeinitFunc mDeinit;
+    ComponentNameEnumFunc mComponentNameEnum;
+    GetHandleFunc mGetHandle;
+    FreeHandleFunc mFreeHandle;
+    GetRolesOfComponentFunc mGetRolesOfComponentHandle;
+
+    SECOMXPlugin(const SECOMXPlugin &);
+    SECOMXPlugin &operator=(const SECOMXPlugin &);
+};
+
+}  // namespace android
+
+#endif  // SEC_OMX_PLUGIN
diff --git a/exynos3/s5pc110/sec_mm/Android.mk b/exynos3/s5pc110/sec_mm/Android.mk
new file mode 100644
index 0000000..16298da
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/Android.mk
new file mode 100644
index 0000000..cbae428
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/Android.mk
@@ -0,0 +1,22 @@
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+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/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/Android.mk
+include $(SEC_OMX_COMPONENT)/video/enc/h264enc/Android.mk
+include $(SEC_OMX_COMPONENT)/video/enc/mpeg4enc/Android.mk
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/Android.mk
new file mode 100644
index 0000000..3c163a4
--- /dev/null
+++ b/exynos3/s5pc110/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
+include   $(SEC_CODECS)/video/mfc_c110/csc/Android.mk
\ No newline at end of file
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/Android.mk
new file mode 100644
index 0000000..4106a68
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/Android.mk
@@ -0,0 +1,36 @@
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+ifeq ($(ARCH_ARM_HAVE_NEON),true)
+LOCAL_SRC_FILES := \
+	csc_yuv420_nv12t_y_neon.s \
+	csc_yuv420_nv12t_uv_neon.s \
+	csc_nv12t_yuv420_y_neon.s \
+	csc_nv12t_yuv420_uv_neon.s \
+	csc_interleave_memcpy.s \
+	csc_deinterleave_memcpy.s
+
+else
+LOCAL_SRC_FILES := \
+	color_space_convertor.c
+
+endif
+
+LOCAL_MODULE := libseccsc
+
+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/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/color_space_convertor.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/color_space_convertor.c
new file mode 100644
index 0000000..c1ac638
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/color_space_convertor.c
@@ -0,0 +1,1092 @@
+/*
+ *
+ * Copyright 2011 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    color_space_convertor.c
+ * @brief   SEC_OMX specific define
+ * @author  ShinWon Lee (shinwon.lee@samsung.com)
+ * @version 1.0
+ * @history
+ *   2011.7.01 : Create
+ */
+
+#include "stdlib.h"
+#include "color_space_convertor.h"
+
+#define TILED_SIZE  64*32
+
+/*
+ * De-interleaves src to dest1, dest2
+ *
+ * @param dest1
+ *   Address of de-interleaved data[out]
+ *
+ * @param dest2
+ *   Address of de-interleaved data[out]
+ *
+ * @param src
+ *   Address of interleaved data[in]
+ *
+ * @param src_size
+ *   Size of interleaved data[in]
+ */
+void csc_deinterleave_memcpy(char *dest1, char *dest2, char *src, int src_size)
+{
+    int i = 0;
+    for(i=0; i<src_size/2; i++) {
+        dest1[i] = src[i*2];
+        dest2[i] = src[i*2+1];
+    }
+}
+
+/*
+ * Interleaves src1, src2 to dest
+ *
+ * @param dest
+ *   Address of interleaved data[out]
+ *
+ * @param src1
+ *   Address of de-interleaved data[in]
+ *
+ * @param src2
+ *   Address of de-interleaved data[in]
+ *
+ * @param src_size
+ *   Size of de-interleaved data[in]
+ */
+void csc_interleave_memcpy(char *dest, char *src1, char *src2, int src_size)
+{
+    int i = 0;
+    for(i=0; i<src_size; i++) {
+        dest[i*2] = src1[i];
+        dest[i*2+1] = src2[i];
+    }
+}
+
+/*
+ * Converts tiled data to linear.
+ * 1. Y of NV12T to Y of YUV420P
+ * 2. Y of NV12T to Y of YUV420S
+ * 3. UV of NV12T to UV of YUV420S
+ *
+ * @param yuv420_dest
+ *   Y or UV plane address of YUV420[out]
+ *
+ * @param nv12t_src
+ *   Y or UV plane address of NV12T[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_height
+ *   Y: Height of YUV420, UV: Height/2 of YUV420[in]
+ */
+void csc_tiled_to_linear(char *yuv420_dest, char *nv12t_src, int yuv420_width, int yuv420_height)
+{
+    unsigned int i, j;
+    unsigned int tiled_x_index = 0, tiled_y_index = 0;
+    unsigned int aligned_x_size = 0;
+    unsigned int tiled_offset = 0, tiled_offset1 = 0, tiled_offset2 = 0, tiled_offset3 = 0;
+    unsigned int temp1 = 0, temp2 = 0;
+
+    if (yuv420_width >= 1024) {
+        for (i=0; i<yuv420_height; i=i+1) {
+            tiled_offset = 0;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+2;
+                tiled_offset = tiled_offset<<11;
+                tiled_offset1 = tiled_offset+2048*1;
+                tiled_offset2 = tiled_offset+2048*2;
+                tiled_offset3 = tiled_offset+2048*3;
+                temp2 = 8;
+            } else {
+                temp2 = ((yuv420_height+31)>>5)<<5;
+                /* even fomula: x_block_num*y */
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_y_index*(temp1>>6);
+                tiled_offset = tiled_offset<<11;
+                if ((i+32)<temp2) {
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*6;
+                    tiled_offset3 = tiled_offset+2048*7;
+                    temp2 = 8;
+                } else {
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*2;
+                    tiled_offset3 = tiled_offset+2048*3;
+                    temp2 = 4;
+                }
+            }
+            temp1 = i&0x1F;
+            memcpy(yuv420_dest+yuv420_width*(i), nv12t_src+tiled_offset+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*1, nv12t_src+tiled_offset1+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*2, nv12t_src+tiled_offset2+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*3, nv12t_src+tiled_offset3+64*(temp1), 64);
+
+            tiled_offset = tiled_offset+temp2*2048;
+            tiled_offset1 = tiled_offset1+temp2*2048;
+            tiled_offset2 = tiled_offset2+temp2*2048;
+            tiled_offset3 = tiled_offset3+temp2*2048;
+            memcpy(yuv420_dest+yuv420_width*(i)+64*4, nv12t_src+tiled_offset+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*5, nv12t_src+tiled_offset1+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*6, nv12t_src+tiled_offset2+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*7, nv12t_src+tiled_offset3+64*(temp1), 64);
+
+            tiled_offset = tiled_offset+temp2*2048;
+            tiled_offset1 = tiled_offset1+temp2*2048;
+            tiled_offset2 = tiled_offset2+temp2*2048;
+            tiled_offset3 = tiled_offset3+temp2*2048;
+            memcpy(yuv420_dest+yuv420_width*(i)+64*8, nv12t_src+tiled_offset+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*9, nv12t_src+tiled_offset1+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*10, nv12t_src+tiled_offset2+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*11, nv12t_src+tiled_offset3+64*(temp1), 64);
+
+            tiled_offset = tiled_offset+temp2*2048;
+            tiled_offset1 = tiled_offset1+temp2*2048;
+            tiled_offset2 = tiled_offset2+temp2*2048;
+            tiled_offset3 = tiled_offset3+temp2*2048;
+            memcpy(yuv420_dest+yuv420_width*(i)+64*12, nv12t_src+tiled_offset+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*13, nv12t_src+tiled_offset1+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*14, nv12t_src+tiled_offset2+64*(temp1), 64);
+            memcpy(yuv420_dest+yuv420_width*(i)+64*15, nv12t_src+tiled_offset3+64*(temp1), 64);
+        }
+        aligned_x_size = 1024;
+    }
+
+    if ((yuv420_width-aligned_x_size) >= 512) {
+        for (i=0; i<yuv420_height; i=i+1) {
+            tiled_offset = 0;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+2;
+                temp1 = aligned_x_size>>5;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+                tiled_offset1 = tiled_offset+2048*1;
+                tiled_offset2 = tiled_offset+2048*2;
+                tiled_offset3 = tiled_offset+2048*3;
+                temp2 = 8;
+            } else {
+                temp2 = ((yuv420_height+31)>>5)<<5;
+                /* even fomula: x_block_num*y */
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_y_index*(temp1>>6);
+                tiled_offset = tiled_offset<<11;
+                if ((i+32)<temp2) {
+                    temp1 = aligned_x_size>>5;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*6;
+                    tiled_offset3 = tiled_offset+2048*7;
+                    temp2 = 8;
+                } else {
+                    temp1 = aligned_x_size>>6;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*2;
+                    tiled_offset3 = tiled_offset+2048*3;
+                    temp2 = 4;
+                }
+            }
+            temp1 = i&0x1F;
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i), nv12t_src+tiled_offset+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*1, nv12t_src+tiled_offset1+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*2, nv12t_src+tiled_offset2+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*3, nv12t_src+tiled_offset3+64*(temp1), 64);
+
+            tiled_offset = tiled_offset+temp2*2048;
+            tiled_offset1 = tiled_offset1+temp2*2048;
+            tiled_offset2 = tiled_offset2+temp2*2048;
+            tiled_offset3 = tiled_offset3+temp2*2048;
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*4, nv12t_src+tiled_offset+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*5, nv12t_src+tiled_offset1+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*6, nv12t_src+tiled_offset2+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*7, nv12t_src+tiled_offset3+64*(temp1), 64);
+        }
+        aligned_x_size = aligned_x_size+512;
+    }
+
+    if ((yuv420_width-aligned_x_size) >= 256) {
+        for (i=0; i<yuv420_height; i=i+1) {
+            tiled_offset = 0;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+2;
+                temp1 = aligned_x_size>>5;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+                tiled_offset1 = tiled_offset+2048*1;
+                tiled_offset2 = tiled_offset+2048*2;
+                tiled_offset3 = tiled_offset+2048*3;
+            } else {
+                temp2 = ((yuv420_height+31)>>5)<<5;
+                /* even fomula: x_block_num*y */
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_y_index*(temp1>>6);
+                tiled_offset = tiled_offset<<11;
+                if ((i+32)<temp2) {
+                    temp1 = aligned_x_size>>5;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*6;
+                    tiled_offset3 = tiled_offset+2048*7;
+                } else {
+                    temp1 = aligned_x_size>>6;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*2;
+                    tiled_offset3 = tiled_offset+2048*3;
+                }
+            }
+            temp1 = i&0x1F;
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i), nv12t_src+tiled_offset+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*1, nv12t_src+tiled_offset1+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*2, nv12t_src+tiled_offset2+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64*3, nv12t_src+tiled_offset3+64*(temp1), 64);
+        }
+        aligned_x_size = aligned_x_size+256;
+    }
+
+    if ((yuv420_width-aligned_x_size) >= 128) {
+        for (i=0; i<yuv420_height; i=i+2) {
+            tiled_offset = 0;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+2;
+                temp1 = aligned_x_size>>5;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+                tiled_offset1 = tiled_offset+2048*1;
+            } else {
+                temp2 = ((yuv420_height+31)>>5)<<5;
+                /* even fomula: x_block_num*y */
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_y_index*(temp1>>6);
+                tiled_offset = tiled_offset<<11;
+                if ((i+32)<temp2) {
+                    temp1 = aligned_x_size>>5;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                } else {
+                    temp1 = aligned_x_size>>6;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                }
+            }
+            temp1 = i&0x1F;
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i), nv12t_src+tiled_offset+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i)+64, nv12t_src+tiled_offset1+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i+1), nv12t_src+tiled_offset+64*(temp1+1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i+1)+64, nv12t_src+tiled_offset1+64*(temp1+1), 64);
+        }
+        aligned_x_size = aligned_x_size+128;
+    }
+
+    if ((yuv420_width-aligned_x_size) >= 64) {
+        for (i=0; i<yuv420_height; i=i+4) {
+            tiled_offset = 0;
+            tiled_x_index = aligned_x_size>>6;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+tiled_x_index;
+                tiled_offset = tiled_offset+2;
+                temp1 = (tiled_x_index>>2)<<2;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+            } else {
+                temp2 = ((yuv420_height+31)>>5)<<5;
+                if ((i+32)<temp2) {
+                    /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                    temp1 = tiled_x_index+2;
+                    temp1 = (temp1>>2)<<2;
+                    tiled_offset = tiled_x_index+temp1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    /* even2 fomula: x+x_block_num*y */
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset<<11;
+                }
+            }
+
+            temp1 = i&0x1F;
+            temp2 = aligned_x_size&0x3F;
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i), nv12t_src+tiled_offset+temp2+64*(temp1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i+1), nv12t_src+tiled_offset+temp2+64*(temp1+1), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i+2), nv12t_src+tiled_offset+temp2+64*(temp1+2), 64);
+            memcpy(yuv420_dest+aligned_x_size+yuv420_width*(i+3), nv12t_src+tiled_offset+temp2+64*(temp1+3), 64);
+        }
+        aligned_x_size = aligned_x_size+64;
+    }
+
+    if (yuv420_width != aligned_x_size) {
+        for (i=0; i<yuv420_height; i=i+4) {
+            for (j=aligned_x_size; j<yuv420_width; j=j+4) {
+                tiled_offset = 0;
+                tiled_x_index = j>>6;
+                tiled_y_index = i>>5;
+                if (tiled_y_index & 0x1) {
+                    /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                    tiled_offset = tiled_y_index-1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset+2;
+                    temp1 = (tiled_x_index>>2)<<2;
+                    tiled_offset = tiled_offset+temp1;
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    temp2 = ((yuv420_height+31)>>5)<<5;
+                    if ((i+32)<temp2) {
+                        /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                        temp1 = tiled_x_index+2;
+                        temp1 = (temp1>>2)<<2;
+                        tiled_offset = tiled_x_index+temp1;
+                        temp1 = ((yuv420_width+127)>>7)<<7;
+                        tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                        tiled_offset = tiled_offset<<11;
+                    } else {
+                        /* even2 fomula: x+x_block_num*y */
+                        temp1 = ((yuv420_width+127)>>7)<<7;
+                        tiled_offset = tiled_y_index*(temp1>>6);
+                        tiled_offset = tiled_offset+tiled_x_index;
+                        tiled_offset = tiled_offset<<11;
+                    }
+                }
+
+                temp1 = i&0x1F;
+                temp2 = j&0x3F;
+                memcpy(yuv420_dest+j+yuv420_width*(i), nv12t_src+tiled_offset+temp2+64*(temp1), 4);
+                memcpy(yuv420_dest+j+yuv420_width*(i+1), nv12t_src+tiled_offset+temp2+64*(temp1+1), 4);
+                memcpy(yuv420_dest+j+yuv420_width*(i+2), nv12t_src+tiled_offset+temp2+64*(temp1+2), 4);
+                memcpy(yuv420_dest+j+yuv420_width*(i+3), nv12t_src+tiled_offset+temp2+64*(temp1+3), 4);
+            }
+        }
+    }
+}
+
+/*
+ * Converts and Deinterleaves tiled data to linear
+ * 1. UV of NV12T to UV of YUV420P
+ *
+ * @param yuv420_u_dest
+ *   U plane address of YUV420P[out]
+ *
+ * @param yuv420_v_dest
+ *   V plane address of YUV420P[out]
+ *
+ * @param nv12t_src
+ *   UV plane address of NV12T[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_uv_height
+ *   Height/2 of YUV420[in]
+ */
+void csc_tiled_to_linear_deinterleave(char *yuv420_u_dest, char *yuv420_v_dest, char *nv12t_uv_src, int yuv420_width, int yuv420_uv_height)
+{
+    unsigned int i, j;
+    unsigned int tiled_x_index = 0, tiled_y_index = 0;
+    unsigned int aligned_x_size = 0;
+    unsigned int tiled_offset = 0, tiled_offset1 = 0, tiled_offset2 = 0, tiled_offset3 = 0;
+    unsigned int temp1 = 0, temp2 = 0;
+
+    if (yuv420_width >= 1024) {
+        for (i=0; i<yuv420_uv_height; i=i+1) {
+            tiled_offset = 0;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+2;
+                tiled_offset = tiled_offset<<11;
+                tiled_offset1 = tiled_offset+2048*1;
+                tiled_offset2 = tiled_offset+2048*2;
+                tiled_offset3 = tiled_offset+2048*3;
+                temp2 = 8;
+            } else {
+                temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                /* even fomula: x_block_num*y */
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_y_index*(temp1>>6);
+                tiled_offset = tiled_offset<<11;
+                if ((i+32)<temp2) {
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*6;
+                    tiled_offset3 = tiled_offset+2048*7;
+                    temp2 = 8;
+                } else {
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*2;
+                    tiled_offset3 = tiled_offset+2048*3;
+                    temp2 = 4;
+                }
+            }
+            temp1 = i&0x1F;
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i), yuv420_v_dest+yuv420_width/2*(i), nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*1, yuv420_v_dest+yuv420_width/2*(i)+32*1, nv12t_uv_src+tiled_offset1+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*2, yuv420_v_dest+yuv420_width/2*(i)+32*2, nv12t_uv_src+tiled_offset2+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*3, yuv420_v_dest+yuv420_width/2*(i)+32*3, nv12t_uv_src+tiled_offset3+64*(temp1), 64);
+
+            tiled_offset = tiled_offset+temp2*2048;
+            tiled_offset1 = tiled_offset1+temp2*2048;
+            tiled_offset2 = tiled_offset2+temp2*2048;
+            tiled_offset3 = tiled_offset3+temp2*2048;
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*4, yuv420_v_dest+yuv420_width/2*(i)+32*4, nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*5, yuv420_v_dest+yuv420_width/2*(i)+32*5, nv12t_uv_src+tiled_offset1+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*6, yuv420_v_dest+yuv420_width/2*(i)+32*6, nv12t_uv_src+tiled_offset2+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*7, yuv420_v_dest+yuv420_width/2*(i)+32*7, nv12t_uv_src+tiled_offset3+64*(temp1), 64);
+
+            tiled_offset = tiled_offset+temp2*2048;
+            tiled_offset1 = tiled_offset1+temp2*2048;
+            tiled_offset2 = tiled_offset2+temp2*2048;
+            tiled_offset3 = tiled_offset3+temp2*2048;
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*8, yuv420_v_dest+yuv420_width/2*(i)+32*8, nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*9, yuv420_v_dest+yuv420_width/2*(i)+32*9, nv12t_uv_src+tiled_offset1+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*10, yuv420_v_dest+yuv420_width/2*(i)+32*10, nv12t_uv_src+tiled_offset2+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*11, yuv420_v_dest+yuv420_width/2*(i)+32*11, nv12t_uv_src+tiled_offset3+64*(temp1), 64);
+
+            tiled_offset = tiled_offset+temp2*2048;
+            tiled_offset1 = tiled_offset1+temp2*2048;
+            tiled_offset2 = tiled_offset2+temp2*2048;
+            tiled_offset3 = tiled_offset3+temp2*2048;
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*12, yuv420_v_dest+yuv420_width/2*(i)+32*12, nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*13, yuv420_v_dest+yuv420_width/2*(i)+32*13, nv12t_uv_src+tiled_offset1+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*14, yuv420_v_dest+yuv420_width/2*(i)+32*14, nv12t_uv_src+tiled_offset2+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+yuv420_width/2*(i)+32*15, yuv420_v_dest+yuv420_width/2*(i)+32*15, nv12t_uv_src+tiled_offset3+64*(temp1), 64);
+        }
+        aligned_x_size = 1024;
+    }
+
+    if ((yuv420_width-aligned_x_size) >= 512) {
+        for (i=0; i<yuv420_uv_height; i=i+1) {
+            tiled_offset = 0;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+2;
+                temp1 = aligned_x_size>>5;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+                tiled_offset1 = tiled_offset+2048*1;
+                tiled_offset2 = tiled_offset+2048*2;
+                tiled_offset3 = tiled_offset+2048*3;
+                temp2 = 8;
+            } else {
+                temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                /* even fomula: x_block_num*y */
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_y_index*(temp1>>6);
+                tiled_offset = tiled_offset<<11;
+                if ((i+32)<temp2) {
+                    temp1 = aligned_x_size>>5;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*6;
+                    tiled_offset3 = tiled_offset+2048*7;
+                    temp2 = 8;
+                } else {
+                    temp1 = aligned_x_size>>6;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*2;
+                    tiled_offset3 = tiled_offset+2048*3;
+                    temp2 = 4;
+                }
+            }
+            temp1 = i&0x1F;
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i), yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i), nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*1, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*1, nv12t_uv_src+tiled_offset1+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*2, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*2, nv12t_uv_src+tiled_offset2+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*3, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*3, nv12t_uv_src+tiled_offset3+64*(temp1), 64);
+
+            tiled_offset = tiled_offset+temp2*2048;
+            tiled_offset1 = tiled_offset1+temp2*2048;
+            tiled_offset2 = tiled_offset2+temp2*2048;
+            tiled_offset3 = tiled_offset3+temp2*2048;
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*4, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*4, nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*5, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*5, nv12t_uv_src+tiled_offset1+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*6, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*6, nv12t_uv_src+tiled_offset2+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*7, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*7, nv12t_uv_src+tiled_offset3+64*(temp1), 64);
+        }
+        aligned_x_size = aligned_x_size+512;
+    }
+
+    if ((yuv420_width-aligned_x_size) >= 256) {
+        for (i=0; i<yuv420_uv_height; i=i+1) {
+            tiled_offset = 0;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+2;
+                temp1 = aligned_x_size>>5;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+                tiled_offset1 = tiled_offset+2048*1;
+                tiled_offset2 = tiled_offset+2048*2;
+                tiled_offset3 = tiled_offset+2048*3;
+            } else {
+                temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                /* even fomula: x_block_num*y */
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_y_index*(temp1>>6);
+                tiled_offset = tiled_offset<<11;
+                if ((i+32)<temp2) {
+                    temp1 = aligned_x_size>>5;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*6;
+                    tiled_offset3 = tiled_offset+2048*7;
+                } else {
+                    temp1 = aligned_x_size>>6;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                    tiled_offset2 = tiled_offset+2048*2;
+                    tiled_offset3 = tiled_offset+2048*3;
+                }
+            }
+            temp1 = i&0x1F;
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i), yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i), nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*1, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*1, nv12t_uv_src+tiled_offset1+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*2, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*2, nv12t_uv_src+tiled_offset2+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*3, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*3, nv12t_uv_src+tiled_offset3+64*(temp1), 64);
+        }
+        aligned_x_size = aligned_x_size+256;
+    }
+
+    if ((yuv420_width-aligned_x_size) >= 128) {
+        for (i=0; i<yuv420_uv_height; i=i+2) {
+            tiled_offset = 0;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+2;
+                temp1 = aligned_x_size>>5;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+                tiled_offset1 = tiled_offset+2048*1;
+            } else {
+                temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                /* even fomula: x_block_num*y */
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_y_index*(temp1>>6);
+                tiled_offset = tiled_offset<<11;
+                if ((i+32)<temp2) {
+                    temp1 = aligned_x_size>>5;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                } else {
+                    temp1 = aligned_x_size>>6;
+                    tiled_offset = tiled_offset+(temp1<<11);
+                    tiled_offset1 = tiled_offset+2048*1;
+                }
+            }
+            temp1 = i&0x1F;
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i), yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i), nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i)+32*1, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i)+32*1, nv12t_uv_src+tiled_offset1+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i+1), yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i+1), nv12t_uv_src+tiled_offset+64*(temp1+1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i+1)+32*1, yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i+1)+32*1, nv12t_uv_src+tiled_offset1+64*(temp1+1), 64);
+        }
+        aligned_x_size = aligned_x_size+128;
+    }
+
+    if ((yuv420_width-aligned_x_size) >= 64) {
+        for (i=0; i<yuv420_uv_height; i=i+2) {
+            tiled_offset = 0;
+            tiled_x_index = aligned_x_size>>6;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+tiled_x_index;
+                tiled_offset = tiled_offset+2;
+                temp1 = (tiled_x_index>>2)<<2;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+            } else {
+                temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                if ((i+32)<temp2) {
+                    /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                    temp1 = tiled_x_index+2;
+                    temp1 = (temp1>>2)<<2;
+                    tiled_offset = tiled_x_index+temp1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    /* even2 fomula: x+x_block_num*y */
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset<<11;
+                }
+            }
+            temp1 = i&0x1F;
+            temp2 = aligned_x_size&0x3F;
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i), yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i), nv12t_uv_src+tiled_offset+64*(temp1), 64);
+            csc_deinterleave_memcpy(yuv420_u_dest+aligned_x_size/2+yuv420_width/2*(i+1), yuv420_v_dest+aligned_x_size/2+yuv420_width/2*(i+1), nv12t_uv_src+tiled_offset+64*(temp1+1), 64);
+        }
+        aligned_x_size = aligned_x_size+64;
+    }
+
+    if (yuv420_width != aligned_x_size) {
+        for (i=0; i<yuv420_uv_height; i=i+2) {
+            for (j=aligned_x_size; j<yuv420_width; j=j+4) {
+                tiled_offset = 0;
+                tiled_x_index = j>>6;
+                tiled_y_index = i>>5;
+                if (tiled_y_index & 0x1) {
+                    /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                    tiled_offset = tiled_y_index-1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset+2;
+                    temp1 = (tiled_x_index>>2)<<2;
+                    tiled_offset = tiled_offset+temp1;
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                    if ((i+32)<temp2) {
+                        /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                        temp1 = tiled_x_index+2;
+                        temp1 = (temp1>>2)<<2;
+                        tiled_offset = tiled_x_index+temp1;
+                        temp1 = ((yuv420_width+127)>>7)<<7;
+                        tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                        tiled_offset = tiled_offset<<11;
+                    } else {
+                        /* even2 fomula: x+x_block_num*y */
+                        temp1 = ((yuv420_width+127)>>7)<<7;
+                        tiled_offset = tiled_y_index*(temp1>>6);
+                        tiled_offset = tiled_offset+tiled_x_index;
+                        tiled_offset = tiled_offset<<11;
+                    }
+                }
+                temp1 = i&0x1F;
+                temp2 = j&0x3F;
+                csc_deinterleave_memcpy(yuv420_u_dest+j/2+yuv420_width/2*(i), yuv420_v_dest+j/2+yuv420_width/2*(i), nv12t_uv_src+tiled_offset+temp2+64*(temp1), 4);
+                csc_deinterleave_memcpy(yuv420_u_dest+j/2+yuv420_width/2*(i+1), yuv420_v_dest+j/2+yuv420_width/2*(i+1), nv12t_uv_src+tiled_offset+temp2+64*(temp1+1), 4);
+            }
+        }
+    }
+}
+
+/*
+ * Converts linear data to tiled.
+ * 1. Y of YUV420P to Y of NV12T
+ * 2. Y of YUV420S to Y of NV12T
+ * 3. UV of YUV420S to UV of NV12T
+ *
+ * @param nv12t_dest
+ *   Y or UV plane address of NV12T[out]
+ *
+ * @param yuv420_src
+ *   Y or UV plane address of YUV420P(S)[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_height
+ *   Y: Height of YUV420, UV: Height/2 of YUV420[in]
+ */
+void csc_linear_to_tiled(char *nv12t_dest, char *yuv420_src, int yuv420_width, int yuv420_height)
+{
+    unsigned int i, j;
+    unsigned int tiled_x_index = 0, tiled_y_index = 0;
+    unsigned int aligned_x_size = 0, aligned_y_size = 0;
+    unsigned int tiled_offset = 0;
+    unsigned int temp1 = 0, temp2 = 0;
+
+    aligned_y_size = (yuv420_height>>5)<<5;
+    aligned_x_size = (yuv420_width>>6)<<6;
+
+    for (i=0; i<aligned_y_size; i=i+32) {
+        for (j=0; j<aligned_x_size; j=j+64) {
+            tiled_offset = 0;
+            tiled_x_index = j>>6;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+tiled_x_index;
+                tiled_offset = tiled_offset+2;
+                temp1 = (tiled_x_index>>2)<<2;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+            } else {
+                temp2 = ((yuv420_height+31)>>5)<<5;
+                if ((i+32)<temp2) {
+                    /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                    temp1 = tiled_x_index+2;
+                    temp1 = (temp1>>2)<<2;
+                    tiled_offset = tiled_x_index+temp1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    /* even2 fomula: x+x_block_num*y */
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset<<11;
+                }
+            }
+
+            memcpy(nv12t_dest+tiled_offset, yuv420_src+j+yuv420_width*(i), 64);
+            memcpy(nv12t_dest+tiled_offset+64*1, yuv420_src+j+yuv420_width*(i+1), 64);
+            memcpy(nv12t_dest+tiled_offset+64*2, yuv420_src+j+yuv420_width*(i+2), 64);
+            memcpy(nv12t_dest+tiled_offset+64*3, yuv420_src+j+yuv420_width*(i+3), 64);
+            memcpy(nv12t_dest+tiled_offset+64*4, yuv420_src+j+yuv420_width*(i+4), 64);
+            memcpy(nv12t_dest+tiled_offset+64*5, yuv420_src+j+yuv420_width*(i+5), 64);
+            memcpy(nv12t_dest+tiled_offset+64*6, yuv420_src+j+yuv420_width*(i+6), 64);
+            memcpy(nv12t_dest+tiled_offset+64*7, yuv420_src+j+yuv420_width*(i+7), 64);
+            memcpy(nv12t_dest+tiled_offset+64*8, yuv420_src+j+yuv420_width*(i+8), 64);
+            memcpy(nv12t_dest+tiled_offset+64*9, yuv420_src+j+yuv420_width*(i+9), 64);
+            memcpy(nv12t_dest+tiled_offset+64*10, yuv420_src+j+yuv420_width*(i+10), 64);
+            memcpy(nv12t_dest+tiled_offset+64*11, yuv420_src+j+yuv420_width*(i+11), 64);
+            memcpy(nv12t_dest+tiled_offset+64*12, yuv420_src+j+yuv420_width*(i+12), 64);
+            memcpy(nv12t_dest+tiled_offset+64*13, yuv420_src+j+yuv420_width*(i+13), 64);
+            memcpy(nv12t_dest+tiled_offset+64*14, yuv420_src+j+yuv420_width*(i+14), 64);
+            memcpy(nv12t_dest+tiled_offset+64*15, yuv420_src+j+yuv420_width*(i+15), 64);
+            memcpy(nv12t_dest+tiled_offset+64*16, yuv420_src+j+yuv420_width*(i+16), 64);
+            memcpy(nv12t_dest+tiled_offset+64*17, yuv420_src+j+yuv420_width*(i+17), 64);
+            memcpy(nv12t_dest+tiled_offset+64*18, yuv420_src+j+yuv420_width*(i+18), 64);
+            memcpy(nv12t_dest+tiled_offset+64*19, yuv420_src+j+yuv420_width*(i+19), 64);
+            memcpy(nv12t_dest+tiled_offset+64*20, yuv420_src+j+yuv420_width*(i+20), 64);
+            memcpy(nv12t_dest+tiled_offset+64*21, yuv420_src+j+yuv420_width*(i+21), 64);
+            memcpy(nv12t_dest+tiled_offset+64*22, yuv420_src+j+yuv420_width*(i+22), 64);
+            memcpy(nv12t_dest+tiled_offset+64*23, yuv420_src+j+yuv420_width*(i+23), 64);
+            memcpy(nv12t_dest+tiled_offset+64*24, yuv420_src+j+yuv420_width*(i+24), 64);
+            memcpy(nv12t_dest+tiled_offset+64*25, yuv420_src+j+yuv420_width*(i+25), 64);
+            memcpy(nv12t_dest+tiled_offset+64*26, yuv420_src+j+yuv420_width*(i+26), 64);
+            memcpy(nv12t_dest+tiled_offset+64*27, yuv420_src+j+yuv420_width*(i+27), 64);
+            memcpy(nv12t_dest+tiled_offset+64*28, yuv420_src+j+yuv420_width*(i+28), 64);
+            memcpy(nv12t_dest+tiled_offset+64*29, yuv420_src+j+yuv420_width*(i+29), 64);
+            memcpy(nv12t_dest+tiled_offset+64*30, yuv420_src+j+yuv420_width*(i+30), 64);
+            memcpy(nv12t_dest+tiled_offset+64*31, yuv420_src+j+yuv420_width*(i+31), 64);
+        }
+    }
+
+    for (i=aligned_y_size; i<yuv420_height; i=i+4) {
+        for (j=0; j<aligned_x_size; j=j+64) {
+            tiled_offset = 0;
+            tiled_x_index = j>>6;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+tiled_x_index;
+                tiled_offset = tiled_offset+2;
+                temp1 = (tiled_x_index>>2)<<2;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+            } else {
+                temp2 = ((yuv420_height+31)>>5)<<5;
+                if ((i+32)<temp2) {
+                    /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                    temp1 = tiled_x_index+2;
+                    temp1 = (temp1>>2)<<2;
+                    tiled_offset = tiled_x_index+temp1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    /* even2 fomula: x+x_block_num*y */
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset<<11;
+                }
+            }
+
+            temp1 = i&0x1F;
+            memcpy(nv12t_dest+tiled_offset+64*(temp1), yuv420_src+j+yuv420_width*(i), 64);
+            memcpy(nv12t_dest+tiled_offset+64*(temp1+1), yuv420_src+j+yuv420_width*(i+1), 64);
+            memcpy(nv12t_dest+tiled_offset+64*(temp1+2), yuv420_src+j+yuv420_width*(i+2), 64);
+            memcpy(nv12t_dest+tiled_offset+64*(temp1+3), yuv420_src+j+yuv420_width*(i+3), 64);
+        }
+    }
+
+    for (i=0; i<yuv420_height; i=i+4) {
+        for (j=aligned_x_size; j<yuv420_width; j=j+4) {
+            tiled_offset = 0;
+            tiled_x_index = j>>6;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+tiled_x_index;
+                tiled_offset = tiled_offset+2;
+                temp1 = (tiled_x_index>>2)<<2;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+            } else {
+                temp2 = ((yuv420_height+31)>>5)<<5;
+                if ((i+32)<temp2) {
+                    /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                    temp1 = tiled_x_index+2;
+                    temp1 = (temp1>>2)<<2;
+                    tiled_offset = tiled_x_index+temp1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    /* even2 fomula: x+x_block_num*y */
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset<<11;
+                }
+            }
+
+            temp1 = i&0x1F;
+            temp2 = j&0x3F;
+            memcpy(nv12t_dest+tiled_offset+temp2+64*(temp1), yuv420_src+j+yuv420_width*(i), 4);
+            memcpy(nv12t_dest+tiled_offset+temp2+64*(temp1+1), yuv420_src+j+yuv420_width*(i+1), 4);
+            memcpy(nv12t_dest+tiled_offset+temp2+64*(temp1+2), yuv420_src+j+yuv420_width*(i+2), 4);
+            memcpy(nv12t_dest+tiled_offset+temp2+64*(temp1+3), yuv420_src+j+yuv420_width*(i+3), 4);
+        }
+    }
+}
+
+/*
+ * Converts and Interleaves linear to tiled
+ * 1. UV of YUV420P to UV of NV12T
+ *
+ * @param nv12t_uv_dest
+ *   UV plane address of NV12T[out]
+ *
+ * @param yuv420p_u_src
+ *   U plane address of YUV420P[in]
+ *
+ * @param yuv420p_v_src
+ *   V plane address of YUV420P[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_uv_height
+ *   Height/2 of YUV420[in]
+ */
+void csc_linear_to_tiled_interleave(char *nv12t_uv_dest, char *yuv420p_u_src, char *yuv420p_v_src, int yuv420_width, int yuv420_uv_height)
+{
+    unsigned int i, j;
+    unsigned int tiled_x_index = 0, tiled_y_index = 0;
+    unsigned int aligned_x_size = 0, aligned_y_size = 0;
+    unsigned int tiled_offset = 0;
+    unsigned int temp1 = 0, temp2 = 0;
+
+    aligned_y_size = (yuv420_uv_height>>5)<<5;
+    aligned_x_size = ((yuv420_width)>>6)<<6;
+
+    for (i=0; i<aligned_y_size; i=i+32) {
+        for (j=0; j<aligned_x_size; j=j+64) {
+            tiled_offset = 0;
+            tiled_x_index = j>>6;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+tiled_x_index;
+                tiled_offset = tiled_offset+2;
+                temp1 = (tiled_x_index>>2)<<2;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+            } else {
+                temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                if ((i+32)<temp2) {
+                    /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                    temp1 = tiled_x_index+2;
+                    temp1 = (temp1>>2)<<2;
+                    tiled_offset = tiled_x_index+temp1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    /* even2 fomula: x+x_block_num*y */
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset<<11;
+                }
+            }
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset, yuv420p_u_src+j/2+yuv420_width/2*(i), yuv420p_v_src+j/2+yuv420_width/2*(i), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*1, yuv420p_u_src+j/2+yuv420_width/2*(i+1), yuv420p_v_src+j/2+yuv420_width/2*(i+1), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*2, yuv420p_u_src+j/2+yuv420_width/2*(i+2), yuv420p_v_src+j/2+yuv420_width/2*(i+2), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*3, yuv420p_u_src+j/2+yuv420_width/2*(i+3), yuv420p_v_src+j/2+yuv420_width/2*(i+3), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*4, yuv420p_u_src+j/2+yuv420_width/2*(i+4), yuv420p_v_src+j/2+yuv420_width/2*(i+4), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*5, yuv420p_u_src+j/2+yuv420_width/2*(i+5), yuv420p_v_src+j/2+yuv420_width/2*(i+5), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*6, yuv420p_u_src+j/2+yuv420_width/2*(i+6), yuv420p_v_src+j/2+yuv420_width/2*(i+6), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*7, yuv420p_u_src+j/2+yuv420_width/2*(i+7), yuv420p_v_src+j/2+yuv420_width/2*(i+7), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*8, yuv420p_u_src+j/2+yuv420_width/2*(i+8), yuv420p_v_src+j/2+yuv420_width/2*(i+8), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*9, yuv420p_u_src+j/2+yuv420_width/2*(i+9), yuv420p_v_src+j/2+yuv420_width/2*(i+9), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*10, yuv420p_u_src+j/2+yuv420_width/2*(i+10), yuv420p_v_src+j/2+yuv420_width/2*(i+10), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*11, yuv420p_u_src+j/2+yuv420_width/2*(i+11), yuv420p_v_src+j/2+yuv420_width/2*(i+11), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*12, yuv420p_u_src+j/2+yuv420_width/2*(i+12), yuv420p_v_src+j/2+yuv420_width/2*(i+12), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*13, yuv420p_u_src+j/2+yuv420_width/2*(i+13), yuv420p_v_src+j/2+yuv420_width/2*(i+13), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*14, yuv420p_u_src+j/2+yuv420_width/2*(i+14), yuv420p_v_src+j/2+yuv420_width/2*(i+14), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*15, yuv420p_u_src+j/2+yuv420_width/2*(i+15), yuv420p_v_src+j/2+yuv420_width/2*(i+15), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*16, yuv420p_u_src+j/2+yuv420_width/2*(i+16), yuv420p_v_src+j/2+yuv420_width/2*(i+16), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*17, yuv420p_u_src+j/2+yuv420_width/2*(i+17), yuv420p_v_src+j/2+yuv420_width/2*(i+17), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*18, yuv420p_u_src+j/2+yuv420_width/2*(i+18), yuv420p_v_src+j/2+yuv420_width/2*(i+18), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*19, yuv420p_u_src+j/2+yuv420_width/2*(i+19), yuv420p_v_src+j/2+yuv420_width/2*(i+19), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*20, yuv420p_u_src+j/2+yuv420_width/2*(i+20), yuv420p_v_src+j/2+yuv420_width/2*(i+20), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*21, yuv420p_u_src+j/2+yuv420_width/2*(i+21), yuv420p_v_src+j/2+yuv420_width/2*(i+21), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*22, yuv420p_u_src+j/2+yuv420_width/2*(i+22), yuv420p_v_src+j/2+yuv420_width/2*(i+22), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*23, yuv420p_u_src+j/2+yuv420_width/2*(i+23), yuv420p_v_src+j/2+yuv420_width/2*(i+23), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*24, yuv420p_u_src+j/2+yuv420_width/2*(i+24), yuv420p_v_src+j/2+yuv420_width/2*(i+24), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*25, yuv420p_u_src+j/2+yuv420_width/2*(i+25), yuv420p_v_src+j/2+yuv420_width/2*(i+25), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*26, yuv420p_u_src+j/2+yuv420_width/2*(i+26), yuv420p_v_src+j/2+yuv420_width/2*(i+26), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*27, yuv420p_u_src+j/2+yuv420_width/2*(i+27), yuv420p_v_src+j/2+yuv420_width/2*(i+27), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*28, yuv420p_u_src+j/2+yuv420_width/2*(i+28), yuv420p_v_src+j/2+yuv420_width/2*(i+28), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*29, yuv420p_u_src+j/2+yuv420_width/2*(i+29), yuv420p_v_src+j/2+yuv420_width/2*(i+29), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*30, yuv420p_u_src+j/2+yuv420_width/2*(i+30), yuv420p_v_src+j/2+yuv420_width/2*(i+30), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*31, yuv420p_u_src+j/2+yuv420_width/2*(i+31), yuv420p_v_src+j/2+yuv420_width/2*(i+31), 32);
+        }
+    }
+
+    for (i=aligned_y_size; i<yuv420_uv_height; i=i+4) {
+        for (j=0; j<aligned_x_size; j=j+64) {
+            tiled_offset = 0;
+            tiled_x_index = j>>6;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+tiled_x_index;
+                tiled_offset = tiled_offset+2;
+                temp1 = (tiled_x_index>>2)<<2;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+            } else {
+                temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                if ((i+32)<temp2) {
+                    /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                    temp1 = tiled_x_index+2;
+                    temp1 = (temp1>>2)<<2;
+                    tiled_offset = tiled_x_index+temp1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    /* even2 fomula: x+x_block_num*y */
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset<<11;
+                }
+            }
+            temp1 = i&0x1F;
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*(temp1), yuv420p_u_src+j/2+yuv420_width/2*(i), yuv420p_v_src+j/2+yuv420_width/2*(i), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*(temp1+1), yuv420p_u_src+j/2+yuv420_width/2*(i+1), yuv420p_v_src+j/2+yuv420_width/2*(i+1), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*(temp1+2), yuv420p_u_src+j/2+yuv420_width/2*(i+2), yuv420p_v_src+j/2+yuv420_width/2*(i+2), 32);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+64*(temp1+3), yuv420p_u_src+j/2+yuv420_width/2*(i+3), yuv420p_v_src+j/2+yuv420_width/2*(i+3), 32);
+        }
+    }
+
+    for (i=0; i<yuv420_uv_height; i=i+4) {
+        for (j=aligned_x_size; j<yuv420_width; j=j+4) {
+            tiled_offset = 0;
+            tiled_x_index = j>>6;
+            tiled_y_index = i>>5;
+            if (tiled_y_index & 0x1) {
+                /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+                tiled_offset = tiled_y_index-1;
+                temp1 = ((yuv420_width+127)>>7)<<7;
+                tiled_offset = tiled_offset*(temp1>>6);
+                tiled_offset = tiled_offset+tiled_x_index;
+                tiled_offset = tiled_offset+2;
+                temp1 = (tiled_x_index>>2)<<2;
+                tiled_offset = tiled_offset+temp1;
+                tiled_offset = tiled_offset<<11;
+            } else {
+                temp2 = ((yuv420_uv_height+31)>>5)<<5;
+                if ((i+32)<temp2) {
+                    /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+                    temp1 = tiled_x_index+2;
+                    temp1 = (temp1>>2)<<2;
+                    tiled_offset = tiled_x_index+temp1;
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_offset+tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset<<11;
+                } else {
+                    /* even2 fomula: x+x_block_num*y */
+                    temp1 = ((yuv420_width+127)>>7)<<7;
+                    tiled_offset = tiled_y_index*(temp1>>6);
+                    tiled_offset = tiled_offset+tiled_x_index;
+                    tiled_offset = tiled_offset<<11;
+                }
+            }
+            temp1 = i&0x1F;
+            temp2 = j&0x3F;
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+temp2+64*(temp1), yuv420p_u_src+j/2+yuv420_width/2*(i), yuv420p_v_src+j/2+yuv420_width/2*(i), 2);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+temp2+64*(temp1+1), yuv420p_u_src+j/2+yuv420_width/2*(i+1), yuv420p_v_src+j/2+yuv420_width/2*(i+1), 2);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+temp2+64*(temp1+2), yuv420p_u_src+j/2+yuv420_width/2*(i+2), yuv420p_v_src+j/2+yuv420_width/2*(i+2), 2);
+            csc_interleave_memcpy(nv12t_uv_dest+tiled_offset+temp2+64*(temp1+3), yuv420p_u_src+j/2+yuv420_width/2*(i+3), yuv420p_v_src+j/2+yuv420_width/2*(i+3), 2);
+        }
+    }
+}
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_deinterleave_memcpy.s b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_deinterleave_memcpy.s
new file mode 100644
index 0000000..5b55080
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_deinterleave_memcpy.s
@@ -0,0 +1,128 @@
+/*
+ *
+ * Copyright 2011 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    csc_deinterleave_memcpy.s
+ * @brief   SEC_OMX specific define
+ * @author  ShinWon Lee (shinwon.lee@samsung.com)
+ * @version 1.0
+ * @history
+ *   2011.7.01 : Create
+ */
+    .arch armv7-a
+    .text
+    .global csc_deinterleave_memcpy
+    .type   csc_deinterleave_memcpy, %function
+csc_deinterleave_memcpy:
+    .fnstart
+
+    @r0     dest1
+    @r1     dest2
+    @r2     src
+    @r3     src_size
+    @r4     i
+    @r5     temp1
+    @r6     temp2
+    @r7     temp3
+
+    stmfd       sp!, {r4-r12,r14}       @ backup registers
+
+    mov         r4, #0
+    cmp         r3, #256
+    blt         LINEAR_SIZE_128
+
+    bic         r5, r3, #0xFF
+LINEAR_SIZE_256_LOOP:
+    pld         [r2, #64]
+    vld2.8      {q0, q1}, [r2]!
+    pld         [r2, #64]
+    vld2.8      {q2, q3}, [r2]!
+    pld         [r2, #64]
+    vld2.8      {q4, q5}, [r2]!
+    pld         [r2, #64]
+    vld2.8      {q6, q7}, [r2]!
+    pld         [r2, #64]
+    vld2.8      {q8, q9}, [r2]!
+    pld         [r2, #64]
+    vld2.8      {q10, q11}, [r2]!
+    vld2.8      {q12, q13}, [r2]!
+    vld2.8      {q14, q15}, [r2]!
+
+    vst1.8      {q0}, [r0]!
+    vst1.8      {q2}, [r0]!
+    vst1.8      {q4}, [r0]!
+    vst1.8      {q6}, [r0]!
+    vst1.8      {q8}, [r0]!
+    vst1.8      {q10}, [r0]!
+    vst1.8      {q12}, [r0]!
+    vst1.8      {q14}, [r0]!
+
+    vst1.8      {q1}, [r1]!
+    vst1.8      {q3}, [r1]!
+    vst1.8      {q5}, [r1]!
+    vst1.8      {q7}, [r1]!
+    vst1.8      {q9}, [r1]!
+    vst1.8      {q11}, [r1]!
+    vst1.8      {q13}, [r1]!
+    vst1.8      {q15}, [r1]!
+
+    add         r4, #256
+    cmp         r4, r5
+    blt         LINEAR_SIZE_256_LOOP
+
+LINEAR_SIZE_128:
+    sub         r5, r3, r4
+    cmp         r5, #64
+    blt         LINEAR_SIZE_4
+    pld         [r2, #64]
+    vld2.8      {q0, q1}, [r2]!
+    pld         [r2, #64]
+    vld2.8      {q2, q3}, [r2]!
+    vld2.8      {q4, q5}, [r2]!
+    vld2.8      {q6, q7}, [r2]!
+
+    vst1.8      {q0}, [r0]!
+    vst1.8      {q4}, [r0]!
+    vst1.8      {q2}, [r0]!
+    vst1.8      {q6}, [r0]!
+
+    vst1.8      {q1}, [r1]!
+    vst1.8      {q3}, [r1]!
+    vst1.8      {q5}, [r1]!
+    vst1.8      {q7}, [r1]!
+
+    add         r4, #128
+
+LINEAR_SIZE_4:
+    ldrb        r6, [r2], #1
+    ldrb        r7, [r2], #1
+    ldrb        r8, [r2], #1
+    ldrb        r9, [r2], #1
+
+    strb        r6, [r0], #1
+    strb        r8, [r0], #1
+    strb        r7, [r1], #1
+    strb        r9, [r1], #1
+
+    add         r4, #4
+    cmp         r4, r3
+    blt         LINEAR_SIZE_4
+
+RESTORE_REG:
+    ldmfd       sp!, {r4-r12,r15}       @ restore registers
+    .fnend
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_interleave_memcpy.s b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_interleave_memcpy.s
new file mode 100644
index 0000000..54f4436
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_interleave_memcpy.s
@@ -0,0 +1,133 @@
+/*
+ *
+ * Copyright 2011 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    csc_interleave_memcpy.s
+ * @brief   SEC_OMX specific define
+ * @author  ShinWon Lee (shinwon.lee@samsung.com)
+ * @version 1.0
+ * @history
+ *   2011.7.01 : Create
+ */
+    .arch armv7-a
+    .text
+    .global csc_interleave_memcpy
+    .type   csc_interleave_memcpy, %function
+csc_interleave_memcpy:
+    .fnstart
+
+    @r0     dest
+    @r1     src1
+    @r2     src2
+    @r3     src_size
+    @r4     i
+    @r5     temp1
+    @r6     temp2
+    @r7     temp3
+    @r8     temp2
+    @r9     temp3
+
+    stmfd       sp!, {r4-r12,r14}       @ backup registers
+
+    mov         r4, #0
+    cmp         r3, #128
+    blt         LINEAR_SIZE_64
+
+    bic         r5, r3, #0x2F
+LINEAR_SIZE_128_LOOP:
+    pld         [r1, #64]
+    vld1.8      {q0}, [r1]!
+    vld1.8      {q2}, [r1]!
+    vld1.8      {q4}, [r1]!
+    vld1.8      {q6}, [r1]!
+    pld         [r2]
+    vld1.8      {q8}, [r1]!
+    vld1.8      {q10}, [r1]!
+    vld1.8      {q12}, [r1]!
+    vld1.8      {q14}, [r1]!
+    pld         [r2, #64]
+    vld1.8      {q1}, [r2]!
+    vld1.8      {q3}, [r2]!
+    vld1.8      {q5}, [r2]!
+    vld1.8      {q7}, [r2]!
+    vld1.8      {q9}, [r2]!
+    vld1.8      {q11}, [r2]!
+    vld1.8      {q13}, [r2]!
+    vld1.8      {q15}, [r2]!
+
+    vst2.8      {q0, q1}, [r0]!
+    vst2.8      {q2, q3}, [r0]!
+    vst2.8      {q4, q5}, [r0]!
+    vst2.8      {q6, q7}, [r0]!
+    vst2.8      {q8, q9}, [r0]!
+    vst2.8      {q10, q11}, [r0]!
+    pld         [r1]
+    vst2.8      {q12, q13}, [r0]!
+    vst2.8      {q14, q15}, [r0]!
+
+    add         r4, #128
+    cmp         r4, r5
+    blt         LINEAR_SIZE_128_LOOP
+
+LINEAR_SIZE_64:
+    sub         r5, r3, r4
+    cmp         r5, #64
+    blt         LINEAR_SIZE_2
+LINEAR_SIZE_64_LOOP:
+    pld         [r2]
+    vld1.8      {q0}, [r1]!
+    vld1.8      {q2}, [r1]!
+    vld1.8      {q4}, [r1]!
+    vld1.8      {q6}, [r1]!
+    vld1.8      {q1}, [r2]!
+    vld1.8      {q3}, [r2]!
+    vld1.8      {q5}, [r2]!
+    vld1.8      {q7}, [r2]!
+
+    vst2.8      {q0, q1}, [r0]!
+    vst2.8      {q2, q3}, [r0]!
+    pld         [r1]
+    vst2.8      {q4, q5}, [r0]!
+    vst2.8      {q6, q7}, [r0]!
+
+    add         r4, #64
+    cmp         r4, r3
+    blt         LINEAR_SIZE_64_LOOP
+
+LINEAR_SIZE_2:
+    sub         r5, r3, r4
+    cmp         r5, #2
+    blt         RESTORE_REG
+LINEAR_SIZE_2_LOOP:
+    ldrb        r6, [r1], #1
+    ldrb        r7, [r2], #1
+    ldrb        r8, [r1], #1
+    ldrb        r9, [r2], #1
+
+    strb        r6, [r0], #1
+    strb        r7, [r0], #1
+    strb        r8, [r0], #1
+    strb        r9, [r0], #1
+
+    add         r4, #2
+    cmp         r4, r3
+    blt         LINEAR_SIZE_2_LOOP
+
+RESTORE_REG:
+    ldmfd       sp!, {r4-r12,r15}       @ restore registers
+    .fnend
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_nv12t_yuv420_uv_neon.s b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_nv12t_yuv420_uv_neon.s
new file mode 100644
index 0000000..08e359c
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_nv12t_yuv420_uv_neon.s
@@ -0,0 +1,768 @@
+/*
+ *
+ * Copyright 2011 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    csc_nv12t_yuv420_uv_neon.s
+ * @brief   SEC_OMX specific define
+ * @author  ShinWon Lee (shinwon.lee@samsung.com)
+ * @version 1.0
+ * @history
+ *   2011.7.01 : Create
+ */
+
+/*
+ * Converts and Deinterleaves tiled data to linear
+ * 1. UV of NV12T to UV of YUV420P
+ *
+ * @param yuv420_u_dest
+ *   U plane address of YUV420P[out]
+ *
+ * @param yuv420_v_dest
+ *   V plane address of YUV420P[out]
+ *
+ * @param nv12t_src
+ *   UV plane address of NV12T[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_uv_height
+ *   Height/2 of YUV420[in]
+ */
+
+    .arch armv7-a
+    .text
+    .global csc_tiled_to_linear_deinterleave
+    .type   csc_tiled_to_linear_deinterleave, %function
+csc_tiled_to_linear_deinterleave:
+    .fnstart
+
+    @r0         linear_u_dest
+    @r1         linear_v_dest
+    @r2         tiled_uv_src
+    @r3         linear_x_size
+    @r4         linear_y_size
+    @r5         j
+    @r6         i
+    @r7         tiled_addr
+    @r8         linear_addr
+    @r9         aligned_x_size
+    @r10        temp1
+    @r11        temp2
+    @r12        temp3
+    @r14        temp4
+
+    stmfd       sp!, {r4-r12,r14}               @ backup registers
+
+    ldr         r4, [sp, #40]           @ load linear_y_size to r4
+
+    mov         r9, #0
+
+LINEAR_X_SIZE_1024:
+    cmp         r3, #1024
+    blt         LINEAR_X_SIZE_512
+
+    mov         r6, #0
+LINEAR_X_SIZE_1024_LOOP:
+    mov         r7, #0                  @ tiled_offset = 0@
+    mov         r5, r6, asr #5          @ tiled_y_index = i>>5@
+    and         r10, r5, #0x1
+    cmp         r10, #0x1
+    bne         LINEAR_X_SIZE_1024_LOOP_EVEN
+LINEAR_X_SIZE_1024_LOOP_ODD:
+    sub         r7, r5, #1              @ tiled_offset = tiled_y_index-1@
+    add         r10, r3, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_offset*(temp1>>6)@
+    mul         r7, r7, r10
+    mov         r5, #8
+    mov         r5, r5, lsl #11
+    sub         r5, r5, #32
+    add         r7, r7, #2              @ tiled_offset = tiled_offset+2@
+    mov         r7, r7, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r11, r7, #2048
+    add         r12, r7, #4096
+    add         r14, r7, #6144
+    b           LINEAR_X_SIZE_1024_LOOP_MEMCPY
+
+LINEAR_X_SIZE_1024_LOOP_EVEN:
+    add         r11, r4, #31            @ temp2 = ((linear_y_size+31)>>5)<<5@
+    bic         r11, r11, #0x1F
+    add         r10, r3, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_y_index*(temp1>>6)@
+    mul         r7, r5, r10
+    add         r12, r6, #32
+    cmp         r12, r11
+    mov         r7, r7, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r11, r7, #2048
+    movlt       r5, #8
+    addlt       r12, r7, #12288
+    addlt       r14, r7, #14336
+    movge       r5, #4
+    addge       r12, r7, #2048
+    addge       r14, r7, #2048
+    mov         r5, r5, lsl #11
+    sub         r5, r5, #32
+
+LINEAR_X_SIZE_1024_LOOP_MEMCPY:
+    and         r10, r6, #0x1F
+    mov         r10, r10, lsl #6
+    add         r10, r2, r10
+
+    add         r7, r7, r10             @ tiled_addr = tiled_src+64*(temp1)
+    add         r11, r11, r10           @ tiled_addr1 = tiled_src+64*(temp1)
+    pld         [r11]
+    vld2.8      {q0, q1}, [r7]!
+    pld         [r11, #32]
+    add         r12, r12, r10           @ tiled_addr2 = tiled_src+64*(temp1)
+    vld2.8      {q2, q3}, [r7], r5
+    pld         [r12]
+    vld2.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    add         r14, r14, r10           @ tiled_addr3 = tiled_src+64*(temp1)
+    vld2.8      {q6, q7}, [r11], r5
+    pld         [r14]
+    vld2.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    mov         r10, r3, asr #1
+    vld2.8      {q10, q11}, [r12], r5
+    mul         r10, r10, r6
+    vld2.8      {q12, q13}, [r14]!
+    vld2.8      {q14, q15}, [r14], r5
+
+    add         r8, r0, r10
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8]!
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8]!
+    vst1.8      {q8}, [r8]!
+    vst1.8      {q10}, [r8]!
+    vst1.8      {q12}, [r8]!
+    vst1.8      {q14}, [r8]!
+
+    add         r10, r1, r10
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10]!
+    vst1.8      {q5}, [r10]!
+    vst1.8      {q7}, [r10]!
+    vst1.8      {q9}, [r10]!
+    vst1.8      {q11}, [r10]!
+    pld         [r7]
+    vst1.8      {q13}, [r10]!
+    pld         [r7, #32]
+    vst1.8      {q15}, [r10]!
+
+    pld         [r11]
+    vld2.8      {q0, q1}, [r7]!
+    pld         [r11, #32]
+    vld2.8      {q2, q3}, [r7], r5
+    pld         [r12]
+    vld2.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    vld2.8      {q6, q7}, [r11], r5
+    pld         [r14]
+    vld2.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    vld2.8      {q10, q11}, [r12], r5
+    vld2.8      {q12, q13}, [r14]!
+    vld2.8      {q14, q15}, [r14], r5
+
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8]!
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8]!
+    vst1.8      {q8}, [r8]!
+    vst1.8      {q10}, [r8]!
+    vst1.8      {q12}, [r8]!
+    vst1.8      {q14}, [r8]!
+
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10]!
+    vst1.8      {q5}, [r10]!
+    vst1.8      {q7}, [r10]!
+    vst1.8      {q9}, [r10]!
+    vst1.8      {q11}, [r10]!
+    pld         [r7]
+    vst1.8      {q13}, [r10]!
+    pld         [r7, #32]
+    vst1.8      {q15}, [r10]!
+
+    pld         [r11]
+    vld2.8      {q0, q1}, [r7]!
+    pld         [r11, #32]
+    vld2.8      {q2, q3}, [r7], r5
+    pld         [r12]
+    vld2.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    vld2.8      {q6, q7}, [r11], r5
+    pld         [r14]
+    vld2.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    vld2.8      {q10, q11}, [r12], r5
+    vld2.8      {q12, q13}, [r14]!
+    vld2.8      {q14, q15}, [r14], r5
+
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8]!
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8]!
+    vst1.8      {q8}, [r8]!
+    vst1.8      {q10}, [r8]!
+    vst1.8      {q12}, [r8]!
+    vst1.8      {q14}, [r8]!
+
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10]!
+    vst1.8      {q5}, [r10]!
+    vst1.8      {q7}, [r10]!
+    vst1.8      {q9}, [r10]!
+    vst1.8      {q11}, [r10]!
+    pld         [r7]
+    vst1.8      {q13}, [r10]!
+    pld         [r7, #32]
+    vst1.8      {q15}, [r10]!
+
+    pld         [r11]
+    vld2.8      {q0, q1}, [r7]!
+    pld         [r11, #32]
+    vld2.8      {q2, q3}, [r7]
+    pld         [r12]
+    vld2.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    vld2.8      {q6, q7}, [r11]
+    pld         [r14]
+    vld2.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    vld2.8      {q10, q11}, [r12]
+    vld2.8      {q12, q13}, [r14]!
+    vld2.8      {q14, q15}, [r14]
+
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8]!
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8]!
+    vst1.8      {q8}, [r8]!
+    vst1.8      {q10}, [r8]!
+    vst1.8      {q12}, [r8]!
+    vst1.8      {q14}, [r8]!
+
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10]!
+    vst1.8      {q5}, [r10]!
+    vst1.8      {q7}, [r10]!
+    vst1.8      {q9}, [r10]!
+    vst1.8      {q11}, [r10]!
+    add         r6, #1
+    vst1.8      {q13}, [r10]!
+    cmp         r6, r4
+    vst1.8      {q15}, [r10]!
+
+    blt         LINEAR_X_SIZE_1024_LOOP
+
+    mov         r9, #1024
+
+LINEAR_X_SIZE_512:
+    sub         r10, r3, r9
+    cmp         r10, #512
+    blt         LINEAR_X_SIZE_256
+
+    mov         r6, #0
+LINEAR_X_SIZE_512_LOOP:
+    mov         r7, #0                  @ tiled_offset = 0@
+    mov         r5, r6, asr #5          @ tiled_y_index = i>>5@
+    and         r10, r5, #0x1
+    cmp         r10, #0x1
+    bne         LINEAR_X_SIZE_512_LOOP_EVEN
+LINEAR_X_SIZE_512_LOOP_ODD:
+    sub         r7, r5, #1              @ tiled_offset = tiled_y_index-1@
+    add         r10, r3, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_offset*(temp1>>6)@
+    mul         r7, r7, r10
+    mov         r5, #8
+    mov         r5, r5, lsl #11
+    add         r7, r7, #2              @ tiled_offset = tiled_offset+2@
+    mov         r10, r9, asr #5
+    add         r7, r7, r10
+    mov         r7, r7, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r11, r7, #2048
+    add         r12, r7, #4096
+    add         r14, r7, #6144
+    sub         r5, r5, #32
+    b           LINEAR_X_SIZE_512_LOOP_MEMCPY
+
+LINEAR_X_SIZE_512_LOOP_EVEN:
+    add         r11, r4, #31            @ temp2 = ((linear_y_size+31)>>5)<<5@
+    bic         r11, r11, #0x1F
+    add         r10, r3, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_y_index*(temp1>>6)@
+    mul         r7, r5, r10
+    add         r12, r6, #32
+    cmp         r12, r11
+    mov         r7, r7, lsl #11         @ tiled_offset = tiled_offset<<11@
+    movlt       r5, #8
+    movlt       r10, r9, asr #5
+    movge       r10, r9, asr #6
+    add         r7, r7, r10, lsl #11
+    add         r11, r7, #2048
+    addlt       r12, r7, #12288
+    addlt       r14, r7, #14336
+    movge       r5, #4
+    addge       r12, r7, #4096
+    addge       r14, r7, #6144
+    mov         r5, r5, lsl #11
+    sub         r5, r5, #32
+
+LINEAR_X_SIZE_512_LOOP_MEMCPY:
+    and         r10, r6, #0x1F
+    mov         r10, r10, lsl #6
+    add         r10, r2, r10
+
+    add         r7, r7, r10             @ tiled_addr = tiled_src+64*(temp1)
+    add         r11, r11, r10           @ tiled_addr1 = tiled_src+64*(temp1)
+    pld         [r11]
+    vld2.8      {q0, q1}, [r7]!
+    pld         [r11, #32]
+    add         r12, r12, r10           @ tiled_addr2 = tiled_src+64*(temp1)
+    vld2.8      {q2, q3}, [r7], r5
+    pld         [r12]
+    vld2.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    add         r14, r14, r10           @ tiled_addr3 = tiled_src+64*(temp1)
+    vld2.8      {q6, q7}, [r11], r5
+    pld         [r14]
+    mov         r10, r3, asr #1
+    vld2.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    mul         r10, r10, r6
+    vld2.8      {q10, q11}, [r12], r5
+    add         r8, r0, r10
+    vld2.8      {q12, q13}, [r14]!
+    add         r8, r8, r9, asr #1
+    vld2.8      {q14, q15}, [r14], r5
+
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8]!
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8]!
+    vst1.8      {q8}, [r8]!
+    vst1.8      {q10}, [r8]!
+    vst1.8      {q12}, [r8]!
+    add         r10, r1, r10
+    vst1.8      {q14}, [r8]!
+
+    add         r10, r10, r9, asr #1
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10]!
+    vst1.8      {q5}, [r10]!
+    vst1.8      {q7}, [r10]!
+    vst1.8      {q9}, [r10]!
+    vst1.8      {q11}, [r10]!
+    pld         [r7]
+    vst1.8      {q13}, [r10]!
+    pld         [r7, #32]
+    vst1.8      {q15}, [r10]!
+
+    pld         [r11]
+    vld2.8      {q0, q1}, [r7]!
+    pld         [r11, #32]
+    vld2.8      {q2, q3}, [r7]
+    pld         [r12]
+    vld2.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    vld2.8      {q6, q7}, [r11]
+    pld         [r14]
+    vld2.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    vld2.8      {q10, q11}, [r12]
+    vld2.8      {q12, q13}, [r14]!
+    vld2.8      {q14, q15}, [r14]
+
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8]!
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8]!
+    vst1.8      {q8}, [r8]!
+    vst1.8      {q10}, [r8]!
+    vst1.8      {q12}, [r8]!
+    vst1.8      {q14}, [r8]!
+
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10]!
+    vst1.8      {q5}, [r10]!
+    vst1.8      {q7}, [r10]!
+    vst1.8      {q9}, [r10]!
+    vst1.8      {q11}, [r10]!
+    add         r6, #1
+    vst1.8      {q13}, [r10]!
+    cmp         r6, r4
+    vst1.8      {q15}, [r10]!
+
+    blt         LINEAR_X_SIZE_512_LOOP
+
+    add         r9, r9, #512
+
+LINEAR_X_SIZE_256:
+    sub         r10, r3, r9
+    cmp         r10, #256
+    blt         LINEAR_X_SIZE_128
+
+    mov         r6, #0
+LINEAR_X_SIZE_256_LOOP:
+    mov         r7, #0                  @ tiled_offset = 0@
+    mov         r5, r6, asr #5          @ tiled_y_index = i>>5@
+    and         r10, r5, #0x1
+    cmp         r10, #0x1
+    bne         LINEAR_X_SIZE_256_LOOP_EVEN
+LINEAR_X_SIZE_256_LOOP_ODD:
+    sub         r7, r5, #1              @ tiled_offset = tiled_y_index-1@
+    add         r10, r3, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_offset*(temp1>>6)@
+    mul         r7, r7, r10
+    add         r7, r7, #2              @ tiled_offset = tiled_offset+2@
+    mov         r10, r9, asr #5
+    add         r7, r7, r10
+    mov         r7, r7, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r11, r7, #2048
+    add         r12, r7, #4096
+    add         r14, r7, #6144
+    b           LINEAR_X_SIZE_256_LOOP_MEMCPY
+
+LINEAR_X_SIZE_256_LOOP_EVEN:
+    add         r11, r4, #31            @ temp2 = ((linear_y_size+31)>>5)<<5@
+    bic         r11, r11, #0x1F
+    add         r10, r3, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_y_index*(temp1>>6)@
+    mul         r7, r5, r10
+    mov         r7, r7, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r12, r6, #32
+    cmp         r12, r11
+    movlt       r10, r9, asr #5
+    addlt       r7, r7, r10, lsl #11
+    addlt       r11, r7, #2048
+    addlt       r12, r7, #12288
+    addlt       r14, r7, #14336
+    movge       r10, r9, asr #6
+    addge       r7, r7, r10, lsl #11
+    addge       r11, r7, #2048
+    addge       r12, r7, #4096
+    addge       r14, r7, #6144
+
+LINEAR_X_SIZE_256_LOOP_MEMCPY:
+    and         r10, r6, #0x1F
+    mov         r10, r10, lsl #6
+    add         r10, r2, r10
+
+    add         r7, r7, r10             @ tiled_addr = tiled_src+64*(temp1)
+    add         r11, r11, r10           @ tiled_addr1 = tiled_src+64*(temp1)
+    pld         [r11]
+    vld2.8      {q0, q1}, [r7]!
+    pld         [r11, #32]
+    add         r12, r12, r10           @ tiled_addr2 = tiled_src+64*(temp1)
+    vld2.8      {q2, q3}, [r7]
+    pld         [r12]
+    vld2.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    add         r14, r14, r10           @ tiled_addr3 = tiled_src+64*(temp1)
+    vld2.8      {q6, q7}, [r11]
+    pld         [r14]
+    vld2.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    mov         r10, r3, asr #1
+    vld2.8      {q10, q11}, [r12]
+    mul         r10, r10, r6
+    vld2.8      {q12, q13}, [r14]!
+    add         r8, r0, r10
+    vld2.8      {q14, q15}, [r14]
+
+    add         r8, r8, r9, asr #1
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8]!
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8]!
+    vst1.8      {q8}, [r8]!
+    vst1.8      {q10}, [r8]!
+    vst1.8      {q12}, [r8]!
+    add         r10, r1, r10
+    vst1.8      {q14}, [r8]!
+
+    add         r10, r10, r9, asr #1
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10]!
+    vst1.8      {q5}, [r10]!
+    vst1.8      {q7}, [r10]!
+    vst1.8      {q9}, [r10]!
+    vst1.8      {q11}, [r10]!
+    add         r6, #1
+    vst1.8      {q13}, [r10]!
+    cmp         r6, r4
+    vst1.8      {q15}, [r10]!
+    blt         LINEAR_X_SIZE_256_LOOP
+
+    add         r9, r9, #256
+
+LINEAR_X_SIZE_128:
+    sub         r10, r3, r9
+    cmp         r10, #128
+    blt         LINEAR_X_SIZE_64
+
+    mov         r6, #0
+LINEAR_X_SIZE_128_LOOP:
+    mov         r7, #0                  @ tiled_offset = 0@
+    mov         r5, r6, asr #5          @ tiled_y_index = i>>5@
+    and         r10, r5, #0x1
+    cmp         r10, #0x1
+    bne         LINEAR_X_SIZE_128_LOOP_EVEN
+LINEAR_X_SIZE_128_LOOP_ODD:
+    sub         r7, r5, #1              @ tiled_offset = tiled_y_index-1@
+    add         r10, r3, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_offset*(temp1>>6)@
+    mul         r7, r7, r10
+    add         r7, r7, #2              @ tiled_offset = tiled_offset+2@
+    mov         r10, r9, asr #5
+    add         r7, r7, r10
+    mov         r7, r7, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r11, r7, #2048
+    b           LINEAR_X_SIZE_128_LOOP_MEMCPY
+
+LINEAR_X_SIZE_128_LOOP_EVEN:
+    add         r11, r4, #31            @ temp2 = ((linear_y_size+31)>>5)<<5@
+    bic         r11, r11, #0x1F
+    add         r10, r3, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_y_index*(temp1>>6)@
+    mul         r7, r5, r10
+    mov         r7, r7, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r12, r6, #32
+    cmp         r12, r11
+    movlt       r10, r9, asr #5
+    movge       r10, r9, asr #6
+    add         r7, r7, r10, lsl #11
+    add         r11, r7, #2048
+
+LINEAR_X_SIZE_128_LOOP_MEMCPY:
+    and         r10, r6, #0x1F
+    mov         r10, r10, lsl #6
+    add         r10, r2, r10
+
+    add         r7, r7, r10             @ tiled_addr = tiled_src+64*(temp1)
+    add         r11, r11, r10           @ tiled_addr1 = tiled_src+64*(temp1)
+    pld         [r11]
+    vld2.8      {q0, q1}, [r7]!
+    pld         [r11, #32]
+    vld2.8      {q2, q3}, [r7]!
+    pld         [r7]
+    vld2.8      {q4, q5}, [r11]!
+    mov         r10, r3, asr #1
+    pld         [r7, #32]
+    vld2.8      {q6, q7}, [r11]!
+    mul         r10, r10, r6
+    pld         [r11]
+    vld2.8      {q8, q9}, [r7]!
+    add         r10, r10, r9, asr #1
+    pld         [r11, #32]
+    vld2.8      {q10, q11}, [r7]!
+    add         r8, r0, r10
+    vld2.8      {q12, q13}, [r11]!
+    mov         r14, r3, asr #1
+    vld2.8      {q14, q15}, [r11]!
+
+    sub         r14, r14, #48
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8]!
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8], r14
+    vst1.8      {q8}, [r8]!
+    vst1.8      {q10}, [r8]!
+    vst1.8      {q12}, [r8]!
+    vst1.8      {q14}, [r8]!
+
+    add         r10, r1, r10
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10]!
+    vst1.8      {q5}, [r10]!
+    vst1.8      {q7}, [r10], r14
+    vst1.8      {q9}, [r10]!
+    vst1.8      {q11}, [r10]!
+    add         r6, #2
+    vst1.8      {q13}, [r10]!
+    cmp         r6, r4
+    vst1.8      {q15}, [r10]!
+
+    blt         LINEAR_X_SIZE_128_LOOP
+
+    add         r9, r9, #128
+
+LINEAR_X_SIZE_64:
+    sub         r10, r3, r9
+    cmp         r10, #64
+    blt         LINEAR_X_SIZE_4
+
+    mov         r5, r9
+    mov         r6, #0
+
+LINEAR_X_SIZE_64_LOOP:
+    bl          GET_TILED_OFFSET
+
+LINEAR_X_SIZE_64_LOOP_MEMCPY:
+    and         r10, r6, #0x1F
+    mov         r14, r3, asr #1
+    mov         r10, r10, lsl #6
+    sub         r14, r14, #16
+    add         r10, r2, r10
+
+    add         r7, r7, r10             @ tiled_addr = tiled_src+64*(temp1)
+    pld         [r7, #64]
+    vld2.8      {q0, q1}, [r7]!
+    mov         r10, r3, asr #1
+    pld         [r7, #64]
+    vld2.8      {q2, q3}, [r7]!
+    mul         r10, r10, r6
+    vld2.8      {q4, q5}, [r7]!
+    add         r10, r10, r9, asr #1
+    vld2.8      {q6, q7}, [r7]!
+    add         r8, r0, r10
+
+    vst1.8      {q0}, [r8]!
+    vst1.8      {q2}, [r8], r14
+    vst1.8      {q4}, [r8]!
+    vst1.8      {q6}, [r8], r14
+
+    add         r10, r1, r10
+    vst1.8      {q1}, [r10]!
+    vst1.8      {q3}, [r10], r14
+    add         r6, #2
+    vst1.8      {q5}, [r10]!
+    cmp         r6, r4
+    vst1.8      {q7}, [r10], r14
+
+    blt         LINEAR_X_SIZE_64_LOOP
+
+    add         r9, r9, #64
+
+LINEAR_X_SIZE_4:
+    cmp         r9, r3
+    beq         RESTORE_REG
+
+    mov         r6, #0                  @ i = 0
+LINEAR_Y_SIZE_4_LOOP:
+
+    mov         r5, r9                  @ j = aligned_x_size
+LINEAR_X_SIZE_4_LOOP:
+
+    bl          GET_TILED_OFFSET
+
+    mov         r11, r3, asr #1         @ temp1 = linear_x_size/2
+    mul         r11, r11, r6            @ temp1 = temp1*(i)
+    add         r11, r11, r5, asr #1    @ temp1 = temp1+j/2
+    mov         r12, r3, asr #1         @ temp2 = linear_x_size/2
+    sub         r12, r12, #1            @ temp2 = linear_x_size-1
+
+    add         r8, r0, r11             @ linear_addr = linear_dest_u+temp1
+    add         r11, r1, r11            @ temp1 = linear_dest_v+temp1
+    add         r7, r2, r7              @ tiled_addr = tiled_src+tiled_addr
+    and         r14, r6, #0x1F          @ temp3 = i&0x1F@
+    mov         r14, r14, lsl #6        @ temp3 = temp3*64
+    add         r7, r7, r14             @ tiled_addr = tiled_addr+temp3
+    and         r14, r5, #0x3F          @ temp3 = j&0x3F
+    add         r7, r7, r14             @ tiled_addr = tiled_addr+temp3
+
+    ldrh        r10, [r7], #2
+    ldrh        r14, [r7], #62
+    strb        r10, [r8], #1
+    mov         r10, r10, asr #8
+    strb        r10, [r11], #1
+    strb        r14, [r8], r12
+    mov         r14, r14, asr #8
+    strb        r14, [r11], r12
+
+    ldrh        r10, [r7], #2
+    ldrh        r14, [r7], #62
+    strb        r10, [r8], #1
+    mov         r10, r10, asr #8
+    strb        r10, [r11], #1
+    strb        r14, [r8], r12
+    mov         r14, r14, asr #8
+    strb        r14, [r11], r12
+
+    add         r5, r5, #4              @ j = j+4
+    cmp         r5, r3                  @ j<linear_x_size
+    blt         LINEAR_X_SIZE_4_LOOP
+
+    add         r6, r6, #2              @ i = i+4
+    cmp         r6, r4                  @ i<linear_y_size
+    blt         LINEAR_Y_SIZE_4_LOOP
+
+RESTORE_REG:
+    ldmfd       sp!, {r4-r12,r15}               @ restore registers
+
+GET_TILED_OFFSET:
+    stmfd       sp!, {r14}
+
+    mov         r12, r6, asr #5         @ temp2 = i>>5
+    mov         r11, r5, asr #6         @ temp1 = j>>6
+
+    and         r14, r12, #0x1          @ if (temp2 & 0x1)
+    cmp         r14, #0x1
+    bne         GET_TILED_OFFSET_EVEN_FORMULA_1
+
+GET_TILED_OFFSET_ODD_FORMULA:
+    sub         r7, r12, #1             @ tiled_addr = temp2-1
+    add         r14, r3, #127           @ temp3 = linear_x_size+127
+    bic         r14, r14, #0x7F         @ temp3 = (temp3 >>7)<<7
+    mov         r14, r14, asr #6        @ temp3 = temp3>>6
+    mul         r7, r7, r14             @ tiled_addr = tiled_addr*temp3
+    add         r7, r7, r11             @ tiled_addr = tiled_addr+temp1
+    add         r7, r7, #2              @ tiled_addr = tiled_addr+2
+    bic         r14, r11, #0x3          @ temp3 = (temp1>>2)<<2
+    add         r7, r7, r14             @ tiled_addr = tiled_addr+temp3
+    mov         r7, r7, lsl #11         @ tiled_addr = tiled_addr<<11
+    b           GET_TILED_OFFSET_RETURN
+
+GET_TILED_OFFSET_EVEN_FORMULA_1:
+    add         r14, r4, #31            @ temp3 = linear_y_size+31
+    bic         r14, r14, #0x1F         @ temp3 = (temp3>>5)<<5
+    sub         r14, r14, #32           @ temp3 = temp3 - 32
+    cmp         r6, r14                 @ if (i<(temp3-32)) {
+    bge         GET_TILED_OFFSET_EVEN_FORMULA_2
+    add         r14, r11, #2            @ temp3 = temp1+2
+    bic         r14, r14, #3            @ temp3 = (temp3>>2)<<2
+    add         r7, r11, r14            @ tiled_addr = temp1+temp3
+    add         r14, r3, #127           @ temp3 = linear_x_size+127
+    bic         r14, r14, #0x7F         @ temp3 = (temp3>>7)<<7
+    mov         r14, r14, asr #6        @ temp3 = temp3>>6
+    mul         r12, r12, r14           @ tiled_y_index = tiled_y_index*temp3
+    add         r7, r7, r12             @ tiled_addr = tiled_addr+tiled_y_index
+    mov         r7, r7, lsl #11         @
+    b           GET_TILED_OFFSET_RETURN
+
+GET_TILED_OFFSET_EVEN_FORMULA_2:
+    add         r14, r3, #127           @ temp3 = linear_x_size+127
+    bic         r14, r14, #0x7F         @ temp3 = (temp3>>7)<<7
+    mov         r14, r14, asr #6        @ temp3 = temp3>>6
+    mul         r7, r12, r14            @ tiled_addr = temp2*temp3
+    add         r7, r7, r11             @ tiled_addr = tiled_addr+temp3
+    mov         r7, r7, lsl #11         @ tiled_addr = tiled_addr<<11@
+
+GET_TILED_OFFSET_RETURN:
+    ldmfd       sp!, {r15}              @ restore registers
+    .fnend
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_nv12t_yuv420_y_neon.s b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_nv12t_yuv420_y_neon.s
new file mode 100644
index 0000000..d71ee17
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_nv12t_yuv420_y_neon.s
@@ -0,0 +1,680 @@
+/*
+ *
+ * Copyright 2011 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    csc_nv12t_yuv420_y_neon.s
+ * @brief   SEC_OMX specific define
+ * @author  ShinWon Lee (shinwon.lee@samsung.com)
+ * @version 1.0
+ * @history
+ *   2011.7.01 : Create
+ */
+
+/*
+ * Converts tiled data to linear.
+ * 1. Y of NV12T to Y of YUV420P
+ * 2. Y of NV12T to Y of YUV420S
+ * 3. UV of NV12T to UV of YUV420S
+ *
+ * @param yuv420_dest
+ *   Y or UV plane address of YUV420[out]
+ *
+ * @param nv12t_src
+ *   Y or UV plane address of NV12T[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_height
+ *   Y: Height of YUV420, UV: Height/2 of YUV420[in]
+ */
+
+    .arch armv7-a
+    .text
+    .global csc_tiled_to_linear
+    .type   csc_tiled_to_linear, %function
+csc_tiled_to_linear:
+    .fnstart
+
+    @r0         linear_dest
+    @r1         tiled_src
+    @r2         linear_x_size
+    @r3         linear_y_size
+    @r4         j
+    @r5         i
+    @r6         tiled_addr
+    @r7         linear_addr
+    @r8         aligned_x_size
+    @r9         aligned_y_size
+    @r10        temp1
+    @r11        temp2
+    @r12        temp3
+    @r14        temp4
+
+    stmfd       sp!, {r4-r12,r14}               @ backup registers
+
+    mov         r8, #0
+    cmp         r2, #1024
+    blt         LINEAR_X_SIZE_512
+
+LINEAR_X_SIZE_1024:
+
+    mov         r5, #0
+LINEAR_X_SIZE_1024_LOOP:
+    mov         r6, #0                  @ tiled_offset = 0@
+    mov         r4, r5, asr #5          @ tiled_y_index = i>>5@
+    and         r10, r4, #0x1
+    cmp         r10, #0x1
+    bne         LINEAR_X_SIZE_1024_LOOP_EVEN
+LINEAR_X_SIZE_1024_LOOP_ODD:
+    sub         r6, r4, #1              @ tiled_offset = tiled_y_index-1@
+    add         r10, r2, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_offset*(temp1>>6)@
+    mul         r6, r6, r10
+    mov         r4, #8
+    mov         r4, r4, lsl #11
+    sub         r4, r4, #32
+    add         r6, r6, #2              @ tiled_offset = tiled_offset+2@
+    mov         r6, r6, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r11, r6, #2048
+    add         r12, r6, #4096
+    add         r14, r6, #6144
+    b           LINEAR_X_SIZE_1024_LOOP_MEMCPY
+
+LINEAR_X_SIZE_1024_LOOP_EVEN:
+    add         r11, r3, #31            @ temp2 = ((linear_y_size+31)>>5)<<5@
+    bic         r11, r11, #0x1F
+    add         r10, r2, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_y_index*(temp1>>6)@
+    mul         r6, r4, r10
+    add         r12, r5, #32
+    cmp         r12, r11
+    mov         r6, r6, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r11, r6, #2048
+    movlt       r4, #8
+    addlt       r12, r6, #12288
+    addlt       r14, r6, #14336
+    movge       r4, #4
+    addge       r12, r6, #4096
+    addge       r14, r6, #6144
+    mov         r4, r4, lsl #11
+    sub         r4, r4, #32
+
+LINEAR_X_SIZE_1024_LOOP_MEMCPY:
+    and         r10, r5, #0x1F
+    mov         r10, r10, lsl #6
+    add         r10, r1, r10
+
+    add         r6, r6, r10             @ tiled_addr = tiled_src+64*(temp1)
+    add         r11, r11, r10           @ tiled_addr1 = tiled_src+64*(temp1)
+    pld         [r11]
+    vld1.8      {q0, q1}, [r6]!
+    pld         [r11, #32]
+    add         r12, r12, r10           @ tiled_addr2 = tiled_src+64*(temp1)
+    vld1.8      {q2, q3}, [r6], r4
+    pld         [r12]
+    vld1.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    add         r14, r14, r10           @ tiled_addr3 = tiled_src+64*(temp1)
+    vld1.8      {q6, q7}, [r11], r4
+    pld         [r14]
+    vld1.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    mul         r7, r2, r5
+    vld1.8      {q10, q11}, [r12], r4
+    add         r7, r7, r0
+    vld1.8      {q12, q13}, [r14]!
+    vld1.8      {q14, q15}, [r14], r4
+
+    vst1.8      {q0, q1}, [r7]!
+    vst1.8      {q2, q3}, [r7]!
+    vst1.8      {q4, q5}, [r7]!
+    vst1.8      {q6, q7}, [r7]!
+    vst1.8      {q8, q9}, [r7]!
+    vst1.8      {q10, q11}, [r7]!
+    pld         [r6]
+    vst1.8      {q12, q13}, [r7]!
+    pld         [r6, #32]
+    vst1.8      {q14, q15}, [r7]!
+
+    pld         [r11]
+    vld1.8      {q0, q1}, [r6]!
+    pld         [r11, #32]
+    vld1.8      {q2, q3}, [r6], r4
+
+    pld         [r12]
+    vld1.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    vld1.8      {q6, q7}, [r11], r4
+    pld         [r14]
+    vld1.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    vld1.8      {q10, q11}, [r12], r4
+    vld1.8      {q12, q13}, [r14]!
+    vld1.8      {q14, q15}, [r14], r4
+
+    vst1.8      {q0, q1}, [r7]!
+    vst1.8      {q2, q3}, [r7]!
+    vst1.8      {q4, q5}, [r7]!
+    vst1.8      {q6, q7}, [r7]!
+    vst1.8      {q8, q9}, [r7]!
+    vst1.8      {q10, q11}, [r7]!
+    pld         [r6]
+    vst1.8      {q12, q13}, [r7]!
+    pld         [r6, #32]
+    vst1.8      {q14, q15}, [r7]!
+
+    pld         [r11]
+    vld1.8      {q0, q1}, [r6]!
+    pld         [r11, #32]
+    vld1.8      {q2, q3}, [r6], r4
+    pld         [r12]
+    vld1.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    vld1.8      {q6, q7}, [r11], r4
+    pld         [r14]
+    vld1.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    vld1.8      {q10, q11}, [r12], r4
+    vld1.8      {q12, q13}, [r14]!
+    vld1.8      {q14, q15}, [r14], r4
+
+    vst1.8      {q0, q1}, [r7]!
+    vst1.8      {q2, q3}, [r7]!
+    vst1.8      {q4, q5}, [r7]!
+    vst1.8      {q6, q7}, [r7]!
+    vst1.8      {q8, q9}, [r7]!
+    vst1.8      {q10, q11}, [r7]!
+    pld         [r6]
+    vst1.8      {q12, q13}, [r7]!
+    pld         [r6, #32]
+    vst1.8      {q14, q15}, [r7]!
+
+    pld         [r11]
+    vld1.8      {q0, q1}, [r6]!
+    pld         [r11, #32]
+    vld1.8      {q2, q3}, [r6]
+    pld         [r12]
+    vld1.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    vld1.8      {q6, q7}, [r11]
+    pld         [r14]
+    vld1.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    vld1.8      {q10, q11}, [r12]
+    vld1.8      {q12, q13}, [r14]!
+    vld1.8      {q14, q15}, [r14]
+
+    vst1.8      {q0, q1}, [r7]!
+    vst1.8      {q2, q3}, [r7]!
+    vst1.8      {q4, q5}, [r7]!
+    vst1.8      {q6, q7}, [r7]!
+    vst1.8      {q8, q9}, [r7]!
+    vst1.8      {q10, q11}, [r7]!
+    add         r5, #1
+    vst1.8      {q12, q13}, [r7]!
+    cmp         r5, r3
+    vst1.8      {q14, q15}, [r7]!
+
+    blt         LINEAR_X_SIZE_1024_LOOP
+
+    mov         r8, #1024
+
+LINEAR_X_SIZE_512:
+
+    sub         r14, r2, r8
+    cmp         r14, #512
+    blt         LINEAR_X_SIZE_256
+
+    mov         r5, #0
+LINEAR_X_SIZE_512_LOOP:
+    mov         r6, #0
+    mov         r4, r5, asr #5          @ tiled_y_index = i>>5
+    and         r10, r4, #0x1
+    cmp         r10, #0x1
+    bne         LINEAR_X_SIZE_512_LOOP_EVEN
+
+LINEAR_X_SIZE_512_LOOP_ODD:
+    sub         r6, r4, #1
+    add         r10, r2, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_offset*(temp1>>6)@
+    mul         r6, r6, r10
+    mov         r4, #8
+    mov         r4, r4, lsl #11
+    sub         r4, r4, #32
+    add         r6, r6, #2              @ tiled_offset = tiled_offset+2@
+    mov         r10, r8, asr #5         @ temp1 = aligned_x_size>>5@
+    add         r6, r6, r10             @ tiled_offset = tiled_offset+temp1@
+    mov         r6, r6, lsl #11
+    add         r11, r6, #2048
+    add         r12, r6, #4096
+    add         r14, r6, #6144
+    b           LINEAR_X_SIZE_512_LOOP_MEMCPY
+
+LINEAR_X_SIZE_512_LOOP_EVEN:
+    add         r11, r3, #31            @ temp2 = ((linear_y_size+31)>>5)<<5@
+    bic         r11, r11, #0x1F
+    add         r10, r2, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_y_index*(temp1>>6)@
+    mul         r6, r4, r10
+    add         r12, r5, #32
+    cmp         r12, r11
+    mov         r6, r6, lsl #11         @ tiled_offset = tiled_offset<<11@
+    movlt       r4, #8
+    movlt       r10, r8, asr #5         @ temp1 = aligned_x_size>>5@
+    movge       r10, r8, asr #6         @ temp1 = aligned_x_size>>6@
+    add         r6, r6, r10, lsl #11    @ tiled_offset = tiled_offset+(temp1<<11)@
+    add         r11, r6, #2048
+    addlt       r12, r6, #12288
+    addlt       r14, r6, #14336
+    movge       r4, #4
+    addge       r12, r6, #4096
+    addge       r14, r6, #6144
+    mov         r4, r4, lsl #11
+    sub         r4, r4, #32
+
+LINEAR_X_SIZE_512_LOOP_MEMCPY:
+    and         r10, r5, #0x1F
+    mov         r10, r10, lsl #6
+    add         r10, r1, r10
+
+    add         r6, r6, r10             @ tiled_addr = tiled_src+64*(temp1)
+    add         r11, r11, r10           @ tiled_addr1 = tiled_src+64*(temp1)
+    pld         [r11]
+    vld1.8      {q0, q1}, [r6]!
+    pld         [r11, #32]
+    add         r12, r12, r10           @ tiled_addr2 = tiled_src+64*(temp1)
+    vld1.8      {q2, q3}, [r6], r4
+    pld         [r12]
+    vld1.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    add         r14, r14, r10           @ tiled_addr3 = tiled_src+64*(temp1)
+    vld1.8      {q6, q7}, [r11], r4
+    pld         [r14]
+    vld1.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    mul         r7, r2, r5
+    vld1.8      {q10, q11}, [r12], r4
+    add         r7, r7, r8
+    vld1.8      {q12, q13}, [r14]!
+    vld1.8      {q14, q15}, [r14], r4
+
+    add         r7, r7, r0
+    vst1.8      {q0, q1}, [r7]!
+    vst1.8      {q2, q3}, [r7]!
+    vst1.8      {q4, q5}, [r7]!
+    vst1.8      {q6, q7}, [r7]!
+    vst1.8      {q8, q9}, [r7]!
+    vst1.8      {q10, q11}, [r7]!
+    pld         [r6]
+    vst1.8      {q12, q13}, [r7]!
+    pld         [r6, #32]
+    vst1.8      {q14, q15}, [r7]!
+
+    pld         [r11]
+    vld1.8      {q0, q1}, [r6]!
+    pld         [r11, #32]
+    vld1.8      {q2, q3}, [r6], r4
+    pld         [r12]
+    vld1.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    vld1.8      {q6, q7}, [r11], r4
+    pld         [r14]
+    vld1.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    vld1.8      {q10, q11}, [r12], r4
+    vld1.8      {q12, q13}, [r14]!
+    vld1.8      {q14, q15}, [r14], r4
+
+    vst1.8      {q0, q1}, [r7]!
+    vst1.8      {q2, q3}, [r7]!
+    vst1.8      {q4, q5}, [r7]!
+    vst1.8      {q6, q7}, [r7]!
+    vst1.8      {q8, q9}, [r7]!
+    vst1.8      {q10, q11}, [r7]!
+    add         r5, #1
+    vst1.8      {q12, q13}, [r7]!
+    cmp         r5, r3
+    vst1.8      {q14, q15}, [r7]!
+
+    blt         LINEAR_X_SIZE_512_LOOP
+
+    add         r8, r8, #512
+
+LINEAR_X_SIZE_256:
+
+    sub         r14, r2, r8
+    cmp         r14, #256
+    blt         LINEAR_X_SIZE_128
+
+    mov         r5, #0
+LINEAR_X_SIZE_256_LOOP:
+    mov         r6, #0
+    mov         r4, r5, asr #5          @ tiled_y_index = i>>5
+    and         r10, r4, #0x1
+    cmp         r10, #0x1
+    bne         LINEAR_X_SIZE_256_LOOP_EVEN
+
+LINEAR_X_SIZE_256_LOOP_ODD:
+    sub         r6, r4, #1
+    add         r10, r2, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_offset*(temp1>>6)@
+    mul         r6, r6, r10
+    add         r6, r6, #2              @ tiled_offset = tiled_offset+2@
+    mov         r10, r8, asr #5         @ temp1 = aligned_x_size>>5@
+    add         r6, r6, r10             @ tiled_offset = tiled_offset+temp1@
+    mov         r6, r6, lsl #11
+    add         r11, r6, #2048
+    add         r12, r6, #4096
+    add         r14, r6, #6144
+    b           LINEAR_X_SIZE_256_LOOP_MEMCPY
+
+LINEAR_X_SIZE_256_LOOP_EVEN:
+    add         r11, r3, #31            @ temp2 = ((linear_y_size+31)>>5)<<5@
+    bic         r11, r11, #0x1F
+    add         r10, r2, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_y_index*(temp1>>6)@
+    mul         r6, r4, r10
+    mov         r6, r6, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r12, r5, #32
+    cmp         r12, r11
+    movlt       r10, r8, asr #5         @ temp1 = aligned_x_size>>5@
+    movge       r10, r8, asr #6         @ temp1 = aligned_x_size>>6@
+    add         r6, r6, r10, lsl #11    @ tiled_offset = tiled_offset+(temp1<<11)@
+    add         r11, r6, #2048
+    addlt       r12, r6, #12288
+    addlt       r14, r6, #14336
+    addge       r12, r6, #4096
+    addge       r14, r6, #6144
+
+LINEAR_X_SIZE_256_LOOP_MEMCPY:
+    and         r10, r5, #0x1F
+    mov         r10, r10, lsl #6
+    add         r10, r1, r10
+
+    add         r6, r6, r10             @ tiled_addr = tiled_src+64*(temp1)
+    add         r11, r11, r10           @ tiled_addr1 = tiled_src+64*(temp1)
+    pld         [r11]
+    vld1.8      {q0, q1}, [r6]!
+    pld         [r11, #32]
+    add         r12, r12, r10           @ tiled_addr2 = tiled_src+64*(temp1)
+    vld1.8      {q2, q3}, [r6]
+    pld         [r12]
+    vld1.8      {q4, q5}, [r11]!
+    pld         [r12, #32]
+    add         r14, r14, r10           @ tiled_addr3 = tiled_src+64*(temp1)
+    vld1.8      {q6, q7}, [r11]
+    pld         [r14]
+    mul         r7, r2, r5
+    vld1.8      {q8, q9}, [r12]!
+    pld         [r14, #32]
+    add         r7, r7, r8
+    vld1.8      {q10, q11}, [r12]
+    add         r7, r7, r0
+    vld1.8      {q12, q13}, [r14]!
+    vld1.8      {q14, q15}, [r14]
+
+    vst1.8      {q0, q1}, [r7]!
+    vst1.8      {q2, q3}, [r7]!
+    vst1.8      {q4, q5}, [r7]!
+    vst1.8      {q6, q7}, [r7]!
+    vst1.8      {q8, q9}, [r7]!
+    vst1.8      {q10, q11}, [r7]!
+    add         r5, #1
+    vst1.8      {q12, q13}, [r7]!
+    cmp         r5, r3
+    vst1.8      {q14, q15}, [r7]!
+
+    blt         LINEAR_X_SIZE_256_LOOP
+
+    add         r8, r8, #256
+
+LINEAR_X_SIZE_128:
+
+    sub         r14, r2, r8
+    cmp         r14, #128
+    blt         LINEAR_X_SIZE_64
+
+    mov         r5, #0
+LINEAR_X_SIZE_128_LOOP:
+    mov         r6, #0
+    mov         r4, r5, asr #5          @ tiled_y_index = i>>5
+    and         r10, r4, #0x1
+    cmp         r10, #0x1
+    bne         LINEAR_X_SIZE_128_LOOP_EVEN
+
+LINEAR_X_SIZE_128_LOOP_ODD:
+    sub         r6, r4, #1
+    add         r10, r2, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_offset*(temp1>>6)@
+    mul         r6, r6, r10
+    add         r6, r6, #2              @ tiled_offset = tiled_offset+2@
+    mov         r10, r8, asr #5         @ temp1 = aligned_x_size>>5@
+    add         r6, r6, r10             @ tiled_offset = tiled_offset+temp1@
+    mov         r6, r6, lsl #11
+    add         r11, r6, #2048
+    b           LINEAR_X_SIZE_128_LOOP_MEMCPY
+
+LINEAR_X_SIZE_128_LOOP_EVEN:
+    add         r11, r3, #31            @ temp2 = ((linear_y_size+31)>>5)<<5@
+    bic         r11, r11, #0x1F
+    add         r10, r2, #127           @ temp1 = ((linear_x_size+127)>>7)<<7@
+    bic         r10, #0x7F
+    mov         r10, r10, asr #6        @ tiled_offset = tiled_y_index*(temp1>>6)@
+    mul         r6, r4, r10
+    mov         r6, r6, lsl #11         @ tiled_offset = tiled_offset<<11@
+    add         r12, r5, #32
+    cmp         r12, r11
+    movlt       r10, r8, asr #5         @ temp1 = aligned_x_size>>5@
+    movge       r10, r8, asr #6         @ temp1 = aligned_x_size>>6@
+    add         r6, r6, r10, lsl #11    @ tiled_offset = tiled_offset+(temp1<<11)@
+    add         r11, r6, #2048
+
+LINEAR_X_SIZE_128_LOOP_MEMCPY:
+    and         r10, r5, #0x1F
+    mov         r10, r10, lsl #6
+    add         r10, r1, r10
+
+    add         r6, r6, r10             @ tiled_addr = tiled_src+64*(temp1)
+    add         r11, r11, r10           @ tiled_addr1 = tiled_src+64*(temp1)
+    pld         [r6, #64]
+    vld1.8      {q0, q1}, [r6]!
+    pld         [r6, #64]
+    vld1.8      {q2, q3}, [r6]!
+    mul         r7, r2, r5
+    pld         [r11]
+    vld1.8      {q4, q5}, [r6]!
+    add         r7, r7, r8
+    pld         [r11, #32]
+    vld1.8      {q6, q7}, [r6]
+    add         r7, r7, r0
+    pld         [r11, #64]
+    vld1.8      {q8, q9}, [r11]!
+    pld         [r11, #64]
+    vld1.8      {q10, q11}, [r11]!
+    vld1.8      {q12, q13}, [r11]!
+    vld1.8      {q14, q15}, [r11]
+
+    sub         r9, r2, #96
+    vst1.8      {q0, q1}, [r7]!
+    vst1.8      {q2, q3}, [r7]!
+    vst1.8      {q8, q9}, [r7]!
+    vst1.8      {q10, q11}, [r7], r9
+    vst1.8      {q4, q5}, [r7]!
+    vst1.8      {q6, q7}, [r7]!
+    add         r5, #2
+    vst1.8      {q12, q13}, [r7]!
+    cmp         r5, r3
+    vst1.8      {q14, q15}, [r7]
+
+    blt         LINEAR_X_SIZE_128_LOOP
+
+    add         r8, r8, #128
+
+LINEAR_X_SIZE_64:
+
+    sub         r14, r2, r8
+    cmp         r14, #64
+    blt         LINEAR_X_SIZE_4
+
+    mov         r5, #0
+    mov         r4, r8
+
+LINEAR_X_SIZE_64_LOOP:
+
+    bl          GET_TILED_OFFSET
+
+    add         r6, r1, r6              @ tiled_addr = tiled_src+tiled_addr
+    and         r11, r5, #0x1F          @ temp2 = i&0x1F
+    mov         r11, r11, lsl #6        @ temp2 = 64*temp2
+    add         r6, r6, r11             @ tiled_addr = tiled_addr+temp2
+
+    pld         [r6, #64]
+    vld1.8      {q0, q1}, [r6]!         @ store {tiled_addr}
+    mul         r10, r2, r5             @ temp1 = linear_x_size*(i)
+    pld         [r6, #64]
+    vld1.8      {q2, q3}, [r6]!
+    pld         [r6, #64]
+    vld1.8      {q4, q5}, [r6]!         @ store {tiled_addr+64*1}
+    pld         [r6, #64]
+    vld1.8      {q6, q7}, [r6]!
+    pld         [r6, #64]
+    vld1.8      {q8, q9}, [r6]!         @ store {tiled_addr+64*2}
+    pld         [r6, #64]
+    vld1.8      {q10, q11}, [r6]!
+    add         r7, r0, r4              @ linear_addr = linear_dest+j
+    vld1.8      {q12, q13}, [r6]!       @ store {tiled_addr+64*3}
+    add         r7, r7, r10             @ linear_addr = linear_addr+temp1
+    vld1.8      {q14, q15}, [r6]!
+    sub         r10, r2, #32            @ temp1 = linear_x_size-32
+
+    vst1.8      {q0, q1}, [r7]!         @ load {linear_src, 64}
+    vst1.8      {q2, q3}, [r7], r10
+    vst1.8      {q4, q5}, [r7]!         @ load {linear_src+linear_x_size*1, 64}
+    vst1.8      {q6, q7}, [r7], r10
+    vst1.8      {q8, q9}, [r7]!         @ load {linear_src+linear_x_size*2, 64}
+    vst1.8      {q10, q11}, [r7], r10
+    add         r5, #4
+    vst1.8      {q12, q13}, [r7]!       @ load {linear_src+linear_x_size*3, 64}
+    cmp         r5, r3
+    vst1.8      {q14, q15}, [r7], r10
+
+    blt         LINEAR_X_SIZE_64_LOOP
+
+    add         r8, r8, #64
+
+LINEAR_X_SIZE_4:
+    cmp         r8, r2
+    beq         RESTORE_REG
+
+    mov         r5, #0                  @ i = 0
+LINEAR_Y_SIZE_4_LOOP:
+
+    mov         r4, r8                  @ j = aligned_x_size
+LINEAR_X_SIZE_4_LOOP:
+
+    bl          GET_TILED_OFFSET
+
+    and         r10, r5, #0x1F           @ temp1 = i&0x1F
+    and         r11, r4, #0x3F           @ temp2 = j&0x3F
+
+    add         r6, r6, r1
+    add         r6, r6, r11
+    add         r6, r6, r10, lsl #6
+
+    ldr         r10, [r6], #64
+    add         r7, r0, r4
+    ldr         r11, [r6], #64
+    mul         r9, r2, r5
+    ldr         r12, [r6], #64
+    add         r7, r7, r9
+    ldr         r14, [r6], #64
+
+    str         r10, [r7], r2
+    str         r11, [r7], r2
+    str         r12, [r7], r2
+    str         r14, [r7], r2
+
+    add         r4, r4, #4              @ j = j+4
+    cmp         r4, r2                  @ j<linear_x_size
+    blt         LINEAR_X_SIZE_4_LOOP
+
+    add         r5, r5, #4              @ i = i+4
+    cmp         r5, r3                  @ i<linear_y_size
+    blt         LINEAR_Y_SIZE_4_LOOP
+
+RESTORE_REG:
+    ldmfd       sp!, {r4-r12,r15}               @ restore registers
+
+GET_TILED_OFFSET:
+
+    mov         r11, r5, asr #5                 @ temp2 = i>>5
+    mov         r10, r4, asr #6                 @ temp1 = j>>6
+
+    and         r12, r11, #0x1                  @ if (temp2 & 0x1)
+    cmp         r12, #0x1
+    bne         GET_TILED_OFFSET_EVEN_FORMULA_1
+
+GET_TILED_OFFSET_ODD_FORMULA:
+    sub         r6, r11, #1                     @ tiled_addr = temp2-1
+    add         r12, r2, #127                   @ temp3 = linear_x_size+127
+    bic         r12, r12, #0x7F                 @ temp3 = (temp3 >>7)<<7
+    mov         r12, r12, asr #6                @ temp3 = temp3>>6
+    mul         r6, r6, r12                     @ tiled_addr = tiled_addr*temp3
+    add         r6, r6, r10                     @ tiled_addr = tiled_addr+temp1
+    add         r6, r6, #2                      @ tiled_addr = tiled_addr+2
+    bic         r12, r10, #0x3                  @ temp3 = (temp1>>2)<<2
+    add         r6, r6, r12                     @ tiled_addr = tiled_addr+temp3
+    mov         r6, r6, lsl #11                 @ tiled_addr = tiled_addr<<11
+    b           GET_TILED_OFFSET_RETURN
+
+GET_TILED_OFFSET_EVEN_FORMULA_1:
+    add         r12, r3, #31                    @ temp3 = linear_y_size+31
+    bic         r12, r12, #0x1F                 @ temp3 = (temp3>>5)<<5
+    sub         r12, r12, #32                   @ temp3 = temp3 - 32
+    cmp         r5, r12                         @ if (i<(temp3-32)) {
+    bge         GET_TILED_OFFSET_EVEN_FORMULA_2
+    add         r12, r10, #2                    @ temp3 = temp1+2
+    bic         r12, r12, #3                    @ temp3 = (temp3>>2)<<2
+    add         r6, r10, r12                    @ tiled_addr = temp1+temp3
+    add         r12, r2, #127                   @ temp3 = linear_x_size+127
+    bic         r12, r12, #0x7F                 @ temp3 = (temp3>>7)<<7
+    mov         r12, r12, asr #6                @ temp3 = temp3>>6
+    mul         r11, r11, r12                   @ tiled_y_index = tiled_y_index*temp3
+    add         r6, r6, r11                     @ tiled_addr = tiled_addr+tiled_y_index
+    mov         r6, r6, lsl #11                 @
+    b           GET_TILED_OFFSET_RETURN
+
+GET_TILED_OFFSET_EVEN_FORMULA_2:
+    add         r12, r2, #127                   @ temp3 = linear_x_size+127
+    bic         r12, r12, #0x7F                 @ temp3 = (temp3>>7)<<7
+    mov         r12, r12, asr #6                @ temp3 = temp3>>6
+    mul         r6, r11, r12                    @ tiled_addr = temp2*temp3
+    add         r6, r6, r10                     @ tiled_addr = tiled_addr+temp3
+    mov         r6, r6, lsl #11                 @ tiled_addr = tiled_addr<<11@
+
+GET_TILED_OFFSET_RETURN:
+    mov         pc, lr
+    .fnend
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_yuv420_nv12t_uv_neon.s b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_yuv420_nv12t_uv_neon.s
new file mode 100644
index 0000000..dd2c879
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_yuv420_nv12t_uv_neon.s
@@ -0,0 +1,573 @@
+/*
+ *
+ * Copyright 2011 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    csc_yuv420_nv12t_uv_neon.s
+ * @brief   SEC_OMX specific define
+ * @author  ShinWon Lee (shinwon.lee@samsung.com)
+ * @version 1.0
+ * @history
+ *   2011.7.01 : Create
+ */
+
+/*
+ * Converts and Interleaves linear to tiled
+ * 1. UV of YUV420P to UV of NV12T
+ *
+ * @param nv12t_uv_dest
+ *   UV plane address of NV12T[out]
+ *
+ * @param yuv420p_u_src
+ *   U plane address of YUV420P[in]
+ *
+ * @param yuv420p_v_src
+ *   V plane address of YUV420P[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_uv_height
+ *   Height/2 of YUV420[in]
+ */
+
+    .arch armv7-a
+    .text
+    .global csc_linear_to_tiled_interleave
+    .type   csc_linear_to_tiled_interleave, %function
+csc_linear_to_tiled_interleave:
+    .fnstart
+
+    @r0     tiled_dest
+    @r1     linear_src_u
+    @r2     linear_src_v
+    @r3     linear_x_size
+    @r4     linear_y_size
+    @r5     j
+    @r6     i
+    @r7     tiled_addr
+    @r8     linear_addr
+    @r9     aligned_x_size
+    @r10    aligned_y_size
+    @r11    temp1
+    @r12    temp2
+    @r14    temp3
+
+    stmfd       sp!, {r4-r12,r14}       @ backup registers
+
+    ldr         r4, [sp, #40]           @ load linear_y_size to r4
+
+    bic         r10, r4, #0x1F          @ aligned_y_size = (linear_y_size>>5)<<5
+    bic         r9, r3, #0x3F           @ aligned_x_size = (linear_x_size>>6)<<6
+
+    mov         r6, #0                  @ i = 0
+LOOP_ALIGNED_Y_SIZE:
+
+    mov         r5, #0                  @ j = 0
+LOOP_ALIGNED_X_SIZE:
+
+    bl          GET_TILED_OFFSET
+
+    mov         r11, r3, asr #1         @ temp1 = linear_x_size/2
+    mul         r11, r11, r6            @ temp1 = temp1*(i)
+    add         r11, r11, r5, asr #1    @ temp1 = temp1+j/2
+    mov         r12, r3, asr #1         @ temp2 = linear_x_size/2
+    sub         r12, r12, #16           @ temp2 = linear_x_size-16
+
+    add         r8, r1, r11             @ linear_addr = linear_src_u+temp1
+    add         r11, r2, r11            @ temp1 = linear_src_v+temp1
+    add         r7, r0, r7              @ tiled_addr = tiled_dest+tiled_addr
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!
+    vst2.8      {q14, q15}, [r7]!
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!
+    vst2.8      {q14, q15}, [r7]!
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!
+    vst2.8      {q14, q15}, [r7]!
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!
+    vst2.8      {q14, q15}, [r7]!
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!
+    vst2.8      {q14, q15}, [r7]!
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!
+    vst2.8      {q14, q15}, [r7]!
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!
+    vst2.8      {q14, q15}, [r7]!
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!
+    vst2.8      {q14, q15}, [r7]!
+
+    add         r5, r5, #64             @ j = j+64
+    cmp         r5, r9                  @ j<aligned_x_size
+    blt         LOOP_ALIGNED_X_SIZE
+
+    add         r6, r6, #32             @ i = i+32
+    cmp         r6, r10                 @ i<aligned_y_size
+    blt         LOOP_ALIGNED_Y_SIZE
+
+    ldr         r4, [sp, #40]           @ load linear_y_size to r4
+    cmp         r6, r4
+    beq         LOOP_LINEAR_Y_SIZE_2_START
+
+LOOP_LINEAR_Y_SIZE_1:
+
+    mov         r5, #0                  @ j = 0
+LOOP_ALIGNED_X_SIZE_1:
+
+    bl          GET_TILED_OFFSET
+
+    mov         r11, r3, asr #1         @ temp1 = linear_x_size/2
+    mul         r11, r11, r6            @ temp1 = temp1*(i)
+    add         r11, r11, r5, asr #1    @ temp1 = temp1+j/2
+    mov         r12, r3, asr #1         @ temp2 = linear_x_size/2
+    sub         r12, r12, #16           @ temp2 = linear_x_size-16
+
+    add         r8, r1, r11             @ linear_addr = linear_src_u+temp1
+    add         r11, r2, r11            @ temp1 = linear_src_v+temp1
+    add         r7, r0, r7              @ tiled_addr = tiled_dest+tiled_addr
+    and         r14, r6, #0x1F          @ temp3 = i&0x1F@
+    mov         r14, r14, lsl #6        @ temp3 = temp3*64
+    add         r7, r7, r14             @ tiled_addr = tiled_addr+temp3
+
+    pld         [r8, r3]
+    vld1.8      {q0}, [r8]!
+    vld1.8      {q2}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q1}, [r11]!
+    vld1.8      {q3}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q4}, [r8]!
+    vld1.8      {q6}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q5}, [r11]!
+    vld1.8      {q7}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q8}, [r8]!
+    vld1.8      {q10}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q9}, [r11]!
+    vld1.8      {q11}, [r11], r12
+    pld         [r8, r3]
+    vld1.8      {q12}, [r8]!
+    vld1.8      {q14}, [r8], r12
+    pld         [r11, r3]
+    vld1.8      {q13}, [r11]!
+    vld1.8      {q15}, [r11], r12
+
+    vst2.8      {q0, q1}, [r7]!         @ store {tiled_addr}
+    vst2.8      {q2, q3}, [r7]!
+    vst2.8      {q4, q5}, [r7]!         @ store {tiled_addr+64*1}
+    vst2.8      {q6, q7}, [r7]!
+    vst2.8      {q8, q9}, [r7]!         @ store {tiled_addr+64*2}
+    vst2.8      {q10, q11}, [r7]!
+    vst2.8      {q12, q13}, [r7]!       @ store {tiled_addr+64*3}
+    vst2.8      {q14, q15}, [r7]!
+
+    add         r5, r5, #64             @ j = j+64
+    cmp         r5, r9                  @ j<aligned_x_size
+    blt         LOOP_ALIGNED_X_SIZE_1
+
+    add         r6, r6, #4              @ i = i+4
+    cmp         r6, r4                  @ i<linear_y_size
+    blt         LOOP_LINEAR_Y_SIZE_1
+
+LOOP_LINEAR_Y_SIZE_2_START:
+    cmp         r5, r3
+    beq         RESTORE_REG
+
+    mov         r6, #0                  @ i = 0
+LOOP_LINEAR_Y_SIZE_2:
+
+    mov         r5, r9                  @ j = aligned_x_size
+LOOP_LINEAR_X_SIZE_2:
+
+    bl          GET_TILED_OFFSET
+
+    mov         r11, r3, asr #1         @ temp1 = linear_x_size/2
+    mul         r11, r11, r6            @ temp1 = temp1*(i)
+    add         r11, r11, r5, asr #1    @ temp1 = temp1+j/2
+    mov         r12, r3, asr #1         @ temp2 = linear_x_size/2
+    sub         r12, r12, #1            @ temp2 = linear_x_size-1
+
+    add         r8, r1, r11             @ linear_addr = linear_src_u+temp1
+    add         r11, r2, r11            @ temp1 = linear_src_v+temp1
+    add         r7, r0, r7              @ tiled_addr = tiled_dest+tiled_addr
+    and         r14, r6, #0x1F          @ temp3 = i&0x1F@
+    mov         r14, r14, lsl #6        @ temp3 = temp3*64
+    add         r7, r7, r14             @ tiled_addr = tiled_addr+temp3
+    and         r14, r5, #0x3F          @ temp3 = j&0x3F
+    add         r7, r7, r14             @ tiled_addr = tiled_addr+temp3
+
+    ldrb        r10, [r8], #1
+    ldrb        r14, [r11], #1
+    mov         r14, r14, lsl #8
+    orr         r10, r10, r14
+    strh        r10, [r7], #2
+    ldrb        r10, [r8], r12
+    ldrb        r14, [r11], r12
+    mov         r14, r14, lsl #8
+    orr         r10, r10, r14
+    strh        r10, [r7], #62
+
+    ldrb        r10, [r8], #1
+    ldrb        r14, [r11], #1
+    mov         r14, r14, lsl #8
+    orr         r10, r10, r14
+    strh        r10, [r7], #2
+    ldrb        r10, [r8], r12
+    ldrb        r14, [r11], r12
+    mov         r14, r14, lsl #8
+    orr         r10, r10, r14
+    strh        r10, [r7], #62
+
+    ldrb        r10, [r8], #1
+    ldrb        r14, [r11], #1
+    mov         r14, r14, lsl #8
+    orr         r10, r10, r14
+    strh        r10, [r7], #2
+    ldrb        r10, [r8], r12
+    ldrb        r14, [r11], r12
+    mov         r14, r14, lsl #8
+    orr         r10, r10, r14
+    strh        r10, [r7], #62
+
+    ldrb        r10, [r8], #1
+    ldrb        r14, [r11], #1
+    mov         r14, r14, lsl #8
+    orr         r10, r10, r14
+    strh        r10, [r7], #2
+    ldrb        r10, [r8], r12
+    ldrb        r14, [r11], r12
+    mov         r14, r14, lsl #8
+    orr         r10, r10, r14
+    strh        r10, [r7], #62
+
+    add         r5, r5, #4              @ j = j+4
+    cmp         r5, r3                  @ j<linear_x_size
+    blt         LOOP_LINEAR_X_SIZE_2
+
+    add         r6, r6, #4              @ i = i+4
+    cmp         r6, r4                  @ i<linear_y_size
+    blt         LOOP_LINEAR_Y_SIZE_2
+
+RESTORE_REG:
+    ldmfd       sp!, {r4-r12,r15}       @ restore registers
+
+GET_TILED_OFFSET:
+    stmfd       sp!, {r14}
+
+    mov         r12, r6, asr #5         @ temp2 = i>>5
+    mov         r11, r5, asr #6         @ temp1 = j>>6
+
+    and         r14, r12, #0x1          @ if (temp2 & 0x1)
+    cmp         r14, #0x1
+    bne         GET_TILED_OFFSET_EVEN_FORMULA_1
+
+GET_TILED_OFFSET_ODD_FORMULA:
+    sub         r7, r12, #1             @ tiled_addr = temp2-1
+    add         r14, r3, #127           @ temp3 = linear_x_size+127
+    bic         r14, r14, #0x7F         @ temp3 = (temp3 >>7)<<7
+    mov         r14, r14, asr #6        @ temp3 = temp3>>6
+    mul         r7, r7, r14             @ tiled_addr = tiled_addr*temp3
+    add         r7, r7, r11             @ tiled_addr = tiled_addr+temp1
+    add         r7, r7, #2              @ tiled_addr = tiled_addr+2
+    bic         r14, r11, #0x3          @ temp3 = (temp1>>2)<<2
+    add         r7, r7, r14             @ tiled_addr = tiled_addr+temp3
+    mov         r7, r7, lsl #11         @ tiled_addr = tiled_addr<<11
+    b           GET_TILED_OFFSET_RETURN
+
+GET_TILED_OFFSET_EVEN_FORMULA_1:
+    add         r14, r4, #31            @ temp3 = linear_y_size+31
+    bic         r14, r14, #0x1F         @ temp3 = (temp3>>5)<<5
+    sub         r14, r14, #32           @ temp3 = temp3 - 32
+    cmp         r6, r14                 @ if (i<(temp3-32)) {
+    bge         GET_TILED_OFFSET_EVEN_FORMULA_2
+    add         r14, r11, #2            @ temp3 = temp1+2
+    bic         r14, r14, #3            @ temp3 = (temp3>>2)<<2
+    add         r7, r11, r14            @ tiled_addr = temp1+temp3
+    add         r14, r3, #127           @ temp3 = linear_x_size+127
+    bic         r14, r14, #0x7F         @ temp3 = (temp3>>7)<<7
+    mov         r14, r14, asr #6        @ temp3 = temp3>>6
+    mul         r12, r12, r14           @ tiled_y_index = tiled_y_index*temp3
+    add         r7, r7, r12             @ tiled_addr = tiled_addr+tiled_y_index
+    mov         r7, r7, lsl #11         @
+    b           GET_TILED_OFFSET_RETURN
+
+GET_TILED_OFFSET_EVEN_FORMULA_2:
+    add         r14, r3, #127           @ temp3 = linear_x_size+127
+    bic         r14, r14, #0x7F         @ temp3 = (temp3>>7)<<7
+    mov         r14, r14, asr #6        @ temp3 = temp3>>6
+    mul         r7, r12, r14            @ tiled_addr = temp2*temp3
+    add         r7, r7, r11             @ tiled_addr = tiled_addr+temp3
+    mov         r7, r7, lsl #11         @ tiled_addr = tiled_addr<<11@
+
+GET_TILED_OFFSET_RETURN:
+    ldmfd       sp!, {r15}              @ restore registers
+    .fnend
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_yuv420_nv12t_y_neon.s b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_yuv420_nv12t_y_neon.s
new file mode 100644
index 0000000..3f8932a
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/csc/csc_yuv420_nv12t_y_neon.s
@@ -0,0 +1,451 @@
+/*
+ *
+ * Copyright 2011 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    csc_yuv420_nv12t_y_neon.s
+ * @brief   SEC_OMX specific define
+ * @author  ShinWon Lee (shinwon.lee@samsung.com)
+ * @version 1.0
+ * @history
+ *   2011.7.01 : Create
+ */
+
+/*
+ * Converts linear data to tiled.
+ * 1. Y of YUV420P to Y of NV12T
+ * 2. Y of YUV420S to Y of NV12T
+ * 3. UV of YUV420S to UV of NV12T
+ *
+ * @param nv12t_dest
+ *   Y or UV plane address of NV12T[out]
+ *
+ * @param yuv420_src
+ *   Y or UV plane address of YUV420P(S)[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_height
+ *   Y: Height of YUV420, UV: Height/2 of YUV420[in]
+ */
+
+    .arch armv7-a
+    .text
+    .global csc_linear_to_tiled
+    .type   csc_linear_to_tiled, %function
+csc_linear_to_tiled:
+    .fnstart
+
+    @r0     tiled_dest
+    @r1     linear_src
+    @r2     linear_x_size
+    @r3     linear_y_size
+    @r4     j
+    @r5     i
+    @r6     nn(tiled_addr)
+    @r7     mm(linear_addr)
+    @r8     aligned_x_size
+    @r9     aligned_y_size
+    @r10    temp1
+    @r11    temp2
+    @r12    temp3
+    @r14    temp4
+
+    stmfd       sp!, {r4-r12,r14}       @ backup registers
+
+    bic         r9, r3, #0x1F           @ aligned_y_size = (linear_y_size>>5)<<5
+    bic         r8, r2, #0x3F           @ aligned_x_size = (linear_x_size>>6)<<6
+
+    mov         r5, #0                  @ i = 0
+LOOP_ALIGNED_Y_SIZE:
+
+    mov         r4, #0                  @ j = 0
+LOOP_ALIGNED_X_SIZE:
+
+    bl          GET_TILED_OFFSET
+
+    mul         r10, r2, r5             @ temp1 = linear_x_size*(i)
+    add         r7, r1, r4              @ linear_addr = linear_src+j
+    add         r7, r7, r10             @ linear_addr = linear_addr+temp1
+    sub         r10, r2, #32
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    add         r6, r0, r6              @ tiled_addr = tiled_dest+tiled_addr
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    add         r4, r4, #64             @ j = j+64
+    cmp         r4, r8                  @ j<aligned_x_size
+    blt         LOOP_ALIGNED_X_SIZE
+
+    add         r5, r5, #32             @ i = i+32
+    cmp         r5, r9                  @ i<aligned_y_size
+    blt         LOOP_ALIGNED_Y_SIZE
+
+    cmp         r5, r3
+    beq         LOOP_LINEAR_Y_SIZE_2_START
+
+LOOP_LINEAR_Y_SIZE_1:
+
+    mov         r4, #0                  @ j = 0
+LOOP_ALIGNED_X_SIZE_1:
+
+    bl          GET_TILED_OFFSET
+
+    mul         r10, r2, r5             @ temp1 = linear_x_size*(i)
+    add         r7, r1, r4              @ linear_addr = linear_src+j
+    add         r7, r7, r10             @ linear_addr = linear_addr+temp1
+    sub         r10, r2, #32            @ temp1 = linear_x_size-32
+
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q0, q1}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q2, q3}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q4, q5}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q6, q7}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q8, q9}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q10, q11}, [r7], r10
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q12, q13}, [r7]!
+    pld         [r7, r2, lsl #1]
+    vld1.8      {q14, q15}, [r7], r10
+
+    add         r6, r0, r6              @ tiled_addr = tiled_dest+tiled_addr
+    and         r11, r5, #0x1F          @ temp2 = i&0x1F
+    mov         r11, r11, lsl #6        @ temp2 = 64*temp2
+    add         r6, r6, r11             @ tiled_addr = tiled_addr+temp2
+
+    vst1.8      {q0, q1}, [r6]!
+    vst1.8      {q2, q3}, [r6]!
+    vst1.8      {q4, q5}, [r6]!
+    vst1.8      {q6, q7}, [r6]!
+    vst1.8      {q8, q9}, [r6]!
+    vst1.8      {q10, q11}, [r6]!
+    vst1.8      {q12, q13}, [r6]!
+    vst1.8      {q14, q15}, [r6]!
+
+    add         r4, r4, #64             @ j = j+64
+    cmp         r4, r8                  @ j<aligned_x_size
+    blt         LOOP_ALIGNED_X_SIZE_1
+
+    add         r5, r5, #4              @ i = i+4
+    cmp         r5, r3                  @ i<linear_y_size
+    blt         LOOP_LINEAR_Y_SIZE_1
+
+LOOP_LINEAR_Y_SIZE_2_START:
+    cmp         r4, r2
+    beq         RESTORE_REG
+
+    mov         r5, #0                  @ i = 0
+LOOP_LINEAR_Y_SIZE_2:
+
+    mov         r4, r8                  @ j = aligned_x_size
+LOOP_LINEAR_X_SIZE_2:
+
+    bl          GET_TILED_OFFSET
+
+    mul         r10, r2, r5             @ temp1 = linear_x_size*(i)
+    add         r7, r1, r4              @ linear_addr = linear_src+j
+    add         r7, r7, r10             @ linear_addr = linear_addr+temp1
+
+    add         r6, r0, r6              @ tiled_addr = tiled_dest+tiled_addr
+    and         r11, r5, #0x1F          @ temp2 = i&0x1F
+    mov         r11, r11, lsl #6        @ temp2 = 64*temp2
+    add         r6, r6, r11             @ tiled_addr = tiled_addr+temp2
+    and         r11, r4, #0x3F          @ temp2 = j&0x3F
+    add         r6, r6, r11             @ tiled_addr = tiled_addr+temp2
+
+    ldr         r10, [r7], r2
+    ldr         r11, [r7], r2
+    ldr         r12, [r7], r2
+    ldr         r14, [r7], r2
+    str         r10, [r6], #64
+    str         r11, [r6], #64
+    str         r12, [r6], #64
+    str         r14, [r6], #64
+
+    add         r4, r4, #4              @ j = j+4
+    cmp         r4, r2                  @ j<linear_x_size
+    blt         LOOP_LINEAR_X_SIZE_2
+
+    add         r5, r5, #4              @ i = i+4
+    cmp         r5, r3                  @ i<linear_y_size
+    blt         LOOP_LINEAR_Y_SIZE_2
+
+RESTORE_REG:
+    ldmfd       sp!, {r4-r12,r15}       @ restore registers
+
+GET_TILED_OFFSET:
+
+    mov         r11, r5, asr #5         @ temp2 = i>>5
+    mov         r10, r4, asr #6         @ temp1 = j>>6
+
+    and         r12, r11, #0x1          @ if (temp2 & 0x1)
+    cmp         r12, #0x1
+    bne         GET_TILED_OFFSET_EVEN_FORMULA_1
+
+GET_TILED_OFFSET_ODD_FORMULA:
+    sub         r6, r11, #1             @ tiled_addr = temp2-1
+    add         r12, r2, #127           @ temp3 = linear_x_size+127
+    bic         r12, r12, #0x7F         @ temp3 = (temp3 >>7)<<7
+    mov         r12, r12, asr #6        @ temp3 = temp3>>6
+    mul         r6, r6, r12             @ tiled_addr = tiled_addr*temp3
+    add         r6, r6, r10             @ tiled_addr = tiled_addr+temp1
+    add         r6, r6, #2              @ tiled_addr = tiled_addr+2
+    bic         r12, r10, #0x3          @ temp3 = (temp1>>2)<<2
+    add         r6, r6, r12             @ tiled_addr = tiled_addr+temp3
+    mov         r6, r6, lsl #11         @ tiled_addr = tiled_addr<<11
+    b           GET_TILED_OFFSET_RETURN
+
+GET_TILED_OFFSET_EVEN_FORMULA_1:
+    add         r12, r3, #31            @ temp3 = linear_y_size+31
+    bic         r12, r12, #0x1F         @ temp3 = (temp3>>5)<<5
+    sub         r12, r12, #32           @ temp3 = temp3 - 32
+    cmp         r5, r12                 @ if (i<(temp3-32)) {
+    bge         GET_TILED_OFFSET_EVEN_FORMULA_2
+    add         r12, r10, #2            @ temp3 = temp1+2
+    bic         r12, r12, #3            @ temp3 = (temp3>>2)<<2
+    add         r6, r10, r12            @ tiled_addr = temp1+temp3
+    add         r12, r2, #127           @ temp3 = linear_x_size+127
+    bic         r12, r12, #0x7F         @ temp3 = (temp3>>7)<<7
+    mov         r12, r12, asr #6        @ temp3 = temp3>>6
+    mul         r11, r11, r12           @ tiled_y_index = tiled_y_index*temp3
+    add         r6, r6, r11             @ tiled_addr = tiled_addr+tiled_y_index
+    mov         r6, r6, lsl #11         @
+    b           GET_TILED_OFFSET_RETURN
+
+GET_TILED_OFFSET_EVEN_FORMULA_2:
+    add         r12, r2, #127           @ temp3 = linear_x_size+127
+    bic         r12, r12, #0x7F         @ temp3 = (temp3>>7)<<7
+    mov         r12, r12, asr #6        @ temp3 = temp3>>6
+    mul         r6, r11, r12            @ tiled_addr = temp2*temp3
+    add         r6, r6, r10             @ tiled_addr = tiled_addr+temp3
+    mov         r6, r6, lsl #11         @ tiled_addr = tiled_addr<<11@
+
+GET_TILED_OFFSET_RETURN:
+    mov         pc, lr
+    .fnend
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/Android.mk
new file mode 100644
index 0000000..c15cd41
--- /dev/null
+++ b/exynos3/s5pc110/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_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/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/src/SsbSipMfcDecAPI.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/src/SsbSipMfcDecAPI.c
new file mode 100644
index 0000000..6c64ef8
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/dec/src/SsbSipMfcDecAPI.c
@@ -0,0 +1,518 @@
+/*
+ * 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) {
+                ALOGV("isPBPacked: VOP START Found !!.....return\n");
+                ALOGV("isPBPacked: Non Packed PB\n");
+                return MFC_UNPACKED_PB;
+            }
+            getAByte(strmBuffer, &startCode);
+            strmBuffer++;
+            if (strmBuffer >= strmBufferEnd)
+                goto out;
+        }
+        ALOGV("isPBPacked: User Data Found !!\n");
+
+        do {
+            if (*strmBuffer == 'p') {
+                ALOGI("isPBPacked: Packed PB\n");
+                return MFC_PACKED_PB;
+            }
+            getAByte(strmBuffer, &startCode);
+            strmBuffer++;
+            if (strmBuffer >= strmBufferEnd)
+                goto out;
+        } while ((startCode >> 8) != MP4_START_CODE);
+    }
+
+out:
+    ALOGV("isPBPacked: Non Packed PB\n");
+    return MFC_UNPACKED_PB;
+}
+
+void *SsbSipMfcDecOpen(void *value)
+{
+    int hMFCOpen;
+    unsigned int mapped_addr;
+    _MFCLIB *pCTX;
+    mfc_common_args DecArg;
+    int ret_code;
+
+    pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
+    if (pCTX == NULL) {
+        ALOGE("SsbSipMfcDecOpen: malloc failed.\n");
+        return NULL;
+    }
+    memset(pCTX, 0, sizeof(_MFCLIB));
+
+    hMFCOpen = open(S5PC110_MFC_DEV_NAME, O_RDWR | O_NDELAY);
+    if (hMFCOpen < 0) {
+        ALOGE("SsbSipMfcDecOpen: MFC Open failure\n");
+        return NULL;
+    }
+
+    if (*(unsigned int *)value == NO_CACHE ||
+        *(unsigned int *)value == CACHE) {
+        DecArg.args.buf_type = *(unsigned int *)value;
+        ret_code = ioctl(hMFCOpen, IOCTL_MFC_BUF_CACHE, &DecArg);
+        if (DecArg.ret_code != MFC_RET_OK) {
+            ALOGE("SsbSipMfcDecOpenExt: IOCTL_MFC_BUF_CACHE (%d) failed\n", DecArg.ret_code);
+        }
+    } else {
+        ALOGE("SsbSipMfcDecOpenExt: value is invalid, value: %d\n", *(int *)value);
+    }
+
+    mapped_addr = (unsigned int)mmap(0, MMAP_BUFFER_SIZE_MMAP, PROT_READ | PROT_WRITE, MAP_SHARED, hMFCOpen, 0);
+    if (!mapped_addr) {
+        ALOGE("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) {
+        ALOGE("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)) {
+        ALOGE("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) {
+        ALOGE("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;
+
+    /* by RainAde : crop information */
+    pCTX->decOutInfo.crop_top_offset = DecArg.args.dec_init.out_crop_top_offset;
+    pCTX->decOutInfo.crop_bottom_offset = DecArg.args.dec_init.out_crop_bottom_offset;
+    pCTX->decOutInfo.crop_left_offset = DecArg.args.dec_init.out_crop_left_offset;
+    pCTX->decOutInfo.crop_right_offset = DecArg.args.dec_init.out_crop_right_offset;
+
+    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) {
+        ALOGE("SsbSipMfcDecExe: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    if ((lengthBufFill < 0) || (lengthBufFill > MAX_DECODER_INPUT_BUFFER_SIZE)) {
+        ALOGE("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) {
+        ALOGE("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) {
+        ALOGE("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) {
+        ALOGE("SsbSipMfcDecGetInBuf: inputBufferSize = %d is invalid\n", inputBufferSize);
+        return NULL;
+    }
+
+    if (openHandle == NULL) {
+        ALOGE("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) {
+        ALOGE("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) {
+        ALOGE("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) {
+        ALOGE("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;
+
+    /* by RainAde : for crop information */
+    output_info->crop_top_offset = pCTX->decOutInfo.crop_top_offset;
+    output_info->crop_bottom_offset= pCTX->decOutInfo.crop_bottom_offset;
+    output_info->crop_left_offset = pCTX->decOutInfo.crop_left_offset;
+    output_info->crop_right_offset= pCTX->decOutInfo.crop_right_offset;
+
+    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) {
+        ALOGE("SsbSipMfcDecSetConfig: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    if (value == NULL) {
+        ALOGE("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:
+        ALOGE("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) {
+        ALOGE("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;
+    SSBSIP_MFC_CROP_INFORMATION *crop_information;
+    MFC_CRC_DATA *crc_data;
+
+    if (openHandle == NULL) {
+        ALOGE("SsbSipMfcDecGetConfig: openHandle is NULL\n");
+        return MFC_RET_FAIL;
+    }
+
+    if (value == NULL) {
+        ALOGE("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;
+
+    /* Added by RainAde */
+    case MFC_DEC_GETCONF_CROP_INFO:
+        crop_information = (SSBSIP_MFC_CROP_INFORMATION*)value;
+        crop_information->crop_top_offset = pCTX->decOutInfo.crop_top_offset;
+        crop_information->crop_bottom_offset= pCTX->decOutInfo.crop_bottom_offset;
+        crop_information->crop_left_offset = pCTX->decOutInfo.crop_left_offset;
+        crop_information->crop_right_offset= pCTX->decOutInfo.crop_right_offset;
+        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) {
+            ALOGE("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:
+        ALOGE("SsbSipMfcDecGetConfig: No such conf_type is supported.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    return MFC_RET_OK;
+}
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/Android.mk
new file mode 100644
index 0000000..b57346b
--- /dev/null
+++ b/exynos3/s5pc110/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_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/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/src/SsbSipMfcEncAPI.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/src/SsbSipMfcEncAPI.c
new file mode 100644
index 0000000..a27fcc0
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/enc/src/SsbSipMfcEncAPI.c
@@ -0,0 +1,686 @@
+/*
+ * 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 *value)
+{
+    int hMFCOpen;
+    _MFCLIB *pCTX;
+    unsigned int mapped_addr;
+    mfc_common_args EncArg;
+    int ret_code;
+
+    hMFCOpen = open(S5PC110_MFC_DEV_NAME, O_RDWR | O_NDELAY);
+    if (hMFCOpen < 0) {
+        ALOGE("SsbSipMfcEncOpen: MFC Open failure\n");
+        return NULL;
+    }
+
+    pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
+    if (pCTX == NULL) {
+        ALOGE("SsbSipMfcEncOpen: malloc failed.\n");
+        close(hMFCOpen);
+        return NULL;
+    }
+
+    if (*(unsigned int *)value == NO_CACHE ||
+        *(unsigned int *)value == CACHE) {
+        EncArg.args.buf_type = *(unsigned int *)value;
+        ret_code = ioctl(hMFCOpen, IOCTL_MFC_BUF_CACHE, &EncArg);
+        if (EncArg.ret_code != MFC_RET_OK) {
+            ALOGE("SsbSipMfcDecOpenExt: IOCTL_MFC_BUF_CACHE (%d) failed\n", EncArg.ret_code);
+        }
+    } else {
+        ALOGE("SsbSipMfcDecOpenExt: value is invalid, value: %d\n", *(int *)value);
+    }
+
+    mapped_addr = (unsigned int)mmap(0, MMAP_BUFFER_SIZE_MMAP, PROT_READ | PROT_WRITE, MAP_SHARED, hMFCOpen, 0);
+    if (!mapped_addr) {
+        ALOGE("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));
+
+    ALOGV("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)) {
+        ALOGE("SsbSipMfcEncOpen: Undefined codec type.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX->codec_type = codec_type;
+
+    switch (pCTX->codec_type) {
+    case MPEG4_ENC:
+        ALOGV("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:
+        ALOGV("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:
+        ALOGV("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) {
+            ALOGE("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)) {
+            ALOGE("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)) {
+            ALOGE("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_frame_map = mpeg4_arg->FrameMap;
+
+        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)) {
+            ALOGE("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)) {
+            ALOGE("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)) {
+            ALOGE("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_frame_map = mpeg4_arg->FrameMap;
+
+        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) {
+            ALOGE("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)) {
+            ALOGE("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 {
+            ALOGE("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) {
+            ALOGE("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)) {
+            ALOGE("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)) {
+            ALOGE("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;
+        EncArg.args.enc_init_mpeg4.in_frame_map = mpeg4_arg->FrameMap;
+
+        /* 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) {
+            ALOGE("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)) {
+            ALOGE("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) {
+        ALOGE("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) {
+        ALOGE("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;
+    if (pCTX->encode_cnt == 0) {
+        EncArg.args.enc_exe.in_strm_st = (unsigned int)pCTX->phyStrmBuf;
+        EncArg.args.enc_exe.in_strm_end = (unsigned int)pCTX->phyStrmBuf + pCTX->sizeStrmBuf;
+    } else {
+        EncArg.args.enc_exe.in_strm_st = (unsigned int)pCTX->phyStrmBuf + (MAX_ENCODER_OUTPUT_BUFFER_SIZE/2);
+        EncArg.args.enc_exe.in_strm_end = (unsigned int)pCTX->phyStrmBuf  + (MAX_ENCODER_OUTPUT_BUFFER_SIZE/2) + pCTX->sizeStrmBuf;
+    }
+
+    ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_ENC_EXE, &EncArg);
+    if (EncArg.ret_code != MFC_RET_OK) {
+        ALOGE("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) {
+        ALOGE("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 SsbSipMfcEncSetSize(void *openHandle, SSBSIP_MFC_CODEC_TYPE codecType, int nWidth, int nHeight)
+{
+    _MFCLIB *pCTX = (_MFCLIB *)openHandle;
+
+    if (pCTX == NULL)
+        return MFC_RET_INVALID_PARAM;
+
+    if (nWidth <= 0 || nHeight <= 0)
+        return MFC_RET_INVALID_PARAM;
+    pCTX->width = nWidth;
+    pCTX->height = nHeight;
+
+    if ((H264_ENC != codecType) &&
+        (MPEG4_ENC != codecType) &&
+        (H263_ENC != codecType))
+        return MFC_RET_INVALID_PARAM;
+    pCTX->codec_type = codecType;
+
+    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) {
+        ALOGE("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) {
+        ALOGE("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;
+
+    input_info->YSize    = aligned_y_size;
+    input_info->CSize    = aligned_c_size;
+
+    return MFC_RET_OK;
+}
+
+SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
+{
+    _MFCLIB *pCTX;
+
+    if (openHandle == NULL) {
+        ALOGE("SsbSipMfcEncSetInBuf: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    ALOGV("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) {
+        ALOGE("SsbSipMfcEncGetOutBuf: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    pCTX = (_MFCLIB *)openHandle;
+
+    output_info->headerSize = pCTX->encodedHeaderSize;
+    output_info->dataSize = pCTX->encodedDataSize;
+
+    if (pCTX->encode_cnt == 0) {
+        output_info->StrmPhyAddr = (void *)pCTX->phyStrmBuf;
+        output_info->StrmVirAddr = (void *)pCTX->virStrmBuf;
+    } else {
+        output_info->StrmPhyAddr = (unsigned char *)pCTX->phyStrmBuf + (MAX_ENCODER_OUTPUT_BUFFER_SIZE/2);
+        output_info->StrmVirAddr = (unsigned char *)pCTX->virStrmBuf + (MAX_ENCODER_OUTPUT_BUFFER_SIZE/2);
+    }
+
+    pCTX->encode_cnt ++;
+    pCTX->encode_cnt %= 2;
+
+    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 {
+        ALOGE("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) {
+        ALOGE("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) {
+        ALOGE("SsbSipMfcEncSetConfig: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    if (value == NULL) {
+        ALOGE("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:
+        ALOGE("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) {
+        ALOGE("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) {
+        ALOGE("SsbSipMfcEncGetConfig: openHandle is NULL\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+    if (value == NULL) {
+        ALOGE("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:
+        ALOGE("SsbSipMfcEncGetConfig: No such conf_type is supported.\n");
+        return MFC_RET_INVALID_PARAM;
+    }
+
+    return MFC_RET_OK;
+}
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/SsbSipMfcApi.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/SsbSipMfcApi.h
new file mode 100644
index 0000000..118e1ba
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/SsbSipMfcApi.h
@@ -0,0 +1,332 @@
+/*
+ * 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 MMAP_BUFFER_SIZE_MMAP          (35328*1024) // 34.5*1024*1024
+
+#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 {
+    NV12_LINEAR = 0,
+    NV12_TILE
+} SSBSIP_MFC_INSTRM_MODE_TYPE;
+
+typedef enum {
+    NO_CACHE = 0,
+    CACHE = 1
+} SSBIP_MFC_BUFFER_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_CROP_INFO,
+    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
+    int FrameMap;                       // [IN] Encoding input mode(tile mode or linear mode)
+
+    // 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
+    int FrameMap;                       // [IN] Encoding input mode(tile mode or linear mode)
+
+    // 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
+    int FrameMap;                       // [IN] Encoding input mode(tile mode or linear mode)
+
+    // 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;
+
+typedef struct {
+    int crop_top_offset;
+    int crop_bottom_offset;
+    int crop_left_offset;
+    int crop_right_offset;
+} SSBSIP_MFC_CROP_INFORMATION;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*--------------------------------------------------------------------------------*/
+/* Decoding APIs                                                                  */
+/*--------------------------------------------------------------------------------*/
+void *SsbSipMfcDecOpen(void *value);
+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 *value);
+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 SsbSipMfcEncSetSize(void *openHandle, SSBSIP_MFC_CODEC_TYPE codecType, int nWidth, int nHeight);
+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/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/color_space_convertor.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/color_space_convertor.h
new file mode 100644
index 0000000..4ad5bda
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/color_space_convertor.h
@@ -0,0 +1,176 @@
+/*
+ *
+ * Copyright 2011 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    color_space_convertor.h
+ * @brief   SEC_OMX specific define.
+ *   NV12T(tiled) layout:
+ *   Each element is not pixel. It is 64x32 pixel block.
+ *   uv pixel block is interleaved as u v u v u v ...
+ *   y1    y2    y7    y8    y9    y10   y15   y16
+ *   y3    y4    y5    y6    y11   y12   y13   y14
+ *   y17   y18   y23   y24   y25   y26   y31   y32
+ *   y19   y20   y21   y22   y27   y28   y29   y30
+ *   uv1   uv2   uv7   uv8   uv9   uv10  uv15  uv16
+ *   uv3   uv4   uv5   uv6   uv11  uv12  uv13  uv14
+ *   YUV420Planar(linear) layout:
+ *   Each element is not pixel. It is 64x32 pixel block.
+ *   y1    y2    y3    y4    y5    y6    y7    y8
+ *   y9    y10   y11   y12   y13   y14   y15   y16
+ *   y17   y18   y19   y20   y21   y22   y23   y24
+ *   y25   y26   y27   y28   y29   y30   y31   y32
+ *   u1    u2    u3    u4    u5    u6    u7    u8
+ *   v1    v2    v3    v4    v5    v6    v7    v8
+ *   YUV420Semiplanar(linear) layout:
+ *   Each element is not pixel. It is 64x32 pixel block.
+ *   uv pixel block is interleaved as u v u v u v ...
+ *   y1    y2    y3    y4    y5    y6    y7    y8
+ *   y9    y10   y11   y12   y13   y14   y15   y16
+ *   y17   y18   y19   y20   y21   y22   y23   y24
+ *   y25   y26   y27   y28   y29   y30   y31   y32
+ *   uv1   uv2   uv3   uv4   uv5   uv6   uv7   uv8
+ *   uv9   uv10  uv11  uv12  uv13  uv14  uv15  uv16
+ * @author  ShinWon Lee (shinwon.lee@samsung.com)
+ * @version 1.0
+ * @history
+ *   2011.7.01 : Create
+ */
+
+#ifndef COLOR_SPACE_CONVERTOR_H_
+#define COLOR_SPACE_CONVERTOR_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Format Conversion API                                                          */
+/*--------------------------------------------------------------------------------*/
+/* C Code */
+/*
+ * De-interleaves src to dest1, dest2
+ *
+ * @param dest1
+ *   Address of de-interleaved data[out]
+ *
+ * @param dest2
+ *   Address of de-interleaved data[out]
+ *
+ * @param src
+ *   Address of interleaved data[in]
+ *
+ * @param src_size
+ *   Size of interleaved data[in]
+ */
+void csc_deinterleave_memcpy(char *dest1, char *dest2, char *src, int src_size);
+
+/*
+ * Interleaves src1, src2 to dest
+ *
+ * @param dest
+ *   Address of interleaved data[out]
+ *
+ * @param src1
+ *   Address of de-interleaved data[in]
+ *
+ * @param src2
+ *   Address of de-interleaved data[in]
+ *
+ * @param src_size
+ *   Size of de-interleaved data[in]
+ */
+void csc_interleave_memcpy(char *dest, char *src1, char *src2, int src_size);
+
+/*
+ * Converts tiled data to linear.
+ * 1. Y of NV12T to Y of YUV420P
+ * 2. Y of NV12T to Y of YUV420S
+ * 3. UV of NV12T to UV of YUV420S
+ *
+ * @param yuv420_dest
+ *   Y or UV plane address of YUV420[out]
+ *
+ * @param nv12t_src
+ *   Y or UV plane address of NV12T[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_height
+ *   Y: Height of YUV420, UV: Height/2 of YUV420[in]
+ */
+void csc_tiled_to_linear(char *yuv420p_y_dest, char *nv12t_y_src, int yuv420p_width, int yuv420p_y_height);
+
+/*
+ * Converts and Deinterleaves tiled data to linear
+ * 1. UV of NV12T to UV of YUV420P
+ *
+ * @param yuv420_u_dest
+ *   U plane address of YUV420P[out]
+ *
+ * @param yuv420_v_dest
+ *   V plane address of YUV420P[out]
+ *
+ * @param nv12t_src
+ *   UV plane address of NV12T[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_uv_height
+ *   Height/2 of YUV420[in]
+ */
+void csc_tiled_to_linear_deinterleave(char *yuv420p_u_dest, char *yuv420p_v_dest, char *nv12t_uv_src, int yuv420p_width, int yuv420p_uv_height);
+
+/*
+ * Converts linear data to tiled.
+ * 1. Y of YUV420P to Y of NV12T
+ * 2. Y of YUV420S to Y of NV12T
+ * 3. UV of YUV420S to UV of NV12T
+ *
+ * @param nv12t_dest
+ *   Y or UV plane address of NV12T[out]
+ *
+ * @param yuv420_src
+ *   Y or UV plane address of YUV420P(S)[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_height
+ *   Y: Height of YUV420, UV: Height/2 of YUV420[in]
+ */
+void csc_linear_to_tiled(char *nv12t_dest, char *yuv420p_src, int yuv420p_width, int yuv420p_y_height);
+
+/*
+ * Converts and Interleaves linear to tiled
+ * 1. UV of YUV420P to UV of NV12T
+ *
+ * @param nv12t_uv_dest
+ *   UV plane address of NV12T[out]
+ *
+ * @param yuv420p_u_src
+ *   U plane address of YUV420P[in]
+ *
+ * @param yuv420p_v_src
+ *   V plane address of YUV420P[in]
+ *
+ * @param yuv420_width
+ *   Width of YUV420[in]
+ *
+ * @param yuv420_uv_height
+ *   Height/2 of YUV420[in]
+ */
+void csc_linear_to_tiled_interleave(char *nv12t_uv_dest, char *yuv420p_u_src, char *yuv420p_v_src, int yuv420p_width, int yuv420p_uv_height);
+
+#endif /*COLOR_SPACE_CONVERTOR_H_*/
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/mfc_interface.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/mfc_interface.h
new file mode 100644
index 0000000..466860d
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_codecs/video/mfc_c110/include/mfc_interface.h
@@ -0,0 +1,347 @@
+/*
+ * 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
+
+#define IOCTL_MFC_BUF_CACHE                    0x00801000
+
+/* 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;
+
+    int in_frame_map;                    /* [IN] Encoding input NV12 type linear(0) TILE(1)              */
+
+    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                  */
+
+    int in_frame_map;                    /* [IN] Encoding input NV12 type linear(0) TILE(1)              */
+
+    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 */
+
+    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_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 enum {
+	MFC_BUFFER_NO_CACHE = 0,
+	MFC_BUFFER_CACHE = 1
+} mfc_buffer_type;
+
+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_buffer_type buf_type;
+} 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;
+    unsigned int encode_cnt;
+} _MFCLIB;
+
+#endif /* _MFC_INTERFACE_H_ */
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/Android.mk
new file mode 100644
index 0000000..ac0516c
--- /dev/null
+++ b/exynos3/s5pc110/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_MODULE := libsecbasecomponent
+
+LOCAL_CFLAGS :=
+
+LOCAL_STATIC_LIBRARIES := libsecosal
+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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.c
new file mode 100644
index 0000000..89e9aeb
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.c
@@ -0,0 +1,1486 @@
+/*
+ *
+ * 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_ThreadExit(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;
+
+                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);
+                }
+
+                SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
+                SEC_OSAL_ThreadTerminate(pSECComponent->hBufferProcess);
+                pSECComponent->hBufferProcess = NULL;
+
+                for (i = 0; i < ALL_PORT_NUM; i++) {
+                    SEC_OSAL_MutexTerminate(pSECComponent->secDataBuffer[i].bufferMutex);
+                    pSECComponent->secDataBuffer[i].bufferMutex = 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;
+                }
+            }
+            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);
+            }
+
+            SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
+            SEC_OSAL_ThreadTerminate(pSECComponent->hBufferProcess);
+            pSECComponent->hBufferProcess = NULL;
+
+            for (i = 0; i < ALL_PORT_NUM; i++) {
+                SEC_OSAL_MutexTerminate(pSECComponent->secDataBuffer[i].bufferMutex);
+                pSECComponent->secDataBuffer[i].bufferMutex = 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 (pSECPort == NULL) {
+                    ret = OMX_ErrorBadParameter;
+                    goto EXIT;
+                }
+                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_ThreadExit(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, index = 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 ?????
+        **********************/
+        cnt = (portIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
+        for (i = 0; i < cnt; i++) {
+            if (portIndex == ALL_PORT_INDEX)
+                index = i;
+            else
+                index = portIndex;
+            pSECComponent->pSECPort[index].bIsPortFlushed = OMX_TRUE;
+        }
+    } 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;
+            pSECPort->bIsPortDisabled = OMX_TRUE;
+        }
+    } else {
+        pSECPort = &pSECComponent->pSECPort[portIndex];
+        pSECPort->portState = OMX_StateLoaded;
+        pSECPort->bIsPortDisabled = OMX_TRUE;
+    }
+    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 = &pSECComponent->pSECPort[portIndex];
+
+        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;
+        }
+
+        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_ErrorUnsupportedIndex;
+
+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_ErrorUnsupportedIndex;
+
+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->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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.h
new file mode 100644
index 0000000..d413257
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Basecomponent.h
@@ -0,0 +1,174 @@
+/*
+ *
+ * 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   previousDataLen;
+    OMX_U32   nFlags;
+    OMX_TICKS timeStamp;
+    SEC_BUFFER_HEADER specificBufferHeader;
+} SEC_OMX_DATA;
+
+/* for Check TimeStamp after Seek */
+typedef struct _SEC_OMX_TIMESTAPM
+{
+    OMX_BOOL  needSetStartTimeStamp;
+    OMX_BOOL  needCheckStartTimeStamp;
+    OMX_TICKS startTimeStamp;
+    OMX_U32   nStartFlags;
+} SEC_OMX_TIMESTAMP;
+
+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;
+
+    /* Save Timestamp */
+    OMX_TICKS                timeStamp[MAX_TIMESTAMP];
+    SEC_OMX_TIMESTAMP        checkTimeStamp;
+
+    /* Save Flags */
+    OMX_U32                  nFlags[MAX_FLAGS];
+
+    OMX_BOOL                 getAllDelayBuffer;
+    OMX_BOOL                 remainOutputData;
+    OMX_BOOL                 reInputData;
+
+    /* 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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.c
new file mode 100644
index 0000000..97e00af
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.c
@@ -0,0 +1,1009 @@
+/*
+ *
+ * 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];
+    while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) > 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_Log(SEC_LOG_ERROR, "Tunneled mode is not working, Line:%d", __LINE__);
+                ret = OMX_ErrorNotImplemented;
+                SEC_OSAL_Queue(&pSECPort->bufferQ, pSECPort);
+                goto EXIT;
+            } 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);
+        }
+        if (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) != pSECPort->assignedBufferNum)
+            SEC_OSAL_SetElemNum(&pSECPort->bufferQ, pSECPort->assignedBufferNum);
+    } else {
+        while(1) {
+            int cnt;
+            SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[portIndex].bufferSemID, &cnt);
+            if (cnt == 0)
+                break;
+            SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[portIndex].bufferSemID);
+        }
+        SEC_OSAL_SetElemNum(&pSECPort->bufferQ, 0);
+    }
+
+    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;
+
+        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);
+        }
+
+        if (portIndex == INPUT_PORT_INDEX) {
+            pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
+            pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
+            SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+            SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+            pSECComponent->bSaveFlagEOS = OMX_FALSE;
+            pSECComponent->reInputData = OMX_FALSE;
+        } else if (portIndex == OUTPUT_PORT_INDEX) {
+            pSECComponent->remainOutputData = 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_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;
+
+        if (portIndex == INPUT_PORT_INDEX) {
+            pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
+            pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
+            SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+            SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+            pSECComponent->bSaveFlagEOS = OMX_FALSE;
+            pSECComponent->remainOutputData = OMX_FALSE;
+            pSECComponent->reInputData = 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;
+
+        if (portIndex == INPUT_PORT_INDEX) {
+            pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
+            pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
+            SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+            SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+            pSECComponent->bSaveFlagEOS = OMX_FALSE;
+            pSECComponent->reInputData = OMX_FALSE;
+        } else if (portIndex == OUTPUT_PORT_INDEX) {
+            pSECComponent->remainOutputData = OMX_FALSE;
+        }
+    }
+
+    for(i = 0; i < cnt; i++) {
+        if (nPortIndex == ALL_PORT_INDEX)
+            portIndex = i;
+        else
+            portIndex = nPortIndex;
+
+        ret = SEC_OMX_DisablePort(pOMXComponent, portIndex);
+        pSECComponent->pSECPort[portIndex].bIsPortDisabled = OMX_FALSE;
+        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)) ||
+        ((CHECK_PORT_BEING_FLUSHED(pSECPort) || CHECK_PORT_BEING_DISABLED(pSECPort)) &&
+        (!CHECK_PORT_TUNNELED(pSECPort) || !CHECK_PORT_BUFFER_SUPPLIER(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)) ||
+        ((CHECK_PORT_BEING_FLUSHED(pSECPort) || CHECK_PORT_BEING_DISABLED(pSECPort)) &&
+        (!CHECK_PORT_TUNNELED(pSECPort) || !CHECK_PORT_BUFFER_SUPPLIER(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->bIsPortDisabled = 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;
+    pSECInputPort->bUseAndroidNativeBuffer = OMX_FALSE;
+    pSECInputPort->bStoreMetaDataInBuffer = OMX_FALSE;
+
+    /* 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->bIsPortDisabled = 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;
+    pSECOutputPort->bUseAndroidNativeBuffer = OMX_FALSE;
+    pSECOutputPort->bStoreMetaDataInBuffer = OMX_FALSE;
+
+    pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
+    pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
+    pSECComponent->checkTimeStamp.startTimeStamp = 0;
+    pSECComponent->checkTimeStamp.nStartFlags = 0x0;
+
+    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;
+
+    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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.h
new file mode 100644
index 0000000..147f940
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Baseport.h
@@ -0,0 +1,98 @@
+/*
+ *
+ * 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_BOOL                       bIsPortDisabled;
+    OMX_MARKTYPE                   markType;
+
+    OMX_CONFIG_RECTTYPE            cropRectangle;
+
+    /* Tunnel Info */
+    OMX_HANDLETYPE                 tunneledComponent;
+    OMX_U32                        tunneledPort;
+    OMX_U32                        tunnelBufferNum;
+    OMX_BUFFERSUPPLIERTYPE         bufferSupplier;
+    OMX_U32                        tunnelFlags;
+
+    OMX_VIDEO_CONTROLRATETYPE      eControlRate;
+
+    /* For Android Native Buffer */
+    OMX_BOOL                       bUseAndroidNativeBuffer;
+    /* For Android Store Meta Data inBuffer */
+    OMX_BOOL                       bStoreMetaDataInBuffer;
+    OMX_PTR                        pIMGGrallocModule;
+} 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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.c
new file mode 100644
index 0000000..41673ad
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/common/SEC_OMX_Resourcemanager.h
new file mode 100644
index 0000000..b958575
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/Android.mk
new file mode 100644
index 0000000..772c477
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/Android.mk
@@ -0,0 +1,20 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	SEC_OMX_Vdec.c
+
+LOCAL_MODULE := libSEC_OMX_Vdec
+LOCAL_ARM_MODE := arm
+LOCAL_MODULE_TAGS := optional
+
+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_STATIC_LIBRARY)
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.c
new file mode 100644
index 0000000..30a1acb
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.c
@@ -0,0 +1,1389 @@
+/*
+ *
+ * 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"
+#include "SEC_OSAL_Thread.h"
+#include "color_space_convertor.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_VIDEO_DEC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+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:
+        case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
+            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;
+        }
+    }
+
+    SEC_OSAL_Free(temp_bufferHeader);
+    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;
+        }
+    }
+
+    SEC_OSAL_Free(temp_bufferHeader);
+    SEC_OSAL_Free(temp_buffer);
+    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 (bufferHeader != NULL) {
+        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 (CHECK_PORT_TUNNELED(secOMXInputPort)) {
+            OMX_FillThisBuffer(secOMXInputPort->tunneledComponent, bufferHeader);
+        } else {
+            bufferHeader->nFilledLen = 0;
+            pSECComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+        }
+    }
+
+    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);
+    }
+
+    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;
+    SEC_OMX_DATABUFFER *inputUseBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+
+    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);
+        SEC_OSAL_MutexLock(inputUseBuffer->bufferMutex);
+        if (dataBuffer->dataValid != OMX_TRUE) {
+            message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+            if (message == NULL) {
+                ret = OMX_ErrorUndefined;
+                SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                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);
+        }
+        SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+        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();
+
+    if (bufferHeader != NULL) {
+        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 (CHECK_PORT_TUNNELED(secOMXOutputPort)) {
+            OMX_EmptyThisBuffer(secOMXOutputPort->tunneledComponent, bufferHeader);
+        } else {
+            pSECComponent->pCallbacks->FillBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+        }
+    }
+
+    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);
+    }
+
+    /* 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;
+    SEC_OMX_DATABUFFER *outputUseBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+
+    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);
+        SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+        if (dataBuffer->dataValid != OMX_TRUE) {
+            message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+            if (message == NULL) {
+                ret = OMX_ErrorUndefined;
+                SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+                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; */
+            pSECComponent->processData[OUTPUT_PORT_INDEX].dataBuffer = dataBuffer->bufferHeader->pBuffer;
+            pSECComponent->processData[OUTPUT_PORT_INDEX].allocSize = dataBuffer->bufferHeader->nAllocLen;
+
+            SEC_OSAL_Free(message);
+        }
+        SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+        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_DataReset(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];
+
+    processData->dataLen       = 0;
+    processData->remainDataLen = 0;
+    processData->usedDataLen   = 0;
+    processData->nFlags        = 0;
+    processData->timeStamp     = 0;
+
+    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;
+
+    FunctionIn();
+
+    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;
+                inputData->nFlags = inputUseBuffer->nFlags;
+            }
+
+            if (pSECComponent->bUseFlagEOF == OMX_TRUE) {
+                if (pSECComponent->bSaveFlagEOS == OMX_TRUE) {
+                    inputData->nFlags |= OMX_BUFFERFLAG_EOS;
+                    flagEOF = OMX_TRUE;
+                    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+                } else {
+                    inputData->nFlags = (inputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+                }
+            } else {
+                if ((checkedSize == checkInputStreamLen) && (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
+                    if ((inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS) &&
+                        ((inputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) ||
+                        (inputData->dataLen == 0))) {
+                    inputData->nFlags |= OMX_BUFFERFLAG_EOS;
+                    flagEOF = OMX_TRUE;
+                    pSECComponent->bSaveFlagEOS = OMX_FALSE;
+                    } else if ((inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS) &&
+                               (!(inputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG)) &&
+                               (inputData->dataLen != 0)) {
+                        inputData->nFlags = (inputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+                        flagEOF = OMX_TRUE;
+                        pSECComponent->bSaveFlagEOS = OMX_TRUE;
+                    }
+                } else {
+                    inputData->nFlags = (inputUseBuffer->nFlags & (~OMX_BUFFERFLAG_EOS));
+                }
+            }
+
+            if(((inputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) &&
+               (inputData->dataLen <= 0) && (flagEOF == OMX_TRUE)) {
+                inputData->dataLen = inputData->previousDataLen;
+                inputData->remainDataLen = inputData->previousDataLen;
+            }
+        } else {
+            /*????????????????????????????????? Error ?????????????????????????????????*/
+            SEC_DataReset(pOMXComponent, INPUT_PORT_INDEX);
+            flagEOF = OMX_FALSE;
+        }
+
+        if (inputUseBuffer->remainDataLen == 0)
+            SEC_InputBufferReturn(pOMXComponent);
+        else
+            inputUseBuffer->dataValid = OMX_TRUE;
+    }
+
+    if (flagEOF == OMX_TRUE) {
+        if (pSECComponent->checkTimeStamp.needSetStartTimeStamp == OMX_TRUE) {
+            pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_TRUE;
+            pSECComponent->checkTimeStamp.startTimeStamp = inputData->timeStamp;
+            pSECComponent->checkTimeStamp.nStartFlags = inputData->nFlags;
+            pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
+        }
+
+        ret = OMX_TRUE;
+    } else {
+        ret = OMX_FALSE;
+    }
+
+    FunctionOut();
+
+    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;
+
+    FunctionIn();
+
+    if (outputUseBuffer->dataValid == OMX_TRUE) {
+        if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
+            if ((pSECComponent->checkTimeStamp.startTimeStamp == outputData->timeStamp) &&
+                (pSECComponent->checkTimeStamp.nStartFlags == outputData->nFlags)){
+                pSECComponent->checkTimeStamp.startTimeStamp = -19761123;
+                pSECComponent->checkTimeStamp.nStartFlags = 0x0;
+                pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
+                pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
+            } else {
+                SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
+
+                ret = OMX_TRUE;
+                goto EXIT;
+            }
+        } else if (pSECComponent->checkTimeStamp.needSetStartTimeStamp == OMX_TRUE) {
+            SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
+
+            ret = OMX_TRUE;
+            goto EXIT;
+        }
+
+        if (outputData->remainDataLen <= (outputUseBuffer->allocSize - outputUseBuffer->dataLen)) {
+            copySize = outputData->remainDataLen;
+            outputUseBuffer->dataLen += copySize;
+            outputUseBuffer->remainDataLen += copySize;
+            outputUseBuffer->nFlags = outputData->nFlags;
+            outputUseBuffer->timeStamp = outputData->timeStamp;
+
+            ret = OMX_TRUE;
+
+            /* reset outputData */
+            SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
+
+            if ((outputUseBuffer->remainDataLen > 0) ||
+                (outputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS))
+                SEC_OutputBufferReturn(pOMXComponent);
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "output buffer is smaller than decoded data size Out Length");
+
+            copySize = outputUseBuffer->allocSize - outputUseBuffer->dataLen;
+            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;
+    }
+
+EXIT:
+    FunctionOut();
+
+    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;
+
+    pSECComponent->remainOutputData = OMX_FALSE;
+    pSECComponent->reInputData = 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);
+
+            SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+            if ((outputUseBuffer->dataValid != OMX_TRUE) &&
+                (!CHECK_PORT_BEING_FLUSHED(secOutputPort))) {
+                SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+                ret = SEC_OutputBufferGetQueue(pSECComponent);
+                if ((ret == OMX_ErrorUndefined) ||
+                    (secInputPort->portState != OMX_StateIdle) ||
+                    (secOutputPort->portState != OMX_StateIdle)) {
+                    break;
+                }
+            } else {
+                SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+            }
+
+            if (pSECComponent->remainOutputData == OMX_FALSE) {
+                if (pSECComponent->reInputData == OMX_FALSE) {
+                    SEC_OSAL_MutexLock(inputUseBuffer->bufferMutex);
+                    if ((SEC_Preprocessor_InputData(pOMXComponent) == OMX_FALSE) &&
+                        (!CHECK_PORT_BEING_FLUSHED(secInputPort))) {
+                            SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                            ret = SEC_InputBufferGetQueue(pSECComponent);
+                            break;
+                        }
+
+                    SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                }
+
+                SEC_OSAL_MutexLock(inputUseBuffer->bufferMutex);
+                SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+                ret = pSECComponent->sec_mfc_bufferProcess(pOMXComponent, inputData, outputData);
+                SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+                SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+
+                if (ret == OMX_ErrorInputDataDecodeYet)
+                    pSECComponent->reInputData = OMX_TRUE;
+                else
+                    pSECComponent->reInputData = OMX_FALSE;
+            }
+
+            SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+
+            if (SEC_Postprocess_OutputData(pOMXComponent) == OMX_FALSE)
+                pSECComponent->remainOutputData = OMX_TRUE;
+            else
+                pSECComponent->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_0:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_COLOR_FormatYUV420Planar;//OMX_COLOR_FormatYUV420SemiPlanar;
+                portFormat->xFramerate           = portDefinition->format.video.xFramerate;
+                break;
+            case supportFormat_1:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_COLOR_FormatYUV420SemiPlanar;//OMX_COLOR_FormatYUV420Planar;
+                portFormat->xFramerate         = portDefinition->format.video.xFramerate;
+                break;
+            case supportFormat_2:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_SEC_COLOR_FormatNV12TPhysicalAddress;
+                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;
+#ifdef USE_ANDROID_EXTENSION
+    case OMX_IndexParamGetAndroidNativeBuffer:
+    {
+        if (OMX_ErrorNone != checkVersionANB(ComponentParameterStructure))
+            goto EXIT;
+
+        if (OUTPUT_PORT_INDEX != checkPortIndexANB(ComponentParameterStructure)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+        ret = getAndroidNativeBuffer(hComponent, ComponentParameterStructure);
+    }
+        break;
+#endif
+    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;
+#ifdef USE_ANDROID_EXTENSION
+    case OMX_IndexParamEnableAndroidBuffers:
+    {
+        if (OMX_ErrorNone != checkVersionANB(ComponentParameterStructure))
+            goto EXIT;
+
+        if (OUTPUT_PORT_INDEX != checkPortIndexANB(ComponentParameterStructure)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        ret = enableAndroidNativeBuffer(hComponent, ComponentParameterStructure);
+        if (ret == OMX_ErrorNone) {
+            SEC_OMX_BASECOMPONENT *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+            SEC_OMX_BASEPORT      *pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+            if (pSECPort->bUseAndroidNativeBuffer) {
+                pSECPort->portDefinition.nBufferCountActual = ANDROID_MAX_VIDEO_OUTPUTBUFFER_NUM;
+                pSECPort->portDefinition.nBufferCountMin = ANDROID_MAX_VIDEO_OUTPUTBUFFER_NUM;
+            } else {
+                pSECPort->portDefinition.nBufferCountActual = MAX_VIDEO_OUTPUTBUFFER_NUM;
+                pSECPort->portDefinition.nBufferCountMin = MAX_VIDEO_OUTPUTBUFFER_NUM;
+            }
+        }
+    }
+        break;
+    case OMX_IndexParamUseAndroidNativeBuffer:
+    {
+        if (OMX_ErrorNone != checkVersionANB(ComponentParameterStructure))
+            goto EXIT;
+
+        if (OUTPUT_PORT_INDEX != checkPortIndexANB(ComponentParameterStructure)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        ret = useAndroidNativeBuffer(hComponent, ComponentParameterStructure);
+    }
+        break;
+#endif
+    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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.h
new file mode 100644
index 0000000..52130f0
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/SEC_OMX_Vdec.h
@@ -0,0 +1,129 @@
+/*
+ *
+ * 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
+#define DEFAULT_FRAME_HEIGHT         144
+
+#define DEFAULT_VIDEO_INPUT_BUFFER_SIZE    ((DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT) * 2)
+#define DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE   ((DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT * 3) / 2)
+
+#define MFC_INPUT_BUFFER_NUM_MAX         2
+#define DEFAULT_MFC_INPUT_BUFFER_SIZE    ((1280 * 720 * 3) / 2)
+
+#define INPUT_PORT_SUPPORTFORMAT_NUM_MAX    1
+#define OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX   3
+
+#ifdef USE_ANDROID_EXTENSION
+#define ANDROID_MAX_VIDEO_OUTPUTBUFFER_NUM   1
+#endif
+
+typedef struct
+{
+    void *pAddrY;
+    void *pAddrC;
+} MFC_DEC_ADDR_INFO;
+
+typedef struct _SEC_MFC_NBDEC_THREAD
+{
+    OMX_HANDLETYPE  hNBDecodeThread;
+    OMX_HANDLETYPE  hDecFrameStart;
+    OMX_HANDLETYPE  hDecFrameEnd;
+    OMX_BOOL        bExitDecodeThread;
+    OMX_BOOL        bDecoderRun;
+
+    OMX_U32         oneFrameSize;
+} SEC_MFC_NBDEC_THREAD;
+
+typedef struct _MFC_DEC_INPUT_BUFFER
+{
+    void *PhyAddr;      // physical address
+    void *VirAddr;      // virtual address
+    int   bufferSize;   // input buffer alloc size
+    int   dataSize;     // Data length
+} MFC_DEC_INPUT_BUFFER;
+
+#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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/Android.mk
new file mode 100644
index 0000000..1248e5e
--- /dev/null
+++ b/exynos3/s5pc110/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_H264dec.c \
+	library_register.c
+
+
+LOCAL_MODULE := libOMX.SEC.AVC.Decoder
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libSEC_OMX_Vdec libsecosal libsecbasecomponent \
+						libsecmfcdecapi libseccsc
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui libhardware
+
+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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.c
new file mode 100644
index 0000000..64ac7eb
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.c
@@ -0,0 +1,1479 @@
+/*
+ *
+ * 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"
+#include "color_space_convertor.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_H264_DEC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+//#define ADD_SPS_PPS_I_FRAME
+//#define FULL_FRAME_SEARCH
+
+/* H.264 Decoder Supported Levels & profiles */
+SEC_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels[] ={
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
+    {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
+
+    {OMX_VIDEO_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_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}};
+
+
+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) {
+#ifdef ADD_SPS_PPS_I_FRAME
+                if (naluType == 1 || naluType == 5)
+#else
+                if (naluType == 1 || naluType == 5 || naluType == 7 || naluType == 8)
+#endif
+                    naluStart = 1;
+            } else {
+#ifdef OLD_DETECT
+                frameTypeBoundary = (8 - naluType) & (naluType - 10); //AUD(9)
+#else
+                if (naluType == 9)
+                    frameTypeBoundary = -2;
+#endif
+                if (naluType == 1 || naluType == 5) {
+                    if (accessUnitSize == 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_COMPONENT_H264_DEC_ROLE);
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelQuerySupported:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
+        SEC_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
+        OMX_U32 maxProfileLevelNum = 0;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pProfileLevel = supportedAVCProfileLevels;
+        maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
+
+        if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
+            ret = OMX_ErrorNoMore;
+            goto EXIT;
+        }
+
+        pProfileLevel += pDstProfileLevel->nProfileIndex;
+        pDstProfileLevel->eProfile = pProfileLevel->profile;
+        pDstProfileLevel->eLevel = pProfileLevel->level;
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
+        SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Dec = (SEC_H264DEC_HANDLE *)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_COMPONENT_H264_DEC_ROLE)) {
+            pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+        } else {
+            ret = OMX_ErrorBadParameter;
+            goto EXIT;
+        }
+    }
+        break;
+    case OMX_IndexParamPortDefinition:
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
+        OMX_U32                       portIndex = pPortDefinition->nPortIndex;
+        SEC_OMX_BASEPORT             *pSECPort;
+        OMX_U32 width, height, size;
+
+        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;
+
+            switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
+            case OMX_COLOR_FormatYUV420Planar:
+            case OMX_COLOR_FormatYUV420SemiPlanar:
+            case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
+            case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
+                pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
+                break;
+            default:
+                SEC_OSAL_Log(SEC_LOG_ERROR, "Color format is not support!! use default YUV size!!");
+                ret = OMX_ErrorUnsupportedSetting;
+                break;
+            }
+        }
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
+        SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+
+        ret = SEC_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
+        if (ret != OMX_ErrorNone)
+            goto EXIT;
+
+        if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        pH264Dec = (SEC_H264DEC_HANDLE *)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_GetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    if (pComponentConfigStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    case OMX_IndexConfigCommonOutputCrop:
+    {
+        SEC_H264DEC_HANDLE  *pH264Dec = NULL;
+        OMX_CONFIG_RECTTYPE *pSrcRectType = NULL;
+        OMX_CONFIG_RECTTYPE *pDstRectType = NULL;
+        pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+
+        if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
+            ret = OMX_ErrorNotReady;
+            break;
+        }
+
+        pDstRectType = (OMX_CONFIG_RECTTYPE *)pComponentConfigStructure;
+
+        if ((pDstRectType->nPortIndex != INPUT_PORT_INDEX) &&
+            (pDstRectType->nPortIndex != OUTPUT_PORT_INDEX)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        SEC_OMX_BASEPORT *pSECPort = &pSECComponent->pSECPort[pDstRectType->nPortIndex];
+
+        pSrcRectType = &(pSECPort->cropRectangle);
+
+        pDstRectType->nTop = pSrcRectType->nTop;
+        pDstRectType->nLeft = pSrcRectType->nLeft;
+        pDstRectType->nHeight = pSrcRectType->nHeight;
+        pDstRectType->nWidth = pSrcRectType->nWidth;
+    }
+        break;
+    default:
+        ret = SEC_OMX_GetConfig(hComponent, nIndex, pComponentConfigStructure);
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_H264Dec_SetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    if (pComponentConfigStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    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, SEC_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
+        SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+        *pIndexType = OMX_IndexVendorThumbnailMode;
+        ret = OMX_ErrorNone;
+#ifdef USE_ANDROID_EXTENSION
+    } else if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_ENABLE_ANB) == 0) {
+	    if (isTvOutEnabled()) {
+	        // Samsung normally pushes HW-decoded frames to the TV Out driver
+	        // but it's hard for us to do that without source, so return an error
+	        // and let Android fallback to software decoding
+	        ret = OMX_ErrorInsufficientResources;
+	        goto EXIT;
+	    }
+
+        *pIndexType = OMX_IndexParamEnableAndroidBuffers;
+        ret = OMX_ErrorNone;
+    } else if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_GET_ANB) == 0) {
+        *pIndexType = OMX_IndexParamGetAndroidNativeBuffer;
+        ret = OMX_ErrorNone;
+    } else if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_USE_ANB) == 0) {
+        *pIndexType = OMX_IndexParamUseAndroidNativeBuffer;
+        ret = OMX_ErrorNone;
+#endif
+    } 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_COMPONENT_H264_DEC_ROLE);
+        ret = OMX_ErrorNone;
+    } else {
+        ret = OMX_ErrorNoMore;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_DecodeThread(OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_H264DEC_HANDLE    *pH264Dec = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pH264Dec = (SEC_H264DEC_HANDLE *)pSECComponent->hCodecHandle;
+
+    while (pH264Dec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
+        SEC_OSAL_SemaphoreWait(pH264Dec->NBDecThread.hDecFrameStart);
+
+        if (pH264Dec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
+            pH264Dec->hMFCH264Handle.returnCodec = SsbSipMfcDecExe(pH264Dec->hMFCH264Handle.hMFCHandle, pH264Dec->NBDecThread.oneFrameSize);
+            SEC_OSAL_SemaphorePost(pH264Dec->NBDecThread.hDecFrameEnd);
+        }
+    }
+
+EXIT:
+    SEC_OSAL_ThreadExit(NULL);
+    FunctionOut();
+
+    return ret;
+}
+
+/* MFC Init */
+OMX_ERRORTYPE SEC_MFC_H264Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    SEC_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 */
+    SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
+    hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen(&buf_type);
+    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 * MFC_INPUT_BUFFER_NUM_MAX);
+    if (pStreamBuffer == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+
+    pH264Dec->MFCDecInputBuffer[0].VirAddr = pStreamBuffer;
+    pH264Dec->MFCDecInputBuffer[0].PhyAddr = pStreamPhyBuffer;
+    pH264Dec->MFCDecInputBuffer[0].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE;
+    pH264Dec->MFCDecInputBuffer[0].dataSize = 0;
+    pH264Dec->MFCDecInputBuffer[1].VirAddr = (unsigned char *)pStreamBuffer + pH264Dec->MFCDecInputBuffer[0].bufferSize;
+    pH264Dec->MFCDecInputBuffer[1].PhyAddr = (unsigned char *)pStreamPhyBuffer + pH264Dec->MFCDecInputBuffer[0].bufferSize;
+    pH264Dec->MFCDecInputBuffer[1].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE;
+    pH264Dec->MFCDecInputBuffer[1].dataSize = 0;
+    pH264Dec->indexInputBuffer = 0;
+
+    pH264Dec->bFirstFrame = OMX_TRUE;
+
+    pH264Dec->NBDecThread.bExitDecodeThread = OMX_FALSE;
+    pH264Dec->NBDecThread.bDecoderRun = OMX_FALSE;
+    pH264Dec->NBDecThread.oneFrameSize = 0;
+    SEC_OSAL_SemaphoreCreate(&(pH264Dec->NBDecThread.hDecFrameStart));
+    SEC_OSAL_SemaphoreCreate(&(pH264Dec->NBDecThread.hDecFrameEnd));
+    if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pH264Dec->NBDecThread.hNBDecodeThread,
+                                                SEC_MFC_DecodeThread,
+                                                pOMXComponent)) {
+        pH264Dec->hMFCH264Handle.returnCodec = MFC_RET_OK;
+    }
+
+    pH264Dec->hMFCH264Handle.pMFCStreamBuffer    = pH264Dec->MFCDecInputBuffer[0].VirAddr;
+    pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pH264Dec->MFCDecInputBuffer[0].PhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pH264Dec->MFCDecInputBuffer[0].VirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].allocSize  = pH264Dec->MFCDecInputBuffer[0].bufferSize;
+
+    SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+    SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
+    pH264Dec->hMFCH264Handle.indexTimestamp = 0;
+    pSECComponent->getAllDelayBuffer = OMX_FALSE;
+
+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 (pH264Dec->NBDecThread.hNBDecodeThread != NULL) {
+        pH264Dec->NBDecThread.bExitDecodeThread = OMX_TRUE;
+        SEC_OSAL_SemaphorePost(pH264Dec->NBDecThread.hDecFrameStart);
+        SEC_OSAL_ThreadTerminate(pH264Dec->NBDecThread.hNBDecodeThread);
+        pH264Dec->NBDecThread.hNBDecodeThread = NULL;
+    }
+
+    if(pH264Dec->NBDecThread.hDecFrameEnd != NULL) {
+        SEC_OSAL_SemaphoreTerminate(pH264Dec->NBDecThread.hDecFrameEnd);
+        pH264Dec->NBDecThread.hDecFrameEnd = NULL;
+    }
+
+    if(pH264Dec->NBDecThread.hDecFrameStart != NULL) {
+        SEC_OSAL_SemaphoreTerminate(pH264Dec->NBDecThread.hDecFrameStart);
+        pH264Dec->NBDecThread.hDecFrameStart = NULL;
+    }
+
+    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;
+    int                        bufWidth = 0;
+    int                        bufHeight = 0;
+    OMX_BOOL                   outputDataValid = OMX_FALSE;
+
+    FunctionIn();
+
+    if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
+        SSBSIP_MFC_CODEC_TYPE eCodecType = H264_DEC;
+
+        if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = pInputData->nFlags;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+
+        setConfVal = 0;
+        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 = 1;
+            SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
+        } else {
+            setConfVal = 8;
+            SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
+        }
+
+        pH264Dec->hMFCH264Handle.returnCodec = SsbSipMfcDecInit(pH264Dec->hMFCH264Handle.hMFCHandle, eCodecType, oneFrameSize);
+        if (pH264Dec->hMFCH264Handle.returnCodec == MFC_RET_OK) {
+            SSBSIP_MFC_IMG_RESOLUTION imgResol;
+            SSBSIP_MFC_CROP_INFORMATION cropInfo;
+            SEC_OMX_BASEPORT *secInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+            SEC_OMX_BASEPORT *secOutputPort = &pSECComponent->pSECPort[OUTPUT_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);
+
+            SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_CROP_INFO, &cropInfo);
+            SEC_OSAL_Log(SEC_LOG_TRACE, "mfc crop_top crop_bottom crop_left crop_right :  %d, %d, %d, %d",
+                            cropInfo.crop_top_offset , cropInfo.crop_bottom_offset ,
+                            cropInfo.crop_left_offset , cropInfo.crop_right_offset);
+
+            secOutputPort->cropRectangle.nTop    = cropInfo.crop_top_offset;
+            secOutputPort->cropRectangle.nLeft   = cropInfo.crop_left_offset;
+            secOutputPort->cropRectangle.nWidth  = imgResol.width - cropInfo.crop_left_offset - cropInfo.crop_right_offset;
+            secOutputPort->cropRectangle.nHeight = imgResol.height - cropInfo.crop_top_offset - cropInfo.crop_bottom_offset;
+
+            pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_TRUE;
+
+            /** Update Frame Size **/
+            if ((cropInfo.crop_left_offset != 0) || (cropInfo.crop_right_offset != 0) ||
+                (cropInfo.crop_top_offset != 0) || (cropInfo.crop_bottom_offset != 0)) {
+                /* change width and height information */
+                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 crop info call back */
+                (*(pSECComponent->pCallbacks->EventHandler))
+                      (pOMXComponent,
+                       pSECComponent->callbackData,
+                       OMX_EventPortSettingsChanged, /* The command was completed */
+                       OMX_DirOutput, /* This is the port index */
+                       OMX_IndexConfigCommonOutputCrop,
+                       NULL);
+            } else 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);
+            }
+
+#ifdef ADD_SPS_PPS_I_FRAME
+            ret = OMX_ErrorInputDataDecodeYet;
+#else
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = pInputData->nFlags;
+
+            ret = OMX_ErrorNone;
+#endif
+            goto EXIT;
+        } else {
+            ret = OMX_ErrorMFCInit;
+            goto EXIT;
+        }
+    }
+
+#ifndef FULL_FRAME_SEARCH
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE))
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+#endif
+
+    pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
+    pSECComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->nFlags;
+
+    if ((pH264Dec->hMFCH264Handle.returnCodec == MFC_RET_OK) &&
+        (pH264Dec->bFirstFrame == OMX_FALSE)) {
+        SSBSIP_MFC_DEC_OUTBUF_STATUS status;
+        OMX_S32 indexTimestamp = 0;
+
+        /* wait for mfc decode done */
+        if (pH264Dec->NBDecThread.bDecoderRun == OMX_TRUE) {
+            SEC_OSAL_SemaphoreWait(pH264Dec->NBDecThread.hDecFrameEnd);
+            pH264Dec->NBDecThread.bDecoderRun = OMX_FALSE;
+        }
+
+        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) ||
+            (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = (pInputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+        } else {
+            pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
+            pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
+        }
+        SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6);
+
+        if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
+            (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
+            outputDataValid = OMX_TRUE;
+        }
+        if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
+            outputDataValid = OMX_FALSE;
+
+        if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
+            (pSECComponent->getAllDelayBuffer == OMX_TRUE))
+            ret = OMX_ErrorInputDataDecodeYet;
+
+        if(status == MFC_GETOUTBUF_DECODING_ONLY) {
+            if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
+                ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
+                pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
+                pSECComponent->getAllDelayBuffer = OMX_TRUE;
+                ret = OMX_ErrorInputDataDecodeYet;
+            } else {
+                ret = OMX_ErrorNone;
+            }
+            outputDataValid = OMX_FALSE;
+        }
+
+#ifdef FULL_FRAME_SEARCH
+        if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
+            (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
+            pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
+            pSECComponent->getAllDelayBuffer = OMX_TRUE;
+            ret = OMX_ErrorInputDataDecodeYet;
+        } else
+#endif
+        if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
+            //setConfVal = 1;
+            //SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_IS_LAST_FRAME, &setConfVal);
+            pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+            pSECComponent->getAllDelayBuffer = OMX_TRUE;
+            ret = OMX_ErrorInputDataDecodeYet;
+        } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+            ret = OMX_ErrorNone;
+        }
+    } else {
+        pOutputData->timeStamp = pInputData->timeStamp;
+        pOutputData->nFlags = pInputData->nFlags;
+
+        if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
+            (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
+            (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
+            pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+        }
+        if ((pH264Dec->bFirstFrame == OMX_TRUE) &&
+            ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
+            pInputData->nFlags = (pInputData->nFlags | OMX_BUFFERFLAG_EOS);
+            pOutputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+        }
+
+        outputDataValid = OMX_FALSE;
+
+        /* ret = OMX_ErrorUndefined; */
+        ret = OMX_ErrorNone;
+    }
+
+    if (ret == OMX_ErrorInputDataDecodeYet) {
+        pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].dataSize = oneFrameSize;
+        pH264Dec->indexInputBuffer++;
+        pH264Dec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
+        pH264Dec->hMFCH264Handle.pMFCStreamBuffer    = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].VirAddr;
+        pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].PhyAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].VirAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].bufferSize;
+        oneFrameSize = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].dataSize;
+        //pInputData->dataLen = oneFrameSize;
+        //pInputData->remainDataLen = oneFrameSize;
+    }
+
+    if ((Check_H264_StartCode(pInputData->dataBuffer, pInputData->dataLen) == OMX_TRUE) &&
+        ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
+        SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pH264Dec->hMFCH264Handle.indexTimestamp));
+        pH264Dec->hMFCH264Handle.indexTimestamp++;
+        pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
+
+        SsbSipMfcDecSetInBuf(pH264Dec->hMFCH264Handle.hMFCHandle,
+                             pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer,
+                             pH264Dec->hMFCH264Handle.pMFCStreamBuffer,
+                             pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
+
+        pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].dataSize = oneFrameSize;
+        pH264Dec->NBDecThread.oneFrameSize = oneFrameSize;
+
+        /* mfc decode start */
+        SEC_OSAL_SemaphorePost(pH264Dec->NBDecThread.hDecFrameStart);
+        pH264Dec->NBDecThread.bDecoderRun = OMX_TRUE;
+        pH264Dec->hMFCH264Handle.returnCodec = MFC_RET_OK;
+
+        pH264Dec->indexInputBuffer++;
+        pH264Dec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
+        pH264Dec->hMFCH264Handle.pMFCStreamBuffer    = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].VirAddr;
+        pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].PhyAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].VirAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pH264Dec->MFCDecInputBuffer[pH264Dec->indexInputBuffer].bufferSize;
+        if (((pH264Dec->hMFCH264Handle.bThumbnailMode == OMX_TRUE) || (pSECComponent->bSaveFlagEOS == OMX_TRUE)) &&
+            (pH264Dec->bFirstFrame == OMX_TRUE) &&
+            (outputDataValid == OMX_FALSE)) {
+            ret = OMX_ErrorInputDataDecodeYet;
+        }
+        pH264Dec->bFirstFrame = OMX_FALSE;
+    }
+
+    /** Fill Output Buffer **/
+    if (outputDataValid == OMX_TRUE) {
+        SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+        SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+        void *pOutputBuf[3];
+
+        int frameSize = bufWidth * bufHeight;
+        int imageSize = outputInfo.img_width * outputInfo.img_height;
+
+        int actualWidth  = outputInfo.img_width;
+        int actualHeight = outputInfo.img_height;
+        int actualImageSize = imageSize;
+
+        pOutputBuf[0] = (void *)pOutputData->dataBuffer;
+        pOutputBuf[1] = (void *)pOutputData->dataBuffer + actualImageSize;
+        pOutputBuf[2] = (void *)pOutputData->dataBuffer + ((actualImageSize * 5) / 4);
+
+#ifdef USE_ANDROID_EXTENSION
+        if (pSECOutputPort->bUseAndroidNativeBuffer == OMX_TRUE) {
+            OMX_U32 retANB = 0;
+            void *pVirAddrs[2];
+            actualWidth  = (outputInfo.img_width + 15) & (~15);
+            actualImageSize = actualWidth * actualHeight;
+
+            retANB = getVADDRfromANB (pOutputData->dataBuffer,
+                            (OMX_U32)pSECInputPort->portDefinition.format.video.nFrameWidth,
+                            (OMX_U32)pSECInputPort->portDefinition.format.video.nFrameHeight,
+                            pVirAddrs);
+            if (retANB != 0) {
+                SEC_OSAL_Log(SEC_LOG_ERROR, "Error getVADDRfromANB, Error code:%d", retANB);
+                ret = OMX_ErrorOverflow;
+                goto EXIT;
+            }
+            pOutputBuf[0] = pVirAddrs[0];
+            pOutputBuf[1] = pVirAddrs[1];
+        }
+#endif
+        if ((pH264Dec->hMFCH264Handle.bThumbnailMode == OMX_FALSE) &&
+            (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress))
+        {
+            /* if use Post copy address structure */
+            SEC_OSAL_Memcpy(pOutputBuf[0], &frameSize, sizeof(frameSize));
+            SEC_OSAL_Memcpy(pOutputBuf[0] + sizeof(frameSize), &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
+            SEC_OSAL_Memcpy(pOutputBuf[0] + sizeof(frameSize) + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
+            SEC_OSAL_Memcpy(pOutputBuf[0] + sizeof(frameSize) + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
+            SEC_OSAL_Memcpy(pOutputBuf[0] + sizeof(frameSize) + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
+            pOutputData->dataLen = (bufWidth * bufHeight * 3) / 2;
+        } else {
+            switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
+            case OMX_COLOR_FormatYUV420Planar:
+            {
+                SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420P out");
+                csc_tiled_to_linear(
+                    (unsigned char *)pOutputBuf[0],
+                    (unsigned char *)outputInfo.YVirAddr,
+                    actualWidth,
+                    actualHeight);
+                csc_tiled_to_linear_deinterleave(
+                    (unsigned char *)pOutputBuf[1],
+                    (unsigned char *)pOutputBuf[2],
+                    (unsigned char *)outputInfo.CVirAddr,
+                    actualWidth,
+                    actualHeight >> 1);
+                pOutputData->dataLen = actualImageSize * 3 / 2;
+            }
+                break;
+            case OMX_COLOR_FormatYUV420SemiPlanar:
+            case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
+            default:
+            {
+                SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420SP out");
+                csc_tiled_to_linear(
+                    (unsigned char *)pOutputBuf[0],
+                    (unsigned char *)outputInfo.YVirAddr,
+                    actualWidth,
+                    actualHeight);
+                csc_tiled_to_linear(
+                    (unsigned char *)pOutputBuf[1],
+                    (unsigned char *)outputInfo.CVirAddr,
+                    actualWidth,
+                    actualHeight >> 1);
+                pOutputData->dataLen = actualImageSize * 3 / 2;
+            }
+                break;
+            }
+        }
+#ifdef USE_ANDROID_EXTENSION
+        if (pSECOutputPort->bUseAndroidNativeBuffer == OMX_TRUE)
+            putVADDRtoANB(pOutputData->dataBuffer);
+#endif
+    } else {
+        pOutputData->dataLen = 0;
+    }
+
+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;
+    }
+
+    ret = SEC_MFC_H264_Decode(pOMXComponent, pInputData, pOutputData);
+    if (ret != OMX_ErrorNone) {
+        if (ret == OMX_ErrorInputDataDecodeYet) {
+            pOutputData->usedDataLen = 0;
+            pOutputData->remainDataLen = pOutputData->dataLen;
+        } else {
+            pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
+                                                    pSECComponent->callbackData,
+                                                    OMX_EventError, ret, 0, NULL);
+        }
+    } else {
+        pInputData->previousDataLen = pInputData->dataLen;
+        pInputData->usedDataLen += pInputData->dataLen;
+        pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen;
+        pInputData->dataLen -= pInputData->usedDataLen;
+        pInputData->usedDataLen = 0;
+
+        pOutputData->usedDataLen = 0;
+        pOutputData->remainDataLen = pOutputData->dataLen;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OSCL_EXPORT_REF OMX_ERRORTYPE SEC_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
+{
+    OMX_ERRORTYPE            ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE       *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT   *pSECComponent = NULL;
+    SEC_OMX_BASEPORT        *pSECPort = NULL;
+    SEC_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_COMPONENT_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_COMPONENT_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_FormatYUV420SemiPlanar;
+    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->GetConfig         = &SEC_MFC_H264Dec_GetConfig;
+    pOMXComponent->SetConfig         = &SEC_MFC_H264Dec_SetConfig;
+    pOMXComponent->GetExtensionIndex = &SEC_MFC_H264Dec_GetExtensionIndex;
+    pOMXComponent->ComponentRoleEnum = &SEC_MFC_H264Dec_ComponentRoleEnum;
+    pOMXComponent->ComponentDeInit   = &SEC_OMX_ComponentDeinit;
+
+    pSECComponent->sec_mfc_componentInit      = &SEC_MFC_H264Dec_Init;
+    pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_H264Dec_Terminate;
+    pSECComponent->sec_mfc_bufferProcess      = &SEC_MFC_H264Dec_bufferProcess;
+    pSECComponent->sec_checkInputFrame        = &Check_H264_Frame;
+
+    pSECComponent->currentState = OMX_StateLoaded;
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE            ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE       *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT   *pSECComponent = NULL;
+    SEC_H264DEC_HANDLE      *pH264Dec = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    SEC_OSAL_Free(pSECComponent->componentName);
+    pSECComponent->componentName = NULL;
+
+    pH264Dec = (SEC_H264DEC_HANDLE *)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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.h
new file mode 100644
index 0000000..d3f8ac8
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/SEC_OMX_H264dec.h
@@ -0,0 +1,73 @@
+/*
+ *
+ * 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"
+
+
+typedef struct _SEC_MFC_H264DEC_HANDLE
+{
+    OMX_HANDLETYPE hMFCHandle;
+    OMX_PTR pMFCStreamBuffer;
+    OMX_PTR pMFCStreamPhyBuffer;
+    OMX_U32    indexTimestamp;
+    OMX_BOOL bConfiguredMFC;
+    OMX_BOOL bThumbnailMode;
+    OMX_S32  returnCodec;
+} 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;
+
+    /* For Non-Block mode */
+    SEC_MFC_NBDEC_THREAD NBDecThread;
+    OMX_BOOL bFirstFrame;
+    MFC_DEC_INPUT_BUFFER MFCDecInputBuffer[MFC_INPUT_BUFFER_NUM_MAX];
+    OMX_U32  indexInputBuffer;
+} 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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.c
new file mode 100644
index 0000000..ef3d672
--- /dev/null
+++ b/exynos3/s5pc110/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_COMPONENT_H264_DEC);
+    SEC_OSAL_Strcpy(secComponents[0]->roles[0], SEC_OMX_COMPONENT_H264_DEC_ROLE);
+    secComponents[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+    FunctionOut();
+
+    return MAX_COMPONENT_NUM;
+}
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/h264dec/library_register.h
new file mode 100644
index 0000000..7a6f7a1
--- /dev/null
+++ b/exynos3/s5pc110/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_COMPONENT_H264_DEC "OMX.SEC.AVC.Decoder"
+#define SEC_OMX_COMPONENT_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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/Android.mk
new file mode 100644
index 0000000..1e7d1e5
--- /dev/null
+++ b/exynos3/s5pc110/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_Mpeg4dec.c \
+	library_register.c
+
+
+LOCAL_MODULE := libOMX.SEC.M4V.Decoder
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libSEC_OMX_Vdec libsecosal libsecbasecomponent \
+						libsecmfcdecapi libseccsc
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui libhardware
+
+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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.c
new file mode 100644
index 0000000..fb679da
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.c
@@ -0,0 +1,1652 @@
+/*
+ *
+ * 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"
+#include "color_space_convertor.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_MPEG4_DEC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+//#define FULL_FRAME_SEARCH
+
+/* 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;
+    unsigned pTypeMask = 0x03;
+    unsigned pType = 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) || (pType != 0x02)) {
+            readStream = *(pInputStream + len);
+            startCode = (startCode << 8) | readStream;
+
+            readStream = *(pInputStream + len + 1);
+            pType = readStream & pTypeMask;
+
+            len++;
+            if (len > buffSize)
+                goto EXIT;
+        }
+    }
+
+    /* find next PSC */
+    startCode = 0xFFFFFFFF;
+    pType = 0;
+    while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
+        readStream = *(pInputStream + len);
+        startCode = (startCode << 8) | readStream;
+
+        readStream = *(pInputStream + len + 1);
+        pType = readStream & pTypeMask;
+
+        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:
+        if (streamSize > 0)
+            return OMX_TRUE;
+        else
+            return OMX_FALSE;
+    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_COMPONENT_MPEG4_DEC_ROLE);
+        else
+            SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPONENT_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_COMPONENT_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_COMPONENT_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;
+
+            switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
+            case OMX_COLOR_FormatYUV420Planar:
+            case OMX_COLOR_FormatYUV420SemiPlanar:
+            case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
+            case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
+                pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
+                break;
+            default:
+                SEC_OSAL_Log(SEC_LOG_ERROR, "Color format is not support!! use default YUV size!!");
+                ret = OMX_ErrorUnsupportedSetting;
+                break;
+            }
+        }
+    }
+        break;
+    case OMX_IndexParamVideoProfileLevelCurrent:
+    {
+        OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
+        OMX_VIDEO_PARAM_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_GetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    if (pComponentConfigStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    default:
+        ret = SEC_OMX_GetConfig(hComponent, nIndex, pComponentConfigStructure);
+        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, SEC_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
+        SEC_MPEG4_HANDLE *pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+        *pIndexType = OMX_IndexVendorThumbnailMode;
+        ret = OMX_ErrorNone;
+#ifdef USE_ANDROID_EXTENSION
+    } else if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_ENABLE_ANB) == 0) {
+	    if (isTvOutEnabled()) {
+	        // Samsung normally pushes HW-decoded frames to the TV Out driver
+	        // but it's hard for us to do that without source, so return an error
+	        // and let Android fallback to software decoding
+	        ret = OMX_ErrorInsufficientResources;
+	        goto EXIT;
+	    }
+
+        *pIndexType = OMX_IndexParamEnableAndroidBuffers;
+        ret = OMX_ErrorNone;
+    } else if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_GET_ANB) == 0) {
+        *pIndexType = OMX_IndexParamGetAndroidNativeBuffer;
+        ret = OMX_ErrorNone;
+    } else if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_USE_ANB) == 0) {
+        *pIndexType = OMX_IndexParamUseAndroidNativeBuffer;
+        ret = OMX_ErrorNone;
+#endif
+    } 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_COMPONENT_MPEG4_DEC_ROLE);
+    else
+        SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPONENT_H263_DEC_ROLE);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_DecodeThread(OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_MPEG4_HANDLE      *pMpeg4Dec = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pMpeg4Dec = (SEC_MPEG4_HANDLE *)pSECComponent->hCodecHandle;
+
+    while (pMpeg4Dec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
+        SEC_OSAL_SemaphoreWait(pMpeg4Dec->NBDecThread.hDecFrameStart);
+
+        if (pMpeg4Dec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
+            pMpeg4Dec->hMFCMpeg4Handle.returnCodec = SsbSipMfcDecExe(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle, pMpeg4Dec->NBDecThread.oneFrameSize);
+            SEC_OSAL_SemaphorePost(pMpeg4Dec->NBDecThread.hDecFrameEnd);
+        }
+    }
+
+EXIT:
+    SEC_OSAL_ThreadExit(NULL);
+    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 */
+    SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
+    hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen(&buf_type);
+    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->MFCDecInputBuffer[0].VirAddr = pStreamBuffer;
+    pMpeg4Dec->MFCDecInputBuffer[0].PhyAddr = pStreamPhyBuffer;
+    pMpeg4Dec->MFCDecInputBuffer[0].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE;
+    pMpeg4Dec->MFCDecInputBuffer[0].dataSize = 0;
+    pMpeg4Dec->MFCDecInputBuffer[1].VirAddr = (unsigned char *)pStreamBuffer + pMpeg4Dec->MFCDecInputBuffer[0].bufferSize;
+    pMpeg4Dec->MFCDecInputBuffer[1].PhyAddr = (unsigned char *)pStreamPhyBuffer + pMpeg4Dec->MFCDecInputBuffer[0].bufferSize;
+    pMpeg4Dec->MFCDecInputBuffer[1].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE;
+    pMpeg4Dec->MFCDecInputBuffer[1].dataSize = 0;
+    pMpeg4Dec->indexInputBuffer = 0;
+
+    pMpeg4Dec->bFirstFrame = OMX_TRUE;
+
+    pMpeg4Dec->NBDecThread.bExitDecodeThread = OMX_FALSE;
+    pMpeg4Dec->NBDecThread.bDecoderRun = OMX_FALSE;
+    pMpeg4Dec->NBDecThread.oneFrameSize = 0;
+    SEC_OSAL_SemaphoreCreate(&(pMpeg4Dec->NBDecThread.hDecFrameStart));
+    SEC_OSAL_SemaphoreCreate(&(pMpeg4Dec->NBDecThread.hDecFrameEnd));
+    if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pMpeg4Dec->NBDecThread.hNBDecodeThread,
+                                                SEC_MFC_DecodeThread,
+                                                pOMXComponent)) {
+        pMpeg4Dec->hMFCMpeg4Handle.returnCodec = MFC_RET_OK;
+    }
+
+    pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer    = pMpeg4Dec->MFCDecInputBuffer[0].VirAddr;
+    pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer = pMpeg4Dec->MFCDecInputBuffer[0].PhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pMpeg4Dec->MFCDecInputBuffer[0].VirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pMpeg4Dec->MFCDecInputBuffer[0].bufferSize;
+
+    SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+    SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
+    pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp = 0;
+    pSECComponent->getAllDelayBuffer = OMX_FALSE;
+
+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 (pMpeg4Dec->NBDecThread.hNBDecodeThread != NULL) {
+        pMpeg4Dec->NBDecThread.bExitDecodeThread = OMX_TRUE;
+        SEC_OSAL_SemaphorePost(pMpeg4Dec->NBDecThread.hDecFrameStart);
+        SEC_OSAL_ThreadTerminate(pMpeg4Dec->NBDecThread.hNBDecodeThread);
+        pMpeg4Dec->NBDecThread.hNBDecodeThread = NULL;
+    }
+
+    if(pMpeg4Dec->NBDecThread.hDecFrameEnd != NULL) {
+        SEC_OSAL_SemaphoreTerminate(pMpeg4Dec->NBDecThread.hDecFrameEnd);
+        pMpeg4Dec->NBDecThread.hDecFrameEnd = NULL;
+    }
+
+    if(pMpeg4Dec->NBDecThread.hDecFrameStart != NULL) {
+        SEC_OSAL_SemaphoreTerminate(pMpeg4Dec->NBDecThread.hDecFrameStart);
+        pMpeg4Dec->NBDecThread.hDecFrameStart = NULL;
+    }
+
+    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 = 0;
+    int                        bufWidth = 0;
+    int                        bufHeight = 0;
+    OMX_BOOL                   outputDataValid = OMX_FALSE;
+
+    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;
+        }
+
+        if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = pInputData->nFlags;
+            ret = OMX_ErrorNone;
+            goto EXIT;
+        }
+
+        /* Set the number of extra buffer to prevent tearing */
+        configValue = 0;
+        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 = 1;    // the number that you want to delay
+            SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &configValue);
+        }
+
+        pMpeg4Dec->hMFCMpeg4Handle.returnCodec = SsbSipMfcDecInit(hMFCHandle, MFCCodecType, oneFrameSize);
+        if (pMpeg4Dec->hMFCMpeg4Handle.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) {
+                pOutputData->timeStamp = pInputData->timeStamp;
+                pOutputData->nFlags = pInputData->nFlags;
+                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;
+        }
+    }
+
+#ifndef FULL_FRAME_SEARCH
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE))
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+#endif
+
+    pSECComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pInputData->timeStamp;
+    pSECComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pInputData->nFlags;
+
+    if ((pMpeg4Dec->hMFCMpeg4Handle.returnCodec == MFC_RET_OK) &&
+        (pMpeg4Dec->bFirstFrame == OMX_FALSE)) {
+        SSBSIP_MFC_DEC_OUTBUF_STATUS status;
+        OMX_S32 indexTimestamp = 0;
+
+        /* wait for mfc decode done */
+        if (pMpeg4Dec->NBDecThread.bDecoderRun == OMX_TRUE) {
+            SEC_OSAL_SemaphoreWait(pMpeg4Dec->NBDecThread.hDecFrameEnd);
+            pMpeg4Dec->NBDecThread.bDecoderRun = OMX_FALSE;
+        }
+
+        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) ||
+            (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = (pInputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+        } else {
+            pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
+            pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
+        }
+        SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6);
+
+        if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
+            (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
+            outputDataValid = OMX_TRUE;
+        }
+        if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
+            outputDataValid = OMX_FALSE;
+
+        if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
+            (pSECComponent->getAllDelayBuffer == OMX_TRUE))
+            ret = OMX_ErrorInputDataDecodeYet;
+
+        if (status == MFC_GETOUTBUF_DECODING_ONLY) {
+            if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
+                ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
+                pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
+                pSECComponent->getAllDelayBuffer = OMX_TRUE;
+                ret = OMX_ErrorInputDataDecodeYet;
+            } else {
+                ret = OMX_ErrorNone;
+            }
+            outputDataValid = OMX_FALSE;
+        }
+
+#ifdef FULL_FRAME_SEARCH
+        if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
+            (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
+            pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
+            pSECComponent->getAllDelayBuffer = OMX_TRUE;
+            ret = OMX_ErrorInputDataDecodeYet;
+        } else
+#endif
+        if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
+            //configValue = 1;
+            //SsbSipMfcDecSetConfig(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle, MFC_DEC_SETCONF_IS_LAST_FRAME, &configValue);
+            pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+            pSECComponent->getAllDelayBuffer = OMX_TRUE;
+            ret = OMX_ErrorInputDataDecodeYet;
+        } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+            ret = OMX_ErrorNone;
+        }
+    } else {
+        pOutputData->timeStamp = pInputData->timeStamp;
+        pOutputData->nFlags = pInputData->nFlags;
+
+        if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
+            (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
+            (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
+            pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+        }
+        if ((pMpeg4Dec->bFirstFrame == OMX_TRUE) &&
+            ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
+            pInputData->nFlags = (pInputData->nFlags | OMX_BUFFERFLAG_EOS);
+            pOutputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+        }
+
+        outputDataValid = OMX_FALSE;
+
+        /* ret = OMX_ErrorUndefined; */
+            ret = OMX_ErrorNone;
+    }
+
+    if (ret == OMX_ErrorInputDataDecodeYet) {
+        pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].dataSize = oneFrameSize;
+        pMpeg4Dec->indexInputBuffer++;
+        pMpeg4Dec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
+        pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer    = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].VirAddr;
+        pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].PhyAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].VirAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].bufferSize;
+        oneFrameSize = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].dataSize;
+        //pInputData->dataLen = oneFrameSize;
+        //pInputData->remainDataLen = oneFrameSize;
+    }
+
+    if ((Check_Stream_PrefixCode(pInputData->dataBuffer, pInputData->dataLen, pMpeg4Dec->hMFCMpeg4Handle.codecType) == OMX_TRUE) &&
+        ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
+        SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp));
+        pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp++;
+        pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
+
+        SsbSipMfcDecSetInBuf(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle,
+                             pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer,
+                             pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer,
+                             pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
+
+        pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].dataSize = oneFrameSize;
+        pMpeg4Dec->NBDecThread.oneFrameSize = oneFrameSize;
+
+        /* mfc decode start */
+        SEC_OSAL_SemaphorePost(pMpeg4Dec->NBDecThread.hDecFrameStart);
+        pMpeg4Dec->NBDecThread.bDecoderRun = OMX_TRUE;
+        pMpeg4Dec->hMFCMpeg4Handle.returnCodec = MFC_RET_OK;
+
+        pMpeg4Dec->indexInputBuffer++;
+        pMpeg4Dec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
+        pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer    = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].VirAddr;
+        pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].PhyAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].VirAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pMpeg4Dec->MFCDecInputBuffer[pMpeg4Dec->indexInputBuffer].bufferSize;
+        if (((pMpeg4Dec->hMFCMpeg4Handle.bThumbnailMode == OMX_TRUE) || (pSECComponent->bSaveFlagEOS == OMX_TRUE)) &&
+            (pMpeg4Dec->bFirstFrame == OMX_TRUE) &&
+            (outputDataValid == OMX_FALSE)) {
+            ret = OMX_ErrorInputDataDecodeYet;
+        }
+        pMpeg4Dec->bFirstFrame = OMX_FALSE;
+    }
+
+    /** Fill Output Buffer **/
+    if (outputDataValid == OMX_TRUE) {
+        SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+        SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+        void *pOutputBuf[3];
+
+        int frameSize = bufWidth * bufHeight;
+        int imageSize = outputInfo.img_width * outputInfo.img_height;
+
+        int actualWidth  = outputInfo.img_width;
+        int actualHeight = outputInfo.img_height;
+        int actualImageSize = imageSize;
+
+        pOutputBuf[0] = (void *)pOutputData->dataBuffer;
+        pOutputBuf[1] = (void *)pOutputData->dataBuffer + actualImageSize;
+        pOutputBuf[2] = (void *)pOutputData->dataBuffer + ((actualImageSize * 5) / 4);
+
+#ifdef USE_ANDROID_EXTENSION
+        if (pSECOutputPort->bUseAndroidNativeBuffer == OMX_TRUE) {
+            OMX_U32 retANB = 0;
+            void *pVirAddrs[2];
+            actualWidth  = (outputInfo.img_width + 15) & (~15);
+            actualImageSize = actualWidth * actualHeight;
+
+             retANB = getVADDRfromANB(pOutputData->dataBuffer,
+                            (OMX_U32)pSECInputPort->portDefinition.format.video.nFrameWidth,
+                            (OMX_U32)pSECInputPort->portDefinition.format.video.nFrameHeight,
+                            pVirAddrs);
+            if (retANB != 0) {
+                SEC_OSAL_Log(SEC_LOG_ERROR, "Error getVADDRfromANB, Error code:%d", retANB);
+                ret = OMX_ErrorOverflow;
+                goto EXIT;
+            }
+            pOutputBuf[0] = pVirAddrs[0];
+            pOutputBuf[1] = pVirAddrs[1];
+        }
+#endif
+        if ((pMpeg4Dec->hMFCMpeg4Handle.bThumbnailMode == OMX_FALSE) &&
+            (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress))
+        {
+            /* if use Post copy address structure */
+            SEC_OSAL_Memcpy(pOutputBuf[0], &frameSize, sizeof(frameSize));
+            SEC_OSAL_Memcpy(pOutputBuf[0] + sizeof(frameSize), &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
+            SEC_OSAL_Memcpy(pOutputBuf[0] + sizeof(frameSize) + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
+            SEC_OSAL_Memcpy(pOutputBuf[0] + sizeof(frameSize) + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
+            SEC_OSAL_Memcpy(pOutputBuf[0] + sizeof(frameSize) + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
+            pOutputData->dataLen = (bufWidth * bufHeight * 3) / 2;
+        } else {
+            switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
+            case OMX_COLOR_FormatYUV420Planar:
+            {
+                SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420P out");
+                csc_tiled_to_linear(
+                    (unsigned char *)pOutputBuf[0],
+                    (unsigned char *)outputInfo.YVirAddr,
+                    actualWidth,
+                    actualHeight);
+                csc_tiled_to_linear_deinterleave(
+                    (unsigned char *)pOutputBuf[1],
+                    (unsigned char *)pOutputBuf[2],
+                    (unsigned char *)outputInfo.CVirAddr,
+                    actualWidth,
+                    actualHeight >> 1);
+                pOutputData->dataLen = actualImageSize * 3 / 2;
+            }
+                break;
+            case OMX_COLOR_FormatYUV420SemiPlanar:
+            case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
+            default:
+            {
+                SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420SP out");
+                csc_tiled_to_linear(
+                    (unsigned char *)pOutputBuf[0],
+                    (unsigned char *)outputInfo.YVirAddr,
+                    actualWidth,
+                    actualHeight);
+                csc_tiled_to_linear(
+                    (unsigned char *)pOutputBuf[1],
+                    (unsigned char *)outputInfo.CVirAddr,
+                    actualWidth,
+                    actualHeight >> 1);
+                pOutputData->dataLen = actualImageSize * 3 / 2;
+            }
+                break;
+            }
+        }
+#ifdef USE_ANDROID_EXTENSION
+        if (pSECOutputPort->bUseAndroidNativeBuffer == OMX_TRUE)
+            putVADDRtoANB(pOutputData->dataBuffer);
+#endif
+    } else {
+        pOutputData->dataLen = 0;
+    }
+
+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))) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+    if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    ret = SEC_MFC_Mpeg4_Decode(pOMXComponent, pInputData, pOutputData);
+    if (ret != OMX_ErrorNone) {
+        if (ret == OMX_ErrorInputDataDecodeYet) {
+            pOutputData->usedDataLen = 0;
+            pOutputData->remainDataLen = pOutputData->dataLen;
+        } else {
+            pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
+                                                    pSECComponent->callbackData,
+                                                    OMX_EventError, ret, 0, NULL);
+        }
+    } else {
+        pInputData->previousDataLen = pInputData->dataLen;
+        pInputData->usedDataLen += pInputData->dataLen;
+        pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen;
+        pInputData->dataLen -= pInputData->usedDataLen;
+        pInputData->usedDataLen = 0;
+
+        pOutputData->usedDataLen = 0;
+        pOutputData->remainDataLen = pOutputData->dataLen;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OSCL_EXPORT_REF OMX_ERRORTYPE SEC_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
+{
+    OMX_ERRORTYPE            ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE       *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT   *pSECComponent = NULL;
+    SEC_OMX_BASEPORT        *pSECPort = NULL;
+    SEC_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_COMPONENT_MPEG4_DEC, componentName) == 0) {
+        codecType = CODEC_TYPE_MPEG4;
+    } else if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_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_COMPONENT_MPEG4_DEC);
+    else
+        SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_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_FormatYUV420SemiPlanar;
+    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->GetConfig         = &SEC_MFC_Mpeg4Dec_GetConfig;
+    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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.h
new file mode 100644
index 0000000..9af04e3
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/SEC_OMX_Mpeg4dec.h
@@ -0,0 +1,98 @@
+/*
+ *
+ * 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"
+
+
+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_U32        indexTimestamp;
+    OMX_BOOL       bConfiguredMFC;
+    OMX_BOOL       bThumbnailMode;
+    CODEC_TYPE     codecType;
+    OMX_S32        returnCodec;
+} 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;
+
+    /* For Non-Block mode */
+    SEC_MFC_NBDEC_THREAD NBDecThread;
+    OMX_BOOL bFirstFrame;
+    MFC_DEC_INPUT_BUFFER MFCDecInputBuffer[MFC_INPUT_BUFFER_NUM_MAX];
+    OMX_U32  indexInputBuffer;
+} 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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.c
new file mode 100644
index 0000000..02d8d39
--- /dev/null
+++ b/exynos3/s5pc110/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_COMPONENT_MPEG4_DEC);
+    SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPONENT_MPEG4_DEC_ROLE);
+    ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+    /* component 2 - video decoder H.263 */
+    SEC_OSAL_Strcpy(ppSECComponent[1]->componentName, SEC_OMX_COMPONENT_H263_DEC);
+    SEC_OSAL_Strcpy(ppSECComponent[1]->roles[0], SEC_OMX_COMPONENT_H263_DEC_ROLE);
+    ppSECComponent[1]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+    FunctionOut();
+    return MAX_COMPONENT_NUM;
+}
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/dec/mpeg4dec/library_register.h
new file mode 100644
index 0000000..c3e5b9c
--- /dev/null
+++ b/exynos3/s5pc110/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_COMPONENT_MPEG4_DEC         "OMX.SEC.MPEG4.Decoder"
+#define SEC_OMX_COMPONENT_MPEG4_DEC_ROLE    "video_decoder.mpeg4"
+
+/* H.263 */
+#define SEC_OMX_COMPONENT_H263_DEC          "OMX.SEC.H263.Decoder"
+#define SEC_OMX_COMPONENT_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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/Android.mk
new file mode 100644
index 0000000..aa671f8
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/Android.mk
@@ -0,0 +1,20 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	SEC_OMX_Venc.c
+
+LOCAL_MODULE := libSEC_OMX_Venc
+LOCAL_ARM_MODE := arm
+LOCAL_MODULE_TAGS := optional
+
+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_STATIC_LIBRARY)
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.c
new file mode 100644
index 0000000..19e33de
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.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_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"
+#include "SEC_OSAL_Thread.h"
+#include "color_space_convertor.h"
+
+#undef  SEC_LOG_TAG
+#define SEC_LOG_TAG    "SEC_VIDEO_ENC"
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+
+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;
+        }
+    }
+
+    SEC_OSAL_Free(temp_bufferHeader);
+    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;
+        }
+    }
+
+    SEC_OSAL_Free(temp_bufferHeader);
+    SEC_OSAL_Free(temp_buffer);
+    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 (bufferHeader != NULL) {
+        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 (CHECK_PORT_TUNNELED(secOMXInputPort)) {
+            OMX_FillThisBuffer(secOMXInputPort->tunneledComponent, bufferHeader);
+        } else {
+            bufferHeader->nFilledLen = 0;
+            pSECComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+        }
+    }
+
+    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);
+    }
+
+    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;
+    SEC_OMX_DATABUFFER *inputUseBuffer = &pSECComponent->secDataBuffer[INPUT_PORT_INDEX];
+
+    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);
+        SEC_OSAL_MutexLock(inputUseBuffer->bufferMutex);
+        if (dataBuffer->dataValid != OMX_TRUE) {
+            message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+            if (message == NULL) {
+                ret = OMX_ErrorUndefined;
+                SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                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;
+            pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = dataBuffer->bufferHeader->pBuffer;
+            pSECComponent->processData[INPUT_PORT_INDEX].allocSize = dataBuffer->bufferHeader->nAllocLen;
+
+            SEC_OSAL_Free(message);
+        }
+        SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+        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();
+
+    if (bufferHeader != NULL) {
+        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 (CHECK_PORT_TUNNELED(secOMXOutputPort)) {
+            OMX_EmptyThisBuffer(secOMXOutputPort->tunneledComponent, bufferHeader);
+        } else {
+            pSECComponent->pCallbacks->FillBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader);
+        }
+    }
+
+    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);
+    }
+    
+    /* 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;
+    SEC_OMX_DATABUFFER *outputUseBuffer = &pSECComponent->secDataBuffer[OUTPUT_PORT_INDEX];
+
+    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);
+        SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+        if (dataBuffer->dataValid != OMX_TRUE) {
+            message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ);
+            if (message == NULL) {
+                ret = OMX_ErrorUndefined;
+                SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+                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);
+        }
+        SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+        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_DataReset(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];
+
+    processData->dataLen       = 0;
+    processData->remainDataLen = 0;
+    processData->usedDataLen   = 0;
+    processData->nFlags        = 0;
+    processData->timeStamp     = 0;
+
+    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 (checkedSize == 0) {
+                SEC_OMX_BASEPORT *pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+                int width = pSECPort->portDefinition.format.video.nFrameWidth;
+                int height = pSECPort->portDefinition.format.video.nFrameHeight;
+                inputUseBuffer->remainDataLen = inputUseBuffer->dataLen = (width * height * 3) / 2;
+                checkedSize = checkInputStreamLen = inputUseBuffer->remainDataLen;
+                inputUseBuffer->nFlags |= OMX_BUFFERFLAG_EOS;
+            }
+            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];
+
+            if ((pSECPort->portDefinition.format.video.eColorFormat != OMX_SEC_COLOR_FormatNV12TPhysicalAddress) &&
+                (pSECPort->bStoreMetaDataInBuffer == OMX_FALSE)) {
+                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)));
+
+                    switch (pSECPort->portDefinition.format.video.eColorFormat) {
+                    case OMX_COLOR_FormatYUV420Planar:
+                        /* Real YUV420P Data */
+                        csc_linear_to_tiled(inputData->specificBufferHeader.YVirAddr,
+                                                checkInputStream, width, height);
+                        csc_linear_to_tiled_interleave(inputData->specificBufferHeader.CVirAddr,
+                                                 checkInputStream + (width * height),
+                                                 checkInputStream + (((width * height) * 5) / 4),
+                                                 width, height >> 1);
+                        break;
+                    case OMX_COLOR_FormatYUV420SemiPlanar:
+                    default:
+                        SEC_OSAL_Memcpy(inputData->specificBufferHeader.YVirAddr, checkInputStream, (width * height));
+                        SEC_OSAL_Memcpy(inputData->specificBufferHeader.CVirAddr, checkInputStream + (width * height), (width * height / 2));
+                        break;
+                    }
+                }
+            }
+
+            inputUseBuffer->dataLen -= copySize;
+            inputUseBuffer->remainDataLen -= copySize;
+            inputUseBuffer->usedDataLen += copySize;
+
+            inputData->dataLen += copySize;
+            inputData->remainDataLen += copySize;
+
+            if (previousFrameEOF == OMX_TRUE) {
+                inputData->timeStamp = inputUseBuffer->timeStamp;
+                inputData->nFlags = inputUseBuffer->nFlags;
+            }
+
+            if (pSECComponent->bUseFlagEOF == OMX_TRUE) {
+                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_DataReset(pOMXComponent, INPUT_PORT_INDEX);
+            flagEOF = OMX_FALSE;
+        }
+
+        if (inputUseBuffer->remainDataLen == 0) {
+            if(flagEOF == OMX_FALSE)
+                SEC_InputBufferReturn(pOMXComponent);
+        } else {
+            inputUseBuffer->dataValid = OMX_TRUE;
+        }
+    }
+
+    if (flagEOF == OMX_TRUE) {
+        if (pSECComponent->checkTimeStamp.needSetStartTimeStamp == OMX_TRUE) {
+            pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_TRUE;
+            pSECComponent->checkTimeStamp.startTimeStamp = inputData->timeStamp;
+            pSECComponent->checkTimeStamp.nStartFlags = inputData->nFlags;
+            pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
+        }
+
+        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 (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
+            if (pSECComponent->checkTimeStamp.startTimeStamp == outputData->timeStamp){
+                pSECComponent->checkTimeStamp.startTimeStamp = -19761123;
+                pSECComponent->checkTimeStamp.nStartFlags = 0x0;
+                pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
+                pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
+            } else {
+                SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
+
+                ret = OMX_TRUE;
+                goto EXIT;
+            }
+        } else if (pSECComponent->checkTimeStamp.needSetStartTimeStamp == OMX_TRUE) {
+            SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
+
+            ret = OMX_TRUE;
+            goto EXIT;
+        }
+
+        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 */
+            SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
+
+            if ((outputUseBuffer->remainDataLen > 0) ||
+                (outputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS))
+                SEC_OutputBufferReturn(pOMXComponent);
+        } 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;
+    }
+
+EXIT:
+    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;
+
+    pSECComponent->remainOutputData = OMX_FALSE;
+    pSECComponent->reInputData = 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);
+
+            SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+            if ((outputUseBuffer->dataValid != OMX_TRUE) &&
+                (!CHECK_PORT_BEING_FLUSHED(secOutputPort))) {
+                SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+                ret = SEC_OutputBufferGetQueue(pSECComponent);
+                if ((ret == OMX_ErrorUndefined) ||
+                    (secInputPort->portState != OMX_StateIdle) ||
+                    (secOutputPort->portState != OMX_StateIdle)) {
+                    break;
+                }
+            } else {
+                SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+            }
+
+            if (pSECComponent->remainOutputData == OMX_FALSE) {
+                if (pSECComponent->reInputData == OMX_FALSE) {
+                    SEC_OSAL_MutexLock(inputUseBuffer->bufferMutex);
+                    if ((SEC_Preprocessor_InputData(pOMXComponent) == OMX_FALSE) &&
+                        (!CHECK_PORT_BEING_FLUSHED(secInputPort))) {
+                            SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                            ret = SEC_InputBufferGetQueue(pSECComponent);
+                            break;
+                    }
+
+                    SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+                }
+
+                SEC_OSAL_MutexLock(inputUseBuffer->bufferMutex);
+                SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+                ret = pSECComponent->sec_mfc_bufferProcess(pOMXComponent, inputData, outputData);
+
+                if (inputUseBuffer->remainDataLen == 0)
+                    SEC_InputBufferReturn(pOMXComponent);
+                else
+                    inputUseBuffer->dataValid = OMX_TRUE;
+
+                SEC_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
+                SEC_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
+
+                if (ret == OMX_ErrorInputDataEncodeYet)
+                    pSECComponent->reInputData = OMX_TRUE;
+                else
+                    pSECComponent->reInputData = OMX_FALSE;
+            }
+
+            SEC_OSAL_MutexLock(outputUseBuffer->bufferMutex);
+
+            if (SEC_Postprocess_OutputData(pOMXComponent) == OMX_FALSE)
+                pSECComponent->remainOutputData = OMX_TRUE;
+            else
+                pSECComponent->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_0:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_COLOR_FormatYUV420SemiPlanar;
+                portFormat->xFramerate         = portDefinition->format.video.xFramerate;
+                break;
+            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_SEC_COLOR_FormatNV12TPhysicalAddress;
+                portFormat->xFramerate         = portDefinition->format.video.xFramerate;
+                break;
+#ifdef USE_ANDROID_EXTENSION
+            case supportFormat_3:
+                portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+                portFormat->eColorFormat       = OMX_COLOR_FormatAndroidOpaque;
+                portFormat->xFramerate         = portDefinition->format.video.xFramerate;
+                break;
+#endif
+            }
+        } 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;
+    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);
+
+#ifdef USE_ANDROID_EXTENSION
+        if (portIndex == 0 && pSECPort->bStoreMetaDataInBuffer == OMX_TRUE) {
+            portDefinition->nBufferSize = MAX_INPUT_METADATA_BUFFER_SIZE;
+        }
+#endif
+    }
+        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;
+    case OMX_IndexParamPortDefinition:
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition =
+                (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
+        ret = SEC_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
+        if (ret != OMX_ErrorNone) {
+            goto EXIT;
+        }
+
+        if (pPortDefinition->nPortIndex == INPUT_PORT_INDEX) {
+            SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+            OMX_U32 width = pSECInputPort->portDefinition.format.video.nFrameWidth;
+            OMX_U32 height = pSECInputPort->portDefinition.format.video.nFrameHeight;
+            SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+            pSECOutputPort->portDefinition.format.video.nFrameWidth = width;
+            pSECOutputPort->portDefinition.format.video.nFrameHeight = height;
+            pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
+            SEC_OSAL_Log(SEC_LOG_TRACE, "pSECOutputPort->portDefinition.nBufferSize: %d",
+                            pSECOutputPort->portDefinition.nBufferSize);
+        }
+    }
+        break;
+#ifdef USE_ANDROID_EXTENSION
+    case OMX_IndexParamStoreMetaDataBuffer:
+    {
+        if (OMX_ErrorNone != checkVersionANB(ComponentParameterStructure))
+            goto EXIT;
+
+        if (INPUT_PORT_INDEX != checkPortIndexANB(ComponentParameterStructure)) {
+            ret = OMX_ErrorBadPortIndex;
+            goto EXIT;
+        }
+
+        ret = enableStoreMetaDataInBuffers(hComponent, ComponentParameterStructure);
+    }
+        break;
+#endif
+    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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.h
new file mode 100644
index 0000000..ac24e10
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/SEC_OMX_Venc.h
@@ -0,0 +1,137 @@
+/*
+ *
+ * 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   4
+
+#define DEFAULT_FRAME_WIDTH          176
+#define DEFAULT_FRAME_HEIGHT         144
+
+#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   DEFAULT_VIDEO_INPUT_BUFFER_SIZE
+
+#define MFC_INPUT_BUFFER_NUM_MAX            2
+
+#ifdef USE_ANDROID_EXTENSION
+#define INPUT_PORT_SUPPORTFORMAT_NUM_MAX    4
+#else
+#define INPUT_PORT_SUPPORTFORMAT_NUM_MAX    3
+#endif
+#define OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX   1
+
+#ifdef USE_ANDROID_EXTENSION
+// The largest metadata buffer size advertised
+// when metadata buffer mode is used for video encoding
+#define  MAX_INPUT_METADATA_BUFFER_SIZE (64)
+#endif
+
+typedef struct
+{
+    void *pAddrY;
+    void *pAddrC;
+} MFC_ENC_ADDR_INFO;
+
+typedef struct _SEC_MFC_NBENC_THREAD
+{
+    OMX_HANDLETYPE  hNBEncodeThread;
+    OMX_HANDLETYPE  hEncFrameStart;
+    OMX_HANDLETYPE  hEncFrameEnd;
+    OMX_BOOL        bExitEncodeThread;
+    OMX_BOOL        bEncoderRun;
+} SEC_MFC_NBENC_THREAD;
+
+typedef struct _MFC_ENC_INPUT_BUFFER
+{
+    void *YPhyAddr; // physical address of Y
+    void *CPhyAddr; // physical address of CbCr
+    void *YVirAddr; // virtual address of Y
+    void *CVirAddr; // virtual address of CbCr
+    int YBufferSize; // input buffer alloc size of Y
+    int CBufferSize; // input buffer alloc size of CbCr
+    int YDataSize;  // input size of Y data
+    int CDataSize;  // input size of CbCr data
+} MFC_ENC_INPUT_BUFFER;
+
+#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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/Android.mk
new file mode 100644
index 0000000..a0c59b6
--- /dev/null
+++ b/exynos3/s5pc110/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_H264enc.c \
+	library_register.c
+
+
+LOCAL_MODULE := libOMX.SEC.AVC.Encoder
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libSEC_OMX_Venc libsecosal libsecbasecomponent \
+						libsecmfcencapi libseccsc
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui libhardware
+
+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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.c
new file mode 100644
index 0000000..24bbc7a
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.c
@@ -0,0 +1,1307 @@
+/*
+ *
+ * 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"
+#include "color_space_convertor.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;
+
+    switch ((SEC_OMX_COLOR_FORMATTYPE)pSECInputPort->portDefinition.format.video.eColorFormat) {
+    case OMX_COLOR_FormatYUV420SemiPlanar:
+        pH264Arg->FrameMap = NV12_LINEAR;
+        break;
+    case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
+    default:
+        pH264Arg->FrameMap = NV12_TILE;
+        break;
+    }
+
+#ifdef USE_ANDROID_EXTENSION
+    if (pSECInputPort->bStoreMetaDataInBuffer != OMX_FALSE) {
+        SEC_OMX_DATA *pInputData = &pSECComponent->processData[INPUT_PORT_INDEX];
+        if(isMetadataBufferTypeGrallocSource(pInputData->dataBuffer) == OMX_TRUE)
+            pH264Arg->FrameMap = NV12_LINEAR;
+        else
+            pH264Arg->FrameMap = NV12_TILE;
+    }
+#endif
+
+/*
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pSECPort->eControlRate: 0x%x", pSECOutputPort->eControlRate);
+    switch (pSECOutputPort->eControlRate) {
+    case OMX_Video_ControlRateVariable:
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
+        pH264Arg->EnableFRMRateControl = 0;        // 0: Disable, 1: Frame level RC
+        pH264Arg->EnableMBRateControl  = 0;        // 0: Disable, 1:MB level RC
+        pH264Arg->CBRPeriodRf  = 100;
+        break;
+    case OMX_Video_ControlRateConstant:
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode CBR");
+        pH264Arg->EnableFRMRateControl = 1;        // 0: Disable, 1: Frame level RC
+        pH264Arg->EnableMBRateControl  = 1;        // 0: Disable, 1:MB level RC
+        pH264Arg->CBRPeriodRf  = 10;
+        break;
+    case OMX_Video_ControlRateDisable:
+    default: //Android default
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
+        pH264Arg->EnableFRMRateControl = 0;
+        pH264Arg->EnableMBRateControl  = 0;
+        pH264Arg->CBRPeriodRf  = 100;
+        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_COMPONENT_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_COMPONENT_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_GetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    if (pComponentConfigStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    default:
+        ret = SEC_OMX_GetConfig(hComponent, nIndex, pComponentConfigStructure);
+        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_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;
+    }
+
+#ifdef USE_ANDROID_EXTENSION
+    if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
+        *pIndexType = OMX_IndexParamStoreMetaDataBuffer;
+        ret = OMX_ErrorNone;
+    } else {
+        ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
+    }
+#else
+    ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
+#endif
+
+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_COMPONENT_H264_ENC_ROLE);
+        ret = OMX_ErrorNone;
+    } else {
+        ret = OMX_ErrorNoMore;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_EncodeThread(OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_H264ENC_HANDLE    *pH264Enc = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+
+    while (pH264Enc->NBEncThread.bExitEncodeThread == OMX_FALSE) {
+        SEC_OSAL_SemaphoreWait(pH264Enc->NBEncThread.hEncFrameStart);
+
+        if (pH264Enc->NBEncThread.bExitEncodeThread == OMX_FALSE) {
+            pH264Enc->hMFCH264Handle.returnCodec = SsbSipMfcEncExe(pH264Enc->hMFCH264Handle.hMFCHandle);
+            SEC_OSAL_SemaphorePost(pH264Enc->NBEncThread.hEncFrameEnd);
+        }
+    }
+
+EXIT:
+    FunctionOut();
+    SEC_OSAL_ThreadExit(NULL);
+
+    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_OMX_BASEPORT          *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT          *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    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 */
+    SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
+    hMFCHandle = (OMX_PTR)SsbSipMfcEncOpen(&buf_type);
+    if (hMFCHandle == NULL) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pH264Enc->hMFCH264Handle.hMFCHandle = hMFCHandle;
+
+    SsbSipMfcEncSetSize(hMFCHandle, H264_ENC,
+                        pSECOutputPort->portDefinition.format.video.nFrameWidth,
+                        pSECOutputPort->portDefinition.format.video.nFrameHeight);
+
+    /* Allocate encoder's input buffer */
+    returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pH264Enc->hMFCH264Handle.inputInfo));
+    if (returnCodec != MFC_RET_OK) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pH264Enc->MFCEncInputBuffer[0].YPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.YPhyAddr;
+    pH264Enc->MFCEncInputBuffer[0].CPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.CPhyAddr;
+    pH264Enc->MFCEncInputBuffer[0].YVirAddr = pH264Enc->hMFCH264Handle.inputInfo.YVirAddr;
+    pH264Enc->MFCEncInputBuffer[0].CVirAddr = pH264Enc->hMFCH264Handle.inputInfo.CVirAddr;
+    pH264Enc->MFCEncInputBuffer[0].YBufferSize = pH264Enc->hMFCH264Handle.inputInfo.YSize;
+    pH264Enc->MFCEncInputBuffer[0].CBufferSize = pH264Enc->hMFCH264Handle.inputInfo.CSize;
+    pH264Enc->MFCEncInputBuffer[0].YDataSize = 0;
+    pH264Enc->MFCEncInputBuffer[0].CDataSize = 0;
+    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);
+
+    returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pH264Enc->hMFCH264Handle.inputInfo));
+    if (returnCodec != MFC_RET_OK) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pH264Enc->MFCEncInputBuffer[1].YPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.YPhyAddr;
+    pH264Enc->MFCEncInputBuffer[1].CPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.CPhyAddr;
+    pH264Enc->MFCEncInputBuffer[1].YVirAddr = pH264Enc->hMFCH264Handle.inputInfo.YVirAddr;
+    pH264Enc->MFCEncInputBuffer[1].CVirAddr = pH264Enc->hMFCH264Handle.inputInfo.CVirAddr;
+    pH264Enc->MFCEncInputBuffer[1].YBufferSize = pH264Enc->hMFCH264Handle.inputInfo.YSize;
+    pH264Enc->MFCEncInputBuffer[1].CBufferSize = pH264Enc->hMFCH264Handle.inputInfo.CSize;
+    pH264Enc->MFCEncInputBuffer[1].YDataSize = 0;
+    pH264Enc->MFCEncInputBuffer[1].CDataSize = 0;
+    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->MFCEncInputBuffer[0].YPhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr = pH264Enc->MFCEncInputBuffer[0].CPhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr = pH264Enc->MFCEncInputBuffer[0].YVirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr = pH264Enc->MFCEncInputBuffer[0].CVirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YSize = pH264Enc->MFCEncInputBuffer[0].YBufferSize;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CSize = pH264Enc->MFCEncInputBuffer[0].CBufferSize;
+
+    pH264Enc->indexInputBuffer = 0;
+    pH264Enc->bFirstFrame = OMX_TRUE;
+
+    pH264Enc->NBEncThread.bExitEncodeThread = OMX_FALSE;
+    pH264Enc->NBEncThread.bEncoderRun = OMX_FALSE;
+    SEC_OSAL_SemaphoreCreate(&(pH264Enc->NBEncThread.hEncFrameStart));
+    SEC_OSAL_SemaphoreCreate(&(pH264Enc->NBEncThread.hEncFrameEnd));
+    if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pH264Enc->NBEncThread.hNBEncodeThread,
+                                                SEC_MFC_EncodeThread,
+                                                pOMXComponent)) {
+        pH264Enc->hMFCH264Handle.returnCodec = MFC_RET_OK;
+    }
+
+    SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+    SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
+    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;
+
+    if (pH264Enc->NBEncThread.hNBEncodeThread != NULL) {
+        pH264Enc->NBEncThread.bExitEncodeThread = OMX_TRUE;
+        SEC_OSAL_SemaphorePost(pH264Enc->NBEncThread.hEncFrameStart);
+        SEC_OSAL_ThreadTerminate(pH264Enc->NBEncThread.hNBEncodeThread);
+        pH264Enc->NBEncThread.hNBEncodeThread = NULL;
+    }
+
+    if(pH264Enc->NBEncThread.hEncFrameEnd != NULL) {
+        SEC_OSAL_SemaphoreTerminate(pH264Enc->NBEncThread.hEncFrameEnd);
+        pH264Enc->NBEncThread.hEncFrameEnd = NULL;
+    }
+
+    if(pH264Enc->NBEncThread.hEncFrameStart != NULL) {
+        SEC_OSAL_SemaphoreTerminate(pH264Enc->NBEncThread.hEncFrameStart);
+        pH264Enc->NBEncThread.hEncFrameStart = NULL;
+    }
+
+    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;
+
+    FunctionIn();
+
+    if (pH264Enc->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
+        Set_H264ENC_Param(&(pH264Enc->hMFCH264Handle.mfcVideoAvc), pSECComponent);
+        pH264Enc->hMFCH264Handle.returnCodec = SsbSipMfcEncInit(pH264Enc->hMFCH264Handle.hMFCHandle, &(pH264Enc->hMFCH264Handle.mfcVideoAvc));
+        if (pH264Enc->hMFCH264Handle.returnCodec != MFC_RET_OK) {
+            ret = OMX_ErrorInsufficientResources;
+            goto EXIT;
+        }
+
+        pH264Enc->hMFCH264Handle.returnCodec = SsbSipMfcEncGetOutBuf(pH264Enc->hMFCH264Handle.hMFCHandle, &outputInfo);
+        if (pH264Enc->hMFCH264Handle.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->timeStamp = 0;
+        pOutputData->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
+        pOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
+
+        pH264Enc->hMFCH264Handle.bConfiguredMFC = OMX_TRUE;
+
+        ret = OMX_ErrorInputDataEncodeYet;
+        goto EXIT;
+    }
+
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE)) {
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+    }
+
+    if (oneFrameSize <= 0) {
+        pOutputData->timeStamp = pInputData->timeStamp;
+        pOutputData->nFlags = pInputData->nFlags;
+
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) ||
+        (pSECComponent->getAllDelayBuffer == OMX_TRUE)){
+        /* Dummy input data for get out encoded last frame */
+        pInputInfo->YPhyAddr = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].YPhyAddr;
+        pInputInfo->CPhyAddr = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].CPhyAddr;
+        pInputInfo->YVirAddr = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].YVirAddr;
+        pInputInfo->CVirAddr = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].CVirAddr;
+    } else if (pSECPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress) {
+        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;
+#ifdef USE_ANDROID_EXTENSION
+    } else if (pSECPort->bStoreMetaDataInBuffer != OMX_FALSE) {
+        ret = preprocessMetaDataInBuffers(pOMXComponent, pInputData->dataBuffer, pInputInfo);
+        if (ret != OMX_ErrorNone)
+            goto EXIT;
+#endif
+    } else {
+        /* Real input data */
+        pInputInfo->YPhyAddr = pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr;
+        pInputInfo->CPhyAddr = pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr;
+    }
+
+    pSECComponent->timeStamp[pH264Enc->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
+    pSECComponent->nFlags[pH264Enc->hMFCH264Handle.indexTimestamp] = pInputData->nFlags;
+
+    if ((pH264Enc->hMFCH264Handle.returnCodec == MFC_RET_OK) &&
+        (pH264Enc->bFirstFrame == OMX_FALSE)) {
+        OMX_S32 indexTimestamp = 0;
+
+        /* wait for mfc encode done */
+        if (pH264Enc->NBEncThread.bEncoderRun != OMX_FALSE) {
+            SEC_OSAL_SemaphoreWait(pH264Enc->NBEncThread.hEncFrameEnd);
+            pH264Enc->NBEncThread.bEncoderRun = OMX_FALSE;
+        }
+
+        pH264Enc->hMFCH264Handle.returnCodec = SsbSipMfcEncGetOutBuf(pH264Enc->hMFCH264Handle.hMFCHandle, &outputInfo);
+        if ((SsbSipMfcEncGetConfig(pH264Enc->hMFCH264Handle.hMFCHandle, MFC_ENC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
+            (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))){
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = pInputData->nFlags;
+        } else {
+            pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
+            pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
+        }
+
+        if (pH264Enc->hMFCH264Handle.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;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncGetOutBuf failed, ret:%d", __FUNCTION__, pH264Enc->hMFCH264Handle.returnCodec);
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+
+        if (pSECComponent->getAllDelayBuffer == OMX_TRUE) {
+            ret = OMX_ErrorInputDataEncodeYet;
+        }
+        if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
+            pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+            pSECComponent->getAllDelayBuffer = OMX_TRUE;
+            ret = OMX_ErrorInputDataEncodeYet;
+        }
+        if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+            pOutputData->dataLen = 0;
+            pOutputData->usedDataLen = 0;
+            SEC_OSAL_Log(SEC_LOG_TRACE, "OMX_BUFFERFLAG_EOS!!!");
+            ret = OMX_ErrorNone;
+        }
+    }
+    if (pH264Enc->hMFCH264Handle.returnCodec != MFC_RET_OK) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "In %s : SsbSipMfcEncExe Failed!!!\n", __func__);
+        ret = OMX_ErrorUndefined;
+    }
+
+    pH264Enc->hMFCH264Handle.returnCodec = SsbSipMfcEncSetInBuf(pH264Enc->hMFCH264Handle.hMFCHandle, pInputInfo);
+    if (pH264Enc->hMFCH264Handle.returnCodec != MFC_RET_OK) {
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Error : SsbSipMfcEncSetInBuf() \n");
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    } else {
+        pH264Enc->indexInputBuffer++;
+        pH264Enc->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].YPhyAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].CPhyAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].YVirAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].CVirAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YSize = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].YBufferSize;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CSize = pH264Enc->MFCEncInputBuffer[pH264Enc->indexInputBuffer].CBufferSize;
+    }
+
+    SsbSipMfcEncSetConfig(pH264Enc->hMFCH264Handle.hMFCHandle, MFC_ENC_SETCONF_FRAME_TAG, &(pH264Enc->hMFCH264Handle.indexTimestamp));
+
+    /* mfc encode start */
+    SEC_OSAL_SemaphorePost(pH264Enc->NBEncThread.hEncFrameStart);
+    pH264Enc->NBEncThread.bEncoderRun = OMX_TRUE;
+    pH264Enc->hMFCH264Handle.indexTimestamp++;
+    pH264Enc->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
+    pH264Enc->bFirstFrame = OMX_FALSE;
+
+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;
+    }
+
+    ret = SEC_MFC_H264_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 - 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_COMPONENT_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_COMPONENT_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 = OMX_COLOR_FormatYUV420SemiPlanar;
+    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_AVCLevel31;
+    }
+
+    pOMXComponent->GetParameter      = &SEC_MFC_H264Enc_GetParameter;
+    pOMXComponent->SetParameter      = &SEC_MFC_H264Enc_SetParameter;
+    pOMXComponent->GetConfig         = &SEC_MFC_H264Enc_GetConfig;
+    pOMXComponent->SetConfig         = &SEC_MFC_H264Enc_SetConfig;
+    pOMXComponent->GetExtensionIndex = &SEC_MFC_H264Enc_GetExtensionIndex;
+    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      *pH264Enc = 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;
+
+    pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle;
+    if (pH264Enc != NULL) {
+        SEC_OSAL_Free(pH264Enc);
+        pH264Enc = pSECComponent->hCodecHandle = NULL;
+    }
+
+    ret = SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.h
new file mode 100644
index 0000000..bdd525f
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/SEC_OMX_H264enc.h
@@ -0,0 +1,83 @@
+/*
+ *
+ * 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"
+
+
+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_U32 indexTimestamp;
+    OMX_BOOL bConfiguredMFC;
+    EXTRA_DATA headerData;
+    OMX_S32 returnCodec;
+} 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;
+
+    /* For Non-Block mode */
+    SEC_MFC_NBENC_THREAD NBEncThread;
+    OMX_BOOL bFirstFrame;
+    MFC_ENC_INPUT_BUFFER MFCEncInputBuffer[MFC_INPUT_BUFFER_NUM_MAX];
+    OMX_U32  indexInputBuffer;
+} 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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.c
new file mode 100644
index 0000000..247b38b
--- /dev/null
+++ b/exynos3/s5pc110/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_COMPONENT_H264_ENC);
+    SEC_OSAL_Strcpy(secComponents[0]->roles[0], SEC_OMX_COMPONENT_H264_ENC_ROLE);
+    secComponents[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+    FunctionOut();
+
+    return MAX_COMPONENT_NUM;
+}
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/h264enc/library_register.h
new file mode 100644
index 0000000..6a176ad
--- /dev/null
+++ b/exynos3/s5pc110/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_COMPONENT_H264_ENC "OMX.SEC.AVC.Encoder"
+#define SEC_OMX_COMPONENT_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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/Android.mk
new file mode 100644
index 0000000..edefec6
--- /dev/null
+++ b/exynos3/s5pc110/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_Mpeg4enc.c \
+	library_register.c
+
+
+LOCAL_MODULE := libOMX.SEC.M4V.Encoder
+
+LOCAL_CFLAGS :=
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_STATIC_LIBRARIES := libSEC_OMX_Venc libsecosal libsecbasecomponent \
+						libsecmfcencapi libseccsc
+LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui libhardware
+
+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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.c
new file mode 100644
index 0000000..5213522
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.c
@@ -0,0 +1,1516 @@
+/*
+ *
+ * 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"
+#include "color_space_convertor.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;
+
+    switch ((SEC_OMX_COLOR_FORMATTYPE)pSECInputPort->portDefinition.format.video.eColorFormat) {
+    case OMX_COLOR_FormatYUV420SemiPlanar:
+        pMpeg4Param->FrameMap = NV12_LINEAR;
+        break;
+    case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
+    default:
+        pMpeg4Param->FrameMap = NV12_TILE;
+        break;
+    }
+
+#ifdef USE_ANDROID_EXTENSION
+    if (pSECInputPort->bStoreMetaDataInBuffer != OMX_FALSE) {
+        SEC_OMX_DATA *pInputData = &pSECComponent->processData[INPUT_PORT_INDEX];
+        if(isMetadataBufferTypeGrallocSource(pInputData->dataBuffer) == OMX_TRUE)
+            pMpeg4Param->FrameMap = NV12_LINEAR;
+        else
+            pMpeg4Param->FrameMap = NV12_TILE;
+    }
+#endif
+
+/*
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pSECPort->eControlRate: 0x%x", pSECOutputPort->eControlRate);
+    switch (pSECOutputPort->eControlRate) {
+    case OMX_Video_ControlRateVariable:
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
+        pH264Arg->EnableFRMRateControl = 0;        // 0: Disable, 1: Frame level RC
+        pH264Arg->EnableMBRateControl  = 0;        // 0: Disable, 1:MB level RC
+        pH264Arg->CBRPeriodRf  = 100;
+        break;
+    case OMX_Video_ControlRateConstant:
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode CBR");
+        pH264Arg->EnableFRMRateControl = 1;        // 0: Disable, 1: Frame level RC
+        pH264Arg->EnableMBRateControl  = 1;        // 0: Disable, 1:MB level RC
+        pH264Arg->CBRPeriodRf  = 10;
+        break;
+    case OMX_Video_ControlRateDisable:
+    default: //Android default
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
+        pH264Arg->EnableFRMRateControl = 0;
+        pH264Arg->EnableMBRateControl  = 0;
+        pH264Arg->CBRPeriodRf  = 100;
+        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;
+
+    switch ((SEC_OMX_COLOR_FORMATTYPE)pSECInputPort->portDefinition.format.video.eColorFormat) {
+    case OMX_COLOR_FormatYUV420SemiPlanar:
+        pH263Param->FrameMap = NV12_LINEAR;
+        break;
+    case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
+    default:
+        pH263Param->FrameMap = NV12_TILE;
+        break;
+    }
+
+#ifdef USE_ANDROID_EXTENSION
+    if (pSECInputPort->bStoreMetaDataInBuffer != OMX_FALSE) {
+        SEC_OMX_DATA *pInputData = &pSECComponent->processData[INPUT_PORT_INDEX];
+        if(isMetadataBufferTypeGrallocSource(pInputData->dataBuffer) == OMX_TRUE)
+            pH263Param->FrameMap = NV12_LINEAR;
+        else
+            pH263Param->FrameMap = NV12_TILE;
+    }
+#endif
+
+/*
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pSECPort->eControlRate: 0x%x", pSECOutputPort->eControlRate);
+    switch (pSECOutputPort->eControlRate) {
+    case OMX_Video_ControlRateVariable:
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
+        pH264Arg->EnableFRMRateControl = 0;        // 0: Disable, 1: Frame level RC
+        pH264Arg->EnableMBRateControl  = 0;        // 0: Disable, 1:MB level RC
+        pH264Arg->CBRPeriodRf  = 100;
+        break;
+    case OMX_Video_ControlRateConstant:
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode CBR");
+        pH264Arg->EnableFRMRateControl = 1;        // 0: Disable, 1: Frame level RC
+        pH264Arg->EnableMBRateControl  = 1;        // 0: Disable, 1:MB level RC
+        pH264Arg->CBRPeriodRf  = 10;
+        break;
+    case OMX_Video_ControlRateDisable:
+    default: //Android default
+        SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
+        pH264Arg->EnableFRMRateControl = 0;
+        pH264Arg->EnableMBRateControl  = 0;
+        pH264Arg->CBRPeriodRf  = 100;
+        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_COMPONENT_MPEG4_ENC_ROLE);
+        else
+            SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPONENT_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_COMPONENT_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_COMPONENT_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_GetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE           ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
+    if (ret != OMX_ErrorNone) {
+        goto EXIT;
+    }
+
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+
+    if (pComponentConfigStructure == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    if (pSECComponent->currentState == OMX_StateInvalid) {
+        ret = OMX_ErrorInvalidState;
+        goto EXIT;
+    }
+
+    switch (nIndex) {
+    default:
+        ret = SEC_OMX_GetConfig(hComponent, nIndex, pComponentConfigStructure);
+        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_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;
+    }
+
+#ifdef USE_ANDROID_EXTENSION
+    if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
+        *pIndexType = OMX_IndexParamStoreMetaDataBuffer;
+        ret = OMX_ErrorNone;
+    } else {
+        ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
+    }
+#else
+    ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
+#endif
+
+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_COMPONENT_MPEG4_ENC_ROLE);
+    else
+        SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPONENT_H263_ENC_ROLE);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE SEC_MFC_EncodeThread(OMX_HANDLETYPE hComponent)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_MPEG4ENC_HANDLE   *pMpeg4Enc = NULL;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
+
+    while (pMpeg4Enc->NBEncThread.bExitEncodeThread == OMX_FALSE) {
+        SEC_OSAL_SemaphoreWait(pMpeg4Enc->NBEncThread.hEncFrameStart);
+
+        if (pMpeg4Enc->NBEncThread.bExitEncodeThread == OMX_FALSE) {
+            pMpeg4Enc->hMFCMpeg4Handle.returnCodec = SsbSipMfcEncExe(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle);
+            SEC_OSAL_SemaphorePost(pMpeg4Enc->NBEncThread.hEncFrameEnd);
+        }
+    }
+
+EXIT:
+    FunctionOut();
+    SEC_OSAL_ThreadExit(NULL);
+
+    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          *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    SEC_OMX_BASEPORT          *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
+    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 */
+    SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
+    hMFCHandle = (OMX_PTR)SsbSipMfcEncOpen(&buf_type);
+    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) {
+        SsbSipMfcEncSetSize(hMFCHandle, MPEG4_ENC,
+                            pSECOutputPort->portDefinition.format.video.nFrameWidth,
+                            pSECOutputPort->portDefinition.format.video.nFrameHeight);
+    } else {
+        SsbSipMfcEncSetSize(hMFCHandle, H263_ENC,
+                            pSECOutputPort->portDefinition.format.video.nFrameWidth,
+                            pSECOutputPort->portDefinition.format.video.nFrameHeight);
+    }
+
+    /* allocate encoder's input buffer */
+    returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.inputInfo));
+    if (returnCodec != MFC_RET_OK) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pMpeg4Enc->MFCEncInputBuffer[0].YPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YPhyAddr;
+    pMpeg4Enc->MFCEncInputBuffer[0].CPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CPhyAddr;
+    pMpeg4Enc->MFCEncInputBuffer[0].YVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr;
+    pMpeg4Enc->MFCEncInputBuffer[0].CVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr;
+    pMpeg4Enc->MFCEncInputBuffer[0].YBufferSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YSize;
+    pMpeg4Enc->MFCEncInputBuffer[0].CBufferSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CSize;
+    pMpeg4Enc->MFCEncInputBuffer[0].YDataSize = 0;
+    pMpeg4Enc->MFCEncInputBuffer[0].CDataSize = 0;
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr : 0x%x", pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr : 0x%x", pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr);
+
+    /* allocate encoder's input buffer */
+    returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.inputInfo));
+    if (returnCodec != MFC_RET_OK) {
+        ret = OMX_ErrorInsufficientResources;
+        goto EXIT;
+    }
+    pMpeg4Enc->MFCEncInputBuffer[1].YPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YPhyAddr;
+    pMpeg4Enc->MFCEncInputBuffer[1].CPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CPhyAddr;
+    pMpeg4Enc->MFCEncInputBuffer[1].YVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr;
+    pMpeg4Enc->MFCEncInputBuffer[1].CVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr;
+    pMpeg4Enc->MFCEncInputBuffer[1].YBufferSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YSize;
+    pMpeg4Enc->MFCEncInputBuffer[1].CBufferSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CSize;
+    pMpeg4Enc->MFCEncInputBuffer[1].YDataSize = 0;
+    pMpeg4Enc->MFCEncInputBuffer[1].CDataSize = 0;
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr : 0x%x", pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr);
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr : 0x%x", pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr);
+
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr = pMpeg4Enc->MFCEncInputBuffer[0].YPhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr = pMpeg4Enc->MFCEncInputBuffer[0].CPhyAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr = pMpeg4Enc->MFCEncInputBuffer[0].YVirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr = pMpeg4Enc->MFCEncInputBuffer[0].CVirAddr;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YSize = pMpeg4Enc->MFCEncInputBuffer[0].YBufferSize;
+    pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CSize = pMpeg4Enc->MFCEncInputBuffer[0].CBufferSize;
+
+    pMpeg4Enc->indexInputBuffer = 0;
+    pMpeg4Enc->bFirstFrame = OMX_TRUE;
+
+    pMpeg4Enc->NBEncThread.bExitEncodeThread = OMX_FALSE;
+    pMpeg4Enc->NBEncThread.bEncoderRun = OMX_FALSE;
+    SEC_OSAL_SemaphoreCreate(&(pMpeg4Enc->NBEncThread.hEncFrameStart));
+    SEC_OSAL_SemaphoreCreate(&(pMpeg4Enc->NBEncThread.hEncFrameEnd));
+    if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pMpeg4Enc->NBEncThread.hNBEncodeThread,
+                                                SEC_MFC_EncodeThread,
+                                                pOMXComponent)) {
+        pMpeg4Enc->hMFCMpeg4Handle.returnCodec = MFC_RET_OK;
+    }
+
+    SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
+    SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
+    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;
+
+    if (pMpeg4Enc->NBEncThread.hNBEncodeThread != NULL) {
+        pMpeg4Enc->NBEncThread.bExitEncodeThread = OMX_TRUE;
+        SEC_OSAL_SemaphorePost(pMpeg4Enc->NBEncThread.hEncFrameStart);
+        SEC_OSAL_ThreadTerminate(pMpeg4Enc->NBEncThread.hNBEncodeThread);
+        pMpeg4Enc->NBEncThread.hNBEncodeThread = NULL;
+    }
+
+    if(pMpeg4Enc->NBEncThread.hEncFrameEnd != NULL) {
+        SEC_OSAL_SemaphoreTerminate(pMpeg4Enc->NBEncThread.hEncFrameEnd);
+        pMpeg4Enc->NBEncThread.hEncFrameEnd = NULL;
+    }
+
+    if(pMpeg4Enc->NBEncThread.hEncFrameStart != NULL) {
+        SEC_OSAL_SemaphoreTerminate(pMpeg4Enc->NBEncThread.hEncFrameStart);
+        pMpeg4Enc->NBEncThread.hEncFrameStart = NULL;
+    }
+
+    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;
+
+    FunctionIn();
+
+    if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFC == OMX_FALSE) {
+        /* set MFC ENC VIDEO PARAM and initialize MFC encoder instance */
+        if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4) {
+            Set_Mpeg4Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam), pSECComponent);
+            pMpeg4Enc->hMFCMpeg4Handle.returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam));
+        } else {
+            Set_H263Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam), pSECComponent);
+            pMpeg4Enc->hMFCMpeg4Handle.returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam));
+        }
+        if (pMpeg4Enc->hMFCMpeg4Handle.returnCodec != MFC_RET_OK) {
+            ret = OMX_ErrorInsufficientResources;
+            goto EXIT;
+        }
+
+        pMpeg4Enc->hMFCMpeg4Handle.returnCodec = SsbSipMfcEncGetOutBuf(hMFCHandle, &outputInfo);
+        if (pMpeg4Enc->hMFCMpeg4Handle.returnCodec != MFC_RET_OK)
+        {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncGetOutBuf failed, ret:%d", __FUNCTION__, pMpeg4Enc->hMFCMpeg4Handle.returnCodec);
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+
+        pOutputData->dataBuffer = outputInfo.StrmVirAddr;
+        pOutputData->allocSize = outputInfo.headerSize;
+        pOutputData->dataLen = outputInfo.headerSize;
+        pOutputData->timeStamp = 0;
+        pOutputData->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
+        pOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
+
+        pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFC = OMX_TRUE;
+
+        ret = OMX_ErrorInputDataEncodeYet;
+        goto EXIT;
+    }
+
+    if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
+        (pSECComponent->bUseFlagEOF == OMX_FALSE)) {
+        pSECComponent->bUseFlagEOF = OMX_TRUE;
+    }
+
+    if (oneFrameSize <= 0) {
+        pOutputData->timeStamp = pInputData->timeStamp;
+        pOutputData->nFlags = pInputData->nFlags;
+
+        ret = OMX_ErrorNone;
+        goto EXIT;
+    }
+
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+    if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) ||
+        (pSECComponent->getAllDelayBuffer == OMX_TRUE)){
+        /* Dummy input data for get out encoded last frame */
+        pInputInfo->YPhyAddr = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].YPhyAddr;
+        pInputInfo->CPhyAddr = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].CPhyAddr;
+        pInputInfo->YVirAddr = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].YVirAddr;
+        pInputInfo->CVirAddr = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].CVirAddr;
+    } else if (pSECPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress) {
+        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;
+#ifdef USE_ANDROID_EXTENSION
+    } else if (pSECPort->bStoreMetaDataInBuffer != OMX_FALSE) {
+        ret = preprocessMetaDataInBuffers(pOMXComponent, pInputData->dataBuffer, pInputInfo);
+        if (ret != OMX_ErrorNone)
+            goto EXIT;
+#endif
+    } else {
+        /* Real input data */
+        pInputInfo->YPhyAddr = pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr;
+        pInputInfo->CPhyAddr = pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr;
+    }
+
+    pSECComponent->timeStamp[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pInputData->timeStamp;
+    pSECComponent->nFlags[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pInputData->nFlags;
+
+    if ((pMpeg4Enc->hMFCMpeg4Handle.returnCodec == MFC_RET_OK) &&
+        (pMpeg4Enc->bFirstFrame == OMX_FALSE)) {
+        OMX_S32 indexTimestamp = 0;
+
+        /* wait for mfc encode done */
+        if (pMpeg4Enc->NBEncThread.bEncoderRun != OMX_FALSE) {
+            SEC_OSAL_SemaphoreWait(pMpeg4Enc->NBEncThread.hEncFrameEnd);
+            pMpeg4Enc->NBEncThread.bEncoderRun = OMX_FALSE;
+        }
+
+        pMpeg4Enc->hMFCMpeg4Handle.returnCodec = SsbSipMfcEncGetOutBuf(hMFCHandle, &outputInfo);
+        if ((SsbSipMfcEncGetConfig(hMFCHandle, MFC_ENC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
+            (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
+            pOutputData->timeStamp = pInputData->timeStamp;
+            pOutputData->nFlags = pInputData->nFlags;
+        } else {
+            pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
+            pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
+        }
+
+        if (pMpeg4Enc->hMFCMpeg4Handle.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;
+
+            ret = OMX_ErrorNone;
+        } else {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncGetOutBuf failed, ret:%d", __FUNCTION__, pMpeg4Enc->hMFCMpeg4Handle.returnCodec);
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+
+        if (pSECComponent->getAllDelayBuffer == OMX_TRUE) {
+            ret = OMX_ErrorInputDataEncodeYet;
+        }
+        if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
+            pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
+            pSECComponent->getAllDelayBuffer = OMX_TRUE;
+            ret = OMX_ErrorInputDataEncodeYet;
+        }
+        if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
+            pSECComponent->getAllDelayBuffer = OMX_FALSE;
+            pOutputData->dataLen = 0;
+            pOutputData->usedDataLen = 0;
+            SEC_OSAL_Log(SEC_LOG_TRACE, "OMX_BUFFERFLAG_EOS!!!");
+            ret = OMX_ErrorNone;
+        }
+    }
+    if (pMpeg4Enc->hMFCMpeg4Handle.returnCodec != MFC_RET_OK) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncExe failed, ret:%d", __FUNCTION__, pMpeg4Enc->hMFCMpeg4Handle.returnCodec);
+        ret = OMX_ErrorUndefined;
+    }
+
+    pMpeg4Enc->hMFCMpeg4Handle.returnCodec = SsbSipMfcEncSetInBuf(hMFCHandle, pInputInfo);
+    if (pMpeg4Enc->hMFCMpeg4Handle.returnCodec != MFC_RET_OK) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncSetInBuf failed, ret:%d", __FUNCTION__, pMpeg4Enc->hMFCMpeg4Handle.returnCodec);
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    } else {
+        pMpeg4Enc->indexInputBuffer++;
+        pMpeg4Enc->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].YPhyAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].CPhyAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].YVirAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].CVirAddr;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YSize = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].YBufferSize;
+        pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CSize = pMpeg4Enc->MFCEncInputBuffer[pMpeg4Enc->indexInputBuffer].CBufferSize;
+    }
+
+    SsbSipMfcEncSetConfig(hMFCHandle, MFC_ENC_SETCONF_FRAME_TAG, &(pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp));
+
+    /* mfc encode start */
+    SEC_OSAL_SemaphorePost(pMpeg4Enc->NBEncThread.hEncFrameStart);
+    pMpeg4Enc->NBEncThread.bEncoderRun = OMX_TRUE;
+    pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp++;
+    pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
+    pMpeg4Enc->bFirstFrame = OMX_FALSE;
+
+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;
+    }
+
+    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_COMPONENT_MPEG4_ENC, componentName) == 0) {
+        codecType = CODEC_TYPE_MPEG4;
+    } else if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_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_COMPONENT_MPEG4_ENC);
+    else
+        SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_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 = 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_MPEG4ProfileSimple;
+            pMpeg4Enc->mpeg4Component[i].eLevel     = OMX_VIDEO_MPEG4Level4;
+
+            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->GetConfig         = &SEC_MFC_Mpeg4Enc_GetConfig;
+    pOMXComponent->SetConfig         = &SEC_MFC_Mpeg4Enc_SetConfig;
+    pOMXComponent->GetExtensionIndex = &SEC_MFC_Mpeg4Enc_GetExtensionIndex;
+    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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.h
new file mode 100644
index 0000000..36e02d8
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/SEC_OMX_Mpeg4enc.h
@@ -0,0 +1,83 @@
+/*
+ *
+ * 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"
+
+
+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_U32                    indexTimestamp;
+    OMX_BOOL                   bConfiguredMFC;
+    CODEC_TYPE                 codecType;
+    OMX_S32                    returnCodec;
+} 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;
+
+    /* For Non-Block mode */
+    SEC_MFC_NBENC_THREAD NBEncThread;
+    OMX_BOOL bFirstFrame;
+    MFC_ENC_INPUT_BUFFER MFCEncInputBuffer[MFC_INPUT_BUFFER_NUM_MAX];
+    OMX_U32  indexInputBuffer;
+} 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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.c
new file mode 100644
index 0000000..467eba2
--- /dev/null
+++ b/exynos3/s5pc110/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_COMPONENT_MPEG4_ENC);
+    SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPONENT_MPEG4_ENC_ROLE);
+    ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+    /* component 2 - video encoder H.263 */
+    SEC_OSAL_Strcpy(ppSECComponent[1]->componentName, SEC_OMX_COMPONENT_H263_ENC);
+    SEC_OSAL_Strcpy(ppSECComponent[1]->roles[0], SEC_OMX_COMPONENT_H263_ENC_ROLE);
+    ppSECComponent[1]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
+
+EXIT:
+    FunctionOut();
+    return MAX_COMPONENT_NUM;
+}
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_component/video/enc/mpeg4enc/library_register.h
new file mode 100644
index 0000000..e172d51
--- /dev/null
+++ b/exynos3/s5pc110/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_COMPONENT_MPEG4_ENC         "OMX.SEC.MPEG4.Encoder"
+#define SEC_OMX_COMPONENT_MPEG4_ENC_ROLE    "video_encoder.mpeg4"
+
+/* H.263 */
+#define SEC_OMX_COMPONENT_H263_ENC          "OMX.SEC.H263.Encoder"
+#define SEC_OMX_COMPONENT_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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/Android.mk
new file mode 100644
index 0000000..3fc0811
--- /dev/null
+++ b/exynos3/s5pc110/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_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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.c
new file mode 100644
index 0000000..1464397
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Component_Register.h
new file mode 100644
index 0000000..66580bd
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.c
new file mode 100644
index 0000000..fb2875d
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.c
@@ -0,0 +1,363 @@
+/*
+ *
+ * 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 <pthread.h>         // for pthread related functions
+
+#include "SEC_OMX_Core.h"
+#include "SEC_OSAL_Mutex.h"  // for mutext related functions
+#include "SEC_OSAL_ETC.h"    // for SEC_OSAL_Strcmp, etc
+#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 OMX_U32 gComponentNum = 0;
+
+static SEC_OMX_COMPONENT_REGLIST *gComponentList = NULL;
+static SEC_OMX_COMPONENT *gLoadComponentList = NULL;
+static pthread_mutex_t ghLoadComponentListMutex = PTHREAD_MUTEX_INITIALIZER;
+
+
+OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_Init(void)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+
+    SEC_OSAL_MutexLock(&ghLoadComponentListMutex);
+    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_Log(SEC_LOG_TRACE, "SEC_OMX_Init : %s", "OMX_ErrorNone");
+    }
+    ++gInitialized;
+
+EXIT:
+    SEC_OSAL_MutexUnlock(&ghLoadComponentListMutex);
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_Deinit(void)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+
+    SEC_OSAL_MutexLock(&ghLoadComponentListMutex);
+    if (gInitialized > 0) {
+        --gInitialized;
+    }
+
+    if (gInitialized != 0) {
+        // Some component still uses the core.
+        // Nothing needs to be done
+        goto EXIT;
+    }
+
+    SEC_OMX_ResourceManager_Deinit();
+
+    if (OMX_ErrorNone != SEC_OMX_Component_Unregister(gComponentList)) {
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+    gComponentList = NULL;
+    gComponentNum = 0;
+
+EXIT:
+    SEC_OSAL_MutexUnlock(&ghLoadComponentListMutex);
+    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;
+
+    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);
+
+    OMX_U32 i = 0;
+    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;
+            goto EXIT;
+        }
+    }
+
+    SEC_OMX_ComponentUnload(deleteComponent);
+    SEC_OSAL_Free(deleteComponent);
+
+EXIT:
+    SEC_OSAL_MutexUnlock(&ghLoadComponentListMutex);
+    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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/SEC_OMX_Core.h
new file mode 100644
index 0000000..87f561c
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/secomxregistry b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_core/secomxregistry
new file mode 100644
index 0000000..9baeba2
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Audio.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Audio.h
new file mode 100644
index 0000000..04f1a99
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Component.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Component.h
new file mode 100644
index 0000000..d595640
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_ContentPipe.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_ContentPipe.h
new file mode 100644
index 0000000..5f6310c
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Core.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Core.h
new file mode 100644
index 0000000..a076f2f
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_IVCommon.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_IVCommon.h
new file mode 100644
index 0000000..4c4995c
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Image.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Image.h
new file mode 100644
index 0000000..a6d4666
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Index.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Index.h
new file mode 100644
index 0000000..44d4ea7
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Other.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Other.h
new file mode 100644
index 0000000..caf7f38
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Types.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Types.h
new file mode 100644
index 0000000..31be916
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Video.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/khronos/OMX_Video.h
new file mode 100644
index 0000000..ceb273c
--- /dev/null
+++ b/exynos3/s5pc110/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 boun
+ */
+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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Def.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Def.h
new file mode 100644
index 0000000..10b6144
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Def.h
@@ -0,0 +1,154 @@
+/*
+ *
+ * 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
+
+#define MAX_TIMESTAMP        17
+#define MAX_FLAGS            17
+
+#define USE_ANDROID_EXTENSION
+
+
+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
+{
+#define SEC_INDEX_PARAM_ENABLE_THUMBNAIL "OMX.SEC.index.ThumbnailMode"
+    OMX_IndexVendorThumbnailMode        = 0x7F000001,
+
+    /* for Android Native Window */
+#define SEC_INDEX_PARAM_ENABLE_ANB "OMX.google.android.index.enableAndroidNativeBuffers"
+    OMX_IndexParamEnableAndroidBuffers    = 0x7F000011,
+#define SEC_INDEX_PARAM_GET_ANB "OMX.google.android.index.getAndroidNativeBufferUsage"
+    OMX_IndexParamGetAndroidNativeBuffer  = 0x7F000012,
+#define SEC_INDEX_PARAM_USE_ANB "OMX.google.android.index.useAndroidNativeBuffer"
+    OMX_IndexParamUseAndroidNativeBuffer  = 0x7F000013,
+    /* for Android Store Metadata Inbuffer */
+#define SEC_INDEX_PARAM_STORE_METADATA_BUFFER "OMX.google.android.index.storeMetaDataInBuffers"
+    OMX_IndexParamStoreMetaDataBuffer     = 0x7F000014,
+
+    /* for Android PV OpenCore*/
+    OMX_COMPONENT_CAPABILITY_TYPE_INDEX = 0xFF7A347
+} 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 {
+    OMX_SEC_COLOR_FormatNV12TPhysicalAddress = 0x7F000001, /**< Reserved region for introducing Vendor Extensions */
+    /* for Android Native Window */
+    OMX_SEC_COLOR_FormatANBYUV420SemiPlanar = 0x100,
+    /* for Android surface texture encode */
+    OMX_COLOR_FormatAndroidOpaque = 0x7F000789
+}SEC_OMX_COLOR_FORMATTYPE;
+
+typedef enum _SEC_OMX_SUPPORTFORMAT_TYPE
+{
+    supportFormat_0 = 0x00,
+    supportFormat_1,
+    supportFormat_2,
+    supportFormat_3
+} 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/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Macros.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Macros.h
new file mode 100644
index 0000000..1debc62
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_omx_include/sec/SEC_OMX_Macros.h
@@ -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    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_BEING_DISABLED(port)                (port->bIsPortDisabled == 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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/Android.mk b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/Android.mk
new file mode 100644
index 0000000..a020149
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/Android.mk
@@ -0,0 +1,38 @@
+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 \
+	SEC_OSAL_Buffer.cpp
+
+
+LOCAL_MODULE := libsecosal
+
+LOCAL_CFLAGS :=
+
+LOCAL_STATIC_LIBRARIES :=
+
+LOCAL_SHARED_LIBRARIES := libcutils \
+                          libutils \
+                          libui \
+                          libhardware \
+                          libandroid_runtime
+
+LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
+	$(SEC_OMX_INC)/sec \
+	$(SEC_OMX_TOP)/sec_osal \
+	$(SEC_OMX_COMPONENT)/common \
+	$(SEC_OMX_TOP)/../../include \
+	$(TOP)/frameworks/native/include/media/hardware
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Buffer.cpp b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Buffer.cpp
new file mode 100644
index 0000000..b28f702
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Buffer.cpp
@@ -0,0 +1,456 @@
+/*
+ *
+ * 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_Buffer.c
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ *              Jinsung Yang (jsgood.yang@samsung.com)
+ * @version     1.0.2
+ * @history
+ *   2011.5.15 : Create
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "SEC_OMX_Def.h"
+#include "SEC_OMX_Macros.h"
+#include "SEC_OSAL_Memory.h"
+#include "SEC_OSAL_Semaphore.h"
+#include "SEC_OSAL_Buffer.h"
+#include "SEC_OMX_Basecomponent.h"
+
+#define SEC_LOG_OFF
+#include "SEC_OSAL_Log.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <cutils/properties.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/GraphicBufferMapper.h>
+#include <ui/Rect.h>
+#include <HardwareAPI.h>
+#include <hardware/hardware.h>
+#include <MetadataBufferType.h>
+#include "hal_public.h"
+
+#define HAL_PIXEL_FORMAT_C110_NV12          0x100
+
+using namespace android;
+
+
+struct AndroidNativeBuffersParams {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+};
+
+#ifdef USE_ANDROID_EXTENSION
+OMX_ERRORTYPE checkVersionANB(OMX_PTR ComponentParameterStructure)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_VERSIONTYPE* version = NULL;
+
+
+    AndroidNativeBuffersParams *pANBP;
+    pANBP = (AndroidNativeBuffersParams *)ComponentParameterStructure;
+
+    version = (OMX_VERSIONTYPE*)((char*)pANBP + sizeof(OMX_U32));
+    if (*((OMX_U32*)pANBP) <= sizeof(AndroidNativeBuffersParams)) {
+        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_U32 checkPortIndexANB(OMX_PTR ComponentParameterStructure)
+{
+    AndroidNativeBuffersParams *pANBP;
+    pANBP = (AndroidNativeBuffersParams *)ComponentParameterStructure;
+
+    return pANBP->nPortIndex;
+}
+
+OMX_U32 getMetadataBufferType(const uint8_t *ptr)
+{
+    OMX_U32 type = *(OMX_U32 *) ptr;
+    SEC_OSAL_Log(SEC_LOG_TRACE, "getMetadataBufferType: %ld", type);
+    return type;
+}
+
+OMX_U32 getVADDRfromANB(OMX_PTR pUnreadableBuffer, OMX_U32 Width, OMX_U32 Height, void *pVirAddrs[])
+{
+    OMX_U32 ret = 0;
+    android_native_buffer_t *buf;
+    void *readableBuffer;
+    GraphicBufferMapper &mapper = GraphicBufferMapper::get();
+    Rect bounds(Width, Height);
+
+    FunctionIn();
+
+    buf = (android_native_buffer_t *)pUnreadableBuffer;
+    SEC_OSAL_Log(SEC_LOG_TRACE, "pUnreadableBuffer:0x%x, buf:0x%x, buf->handle:0x%x",
+                                pUnreadableBuffer, buf, buf->handle);
+
+    ret = mapper.lock(buf->handle, GRALLOC_USAGE_SW_WRITE_OFTEN, bounds, pVirAddrs);
+    if (ret != 0) {
+        SEC_OSAL_Log(SEC_LOG_ERROR, "mapper.lock Error, Error code:%d", ret);
+    }
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_U32 putVADDRtoANB(OMX_PTR pUnreadableBuffer)
+{
+    android_native_buffer_t *buf;
+    void *readableBuffer;
+    int ret = 0;
+    GraphicBufferMapper &mapper = GraphicBufferMapper::get();
+
+    FunctionIn();
+
+    buf = (android_native_buffer_t *)pUnreadableBuffer;
+
+    FunctionOut();
+
+    return mapper.unlock(buf->handle);
+}
+
+OMX_ERRORTYPE enableAndroidNativeBuffer(OMX_HANDLETYPE hComponent, OMX_PTR ComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+
+    EnableAndroidNativeBuffersParams *peanbp;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    peanbp = (EnableAndroidNativeBuffersParams *)ComponentParameterStructure;
+    pSECPort = &pSECComponent->pSECPort[peanbp->nPortIndex];
+
+    if (peanbp->enable == OMX_FALSE) {
+        SEC_OSAL_Log(SEC_LOG_TRACE, "disable AndroidNativeBuffer");
+        pSECPort->bUseAndroidNativeBuffer = OMX_FALSE;
+    } else {
+        SEC_OSAL_Log(SEC_LOG_TRACE, "enable AndroidNativeBuffer");
+        pSECPort->bUseAndroidNativeBuffer = OMX_TRUE;
+        pSECPort->portDefinition.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatANBYUV420SemiPlanar;
+    }
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE getAndroidNativeBuffer(OMX_HANDLETYPE hComponent, OMX_PTR ComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+
+    GetAndroidNativeBufferUsageParams *pganbp;
+
+    FunctionIn();
+
+    pganbp = (GetAndroidNativeBufferUsageParams *)ComponentParameterStructure;
+
+    pganbp->nUsage = GRALLOC_USAGE_SW_WRITE_OFTEN;
+
+    ret = OMX_ErrorNone;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE UseBufferANB(
+    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;
+    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;
+        }
+    }
+
+    SEC_OSAL_Free(temp_bufferHeader);
+    ret = OMX_ErrorInsufficientResources;
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE useAndroidNativeBuffer(OMX_HANDLETYPE hComponent, OMX_PTR ComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_U32                frameSize = 0;
+    OMX_U32                bufWidth, bufHeight;
+    UseAndroidNativeBufferParams *puanbp;
+
+    FunctionIn();
+
+    puanbp = (UseAndroidNativeBufferParams *)ComponentParameterStructure;
+
+    OMX_PTR buffer = (void *)puanbp->nativeBuffer.get();
+    android_native_buffer_t *buf = (android_native_buffer_t *)buffer;
+    bufWidth = ((buf->width + 15) / 16) * 16;
+    bufHeight = ((buf->height + 15) / 16) * 16;
+    frameSize = (bufWidth * bufHeight * 3) / 2;
+    SEC_OSAL_Log(SEC_LOG_TRACE, "buffer:0x%x, buf:0x%x, buf->handle:0x%x", buffer, buf, buf->handle);
+
+    ret = UseBufferANB(hComponent, puanbp->bufferHeader, puanbp->nPortIndex,
+                       puanbp->pAppPrivate, frameSize, (OMX_U8 *)buffer);
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_ERRORTYPE enableStoreMetaDataInBuffers(OMX_HANDLETYPE hComponent, OMX_PTR ComponentParameterStructure)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+
+    StoreMetaDataInBuffersParams *pStoreMetaData;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pStoreMetaData = (StoreMetaDataInBuffersParams*)ComponentParameterStructure;
+    pSECPort = &pSECComponent->pSECPort[pStoreMetaData->nPortIndex];
+
+    if (pStoreMetaData->bStoreMetaData == OMX_FALSE) {
+        SEC_OSAL_Log(SEC_LOG_TRACE, "disable StoreMetaDataInBuffers");
+        pSECPort->bStoreMetaDataInBuffer = OMX_FALSE;
+    } else {
+        SEC_OSAL_Log(SEC_LOG_TRACE, "enable StoreMetaDataInBuffers");
+        pSECPort->bStoreMetaDataInBuffer = OMX_TRUE;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+OMX_BOOL isMetadataBufferTypeGrallocSource(OMX_BYTE pInputDataBuffer)
+{
+    OMX_U32 type = getMetadataBufferType(pInputDataBuffer);
+
+    if (type == kMetadataBufferTypeGrallocSource)
+        return OMX_TRUE;
+    else
+        return OMX_FALSE;
+}
+
+OMX_ERRORTYPE preprocessMetaDataInBuffers(OMX_HANDLETYPE hComponent, OMX_BYTE pInputDataBuffer, BUFFER_ADDRESS_INFO *pInputInfo)
+{
+    OMX_ERRORTYPE          ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE     *pOMXComponent = NULL;
+    SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
+    SEC_OMX_BASEPORT      *pSECPort = NULL;
+    OMX_U32                type = 0;
+
+    FunctionIn();
+
+    if (hComponent == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    if (pOMXComponent->pComponentPrivate == NULL) {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+    pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
+
+    type = getMetadataBufferType(pInputDataBuffer);
+    if (type == kMetadataBufferTypeCameraSource) {
+        SEC_OSAL_Memcpy(&pInputInfo->YPhyAddr, pInputDataBuffer + 4, sizeof(void *));
+        SEC_OSAL_Memcpy(&pInputInfo->CPhyAddr, pInputDataBuffer + 4 + sizeof(void *), sizeof(void *));
+    } else if (type == kMetadataBufferTypeGrallocSource){
+        IMG_gralloc_module_public_t *module = (IMG_gralloc_module_public_t *)pSECPort->pIMGGrallocModule;
+        OMX_PTR pUnreadableBuffer = NULL;
+        OMX_PTR pReadableBuffer = NULL;
+        OMX_PTR pVirAddrs[3];
+        int err = 0;
+
+        pVirAddrs[0] = pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr;
+        pVirAddrs[1] = pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr;
+        pVirAddrs[2] = NULL;
+
+        if (module == NULL) {
+            err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&module);
+            if(err) {
+                SEC_OSAL_Log(SEC_LOG_ERROR, "hw_get_module failed (err=%d)\n", err);
+                ret = OMX_ErrorUndefined;
+                goto EXIT;
+            }
+            pSECPort->pIMGGrallocModule = (OMX_PTR)module;
+        }
+
+        /**************************************/
+        /*     IMG CSC RGB to NV12            */
+        /**************************************/
+        buffer_handle_t buf = *((buffer_handle_t *) (pInputDataBuffer + 4));
+        SEC_OSAL_Log(SEC_LOG_TRACE, "buffer handle %p)\n", buf);
+        err = module->Blit(module, buf, pVirAddrs, HAL_PIXEL_FORMAT_C110_NV12);
+        if(err) {
+            SEC_OSAL_Log(SEC_LOG_ERROR, "module->Blit() failed (err=%d)\n", err);
+            ret = OMX_ErrorUndefined;
+            goto EXIT;
+        }
+
+        pInputInfo->YPhyAddr = pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr;
+        pInputInfo->CPhyAddr = pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr;
+    } else {
+        ret = OMX_ErrorNotImplemented;
+        goto EXIT;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+int isTvOutEnabled() {
+    char value[PROPERTY_VALUE_MAX];
+    property_get("init.svc.tvouthack", value, "");
+    return (strcmp(value, "running") == 0);
+}
+
+#endif
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Buffer.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Buffer.h
new file mode 100644
index 0000000..a096bfe
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Buffer.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_Buffer.h
+ * @brief
+ * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
+ *              Jinsung Yang (jsgood.yang@samsung.com)
+ * @version     1.0.2
+ * @history
+ *   2011.5.15 : Create
+ */
+
+#ifndef SEC_OSAL_BUFFER
+#define SEC_OSAL_BUFFER
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OMX_Types.h"
+
+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
+} BUFFER_ADDRESS_INFO;
+
+
+OMX_ERRORTYPE checkVersionANB(OMX_PTR ComponentParameterStructure);
+OMX_U32 checkPortIndexANB(OMX_PTR ComponentParameterStructure);
+OMX_U32 getMetadataBufferType(const uint8_t *ptr);
+OMX_ERRORTYPE enableAndroidNativeBuffer(OMX_HANDLETYPE hComponent, OMX_PTR ComponentParameterStructure);
+OMX_ERRORTYPE getAndroidNativeBuffer(OMX_HANDLETYPE hComponent, OMX_PTR ComponentParameterStructure);
+OMX_ERRORTYPE useAndroidNativeBuffer(OMX_HANDLETYPE hComponent, OMX_PTR ComponentParameterStructure);
+OMX_U32 getVADDRfromANB(OMX_PTR pUnreadableBuffer, OMX_U32 Width, OMX_U32 Height, void *vaddress[]);
+OMX_U32 putVADDRtoANB(OMX_PTR pUnreadableBuffer);
+OMX_ERRORTYPE enableStoreMetaDataInBuffers(OMX_HANDLETYPE hComponent, OMX_PTR ComponentParameterStructure);
+OMX_BOOL isMetadataBufferTypeGrallocSource(OMX_BYTE pInputDataBuffer);
+OMX_ERRORTYPE preprocessMetaDataInBuffers(OMX_HANDLETYPE hComponent, OMX_BYTE pInputDataBuffer, BUFFER_ADDRESS_INFO *pInputInfo);
+
+int isTvOutEnabled();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.c
new file mode 100644
index 0000000..66f8355
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_ETC.h
new file mode 100644
index 0000000..6c6ede7
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.c
new file mode 100644
index 0000000..51b3ca2
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Event.h
new file mode 100644
index 0000000..640d2cc
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.c
new file mode 100644
index 0000000..06ac712
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Library.h
new file mode 100644
index 0000000..687cecd
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.c
new file mode 100644
index 0000000..bae4974
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Log.h
new file mode 100644
index 0000000..2f8a6ce
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.c
new file mode 100644
index 0000000..3579d92
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Memory.h
new file mode 100644
index 0000000..3a12838
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.c
new file mode 100644
index 0000000..146809c
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Mutex.h
new file mode 100644
index 0000000..70dcd9d
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.c
new file mode 100644
index 0000000..7a6c024
--- /dev/null
+++ b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.c
@@ -0,0 +1,174 @@
+/*
+ *
+ * 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;
+}
+
+int SEC_OSAL_SetElemNum(SEC_QUEUE *queueHandle, int ElemNum)
+{
+    SEC_QUEUE *queue = (SEC_QUEUE *)queueHandle;
+    if (queue == NULL)
+        return -1;
+
+    SEC_OSAL_MutexLock(queue->qMutex);
+    queue->numElem = ElemNum; 
+    SEC_OSAL_MutexUnlock(queue->qMutex);
+    return ElemNum;
+}
+
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Queue.h
new file mode 100644
index 0000000..3f0938f
--- /dev/null
+++ b/exynos3/s5pc110/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
+
+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);
+int           SEC_OSAL_SetElemNum(SEC_QUEUE *queueHandle, int ElemNum);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.c
new file mode 100644
index 0000000..94bc9c8
--- /dev/null
+++ b/exynos3/s5pc110/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(sem_t));
+    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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Semaphore.h
new file mode 100644
index 0000000..f23d3d6
--- /dev/null
+++ b/exynos3/s5pc110/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/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.c b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.c
new file mode 100644
index 0000000..3b69d30
--- /dev/null
+++ b/exynos3/s5pc110/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_ThreadCancel(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_ThreadExit(void *value_ptr)
+{
+    pthread_exit(value_ptr);
+    return;
+}
+
+void SEC_OSAL_SleepMillisec(OMX_U32 ms)
+{
+    usleep(ms * 1000);
+    return;
+}
diff --git a/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.h b/exynos3/s5pc110/sec_mm/sec_omx/sec_osal/SEC_OSAL_Thread.h
new file mode 100644
index 0000000..ccd2609
--- /dev/null
+++ b/exynos3/s5pc110/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_ThreadCancel(OMX_HANDLETYPE threadHandle);
+void          SEC_OSAL_ThreadExit(void *value_ptr);
+void          SEC_OSAL_SleepMillisec(OMX_U32 ms);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/s5pc110.mk b/s5pc110.mk
new file mode 100644
index 0000000..c4f5e0e
--- /dev/null
+++ b/s5pc110.mk
@@ -0,0 +1,19 @@
+# Copyright (C) 2012 The Android Open Source Project
+#
+# 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.
+
+ifeq ($(TARGET_BOARD_PLATFORM),s5pc110)
+
+include hardware/samsung/exynos3/s5pc110/Android.mk
+
+endif