exynos: reorganized and updated from insignal
Changes needed on exynos4210 devices:
libcsc -> libseccscapi
libswconverter -> remove
TARGET_HAL_PATH := hardware/samsung/exynos4/hal
TARGET_OMX_PATH := hardware/samsung/exynos/multimedia/openmax
$(call inherit-product, hardware/samsung/exynos4210.mk)
Change-Id: Ic59ef95b85ef37b3f38fb36cf6a364a5414685ee
diff --git a/exynos4/Android.mk b/exynos4/exynos4210/Android.mk
similarity index 78%
rename from exynos4/Android.mk
rename to exynos4/exynos4210/Android.mk
index 3c99f1a..89f6189 100644
--- a/exynos4/Android.mk
+++ b/exynos4/exynos4210/Android.mk
@@ -1,3 +1,4 @@
+#
# Copyright (C) 2012 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
@@ -11,13 +12,11 @@
# 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),exynos4)
+exynos4210_dirs := liblights libsensors
-BOARD_HAL_PATH := hardware/samsung/exynos4/hal
-BOARD_HMM_PATH := hardware/samsung/exynos4/multimedia
-
-include $(BOARD_HAL_PATH)/Android.mk
-include $(BOARD_HMM_PATH)/Android.mk
+include $(call all-named-subdir-makefiles,$(exynos4210_dirs))
endif
diff --git a/exynos4/hal/liblights/Android.mk b/exynos4/exynos4210/liblights/Android.mk
similarity index 100%
rename from exynos4/hal/liblights/Android.mk
rename to exynos4/exynos4210/liblights/Android.mk
diff --git a/exynos4/hal/liblights/NOTICE b/exynos4/exynos4210/liblights/NOTICE
similarity index 100%
copy from exynos4/hal/liblights/NOTICE
copy to exynos4/exynos4210/liblights/NOTICE
diff --git a/exynos4/hal/liblights/lights.c b/exynos4/exynos4210/liblights/lights.c
similarity index 100%
rename from exynos4/hal/liblights/lights.c
rename to exynos4/exynos4210/liblights/lights.c
diff --git a/exynos4/hal/libsensors/AkmSensor.cpp b/exynos4/exynos4210/libsensors/AkmSensor.cpp
similarity index 100%
rename from exynos4/hal/libsensors/AkmSensor.cpp
rename to exynos4/exynos4210/libsensors/AkmSensor.cpp
diff --git a/exynos4/hal/libsensors/AkmSensor.h b/exynos4/exynos4210/libsensors/AkmSensor.h
similarity index 100%
rename from exynos4/hal/libsensors/AkmSensor.h
rename to exynos4/exynos4210/libsensors/AkmSensor.h
diff --git a/exynos4/hal/libsensors/Android.mk b/exynos4/exynos4210/libsensors/Android.mk
similarity index 100%
rename from exynos4/hal/libsensors/Android.mk
rename to exynos4/exynos4210/libsensors/Android.mk
diff --git a/exynos4/hal/libsensors/GyroSensor.cpp b/exynos4/exynos4210/libsensors/GyroSensor.cpp
similarity index 100%
rename from exynos4/hal/libsensors/GyroSensor.cpp
rename to exynos4/exynos4210/libsensors/GyroSensor.cpp
diff --git a/exynos4/hal/libsensors/GyroSensor.h b/exynos4/exynos4210/libsensors/GyroSensor.h
similarity index 100%
rename from exynos4/hal/libsensors/GyroSensor.h
rename to exynos4/exynos4210/libsensors/GyroSensor.h
diff --git a/exynos4/hal/libsensors/InputEventReader.cpp b/exynos4/exynos4210/libsensors/InputEventReader.cpp
similarity index 100%
rename from exynos4/hal/libsensors/InputEventReader.cpp
rename to exynos4/exynos4210/libsensors/InputEventReader.cpp
diff --git a/exynos4/hal/libsensors/InputEventReader.h b/exynos4/exynos4210/libsensors/InputEventReader.h
similarity index 100%
rename from exynos4/hal/libsensors/InputEventReader.h
rename to exynos4/exynos4210/libsensors/InputEventReader.h
diff --git a/exynos4/hal/libsensors/LightSensor.cpp b/exynos4/exynos4210/libsensors/LightSensor.cpp
similarity index 100%
rename from exynos4/hal/libsensors/LightSensor.cpp
rename to exynos4/exynos4210/libsensors/LightSensor.cpp
diff --git a/exynos4/hal/libsensors/LightSensor.h b/exynos4/exynos4210/libsensors/LightSensor.h
similarity index 100%
rename from exynos4/hal/libsensors/LightSensor.h
rename to exynos4/exynos4210/libsensors/LightSensor.h
diff --git a/exynos4/hal/libsensors/MODULE_LICENSE_APACHE2 b/exynos4/exynos4210/libsensors/MODULE_LICENSE_APACHE2
similarity index 100%
rename from exynos4/hal/libsensors/MODULE_LICENSE_APACHE2
rename to exynos4/exynos4210/libsensors/MODULE_LICENSE_APACHE2
diff --git a/exynos4/hal/libsensors/ProximitySensor.cpp b/exynos4/exynos4210/libsensors/ProximitySensor.cpp
similarity index 100%
rename from exynos4/hal/libsensors/ProximitySensor.cpp
rename to exynos4/exynos4210/libsensors/ProximitySensor.cpp
diff --git a/exynos4/hal/libsensors/ProximitySensor.h b/exynos4/exynos4210/libsensors/ProximitySensor.h
similarity index 100%
rename from exynos4/hal/libsensors/ProximitySensor.h
rename to exynos4/exynos4210/libsensors/ProximitySensor.h
diff --git a/exynos4/hal/libsensors/SensorBase.cpp b/exynos4/exynos4210/libsensors/SensorBase.cpp
similarity index 100%
rename from exynos4/hal/libsensors/SensorBase.cpp
rename to exynos4/exynos4210/libsensors/SensorBase.cpp
diff --git a/exynos4/hal/libsensors/SensorBase.h b/exynos4/exynos4210/libsensors/SensorBase.h
similarity index 100%
rename from exynos4/hal/libsensors/SensorBase.h
rename to exynos4/exynos4210/libsensors/SensorBase.h
diff --git a/exynos4/hal/libsensors/ak8973b.h b/exynos4/exynos4210/libsensors/ak8973b.h
similarity index 100%
rename from exynos4/hal/libsensors/ak8973b.h
rename to exynos4/exynos4210/libsensors/ak8973b.h
diff --git a/exynos4/hal/libsensors/sensors.cpp b/exynos4/exynos4210/libsensors/sensors.cpp
similarity index 100%
rename from exynos4/hal/libsensors/sensors.cpp
rename to exynos4/exynos4210/libsensors/sensors.cpp
diff --git a/exynos4/hal/libsensors/sensors.h b/exynos4/exynos4210/libsensors/sensors.h
similarity index 100%
rename from exynos4/hal/libsensors/sensors.h
rename to exynos4/exynos4210/libsensors/sensors.h
diff --git a/exynos4/hal/Android.mk b/exynos4/hal/Android.mk
index c1c40da..5765418 100644
--- a/exynos4/hal/Android.mk
+++ b/exynos4/hal/Android.mk
@@ -1,2 +1,29 @@
-exynos4_dirs := libfimg libhwconverter liblights libs5pjpeg libsensors libswconverter libump
-include $(call all-named-subdir-makefiles,$(exynos4_dirs))
+#
+# 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),exynos4)
+#common_exynos4_dirs := libgralloc_ump libhdmi libfimc libhwcomposer libcamera libhwconverter
+common_exynos4_dirs := libgralloc_ump libhdmi libfimc libhwcomposer libhwconverter
+exynos4210_dirs := $(common_exynos4_dirs) libs5pjpeg libfimg3x
+
+exynos4x12_dirs := $(common_exynos4_dirs) libhwjpeg libfimg4x
+
+ifeq ($(TARGET_SOC),exynos4210)
+ include $(call all-named-subdir-makefiles,$(exynos4210_dirs))
+else
+ include $(call all-named-subdir-makefiles,$(exynos4x12_dirs))
+endif
+endif
diff --git a/exynos4/hal/include/SecHdmi.h b/exynos4/hal/include/SecHdmi.h
index 67c3378..08bee20 100644
--- a/exynos4/hal/include/SecHdmi.h
+++ b/exynos4/hal/include/SecHdmi.h
@@ -159,6 +159,7 @@
void *mFBaddr;
unsigned int mFBsize;
int mFBionfd;
+ unsigned int mFBIndex;
int mHdmiFd[HDMI_LAYER_MAX];
int mDstWidth[HDMI_LAYER_MAX];
diff --git a/exynos4/hal/include/gralloc_priv.h b/exynos4/hal/include/gralloc_priv.h
index 9f3346a..8ffd161 100644
--- a/exynos4/hal/include/gralloc_priv.h
+++ b/exynos4/hal/include/gralloc_priv.h
@@ -1,6 +1,14 @@
/*
* Copyright (C) 2010 ARM Limited. All rights reserved.
*
+ * Portions of this code have been modified from the original.
+ * These modifications are:
+ * * includes
+ * * struct private_handle_t
+ * * usesPhysicallyContiguousMemory()
+ * * validate()
+ * * dynamicCast()
+ *
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,145 +35,200 @@
#include <hardware/gralloc.h>
#include <cutils/native_handle.h>
-#include <ump/ump.h>
+/*#include <ump/ump.h>*/
+#include "ump.h"
+
+/*
+ * HWC_HWOVERLAY is flag for location of glReadPixels().
+ * Enable this define if you want that glReadPixesl() is in HWComposer.
+ * If you disable this define, glReadPixesl() is called in threadloop().
+ */
+#define HWC_HWOVERLAY 1
#define GRALLOC_ARM_UMP_MODULE 1
struct private_handle_t;
-struct private_module_t
-{
- gralloc_module_t base;
+struct private_module_t {
+ gralloc_module_t base;
- private_handle_t* framebuffer;
- uint32_t flags;
- uint32_t numBuffers;
- uint32_t bufferMask;
- pthread_mutex_t lock;
- buffer_handle_t currentBuffer;
+ private_handle_t* framebuffer;
+ uint32_t flags;
+ uint32_t numBuffers;
+ uint32_t bufferMask;
+ pthread_mutex_t lock;
+ buffer_handle_t currentBuffer;
+ int ion_client;
- struct fb_var_screeninfo info;
- struct fb_fix_screeninfo finfo;
- float xdpi;
- float ydpi;
- float fps;
+ struct fb_var_screeninfo info;
+ struct fb_fix_screeninfo finfo;
+ float xdpi;
+ float ydpi;
+ float fps;
+ int enableVSync;
- enum
- {
- // flag to indicate we'll post this buffer
- PRIV_USAGE_LOCKED_FOR_POST = 0x80000000
- };
+ enum {
+ PRIV_USAGE_LOCKED_FOR_POST = 0x80000000
+ };
};
+#ifdef USE_PARTIAL_FLUSH
+struct private_handle_rect {
+ int handle;
+ int stride;
+ int l;
+ int t;
+ int w;
+ int h;
+ int locked;
+ struct private_handle_rect *next;
+};
+#endif
+
#ifdef __cplusplus
struct private_handle_t : public native_handle
{
#else
-struct private_handle_t
-{
- struct native_handle nativeHandle;
+struct private_handle_t {
+ struct native_handle nativeHandle;
#endif
+ enum {
+ PRIV_FLAGS_FRAMEBUFFER = 0x00000001,
+ PRIV_FLAGS_USES_UMP = 0x00000002,
+ PRIV_FLAGS_USES_PMEM = 0x00000004,
+ PRIV_FLAGS_USES_IOCTL = 0x00000008,
+ PRIV_FLAGS_USES_HDMI = 0x00000010,
+ PRIV_FLAGS_USES_ION = 0x00000020,
+ PRIV_FLAGS_NONE_CACHED = 0x00000040,
+ };
- enum
- {
- PRIV_FLAGS_FRAMEBUFFER = 0x00000001,
- PRIV_FLAGS_USES_UMP = 0x00000002,
- };
+ enum {
+ LOCK_STATE_WRITE = 1<<31,
+ LOCK_STATE_MAPPED = 1<<30,
+ LOCK_STATE_READ_MASK = 0x3FFFFFFF
+ };
- enum
- {
- LOCK_STATE_WRITE = 1<<31,
- LOCK_STATE_MAPPED = 1<<30,
- LOCK_STATE_READ_MASK = 0x3FFFFFFF
- };
+ int fd;
- // ints
- int magic;
- int flags;
- int size;
- int base;
- int lockState;
- int writeOwner;
- int pid;
+ int magic;
+ int flags;
+ int size;
+ int base;
+ int lockState;
+ int writeOwner;
+ int pid;
- // Following members are for UMP memory only
- int ump_id;
- int ump_mem_handle;
+ /* Following members are for UMP memory only */
+ int ump_id;
+ int ump_mem_handle;
+ int offset;
+ int paddr;
- // Following members is for framebuffer only
- int fd;
- int offset;
+ int format;
+ int usage;
+ int width;
+ int height;
+ int bpp;
+ int stride;
+ /* Following members are for ION memory only */
+ int ion_client;
+
+ /* Following members ard for YUV information */
+ unsigned int yaddr;
+ unsigned int uoffset;
+ unsigned int voffset;
#ifdef __cplusplus
- static const int sNumInts = 11;
- static const int sNumFds = 0;
- static const int sMagic = 0x3141592;
+ static const int sNumInts = 21;
+ static const int sNumFds = 1;
+ static const int sMagic = 0x3141592;
- private_handle_t(int flags, int size, int base, int lock_state, ump_secure_id secure_id, ump_handle handle):
- magic(sMagic),
- flags(flags),
- size(size),
- base(base),
- lockState(lock_state),
- writeOwner(0),
- pid(getpid()),
- ump_id((int)secure_id),
- ump_mem_handle((int)handle),
- fd(0),
- offset(0)
- {
- version = sizeof(native_handle);
- numFds = sNumFds;
- numInts = sNumInts;
- }
+ private_handle_t(int flags, int size, int base, int lock_state, ump_secure_id secure_id, ump_handle handle,int fd_val, int offset_val, int paddr_val):
+ fd(fd_val),
+ magic(sMagic),
+ flags(flags),
+ size(size),
+ base(base),
+ lockState(lock_state),
+ writeOwner(0),
+ pid(getpid()),
+ ump_id((int)secure_id),
+ ump_mem_handle((int)handle),
+ offset(offset_val),
+ paddr(paddr_val),
+ format(0),
+ usage(0),
+ width(0),
+ height(0),
+ bpp(0),
+ stride(0),
+ ion_client(0),
+ yaddr(0),
+ uoffset(0),
+ voffset(0)
+ {
+ version = sizeof(native_handle);
+ numFds = sNumFds;
+ numInts = sNumInts;
+ }
- private_handle_t(int flags, int size, int base, int lock_state, int fb_file, int fb_offset):
- magic(sMagic),
- flags(flags),
- size(size),
- base(base),
- lockState(lock_state),
- writeOwner(0),
- pid(getpid()),
- ump_id((int)UMP_INVALID_SECURE_ID),
- ump_mem_handle((int)UMP_INVALID_MEMORY_HANDLE),
- fd(fb_file),
- offset(fb_offset)
- {
- version = sizeof(native_handle);
- numFds = sNumFds;
- numInts = sNumInts;
- }
+ private_handle_t(int flags, int size, int base, int lock_state, int fb_file, int fb_offset):
+ fd(fb_file),
+ magic(sMagic),
+ flags(flags),
+ size(size),
+ base(base),
+ lockState(lock_state),
+ writeOwner(0),
+ pid(getpid()),
+ ump_id((int)UMP_INVALID_SECURE_ID),
+ ump_mem_handle((int)UMP_INVALID_MEMORY_HANDLE),
+ offset(fb_offset),
+ paddr(0),
+ format(0),
+ usage(0),
+ width(0),
+ height(0),
+ bpp(0),
+ stride(0),
+ ion_client(0),
+ yaddr(0),
+ uoffset(0),
+ voffset(0)
+ {
+ version = sizeof(native_handle);
+ numFds = sNumFds;
+ numInts = sNumInts;
+ }
- ~private_handle_t()
- {
- magic = 0;
- }
+ ~private_handle_t()
+ {
+ magic = 0;
+ }
- bool usesPhysicallyContiguousMemory()
- {
- return (flags & PRIV_FLAGS_FRAMEBUFFER) ? true : false;
- }
+ bool usesPhysicallyContiguousMemory()
+ {
+ return (flags & PRIV_FLAGS_FRAMEBUFFER) ? true : false;
+ }
- static int validate(const native_handle* h)
- {
- const private_handle_t* hnd = (const private_handle_t*)h;
- if (!h || h->version != sizeof(native_handle) || h->numInts != sNumInts || h->numFds != sNumFds || hnd->magic != sMagic)
- {
- return -EINVAL;
- }
- return 0;
- }
+ static int validate(const native_handle* h)
+ {
+ const private_handle_t* hnd = (const private_handle_t*)h;
+ if (!h || h->version != sizeof(native_handle) ||
+ h->numInts != sNumInts ||
+ h->numFds != sNumFds ||
+ hnd->magic != sMagic)
+ return -EINVAL;
+ return 0;
+ }
- static private_handle_t* dynamicCast(const native_handle* in)
- {
- if (validate(in) == 0)
- {
- return (private_handle_t*) in;
- }
- return NULL;
- }
+ static private_handle_t* dynamicCast(const native_handle* in)
+ {
+ if (validate(in) == 0)
+ return (private_handle_t*) in;
+ return NULL;
+ }
#endif
};
diff --git a/exynos4/hal/include/s3c_lcd.h b/exynos4/hal/include/s3c_lcd.h
index 7f2dec7..2782542 100644
--- a/exynos4/hal/include/s3c_lcd.h
+++ b/exynos4/hal/include/s3c_lcd.h
@@ -55,7 +55,6 @@
#ifdef BOARD_USE_V4L2_ION
struct s3c_fb_user_ion_client {
int fd;
- int offset;
};
#endif
diff --git a/exynos4/hal/include/sec_format.h b/exynos4/hal/include/sec_format.h
index 8722b45..23534c5 100644
--- a/exynos4/hal/include/sec_format.h
+++ b/exynos4/hal/include/sec_format.h
@@ -27,8 +27,6 @@
HAL_PIXEL_FORMAT_CbYCrY_420_I = 0x104,
HAL_PIXEL_FORMAT_YCbCr_420_SP = 0x105,
HAL_PIXEL_FORMAT_YCrCb_422_SP = 0x106,
- HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED = 0x107,
- HAL_PIXEL_FORMAT_ARGB888 = 0x108,
// support custom format for zero copy
HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP = 0x110,
HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP = 0x111,
diff --git a/exynos4/hal/include/swconverter.h b/exynos4/hal/include/swconverter.h
deleted file mode 100644
index eb2eae3..0000000
--- a/exynos4/hal/include/swconverter.h
+++ /dev/null
@@ -1,462 +0,0 @@
-/*
- *
- * Copyright 2012 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 swconverter.h
- * @brief SEC_OMX specific define. It support MFC 5.x tiled.
- * 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
- * 2012.02.01 : Create
- */
-
-#ifndef SW_CONVERTOR_H_
-#define SW_CONVERTOR_H_
-
-/*--------------------------------------------------------------------------------*/
-/* Format Conversion API */
-/*--------------------------------------------------------------------------------*/
-/*
- * 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(
- unsigned char *dest1,
- unsigned char *dest2,
- unsigned char *src,
- unsigned 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(
- unsigned char *dest,
- unsigned char *src1,
- unsigned char *src2,
- unsigned int src_size);
-
-/* C Code */
-/*
- * Converts tiled data to linear
- * 1. y of nv12t to y of yuv420p
- * 2. y of nv12t to y of yuv420s
- *
- * @param dst
- * y address of yuv420[out]
- *
- * @param src
- * y address of nv12t[in]
- *
- * @param yuv420_width
- * real width of yuv420[in]
- * it should be even
- *
- * @param yuv420_height
- * real height of yuv420[in]
- * it should be even.
- *
- */
-void csc_tiled_to_linear_y(
- unsigned char *y_dst,
- unsigned char *y_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts tiled data to linear
- * 1. uv of nv12t to y of yuv420s
- *
- * @param dst
- * uv address of yuv420s[out]
- *
- * @param src
- * uv address of nv12t[in]
- *
- * @param yuv420_width
- * real width of yuv420s[in]
- *
- * @param yuv420_height
- * real height of yuv420s[in]
- *
- */
-void csc_tiled_to_linear_uv(
- unsigned char *uv_dst,
- unsigned char *uv_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts tiled data to linear
- * 1. uv of nt12t to uv of yuv420p
- *
- * @param u_dst
- * u address of yuv420p[out]
- *
- * @param v_dst
- * v address of yuv420p[out]
- *
- * @param uv_src
- * uv address of nt12t[in]
- *
- * @param yuv420_width
- * real width of yuv420p[in]
- *
- * @param yuv420_height
- * real height of yuv420p[in]
- */
-void csc_tiled_to_linear_uv_deinterleave(
- unsigned char *u_dst,
- unsigned char *v_dst,
- unsigned char *uv_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts linear data to tiled
- * 1. y of yuv420 to y of nv12t
- *
- * @param dst
- * y address of nv12t[out]
- *
- * @param src
- * y address of yuv420[in]
- *
- * @param yuv420_width
- * real width of yuv420[in]
- * it should be even
- *
- * @param yuv420_height
- * real height of yuv420[in]
- * it should be even.
- *
- */
-void csc_linear_to_tiled_y(
- unsigned char *y_dst,
- unsigned char *y_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts and interleaves linear data to tiled
- * 1. uv of nv12t to uv of yuv420
- *
- * @param dst
- * uv address of nv12t[out]
- *
- * @param src
- * u address of yuv420[in]
- *
- * @param src
- * v address of yuv420[in]
- *
- * @param yuv420_width
- * real width of yuv420[in]
- *
- * @param yuv420_height
- * real height of yuv420[in]
- *
- */
-void csc_linear_to_tiled_uv(
- unsigned char *uv_dst,
- unsigned char *u_src,
- unsigned char *v_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts tiled data to linear for mfc 6.x
- * 1. Y of NV12T to Y of YUV420P
- * 2. Y of NV12T to Y of YUV420S
- *
- * @param dst
- * Y address of YUV420[out]
- *
- * @param src
- * Y address of NV12T[in]
- *
- * @param yuv420_width
- * real width of YUV420[in]
- *
- * @param yuv420_height
- * Y: real height of YUV420[in]
- *
- */
-void csc_tiled_to_linear_y_neon(
- unsigned char *y_dst,
- unsigned char *y_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts tiled data to linear for mfc 6.x
- * 1. UV of NV12T to Y of YUV420S
- *
- * @param u_dst
- * UV plane address of YUV420P[out]
- *
- * @param nv12t_src
- * Y or UV plane address of NV12T[in]
- *
- * @param yuv420_width
- * real width of YUV420[in]
- *
- * @param yuv420_height
- * (real height)/2 of YUV420[in]
- */
-void csc_tiled_to_linear_uv_neon(
- unsigned char *uv_dst,
- unsigned char *uv_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts tiled data to linear for mfc 6.x
- * Deinterleave src to u_dst, v_dst
- * 1. UV of NV12T to Y of YUV420P
- *
- * @param u_dst
- * U plane address of YUV420P[out]
- *
- * @param v_dst
- * V plane address of YUV420P[out]
- *
- * @param nv12t_src
- * Y or UV plane address of NV12T[in]
- *
- * @param yuv420_width
- * real width of YUV420[in]
- *
- * @param yuv420_height
- * (real height)/2 of YUV420[in]
- */
-void csc_tiled_to_linear_uv_deinterleave_neon(
- unsigned char *u_dst,
- unsigned char *v_dst,
- unsigned char *uv_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts linear data to tiled
- * 1. y of yuv420 to y of nv12t
- *
- * @param dst
- * y address of nv12t[out]
- *
- * @param src
- * y address of yuv420[in]
- *
- * @param yuv420_width
- * real width of yuv420[in]
- * it should be even
- *
- * @param yuv420_height
- * real height of yuv420[in]
- * it should be even.
- *
- */
-void csc_linear_to_tiled_y_neon(
- unsigned char *y_dst,
- unsigned char *y_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts and interleaves linear data to tiled
- * 1. uv of nv12t to uv of yuv420
- *
- * @param dst
- * uv address of nv12t[out]
- *
- * @param src
- * u address of yuv420[in]
- *
- * @param src
- * v address of yuv420[in]
- *
- * @param yuv420_width
- * real width of yuv420[in]
- *
- * @param yuv420_height
- * real height of yuv420[in]
- *
- */
-void csc_linear_to_tiled_uv_neon(
- unsigned char *uv_dst,
- unsigned char *u_src,
- unsigned char *v_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts RGB565 to YUV420P
- *
- * @param y_dst
- * Y plane address of YUV420P[out]
- *
- * @param u_dst
- * U plane address of YUV420P[out]
- *
- * @param v_dst
- * V plane address of YUV420P[out]
- *
- * @param rgb_src
- * Address of RGB565[in]
- *
- * @param width
- * Width of RGB565[in]
- *
- * @param height
- * Height of RGB565[in]
- */
-void csc_RGB565_to_YUV420P(
- unsigned char *y_dst,
- unsigned char *u_dst,
- unsigned char *v_dst,
- unsigned char *rgb_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts RGB565 to YUV420S
- *
- * @param y_dst
- * Y plane address of YUV420S[out]
- *
- * @param uv_dst
- * UV plane address of YUV420S[out]
- *
- * @param rgb_src
- * Address of RGB565[in]
- *
- * @param width
- * Width of RGB565[in]
- *
- * @param height
- * Height of RGB565[in]
- */
-void csc_RGB565_to_YUV420SP(
- unsigned char *y_dst,
- unsigned char *uv_dst,
- unsigned char *rgb_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts ARGB8888 to YUV420P
- *
- * @param y_dst
- * Y plane address of YUV420P[out]
- *
- * @param u_dst
- * U plane address of YUV420P[out]
- *
- * @param v_dst
- * V plane address of YUV420P[out]
- *
- * @param rgb_src
- * Address of ARGB8888[in]
- *
- * @param width
- * Width of ARGB8888[in]
- *
- * @param height
- * Height of ARGB8888[in]
- */
-void csc_ARGB8888_to_YUV420P(
- unsigned char *y_dst,
- unsigned char *u_dst,
- unsigned char *v_dst,
- unsigned char *rgb_src,
- unsigned int width,
- unsigned int height);
-
-/*
- * Converts ARGB888 to YUV420SP
- *
- * @param y_dst
- * Y plane address of YUV420SP[out]
- *
- * @param uv_dst
- * UV plane address of YUV420SP[out]
- *
- * @param rgb_src
- * Address of ARGB8888[in]
- *
- * @param width
- * Width of ARGB8888[in]
- *
- * @param height
- * Height of ARGB8888[in]
- */
-void csc_ARGB8888_to_YUV420SP(
- unsigned char *y_dst,
- unsigned char *uv_dst,
- unsigned char *rgb_src,
- unsigned int width,
- unsigned int height);
-
-#endif /*COLOR_SPACE_CONVERTOR_H_*/
diff --git a/exynos4/hal/libump/include/ump/ump.h b/exynos4/hal/include/ump.h
similarity index 91%
rename from exynos4/hal/libump/include/ump/ump.h
rename to exynos4/hal/include/ump.h
index 2829113..fd01c44 100644
--- a/exynos4/hal/libump/include/ump/ump.h
+++ b/exynos4/hal/include/ump.h
@@ -1,17 +1,11 @@
/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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.
+ * This confidential and proprietary software may be used only as
+ * authorised by a licensing agreement from ARM Limited
+ * (C) COPYRIGHT 2008-2010 ARM Limited
+ * ALL RIGHTS RESERVED
+ * The entire notice above must be reproduced on all authorised
+ * copies and copies may only be made to the extent permitted
+ * by a licensing agreement from ARM Limited.
*/
/**
@@ -31,6 +25,7 @@
#include "ump_platform.h"
+#include "ion.h"
#ifdef __cplusplus
extern "C" {
#endif
@@ -61,8 +56,8 @@
*/
typedef enum
{
- UMP_OK = 0, /**< indicates success */
- UMP_ERROR, /**< indicates failure */
+ UMP_OK, /**< indicates success */
+ UMP_ERROR, /**< indicates failure */
} ump_result;
diff --git a/exynos4/hal/include/ump_platform.h b/exynos4/hal/include/ump_platform.h
new file mode 100644
index 0000000..9285aef
--- /dev/null
+++ b/exynos4/hal/include/ump_platform.h
@@ -0,0 +1,46 @@
+/*
+ * This confidential and proprietary software may be used only as
+ * authorised by a licensing agreement from ARM Limited
+ * (C) COPYRIGHT 2008-2010 ARM Limited
+ * ALL RIGHTS RESERVED
+ * The entire notice above must be reproduced on all authorised
+ * copies and copies may only be made to the extent permitted
+ * by a licensing agreement from ARM Limited.
+ */
+
+/**
+ * @file ump_platform.h
+ *
+ * This file should define UMP_API_EXPORT,
+ * which dictates how the UMP user space API should be exported/imported.
+ * Modify this file, if needed, to match your platform setup.
+ */
+
+#ifndef __UMP_PLATFORM_H__
+#define __UMP_PLATFORM_H__
+
+/** @addtogroup ump_user_space_api
+ * @{ */
+
+/**
+ * A define which controls how UMP user space API functions are imported and exported.
+ * This define should be set by the implementor of the UMP API.
+ */
+#if defined(_WIN32)
+
+#define UMP_API_EXPORT
+
+#elif defined(__SYMBIAN32__)
+
+#define UMP_API_EXPORT IMPORT_C
+
+#else
+
+#define UMP_API_EXPORT
+
+#endif
+
+/** @} */ /* end group ump_user_space_api */
+
+
+#endif /* __UMP_PLATFORM_H__ */
diff --git a/exynos4/hal/libump/include/ump/ump_ref_drv.h b/exynos4/hal/include/ump_ref_drv.h
similarity index 63%
rename from exynos4/hal/libump/include/ump/ump_ref_drv.h
rename to exynos4/hal/include/ump_ref_drv.h
index 19fb28d..6320f1d 100644
--- a/exynos4/hal/libump/include/ump/ump_ref_drv.h
+++ b/exynos4/hal/include/ump_ref_drv.h
@@ -1,17 +1,11 @@
/*
- * Copyright (C) 2010 ARM Limited. All rights reserved.
- *
- * 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.
+ * This confidential and proprietary software may be used only as
+ * authorised by a licensing agreement from ARM Limited
+ * (C) COPYRIGHT 2009-2010 ARM Limited
+ * ALL RIGHTS RESERVED
+ * The entire notice above must be reproduced on all authorised
+ * copies and copies may only be made to the extent permitted
+ * by a licensing agreement from ARM Limited.
*/
/**
@@ -29,12 +23,12 @@
extern "C" {
#endif
-typedef enum
-{
- /* This enum must match with the IOCTL enum in ump_ioctl.h */
- UMP_REF_DRV_CONSTRAINT_NONE = 0,
- UMP_REF_DRV_CONSTRAINT_PHYSICALLY_LINEAR = 1,
- UMP_REF_DRV_CONSTRAINT_USE_CACHE = 4,
+typedef enum {
+ /* This enum must match with the IOCTL enum in ump_ioctl.h */
+ UMP_REF_DRV_CONSTRAINT_NONE = 0,
+ UMP_REF_DRV_CONSTRAINT_PHYSICALLY_LINEAR = 1,
+ /* This enum is included by samsung */
+ UMP_REF_DRV_CONSTRAINT_USE_CACHE = 128,
} ump_alloc_constraints;
/** Allocate an UMP handle containing a memory buffer.
@@ -44,8 +38,8 @@
* The flag UMP_REF_DRV_CONSTRAINT_PHYSICALLY_LINEAR is not supported.*/
UMP_API_EXPORT ump_handle ump_ref_drv_allocate(unsigned long size, ump_alloc_constraints usage);
-typedef enum
-{
+UMP_API_EXPORT ump_handle ump_ref_drv_ion_import(int ion_fd, ump_alloc_constraints constraints);
+typedef enum {
UMP_MSYNC_CLEAN = 0 ,
UMP_MSYNC_CLEAN_AND_INVALIDATE = 1,
UMP_MSYNC_READOUT_CACHE_ENABLED = 128,
@@ -58,7 +52,6 @@
* Return value is 1 if cache is enabled, and 0 if it is disabled for the given allocation.*/
UMP_API_EXPORT int ump_cpu_msync_now(ump_handle mem, ump_cpu_msync_op op, void* address, int size);
-
#ifdef __cplusplus
}
#endif
diff --git a/exynos4/hal/libcamera/Android.mk b/exynos4/hal/libcamera/Android.mk
new file mode 100644
index 0000000..9523db9
--- /dev/null
+++ b/exynos4/hal/libcamera/Android.mk
@@ -0,0 +1,38 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+# HAL module implemenation stored in
+# hw/<COPYPIX_HARDWARE_MODULE_ID>.<ro.product.board>.so
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
+
+LOCAL_SRC_FILES:= \
+ SecCamera.cpp SecCameraHWInterface.cpp
+
+LOCAL_SHARED_LIBRARIES:= libutils libcutils libbinder liblog libcamera_client libhardware
+
+ifeq ($(TARGET_SOC), exynos4210)
+LOCAL_SHARED_LIBRARIES += libs5pjpeg
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4210
+endif
+
+ifeq ($(TARGET_SOC), exynos4x12)
+LOCAL_SHARED_LIBRARIES += libhwjpeg
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4x12
+endif
+
+ifeq ($(BOARD_USE_V4L2), true)
+LOCAL_CFLAGS += -DBOARD_USE_V4L2
+endif
+
+ifeq ($(BOARD_USE_V4L2_ION), true)
+LOCAL_CFLAGS += -DBOARD_USE_V4L2
+LOCAL_CFLAGS += -DBOARD_USE_V4L2_ION
+endif
+
+LOCAL_MODULE := camera.$(TARGET_BOARD_PLATFORM)
+
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/hal/liblights/NOTICE b/exynos4/hal/libcamera/NOTICE
similarity index 100%
rename from exynos4/hal/liblights/NOTICE
rename to exynos4/hal/libcamera/NOTICE
diff --git a/exynos4/hal/libcamera/SecCamera.cpp b/exynos4/hal/libcamera/SecCamera.cpp
new file mode 100644
index 0000000..9c7bf94
--- /dev/null
+++ b/exynos4/hal/libcamera/SecCamera.cpp
@@ -0,0 +1,4360 @@
+/*
+ * Copyright 2008, The Android Open Source Project
+ * 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.
+ */
+
+/*
+************************************
+* Filename: SecCamera.cpp
+* Author: Sachin P. Kamat
+* Purpose: This file interacts with the Camera and JPEG drivers.
+*************************************
+*/
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "SecCamera"
+
+#include <utils/Log.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/poll.h>
+#include "SecCamera.h"
+#include "cutils/properties.h"
+
+using namespace android;
+
+#define CHECK(return_value) \
+ if (return_value < 0) { \
+ LOGE("%s::%d fail. errno: %s, m_camera_id = %d", \
+ __func__, __LINE__, strerror(errno), m_camera_id); \
+ return -1; \
+ }
+
+#define CHECK_PTR(return_value) \
+ if (return_value < 0) { \
+ LOGE("%s::%d fail, errno: %s, m_camera_id = %d", \
+ __func__,__LINE__, strerror(errno), m_camera_id); \
+ return NULL; \
+ }
+
+namespace android {
+
+static struct timeval time_start;
+static struct timeval time_stop;
+
+#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
+unsigned long measure_time_camera(struct timeval *start, struct timeval *stop)
+{
+ unsigned long sec, usec, time;
+
+ sec = stop->tv_sec - start->tv_sec;
+
+ if (stop->tv_usec >= start->tv_usec) {
+ usec = stop->tv_usec - start->tv_usec;
+ } else {
+ usec = stop->tv_usec + 1000000 - start->tv_usec;
+ sec--;
+ }
+
+ time = (sec * 1000000) + usec;
+
+ return time;
+}
+#endif
+
+static int close_buffers(struct SecBuffer *buffers, int num_of_buf)
+{
+ int ret;
+
+ for (int i = 0; i < num_of_buf; i++) {
+ for(int j = 0; j < MAX_PLANES; j++) {
+ if (buffers[i].virt.extP[j]) {
+#ifndef BOARD_USE_V4L2_ION
+ ret = munmap(buffers[i].virt.extP[j], buffers[i].size.extS[j]);
+ LOGV("munmap():buffers[%d].virt.extP[%d]: 0x%x size = %d",
+ i, j, (unsigned int) buffers[i].virt.extP[j],
+ buffers[i].size.extS[j]);
+#endif
+ buffers[i].virt.extP[j] = NULL;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int get_pixel_depth(unsigned int fmt)
+{
+ int depth = 0;
+
+ switch (fmt) {
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV12T:
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_YUV420:
+ case V4L2_PIX_FMT_YVU420:
+ case V4L2_PIX_FMT_YVU420M:
+ depth = 12;
+ break;
+
+ case V4L2_PIX_FMT_RGB565:
+ case V4L2_PIX_FMT_YUYV:
+ case V4L2_PIX_FMT_YVYU:
+ case V4L2_PIX_FMT_UYVY:
+ case V4L2_PIX_FMT_VYUY:
+ case V4L2_PIX_FMT_NV16:
+ case V4L2_PIX_FMT_NV61:
+ case V4L2_PIX_FMT_YUV422P:
+ depth = 16;
+ break;
+
+ case V4L2_PIX_FMT_RGB32:
+ depth = 32;
+ break;
+ }
+
+ return depth;
+}
+
+static int fimc_poll(struct pollfd *events)
+{
+ int ret;
+
+ /* 10 second delay is because sensor can take a long time
+ * to do auto focus and capture in dark settings
+ */
+ ret = poll(events, 1, 10000);
+ if (ret < 0) {
+ LOGE("ERR(%s):poll error", __func__);
+ return ret;
+ }
+
+ if (ret == 0) {
+ LOGE("ERR(%s):No data in 10 secs..", __func__);
+ return ret;
+ }
+
+ return ret;
+}
+
+static int fimc_v4l2_querycap(int fp)
+{
+ struct v4l2_capability cap;
+
+ if (ioctl(fp, VIDIOC_QUERYCAP, &cap) < 0) {
+ LOGE("ERR(%s):VIDIOC_QUERYCAP failed", __func__);
+ return -1;
+ }
+
+ if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+ LOGE("ERR(%s):no capture devices", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+static const __u8* fimc_v4l2_enuminput(int fp, int index)
+{
+ static struct v4l2_input input;
+
+ input.index = index;
+ if (ioctl(fp, VIDIOC_ENUMINPUT, &input) != 0) {
+ LOGE("ERR(%s):No matching index found", __func__);
+ return NULL;
+ }
+ LOGI("Name of input channel[%d] is %s", input.index, input.name);
+
+ return input.name;
+}
+
+static int fimc_v4l2_s_input(int fp, int index)
+{
+ struct v4l2_input input;
+
+ input.index = index;
+
+ if (ioctl(fp, VIDIOC_S_INPUT, &input) < 0) {
+ LOGE("ERR(%s):VIDIOC_S_INPUT failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int fimc_v4l2_s_fmt(int fp, int width, int height, unsigned int fmt, enum v4l2_field field, unsigned int num_plane)
+{
+ struct v4l2_format v4l2_fmt;
+ struct v4l2_pix_format pixfmt;
+ unsigned int framesize;
+
+ memset(&v4l2_fmt, 0, sizeof(struct v4l2_format));
+ v4l2_fmt.type = V4L2_BUF_TYPE;
+
+#ifdef BOARD_USE_V4L2
+ framesize = (width * height * get_pixel_depth(fmt)) / 8;
+
+ v4l2_fmt.fmt.pix_mp.width = width;
+ v4l2_fmt.fmt.pix_mp.height = height;
+ v4l2_fmt.fmt.pix_mp.pixelformat = fmt;
+ v4l2_fmt.fmt.pix_mp.field = field;
+ if (num_plane == 1) {
+ v4l2_fmt.fmt.pix_mp.plane_fmt[0].sizeimage = framesize;
+ } else if (num_plane == 2) {
+ v4l2_fmt.fmt.pix_mp.plane_fmt[0].sizeimage = ALIGN(width * height, 2048);
+ v4l2_fmt.fmt.pix_mp.plane_fmt[1].sizeimage = ALIGN(width/2, 16) * ALIGN(height/2, 16) * 2;
+ } else if (num_plane == 3) {
+ v4l2_fmt.fmt.pix_mp.plane_fmt[0].sizeimage = ALIGN(width, 16) * ALIGN(height, 16);
+ v4l2_fmt.fmt.pix_mp.plane_fmt[1].sizeimage = ALIGN(width/2, 16) * ALIGN(height/2, 16);
+ v4l2_fmt.fmt.pix_mp.plane_fmt[2].sizeimage = ALIGN(width/2, 16) * ALIGN(height/2, 16);
+ } else {
+ LOGE("ERR(%s): Invalid plane number", __func__);
+ return -1;
+ }
+ v4l2_fmt.fmt.pix_mp.num_planes = num_plane;
+#else
+ memset(&pixfmt, 0, sizeof(pixfmt));
+
+ pixfmt.width = width;
+ pixfmt.height = height;
+ pixfmt.pixelformat = fmt;
+ pixfmt.field = V4L2_FIELD_NONE;
+
+ v4l2_fmt.fmt.pix = pixfmt;
+ LOGV("fimc_v4l2_s_fmt : width(%d) height(%d)", width, height);
+#endif
+
+ /* Set up for capture */
+ if (ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt) < 0) {
+ LOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int fimc_v4l2_s_fmt_cap(int fp, int width, int height, unsigned int fmt)
+{
+ struct v4l2_format v4l2_fmt;
+ struct v4l2_pix_format pixfmt;
+
+ memset(&pixfmt, 0, sizeof(pixfmt));
+
+ v4l2_fmt.type = V4L2_BUF_TYPE;
+
+ pixfmt.width = width;
+ pixfmt.height = height;
+ pixfmt.pixelformat = fmt;
+ if (fmt == V4L2_PIX_FMT_JPEG)
+ pixfmt.colorspace = V4L2_COLORSPACE_JPEG;
+
+ v4l2_fmt.fmt.pix = pixfmt;
+ LOGV("fimc_v4l2_s_fmt_cap : width(%d) height(%d)", width, height);
+
+ /* Set up for capture */
+ if (ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt) < 0) {
+ LOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_s_fmt_is(int fp, int width, int height, unsigned int fmt, enum v4l2_field field)
+{
+ struct v4l2_format v4l2_fmt;
+ struct v4l2_pix_format pixfmt;
+
+ memset(&pixfmt, 0, sizeof(pixfmt));
+
+ v4l2_fmt.type = V4L2_BUF_TYPE_PRIVATE;
+
+ pixfmt.width = width;
+ pixfmt.height = height;
+ pixfmt.pixelformat = fmt;
+ pixfmt.field = field;
+
+ v4l2_fmt.fmt.pix = pixfmt;
+ LOGV("fimc_v4l2_s_fmt_is : width(%d) height(%d)", width, height);
+
+ /* Set up for capture */
+ if (ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt) < 0) {
+ LOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int fimc_v4l2_enum_fmt(int fp, unsigned int fmt)
+{
+ struct v4l2_fmtdesc fmtdesc;
+ int found = 0;
+
+ fmtdesc.type = V4L2_BUF_TYPE;
+ fmtdesc.index = 0;
+
+ while (ioctl(fp, VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
+ if (fmtdesc.pixelformat == fmt) {
+ LOGV("passed fmt = %#x found pixel format[%d]: %s", fmt, fmtdesc.index, fmtdesc.description);
+ found = 1;
+ break;
+ }
+
+ fmtdesc.index++;
+ }
+
+ if (!found) {
+ LOGE("unsupported pixel format");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int fimc_v4l2_reqbufs(int fp, enum v4l2_buf_type type, int nr_bufs)
+{
+ struct v4l2_requestbuffers req;
+
+ req.count = nr_bufs;
+ req.type = type;
+ req.memory = V4L2_MEMORY_TYPE;
+
+ if (ioctl(fp, VIDIOC_REQBUFS, &req) < 0) {
+ LOGE("ERR(%s):VIDIOC_REQBUFS failed", __func__);
+ return -1;
+ }
+
+ return req.count;
+}
+
+static int fimc_v4l2_querybuf(int fp, struct SecBuffer *buffers, enum v4l2_buf_type type, int nr_frames, int num_plane)
+{
+ struct v4l2_buffer v4l2_buf;
+#ifdef BOARD_USE_V4L2
+ struct v4l2_plane planes[VIDEO_MAX_PLANES];
+#endif
+ int i, ret, plane_index;
+
+ for (i = 0; i < nr_frames; i++) {
+ v4l2_buf.type = type;
+ v4l2_buf.memory = V4L2_MEMORY_TYPE;
+ v4l2_buf.index = i;
+#ifdef BOARD_USE_V4L2
+ v4l2_buf.m.planes = planes;
+ v4l2_buf.length = num_plane; // this is for multi-planar
+ LOGV("QUERYBUF(index=%d)", i);
+ LOGV("memory plane is %d", v4l2_buf.length);
+#endif
+
+ ret = ioctl(fp, VIDIOC_QUERYBUF, &v4l2_buf);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_QUERYBUF failed", __func__);
+ return -1;
+ }
+
+#ifdef BOARD_USE_V4L2
+ for (plane_index = 0; plane_index < num_plane; plane_index++) {
+ LOGV("Offset : 0x%x", v4l2_buf.m.planes[plane_index].m.mem_offset);
+ LOGV("Plane Length : 0x%x", v4l2_buf.m.planes[plane_index].length);
+
+ buffers[i].phys.extP[plane_index] = (unsigned int)v4l2_buf.m.planes[plane_index].cookie;
+
+ buffers[i].size.extS[plane_index] = v4l2_buf.m.planes[plane_index].length;
+ LOGV("length[%d] : 0x%x", i, buffers[i].size.extS[plane_index]);
+ if ((buffers[i].virt.extP[plane_index] = (char *)mmap(0, v4l2_buf.m.planes[plane_index].length,
+ PROT_READ | PROT_WRITE, MAP_SHARED, fp, v4l2_buf.m.planes[plane_index].m.mem_offset)) < 0) {
+ LOGE("mmap failed");
+ return -1;
+ }
+ LOGV("vaddr[%d][%d] : 0x%x", i, plane_index, (__u32) buffers[i].virt.extP[plane_index]);
+ }
+#else
+ buffers[i].size.s = v4l2_buf.length;
+
+ if ((buffers[i].virt.p = (char *)mmap(0, v4l2_buf.length, PROT_READ | PROT_WRITE, MAP_SHARED,
+ fp, v4l2_buf.m.offset)) < 0) {
+ LOGE("%s %d] mmap() failed",__func__, __LINE__);
+ return -1;
+ }
+ LOGV("buffers[%d].virt.p = %p v4l2_buf.length = %d", i, buffers[i].virt.p, v4l2_buf.length);
+#endif
+ }
+ return 0;
+}
+
+static int fimc_v4l2_streamon(int fp)
+{
+ enum v4l2_buf_type type = V4L2_BUF_TYPE;
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_STREAMON, &type);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_STREAMON failed", __func__);
+ return ret;
+ }
+
+ return ret;
+}
+
+static int fimc_v4l2_streamoff(int fp)
+{
+ enum v4l2_buf_type type = V4L2_BUF_TYPE;
+ int ret;
+
+ LOGV("%s :", __func__);
+ ret = ioctl(fp, VIDIOC_STREAMOFF, &type);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_STREAMOFF failed", __func__);
+ return ret;
+ }
+
+ return ret;
+}
+
+static int fimc_v4l2_qbuf(int fp, int width, int height, struct SecBuffer *vaddr, int index, int num_plane, int mode)
+{
+ struct v4l2_buffer v4l2_buf;
+ int ret;
+
+#ifdef BOARD_USE_V4L2
+ struct v4l2_plane planes[VIDEO_MAX_PLANES];
+
+ v4l2_buf.m.planes = planes;
+ v4l2_buf.length = num_plane;
+#endif
+
+ v4l2_buf.type = V4L2_BUF_TYPE;
+ v4l2_buf.memory = V4L2_MEMORY_TYPE;
+ v4l2_buf.index = index;
+
+#ifdef BOARD_USE_V4L2_ION
+ if (mode == PREVIEW_MODE) {
+ if (num_plane == 1) {
+ v4l2_buf.m.planes[0].m.userptr = (long unsigned int)vaddr[index].virt.extP[0];
+ v4l2_buf.m.planes[0].length = width * height * 2;
+ } else if (num_plane == 2) {
+ v4l2_buf.m.planes[0].m.userptr = (long unsigned int)vaddr[index].virt.extP[0];
+ v4l2_buf.m.planes[0].length = ALIGN(width, 16) * ALIGN(height, 16);
+ v4l2_buf.m.planes[1].m.userptr = (long unsigned int)vaddr[index].virt.extP[1];
+ v4l2_buf.m.planes[1].length = ALIGN(width/2, 16) * ALIGN(height/2, 16);
+ } else if (num_plane == 3) {
+ v4l2_buf.m.planes[0].m.userptr = (long unsigned int)vaddr[index].virt.extP[0];
+ v4l2_buf.m.planes[0].length = ALIGN(width, 16) * ALIGN(height, 16);
+ v4l2_buf.m.planes[1].m.userptr = (long unsigned int)vaddr[index].virt.extP[1];
+ v4l2_buf.m.planes[1].length = ALIGN(width/2, 16) * ALIGN(height/2, 16);
+ v4l2_buf.m.planes[2].m.userptr = (long unsigned int)vaddr[index].virt.extP[2];
+ v4l2_buf.m.planes[2].length = ALIGN(width/2, 16) * ALIGN(height/2, 16);
+ } else {
+ LOGE("ERR(%s): Invalid plane number", __func__);
+ return -1;
+ }
+ } else if (mode == CAPTURE_MODE) {
+ v4l2_buf.m.planes[0].m.userptr = (long unsigned int)vaddr[index].virt.extP[0];
+ v4l2_buf.m.planes[0].length = width * height * 2;
+ } else if (mode == RECORD_MODE) {
+ v4l2_buf.m.planes[0].m.userptr = (long unsigned int)vaddr[index].virt.extP[0];
+ v4l2_buf.m.planes[0].length = ALIGN(ALIGN(width, 16) * ALIGN(height, 16), 2048);
+ v4l2_buf.m.planes[1].m.userptr = (long unsigned int)vaddr[index].virt.extP[1];
+ v4l2_buf.m.planes[1].length = ALIGN(ALIGN(width, 16) * ALIGN(height >> 1, 8), 2048);
+ } else {
+ LOGE("ERR(%s): Invalid mode", __func__);
+ return -1;
+ }
+#endif
+
+ ret = ioctl(fp, VIDIOC_QBUF, &v4l2_buf);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_QBUF failed", __func__);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int fimc_v4l2_dqbuf(int fp, int num_plane)
+{
+ struct v4l2_buffer v4l2_buf;
+ int ret;
+
+#ifdef BOARD_USE_V4L2
+ struct v4l2_plane planes[VIDEO_MAX_PLANES];
+
+ v4l2_buf.m.planes = planes;
+ v4l2_buf.length = num_plane;
+#endif
+
+ v4l2_buf.type = V4L2_BUF_TYPE;
+ v4l2_buf.memory = V4L2_MEMORY_TYPE;
+
+ ret = ioctl(fp, VIDIOC_DQBUF, &v4l2_buf);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_DQBUF failed, dropped frame", __func__);
+ return ret;
+ }
+
+ return v4l2_buf.index;
+}
+
+static int fimc_v4l2_g_ctrl(int fp, unsigned int id)
+{
+ struct v4l2_control ctrl;
+ int ret;
+
+ ctrl.id = id;
+
+ ret = ioctl(fp, VIDIOC_G_CTRL, &ctrl);
+ if (ret < 0) {
+ LOGE("ERR(%s): VIDIOC_G_CTRL(id = 0x%x (%d)) failed, ret = %d",
+ __func__, id, id-V4L2_CID_PRIVATE_BASE, ret);
+ return ret;
+ }
+
+ return ctrl.value;
+}
+
+static int fimc_v4l2_s_ctrl(int fp, unsigned int id, unsigned int value)
+{
+ struct v4l2_control ctrl;
+ int ret;
+
+ ctrl.id = id;
+ ctrl.value = value;
+
+ ret = ioctl(fp, VIDIOC_S_CTRL, &ctrl);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_S_CTRL(id = %#x (%d), value = %d) failed ret = %d",
+ __func__, id, id-V4L2_CID_PRIVATE_BASE, value, ret);
+
+ return ret;
+ }
+
+ return ctrl.value;
+}
+
+static int fimc_v4l2_s_ext_ctrl(int fp, unsigned int id, void *value)
+{
+ struct v4l2_ext_controls ctrls;
+ struct v4l2_ext_control ctrl;
+ int ret;
+
+ ctrl.id = id;
+
+ ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+ ctrls.count = 1;
+ ctrls.controls = &ctrl;
+
+ ret = ioctl(fp, VIDIOC_S_EXT_CTRLS, &ctrls);
+ if (ret < 0)
+ LOGE("ERR(%s):VIDIOC_S_EXT_CTRLS failed", __func__);
+
+ return ret;
+}
+
+static int fimc_v4l2_s_ext_ctrl_face_detection(int fp, unsigned int id, void *value)
+{
+ struct v4l2_ext_control ext_ctrl_fd[111];
+ struct v4l2_ext_controls ext_ctrls_fd;
+ struct v4l2_ext_controls *ctrls;
+ camera_frame_metadata_t *facedata = (camera_frame_metadata_t *)value;
+ int i, ret;
+
+ ext_ctrl_fd[0].id = V4L2_CID_IS_FD_GET_FACE_COUNT;
+ for (i = 0; i < 5; i++) {
+ ext_ctrl_fd[22*i+1].id = V4L2_CID_IS_FD_GET_FACE_FRAME_NUMBER;
+ ext_ctrl_fd[22*i+2].id = V4L2_CID_IS_FD_GET_FACE_CONFIDENCE;
+ ext_ctrl_fd[22*i+3].id = V4L2_CID_IS_FD_GET_FACE_SMILE_LEVEL;
+ ext_ctrl_fd[22*i+4].id = V4L2_CID_IS_FD_GET_FACE_BLINK_LEVEL;
+ ext_ctrl_fd[22*i+5].id = V4L2_CID_IS_FD_GET_FACE_TOPLEFT_X;
+ ext_ctrl_fd[22*i+6].id = V4L2_CID_IS_FD_GET_FACE_TOPLEFT_Y;
+ ext_ctrl_fd[22*i+7].id = V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_X;
+ ext_ctrl_fd[22*i+8].id = V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_Y;
+ ext_ctrl_fd[22*i+9].id = V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_X;
+ ext_ctrl_fd[22*i+10].id = V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_Y;
+ ext_ctrl_fd[22*i+11].id = V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_X;
+ ext_ctrl_fd[22*i+12].id = V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_Y;
+ ext_ctrl_fd[22*i+13].id = V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_X;
+ ext_ctrl_fd[22*i+14].id = V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_Y;
+ ext_ctrl_fd[22*i+15].id = V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_X;
+ ext_ctrl_fd[22*i+16].id = V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_Y;
+ ext_ctrl_fd[22*i+17].id = V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_X;
+ ext_ctrl_fd[22*i+18].id = V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_Y;
+ ext_ctrl_fd[22*i+19].id = V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_X;
+ ext_ctrl_fd[22*i+20].id = V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_Y;
+ ext_ctrl_fd[22*i+21].id = V4L2_CID_IS_FD_GET_ANGLE;
+ ext_ctrl_fd[22*i+22].id = V4L2_CID_IS_FD_GET_NEXT;
+ }
+
+ ext_ctrls_fd.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+ ext_ctrls_fd.count = 111;
+ ext_ctrls_fd.controls = ext_ctrl_fd;
+ ctrls = &ext_ctrls_fd;
+
+ ret = ioctl(fp, VIDIOC_G_EXT_CTRLS, &ext_ctrls_fd);
+
+ facedata->number_of_faces = ext_ctrls_fd.controls[0].value;
+
+ for(i = 0; i < facedata->number_of_faces; i++) {
+ facedata->faces[i].rect[0] = ext_ctrl_fd[22*i+5].value;
+ facedata->faces[i].rect[1] = ext_ctrl_fd[22*i+6].value;
+ facedata->faces[i].rect[2] = ext_ctrl_fd[22*i+7].value;
+ facedata->faces[i].rect[3] = ext_ctrl_fd[22*i+8].value;
+ facedata->faces[i].score = ext_ctrl_fd[22*i+2].value;
+/* TODO : id is unique value for each face. We need to suppot this. */
+ facedata->faces[i].id = 0;
+ facedata->faces[i].left_eye[0] = (ext_ctrl_fd[22*i+9].value + ext_ctrl_fd[22*i+11].value) / 2;
+ facedata->faces[i].left_eye[1] = (ext_ctrl_fd[22*i+10].value + ext_ctrl_fd[22*i+12].value) / 2;
+ facedata->faces[i].right_eye[0] = (ext_ctrl_fd[22*i+13].value + ext_ctrl_fd[22*i+15].value) / 2;
+ facedata->faces[i].right_eye[1] = (ext_ctrl_fd[22*i+14].value + ext_ctrl_fd[22*i+16].value) / 2;
+ facedata->faces[i].mouth[0] = (ext_ctrl_fd[22*i+17].value + ext_ctrl_fd[22*i+19].value) / 2;
+ facedata->faces[i].mouth[1] = (ext_ctrl_fd[22*i+18].value + ext_ctrl_fd[22*i+20].value) / 2;
+ }
+
+ return ret;
+}
+
+static int fimc_v4l2_g_parm(int fp, struct v4l2_streamparm *streamparm)
+{
+ int ret;
+
+ streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+ ret = ioctl(fp, VIDIOC_G_PARM, streamparm);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_G_PARM failed", __func__);
+ return -1;
+ }
+
+ LOGV("%s : timeperframe: numerator %d, denominator %d", __func__,
+ streamparm->parm.capture.timeperframe.numerator,
+ streamparm->parm.capture.timeperframe.denominator);
+
+ return 0;
+}
+
+static int fimc_v4l2_s_parm(int fp, struct v4l2_streamparm *streamparm)
+{
+ int ret;
+
+ streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+ ret = ioctl(fp, VIDIOC_S_PARM, streamparm);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_S_PARM failed", __func__);
+ return ret;
+ }
+
+ return 0;
+}
+
+SecCamera::SecCamera() :
+ m_flagCreate(0),
+ m_preview_state(0),
+ m_snapshot_state(0),
+ m_camera_id(CAMERA_ID_BACK),
+ m_camera_use_ISP(0),
+ m_cam_fd(-1),
+ m_cam_fd2(-1),
+ m_cam_fd3(-1),
+ m_cap_fd(-1),
+ m_rec_fd(-1),
+ m_jpeg_fd(-1),
+ m_flag_record_start(0),
+ m_preview_v4lformat(V4L2_PIX_FMT_YVU420),
+ m_preview_width (0),
+ m_preview_height (0),
+ m_preview_max_width (MAX_BACK_CAMERA_PREVIEW_WIDTH),
+ m_preview_max_height (MAX_BACK_CAMERA_PREVIEW_HEIGHT),
+ m_snapshot_v4lformat(V4L2_PIX_FMT_YUYV),
+ m_snapshot_width (0),
+ m_snapshot_height (0),
+ m_num_capbuf (0),
+ m_videosnapshot_width (0),
+ m_videosnapshot_height(0),
+ m_snapshot_max_width (MAX_BACK_CAMERA_SNAPSHOT_WIDTH),
+ m_snapshot_max_height (MAX_BACK_CAMERA_SNAPSHOT_HEIGHT),
+ m_recording_en (0),
+ m_record_hint (0),
+ m_recording_width (0),
+ m_recording_height (0),
+ m_angle(-1),
+ m_anti_banding(0),
+ m_wdr(0),
+ m_anti_shake(0),
+ m_zoom_level(-1),
+ m_object_tracking(-1),
+ m_smart_auto(-1),
+ m_beauty_shot(-1),
+ m_vintage_mode(-1),
+ m_face_detect(0),
+ m_object_tracking_start_stop(-1),
+ m_gps_latitude(-1),
+ m_gps_longitude(-1),
+ m_gps_altitude(-1),
+ m_gps_timestamp(-1),
+ m_sensor_mode(-1),
+ m_shot_mode(-1),
+ m_exif_orientation(-1),
+ m_chk_dataline(-1),
+ m_video_gamma(0),
+ m_slow_ae(0),
+ m_camera_af_flag(-1),
+ m_flag_camera_create(0),
+ m_flag_camera_start(0),
+ m_jpeg_thumbnail_width (0),
+ m_jpeg_thumbnail_height(0),
+ m_jpeg_thumbnail_quality(100),
+ m_jpeg_quality(100),
+ m_touch_af_start_stop(-1),
+ m_postview_offset(0),
+ m_auto_focus_state(0)
+#ifdef ENABLE_ESD_PREVIEW_CHECK
+ ,
+ m_esd_check_count(0)
+#endif // ENABLE_ESD_PREVIEW_CHECK
+{
+ initParameters(0);
+ memset(&mExifInfo, 0, sizeof(mExifInfo));
+
+ memset(&m_events_c, 0, sizeof(m_events_c));
+ memset(&m_events_c2, 0, sizeof(m_events_c2));
+ memset(&m_events_c3, 0, sizeof(m_events_c3));
+}
+
+SecCamera::~SecCamera()
+{
+ LOGV("%s :", __func__);
+ DestroyCamera();
+}
+
+bool SecCamera::CreateCamera(int index)
+{
+ LOGV("%s :", __func__);
+ int ret = 0;
+
+ switch (index) {
+ case CAMERA_ID_FRONT:
+ m_preview_max_width = MAX_FRONT_CAMERA_PREVIEW_WIDTH;
+ m_preview_max_height = MAX_FRONT_CAMERA_PREVIEW_HEIGHT;
+ m_snapshot_max_width = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH;
+ m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT;
+ break;
+
+ case CAMERA_ID_BACK:
+ default:
+ m_preview_max_width = MAX_BACK_CAMERA_PREVIEW_WIDTH;
+ m_preview_max_height = MAX_BACK_CAMERA_PREVIEW_HEIGHT;
+ m_snapshot_max_width = MAX_BACK_CAMERA_SNAPSHOT_WIDTH;
+ m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT;
+ break;
+ }
+
+ if (!m_flagCreate) {
+ /* Arun C
+ * Reset the lense position only during camera starts; don't do
+ * reset between shot to shot
+ */
+ m_flagCreate = 1;
+ m_snapshot_state = 0;
+ m_camera_af_flag = -1;
+ m_camera_id = index;
+ m_recording_en = 0;
+
+ m_cam_fd = open(CAMERA_DEV_NAME, O_RDWR);
+ if (m_cam_fd < 0) {
+ LOGE("ERR(%s):Cannot open %s (error : %s)", __func__, CAMERA_DEV_NAME, strerror(errno));
+ return -1;
+ }
+ LOGV("%s: open(%s) --> m_cam_fd %d", __func__, CAMERA_DEV_NAME, m_cam_fd);
+
+ ret = fimc_v4l2_querycap(m_cam_fd);
+ CHECK(ret);
+ if (!fimc_v4l2_enuminput(m_cam_fd, index)) {
+ LOGE("m_cam_fd(%d) fimc_v4l2_enuminput fail", m_cam_fd);
+ return -1;
+ }
+ ret = fimc_v4l2_s_input(m_cam_fd, index);
+ CHECK(ret);
+
+ m_camera_use_ISP = getUseInternalISP();
+
+ if (m_camera_use_ISP) {
+ if (!m_recording_en)
+ fimc_v4l2_s_fmt_is(m_cam_fd, m_preview_max_width, m_preview_max_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_PREVIEW_STILL);
+ else
+ fimc_v4l2_s_fmt_is(m_cam_fd, m_preview_max_width, m_preview_max_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_PREVIEW_VIDEO);
+ }
+
+ ret = fimc_v4l2_s_fmt(m_cam_fd, m_preview_max_width, m_preview_max_height,
+ m_preview_v4lformat, V4L2_FIELD_ANY, PREVIEW_NUM_PLANE);
+ CHECK(ret);
+
+ initParameters(m_camera_use_ISP);
+
+#ifdef SAMSUNG_EXYNOS4x12
+#ifdef ZERO_SHUTTER_LAG
+ if (m_camera_use_ISP) {
+ m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR);
+ LOGV("%s: open(%s) --> m_cam_fd2 = %d", __func__, CAMERA_DEV_NAME2, m_cam_fd2);
+ if (m_cam_fd2 < 0) {
+ LOGE("ERR(%s):Cannot open %s (error : %s)", __func__, CAMERA_DEV_NAME2, strerror(errno));
+ return -1;
+ }
+
+ ret = fimc_v4l2_querycap(m_cam_fd2);
+ CHECK(ret);
+ if (!fimc_v4l2_enuminput(m_cam_fd2, index)) {
+ LOGE("m_cam_fd2(%d) fimc_v4l2_enuminput fail", m_cam_fd2);
+ return -1;
+ }
+ ret = fimc_v4l2_s_input(m_cam_fd2, index);
+ CHECK(ret);
+ }
+#endif
+#endif
+
+ m_cam_fd3 = open(CAMERA_DEV_NAME3, O_RDWR);
+ LOGV("%s: open(%s) --> m_cam_fd3 = %d", __func__, CAMERA_DEV_NAME3, m_cam_fd3);
+ if (m_cam_fd3 < 0) {
+ LOGE("ERR(%s):Cannot open %s (error : %s)", __func__, CAMERA_DEV_NAME3, strerror(errno));
+ return -1;
+ }
+
+ ret = fimc_v4l2_querycap(m_cam_fd3);
+ CHECK(ret);
+ if (!fimc_v4l2_enuminput(m_cam_fd3, index)) {
+ LOGE("m_cam_fd3(%d) fimc_v4l2_enuminput fail", m_cam_fd3);
+ return -1;
+ }
+ ret = fimc_v4l2_s_input(m_cam_fd3, index);
+ CHECK(ret);
+
+ setExifFixedAttribute();
+ }
+
+#ifdef ZERO_SHUTTER_LAG
+ if (m_camera_use_ISP)
+ m_cap_fd = m_cam_fd2;
+ else
+ m_cap_fd = m_cam_fd;
+#else
+ m_cap_fd = m_cam_fd;
+#endif
+
+ m_rec_fd = m_cam_fd3;
+
+ if (m_camera_use_ISP)
+ m_num_capbuf = CAP_BUFFERS;
+ else
+ m_num_capbuf = 1;
+
+ m_flag_camera_create = 1;
+
+ return 0;
+}
+
+void SecCamera::resetCamera()
+{
+ LOGV("%s :", __func__);
+ DestroyCamera();
+ CreateCamera(m_camera_id);
+}
+
+bool SecCamera::DestroyCamera()
+{
+ LOGV("%s :", __func__);
+
+ if (m_flagCreate) {
+
+ stopRecord();
+
+ /* close m_cam_fd after stopRecord() because stopRecord()
+ * uses m_cam_fd to change frame rate
+ */
+ LOGI("DestroyCamera: m_cam_fd(%d)", m_cam_fd);
+ if (m_cam_fd > -1) {
+ close(m_cam_fd);
+ m_cam_fd = -1;
+ }
+
+#ifdef ZERO_SHUTTER_LAG
+ if (m_camera_use_ISP) {
+ LOGI("DestroyCamera: m_cam_fd2(%d)", m_cam_fd2);
+ if (m_cam_fd2 > -1) {
+ close(m_cam_fd2);
+ m_cam_fd2 = -1;
+ }
+ }
+#endif
+
+ LOGI("DestroyCamera: m_cam_fd3(%d)", m_cam_fd3);
+ if (m_cam_fd3 > -1) {
+ close(m_cam_fd3);
+ m_cam_fd3 = -1;
+ }
+
+ m_flagCreate = 0;
+ } else
+ LOGI("%s : already deinitialized", __func__);
+
+ return 0;
+}
+
+void SecCamera::initParameters(int internalISP)
+{
+ memset(&m_streamparm, 0, sizeof(m_streamparm));
+ m_params = (struct sec_cam_parm*)&m_streamparm.parm.raw_data;
+ struct v4l2_captureparm capture;
+
+ m_params->capture.timeperframe.numerator = 1;
+ m_params->capture.timeperframe.denominator = FRAME_RATE_AUTO;
+ m_params->flash_mode = FLASH_MODE_AUTO;
+ m_params->iso = ISO_AUTO;
+ m_params->metering = METERING_CENTER;
+ m_params->saturation = SATURATION_DEFAULT;
+ m_params->scene_mode = SCENE_MODE_NONE;
+ m_params->sharpness = SHARPNESS_DEFAULT;
+ m_params->white_balance = WHITE_BALANCE_AUTO;
+ m_params->anti_banding = ANTI_BANDING_OFF;
+ m_params->effects = IMAGE_EFFECT_NONE;
+ m_params->focus_mode = FOCUS_MODE_AUTO;
+
+ if (internalISP) {
+ m_params->contrast = IS_CONTRAST_DEFAULT;
+ m_params->brightness = IS_BRIGHTNESS_DEFAULT;
+ m_params->exposure = IS_EXPOSURE_DEFAULT;
+ m_params->hue = IS_HUE_DEFAULT;
+ m_params->aeawb_mode = AE_UNLOCK_AWB_UNLOCK;
+ } else {
+ m_params->contrast = CONTRAST_DEFAULT;
+ m_params->brightness = EV_DEFAULT;
+ m_params->exposure = EV_DEFAULT;
+ m_params->hue = -1;
+ m_params->aeawb_mode = -1;
+ }
+}
+
+int SecCamera::setMode(int recording_en)
+{
+ LOGV("%s :", __func__);
+ int mode;
+
+ m_recording_en = recording_en;
+
+ if (m_camera_use_ISP) {
+ if (!recording_en)
+ mode = IS_MODE_PREVIEW_STILL;
+ else
+ mode = IS_MODE_PREVIEW_VIDEO;
+
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_S_FORMAT_SCENARIO, mode) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_S_FORMAT_SCENARIO", __func__);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getCameraFd(enum CAM_MODE mode)
+{
+ int ret = -1;
+
+ switch (mode) {
+ case PREVIEW:
+ ret = m_cam_fd;
+ break;
+ case PICTURE:
+ ret = m_cap_fd;
+ break;
+ default:
+ ret = m_cam_fd;
+ break;
+ }
+
+ return ret;
+}
+
+int SecCamera::startPreview(void)
+{
+ v4l2_streamparm streamparm;
+ struct sec_cam_parm *parms;
+ parms = (struct sec_cam_parm*)&streamparm.parm.raw_data;
+ LOGV("%s :", __func__);
+
+ // aleady started
+ if (m_flag_camera_start > 0) {
+ LOGE("ERR(%s):Preview was already started", __func__);
+ return 0;
+ }
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ memset(&m_events_c, 0, sizeof(m_events_c));
+ m_events_c.fd = m_cam_fd;
+ m_events_c.events = POLLIN | POLLERR;
+
+ /* enum_fmt, s_fmt sample */
+ int ret = fimc_v4l2_enum_fmt(m_cam_fd,m_preview_v4lformat);
+ CHECK(ret);
+
+ LOGV("m_camera_use_ISP(%d), %s", m_camera_use_ISP, (const char*)getCameraSensorName());
+
+ if (m_camera_use_ISP) {
+ if (!m_recording_en)
+ fimc_v4l2_s_fmt_is(m_cam_fd, m_videosnapshot_width, m_videosnapshot_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_PREVIEW_STILL);
+ else
+ fimc_v4l2_s_fmt_is(m_cam_fd, m_videosnapshot_width, m_videosnapshot_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_PREVIEW_VIDEO);
+ }
+
+ ret = fimc_v4l2_s_fmt(m_cam_fd, m_preview_width, m_preview_height, m_preview_v4lformat, V4L2_FIELD_ANY, PREVIEW_NUM_PLANE);
+ CHECK(ret);
+
+#ifndef BOARD_USE_V4L2_ION
+ if (!m_camera_use_ISP) {
+ fimc_v4l2_s_fmt_is(m_cam_fd, m_preview_width, m_preview_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_PREVIEW_STILL);
+ }
+#endif
+
+ if (m_camera_use_ISP) {
+ if (!m_recording_en)
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_S_SCENARIO_MODE, IS_MODE_PREVIEW_STILL);
+ else
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_S_SCENARIO_MODE, IS_MODE_PREVIEW_VIDEO);
+ }
+ CHECK(ret);
+
+#ifndef BOARD_USE_V4L2_ION
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CACHEABLE, 1);
+ CHECK(ret);
+#endif
+
+ ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE, MAX_BUFFERS);
+ CHECK(ret);
+
+#ifndef BOARD_USE_V4L2_ION
+ ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_preview, V4L2_BUF_TYPE, MAX_BUFFERS, PREVIEW_NUM_PLANE);
+ CHECK(ret);
+#endif
+
+ LOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d",
+ __func__, m_preview_width, m_preview_height, m_angle);
+
+ LOGV("m_camera_id : %d", m_camera_id);
+
+ /* start with all buffers in queue */
+ for (int i = 0; i < MAX_BUFFERS; i++) {
+ ret = fimc_v4l2_qbuf(m_cam_fd, m_preview_width, m_preview_height, m_buffers_preview, i, PREVIEW_NUM_PLANE, PREVIEW_MODE);
+ CHECK(ret);
+ }
+
+ ret = fimc_v4l2_streamon(m_cam_fd);
+ CHECK(ret);
+
+#ifdef USE_FACE_DETECTION
+ if (m_camera_use_ISP) {
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CMD_FD, IS_FD_COMMAND_START);
+ CHECK(ret);
+ }
+#endif
+
+#ifdef ZERO_SHUTTER_LAG
+ if (m_camera_use_ISP && !m_recording_en) {
+ stopSnapshot();
+ startSnapshot(NULL);
+ }
+#endif
+
+ m_flag_camera_start = 1;
+
+ LOGV("%s: got the first frame of the preview", __func__);
+
+ return 0;
+}
+
+int SecCamera::stopPreview(void)
+{
+ int ret;
+
+ LOGV("%s :", __func__);
+
+ if (m_flag_camera_start == 0) {
+ LOGW("%s: doing nothing because m_flag_camera_start is zero", __func__);
+ return 0;
+ }
+
+#ifdef ZERO_SHUTTER_LAG
+ if (m_camera_use_ISP && !m_recording_en)
+ stopSnapshot();
+#endif
+
+ if (m_params->flash_mode == FLASH_MODE_TORCH)
+ setFlashMode(FLASH_MODE_OFF);
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+#ifdef USE_FACE_DETECTION
+ if (m_camera_use_ISP) {
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CMD_FD, IS_FD_COMMAND_STOP);
+ CHECK(ret);
+ }
+#endif
+ /* TODO : This code is temporary implementation. */
+ /* Because streamoff is failed when ae lock or awb lock state */
+ if (m_camera_use_ISP && m_params->aeawb_mode) {
+ if (m_params->aeawb_mode & 0x1) {
+ if (setAutoExposureLock(0) < 0) {
+ LOGE("ERR(%s): Fail on setAutoExposureLock()");
+ return -1;
+ }
+ }
+ if (m_params->aeawb_mode & (0x1 << 1)) {
+ if (setAutoWhiteBalanceLock(0) < 0) {
+ LOGE("ERR(%s): Fail on setAutoWhiteBalnaceLock()");
+ return -1;
+ }
+ }
+ m_params->aeawb_mode = 0;
+ }
+
+ ret = fimc_v4l2_streamoff(m_cam_fd);
+ CHECK(ret);
+
+ close_buffers(m_buffers_preview, MAX_BUFFERS);
+
+ fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE, 0);
+
+ m_flag_camera_start = 0;
+
+ return ret;
+}
+
+int SecCamera::startSnapshot(SecBuffer *yuv_buf)
+{
+ LOGV("%s :", __func__);
+
+ // already started
+ if (m_snapshot_state) {
+ LOGI("%s: Doing nothing because snapshot is already started!", __func__);
+ return 0;
+ }
+
+ if (m_cap_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ m_snapshot_state = 1;
+
+ memset(&m_events_c2, 0, sizeof(m_events_c2));
+ m_events_c2.fd = m_cap_fd;
+ m_events_c2.events = POLLIN | POLLERR;
+
+#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
+ if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
+ LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV420");
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
+ LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12");
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
+ LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12T");
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
+ LOGV("SnapshotFormat:V4L2_PIX_FMT_NV21");
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
+ LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV422P");
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
+ LOGV("SnapshotFormat:V4L2_PIX_FMT_YUYV");
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
+ LOGV("SnapshotFormat:V4L2_PIX_FMT_UYVY");
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
+ LOGV("SnapshotFormat:V4L2_PIX_FMT_RGB565");
+ else
+ LOGV("SnapshotFormat:UnknownFormat");
+#endif
+
+ int ret = fimc_v4l2_enum_fmt(m_cap_fd, m_snapshot_v4lformat);
+ CHECK(ret);
+
+ if (m_camera_use_ISP) {
+ fimc_v4l2_s_fmt_is(m_cap_fd, m_videosnapshot_width, m_videosnapshot_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_PREVIEW_STILL);
+ }
+
+ if (!m_recording_en)
+ ret = fimc_v4l2_s_fmt_cap(m_cap_fd, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
+ else
+ ret = fimc_v4l2_s_fmt_cap(m_cap_fd, m_videosnapshot_width, m_videosnapshot_height, m_snapshot_v4lformat);
+ CHECK(ret);
+
+#ifndef BOARD_USE_V4L2_ION
+ if (!m_camera_use_ISP)
+ if (!m_recording_en)
+ fimc_v4l2_s_fmt_is(m_cap_fd, m_snapshot_width, m_snapshot_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_PREVIEW_STILL);
+ else
+ fimc_v4l2_s_fmt_is(m_cap_fd, m_videosnapshot_width, m_videosnapshot_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_PREVIEW_VIDEO);
+#endif
+
+#ifndef ZERO_SHUTTER_LAG
+ if (m_camera_use_ISP)
+ ret = fimc_v4l2_s_ctrl(m_cap_fd, V4L2_CID_IS_S_SCENARIO_MODE, IS_MODE_PREVIEW_STILL);
+ CHECK(ret);
+#endif
+
+#ifndef BOARD_USE_V4L2_ION
+ ret = fimc_v4l2_s_ctrl(m_cap_fd, V4L2_CID_CACHEABLE, 1);
+ CHECK(ret);
+#endif
+
+ ret = fimc_v4l2_reqbufs(m_cap_fd, V4L2_BUF_TYPE, m_num_capbuf);
+ CHECK(ret);
+
+#ifdef BOARD_USE_V4L2_ION
+#ifndef ZERO_SHUTTER_LAG
+ m_capture_buf[0].virt.p = (char *)yuv_buf->virt.p;
+#endif
+#else
+ ret = fimc_v4l2_querybuf(m_cap_fd, m_capture_buf, V4L2_BUF_TYPE, m_num_capbuf, 1);
+ CHECK(ret);
+#endif
+
+ /* start with all buffers in queue */
+ for (int i = 0; i < m_num_capbuf; i++) {
+ ret = fimc_v4l2_qbuf(m_cap_fd, m_snapshot_width, m_snapshot_height, m_capture_buf, i, 1, CAPTURE_MODE);
+ CHECK(ret);
+ }
+
+ ret = fimc_v4l2_streamon(m_cap_fd);
+ CHECK(ret);
+
+ return 0;
+}
+
+int SecCamera::stopSnapshot(void)
+{
+ int ret;
+
+ LOGV("%s :", __func__);
+
+ if (!m_snapshot_state) {
+ LOGI("%s: Doing nothing because snapshot is not started!", __func__);
+ return 0;
+ }
+
+ if (m_cap_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ ret = fimc_v4l2_streamoff(m_cap_fd);
+ CHECK(ret);
+
+ endSnapshot();
+
+ m_snapshot_state = 0;
+
+ return ret;
+}
+
+//Recording
+int SecCamera::startRecord(bool recordHint)
+{
+ int ret, i;
+
+ LOGV("%s :", __func__);
+
+ // aleady started
+ if (m_flag_record_start > 0) {
+ LOGE("ERR(%s):Preview was already started", __func__);
+ return 0;
+ }
+
+ if (m_rec_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ /* enum_fmt, s_fmt sample */
+ ret = fimc_v4l2_enum_fmt(m_rec_fd, RECORD_PIX_FMT);
+ CHECK(ret);
+
+ LOGI("%s: m_recording_width = %d, m_recording_height = %d",
+ __func__, m_recording_width, m_recording_height);
+
+ LOGV("m_camera_use_ISP(%d), %s", m_camera_use_ISP, (const char*)getCameraSensorName());
+
+ if (m_camera_use_ISP) {
+ fimc_v4l2_s_fmt_is(m_rec_fd, m_videosnapshot_width, m_videosnapshot_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_CAPTURE_VIDEO);
+
+ ret = fimc_v4l2_s_fmt(m_rec_fd, m_recording_width,
+ m_recording_height, RECORD_PIX_FMT, V4L2_FIELD_ANY, RECORD_NUM_PLANE);
+ CHECK(ret);
+ } else {
+ ret = fimc_v4l2_s_fmt(m_rec_fd, m_preview_width,
+ m_preview_height, RECORD_PIX_FMT, V4L2_FIELD_ANY, RECORD_NUM_PLANE);
+ CHECK(ret);
+#ifndef BOARD_USE_V4L2_ION
+ fimc_v4l2_s_fmt_is(m_rec_fd, m_preview_width, m_preview_height,
+ m_preview_v4lformat, (enum v4l2_field) IS_MODE_CAPTURE_VIDEO);
+#endif
+ }
+
+ if (!m_camera_use_ISP) {
+ ret = fimc_v4l2_s_ctrl(m_rec_fd, V4L2_CID_CAMERA_BUSFREQ_LOCK, 267160);
+ CHECK(ret);
+ }
+
+ ret = fimc_v4l2_reqbufs(m_rec_fd, V4L2_BUF_TYPE, MAX_BUFFERS);
+ CHECK(ret);
+
+#ifndef BOARD_USE_V4L2_ION
+ ret = fimc_v4l2_querybuf(m_rec_fd, m_buffers_record, V4L2_BUF_TYPE, MAX_BUFFERS, RECORD_NUM_PLANE);
+ CHECK(ret);
+#endif
+
+ /* start with all buffers in queue */
+ for (i = 0; i < MAX_BUFFERS; i++) {
+ ret = fimc_v4l2_qbuf(m_rec_fd, m_recording_width, m_recording_height, m_buffers_record, i, RECORD_NUM_PLANE, RECORD_MODE);
+ CHECK(ret);
+ }
+
+ // Get and throw away the first frame since it is often garbled.
+ memset(&m_events_c3, 0, sizeof(m_events_c3));
+ m_events_c3.fd = m_rec_fd;
+ m_events_c3.events = POLLIN | POLLERR;
+
+ m_record_hint = recordHint;
+#ifdef VIDEO_SNAPSHOT
+ if (m_camera_use_ISP && m_record_hint) {
+ stopSnapshot();
+ startSnapshot(NULL);
+ }
+#endif
+
+ ret = fimc_v4l2_streamon(m_rec_fd);
+ CHECK(ret);
+
+ m_flag_record_start = 1;
+
+ return 0;
+}
+
+int SecCamera::stopRecord(void)
+{
+ int ret;
+
+ LOGV("%s :", __func__);
+
+ if (m_flag_record_start == 0) {
+ LOGW("%s: doing nothing because m_flag_record_start is zero", __func__);
+ return 0;
+ }
+
+#ifdef VIDEO_SNAPSHOT
+ if (m_camera_use_ISP && m_record_hint)
+ stopSnapshot();
+#endif
+
+ if (m_rec_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ m_flag_record_start = 0;
+
+ if (!m_camera_use_ISP) {
+ ret = fimc_v4l2_s_ctrl(m_rec_fd, V4L2_CID_CAMERA_BUSFREQ_UNLOCK, 0);
+ CHECK(ret);
+ }
+
+ ret = fimc_v4l2_streamoff(m_rec_fd);
+ CHECK(ret);
+
+ close_buffers(m_buffers_record, MAX_BUFFERS);
+
+ fimc_v4l2_reqbufs(m_rec_fd, V4L2_BUF_TYPE, 0);
+
+ return 0;
+}
+
+int SecCamera::getRecordAddr(int index, SecBuffer *buffer)
+{
+#ifdef BOARD_USE_V4L2
+ buffer->phys.extP[0] = (unsigned int)m_buffers_record[index].phys.extP[0];
+ buffer->phys.extP[1] = (unsigned int)(m_buffers_record[index].phys.extP[0] + (m_recording_width * m_recording_height));
+#else
+ buffer->phys.extP[0] = fimc_v4l2_s_ctrl(m_rec_fd, V4L2_CID_PADDR_Y, index);
+ CHECK((int)buffer->phys.extP[0]);
+ buffer->phys.extP[1] = fimc_v4l2_s_ctrl(m_rec_fd, V4L2_CID_PADDR_CBCR, index);
+ CHECK((int)buffer->phys.extP[1]);
+#endif
+ return 0;
+}
+
+int SecCamera::getPreviewAddr(int index, SecBuffer *buffer)
+{
+#ifdef BOARD_USE_V4L2
+ buffer->phys.extP[0] = (unsigned int)m_buffers_preview[index].phys.extP[0];
+ buffer->phys.extP[1] = (unsigned int)m_buffers_preview[index].phys.extP[1];
+ buffer->virt.extP[0] = m_buffers_preview[index].virt.extP[0];
+#else
+ buffer->phys.extP[0] = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_Y, index);
+ CHECK((int)buffer->phys.extP[0]);
+ buffer->phys.extP[1] = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_CBCR, index);
+ CHECK((int)buffer->phys.extP[1]);
+#endif
+ return 0;
+}
+
+int SecCamera::getCaptureAddr(int index, SecBuffer *buffer)
+{
+ buffer->virt.extP[0] = m_capture_buf[index].virt.extP[0];
+ CHECK((int)buffer->virt.extP[0]);
+ return 0;
+}
+
+#ifdef BOARD_USE_V4L2_ION
+void SecCamera::setUserBufferAddr(void *ptr, int index, int mode)
+{
+ if (mode == PREVIEW_MODE) {
+ m_buffers_preview[index].virt.extP[0] = (char *)((unsigned int *)ptr)[0];
+ m_buffers_preview[index].virt.extP[1] = (char *)((unsigned int *)ptr)[1];
+ m_buffers_preview[index].virt.extP[2] = (char *)((unsigned int *)ptr)[2];
+ } else if (mode == CAPTURE_MODE) {
+ m_capture_buf[index].virt.extP[0] = (char *)ptr;
+ } else if (mode == RECORD_MODE) {
+ m_buffers_record[index].virt.extP[0] = (char *)ptr;
+ m_buffers_record[index].virt.extP[1] = (char *)ptr + (ALIGN((ALIGN(m_recording_width, 16) * ALIGN(m_recording_height, 16)), 2048));
+ } else
+ LOGE("%s: Invalid fd!!!", __func__);
+}
+#endif
+
+int SecCamera::getPreview(camera_frame_metadata_t *facedata)
+{
+ int index;
+ int ret;
+
+ if (m_flag_camera_start == 0 || fimc_poll(&m_events_c) == 0) {
+ LOGE("ERR(%s):Start Camera Device Reset", __func__);
+ /*
+ * When there is no data for more than 1 second from the camera we inform
+ * the FIMC driver by calling fimc_v4l2_s_input() with a special value = 1000
+ * FIMC driver identify that there is something wrong with the camera
+ * and it restarts the sensor.
+ */
+ stopPreview();
+ /* Reset Only Camera Device */
+ ret = fimc_v4l2_querycap(m_cam_fd);
+ CHECK(ret);
+ if (fimc_v4l2_enuminput(m_cam_fd, m_camera_id))
+ return -1;
+ ret = fimc_v4l2_s_input(m_cam_fd, 1000);
+ CHECK(ret);
+#ifdef BOARD_USE_V4L2_ION
+ m_preview_state = 0;
+ return -1;
+#endif
+ ret = startPreview();
+ if (ret < 0) {
+ LOGE("ERR(%s): startPreview() return %d", __func__, ret);
+ return 0;
+ }
+ }
+
+ index = fimc_v4l2_dqbuf(m_cam_fd, PREVIEW_NUM_PLANE);
+ if (!(0 <= index && index < MAX_BUFFERS)) {
+ LOGE("ERR(%s):wrong index = %d", __func__, index);
+ return -1;
+ }
+
+#ifdef USE_FACE_DETECTION
+ if (m_camera_use_ISP) {
+ fimc_v4l2_s_ext_ctrl_face_detection(m_cam_fd, 0, facedata);
+ }
+#endif
+
+ return index;
+}
+
+int SecCamera::setPreviewFrame(int index)
+{
+ int ret;
+ ret = fimc_v4l2_qbuf(m_cam_fd, m_preview_width, m_preview_height, m_buffers_preview, index, PREVIEW_NUM_PLANE, PREVIEW_MODE);
+ CHECK(ret);
+
+ return ret;
+}
+
+int SecCamera::getSnapshot()
+{
+ int index;
+ int ret;
+
+ if (m_snapshot_state) {
+ fimc_poll(&m_events_c2);
+
+ index = fimc_v4l2_dqbuf(m_cap_fd, 1);
+ if (!(0 <= index && index < m_num_capbuf)) {
+ LOGE("ERR(%s):wrong index = %d", __func__, index);
+ return -1;
+ }
+ return index;
+ }
+
+ return -1;
+}
+
+int SecCamera::setSnapshotFrame(int index)
+{
+ int ret;
+ ret = fimc_v4l2_qbuf(m_cap_fd, m_snapshot_width, m_snapshot_height, m_capture_buf, index, PREVIEW_NUM_PLANE, CAPTURE_MODE);
+ CHECK(ret);
+
+ return ret;
+}
+
+int SecCamera::getRecordFrame()
+{
+ if (m_flag_record_start == 0) {
+ LOGE("%s: m_flag_record_start is 0", __func__);
+ return -1;
+ }
+
+ fimc_poll(&m_events_c3);
+ int index = fimc_v4l2_dqbuf(m_rec_fd, RECORD_NUM_PLANE);
+ if (!(0 <= index && index < MAX_BUFFERS)) {
+ LOGE("ERR(%s):wrong index = %d", __func__, index);
+ return -1;
+ }
+
+ return index;
+}
+
+int SecCamera::releaseRecordFrame(int index)
+{
+ if (!m_flag_record_start) {
+ /* this can happen when recording frames are returned after
+ * the recording is stopped at the driver level. we don't
+ * need to return the buffers in this case and we've seen
+ * cases where fimc could crash if we called qbuf and it
+ * wasn't expecting it.
+ */
+ LOGI("%s: recording not in progress, ignoring", __func__);
+ return 0;
+ }
+
+ return fimc_v4l2_qbuf(m_rec_fd, m_recording_width, m_recording_height, m_buffers_record, index, RECORD_NUM_PLANE, RECORD_MODE);
+}
+
+int SecCamera::setPreviewSize(int width, int height, int pixel_format)
+{
+ LOGV("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format);
+
+ int v4lpixelformat = pixel_format;
+
+#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
+ if (v4lpixelformat == V4L2_PIX_FMT_YUV420)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_YUV420");
+ else if (v4lpixelformat == V4L2_PIX_FMT_YVU420)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_YVU420");
+ else if (v4lpixelformat == V4L2_PIX_FMT_YVU420M)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_YVU420M");
+ else if (v4lpixelformat == V4L2_PIX_FMT_NV12)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_NV12");
+ else if (v4lpixelformat == V4L2_PIX_FMT_NV12T)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_NV12T");
+ else if (v4lpixelformat == V4L2_PIX_FMT_NV21)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_NV21");
+ else if (v4lpixelformat == V4L2_PIX_FMT_YUV422P)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_YUV422P");
+ else if (v4lpixelformat == V4L2_PIX_FMT_YUYV)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_YUYV");
+ else if (v4lpixelformat == V4L2_PIX_FMT_RGB565)
+ LOGV("PreviewFormat:V4L2_PIX_FMT_RGB565");
+ else
+ LOGV("PreviewFormat:UnknownFormat");
+#endif
+ m_preview_width = width;
+ m_preview_height = height;
+ m_preview_v4lformat = v4lpixelformat;
+
+ return 0;
+}
+
+int SecCamera::getPreviewSize(int *width, int *height, int *frame_size)
+{
+ *width = m_preview_width;
+ *height = m_preview_height;
+ *frame_size = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(m_preview_v4lformat), *width, *height);
+ return 0;
+}
+
+int SecCamera::getPreviewMaxSize(int *width, int *height)
+{
+ *width = m_preview_max_width;
+ *height = m_preview_max_height;
+
+ return 0;
+}
+
+int SecCamera::getPreviewPixelFormat(void)
+{
+ return m_preview_v4lformat;
+}
+
+/*
+ * Devide getJpeg() as two funcs, setSnapshotCmd() & getJpeg() because of the shutter sound timing.
+ * Here, just send the capture cmd to camera ISP to start JPEG capture.
+ */
+int SecCamera::setSnapshotCmd(void)
+{
+ LOGV("%s :", __func__);
+
+ int ret = 0;
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return 0;
+ }
+
+ if (m_flag_camera_start > 0) {
+ LOGW("WARN(%s):Camera was in preview, should have been stopped", __func__);
+ stopPreview();
+ }
+
+ memset(&m_events_c, 0, sizeof(m_events_c));
+ m_events_c.fd = m_cam_fd;
+ m_events_c.events = POLLIN | POLLERR;
+
+ int nframe = 1;
+
+ ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat);
+ CHECK(ret);
+ ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, V4L2_PIX_FMT_JPEG);
+ CHECK(ret);
+
+#ifndef BOARD_USE_V4L2_ION
+ if (!m_camera_use_ISP)
+ if (!m_recording_en)
+ fimc_v4l2_s_fmt_is(m_cap_fd, m_snapshot_width, m_snapshot_height,
+ V4L2_PIX_FMT_JPEG, (enum v4l2_field) IS_MODE_PREVIEW_STILL);
+ else
+ fimc_v4l2_s_fmt_is(m_cap_fd, m_videosnapshot_width, m_videosnapshot_height,
+ V4L2_PIX_FMT_JPEG, (enum v4l2_field) IS_MODE_PREVIEW_VIDEO);
+#endif
+
+ ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE, nframe);
+ CHECK(ret);
+
+#ifndef BOARD_USE_V4L2_ION
+ ret = fimc_v4l2_querybuf(m_cam_fd, m_capture_buf, V4L2_BUF_TYPE, 1, 1);
+ CHECK(ret);
+#endif
+
+ ret = fimc_v4l2_qbuf(m_cam_fd, m_snapshot_width, m_snapshot_height, m_capture_buf, 0, 1, CAPTURE_MODE);
+ CHECK(ret);
+
+ ret = fimc_v4l2_streamon(m_cam_fd);
+ CHECK(ret);
+
+ return 0;
+}
+
+int SecCamera::endSnapshot(void)
+{
+ close_buffers(m_capture_buf, m_num_capbuf);
+
+ fimc_v4l2_reqbufs(m_cap_fd, V4L2_BUF_TYPE, 0);
+
+ return 0;
+}
+
+/*
+ * Set Jpeg quality & exif info and get JPEG data from camera ISP
+ */
+unsigned char* SecCamera::getJpeg(int *jpeg_size,
+ int *thumb_size,
+ unsigned int *thumb_addr,
+ unsigned int *phyaddr)
+{
+ int index, ret = 0;
+ unsigned char *addr;
+ SecBuffer jpegAddr;
+
+ // capture
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CAPTURE, 0);
+ CHECK_PTR(ret);
+ ret = fimc_poll(&m_events_c);
+ CHECK_PTR(ret);
+ index = fimc_v4l2_dqbuf(m_cam_fd, 1);
+
+ if (index != 0) {
+ LOGE("ERR(%s):wrong index = %d", __func__, index);
+ return NULL;
+ }
+
+ *jpeg_size = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_SIZE);
+ CHECK_PTR(*jpeg_size);
+
+ int main_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_OFFSET);
+ CHECK_PTR(main_offset);
+
+ *thumb_size = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_THUMB_SIZE);
+ CHECK_PTR(*thumb_size);
+
+ int thumb_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_THUMB_OFFSET);
+ CHECK_PTR(thumb_offset);
+
+ m_postview_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET);
+ CHECK_PTR(m_postview_offset);
+
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
+ CHECK_PTR(ret);
+
+ LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d",
+ index, m_snapshot_width, m_snapshot_height, *jpeg_size);
+
+ addr = (unsigned char*)(m_capture_buf[0].virt.extP[0]) + main_offset;
+
+ *thumb_addr = (unsigned int)(addr + thumb_offset);
+
+ getPreviewAddr(index, &jpegAddr);
+ *phyaddr = jpegAddr.phys.extP[0] + m_postview_offset;
+
+ ret = fimc_v4l2_streamoff(m_cam_fd);
+ CHECK_PTR(ret);
+
+ return addr;
+}
+
+int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc, int thumbSize)
+{
+#ifdef SAMSUNG_EXYNOS4210
+ /* JPEG encode for smdkv310 */
+ if (m_jpeg_fd > 0) {
+ if (api_jpeg_encode_deinit(m_jpeg_fd) != JPEG_OK)
+ LOGE("ERR(%s):Fail on api_jpeg_encode_deinit", __func__);
+ m_jpeg_fd = 0;
+ }
+
+ m_jpeg_fd = api_jpeg_encode_init();
+ LOGV("(%s):JPEG device open ID = %d", __func__, m_jpeg_fd);
+
+ if (m_jpeg_fd <= 0) {
+ if (m_jpeg_fd < 0) {
+ m_jpeg_fd = 0;
+ LOGE("ERR(%s):Cannot open a jpeg device file", __func__);
+ return -1;
+ }
+ LOGE("ERR(%s):JPEG device was closed", __func__);
+ return -1;
+ }
+
+ if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) {
+ LOGE("ERR(%s):It doesn't support V4L2_PIX_FMT_RGB565", __func__);
+ return -1;
+ }
+
+ struct jpeg_enc_param enc_param;
+ enum jpeg_frame_format inFormat = YUV_422;
+ enum jpeg_stream_format outFormat = JPEG_422;
+
+ switch (m_snapshot_v4lformat) {
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_NV12T:
+ case V4L2_PIX_FMT_YUV420:
+ inFormat = YUV_420;
+ outFormat = JPEG_420;
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ case V4L2_PIX_FMT_UYVY:
+ case V4L2_PIX_FMT_YUV422P:
+ default:
+ inFormat = YUV_422;
+ outFormat = JPEG_422;
+ break;
+ }
+
+ // set encode parameters //
+ enc_param.width = m_jpeg_thumbnail_width;
+ enc_param.height = m_jpeg_thumbnail_width;
+ enc_param.in_fmt = inFormat; // YCBCR Only
+ enc_param.out_fmt = outFormat;
+
+ if (m_jpeg_thumbnail_quality >= 90)
+ enc_param.quality = QUALITY_LEVEL_1;
+ else if (m_jpeg_thumbnail_quality >= 80)
+ enc_param.quality = QUALITY_LEVEL_2;
+ else if (m_jpeg_thumbnail_quality >= 70)
+ enc_param.quality = QUALITY_LEVEL_3;
+ else
+ enc_param.quality = QUALITY_LEVEL_4;
+
+ api_jpeg_set_encode_param(&enc_param);
+
+ unsigned int thumbnail_size = m_jpeg_thumbnail_width * m_jpeg_thumbnail_height * 2;
+ unsigned char *pInBuf = (unsigned char *)api_jpeg_get_encode_in_buf(m_jpeg_fd, thumbnail_size);
+ if (pInBuf == NULL) {
+ LOGE("ERR(%s):JPEG input buffer is NULL!!", __func__);
+ return -1;
+ }
+
+ unsigned char *pOutBuf = (unsigned char *)api_jpeg_get_encode_out_buf(m_jpeg_fd);
+ if (pOutBuf == NULL) {
+ LOGE("ERR(%s):JPEG output buffer is NULL!!", __func__);
+ return -1;
+ }
+
+ memcpy(pInBuf, pThumbSrc, thumbnail_size);
+
+ enum jpeg_ret_type result = api_jpeg_encode_exe(m_jpeg_fd, &enc_param);
+ if (result != JPEG_ENCODE_OK) {
+ LOGE("ERR(%s):encode failed", __func__);
+ return -1;
+ }
+
+ unsigned int outbuf_size = enc_param.size;
+ unsigned int exifSize;
+
+ setExifChangedAttribute();
+
+ LOGV("%s: calling jpgEnc.makeExif, mExifInfo.width set to %d, height to %d",
+ __func__, mExifInfo.width, mExifInfo.height);
+
+ LOGV("%s : enableThumb set to true", __func__);
+ mExifInfo.enableThumb = true;
+
+ makeExif(pExifDst, pOutBuf, outbuf_size, &mExifInfo, &exifSize, true);
+#endif
+
+#ifdef SAMSUNG_EXYNOS4x12
+ /* JPEG encode for smdk4x12 */
+ unsigned int exifSize;
+
+ if (m_camera_use_ISP) {
+ LOGV("%s : m_jpeg_thumbnail_width = %d, height = %d",
+ __func__, m_jpeg_thumbnail_width, m_jpeg_thumbnail_height);
+ m_jpeg_fd = jpeghal_enc_init();
+ LOGV("(%s):JPEG device open ID = %d", __func__, m_jpeg_fd);
+
+ if (m_jpeg_fd <= 0) {
+ if (m_jpeg_fd < 0) {
+ m_jpeg_fd = 0;
+ LOGE("ERR(%s):Cannot open a jpeg device file", __func__);
+ return -1;
+ }
+ LOGE("ERR(%s):JPEG device was closed", __func__);
+ return -1;
+ }
+
+ if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) {
+ LOGE("ERR(%s):It doesn't support V4L2_PIX_FMT_RGB565", __func__);
+ return -1;
+ }
+
+ struct jpeg_config enc_config;
+ int outFormat;
+
+ switch (m_snapshot_v4lformat) {
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_NV12T:
+ case V4L2_PIX_FMT_YUV420:
+ outFormat = V4L2_PIX_FMT_JPEG_420;
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ case V4L2_PIX_FMT_UYVY:
+ case V4L2_PIX_FMT_YUV422P:
+ default:
+ outFormat = V4L2_PIX_FMT_JPEG_422;
+ break;
+ }
+
+ // set encode parameters //
+ enc_config.mode = JPEG_ENCODE;
+
+ if (m_jpeg_thumbnail_quality >= 90)
+ enc_config.enc_qual = QUALITY_LEVEL_1;
+ else if (m_jpeg_thumbnail_quality >= 80)
+ enc_config.enc_qual = QUALITY_LEVEL_2;
+ else if (m_jpeg_thumbnail_quality >= 70)
+ enc_config.enc_qual = QUALITY_LEVEL_3;
+ else
+ enc_config.enc_qual = QUALITY_LEVEL_4;
+
+ enc_config.width = m_jpeg_thumbnail_width;
+ enc_config.height = m_jpeg_thumbnail_height;
+ enc_config.pix.enc_fmt.in_fmt = m_snapshot_v4lformat;
+ enc_config.pix.enc_fmt.out_fmt = outFormat;
+
+ jpeghal_enc_setconfig(m_jpeg_fd, &enc_config);
+
+ jpeghal_s_ctrl(m_jpeg_fd, V4L2_CID_CACHEABLE, 1);
+
+ struct jpeg_buf m_jpeg_inbuf;
+ m_jpeg_inbuf.memory = V4L2_MEMORY_MMAP;
+ m_jpeg_inbuf.num_planes = 1;
+
+ if (jpeghal_set_inbuf(m_jpeg_fd, &m_jpeg_inbuf) < 0) {
+ LOGE("ERR(%s):Fail to JPEG input buffer!!", __func__);
+ return -1;
+ }
+
+ struct jpeg_buf m_jpeg_outbuf;
+ m_jpeg_outbuf.memory = V4L2_MEMORY_MMAP;
+ m_jpeg_outbuf.num_planes = 1;
+
+ if (jpeghal_set_outbuf(m_jpeg_fd, &m_jpeg_outbuf) < 0) {
+ LOGE("ERR(%s):Fail to JPEG output buffer!!", __func__);
+ return -1;
+ }
+
+ memcpy(m_jpeg_inbuf.start[0], pThumbSrc, m_jpeg_inbuf.length[0]);
+
+ if (jpeghal_enc_exe(m_jpeg_fd, &m_jpeg_inbuf, &m_jpeg_outbuf) < 0) {
+ LOGE("ERR(%s):encode failed", __func__);
+ return -1;
+ }
+
+ int outbuf_size = jpeghal_g_ctrl(m_jpeg_fd, V4L2_CID_CAM_JPEG_ENCODEDSIZE);
+ if (outbuf_size < 0) {
+ LOGE("ERR(%s): jpeghal_g_ctrl fail on V4L2_CID_CAM_JPEG_ENCODEDSIZE", __func__);
+ return -1;
+ }
+
+ setExifChangedAttribute();
+
+ LOGV("%s: calling jpgEnc.makeExif, mExifInfo.width set to %d, height to %d",
+ __func__, mExifInfo.width, mExifInfo.height);
+
+ LOGV("%s : enableThumb set to true", __func__);
+ mExifInfo.enableThumb = true;
+
+ makeExif(pExifDst, (unsigned char *)m_jpeg_outbuf.start[0], (unsigned int)outbuf_size, &mExifInfo, &exifSize, true);
+
+ if (m_jpeg_fd > 0) {
+ if (jpeghal_deinit(m_jpeg_fd, &m_jpeg_inbuf, &m_jpeg_outbuf) < 0)
+ LOGE("ERR(%s):Fail on api_jpeg_encode_deinit", __func__);
+ m_jpeg_fd = 0;
+ }
+ } else {
+ setExifChangedAttribute();
+ mExifInfo.enableThumb = true;
+ makeExif(pExifDst, pThumbSrc, (unsigned int)thumbSize, &mExifInfo, &exifSize, true);
+ }
+#endif
+
+ return exifSize;
+}
+
+void SecCamera::getPostViewConfig(int *width, int *height, int *size)
+{
+ *width = m_snapshot_width;
+ *height = m_snapshot_height;
+ *size = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(m_snapshot_v4lformat), *width, *height);
+ LOGV("[5B] m_preview_width : %d, mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
+ m_preview_width, *width, *height, *size);
+}
+
+void SecCamera::getThumbnailConfig(int *width, int *height, int *size)
+{
+ *width = m_jpeg_thumbnail_width;
+ *height = m_jpeg_thumbnail_height;
+ *size = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(m_snapshot_v4lformat), *width, *height);
+}
+
+int SecCamera::getPostViewOffset(void)
+{
+ return m_postview_offset;
+}
+
+int SecCamera::getSnapshotAndJpeg(SecBuffer *yuv_buf, int index, unsigned char *jpeg_buf,
+ int *output_size)
+{
+ LOGV("%s :", __func__);
+
+ int ret = 0;
+ int i;
+
+#ifdef ZERO_SHUTTER_LAG
+ if (!m_camera_use_ISP){
+ startSnapshot(yuv_buf);
+
+ index = getSnapshot();
+ if (index < 0) {
+ LOGE("ERR(%s): Invalid index!", __func__);
+ return -1;
+ }
+
+#ifndef BOARD_USE_V4L2_ION
+ ret = fimc_v4l2_s_ctrl(m_cap_fd, V4L2_CID_STREAM_PAUSE, 0);
+ CHECK_PTR(ret);
+ LOGV("snapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d",
+ index, m_snapshot_width, m_snapshot_height);
+
+ getCaptureAddr(index, yuv_buf);
+#endif
+
+ if (yuv_buf->virt.extP[0] == NULL) {
+ LOGE("ERR(%s):Fail on SecCamera getCaptureAddr = %0x ",
+ __func__, yuv_buf->virt.extP[0]);
+ return UNKNOWN_ERROR;
+ }
+ }
+#else
+ startSnapshot(yuv_buf);
+
+ index = getSnapshot();
+ if (index < 0) {
+ LOGE("ERR(%s): Invalid index!", __func__);
+ return -1;
+ }
+
+#ifndef BOARD_USE_V4L2_ION
+ ret = fimc_v4l2_s_ctrl(m_cap_fd, V4L2_CID_STREAM_PAUSE, 0);
+ CHECK_PTR(ret);
+ LOGV("snapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d",
+ index, m_snapshot_width, m_snapshot_height);
+
+ getCaptureAddr(index, yuv_buf);
+#endif
+
+ if (yuv_buf->virt.extP[0] == NULL) {
+ LOGE("ERR(%s):Fail on SecCamera getCaptureAddr = %0x ",
+ __func__, yuv_buf->virt.extP[0]);
+ return UNKNOWN_ERROR;
+ }
+#endif
+
+#ifdef SAMSUNG_EXYNOS4210
+ /* JPEG encode for smdkv310 */
+ if (m_jpeg_fd > 0) {
+ if (api_jpeg_encode_deinit(m_jpeg_fd) != JPEG_OK)
+ LOGE("ERR(%s):Fail on api_jpeg_encode_deinit", __func__);
+ m_jpeg_fd = 0;
+ }
+
+ m_jpeg_fd = api_jpeg_encode_init();
+ LOGV("(%s):JPEG device open ID = %d", __func__, m_jpeg_fd);
+
+ if (m_jpeg_fd <= 0) {
+ if (m_jpeg_fd < 0) {
+ m_jpeg_fd = 0;
+ LOGE("ERR(%s):Cannot open a jpeg device file", __func__);
+ return -1;
+ }
+ LOGE("ERR(%s):JPEG device was closed", __func__);
+ return -1;
+ }
+
+ if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) {
+ LOGE("ERR(%s):It doesn't support V4L2_PIX_FMT_RGB565", __func__);
+ return -1;
+ }
+
+ struct jpeg_enc_param enc_param;
+ enum jpeg_frame_format inFormat = YUV_422;
+ enum jpeg_stream_format outFormat = JPEG_422;
+
+ switch (m_snapshot_v4lformat) {
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_NV12T:
+ case V4L2_PIX_FMT_YUV420:
+ inFormat = YUV_420;
+ outFormat = JPEG_420;
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ case V4L2_PIX_FMT_UYVY:
+ case V4L2_PIX_FMT_YUV422P:
+ default:
+ inFormat = YUV_422;
+ outFormat = JPEG_422;
+ break;
+ }
+
+ // set encode parameters //
+ enc_param.width = m_snapshot_width;
+ enc_param.height = m_snapshot_height;
+ enc_param.in_fmt = inFormat; // YCBCR Only
+ enc_param.out_fmt = outFormat;
+
+ if (m_jpeg_quality >= 90)
+ enc_param.quality = QUALITY_LEVEL_1;
+ else if (m_jpeg_quality >= 80)
+ enc_param.quality = QUALITY_LEVEL_2;
+ else if (m_jpeg_quality >= 70)
+ enc_param.quality = QUALITY_LEVEL_3;
+ else
+ enc_param.quality = QUALITY_LEVEL_4;
+
+ api_jpeg_set_encode_param(&enc_param);
+
+ unsigned int snapshot_size = m_snapshot_width * m_snapshot_height * 2;
+ unsigned char *pInBuf = (unsigned char *)api_jpeg_get_encode_in_buf(m_jpeg_fd, snapshot_size);
+ if (pInBuf == NULL) {
+ LOGE("ERR(%s):JPEG input buffer is NULL!!", __func__);
+ return -1;
+ }
+
+ unsigned char *pOutBuf = (unsigned char *)api_jpeg_get_encode_out_buf(m_jpeg_fd);
+ if (pOutBuf == NULL) {
+ LOGE("ERR(%s):JPEG output buffer is NULL!!", __func__);
+ return -1;
+ }
+
+ memcpy(pInBuf, yuv_buf->virt.extP[0], snapshot_size);
+
+ enum jpeg_ret_type result = api_jpeg_encode_exe(m_jpeg_fd, &enc_param);
+ if (result != JPEG_ENCODE_OK) {
+ LOGE("ERR(%s):encode failed", __func__);
+ return -1;
+ }
+
+ *output_size = enc_param.size;
+ memcpy(jpeg_buf, pOutBuf, *output_size);
+#endif
+
+#ifdef SAMSUNG_EXYNOS4x12
+ /* JPEG encode for smdk4x12 */
+ m_jpeg_fd = jpeghal_enc_init();
+ LOGV("(%s):JPEG device open ID = %d", __func__, m_jpeg_fd);
+
+ if (m_jpeg_fd <= 0) {
+ if (m_jpeg_fd < 0) {
+ m_jpeg_fd = 0;
+ LOGE("ERR(%s):Cannot open a jpeg device file", __func__);
+ return -1;
+ }
+ LOGE("ERR(%s):JPEG device was closed", __func__);
+ return -1;
+ }
+
+ if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) {
+ LOGE("ERR(%s):It doesn't support V4L2_PIX_FMT_RGB565", __func__);
+ return -1;
+ }
+
+ struct jpeg_config enc_config;
+ int outFormat;
+
+ switch (m_snapshot_v4lformat) {
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_NV12T:
+ case V4L2_PIX_FMT_YUV420:
+ outFormat = V4L2_PIX_FMT_JPEG_420;
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ case V4L2_PIX_FMT_UYVY:
+ case V4L2_PIX_FMT_YUV422P:
+ default:
+ outFormat = V4L2_PIX_FMT_JPEG_422;
+ break;
+ }
+
+ // set encode parameters //
+ enc_config.mode = JPEG_ENCODE;
+
+ if (m_jpeg_quality >= 90)
+ enc_config.enc_qual = QUALITY_LEVEL_1;
+ else if (m_jpeg_quality >= 80)
+ enc_config.enc_qual = QUALITY_LEVEL_2;
+ else if (m_jpeg_quality >= 70)
+ enc_config.enc_qual = QUALITY_LEVEL_3;
+ else
+ enc_config.enc_qual = QUALITY_LEVEL_4;
+
+ if (!m_recording_en) {
+ enc_config.width = m_snapshot_width;
+ enc_config.height = m_snapshot_height;
+ } else {
+ enc_config.width = m_videosnapshot_width;
+ enc_config.height = m_videosnapshot_height;
+ }
+ enc_config.pix.enc_fmt.in_fmt = m_snapshot_v4lformat;
+ enc_config.pix.enc_fmt.out_fmt = outFormat;
+
+ jpeghal_enc_setconfig(m_jpeg_fd, &enc_config);
+
+ ret = jpeghal_s_ctrl(m_jpeg_fd, V4L2_CID_CACHEABLE, 3);
+ CHECK(ret);
+
+ struct jpeg_buf m_jpeg_inbuf;
+#ifdef BOARD_USE_V4L2_ION
+ m_jpeg_inbuf.memory = V4L2_MEMORY_MMAP;
+ m_jpeg_inbuf.num_planes = 1;
+#else
+ m_jpeg_inbuf.start[0] = (void *)fimc_v4l2_s_ctrl(m_cap_fd, V4L2_CID_PADDR_Y, index);
+ m_jpeg_inbuf.length[0] = m_capture_buf[index].size.extS[0];
+ m_jpeg_inbuf.memory = V4L2_MEMORY_USERPTR;
+ m_jpeg_inbuf.num_planes = 1;
+#endif
+
+ if (jpeghal_set_inbuf(m_jpeg_fd, &m_jpeg_inbuf) < 0) {
+ LOGE("ERR(%s):Fail to JPEG input buffer!!", __func__);
+ return -1;
+ }
+
+ for (i = 0; i < m_jpeg_inbuf.num_planes; i++) {
+ if ((unsigned int)m_jpeg_inbuf.start[i] & (SIZE_4K - 1)) {
+ LOGE("ERR(%s): JPEG start address should be aligned to 4 Kbytes", __func__);
+ return -1;
+ } else if ((unsigned int)enc_config.width & (16 - 1)) {
+ LOGE("ERR(%s): Image width should be multiple of 16", __func__);
+ return -1;
+ }
+ }
+
+ struct jpeg_buf m_jpeg_outbuf;
+ m_jpeg_outbuf.memory = V4L2_MEMORY_MMAP;
+ m_jpeg_outbuf.num_planes = 1;
+
+ if (jpeghal_set_outbuf(m_jpeg_fd, &m_jpeg_outbuf) < 0) {
+ LOGE("ERR(%s):Fail to JPEG output buffer!!", __func__);
+ return -1;
+ }
+
+#ifdef BOARD_USE_V4L2_ION
+ memcpy(m_jpeg_inbuf.start[0], yuv_buf->virt.extP[0], m_jpeg_inbuf.length[0]);
+#endif
+
+ if (jpeghal_enc_exe(m_jpeg_fd, &m_jpeg_inbuf, &m_jpeg_outbuf) < 0) {
+ LOGE("ERR(%s):encode failed", __func__);
+ return -1;
+ }
+
+ ret = jpeghal_g_ctrl(m_jpeg_fd, V4L2_CID_CAM_JPEG_ENCODEDSIZE);
+ if (ret < 0) {
+ LOGE("ERR(%s): jpeghal_g_ctrl fail on V4L2_CID_CAM_JPEG_ENCODEDSIZE", __func__);
+ return -1;
+ } else {
+ *output_size = (unsigned int)ret;
+ }
+
+ memcpy(jpeg_buf, m_jpeg_outbuf.start[0], *output_size);
+
+ if (m_jpeg_fd > 0) {
+ if (jpeghal_deinit(m_jpeg_fd, &m_jpeg_inbuf, &m_jpeg_outbuf) < 0)
+ LOGE("ERR(%s):Fail on api_jpeg_encode_deinit", __func__);
+ m_jpeg_fd = 0;
+ }
+#endif
+
+ return 0;
+}
+
+int SecCamera::setVideosnapshotSize(int width, int height)
+{
+ LOGV("%s(width(%d), height(%d))", __func__, width, height);
+
+ m_videosnapshot_width = width;
+ m_videosnapshot_height = height;
+
+ return 0;
+}
+
+int SecCamera::getVideosnapshotSize(int *width, int *height, int *frame_size)
+{
+ *width = m_videosnapshot_width;
+ *height = m_videosnapshot_height;
+
+ int frame = 0;
+
+ frame = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(m_snapshot_v4lformat), *width, *height);
+
+ // set it big.
+ if (frame == 0)
+ frame = m_videosnapshot_width * m_videosnapshot_height * BPP;
+
+ *frame_size = frame;
+
+ return 0;
+}
+
+int SecCamera::setSnapshotSize(int width, int height)
+{
+ LOGV("%s(width(%d), height(%d))", __func__, width, height);
+
+ m_snapshot_width = width;
+ m_snapshot_height = height;
+
+ return 0;
+}
+
+int SecCamera::getSnapshotSize(int *width, int *height, int *frame_size)
+{
+ *width = m_snapshot_width;
+ *height = m_snapshot_height;
+
+ int frame = 0;
+
+ frame = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(m_snapshot_v4lformat), *width, *height);
+
+ // set it big.
+ if (frame == 0)
+ frame = m_snapshot_width * m_snapshot_height * BPP;
+
+ *frame_size = frame;
+
+ return 0;
+}
+
+int SecCamera::getSnapshotMaxSize(int *width, int *height)
+{
+ *width = m_snapshot_max_width;
+ *height = m_snapshot_max_height;
+
+ return 0;
+}
+
+int SecCamera::setSnapshotPixelFormat(int pixel_format)
+{
+ int v4lpixelformat = pixel_format;
+
+ if (m_snapshot_v4lformat != v4lpixelformat) {
+ m_snapshot_v4lformat = v4lpixelformat;
+ }
+
+#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
+ if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
+ LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV420", __func__);
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__);
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__);
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__);
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__);
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__);
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__);
+ else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__);
+ else
+ LOGD("SnapshotFormat:UnknownFormat");
+#endif
+ return 0;
+}
+
+int SecCamera::getSnapshotPixelFormat(void)
+{
+ return m_snapshot_v4lformat;
+}
+
+int SecCamera::getCameraId(void)
+{
+ return m_camera_id;
+}
+
+int SecCamera::initSetParams(void)
+{
+ LOGV("%s :", __func__);
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, ISO_AUTO) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ISO", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, METERING_CENTER) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_METERING", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, SATURATION_DEFAULT) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, SCENE_MODE_NONE) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, SHARPNESS_DEFAULT) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, WHITE_BALANCE_AUTO) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WHITE_BALANCE", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_BANDING, ANTI_BANDING_OFF) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_BANDING", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_CONTRAST, IS_CONTRAST_DEFAULT) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_CONTRAST", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, IMAGE_EFFECT_NONE) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_EFFECT", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_BRIGHTNESS, IS_BRIGHTNESS_DEFAULT) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_BRIGHTNESS", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_EXPOSURE, IS_EXPOSURE_DEFAULT) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_EXPOSURE", __func__);
+ return -1;
+ }
+/* TODO */
+/* This code is temporary implementation because *
+ * hue value tuning was not complete */
+#ifdef USE_HUE
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_HUE, IS_HUE_DEFAULT) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_HUE", __func__);
+ return -1;
+ }
+#endif
+
+ initParameters(m_camera_use_ISP);
+
+ return 0;
+}
+
+int SecCamera::setAutofocus(void)
+{
+ LOGV("%s :", __func__);
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
+ return -1;
+ }
+
+ m_auto_focus_state = 1;
+
+ return 0;
+}
+
+int SecCamera::setTouchAF(void)
+{
+ LOGV("%s :", __func__);
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_TOUCH) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int SecCamera::getAutoFocusResult(void)
+{
+ int af_result;
+
+ af_result = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT);
+
+ LOGV("%s : returning %d", __func__, af_result);
+
+ return af_result;
+}
+
+int SecCamera::cancelAutofocus(void)
+{
+ LOGV("%s :", __func__);
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+#ifndef BOARD_USE_V4L2
+ if (m_flag_camera_start && m_auto_focus_state) {
+ if (m_params->focus_mode == FOCUS_MODE_AUTO || m_params->focus_mode == FOCUS_MODE_MACRO) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
+ return -1;
+ }
+ }
+ m_auto_focus_state = 0;
+ }
+#endif
+
+ return 0;
+}
+
+int SecCamera::SetRotate(int angle)
+{
+ LOGE("%s(angle(%d))", __func__, angle);
+
+ if (m_angle != angle) {
+ switch (angle) {
+ case -360:
+ case 0:
+ case 360:
+ m_angle = 0;
+ break;
+
+ case -270:
+ case 90:
+ m_angle = 90;
+ break;
+
+ case -180:
+ case 180:
+ m_angle = 180;
+ break;
+
+ case -90:
+ case 270:
+ m_angle = 270;
+ break;
+
+ default:
+ LOGE("ERR(%s):Invalid angle(%d)", __func__, angle);
+ return -1;
+ }
+
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_ROTATION, angle) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_ROTATION", __func__);
+ return -1;
+ }
+ m_angle = angle;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getRotate(void)
+{
+ LOGV("%s : angle(%d)", __func__, m_angle);
+ return m_angle;
+}
+
+int SecCamera::setFrameRate(int frame_rate)
+{
+ LOGV("%s(FrameRate(%d))", __func__, frame_rate);
+
+ if (frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate ) {
+ LOGE("ERR(%s):Invalid frame_rate(%d)", __func__, frame_rate);
+ return -1;
+ }
+
+ if (m_params->capture.timeperframe.denominator != frame_rate) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__);
+ return -1;
+ }
+ m_params->capture.timeperframe.denominator = frame_rate;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::setVerticalMirror(void)
+{
+ LOGV("%s :", __func__);
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_VFLIP, 0) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_VFLIP", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int SecCamera::setHorizontalMirror(void)
+{
+ LOGV("%s :", __func__);
+
+ if (m_cam_fd <= 0) {
+ LOGE("ERR(%s):Camera was closed", __func__);
+ return -1;
+ }
+
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_HFLIP, 0) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_HFLIP", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int SecCamera::setWhiteBalance(int white_balance)
+{
+ LOGV("%s(white_balance(%d))", __func__, white_balance);
+
+ if (white_balance <= WHITE_BALANCE_BASE || WHITE_BALANCE_MAX <= white_balance) {
+ LOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance);
+ return -1;
+ }
+
+ if (m_params->white_balance != white_balance) {
+ if (m_flag_camera_create) {
+ LOGE("%s(white_balance(%d))", __func__, white_balance);
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, white_balance) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WHITE_BALANCE", __func__);
+ return -1;
+ }
+ m_params->white_balance = white_balance;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getWhiteBalance(void)
+{
+ LOGV("%s : white_balance(%d)", __func__, m_params->white_balance);
+ return m_params->white_balance;
+}
+
+int SecCamera::setBrightness(int brightness)
+{
+ LOGV("%s(brightness(%d))", __func__, brightness);
+
+ if (m_camera_use_ISP) {
+ brightness += IS_BRIGHTNESS_DEFAULT;
+ if (brightness < IS_BRIGHTNESS_MINUS_2 || IS_BRIGHTNESS_PLUS_2 < brightness) {
+ LOGE("ERR(%s):Invalid brightness(%d)", __func__, brightness);
+ return -1;
+ }
+ } else {
+ LOGW("WARN(%s):Not supported brightness setting", __func__);
+ return 0;
+ }
+
+ if (m_params->brightness != brightness) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_BRIGHTNESS, brightness) < EV_MINUS_4) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_BRIGHTNESS", __func__);
+ return -1;
+ }
+ m_params->brightness = brightness;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getBrightness(void)
+{
+ LOGV("%s : brightness(%d)", __func__, m_params->brightness);
+ return m_params->brightness;
+}
+
+int SecCamera::setExposure(int exposure)
+{
+ LOGV("%s(exposure(%d))", __func__, exposure);
+
+ if (m_camera_use_ISP) {
+ exposure += IS_EXPOSURE_DEFAULT;
+ if (exposure < IS_EXPOSURE_MINUS_4 || IS_EXPOSURE_PLUS_4 < exposure) {
+ LOGE("ERR(%s):Invalid exposure(%d)", __func__, exposure);
+ return -1;
+ }
+ } else {
+ exposure += EV_DEFAULT;
+ if (exposure < EV_MINUS_4 || EV_PLUS_4 < exposure) {
+ LOGE("ERR(%s):Invalid exposure(%d)", __func__, exposure);
+ return -1;
+ }
+ }
+
+ if (m_params->exposure != exposure) {
+ if (m_flag_camera_create) {
+ if (m_camera_use_ISP) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_EXPOSURE, exposure) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_EXPOSURE", __func__);
+ return -1;
+ }
+ } else {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, exposure) < EV_MINUS_4) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BRIGHTNESS", __func__);
+ return -1;
+ }
+ }
+ m_params->exposure = exposure;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getExposure(void)
+{
+ LOGV("%s : exposure(%d)", __func__, m_params->exposure);
+ return m_params->exposure;
+}
+
+int SecCamera::setImageEffect(int image_effect)
+{
+ LOGV("%s(image_effect(%d))", __func__, image_effect);
+
+ if (image_effect <= IMAGE_EFFECT_BASE || IMAGE_EFFECT_MAX <= image_effect) {
+ LOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect);
+ return -1;
+ }
+
+ if (m_params->effects != image_effect) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, image_effect) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_EFFECT", __func__);
+ return -1;
+ }
+ m_params->effects = image_effect;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getImageEffect(void)
+{
+ LOGV("%s : image_effect(%d)", __func__, m_params->effects);
+ return m_params->effects;
+}
+
+int SecCamera::setAntiBanding(int anti_banding)
+{
+ LOGV("%s(anti_banding(%d))", __func__, anti_banding);
+
+ if (anti_banding < ANTI_BANDING_AUTO || ANTI_BANDING_OFF < anti_banding) {
+ LOGE("ERR(%s):Invalid anti_banding (%d)", __func__, anti_banding);
+ return -1;
+ }
+
+ if (m_params->anti_banding != anti_banding) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_BANDING, anti_banding) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_BANDING", __func__);
+ return -1;
+ }
+ m_params->anti_banding = anti_banding;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::setSceneMode(int scene_mode)
+{
+ LOGV("%s(scene_mode(%d))", __func__, scene_mode);
+
+ if (scene_mode <= SCENE_MODE_BASE || SCENE_MODE_MAX <= scene_mode) {
+ LOGE("ERR(%s):Invalid scene_mode (%d)", __func__, scene_mode);
+ return -1;
+ }
+
+ if (m_params->scene_mode != scene_mode) {
+ if (m_flag_camera_create) {
+ LOGE("%s(scene_mode(%d))", __func__, scene_mode);
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, scene_mode) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __func__);
+ return -1;
+ }
+ m_params->scene_mode = scene_mode;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getSceneMode(void)
+{
+ return m_params->scene_mode;
+}
+
+int SecCamera::setFlashMode(int flash_mode)
+{
+ LOGV("%s(flash_mode(%d))", __func__, flash_mode);
+
+ if (flash_mode <= FLASH_MODE_BASE || FLASH_MODE_MAX <= flash_mode) {
+ LOGE("ERR(%s):Invalid flash_mode (%d)", __func__, flash_mode);
+ return -1;
+ }
+
+ if (m_params->flash_mode != flash_mode) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FLASH_MODE, flash_mode) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FLASH_MODE", __func__);
+ return -1;
+ }
+ m_params->flash_mode = flash_mode;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getFlashMode(void)
+{
+ return m_params->flash_mode;
+}
+
+int SecCamera::setAutoExposureLock(int toggle)
+{
+ LOGV("%s(toggle value(%d))", __func__, toggle);
+
+ int aeawb_mode = m_params->aeawb_mode;
+
+ if (m_flag_camera_create) {
+ if (toggle ^ aeawb_mode) {
+ aeawb_mode = aeawb_mode ^ 0x1;
+ m_params->aeawb_mode = aeawb_mode;
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, aeawb_mode) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK", __func__);
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+int SecCamera::setAutoWhiteBalanceLock(int toggle)
+{
+ LOGV("%s(toggle value(%d))", __func__, toggle);
+
+ int aeawb_mode = m_params->aeawb_mode;
+
+ if (m_flag_camera_create) {
+ if (toggle ^ (aeawb_mode >> 1)) {
+ aeawb_mode = aeawb_mode ^ (0x1 << 1);
+ m_params->aeawb_mode = aeawb_mode;
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, aeawb_mode) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK", __func__);
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+int SecCamera::setISO(int iso_value)
+{
+ LOGV("%s(iso_value(%d))", __func__, iso_value);
+
+ if (iso_value < ISO_AUTO || ISO_MAX <= iso_value) {
+ LOGE("ERR(%s):Invalid iso_value (%d)", __func__, iso_value);
+ return -1;
+ }
+
+ if (m_params->iso != iso_value) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, iso_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ISO", __func__);
+ return -1;
+ }
+ m_params->iso = iso_value;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getISO(void)
+{
+ return m_params->iso;
+}
+
+int SecCamera::setContrast(int contrast_value)
+{
+ LOGV("%s(contrast_value(%d))", __func__, contrast_value);
+
+ if (m_camera_use_ISP) {
+ if (contrast_value < IS_CONTRAST_AUTO || IS_CONTRAST_MAX <= contrast_value) {
+ LOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value);
+ return -1;
+ }
+ } else {
+ if (contrast_value < CONTRAST_MINUS_2 || CONTRAST_MAX <= contrast_value) {
+ LOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value);
+ return -1;
+ }
+ }
+
+ if (m_params->contrast != contrast_value) {
+ if (m_flag_camera_create) {
+ if (m_camera_use_ISP) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_CONTRAST, contrast_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_CONTRAST", __func__);
+ return -1;
+ }
+ } else {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CONTRAST, contrast_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CONTRAST", __func__);
+ return -1;
+ }
+ }
+ m_params->contrast = contrast_value;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getContrast(void)
+{
+ return m_params->contrast;
+}
+
+int SecCamera::setSaturation(int saturation_value)
+{
+ LOGV("%s(saturation_value(%d))", __func__, saturation_value);
+
+ saturation_value += SATURATION_DEFAULT;
+ if (saturation_value < SATURATION_MINUS_2 || SATURATION_MAX <= saturation_value) {
+ LOGE("ERR(%s):Invalid saturation_value (%d)", __func__, saturation_value);
+ return -1;
+ }
+
+ if (m_params->saturation != saturation_value) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, saturation_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__);
+ return -1;
+ }
+ m_params->saturation = saturation_value;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getSaturation(void)
+{
+ return m_params->saturation;
+}
+
+int SecCamera::setSharpness(int sharpness_value)
+{
+ LOGV("%s(sharpness_value(%d))", __func__, sharpness_value);
+
+ sharpness_value += SHARPNESS_DEFAULT;
+ if (sharpness_value < SHARPNESS_MINUS_2 || SHARPNESS_MAX <= sharpness_value) {
+ LOGE("ERR(%s):Invalid sharpness_value (%d)", __func__, sharpness_value);
+ return -1;
+ }
+
+ if (m_params->sharpness != sharpness_value) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, sharpness_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__);
+ return -1;
+ }
+ m_params->sharpness = sharpness_value;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getSharpness(void)
+{
+ return m_params->sharpness;
+}
+
+int SecCamera::setHue(int hue_value)
+{
+ LOGV("%s(hue_value(%d))", __func__, hue_value);
+
+/* TODO */
+/* This code is temporary implementation because *
+ * hue value tuning was not complete */
+#ifdef USE_HUE
+ if (m_camera_use_ISP) {
+ hue_value += IS_HUE_DEFAULT;
+ if (hue_value < IS_HUE_MINUS_2 || IS_HUE_MAX <= hue_value) {
+ LOGE("ERR(%s):Invalid hue_value (%d)", __func__, hue_value);
+ return -1;
+ }
+ } else {
+ LOGW("WARN(%s):Not supported hue setting", __func__);
+ return 0;
+ }
+
+ if (m_params->hue != hue_value) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_HUE, hue_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_HUE", __func__);
+ return -1;
+ }
+ m_params->hue = hue_value;
+ }
+ }
+#endif
+
+ return 0;
+}
+
+int SecCamera::getHue(void)
+{
+ return m_params->hue;
+}
+
+int SecCamera::setWDR(int wdr_value)
+{
+ LOGV("%s(wdr_value(%d))", __func__, wdr_value);
+
+ if (m_camera_use_ISP) {
+ if (wdr_value < IS_DRC_BYPASS_DISABLE || IS_DRC_BYPASS_MAX <= wdr_value) {
+ LOGE("ERR(%s):Invalid drc_value (%d)", __func__, wdr_value);
+ return -1;
+ }
+ } else {
+ if (wdr_value < WDR_OFF || WDR_MAX <= wdr_value) {
+ LOGE("ERR(%s):Invalid wdr_value (%d)", __func__, wdr_value);
+ return -1;
+ }
+ }
+
+ if (m_wdr != wdr_value) {
+ if (m_flag_camera_create) {
+ if (m_camera_use_ISP) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_SET_DRC, wdr_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_SET_DRC", __func__);
+ return -1;
+ }
+ } else {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WDR, wdr_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WDR", __func__);
+ return -1;
+ }
+ }
+ m_wdr = wdr_value;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getWDR(void)
+{
+ return m_wdr;
+}
+
+int SecCamera::setAntiShake(int anti_shake)
+{
+ LOGV("%s(anti_shake(%d))", __func__, anti_shake);
+
+ if (anti_shake < ANTI_SHAKE_OFF || ANTI_SHAKE_MAX <= anti_shake) {
+ LOGE("ERR(%s):Invalid anti_shake (%d)", __func__, anti_shake);
+ return -1;
+ }
+
+ if (m_anti_shake != anti_shake) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_SHAKE, anti_shake) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_SHAKE", __func__);
+ return -1;
+ }
+ m_anti_shake = anti_shake;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getAntiShake(void)
+{
+ return m_anti_shake;
+}
+
+int SecCamera::setMetering(int metering_value)
+{
+ LOGV("%s(metering (%d))", __func__, metering_value);
+
+ if (metering_value <= METERING_BASE || METERING_MAX <= metering_value) {
+ LOGE("ERR(%s):Invalid metering_value (%d)", __func__, metering_value);
+ return -1;
+ }
+
+ if (m_params->metering != metering_value) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, metering_value) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_METERING", __func__);
+ return -1;
+ }
+ m_params->metering = metering_value;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getMetering(void)
+{
+ return m_params->metering;
+}
+
+int SecCamera::setJpegQuality(int jpeg_quality)
+{
+ LOGV("%s(jpeg_quality (%d))", __func__, jpeg_quality);
+
+ if (jpeg_quality < JPEG_QUALITY_ECONOMY || JPEG_QUALITY_MAX <= jpeg_quality) {
+ LOGE("ERR(%s):Invalid jpeg_quality (%d)", __func__, jpeg_quality);
+ return -1;
+ }
+
+ if (m_jpeg_quality != jpeg_quality) {
+ m_jpeg_quality = jpeg_quality;
+ if (m_flag_camera_create && !m_camera_use_ISP) {
+ jpeg_quality -= 5;
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAM_JPEG_QUALITY", __func__);
+ return -1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getJpegQuality(void)
+{
+ return m_jpeg_quality;
+}
+
+int SecCamera::setZoom(int zoom_level)
+{
+ LOGV("%s(zoom_level (%d))", __func__, zoom_level);
+
+ if (zoom_level < ZOOM_LEVEL_0 || ZOOM_LEVEL_MAX <= zoom_level) {
+ LOGE("ERR(%s):Invalid zoom_level (%d)", __func__, zoom_level);
+ return -1;
+ }
+
+ if (m_zoom_level != zoom_level) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ZOOM, zoom_level) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ZOOM", __func__);
+ return -1;
+ }
+ m_zoom_level = zoom_level;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getZoom(void)
+{
+ return m_zoom_level;
+}
+
+int SecCamera::setObjectTracking(int object_tracking)
+{
+ LOGV("%s(object_tracking (%d))", __func__, object_tracking);
+
+ if (object_tracking < OBJECT_TRACKING_OFF || OBJECT_TRACKING_MAX <= object_tracking) {
+ LOGE("ERR(%s):Invalid object_tracking (%d)", __func__, object_tracking);
+ return -1;
+ }
+
+ if (m_object_tracking != object_tracking)
+ m_object_tracking = object_tracking;
+
+ return 0;
+}
+
+int SecCamera::getObjectTracking(void)
+{
+ return m_object_tracking;
+}
+
+int SecCamera::getObjectTrackingStatus(void)
+{
+ int obj_status = 0;
+ obj_status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJ_TRACKING_STATUS);
+ return obj_status;
+}
+
+int SecCamera::setObjectTrackingStartStop(int start_stop)
+{
+ LOGV("%s(object_tracking_start_stop (%d))", __func__, start_stop);
+
+ if (m_object_tracking_start_stop != start_stop) {
+ m_object_tracking_start_stop = start_stop;
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP, start_stop) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP", __func__);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::setTouchAFStartStop(int start_stop)
+{
+ LOGV("%s(touch_af_start_stop (%d))", __func__, start_stop);
+
+ if (m_touch_af_start_stop != start_stop) {
+ m_touch_af_start_stop = start_stop;
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, start_stop) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_TOUCH_AF_START_STOP", __func__);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::setSmartAuto(int smart_auto)
+{
+ LOGV("%s(smart_auto (%d))", __func__, smart_auto);
+
+ if (smart_auto < SMART_AUTO_OFF || SMART_AUTO_MAX <= smart_auto) {
+ LOGE("ERR(%s):Invalid smart_auto (%d)", __func__, smart_auto);
+ return -1;
+ }
+
+ if (m_smart_auto != smart_auto) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SMART_AUTO, smart_auto) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SMART_AUTO", __func__);
+ return -1;
+ }
+ m_smart_auto = smart_auto;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getSmartAuto(void)
+{
+ return m_smart_auto;
+}
+
+int SecCamera::getAutosceneStatus(void)
+{
+ int autoscene_status = -1;
+
+ if (getSmartAuto() == SMART_AUTO_ON) {
+ autoscene_status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_SMART_AUTO_STATUS);
+
+ if ((autoscene_status < SMART_AUTO_STATUS_AUTO) || (autoscene_status > SMART_AUTO_STATUS_MAX)) {
+ LOGE("ERR(%s):Invalid getAutosceneStatus (%d)", __func__, autoscene_status);
+ return -1;
+ }
+ }
+ return autoscene_status;
+}
+
+int SecCamera::setBeautyShot(int beauty_shot)
+{
+ LOGV("%s(beauty_shot (%d))", __func__, beauty_shot);
+
+ if (beauty_shot < BEAUTY_SHOT_OFF || BEAUTY_SHOT_MAX <= beauty_shot) {
+ LOGE("ERR(%s):Invalid beauty_shot (%d)", __func__, beauty_shot);
+ return -1;
+ }
+
+ if (m_beauty_shot != beauty_shot) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BEAUTY_SHOT, beauty_shot) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BEAUTY_SHOT", __func__);
+ return -1;
+ }
+ m_beauty_shot = beauty_shot;
+ }
+
+ setFaceDetect(FACE_DETECTION_ON_BEAUTY);
+ }
+
+ return 0;
+}
+
+int SecCamera::getBeautyShot(void)
+{
+ return m_beauty_shot;
+}
+
+int SecCamera::setVintageMode(int vintage_mode)
+{
+ LOGV("%s(vintage_mode(%d))", __func__, vintage_mode);
+
+ if (vintage_mode <= VINTAGE_MODE_BASE || VINTAGE_MODE_MAX <= vintage_mode) {
+ LOGE("ERR(%s):Invalid vintage_mode (%d)", __func__, vintage_mode);
+ return -1;
+ }
+
+ if (m_vintage_mode != vintage_mode) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VINTAGE_MODE, vintage_mode) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VINTAGE_MODE", __func__);
+ return -1;
+ }
+ m_vintage_mode = vintage_mode;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getVintageMode(void)
+{
+ return m_vintage_mode;
+}
+
+int SecCamera::setFocusMode(int focus_mode)
+{
+ LOGV("%s(focus_mode(%d))", __func__, focus_mode);
+
+ if (FOCUS_MODE_MAX <= focus_mode) {
+ LOGE("ERR(%s):Invalid focus_mode (%d)", __func__, focus_mode);
+ return -1;
+ }
+
+ if (m_params->focus_mode != focus_mode) {
+ if (m_flag_camera_create) {
+ if (m_params->focus_mode == FOCUS_MODE_AUTO || m_params->focus_mode == FOCUS_MODE_MACRO) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
+ return -1;
+ }
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__);
+ return -1;
+ }
+ if (!m_camera_use_ISP) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
+ return -1;
+ }
+ }
+ m_params->focus_mode = focus_mode;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getFocusMode(void)
+{
+ return m_params->focus_mode;
+}
+
+int SecCamera::setFaceDetect(int face_detect)
+{
+ LOGV("%s(face_detect(%d))", __func__, face_detect);
+ if (m_camera_use_ISP) {
+ if (face_detect < IS_FD_COMMAND_STOP || IS_FD_COMMAND_MAX <= face_detect) {
+ LOGE("ERR(%s):Invalid face_detect value (%d)", __func__, face_detect);
+ return -1;
+ }
+ } else {
+ if (face_detect < FACE_DETECTION_OFF || FACE_DETECTION_MAX <= face_detect) {
+ LOGE("ERR(%s):Invalid face_detect value (%d)", __func__, face_detect);
+ return -1;
+ }
+ }
+
+ if (m_face_detect != face_detect) {
+ if (m_flag_camera_create) {
+ if (m_camera_use_ISP) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_IS_CMD_FD, face_detect) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_IS_CMD_FD", __func__);
+ return -1;
+ }
+ } else {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACE_DETECTION, face_detect) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACE_DETECTION", __func__);
+ return -1;
+ }
+ }
+ m_face_detect = face_detect;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::getFaceDetect(void)
+{
+ return m_face_detect;
+}
+
+int SecCamera::setGPSLatitude(const char *gps_latitude)
+{
+ double conveted_latitude = 0;
+ LOGV("%s(gps_latitude(%s))", __func__, gps_latitude);
+ if (gps_latitude == NULL)
+ m_gps_latitude = 0;
+ else {
+ conveted_latitude = atof(gps_latitude);
+ m_gps_latitude = (long)(conveted_latitude * 10000 / 1);
+ }
+
+ LOGV("%s(m_gps_latitude(%ld))", __func__, m_gps_latitude);
+ return 0;
+}
+
+int SecCamera::setGPSLongitude(const char *gps_longitude)
+{
+ double conveted_longitude = 0;
+ LOGV("%s(gps_longitude(%s))", __func__, gps_longitude);
+ if (gps_longitude == NULL)
+ m_gps_longitude = 0;
+ else {
+ conveted_longitude = atof(gps_longitude);
+ m_gps_longitude = (long)(conveted_longitude * 10000 / 1);
+ }
+
+ LOGV("%s(m_gps_longitude(%ld))", __func__, m_gps_longitude);
+ return 0;
+}
+
+int SecCamera::setGPSAltitude(const char *gps_altitude)
+{
+ double conveted_altitude = 0;
+ LOGV("%s(gps_altitude(%s))", __func__, gps_altitude);
+ if (gps_altitude == NULL)
+ m_gps_altitude = 0;
+ else {
+ conveted_altitude = atof(gps_altitude);
+ m_gps_altitude = (long)(conveted_altitude * 100 / 1);
+ }
+
+ LOGV("%s(m_gps_altitude(%ld))", __func__, m_gps_altitude);
+ return 0;
+}
+
+int SecCamera::setGPSTimeStamp(const char *gps_timestamp)
+{
+ LOGV("%s(gps_timestamp(%s))", __func__, gps_timestamp);
+ if (gps_timestamp == NULL)
+ m_gps_timestamp = 0;
+ else
+ m_gps_timestamp = atol(gps_timestamp);
+
+ LOGV("%s(m_gps_timestamp(%ld))", __func__, m_gps_timestamp);
+ return 0;
+}
+
+int SecCamera::setGPSProcessingMethod(const char *gps_processing_method)
+{
+ LOGV("%s(gps_processing_method(%s))", __func__, gps_processing_method);
+ memset(mExifInfo.gps_processing_method, 0, sizeof(mExifInfo.gps_processing_method));
+ if (gps_processing_method != NULL) {
+ size_t len = strlen(gps_processing_method);
+ if (len > sizeof(mExifInfo.gps_processing_method)) {
+ len = sizeof(mExifInfo.gps_processing_method);
+ }
+ memcpy(mExifInfo.gps_processing_method, gps_processing_method, len);
+ }
+ return 0;
+}
+
+int SecCamera::setFaceDetectLockUnlock(int facedetect_lockunlock)
+{
+ LOGV("%s(facedetect_lockunlock(%d))", __func__, facedetect_lockunlock);
+
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK, facedetect_lockunlock) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int SecCamera::setObjectPosition(int x, int y)
+{
+ LOGV("%s(setObjectPosition(x=%d, y=%d))", __func__, x, y);
+
+ if (m_flag_camera_start) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJECT_POSITION_X, x) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_X", __func__);
+ return -1;
+ }
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJECT_POSITION_Y, y) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_Y", __func__);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::setGamma(int gamma)
+{
+ LOGV("%s(gamma(%d))", __func__, gamma);
+
+ if (gamma < GAMMA_OFF || GAMMA_MAX <= gamma) {
+ LOGE("ERR(%s):Invalid gamma (%d)", __func__, gamma);
+ return -1;
+ }
+
+ if (m_video_gamma != gamma) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_GAMMA, gamma) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_GAMMA", __func__);
+ return -1;
+ }
+ m_video_gamma = gamma;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::setSlowAE(int slow_ae)
+{
+ LOGV("%s(slow_ae(%d))", __func__, slow_ae);
+
+ if (slow_ae < GAMMA_OFF || GAMMA_MAX <= slow_ae) {
+ LOGE("ERR(%s):Invalid slow_ae (%d)", __func__, slow_ae);
+ return -1;
+ }
+
+ if (m_slow_ae!= slow_ae) {
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_SLOW_AE, slow_ae) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_SLOW_AE", __func__);
+ return -1;
+ }
+ m_slow_ae = slow_ae;
+ }
+ }
+
+ return 0;
+}
+
+int SecCamera::setRecordingSize(int width, int height)
+{
+ LOGV("%s(width(%d), height(%d))", __func__, width, height);
+
+ m_recording_width = width;
+ m_recording_height = height;
+
+ return 0;
+}
+
+int SecCamera::getRecordingSize(int *width, int *height)
+{
+ *width = m_recording_width;
+ *height = m_recording_height;
+
+ return 0;
+}
+
+int SecCamera::setExifOrientationInfo(int orientationInfo)
+{
+ LOGV("%s(orientationInfo(%d))", __func__, orientationInfo);
+
+ if (orientationInfo < 0) {
+ LOGE("ERR(%s):Invalid orientationInfo (%d)", __func__, orientationInfo);
+ return -1;
+ }
+ m_exif_orientation = orientationInfo;
+
+ return 0;
+}
+
+int SecCamera::setBatchReflection()
+{
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BATCH_REFLECTION, 1) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BATCH_REFLECTION", __func__);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+/* Camcorder fix fps */
+int SecCamera::setSensorMode(int sensor_mode)
+{
+ LOGV("%s(sensor_mode (%d))", __func__, sensor_mode);
+
+ if (sensor_mode < SENSOR_MODE_CAMERA || SENSOR_MODE_MOVIE < sensor_mode) {
+ LOGE("ERR(%s):Invalid sensor mode (%d)", __func__, sensor_mode);
+ return -1;
+ }
+
+ if (m_sensor_mode != sensor_mode)
+ m_sensor_mode = sensor_mode;
+
+ return 0;
+}
+
+/* Shot mode */
+/* SINGLE = 0
+* CONTINUOUS = 1
+* PANORAMA = 2
+* SMILE = 3
+* SELF = 6
+*/
+int SecCamera::setShotMode(int shot_mode)
+{
+ LOGV("%s(shot_mode (%d))", __func__, shot_mode);
+ if (shot_mode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shot_mode) {
+ LOGE("ERR(%s):Invalid shot_mode (%d)", __func__, shot_mode);
+ return -1;
+ }
+ m_shot_mode = shot_mode;
+
+ return 0;
+}
+
+int SecCamera::setDataLineCheck(int chk_dataline)
+{
+ LOGV("%s(chk_dataline (%d))", __func__, chk_dataline);
+
+ if (chk_dataline < CHK_DATALINE_OFF || CHK_DATALINE_MAX <= chk_dataline) {
+ LOGE("ERR(%s):Invalid chk_dataline (%d)", __func__, chk_dataline);
+ return -1;
+ }
+
+ m_chk_dataline = chk_dataline;
+
+ return 0;
+}
+
+int SecCamera::getDataLineCheck(void)
+{
+ return m_chk_dataline;
+}
+
+int SecCamera::setDataLineCheckStop(void)
+{
+ LOGV("%s", __func__);
+
+ if (m_flag_camera_create) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CHECK_DATALINE_STOP, 1) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CHECK_DATALINE_STOP", __func__);
+ return -1;
+ }
+ }
+ return 0;
+}
+
+const __u8* SecCamera::getCameraSensorName(void)
+{
+ LOGV("%s", __func__);
+
+ return fimc_v4l2_enuminput(m_cam_fd, getCameraId());
+}
+
+bool SecCamera::getUseInternalISP(void)
+{
+ LOGV("%s", __func__);
+ int ret = 0;
+
+/*TODO*/
+ if (!strncmp((const char*)getCameraSensorName(), "ISP Camera", 10))
+ return true;
+ else if(!strncmp((const char*)getCameraSensorName(), "S5K3H2", 10))
+ return true;
+ else if(!strncmp((const char*)getCameraSensorName(), "S5K3H7", 10))
+ return true;
+ else if(!strncmp((const char*)getCameraSensorName(), "S5K4E5", 10))
+ return true;
+ else if(!strncmp((const char*)getCameraSensorName(), "S5K6A3", 10))
+ return true;
+ else
+ return false;
+}
+
+#ifdef ENABLE_ESD_PREVIEW_CHECK
+int SecCamera::getCameraSensorESDStatus(void)
+{
+ LOGV("%s", __func__);
+
+ // 0 : normal operation, 1 : abnormal operation
+ int status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_ESD_INT);
+
+ return status;
+}
+#endif // ENABLE_ESD_PREVIEW_CHECK
+
+int SecCamera::setJpegThumbnailSize(int width, int height)
+{
+ LOGV("%s(width(%d), height(%d))", __func__, width, height);
+
+ m_jpeg_thumbnail_width = width;
+ m_jpeg_thumbnail_height = height;
+
+ return 0;
+}
+
+int SecCamera::getJpegThumbnailSize(int *width, int *height)
+{
+ if (width)
+ *width = m_jpeg_thumbnail_width;
+ if (height)
+ *height = m_jpeg_thumbnail_height;
+
+ return 0;
+}
+
+int SecCamera::setJpegThumbnailQuality(int jpeg_thumbnail_quality)
+{
+ LOGV("%s(jpeg_thumbnail_quality (%d))", __func__, jpeg_thumbnail_quality);
+
+ if (jpeg_thumbnail_quality < JPEG_QUALITY_ECONOMY || JPEG_QUALITY_MAX <= jpeg_thumbnail_quality) {
+ LOGE("ERR(%s):Invalid jpeg_thumbnail_quality (%d)", __func__, jpeg_thumbnail_quality);
+ return -1;
+ }
+
+ if (m_jpeg_thumbnail_quality != jpeg_thumbnail_quality) {
+ m_jpeg_thumbnail_quality = jpeg_thumbnail_quality;
+ }
+
+ return 0;
+}
+
+int SecCamera::getJpegThumbnailQuality(void)
+{
+ return m_jpeg_thumbnail_quality;
+}
+
+void SecCamera::setExifFixedAttribute()
+{
+ char property[PROPERTY_VALUE_MAX];
+
+ //2 0th IFD TIFF Tags
+ //3 Maker
+ property_get("ro.product.brand", property, EXIF_DEF_MAKER);
+ strncpy((char *)mExifInfo.maker, property,
+ sizeof(mExifInfo.maker) - 1);
+ mExifInfo.maker[sizeof(mExifInfo.maker) - 1] = '\0';
+ //3 Model
+ property_get("ro.product.model", property, EXIF_DEF_MODEL);
+ strncpy((char *)mExifInfo.model, property,
+ sizeof(mExifInfo.model) - 1);
+ mExifInfo.model[sizeof(mExifInfo.model) - 1] = '\0';
+ //3 Software
+ property_get("ro.build.id", property, EXIF_DEF_SOFTWARE);
+ strncpy((char *)mExifInfo.software, property,
+ sizeof(mExifInfo.software) - 1);
+ mExifInfo.software[sizeof(mExifInfo.software) - 1] = '\0';
+
+ //3 YCbCr Positioning
+ mExifInfo.ycbcr_positioning = EXIF_DEF_YCBCR_POSITIONING;
+
+ //2 0th IFD Exif Private Tags
+ //3 F Number
+ mExifInfo.fnumber.num = EXIF_DEF_FNUMBER_NUM;
+ mExifInfo.fnumber.den = EXIF_DEF_FNUMBER_DEN;
+ //3 Exposure Program
+ mExifInfo.exposure_program = EXIF_DEF_EXPOSURE_PROGRAM;
+ //3 Exif Version
+ memcpy(mExifInfo.exif_version, EXIF_DEF_EXIF_VERSION, sizeof(mExifInfo.exif_version));
+ //3 Aperture
+ uint32_t av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num/mExifInfo.fnumber.den);
+ mExifInfo.aperture.num = av*EXIF_DEF_APEX_DEN;
+ mExifInfo.aperture.den = EXIF_DEF_APEX_DEN;
+ //3 Maximum lens aperture
+ mExifInfo.max_aperture.num = mExifInfo.aperture.num;
+ mExifInfo.max_aperture.den = mExifInfo.aperture.den;
+ //3 Lens Focal Length
+ if (m_camera_id == CAMERA_ID_BACK)
+ mExifInfo.focal_length.num = BACK_CAMERA_FOCAL_LENGTH;
+ else
+ mExifInfo.focal_length.num = FRONT_CAMERA_FOCAL_LENGTH;
+
+ mExifInfo.focal_length.den = EXIF_DEF_FOCAL_LEN_DEN;
+ //3 User Comments
+ strcpy((char *)mExifInfo.user_comment, EXIF_DEF_USERCOMMENTS);
+ //3 Color Space information
+ mExifInfo.color_space = EXIF_DEF_COLOR_SPACE;
+ //3 Exposure Mode
+ mExifInfo.exposure_mode = EXIF_DEF_EXPOSURE_MODE;
+
+ //2 0th IFD GPS Info Tags
+ unsigned char gps_version[4] = { 0x02, 0x02, 0x00, 0x00 };
+ memcpy(mExifInfo.gps_version_id, gps_version, sizeof(gps_version));
+
+ //2 1th IFD TIFF Tags
+ mExifInfo.compression_scheme = EXIF_DEF_COMPRESSION;
+ mExifInfo.x_resolution.num = EXIF_DEF_RESOLUTION_NUM;
+ mExifInfo.x_resolution.den = EXIF_DEF_RESOLUTION_DEN;
+ mExifInfo.y_resolution.num = EXIF_DEF_RESOLUTION_NUM;
+ mExifInfo.y_resolution.den = EXIF_DEF_RESOLUTION_DEN;
+ mExifInfo.resolution_unit = EXIF_DEF_RESOLUTION_UNIT;
+}
+
+void SecCamera::setExifChangedAttribute()
+{
+ //2 0th IFD TIFF Tags
+ //3 Width
+ mExifInfo.width = m_snapshot_width;
+ //3 Height
+ mExifInfo.height = m_snapshot_height;
+ //3 Orientation
+ switch (m_exif_orientation) {
+ case 90:
+ mExifInfo.orientation = EXIF_ORIENTATION_90;
+ break;
+ case 180:
+ mExifInfo.orientation = EXIF_ORIENTATION_180;
+ break;
+ case 270:
+ mExifInfo.orientation = EXIF_ORIENTATION_270;
+ break;
+ case 0:
+ default:
+ mExifInfo.orientation = EXIF_ORIENTATION_UP;
+ break;
+ }
+ //3 Date time
+ time_t rawtime;
+ struct tm *timeinfo;
+ time(&rawtime);
+ timeinfo = localtime(&rawtime);
+ strftime((char *)mExifInfo.date_time, 20, "%Y:%m:%d %H:%M:%S", timeinfo);
+
+ //2 0th IFD Exif Private Tags
+ //3 Exposure Time
+ int shutterSpeed = 100;
+ if (m_camera_use_ISP) {
+ shutterSpeed = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_EXIF_SHUTTERSPEED);
+ if (shutterSpeed <= 0) {
+ LOGE("%s: error %d getting shutterSpeed, camera_id = %d, using 100",
+ __func__, shutterSpeed, m_camera_id);
+ shutterSpeed = 100;
+ }
+ } else {
+ shutterSpeed = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_EXIF_TV);
+ if (shutterSpeed <= 0) {
+ LOGE("%s: error %d getting shutterSpeed, camera_id = %d, using 100",
+ __func__, shutterSpeed, m_camera_id);
+ shutterSpeed = 100;
+ }
+ }
+
+ /* TODO : external isp is not shuppoting exptime now. */
+ int exptime = 100;
+ if (m_camera_use_ISP) {
+ exptime = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_EXIF_EXPTIME);
+ if (exptime <= 0) {
+ LOGE("%s: error %d getting exposure time, camera_id = %d, using 100",
+ __func__, exptime, m_camera_id);
+ exptime = 100;
+ }
+ }
+ mExifInfo.exposure_time.num = 1;
+ mExifInfo.exposure_time.den = (uint32_t)exptime;
+
+ /* TODO : Normaly exposure time and shutter speed is same. But we need to */
+ /* calculate exactly value. */
+ shutterSpeed = exptime;
+
+ //3 ISO Speed Rating
+ int iso;
+ if (m_camera_use_ISP)
+ iso = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_IS_CAMERA_EXIF_ISO);
+ else
+ iso = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_EXIF_ISO);
+ if (iso < 0) {
+ LOGE("%s: error %d getting iso, camera_id = %d, using 100",
+ __func__, iso, m_camera_id);
+ iso = 0;
+ }
+ mExifInfo.iso_speed_rating = iso;
+
+ uint32_t av, tv, bv, sv, ev;
+ if (m_camera_use_ISP) {
+ av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num / mExifInfo.fnumber.den);
+ tv = APEX_EXPOSURE_TO_SHUTTER((double)mExifInfo.exposure_time.num / mExifInfo.exposure_time.den);
+ sv = APEX_ISO_TO_FILMSENSITIVITY(mExifInfo.iso_speed_rating);
+ bv = av + tv - sv;
+ ev = m_params->exposure - IS_EXPOSURE_DEFAULT;
+ } else {
+ av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num / mExifInfo.fnumber.den);
+ tv = shutterSpeed;
+ sv = APEX_ISO_TO_FILMSENSITIVITY(mExifInfo.iso_speed_rating);
+ bv = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_EXIF_BV);
+ ev = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_EXIF_EBV);
+ }
+ LOGD("Shutter speed=1/%d s, iso=%d", shutterSpeed, mExifInfo.iso_speed_rating);
+ LOGD("AV=%d, TV=%d, SV=%d, BV=%d, EV=%d", av, tv, sv, bv, ev);
+
+ //3 Shutter Speed
+ mExifInfo.shutter_speed.num = 1;
+ mExifInfo.shutter_speed.den = shutterSpeed;
+ //3 Brightness
+ mExifInfo.brightness.num = bv*EXIF_DEF_APEX_DEN;
+ mExifInfo.brightness.den = EXIF_DEF_APEX_DEN;
+ //3 Exposure Bias
+ if (m_params->scene_mode == SCENE_MODE_BEACH_SNOW) {
+ mExifInfo.exposure_bias.num = EXIF_DEF_APEX_DEN;
+ mExifInfo.exposure_bias.den = EXIF_DEF_APEX_DEN;
+ } else {
+ mExifInfo.exposure_bias.num = ev*EXIF_DEF_APEX_DEN;
+ mExifInfo.exposure_bias.den = EXIF_DEF_APEX_DEN;
+ }
+ //3 Metering Mode
+ switch (m_params->metering) {
+ case METERING_SPOT:
+ mExifInfo.metering_mode = EXIF_METERING_SPOT;
+ break;
+ case METERING_MATRIX:
+ mExifInfo.metering_mode = EXIF_METERING_AVERAGE;
+ break;
+ case METERING_CENTER:
+ mExifInfo.metering_mode = EXIF_METERING_CENTER;
+ break;
+ default :
+ mExifInfo.metering_mode = EXIF_METERING_AVERAGE;
+ break;
+ }
+
+ //3 Flash
+ int flash = m_params->flash_mode;
+ //int flash = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_FLASH_ONOFF);
+ if (flash < 0)
+ mExifInfo.flash = EXIF_DEF_FLASH;
+ else
+ mExifInfo.flash = flash;
+
+ //3 White Balance
+ if (m_params->white_balance == WHITE_BALANCE_AUTO || m_params->white_balance == IS_AWB_AUTO)
+ mExifInfo.white_balance = EXIF_WB_AUTO;
+ else
+ mExifInfo.white_balance = EXIF_WB_MANUAL;
+ //3 Scene Capture Type
+ switch (m_params->scene_mode) {
+ case SCENE_MODE_PORTRAIT:
+ mExifInfo.scene_capture_type = EXIF_SCENE_PORTRAIT;
+ break;
+ case SCENE_MODE_LANDSCAPE:
+ mExifInfo.scene_capture_type = EXIF_SCENE_LANDSCAPE;
+ break;
+ case SCENE_MODE_NIGHTSHOT:
+ mExifInfo.scene_capture_type = EXIF_SCENE_NIGHT;
+ break;
+ default:
+ mExifInfo.scene_capture_type = EXIF_SCENE_STANDARD;
+ break;
+ }
+
+ //2 0th IFD GPS Info Tags
+ if (m_gps_latitude != 0 && m_gps_longitude != 0) {
+ if (m_gps_latitude > 0)
+ strcpy((char *)mExifInfo.gps_latitude_ref, "N");
+ else
+ strcpy((char *)mExifInfo.gps_latitude_ref, "S");
+
+ if (m_gps_longitude > 0)
+ strcpy((char *)mExifInfo.gps_longitude_ref, "E");
+ else
+ strcpy((char *)mExifInfo.gps_longitude_ref, "W");
+
+ if (m_gps_altitude > 0)
+ mExifInfo.gps_altitude_ref = 0;
+ else
+ mExifInfo.gps_altitude_ref = 1;
+
+ double latitude = fabs(m_gps_latitude / 10000.0);
+ double longitude = fabs(m_gps_longitude / 10000.0);
+ double altitude = fabs(m_gps_altitude / 100.0);
+
+ mExifInfo.gps_latitude[0].num = (uint32_t)latitude;
+ mExifInfo.gps_latitude[0].den = 1;
+ mExifInfo.gps_latitude[1].num = (uint32_t)((latitude - mExifInfo.gps_latitude[0].num) * 60);
+ mExifInfo.gps_latitude[1].den = 1;
+ mExifInfo.gps_latitude[2].num = (uint32_t)((((latitude - mExifInfo.gps_latitude[0].num) * 60)
+ - mExifInfo.gps_latitude[1].num) * 60);
+ mExifInfo.gps_latitude[2].den = 1;
+
+ mExifInfo.gps_longitude[0].num = (uint32_t)longitude;
+ mExifInfo.gps_longitude[0].den = 1;
+ mExifInfo.gps_longitude[1].num = (uint32_t)((longitude - mExifInfo.gps_longitude[0].num) * 60);
+ mExifInfo.gps_longitude[1].den = 1;
+ mExifInfo.gps_longitude[2].num = (uint32_t)((((longitude - mExifInfo.gps_longitude[0].num) * 60)
+ - mExifInfo.gps_longitude[1].num) * 60);
+ mExifInfo.gps_longitude[2].den = 1;
+
+ mExifInfo.gps_altitude.num = (uint32_t)altitude;
+ mExifInfo.gps_altitude.den = 1;
+
+ struct tm tm_data;
+ gmtime_r(&m_gps_timestamp, &tm_data);
+ mExifInfo.gps_timestamp[0].num = tm_data.tm_hour;
+ mExifInfo.gps_timestamp[0].den = 1;
+ mExifInfo.gps_timestamp[1].num = tm_data.tm_min;
+ mExifInfo.gps_timestamp[1].den = 1;
+ mExifInfo.gps_timestamp[2].num = tm_data.tm_sec;
+ mExifInfo.gps_timestamp[2].den = 1;
+ snprintf((char*)mExifInfo.gps_datestamp, sizeof(mExifInfo.gps_datestamp),
+ "%04d:%02d:%02d", tm_data.tm_year + 1900, tm_data.tm_mon + 1, tm_data.tm_mday);
+
+ mExifInfo.enableGps = true;
+ } else {
+ mExifInfo.enableGps = false;
+ }
+
+ //2 1th IFD TIFF Tags
+ mExifInfo.widthThumb = m_jpeg_thumbnail_width;
+ mExifInfo.heightThumb = m_jpeg_thumbnail_height;
+}
+
+int SecCamera::makeExif (unsigned char *exifOut,
+ unsigned char *thumb_buf,
+ unsigned int thumb_size,
+ exif_attribute_t *exifInfo,
+ unsigned int *size,
+ bool useMainbufForThumb)
+{
+ 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;
+ }
+ static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };
+ 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
+
+ unsigned char *thumbBuf = thumb_buf;
+ unsigned int thumbSize = thumb_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);
+
+ LOGD("makeExif X");
+
+ return 0;
+}
+
+inline void SecCamera::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 SecCamera::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 SecCamera::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 SecCamera::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;
+}
+
+status_t SecCamera::dump(int fd)
+{
+ const size_t SIZE = 256;
+ char buffer[SIZE];
+ String8 result;
+ snprintf(buffer, 255, "dump(%d)\n", fd);
+ result.append(buffer);
+ ::write(fd, result.string(), result.size());
+ return NO_ERROR;
+}
+
+double SecCamera::jpeg_ratio = 0.7;
+int SecCamera::interleaveDataSize = 5242880;
+int SecCamera::jpegLineLength = 636;
+
+}; // namespace android
diff --git a/exynos4/hal/libcamera/SecCamera.h b/exynos4/hal/libcamera/SecCamera.h
new file mode 100644
index 0000000..fc30fc4
--- /dev/null
+++ b/exynos4/hal/libcamera/SecCamera.h
@@ -0,0 +1,695 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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 ANDROID_HARDWARE_CAMERA_SEC_H
+#define ANDROID_HARDWARE_CAMERA_SEC_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <sys/stat.h>
+
+#include <utils/RefBase.h>
+#include <hardware/camera.h>
+#include <videodev2.h>
+#include <videodev2_samsung.h>
+#include "sec_utils_v4l2.h"
+
+#include "SecBuffer.h"
+
+#include <utils/String8.h>
+
+#ifdef SAMSUNG_EXYNOS4210
+#include "jpeg_api.h"
+#endif
+
+#ifdef SAMSUNG_EXYNOS4x12
+#include "jpeg_hal.h"
+#endif
+
+#include "Exif.h"
+namespace android {
+
+//#define ENABLE_ESD_PREVIEW_CHECK
+//#define ZERO_SHUTTER_LAG
+#define VIDEO_SNAPSHOT
+
+#if defined VIDEO_SNAPSHOT
+#define ZERO_SHUTTER_LAG
+#endif
+
+#define USE_FACE_DETECTION
+//#define USE_TOUCH_AF
+
+#if defined(LOG_NDEBUG) && (LOG_NDEBUG == 0)
+#define LOG_CAMERA LOGD
+#define LOG_CAMERA_PREVIEW LOGD
+
+#define LOG_TIME_DEFINE(n) \
+ struct timeval time_start_##n, time_stop_##n; unsigned long log_time_##n = 0;
+
+#define LOG_TIME_START(n) \
+ gettimeofday(&time_start_##n, NULL);
+
+#define LOG_TIME_END(n) \
+ gettimeofday(&time_stop_##n, NULL); log_time_##n = measure_time_camera(&time_start_##n, &time_stop_##n);
+
+#define LOG_TIME(n) \
+ log_time_##n
+
+#else
+#define LOG_CAMERA(...)
+#define LOG_CAMERA_PREVIEW(...)
+#define LOG_TIME_DEFINE(n)
+#define LOG_TIME_START(n)
+#define LOG_TIME_END(n)
+#define LOG_TIME(n)
+#endif
+
+#define FRM_RATIO(w, h) ((w)*10/(h))
+#define SIZE_4K (1 << 12)
+
+#define JOIN(x, y) JOIN_AGAIN(x, y)
+#define JOIN_AGAIN(x, y) x ## y
+
+#define FRONT_CAM S5K6A3
+#define BACK_CAM M5MO
+
+#if !defined (FRONT_CAM) || !defined(BACK_CAM)
+#error "Please define the Camera module"
+#endif
+
+#define M5MO_PREVIEW_WIDTH 640
+#define M5MO_PREVIEW_HEIGHT 480
+#define M5MO_SNAPSHOT_WIDTH 3264
+#define M5MO_SNAPSHOT_HEIGHT 2448
+
+#define M5MO_THUMBNAIL_WIDTH 320
+#define M5MO_THUMBNAIL_HEIGHT 240
+#define M5MO_THUMBNAIL_BPP 16
+
+#define M5MO_FPS 30
+
+/* focal length of 3.43mm */
+#define M5MO_FOCAL_LENGTH 343
+
+#define S5K6A3_PREVIEW_WIDTH 480
+#define S5K6A3_PREVIEW_HEIGHT 480
+#define S5K6A3_SNAPSHOT_WIDTH 1392
+#define S5K6A3_SNAPSHOT_HEIGHT 1392
+
+#define S5K6A3_THUMBNAIL_WIDTH 160
+#define S5K6A3_THUMBNAIL_HEIGHT 120
+#define S5K6A3_THUMBNAIL_BPP 16
+
+#define S5K6A3_FPS 30
+
+/* focal length of 0.9mm */
+#define S5K6A3_FOCAL_LENGTH 90
+
+#define MAX_BACK_CAMERA_PREVIEW_WIDTH JOIN(BACK_CAM,_PREVIEW_WIDTH)
+#define MAX_BACK_CAMERA_PREVIEW_HEIGHT JOIN(BACK_CAM,_PREVIEW_HEIGHT)
+#define MAX_BACK_CAMERA_SNAPSHOT_WIDTH JOIN(BACK_CAM,_SNAPSHOT_WIDTH)
+#define MAX_BACK_CAMERA_SNAPSHOT_HEIGHT JOIN(BACK_CAM,_SNAPSHOT_HEIGHT)
+
+#define BACK_CAMERA_THUMBNAIL_WIDTH JOIN(BACK_CAM,_THUMBNAIL_WIDTH)
+#define BACK_CAMERA_THUMBNAIL_HEIGHT JOIN(BACK_CAM,_THUMBNAIL_HEIGHT)
+#define BACK_CAMERA_THUMBNAIL_BPP JOIN(BACK_CAM,_THUMBNAIL_BPP)
+
+#define BACK_CAMERA_FPS JOIN(BACK_CAM,_FPS)
+
+#define BACK_CAMERA_FOCAL_LENGTH JOIN(BACK_CAM,_FOCAL_LENGTH)
+
+#define MAX_FRONT_CAMERA_PREVIEW_WIDTH JOIN(FRONT_CAM,_PREVIEW_WIDTH)
+#define MAX_FRONT_CAMERA_PREVIEW_HEIGHT JOIN(FRONT_CAM,_PREVIEW_HEIGHT)
+#define MAX_FRONT_CAMERA_SNAPSHOT_WIDTH JOIN(FRONT_CAM,_SNAPSHOT_WIDTH)
+#define MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT JOIN(FRONT_CAM,_SNAPSHOT_HEIGHT)
+
+#define FRONT_CAMERA_THUMBNAIL_WIDTH JOIN(FRONT_CAM,_THUMBNAIL_WIDTH)
+#define FRONT_CAMERA_THUMBNAIL_HEIGHT JOIN(FRONT_CAM,_THUMBNAIL_HEIGHT)
+#define FRONT_CAMERA_THUMBNAIL_BPP JOIN(FRONT_CAM,_THUMBNAIL_BPP)
+
+#define FRONT_CAMERA_FPS JOIN(FRONT_CAM,_FPS)
+
+#define FRONT_CAMERA_FOCAL_LENGTH JOIN(FRONT_CAM,_FOCAL_LENGTH)
+
+#define DEFAULT_JPEG_THUMBNAIL_WIDTH 256
+#define DEFAULT_JPEG_THUMBNAIL_HEIGHT 192
+
+#ifdef BOARD_USE_V4L2
+#define CAMERA_DEV_NAME "/dev/video1"
+#else
+#define CAMERA_DEV_NAME "/dev/video0"
+#endif
+
+#ifdef SAMSUNG_EXYNOS4210
+#define CAMERA_DEV_NAME3 "/dev/video2"
+#endif
+
+#ifdef SAMSUNG_EXYNOS4x12
+#ifdef BOARD_USE_V4L2
+#define CAMERA_DEV_NAME3 "/dev/video3"
+#else
+#define CAMERA_DEV_NAME3 "/dev/video1"
+#endif
+#ifdef ZERO_SHUTTER_LAG
+#define CAMERA_DEV_NAME2 "/dev/video2"
+#endif
+#endif
+
+#define CAMERA_DEV_NAME_TEMP "/data/videotmp_000"
+#define CAMERA_DEV_NAME2_TEMP "/data/videotemp_002"
+
+
+#define BPP 2
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
+#define MAX_BUFFERS 8
+
+#ifdef ZERO_SHUTTER_LAG
+#define CAP_BUFFERS 8
+#else
+#define CAP_BUFFERS 1
+#endif
+
+#ifdef BOARD_USE_V4L2
+#define MAX_PLANES (3)
+#define V4L2_BUF_TYPE V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
+#else
+#define MAX_PLANES (1)
+#define V4L2_BUF_TYPE V4L2_BUF_TYPE_VIDEO_CAPTURE
+#endif
+
+#ifdef BOARD_USE_V4L2_ION
+#define V4L2_MEMORY_TYPE V4L2_MEMORY_USERPTR
+#define RECORD_PIX_FMT V4L2_PIX_FMT_NV12M
+#define PREVIEW_NUM_PLANE (3)
+#define RECORD_NUM_PLANE (2)
+#else
+#define V4L2_MEMORY_TYPE V4L2_MEMORY_MMAP
+#define RECORD_PIX_FMT V4L2_PIX_FMT_NV12
+#define PREVIEW_NUM_PLANE (1)
+#define RECORD_NUM_PLANE (1)
+#endif
+
+/*
+ * V 4 L 2 F I M C E X T E N S I O N S
+ *
+ */
+#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_STREAM_PAUSE (V4L2_CID_PRIVATE_BASE + 53)
+
+#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 TPATTERN_COLORBAR 1
+#define TPATTERN_HORIZONTAL 2
+#define TPATTERN_VERTICAL 3
+
+#define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U')
+
+/* FOURCC for FIMC specific */
+#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_NV12T v4l2_fourcc('T', 'V', '1', '2')
+/*
+ * U S E R D E F I N E D T Y P E S
+ *
+ */
+#define PREVIEW_MODE 1
+#define CAPTURE_MODE 2
+#define RECORD_MODE 3
+
+struct yuv_fmt_list {
+ const char *name;
+ const char *desc;
+ unsigned int fmt;
+ int depth;
+ int planes;
+};
+
+struct camsensor_date_info {
+ unsigned int year;
+ unsigned int month;
+ unsigned int date;
+};
+
+class SecCamera : public virtual RefBase {
+public:
+
+ enum CAMERA_ID {
+ CAMERA_ID_BACK = 0,
+ CAMERA_ID_FRONT = 1,
+ };
+
+ enum JPEG_QUALITY {
+ JPEG_QUALITY_ECONOMY = 0,
+ JPEG_QUALITY_NORMAL = 50,
+ JPEG_QUALITY_SUPERFINE = 100,
+ JPEG_QUALITY_MAX,
+ };
+
+ enum OBJECT_TRACKING {
+ OBJECT_TRACKING_OFF,
+ OBJECT_TRACKING_ON,
+ OBJECT_TRACKING_MAX,
+ };
+
+ /*VT call*/
+ enum VT_MODE {
+ VT_MODE_OFF,
+ VT_MODE_ON,
+ VT_MODE_MAX,
+ };
+
+ /*Camera sensor mode - Camcorder fix fps*/
+ enum SENSOR_MODE {
+ SENSOR_MODE_CAMERA,
+ SENSOR_MODE_MOVIE,
+ };
+
+ /*Camera Shot mode*/
+ enum SHOT_MODE {
+ SHOT_MODE_SINGLE = 0,
+ SHOT_MODE_CONTINUOUS = 1,
+ SHOT_MODE_PANORAMA = 2,
+ SHOT_MODE_SMILE = 3,
+ SHOT_MODE_SELF = 6,
+ };
+
+ enum CHK_DATALINE {
+ CHK_DATALINE_OFF,
+ CHK_DATALINE_ON,
+ CHK_DATALINE_MAX,
+ };
+
+ enum CAM_MODE {
+ PREVIEW = 0,
+ PICTURE = 1,
+ RECORDING = 2,
+ };
+
+ int m_touch_af_start_stop;
+
+ SecCamera();
+ virtual ~SecCamera();
+
+ static SecCamera* createInstance(void)
+ {
+ static SecCamera singleton;
+ return &singleton;
+ }
+ status_t dump(int fd);
+
+ bool CreateCamera(int index);
+ bool DestroyCamera(void);
+ int getCameraId(void);
+ void initParameters(int index);
+ int setMode(int recording_en);
+
+ int startPreview(void);
+ int stopPreview(void);
+ int getPreviewState(void)
+ {
+ return m_preview_state;
+ }
+ void clearPreviewState(void)
+ {
+ m_preview_state = 0;
+ }
+
+ int startSnapshot(SecBuffer *yuv_buf);
+ int stopSnapshot(void);
+ int getSnapshot(void);
+ int setSnapshotFrame(int index);
+
+ int startRecord(bool recordHint);
+ int stopRecord(void);
+ int setPreviewFrame(int index);
+ int getRecordFrame(void);
+ int releaseRecordFrame(int index);
+ int getRecordAddr(int index, SecBuffer *buffer);
+
+ int getPreview(camera_frame_metadata_t *facedata);
+ int setPreviewSize(int width, int height, int pixel_format);
+ int getPreviewSize(int *width, int *height, int *frame_size);
+ int getPreviewMaxSize(int *width, int *height);
+ int getPreviewPixelFormat(void);
+ int setPreviewImage(int index, unsigned char *buffer, int size);
+
+ int setVideosnapshotSize(int width, int height);
+ int getVideosnapshotSize(int *width, int *height, int *frame_size);
+ int setSnapshotSize(int width, int height);
+ int getSnapshotSize(int *width, int *height, int *frame_size);
+ int getSnapshotMaxSize(int *width, int *height);
+ int setSnapshotPixelFormat(int pixel_format);
+ int getSnapshotPixelFormat(void);
+
+ unsigned char* getJpeg(unsigned char *snapshot_data, int snapshot_size, int *size);
+ unsigned char* yuv2Jpeg(unsigned char *raw_data, int raw_size,
+ int *jpeg_size,
+ int width, int height, int pixel_format);
+
+ int setJpegThumbnailSize(int width, int height);
+ int getJpegThumbnailSize(int *width, int *height);
+
+ int setJpegThumbnailQuality(int jpeg_thumbnail_quality);
+ int getJpegThumbnailQuality(void);
+
+ int initSetParams(void);
+
+ int setAutofocus(void);
+ int setTouchAF(void);
+
+ int SetRotate(int angle);
+ int getRotate(void);
+
+ int setVerticalMirror(void);
+ int setHorizontalMirror(void);
+
+ int setWhiteBalance(int white_balance);
+ int getWhiteBalance(void);
+
+ int setBrightness(int brightness);
+ int getBrightness(void);
+
+ int setExposure(int exposure);
+ int getExposure(void);
+
+ int setImageEffect(int image_effect);
+ int getImageEffect(void);
+
+ int setSceneMode(int scene_mode);
+ int getSceneMode(void);
+
+ int setFlashMode(int flash_mode);
+ int getFlashMode(void);
+
+ int setMetering(int metering_value);
+ int getMetering(void);
+
+ int setAutoExposureLock(int toggle);
+ int setAutoWhiteBalanceLock(int toggle);
+
+ int setISO(int iso_value);
+ int getISO(void);
+
+ int setContrast(int contrast_value);
+ int getContrast(void);
+
+ int setSaturation(int saturation_value);
+ int getSaturation(void);
+
+ int setSharpness(int sharpness_value);
+ int getSharpness(void);
+
+ int setHue(int hue_value);
+ int getHue(void);
+
+ int setWDR(int wdr_value);
+ int getWDR(void);
+
+ int setAntiShake(int anti_shake);
+ int getAntiShake(void);
+
+ int setJpegQuality(int jpeg_qality);
+ int getJpegQuality(void);
+
+ int setZoom(int zoom_level);
+ int getZoom(void);
+
+ int setObjectTracking(int object_tracking);
+ int getObjectTracking(void);
+ int getObjectTrackingStatus(void);
+
+ int setSmartAuto(int smart_auto);
+ int getSmartAuto(void);
+ int getAutosceneStatus(void);
+
+ int setBeautyShot(int beauty_shot);
+ int getBeautyShot(void);
+
+ int setVintageMode(int vintage_mode);
+ int getVintageMode(void);
+
+ int setFocusMode(int focus_mode);
+ int getFocusMode(void);
+
+ int setFaceDetect(int face_detect);
+ int getFaceDetect(void);
+
+ int setGPSLatitude(const char *gps_latitude);
+ int setGPSLongitude(const char *gps_longitude);
+ int setGPSAltitude(const char *gps_altitude);
+ int setGPSTimeStamp(const char *gps_timestamp);
+ int setGPSProcessingMethod(const char *gps_timestamp);
+ int cancelAutofocus(void);
+ int setFaceDetectLockUnlock(int facedetect_lockunlock);
+ int setObjectPosition(int x, int y);
+ int setObjectTrackingStartStop(int start_stop);
+ int setTouchAFStartStop(int start_stop);
+ int setCAFStatus(int on_off);
+ int getAutoFocusResult(void);
+ int setAntiBanding(int anti_banding);
+ int getPostview(void);
+ int setRecordingSize(int width, int height);
+ int getRecordingSize(int *width, int *height);
+ int setGamma(int gamma);
+ int setSlowAE(int slow_ae);
+ int setExifOrientationInfo(int orientationInfo);
+ int setBatchReflection(void);
+ int setSnapshotCmd(void);
+ int endSnapshot(void);
+ int setCameraSensorReset(void);
+ int setSensorMode(int sensor_mode); /* Camcorder fix fps */
+ int setShotMode(int shot_mode); /* Shot mode */
+ int setDataLineCheck(int chk_dataline);
+ int getDataLineCheck(void);
+ int setDataLineCheckStop(void);
+ int setDefultIMEI(int imei);
+ int getDefultIMEI(void);
+ const __u8* getCameraSensorName(void);
+ bool getUseInternalISP(void);
+#ifdef ENABLE_ESD_PREVIEW_CHECK
+ int getCameraSensorESDStatus(void);
+#endif // ENABLE_ESD_PREVIEW_CHECK
+
+ int setFrameRate(int frame_rate);
+ unsigned char* getJpeg(int *jpeg_size,
+ int *thumb_size,
+ unsigned int *thumb_addr,
+ unsigned int *phyaddr);
+ int getSnapshotAndJpeg(SecBuffer *yuv_buf,
+ int index,
+ unsigned char *jpeg_buf,
+ int *output_size);
+ int getExif(unsigned char *pExifDst, unsigned char *pThumbSrc, int thumbSize);
+
+ void getPostViewConfig(int*, int*, int*);
+ void getThumbnailConfig(int *width, int *height, int *size);
+
+ int getPostViewOffset(void);
+ int getCameraFd(enum CAM_MODE);
+ int getJpegFd(void);
+ void SetJpgAddr(unsigned char *addr);
+ int getPreviewAddr(int index, SecBuffer *buffer);
+ int getCaptureAddr(int index, SecBuffer *buffer);
+#ifdef BOARD_USE_V4L2_ION
+ void setUserBufferAddr(void *ptr, int index, int mode);
+#endif
+ static void setJpegRatio(double ratio)
+ {
+ if((ratio < 0) || (ratio > 1))
+ return;
+
+ jpeg_ratio = ratio;
+ }
+
+ static double getJpegRatio()
+ {
+ return jpeg_ratio;
+ }
+
+ static void setInterleaveDataSize(int x)
+ {
+ interleaveDataSize = x;
+ }
+
+ static int getInterleaveDataSize()
+ {
+ return interleaveDataSize;
+ }
+
+ static void setJpegLineLength(int x)
+ {
+ jpegLineLength = x;
+ }
+
+ static int getJpegLineLength()
+ {
+ return jpegLineLength;
+ }
+
+private:
+ v4l2_streamparm m_streamparm;
+ struct sec_cam_parm *m_params;
+ int m_flagCreate;
+ int m_preview_state;
+ int m_snapshot_state;
+ int m_camera_id;
+ bool m_camera_use_ISP;
+
+ int m_cam_fd;
+ struct pollfd m_events_c;
+
+ int m_cam_fd2;
+ int m_cap_fd;
+ struct pollfd m_events_c2;
+
+ int m_cam_fd3;
+ int m_rec_fd;
+ struct pollfd m_events_c3;
+ int m_flag_record_start;
+
+ int m_preview_v4lformat;
+ int m_preview_width;
+ int m_preview_height;
+ int m_preview_max_width;
+ int m_preview_max_height;
+
+ int m_snapshot_v4lformat;
+ int m_snapshot_width;
+ int m_snapshot_height;
+ int m_snapshot_max_width;
+ int m_snapshot_max_height;
+
+ int m_num_capbuf;
+ int m_videosnapshot_width;
+ int m_videosnapshot_height;
+
+ int m_angle;
+ int m_anti_banding;
+ int m_wdr;
+ int m_anti_shake;
+ int m_zoom_level;
+ int m_object_tracking;
+ int m_smart_auto;
+ int m_beauty_shot;
+ int m_vintage_mode;
+ int m_face_detect;
+ int m_object_tracking_start_stop;
+ int m_recording_en;
+ bool m_record_hint;
+ int m_recording_width;
+ int m_recording_height;
+ long m_gps_latitude;
+ long m_gps_longitude;
+ long m_gps_altitude;
+ long m_gps_timestamp;
+ int m_sensor_mode; /*Camcorder fix fps */
+ int m_shot_mode; /* Shot mode */
+ int m_exif_orientation;
+ int m_chk_dataline;
+ int m_video_gamma;
+ int m_slow_ae;
+ int m_camera_af_flag;
+ int m_auto_focus_state;
+
+ int m_flag_camera_create;
+ int m_flag_camera_start;
+
+ int m_jpeg_fd;
+ int m_jpeg_thumbnail_width;
+ int m_jpeg_thumbnail_height;
+ int m_jpeg_thumbnail_quality;
+ int m_jpeg_quality;
+
+ int m_postview_offset;
+
+#ifdef ENABLE_ESD_PREVIEW_CHECK
+ int m_esd_check_count;
+#endif // ENABLE_ESD_PREVIEW_CHECK
+
+ exif_attribute_t mExifInfo;
+
+ struct SecBuffer m_capture_buf[CAP_BUFFERS];
+ struct SecBuffer m_buffers_preview[MAX_BUFFERS];
+ struct SecBuffer m_buffers_record[MAX_BUFFERS];
+
+ 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);
+
+ void setExifChangedAttribute();
+ void setExifFixedAttribute();
+ int makeExif (unsigned char *exifOut,
+ unsigned char *thumb_buf,
+ unsigned int thumb_size,
+ exif_attribute_t *exifInfo,
+ unsigned int *size,
+ bool useMainbufForThumb);
+ void resetCamera();
+
+ static double jpeg_ratio;
+ static int interleaveDataSize;
+ static int jpegLineLength;
+};
+
+extern unsigned long measure_time_camera(struct timeval *start, struct timeval *stop);
+
+}; // namespace android
+
+#endif // ANDROID_HARDWARE_CAMERA_SEC_H
diff --git a/exynos4/hal/libcamera/SecCameraHWInterface.cpp b/exynos4/hal/libcamera/SecCameraHWInterface.cpp
new file mode 100644
index 0000000..c50ec8d
--- /dev/null
+++ b/exynos4/hal/libcamera/SecCameraHWInterface.cpp
@@ -0,0 +1,3410 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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.
+*/
+//#define LOG_NDEBUG 0
+#define LOG_TAG "CameraHardwareSec"
+#include <utils/Log.h>
+
+#include "SecCameraHWInterface.h"
+#include <utils/threads.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <camera/Camera.h>
+#include <media/stagefright/MetadataBufferType.h>
+
+#define VIDEO_COMMENT_MARKER_H 0xFFBE
+#define VIDEO_COMMENT_MARKER_L 0xFFBF
+#define VIDEO_COMMENT_MARKER_LENGTH 4
+#define JPEG_EOI_MARKER 0xFFD9
+#define HIBYTE(x) (((x) >> 8) & 0xFF)
+#define LOBYTE(x) ((x) & 0xFF)
+
+#define BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR "0.10,1.20,Infinity"
+#define BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR "0.10,0.20,Infinity"
+#define BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR "0.10,1.20,Infinity"
+#define FRONT_CAMERA_FOCUS_DISTANCES_STR "0.20,0.25,Infinity"
+#define USE_EGL
+
+// This hack does two things:
+// -- it sets preview to NV21 (YUV420SP)
+// -- it sets gralloc to YV12
+//
+// The reason being: the samsung encoder understands only yuv420sp, and gralloc
+// does yv12 and rgb565. So what we do is we break up the interleaved UV in
+// separate V and U planes, which makes preview look good, and enabled the
+// encoder as well.
+//
+// FIXME: Samsung needs to enable support for proper yv12 coming out of the
+// camera, and to fix their video encoder to work with yv12.
+// FIXME: It also seems like either Samsung's YUV420SP (NV21) or img's YV12 has
+// the color planes switched. We need to figure which side is doing it
+// wrong and have the respective party fix it.
+
+namespace android {
+
+struct addrs {
+ uint32_t type; // make sure that this is 4 byte.
+ unsigned int addr_y;
+ unsigned int addr_cbcr;
+ unsigned int buf_index;
+ unsigned int reserved;
+};
+
+struct addrs_cap {
+ unsigned int addr_y;
+ unsigned int width;
+ unsigned int height;
+};
+
+static const int INITIAL_SKIP_FRAME = 3;
+static const int EFFECT_SKIP_FRAME = 1;
+
+gralloc_module_t const* CameraHardwareSec::mGrallocHal;
+
+CameraHardwareSec::CameraHardwareSec(int cameraId, camera_device_t *dev)
+ :
+ mCaptureInProgress(false),
+ mParameters(),
+ mFrameSizeDelta(0),
+ mCameraSensorName(NULL),
+ mUseInternalISP(false),
+ mSkipFrame(0),
+ mNotifyCb(0),
+ mDataCb(0),
+ mDataCbTimestamp(0),
+ mCallbackCookie(0),
+ mMsgEnabled(CAMERA_MSG_RAW_IMAGE),
+ mRecordRunning(false),
+ mPostViewWidth(0),
+ mPostViewHeight(0),
+ mPostViewSize(0),
+ mCapIndex(0),
+ mRecordHint(false),
+ mTouched(0),
+ mHalDevice(dev)
+{
+ LOGV("%s :", __func__);
+ memset(&mCapBuffer, 0, sizeof(struct SecBuffer));
+ int ret = 0;
+
+ mPreviewWindow = NULL;
+ mSecCamera = SecCamera::createInstance();
+
+ mRawHeap = NULL;
+ mPreviewHeap = NULL;
+ for(int i = 0; i < BUFFER_COUNT_FOR_ARRAY; i++)
+ mRecordHeap[i] = NULL;
+
+ if (!mGrallocHal) {
+ ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&mGrallocHal);
+ if (ret)
+ LOGE("ERR(%s):Fail on loading gralloc HAL", __func__);
+ }
+
+ ret = mSecCamera->CreateCamera(cameraId);
+ if (ret < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera init", __func__);
+ mSecCamera->DestroyCamera();
+ }
+
+ initDefaultParameters(cameraId);
+
+ mExitAutoFocusThread = false;
+ mExitPreviewThread = false;
+ /* whether the PreviewThread is active in preview or stopped. we
+ * create the thread but it is initially in stopped state.
+ */
+ mPreviewRunning = false;
+ mPreviewStartDeferred = false;
+ mPreviewThread = new PreviewThread(this);
+ mAutoFocusThread = new AutoFocusThread(this);
+ mPictureThread = new PictureThread(this);
+}
+
+int CameraHardwareSec::getCameraId() const
+{
+ return mSecCamera->getCameraId();
+}
+
+void CameraHardwareSec::initDefaultParameters(int cameraId)
+{
+ if (mSecCamera == NULL) {
+ LOGE("ERR(%s):mSecCamera object is NULL", __func__);
+ return;
+ }
+
+ CameraParameters p;
+ CameraParameters ip;
+
+ mCameraSensorName = mSecCamera->getCameraSensorName();
+ if (mCameraSensorName == NULL) {
+ LOGE("ERR(%s):mCameraSensorName is NULL", __func__);
+ return;
+ }
+ LOGV("CameraSensorName: %s", mCameraSensorName);
+
+ int preview_max_width = 0;
+ int preview_max_height = 0;
+ int snapshot_max_width = 0;
+ int snapshot_max_height = 0;
+
+ mCameraID = cameraId;
+ mUseInternalISP = mSecCamera->getUseInternalISP();
+
+ if (cameraId == SecCamera::CAMERA_ID_BACK) {
+ if (mUseInternalISP) {
+ //3H2
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
+ "720x480,640x384,640x360,640x480,320x240,528x432,176x144");
+ p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
+ "3248x2436,3216x2144,3200x1920,3072x1728,2592x1944,1920x1080,1440x1080,1280x720,1232x1008,800x480,720x480,640x480");
+ p.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
+ "1920x1080,1280x720,640x480,176x144");
+ } else {
+ //M5MO
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
+ "3264x2448,1920x1080,1280x720,800x480,720x480,640x480,320x240,528x432,176x144");
+ p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
+ "3264x2448,3264x1968,2048x1536,2048x1232,800x480,640x480");
+ }
+ } else {
+ if (mUseInternalISP) {
+ //6A3
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
+ "640x480,640x360,480x480,352x288,320x240,176x144");
+ p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
+ "1392x1392,1280x960,1280x720,880x720,640x480");
+ p.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
+ "1280x720,640x480,176x144");
+ }
+ }
+
+ p.getSupportedPreviewSizes(mSupportedPreviewSizes);
+
+ String8 parameterString;
+
+ // If these fail, then we are using an invalid cameraId and we'll leave the
+ // sizes at zero to catch the error.
+ if (mSecCamera->getPreviewMaxSize(&preview_max_width,
+ &preview_max_height) < 0)
+ LOGE("getPreviewMaxSize fail (%d / %d)",
+ preview_max_width, preview_max_height);
+ if (mSecCamera->getSnapshotMaxSize(&snapshot_max_width,
+ &snapshot_max_height) < 0)
+ LOGE("getSnapshotMaxSize fail (%d / %d)",
+ snapshot_max_width, snapshot_max_height);
+
+ parameterString = CameraParameters::PIXEL_FORMAT_YUV420P;
+ parameterString.append(",");
+ parameterString.append(CameraParameters::PIXEL_FORMAT_YUV420SP);
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, parameterString);
+ p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420P);
+ mFrameSizeDelta = 16;
+ p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, CameraParameters::PIXEL_FORMAT_YUV420SP);
+ p.setPreviewSize(preview_max_width, preview_max_height);
+
+ p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
+ p.setPictureSize(snapshot_max_width, snapshot_max_height);
+ p.set(CameraParameters::KEY_JPEG_QUALITY, "100"); // maximum quality
+ p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
+ CameraParameters::PIXEL_FORMAT_JPEG);
+
+ p.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, "1280x720");
+
+#ifdef USE_FACE_DETECTION
+ if (mUseInternalISP) {
+ p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, "5");
+ } else {
+ p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, "0");
+ }
+#endif
+
+ if (cameraId == SecCamera::CAMERA_ID_BACK) {
+ parameterString = CameraParameters::FOCUS_MODE_AUTO;
+ /* TODO : sensor will be support this mode */
+ //parameterString.append(",");
+ //parameterString.append(CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO);
+ if (mUseInternalISP) {
+ parameterString.append(",");
+ parameterString.append(CameraParameters::FOCUS_MODE_INFINITY);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::FOCUS_MODE_MACRO);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE);
+ }
+ p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
+ parameterString.string());
+ p.set(CameraParameters::KEY_FOCUS_MODE,
+ CameraParameters::FOCUS_MODE_AUTO);
+ p.set(CameraParameters::KEY_FOCUS_DISTANCES,
+ BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
+#ifdef USE_TOUCH_AF
+ if (mUseInternalISP)
+ p.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "1");
+#endif
+ p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
+ "320x240,0x0");
+ p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "320");
+ p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "240");
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "7,15,30");
+ p.setPreviewFrameRate(30);
+ } else {
+ p.set(CameraParameters::KEY_FOCUS_MODE, NULL);
+ p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
+ "160x120,0x0");
+ p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160");
+ p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120");
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
+ "7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,50,60");
+ p.setPreviewFrameRate(30);
+ }
+
+ parameterString = CameraParameters::EFFECT_NONE;
+ parameterString.append(",");
+ parameterString.append(CameraParameters::EFFECT_MONO);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::EFFECT_NEGATIVE);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::EFFECT_SEPIA);
+ p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, parameterString.string());
+
+ if (cameraId == SecCamera::CAMERA_ID_BACK) {
+ parameterString = CameraParameters::FLASH_MODE_ON;
+ parameterString.append(",");
+ parameterString.append(CameraParameters::FLASH_MODE_OFF);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::FLASH_MODE_AUTO);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::FLASH_MODE_TORCH);
+ p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
+ parameterString.string());
+ p.set(CameraParameters::KEY_FLASH_MODE,
+ CameraParameters::FLASH_MODE_OFF);
+
+ /* we have two ranges, 4-30fps for night mode and
+ * 15-30fps for all others
+ */
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
+ p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000");
+
+ p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.43");
+ } else {
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(7500,30000)");
+ p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "7500,30000");
+
+ p.set(CameraParameters::KEY_FOCAL_LENGTH, "0.9");
+ }
+ parameterString = CameraParameters::SCENE_MODE_AUTO;
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_PORTRAIT);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_LANDSCAPE);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_BEACH);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_SNOW);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_FIREWORKS);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_SPORTS);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_PARTY);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_CANDLELIGHT);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_NIGHT);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::SCENE_MODE_SUNSET);
+ p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
+ parameterString.string());
+ p.set(CameraParameters::KEY_SCENE_MODE,
+ CameraParameters::SCENE_MODE_AUTO);
+
+ parameterString = CameraParameters::WHITE_BALANCE_AUTO;
+ parameterString.append(",");
+ parameterString.append(CameraParameters::WHITE_BALANCE_INCANDESCENT);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::WHITE_BALANCE_FLUORESCENT);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::WHITE_BALANCE_DAYLIGHT);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT);
+ p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
+ parameterString.string());
+
+ p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100");
+
+ p.set(CameraParameters::KEY_ROTATION, 0);
+ p.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO);
+
+ p.set(CameraParameters::KEY_EFFECT, CameraParameters::EFFECT_NONE);
+
+ p.set("contrast", 0);
+ p.set("iso", "auto");
+ p.set("metering", "center");
+ p.set("wdr", 0);
+
+ ip.set("chk_dataline", 0);
+ if (cameraId == SecCamera::CAMERA_ID_FRONT) {
+ ip.set("vtmode", 0);
+ ip.set("blur", 0);
+ }
+
+ p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "51.2");
+ p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "39.4");
+
+ p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0");
+ p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "4");
+ p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-4");
+ p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "1");
+
+ p.set("brightness", 0);
+ p.set("brightness-max", 2);
+ p.set("brightness-min", -2);
+
+ p.set("saturation", 0);
+ p.set("saturation-max", 2);
+ p.set("saturation-min", -2);
+
+ p.set("sharpness", 0);
+ p.set("sharpness-max", 2);
+ p.set("sharpness-min", -2);
+
+ p.set("hue", 0);
+ p.set("hue-max", 2);
+ p.set("hue-min", -2);
+
+ parameterString = CameraParameters::ANTIBANDING_AUTO;
+ parameterString.append(",");
+ parameterString.append(CameraParameters::ANTIBANDING_50HZ);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::ANTIBANDING_60HZ);
+ parameterString.append(",");
+ parameterString.append(CameraParameters::ANTIBANDING_OFF);
+ p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
+ parameterString.string());
+
+ p.set(CameraParameters::KEY_ANTIBANDING, CameraParameters::ANTIBANDING_OFF);
+
+ if (mUseInternalISP) {
+ p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true");
+ p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, "false");
+ }
+
+ if (mUseInternalISP) {
+ p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true");
+ p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, "false");
+ }
+
+ p.set(CameraParameters::KEY_RECORDING_HINT, "false");
+
+#ifdef VIDEO_SNAPSHOT
+ if (mUseInternalISP)
+ p.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, "true");
+#endif
+
+ if (!mUseInternalISP) {
+ p.set(CameraParameters::KEY_ZOOM_SUPPORTED, "true");
+ p.set(CameraParameters::KEY_MAX_ZOOM, ZOOM_LEVEL_MAX - 1);
+ p.set(CameraParameters::KEY_ZOOM_RATIOS, "31,4.0");
+ }
+
+ mPreviewRunning = false;
+ mParameters = p;
+ mInternalParameters = ip;
+
+ /* make sure mSecCamera has all the settings we do. applications
+ * aren't required to call setParameters themselves (only if they
+ * want to change something.
+ */
+ setParameters(p);
+}
+
+CameraHardwareSec::~CameraHardwareSec()
+{
+ LOGV("%s", __func__);
+ mSecCamera->DestroyCamera();
+}
+
+status_t CameraHardwareSec::setPreviewWindow(preview_stream_ops *w)
+{
+ int min_bufs;
+
+ mPreviewWindow = w;
+ LOGV("%s: mPreviewWindow %p", __func__, mPreviewWindow);
+
+ if (!w) {
+ LOGE("preview window is NULL!");
+ return OK;
+ }
+
+ mPreviewLock.lock();
+
+ if (mPreviewRunning && !mPreviewStartDeferred) {
+ LOGI("stop preview (window change)");
+ stopPreviewInternal();
+ }
+
+ if (w->get_min_undequeued_buffer_count(w, &min_bufs)) {
+ LOGE("%s: could not retrieve min undequeued buffer count", __func__);
+ return INVALID_OPERATION;
+ }
+
+ if (min_bufs >= BUFFER_COUNT_FOR_GRALLOC) {
+ LOGE("%s: min undequeued buffer count %d is too high (expecting at most %d)", __func__,
+ min_bufs, BUFFER_COUNT_FOR_GRALLOC - 1);
+ }
+
+ LOGV("%s: setting buffer count to %d", __func__, BUFFER_COUNT_FOR_GRALLOC);
+ if (w->set_buffer_count(w, BUFFER_COUNT_FOR_GRALLOC)) {
+ LOGE("%s: could not set buffer count", __func__);
+ return INVALID_OPERATION;
+ }
+
+ int preview_width;
+ int preview_height;
+ mParameters.getPreviewSize(&preview_width, &preview_height);
+
+ int hal_pixel_format;
+
+ const char *str_preview_format = mParameters.getPreviewFormat();
+ LOGV("%s: preview format %s", __func__, str_preview_format);
+ mFrameSizeDelta = 16;
+
+ hal_pixel_format = HAL_PIXEL_FORMAT_YV12; // default
+
+ if (!strcmp(str_preview_format,
+ CameraParameters::PIXEL_FORMAT_RGB565)) {
+ hal_pixel_format = HAL_PIXEL_FORMAT_RGB_565;
+ mFrameSizeDelta = 0;
+ } else if (!strcmp(str_preview_format,
+ CameraParameters::PIXEL_FORMAT_RGBA8888)) {
+ hal_pixel_format = HAL_PIXEL_FORMAT_RGBA_8888;
+ mFrameSizeDelta = 0;
+ } else if (!strcmp(str_preview_format,
+ CameraParameters::PIXEL_FORMAT_YUV420SP)) {
+ hal_pixel_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
+ } else if (!strcmp(str_preview_format,
+ CameraParameters::PIXEL_FORMAT_YUV420P))
+ hal_pixel_format = HAL_PIXEL_FORMAT_YV12; // HACK
+
+#ifdef USE_EGL
+#ifdef BOARD_USE_V4L2_ION
+ if (w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_HW_ION)) {
+#else
+ if (w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN)) {
+#endif
+ LOGE("%s: could not set usage on gralloc buffer", __func__);
+ return INVALID_OPERATION;
+ }
+#else
+#ifdef BOARD_USE_V4L2_ION
+ if (w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN
+ | GRALLOC_USAGE_HWC_HWOVERLAY | GRALLOC_USAGE_HW_ION)) {
+#else
+ if (w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN
+ | GRALLOC_USAGE_HW_FIMC1 | GRALLOC_USAGE_HWC_HWOVERLAY)) {
+#endif
+ LOGE("%s: could not set usage on gralloc buffer", __func__);
+ return INVALID_OPERATION;
+ }
+#endif
+
+ if (w->set_buffers_geometry(w,
+ preview_width, preview_height,
+ hal_pixel_format)) {
+ LOGE("%s: could not set buffers geometry to %s",
+ __func__, str_preview_format);
+ return INVALID_OPERATION;
+ }
+
+#ifdef BOARD_USE_V4L2_ION
+ for(int i = 0; i < BUFFER_COUNT_FOR_ARRAY; i++)
+ if (0 != mPreviewWindow->dequeue_buffer(mPreviewWindow, &mBufferHandle[i], &mStride[i])) {
+ LOGE("%s: Could not dequeue gralloc buffer[%d]!!", __func__, i);
+ return INVALID_OPERATION;
+ }
+#endif
+
+ if (mPreviewRunning && mPreviewStartDeferred) {
+ LOGV("start/resume preview");
+ status_t ret = startPreviewInternal();
+ if (ret == OK) {
+ mPreviewStartDeferred = false;
+ mPreviewCondition.signal();
+ }
+ }
+ mPreviewLock.unlock();
+
+ return OK;
+}
+
+void CameraHardwareSec::setCallbacks(camera_notify_callback notify_cb,
+ camera_data_callback data_cb,
+ camera_data_timestamp_callback data_cb_timestamp,
+ camera_request_memory get_memory,
+ void *user)
+{
+ mNotifyCb = notify_cb;
+ mDataCb = data_cb;
+ mDataCbTimestamp = data_cb_timestamp;
+ mGetMemoryCb = get_memory;
+ mCallbackCookie = user;
+}
+
+void CameraHardwareSec::enableMsgType(int32_t msgType)
+{
+ LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
+ __func__, msgType, mMsgEnabled);
+ mMsgEnabled |= msgType;
+
+ mPreviewLock.lock();
+ if ((msgType & (CAMERA_MSG_PREVIEW_FRAME | CAMERA_MSG_VIDEO_FRAME)) &&
+ mPreviewRunning && mPreviewStartDeferred) {
+ LOGV("%s: starting deferred preview", __func__);
+ if (startPreviewInternal() == OK) {
+ mPreviewStartDeferred = false;
+ mPreviewCondition.signal();
+ }
+ }
+ mPreviewLock.unlock();
+
+ LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
+}
+
+void CameraHardwareSec::disableMsgType(int32_t msgType)
+{
+ LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
+ __func__, msgType, mMsgEnabled);
+ mMsgEnabled &= ~msgType;
+ LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
+}
+
+bool CameraHardwareSec::msgTypeEnabled(int32_t msgType)
+{
+ return (mMsgEnabled & msgType);
+}
+
+void CameraHardwareSec::setSkipFrame(int frame)
+{
+ Mutex::Autolock lock(mSkipFrameLock);
+ if (frame < mSkipFrame)
+ return;
+
+ mSkipFrame = frame;
+}
+
+int CameraHardwareSec::previewThreadWrapper()
+{
+ LOGI("%s: starting", __func__);
+ while (1) {
+ mPreviewLock.lock();
+ while (!mPreviewRunning) {
+ LOGI("%s: calling mSecCamera->stopPreview() and waiting", __func__);
+ mSecCamera->stopPreview();
+ /* signal that we're stopping */
+ mPreviewStoppedCondition.signal();
+ mPreviewCondition.wait(mPreviewLock);
+ LOGI("%s: return from wait", __func__);
+ }
+ mPreviewLock.unlock();
+
+ if (mExitPreviewThread) {
+ LOGI("%s: exiting", __func__);
+ mSecCamera->stopPreview();
+ return 0;
+ }
+
+ previewThread();
+ }
+}
+
+int CameraHardwareSec::previewThread()
+{
+ int index;
+ nsecs_t timestamp;
+ SecBuffer previewAddr, recordAddr;
+ static int numArray = 0;
+ void *virAddr[3];
+ camera_frame_metadata_t fdmeta;
+ camera_face_t caface[5];
+
+#ifdef BOARD_USE_V4L2_ION
+ private_handle_t *hnd = NULL;
+#else
+ struct addrs *addrs;
+#endif
+
+ fdmeta.faces = caface;
+ index = mSecCamera->getPreview(&fdmeta);
+
+ mFaceData = &fdmeta;
+
+ if (index < 0) {
+ LOGE("ERR(%s):Fail on SecCamera->getPreview()", __func__);
+#ifdef BOARD_USE_V4L2_ION
+ if (mSecCamera->getPreviewState()) {
+ stopPreview();
+ startPreview();
+ mSecCamera->clearPreviewState();
+ }
+#endif
+ return UNKNOWN_ERROR;
+ }
+
+#ifdef ZERO_SHUTTER_LAG
+ if (mUseInternalISP && !mRecordHint) {
+ mCapIndex = mSecCamera->getSnapshot();
+
+ if (mCapIndex >= 0) {
+ if (mSecCamera->setSnapshotFrame(mCapIndex) < 0) {
+ LOGE("%s: Fail qbuf, index(%d)", __func__, mCapIndex);
+ return INVALID_OPERATION;
+ }
+ }
+ }
+#endif
+
+ mSkipFrameLock.lock();
+ if (mSkipFrame > 0) {
+ mSkipFrame--;
+ mSkipFrameLock.unlock();
+ LOGV("%s: index %d skipping frame", __func__, index);
+ if (mSecCamera->setPreviewFrame(index) < 0) {
+ LOGE("%s: Could not qbuff[%d]!!", __func__, index);
+ return UNKNOWN_ERROR;
+ }
+ return NO_ERROR;
+ }
+ mSkipFrameLock.unlock();
+
+ timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
+
+ int width, height, frame_size, offset;
+
+ mSecCamera->getPreviewSize(&width, &height, &frame_size);
+
+ offset = frame_size * index;
+
+ if (mPreviewWindow && mGrallocHal && mPreviewRunning) {
+#ifdef BOARD_USE_V4L2_ION
+ hnd = (private_handle_t*)*mBufferHandle[index];
+
+ if (mPreviewHeap) {
+ mPreviewHeap->release(mPreviewHeap);
+ mPreviewHeap = 0;
+ }
+
+ mPreviewHeap = mGetMemoryCb(hnd->fd, frame_size, 1, 0);
+
+ hnd = NULL;
+
+ mGrallocHal->unlock(mGrallocHal, *mBufferHandle[index]);
+ if (0 != mPreviewWindow->enqueue_buffer(mPreviewWindow, mBufferHandle[index])) {
+ LOGE("%s: Could not enqueue gralloc buffer[%d]!!", __func__, index);
+ goto callbacks;
+ } else {
+ mBufferHandle[index] = NULL;
+ mStride[index] = NULL;
+ }
+
+ numArray = index;
+#endif
+
+ if (0 != mPreviewWindow->dequeue_buffer(mPreviewWindow, &mBufferHandle[numArray], &mStride[numArray])) {
+ LOGE("%s: Could not dequeue gralloc buffer[%d]!!", __func__, numArray);
+ goto callbacks;
+ }
+
+ if (!mGrallocHal->lock(mGrallocHal,
+ *mBufferHandle[numArray],
+ GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_YUV_ADDR,
+ 0, 0, width, height, virAddr)) {
+#ifdef BOARD_USE_V4L2
+ mSecCamera->getPreviewAddr(index, &previewAddr);
+ char *frame = (char *)previewAddr.virt.extP[0];
+#else
+ char *frame = ((char *)mPreviewHeap->data) + offset;
+#endif
+
+#ifdef BOARD_USE_V4L2_ION
+ mSecCamera->setUserBufferAddr(virAddr, index, PREVIEW_MODE);
+#else
+ int total = frame_size + mFrameSizeDelta;
+ int h = 0;
+ char *src = frame;
+
+ /* TODO : Need to fix size of planes for supported color fmt.
+ Currnetly we support only YV12(3 plane) and NV21(2 plane)*/
+ // Y
+ memcpy(virAddr[0],src, width * height);
+ src += width * height;
+
+ if (mPreviewFmtPlane == PREVIEW_FMT_2_PLANE) {
+ memcpy(virAddr[1], src, width * height / 2);
+ } else if (mPreviewFmtPlane == PREVIEW_FMT_3_PLANE) {
+ // U
+ memcpy(virAddr[1], src, width * height / 4);
+ src += width * height / 4;
+
+ // V
+ memcpy(virAddr[2], src, width * height / 4);
+ }
+
+ mGrallocHal->unlock(mGrallocHal, **mBufferHandle);
+#endif
+ }
+ else
+ LOGE("%s: could not obtain gralloc buffer", __func__);
+
+ if (mSecCamera->setPreviewFrame(index) < 0) {
+ LOGE("%s: Fail qbuf, index(%d)", __func__, index);
+ goto callbacks;
+ }
+
+ index = 0;
+#ifndef BOARD_USE_V4L2_ION
+ if (0 != mPreviewWindow->enqueue_buffer(mPreviewWindow, *mBufferHandle)) {
+ LOGE("Could not enqueue gralloc buffer!");
+ goto callbacks;
+ }
+#endif
+ }
+
+callbacks:
+ // Notify the client of a new frame.
+ if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME && mPreviewRunning)
+ mDataCb(CAMERA_MSG_PREVIEW_FRAME, mPreviewHeap, index, NULL, mCallbackCookie);
+
+#ifdef USE_FACE_DETECTION
+ if (mUseInternalISP && (mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA) && mPreviewRunning)
+ mDataCb(CAMERA_MSG_PREVIEW_METADATA, mFaceDataHeap, 0, mFaceData, mCallbackCookie);
+#endif
+
+ Mutex::Autolock lock(mRecordLock);
+ if (mRecordRunning == true) {
+ int recordingIndex = 0;
+
+ index = mSecCamera->getRecordFrame();
+ if (index < 0) {
+ LOGE("ERR(%s):Fail on SecCamera->getRecordFrame()", __func__);
+ return UNKNOWN_ERROR;
+ }
+
+#ifdef VIDEO_SNAPSHOT
+ if (mUseInternalISP && mRecordHint) {
+ mCapIndex = mSecCamera->getSnapshot();
+
+ if (mSecCamera->setSnapshotFrame(mCapIndex) < 0) {
+ LOGE("%s: Fail qbuf, index(%d)", __func__, mCapIndex);
+ return INVALID_OPERATION;
+ }
+ }
+#endif
+
+#ifdef BOARD_USE_V4L2_ION
+ numArray = index;
+#else
+ recordingIndex = index;
+ mSecCamera->getRecordAddr(index, &recordAddr);
+
+ LOGV("record PhyY(0x%08x) phyC(0x%08x) ", recordAddr.phys.extP[0], recordAddr.phys.extP[1]);
+
+ if (recordAddr.phys.extP[0] == 0xffffffff || recordAddr.phys.extP[1] == 0xffffffff) {
+ LOGE("ERR(%s):Fail on SecCamera getRectPhyAddr Y addr = %0x C addr = %0x", __func__,
+ recordAddr.phys.extP[0], recordAddr.phys.extP[1]);
+ return UNKNOWN_ERROR;
+ }
+
+ addrs = (struct addrs *)(*mRecordHeap)->data;
+
+ addrs[index].type = kMetadataBufferTypeCameraSource;
+ addrs[index].addr_y = recordAddr.phys.extP[0];
+ addrs[index].addr_cbcr = recordAddr.phys.extP[1];
+ addrs[index].buf_index = index;
+#endif
+
+ // Notify the client of a new frame.
+ if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)
+ mDataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME,
+ mRecordHeap[numArray], recordingIndex, mCallbackCookie);
+ else
+ mSecCamera->releaseRecordFrame(index);
+ }
+
+ return NO_ERROR;
+}
+
+status_t CameraHardwareSec::startPreview()
+{
+ int ret = 0;
+
+ LOGV("%s :", __func__);
+
+ Mutex::Autolock lock(mStateLock);
+ if (mCaptureInProgress) {
+ LOGE("%s : capture in progress, not allowed", __func__);
+ return INVALID_OPERATION;
+ }
+
+ mPreviewLock.lock();
+ if (mPreviewRunning) {
+ // already running
+ LOGE("%s : preview thread already running", __func__);
+ mPreviewLock.unlock();
+ return INVALID_OPERATION;
+ }
+
+ mPreviewRunning = true;
+ mPreviewStartDeferred = false;
+
+ if (!mPreviewWindow &&
+ !(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) &&
+ !(mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) {
+ LOGI("%s : deferring", __func__);
+ mPreviewStartDeferred = true;
+ mPreviewLock.unlock();
+ return NO_ERROR;
+ }
+
+ ret = startPreviewInternal();
+ if (ret == OK)
+ mPreviewCondition.signal();
+
+ mPreviewLock.unlock();
+ return ret;
+}
+
+status_t CameraHardwareSec::startPreviewInternal()
+{
+ LOGV("%s", __func__);
+ int width, height, frame_size;
+
+ mSecCamera->getPreviewSize(&width, &height, &frame_size);
+ LOGD("mPreviewHeap(fd(%d), size(%d), width(%d), height(%d))",
+ mSecCamera->getCameraFd(SecCamera::PREVIEW), frame_size + mFrameSizeDelta, width, height);
+
+#ifdef BOARD_USE_V4L2_ION
+#ifdef ZERO_SHUTTER_LAG
+/*TODO*/
+ int mPostViewWidth, mPostViewHeight, mPostViewSize;
+ mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
+ for(int i = 0; i < CAP_BUFFERS; i++) {
+ mPostviewHeap[i] = new MemoryHeapBaseIon(mPostViewSize);
+ mSecCamera->setUserBufferAddr(mPostviewHeap[i]->base(), i, CAPTURE_MODE);
+ }
+#endif
+ void *vaddr[3];
+
+ for (int i = 0; i < MAX_BUFFERS; i++) {
+ if (mBufferHandle[i] == NULL) {
+ if (0 != mPreviewWindow->dequeue_buffer(mPreviewWindow, &mBufferHandle[i], &mStride[i])) {
+ LOGE("%s: Could not dequeue gralloc buffer[%d]!!", __func__, i);
+ return INVALID_OPERATION;
+ }
+ }
+ if (mGrallocHal->lock(mGrallocHal,
+ *mBufferHandle[i],
+ GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_YUV_ADDR,
+ 0, 0, width, height, vaddr)) {
+ LOGE("ERR(%s): Could not get virtual address!!, index = %d", __func__, i);
+ return UNKNOWN_ERROR;
+ }
+ mSecCamera->setUserBufferAddr(vaddr, i, PREVIEW_MODE);
+ }
+#endif
+
+ int ret = mSecCamera->startPreview();
+ LOGV("%s : mSecCamera->startPreview() returned %d", __func__, ret);
+
+ if (ret < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->startPreview()", __func__);
+ return UNKNOWN_ERROR;
+ }
+
+ setSkipFrame(INITIAL_SKIP_FRAME);
+
+ if (mPreviewHeap) {
+ mPreviewHeap->release(mPreviewHeap);
+ mPreviewHeap = 0;
+ }
+
+ for(int i=0; i<BUFFER_COUNT_FOR_ARRAY; i++){
+ if (mRecordHeap[i] != NULL) {
+ mRecordHeap[i]->release(mRecordHeap[i]);
+ mRecordHeap[i] = 0;
+ }
+ }
+
+#ifndef BOARD_USE_V4L2
+ mPreviewHeap = mGetMemoryCb((int)mSecCamera->getCameraFd(SecCamera::PREVIEW),
+ frame_size + mFrameSizeDelta,
+ MAX_BUFFERS,
+ 0); // no cookie
+#endif
+
+ mFaceDataHeap = mGetMemoryCb(-1, 1, 1, 0);
+
+ mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
+ LOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
+ mPostViewWidth,mPostViewHeight,mPostViewSize);
+
+ return NO_ERROR;
+}
+
+void CameraHardwareSec::stopPreviewInternal()
+{
+ LOGV("%s :", __func__);
+
+ /* request that the preview thread stop. */
+ if (mPreviewRunning) {
+ mPreviewRunning = false;
+ if (!mPreviewStartDeferred) {
+ mPreviewCondition.signal();
+ /* wait until preview thread is stopped */
+ mPreviewStoppedCondition.wait(mPreviewLock);
+
+#ifdef BOARD_USE_V4L2_ION
+ for (int i = 0; i < MAX_BUFFERS; i++) {
+ if (mBufferHandle[i] != NULL) {
+ if (0 != mPreviewWindow->cancel_buffer(mPreviewWindow, mBufferHandle[i])) {
+ LOGE("%s: Fail to cancel buffer[%d]", __func__, i);
+ } else {
+ mBufferHandle[i] = NULL;
+ mStride[i] = NULL;
+ }
+ }
+ }
+#endif
+ }
+ else
+ LOGV("%s : preview running but deferred, doing nothing", __func__);
+ } else
+ LOGI("%s : preview not running, doing nothing", __func__);
+}
+
+void CameraHardwareSec::stopPreview()
+{
+ LOGV("%s :", __func__);
+
+ /* request that the preview thread stop. */
+ mPreviewLock.lock();
+ stopPreviewInternal();
+ mPreviewLock.unlock();
+}
+
+bool CameraHardwareSec::previewEnabled()
+{
+ Mutex::Autolock lock(mPreviewLock);
+ LOGV("%s : %d", __func__, mPreviewRunning);
+ return mPreviewRunning;
+}
+
+status_t CameraHardwareSec::startRecording()
+{
+ LOGV("%s :", __func__);
+
+ Mutex::Autolock lock(mRecordLock);
+
+ for(int i = 0; i<BUFFER_COUNT_FOR_ARRAY; i++){
+ if (mRecordHeap[i] != NULL) {
+ mRecordHeap[i]->release(mRecordHeap[i]);
+ mRecordHeap[i] = 0;
+ }
+
+#ifdef BOARD_USE_V4L2_ION
+ int width, height;
+
+ mSecCamera->getRecordingSize(&width, &height);
+
+ mRecordHeap[i] = mGetMemoryCb(-1, (ALIGN((ALIGN(width, 16) * ALIGN(height, 16)), 2048) + ALIGN((ALIGN(width, 16) * ALIGN(height >> 1, 8)), 2048)), 1, NULL);
+
+ mSecCamera->setUserBufferAddr((void *)(mRecordHeap[i]->data), i, RECORD_MODE);
+#else
+ mRecordHeap[i] = mGetMemoryCb(-1, sizeof(struct addrs), MAX_BUFFERS, NULL);
+#endif
+ if (!mRecordHeap[i]) {
+ LOGE("ERR(%s): Record heap[%d] creation fail", __func__, i);
+ return UNKNOWN_ERROR;
+ }
+ }
+
+ LOGV("mRecordHeaps alloc done");
+
+ if (mRecordRunning == false) {
+ if (mSecCamera->startRecord(mRecordHint) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__);
+ return UNKNOWN_ERROR;
+ }
+ mRecordRunning = true;
+ }
+ return NO_ERROR;
+}
+
+void CameraHardwareSec::stopRecording()
+{
+ LOGV("%s :", __func__);
+
+ Mutex::Autolock lock(mRecordLock);
+
+ if (mRecordRunning == true) {
+ if (mSecCamera->stopRecord() < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__);
+ return;
+ }
+ mRecordRunning = false;
+ }
+}
+
+bool CameraHardwareSec::recordingEnabled()
+{
+ LOGV("%s :", __func__);
+ LOGV("%s : %d", __func__, mPreviewRunning);
+
+ return mRecordRunning;
+}
+
+void CameraHardwareSec::releaseRecordingFrame(const void *opaque)
+{
+#ifdef BOARD_USE_V4L2_ION
+ int i;
+ for (i = 0; i < MAX_BUFFERS; i++)
+ if ((char *)mRecordHeap[i]->data == (char *)opaque)
+ break;
+
+ mSecCamera->releaseRecordFrame(i);
+#else
+ struct addrs *addrs = (struct addrs *)opaque;
+ mSecCamera->releaseRecordFrame(addrs->buf_index);
+#endif
+}
+
+int CameraHardwareSec::autoFocusThread()
+{
+ int count =0;
+ int af_status =0 ;
+
+ LOGV("%s : starting", __func__);
+
+ /* block until we're told to start. we don't want to use
+ * a restartable thread and requestExitAndWait() in cancelAutoFocus()
+ * because it would cause deadlock between our callbacks and the
+ * caller of cancelAutoFocus() which both want to grab the same lock
+ * in CameraServices layer.
+ */
+ mFocusLock.lock();
+ /* check early exit request */
+ if (mExitAutoFocusThread) {
+ mFocusLock.unlock();
+ LOGV("%s : exiting on request0", __func__);
+ return NO_ERROR;
+ }
+ mFocusCondition.wait(mFocusLock);
+ /* check early exit request */
+ if (mExitAutoFocusThread) {
+ mFocusLock.unlock();
+ LOGV("%s : exiting on request1", __func__);
+ return NO_ERROR;
+ }
+ mFocusLock.unlock();
+
+ /* TODO : Currently only possible auto focus at BACK caemra
+ We need to modify to check that sensor can support auto focus */
+ if (mCameraID == SecCamera::CAMERA_ID_BACK) {
+ LOGV("%s : calling setAutoFocus", __func__);
+ if (mTouched == 0) {
+ if (mSecCamera->setAutofocus() < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__);
+ return UNKNOWN_ERROR;
+ }
+ } else {
+ if (mSecCamera->setTouchAF() < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__);
+ return UNKNOWN_ERROR;
+ }
+ }
+ }
+
+ /* TODO */
+ /* This is temperary implementation.
+ When camera support AF blocking mode, this code will be removed
+ Continous AutoFocus is not need to success */
+ const char *focusModeStr = mParameters.get(CameraParameters::KEY_FOCUS_MODE);
+ int isContinousAF = !strncmp(focusModeStr, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO, 7);
+ if (mUseInternalISP && !isContinousAF) {
+ int i, err = -1;
+ for (i = 0; i < 400; i++) {
+ usleep(10000);
+
+ af_status = mSecCamera->getAutoFocusResult();
+
+ if ((af_status & 0x2)) {
+ err = 0;
+ break;
+ }
+ }
+ } else {
+ af_status = mSecCamera->getAutoFocusResult();
+ }
+
+ if (af_status == 0x01) {
+ LOGV("%s : AF Cancelled !!", __func__);
+ if (mMsgEnabled & CAMERA_MSG_FOCUS)
+ mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
+ } else if (af_status == 0x02) {
+ LOGV("%s : AF Success !!", __func__);
+ if (mMsgEnabled & CAMERA_MSG_FOCUS) {
+ /* CAMERA_MSG_FOCUS only takes a bool. true for
+ * finished and false for failure. cancel is still
+ * considered a true result.
+ */
+ mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
+ }
+ } else {
+ LOGV("%s : AF Fail !!", __func__);
+ LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
+ if (mMsgEnabled & CAMERA_MSG_FOCUS)
+ mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
+ }
+
+ LOGV("%s : exiting with no error", __func__);
+ return NO_ERROR;
+}
+
+status_t CameraHardwareSec::autoFocus()
+{
+ LOGV("%s :", __func__);
+ /* signal autoFocusThread to run once */
+ mFocusCondition.signal();
+ return NO_ERROR;
+}
+
+status_t CameraHardwareSec::cancelAutoFocus()
+{
+ LOGV("%s :", __func__);
+
+ if (mSecCamera->cancelAutofocus() < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__);
+ return UNKNOWN_ERROR;
+ }
+
+ return NO_ERROR;
+}
+
+int CameraHardwareSec::save_jpeg( unsigned char *real_jpeg, int jpeg_size)
+{
+ FILE *yuv_fp = NULL;
+ char filename[100], *buffer = NULL;
+
+ /* file create/open, note to "wb" */
+ yuv_fp = fopen("/data/camera_dump.jpeg", "wb");
+ if (yuv_fp == NULL) {
+ LOGE("Save jpeg file open error");
+ return -1;
+ }
+
+ LOGV("[BestIQ] real_jpeg size ========> %d", jpeg_size);
+ buffer = (char *) malloc(jpeg_size);
+ if (buffer == NULL) {
+ LOGE("Save YUV] buffer alloc failed");
+ if (yuv_fp)
+ fclose(yuv_fp);
+
+ return -1;
+ }
+
+ memcpy(buffer, real_jpeg, jpeg_size);
+
+ fflush(stdout);
+
+ fwrite(buffer, 1, jpeg_size, yuv_fp);
+
+ fflush(yuv_fp);
+
+ if (yuv_fp)
+ fclose(yuv_fp);
+ if (buffer)
+ free(buffer);
+
+ return 0;
+}
+
+void CameraHardwareSec::save_postview(const char *fname, uint8_t *buf, uint32_t size)
+{
+ int nw;
+ int cnt = 0;
+ uint32_t written = 0;
+
+ LOGD("opening file [%s]", fname);
+ int fd = open(fname, O_RDWR | O_CREAT);
+ if (fd < 0) {
+ LOGE("failed to create file [%s]: %s", fname, strerror(errno));
+ return;
+ }
+
+ LOGD("writing %d bytes to file [%s]", size, fname);
+ while (written < size) {
+ nw = ::write(fd, buf + written, size - written);
+ if (nw < 0) {
+ LOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno));
+ break;
+ }
+ written += nw;
+ cnt++;
+ }
+ LOGD("done writing %d bytes to file [%s] in %d passes",size, fname, cnt);
+ ::close(fd);
+}
+
+bool CameraHardwareSec::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHeight,
+ char *dstBuf, uint32_t dstWidth, uint32_t dstHeight)
+{
+ 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 || dstHeight % 2 != 0) {
+ LOGE("scale_down_yuv422: invalid width, height for scaling");
+ return false;
+ }
+
+ step_x = srcWidth / dstWidth;
+ step_y = srcHeight / dstHeight;
+
+ dst_pos = 0;
+ for (uint32_t y = 0; y < dstHeight; 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;
+}
+
+bool CameraHardwareSec::YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight)
+{
+ int32_t x, y, src_y_start_pos, dst_cbcr_pos, dst_pos, src_pos;
+ unsigned char *srcBufPointer = (unsigned char *)srcBuf;
+ unsigned char *dstBufPointer = (unsigned char *)dstBuf;
+
+ dst_pos = 0;
+ dst_cbcr_pos = srcWidth*srcHeight;
+ for (uint32_t y = 0; y < srcHeight; y++) {
+ src_y_start_pos = (y * (srcWidth * 2));
+
+ for (uint32_t x = 0; x < (srcWidth * 2); x += 2) {
+ src_pos = src_y_start_pos + x;
+
+ dstBufPointer[dst_pos++] = srcBufPointer[src_pos];
+ }
+ }
+ for (uint32_t y = 0; y < srcHeight; y += 2) {
+ src_y_start_pos = (y * (srcWidth * 2));
+
+ for (uint32_t x = 0; x < (srcWidth * 2); x += 4) {
+ src_pos = src_y_start_pos + x;
+
+ dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 3];
+ dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 1];
+ }
+ }
+
+ return true;
+}
+
+int CameraHardwareSec::pictureThread()
+{
+ LOGV("%s :", __func__);
+
+ int jpeg_size = 0;
+ int ret = NO_ERROR;
+ unsigned char *jpeg_data = NULL;
+ int postview_offset = 0;
+ unsigned char *postview_data = NULL;
+
+ unsigned char *addr = NULL;
+ int mPostViewWidth, mPostViewHeight, mPostViewSize;
+ int mThumbWidth, mThumbHeight, mThumbSize;
+ int cap_width, cap_height, cap_frame_size;
+
+ int JpegImageSize = 0;
+
+ mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
+ mSecCamera->getThumbnailConfig(&mThumbWidth, &mThumbHeight, &mThumbSize);
+ int postviewHeapSize = mPostViewSize;
+ if (!mRecordRunning)
+ mSecCamera->getSnapshotSize(&cap_width, &cap_height, &cap_frame_size);
+ else
+ mSecCamera->getVideosnapshotSize(&cap_width, &cap_height, &cap_frame_size);
+ int mJpegHeapSize;
+ if (!mUseInternalISP)
+ mJpegHeapSize = cap_frame_size * SecCamera::getJpegRatio();
+ else
+ mJpegHeapSize = cap_frame_size;
+
+ LOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight);
+
+ camera_memory_t *JpegHeap = mGetMemoryCb(-1, mJpegHeapSize, 1, 0);
+#ifdef BOARD_USE_V4L2_ION
+#ifdef ZERO_SHUTTER_LAG
+ mThumbnailHeap = new MemoryHeapBaseIon(mThumbSize);
+#else
+ mPostviewHeap[mCapIndex] = new MemoryHeapBaseIon(mPostViewSize);
+ mThumbnailHeap = new MemoryHeapBaseIon(mThumbSize);
+#endif
+#else
+ mThumbnailHeap = new MemoryHeapBase(mThumbSize);
+#endif
+
+ if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
+ int picture_size, picture_width, picture_height;
+ mSecCamera->getSnapshotSize(&picture_width, &picture_height, &picture_size);
+ int picture_format = mSecCamera->getSnapshotPixelFormat();
+
+ unsigned int thumb_addr, phyAddr;
+
+ // Modified the shutter sound timing for Jpeg capture
+ if (!mUseInternalISP) {
+ mSecCamera->setSnapshotCmd();
+
+ if (mMsgEnabled & CAMERA_MSG_SHUTTER)
+ mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
+
+ jpeg_data = mSecCamera->getJpeg(&JpegImageSize, &mThumbSize, &thumb_addr, &phyAddr);
+ if (jpeg_data == NULL) {
+ LOGE("ERR(%s):Fail on SecCamera->getJpeg()", __func__);
+ ret = UNKNOWN_ERROR;
+ }
+
+ memcpy((unsigned char *)mThumbnailHeap->base(), (unsigned char *)thumb_addr, mThumbSize);
+ memcpy(JpegHeap->data, jpeg_data, JpegImageSize);
+ } else {
+ if (mMsgEnabled & CAMERA_MSG_SHUTTER)
+ mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
+
+#ifdef ZERO_SHUTTER_LAG
+ mSecCamera->getCaptureAddr(mCapIndex, &mCapBuffer);
+
+ if (mCapBuffer.virt.extP[0] == NULL) {
+ LOGE("ERR(%s):Fail on SecCamera getCaptureAddr = %0x ",
+ __func__, mCapBuffer.virt.extP[0]);
+ return UNKNOWN_ERROR;
+ }
+
+ scaleDownYuv422((char *)mCapBuffer.virt.extP[0], cap_width, cap_height,
+ (char *)mThumbnailHeap->base(), mThumbWidth, mThumbHeight);
+#else
+#ifdef BOARD_USE_V4L2_ION
+ mCapBuffer.virt.extP[0] = (char *)mPostviewHeap[mCapIndex]->base();
+#endif
+#endif
+
+ if (mSecCamera->getSnapshotAndJpeg(&mCapBuffer, mCapIndex,
+ (unsigned char*)JpegHeap->data, &JpegImageSize) < 0) {
+ mStateLock.lock();
+ mCaptureInProgress = false;
+ mStateLock.unlock();
+ JpegHeap->release(JpegHeap);
+ return UNKNOWN_ERROR;
+ }
+ LOGI("snapshotandjpeg done");
+
+#ifdef ZERO_SHUTTER_LAG
+ if (!mRecordRunning)
+ stopPreview();
+ memset(&mCapBuffer, 0, sizeof(struct SecBuffer));
+#else
+ scaleDownYuv422((char *)mCapBuffer.virt.extP[0], cap_width, cap_height,
+ (char *)mThumbnailHeap->base(), mThumbWidth, mThumbHeight);
+#endif
+ }
+ }
+
+#ifndef BOARD_USE_V4L2_ION
+ int rawHeapSize = cap_frame_size;
+ LOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize);
+#ifdef BOARD_USE_V4L2_ION
+ mRawHeap = mGetMemoryCb(mPostviewHeap[mCapIndex]->getHeapID(), rawHeapSize, 1, 0);
+#else
+ mRawHeap = mGetMemoryCb((int)mSecCamera->getCameraFd(SecCamera::PICTURE), rawHeapSize, 1, 0);
+#endif
+ if (!mRawHeap)
+ LOGE("ERR(%s): Raw heap creation fail", __func__);
+
+ if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE)
+ mDataCb(CAMERA_MSG_RAW_IMAGE, mRawHeap, 0, NULL, mCallbackCookie);
+#endif
+ mStateLock.lock();
+ mCaptureInProgress = false;
+ mStateLock.unlock();
+
+ if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
+ camera_memory_t *ExifHeap =
+ mGetMemoryCb(-1, EXIF_FILE_SIZE + mThumbSize, 1, 0);
+
+ int JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->data,
+ (unsigned char *)mThumbnailHeap->base(),
+ mThumbSize);
+ LOGV("JpegExifSize=%d", JpegExifSize);
+
+ if (JpegExifSize < 0) {
+ ret = UNKNOWN_ERROR;
+ goto out;
+ }
+
+ int mJpegHeapSize_out = JpegImageSize + JpegExifSize;
+ camera_memory_t *JpegHeap_out = mGetMemoryCb(-1, mJpegHeapSize_out, 1, 0);
+
+ unsigned char *ExifStart = (unsigned char *)JpegHeap_out->data + 2;
+ unsigned char *ImageStart = ExifStart + JpegExifSize;
+
+ memcpy(JpegHeap_out->data, JpegHeap->data, 2);
+ memcpy(ExifStart, ExifHeap->data, JpegExifSize);
+ memcpy(ImageStart, JpegHeap->data + 2, JpegImageSize - 2);
+
+ mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, JpegHeap_out, 0, NULL, mCallbackCookie);
+
+ if (ExifHeap) {
+ ExifHeap->release(ExifHeap);
+ ExifHeap = 0;
+ }
+
+ if (JpegHeap_out) {
+ JpegHeap_out->release(JpegHeap_out);
+ JpegHeap_out = 0;
+ }
+ }
+
+ LOGV("%s : pictureThread end", __func__);
+
+out:
+ if (JpegHeap) {
+ JpegHeap->release(JpegHeap);
+ JpegHeap = 0;
+ }
+
+ if (mRawHeap) {
+ mRawHeap->release(mRawHeap);
+ mRawHeap = 0;
+ }
+
+ if (!mUseInternalISP && !mRecordRunning)
+ mSecCamera->endSnapshot();
+
+ return ret;
+}
+
+status_t CameraHardwareSec::takePicture()
+{
+ LOGV("%s :", __func__);
+
+#ifdef ZERO_SHUTTER_LAG
+ if (!mUseInternalISP) {
+ stopPreview();
+ }
+#else
+ stopPreview();
+#endif
+
+ Mutex::Autolock lock(mStateLock);
+ if (mCaptureInProgress) {
+ LOGE("%s : capture already in progress", __func__);
+ return INVALID_OPERATION;
+ }
+
+ if (mPictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
+ LOGE("%s : couldn't run picture thread", __func__);
+ return INVALID_OPERATION;
+ }
+ mCaptureInProgress = true;
+
+ return NO_ERROR;
+}
+
+status_t CameraHardwareSec::cancelPicture()
+{
+ LOGV("%s", __func__);
+
+ if (mPictureThread.get()) {
+ LOGV("%s: waiting for picture thread to exit", __func__);
+ mPictureThread->requestExitAndWait();
+ LOGV("%s: picture thread has exited", __func__);
+ }
+
+ return NO_ERROR;
+}
+
+bool CameraHardwareSec::CheckVideoStartMarker(unsigned char *pBuf)
+{
+ if (!pBuf) {
+ LOGE("CheckVideoStartMarker() => pBuf is NULL");
+ return false;
+ }
+
+ if (HIBYTE(VIDEO_COMMENT_MARKER_H) == * pBuf && LOBYTE(VIDEO_COMMENT_MARKER_H) == *(pBuf + 1) &&
+ HIBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 2) && LOBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 3))
+ return true;
+
+ return false;
+}
+
+bool CameraHardwareSec::CheckEOIMarker(unsigned char *pBuf)
+{
+ if (!pBuf) {
+ LOGE("CheckEOIMarker() => pBuf is NULL");
+ return false;
+ }
+
+ // EOI marker [FF D9]
+ if (HIBYTE(JPEG_EOI_MARKER) == *pBuf && LOBYTE(JPEG_EOI_MARKER) == *(pBuf + 1))
+ return true;
+
+ return false;
+}
+
+bool CameraHardwareSec::FindEOIMarkerInJPEG(unsigned char *pBuf, int dwBufSize, int *pnJPEGsize)
+{
+ if (NULL == pBuf || 0 >= dwBufSize) {
+ LOGE("FindEOIMarkerInJPEG() => There is no contents.");
+ return false;
+ }
+
+ unsigned char *pBufEnd = pBuf + dwBufSize;
+
+ while (pBuf < pBufEnd) {
+ if (CheckEOIMarker(pBuf++))
+ return true;
+
+ (*pnJPEGsize)++;
+ }
+
+ return false;
+}
+
+bool CameraHardwareSec::SplitFrame(unsigned char *pFrame, int dwSize,
+ int dwJPEGLineLength, int dwVideoLineLength, int dwVideoHeight,
+ void *pJPEG, int *pdwJPEGSize,
+ void *pVideo, int *pdwVideoSize)
+{
+ LOGV("===========SplitFrame Start==============");
+
+ if (NULL == pFrame || 0 >= dwSize) {
+ LOGE("There is no contents (pFrame=%p, dwSize=%d", pFrame, dwSize);
+ return false;
+ }
+
+ if (0 == dwJPEGLineLength || 0 == dwVideoLineLength) {
+ LOGE("There in no input information for decoding interleaved jpeg");
+ return false;
+ }
+
+ unsigned char *pSrc = pFrame;
+ unsigned char *pSrcEnd = pFrame + dwSize;
+
+ unsigned char *pJ = (unsigned char *)pJPEG;
+ int dwJSize = 0;
+ unsigned char *pV = (unsigned char *)pVideo;
+ int dwVSize = 0;
+
+ bool bRet = false;
+ bool isFinishJpeg = false;
+
+ while (pSrc < pSrcEnd) {
+ // Check video start marker
+ if (CheckVideoStartMarker(pSrc)) {
+ int copyLength;
+
+ if (pSrc + dwVideoLineLength <= pSrcEnd)
+ copyLength = dwVideoLineLength;
+ else
+ copyLength = pSrcEnd - pSrc - VIDEO_COMMENT_MARKER_LENGTH;
+
+ // Copy video data
+ if (pV) {
+ memcpy(pV, pSrc + VIDEO_COMMENT_MARKER_LENGTH, copyLength);
+ pV += copyLength;
+ dwVSize += copyLength;
+ }
+
+ pSrc += copyLength + VIDEO_COMMENT_MARKER_LENGTH;
+ } else {
+ // Copy pure JPEG data
+ int size = 0;
+ int dwCopyBufLen = dwJPEGLineLength <= pSrcEnd-pSrc ? dwJPEGLineLength : pSrcEnd - pSrc;
+
+ if (FindEOIMarkerInJPEG((unsigned char *)pSrc, dwCopyBufLen, &size)) {
+ isFinishJpeg = true;
+ size += 2; // to count EOF marker size
+ } else {
+ if ((dwCopyBufLen == 1) && (pJPEG < pJ)) {
+ unsigned char checkBuf[2] = { *(pJ - 1), *pSrc };
+
+ if (CheckEOIMarker(checkBuf))
+ isFinishJpeg = true;
+ }
+ size = dwCopyBufLen;
+ }
+
+ memcpy(pJ, pSrc, size);
+
+ dwJSize += size;
+
+ pJ += dwCopyBufLen;
+ pSrc += dwCopyBufLen;
+ }
+ if (isFinishJpeg)
+ break;
+ }
+
+ if (isFinishJpeg) {
+ bRet = true;
+ if (pdwJPEGSize)
+ *pdwJPEGSize = dwJSize;
+ if (pdwVideoSize)
+ *pdwVideoSize = dwVSize;
+ } else {
+ LOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI");
+ bRet = false;
+ if (pdwJPEGSize)
+ *pdwJPEGSize = 0;
+ if (pdwVideoSize)
+ *pdwVideoSize = 0;
+ }
+ LOGV("===========SplitFrame end==============");
+
+ return bRet;
+}
+
+int CameraHardwareSec::decodeInterleaveData(unsigned char *pInterleaveData,
+ int interleaveDataSize,
+ int yuvWidth,
+ int yuvHeight,
+ int *pJpegSize,
+ void *pJpegData,
+ void *pYuvData)
+{
+ if (pInterleaveData == NULL)
+ return false;
+
+ bool ret = true;
+ unsigned int *interleave_ptr = (unsigned int *)pInterleaveData;
+ unsigned char *jpeg_ptr = (unsigned char *)pJpegData;
+ unsigned char *yuv_ptr = (unsigned char *)pYuvData;
+ unsigned char *p;
+ int jpeg_size = 0;
+ int yuv_size = 0;
+
+ int i = 0;
+
+ LOGV("decodeInterleaveData Start~~~");
+ while (i < interleaveDataSize) {
+ if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) ||
+ (*interleave_ptr == 0xFF02FFFF)) {
+ // Padding Data
+ interleave_ptr++;
+ i += 4;
+ } else if ((*interleave_ptr & 0xFFFF) == 0x05FF) {
+ // Start-code of YUV Data
+ p = (unsigned char *)interleave_ptr;
+ p += 2;
+ i += 2;
+
+ // Extract YUV Data
+ if (pYuvData != NULL) {
+ memcpy(yuv_ptr, p, yuvWidth * 2);
+ yuv_ptr += yuvWidth * 2;
+ yuv_size += yuvWidth * 2;
+ }
+ p += yuvWidth * 2;
+ i += yuvWidth * 2;
+
+ // Check End-code of YUV Data
+ if ((*p == 0xFF) && (*(p + 1) == 0x06)) {
+ interleave_ptr = (unsigned int *)(p + 2);
+ i += 2;
+ } else {
+ ret = false;
+ break;
+ }
+ } else {
+ // Extract JPEG Data
+ if (pJpegData != NULL) {
+ memcpy(jpeg_ptr, interleave_ptr, 4);
+ jpeg_ptr += 4;
+ jpeg_size += 4;
+ }
+ interleave_ptr++;
+ i += 4;
+ }
+ }
+ if (ret) {
+ if (pJpegData != NULL) {
+ // Remove Padding after EOI
+ for (i = 0; i < 3; i++) {
+ if (*(--jpeg_ptr) != 0xFF) {
+ break;
+ }
+ jpeg_size--;
+ }
+ *pJpegSize = jpeg_size;
+
+ }
+ // Check YUV Data Size
+ if (pYuvData != NULL) {
+ if (yuv_size != (yuvWidth * yuvHeight * 2)) {
+ ret = false;
+ }
+ }
+ }
+ LOGV("decodeInterleaveData End~~~");
+ return ret;
+}
+
+status_t CameraHardwareSec::dump(int fd) const
+{
+ const size_t SIZE = 256;
+ char buffer[SIZE];
+ String8 result;
+ const Vector<String16> args;
+
+ if (mSecCamera != 0) {
+ mSecCamera->dump(fd);
+ mParameters.dump(fd, args);
+ mInternalParameters.dump(fd, args);
+ snprintf(buffer, 255, " preview running(%s)\n", mPreviewRunning?"true": "false");
+ result.append(buffer);
+ } else
+ result.append("No camera client yet.\n");
+ write(fd, result.string(), result.size());
+ return NO_ERROR;
+}
+
+bool CameraHardwareSec::isSupportedPreviewSize(const int width,
+ const int height) const
+{
+ unsigned int i;
+
+ for (i = 0; i < mSupportedPreviewSizes.size(); i++) {
+ if (mSupportedPreviewSizes[i].width == width &&
+ mSupportedPreviewSizes[i].height == height)
+ return true;
+ }
+
+ return false;
+}
+
+bool CameraHardwareSec::getVideosnapshotSize(int *width, int *height)
+{
+ unsigned int i;
+ Vector<Size> pictureSizes, videoSizes;
+ int ratio = FRM_RATIO(*width, *height);
+
+ mParameters.getSupportedPictureSizes(pictureSizes);
+ mParameters.getSupportedVideoSizes(videoSizes);
+
+ for (i = 0; i < pictureSizes.size(); i++) {
+ if (FRM_RATIO(pictureSizes[i].width, pictureSizes[i].height) == ratio) {
+ if (mRecordHint) {
+ if (pictureSizes[i].width <= videoSizes[0].width) {
+ *width = pictureSizes[i].width;
+ *height = pictureSizes[i].height;
+ LOGV("%s(width(%d), height(%d))", __func__, *width, *height);
+ return true;
+ }
+ } else {
+ *width = pictureSizes[i].width;
+ *height = pictureSizes[i].height;
+ LOGV("%s(width(%d), height(%d))", __func__, *width, *height);
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+status_t CameraHardwareSec::setParameters(const CameraParameters& params)
+{
+ LOGV("%s :", __func__);
+
+ status_t ret = NO_ERROR;
+
+ const char *new_record_hint_str = params.get(CameraParameters::KEY_RECORDING_HINT);
+ const char *curr_record_hint_str = mParameters.get(CameraParameters::KEY_RECORDING_HINT);
+ LOGV("new_record_hint_str: %s", new_record_hint_str);
+
+ if (new_record_hint_str) {
+ if (strncmp(new_record_hint_str, curr_record_hint_str, 5)) {
+ mRecordHint = !strncmp(new_record_hint_str, "true", 4);
+ if (mSecCamera->setMode(mRecordHint) < 0) {
+ LOGE("ERR(%s):fail on mSecCamera->setMode(%d)", __func__, mRecordHint);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_RECORDING_HINT, new_record_hint_str);
+ }
+
+ if (mUseInternalISP) {
+ if (mSecCamera->initSetParams() < 0) {
+ LOGE("ERR(%s):fail on mSecCamera->initSetParams()", __func__);
+ ret = UNKNOWN_ERROR;
+ }
+ }
+ }
+ }
+
+ /* if someone calls us while picture thread is running, it could screw
+ * up the sensor quite a bit so return error. we can't wait because
+ * that would cause deadlock with the callbacks
+ */
+ mStateLock.lock();
+ if (mCaptureInProgress) {
+ mStateLock.unlock();
+ LOGE("%s : capture in progress, not allowed", __func__);
+ return UNKNOWN_ERROR;
+ }
+ mStateLock.unlock();
+
+ // preview size
+ int new_preview_width = 0;
+ int new_preview_height = 0;
+ int new_preview_format = 0;
+
+ params.getPreviewSize(&new_preview_width, &new_preview_height);
+
+ if (mUseInternalISP) {
+ int videosnapshot_width = new_preview_width;
+ int videosnapshot_height = new_preview_height;
+
+ if (!getVideosnapshotSize(&videosnapshot_width, &videosnapshot_height)) {
+ LOGE("ERR(%s):fail on getVideosnapshotSize(width(%d), height(%d))",
+ __func__, videosnapshot_width, videosnapshot_height);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (mSecCamera->setVideosnapshotSize(videosnapshot_width, videosnapshot_height) < 0) {
+ LOGE("ERR(%s):fail on mSecCamera->setVideosnapshotSize(width(%d), height(%d))",
+ __func__, videosnapshot_width, videosnapshot_height);
+ ret = UNKNOWN_ERROR;
+ }
+ }
+
+ const char *new_str_preview_format = params.getPreviewFormat();
+ LOGV("%s : new_preview_width x new_preview_height = %dx%d, format = %s",
+ __func__, new_preview_width, new_preview_height, new_str_preview_format);
+
+ if (0 < new_preview_width && 0 < new_preview_height &&
+ new_str_preview_format != NULL &&
+ isSupportedPreviewSize(new_preview_width, new_preview_height)) {
+
+ mFrameSizeDelta = 16;
+ if (!strcmp(new_str_preview_format,
+ CameraParameters::PIXEL_FORMAT_RGB565)) {
+ new_preview_format = V4L2_PIX_FMT_RGB565;
+ mFrameSizeDelta = 0;
+ }
+ else if (!strcmp(new_str_preview_format,
+ CameraParameters::PIXEL_FORMAT_RGBA8888)) {
+ new_preview_format = V4L2_PIX_FMT_RGB32;
+ mFrameSizeDelta = 0;
+ }
+ else if (!strcmp(new_str_preview_format,
+ CameraParameters::PIXEL_FORMAT_YUV420SP)) {
+ new_preview_format = V4L2_PIX_FMT_NV21;
+ mPreviewFmtPlane = PREVIEW_FMT_2_PLANE;
+ }
+ else if (!strcmp(new_str_preview_format,
+ CameraParameters::PIXEL_FORMAT_YUV420P)) {
+#ifdef BOARD_USE_V4L2_ION
+ new_preview_format = V4L2_PIX_FMT_YVU420M;
+#else
+ new_preview_format = V4L2_PIX_FMT_YVU420;
+#endif
+ mPreviewFmtPlane = PREVIEW_FMT_3_PLANE;
+ }
+ else if (!strcmp(new_str_preview_format, "yuv420sp_custom"))
+ new_preview_format = V4L2_PIX_FMT_NV12T;
+ else if (!strcmp(new_str_preview_format, "yuv422i"))
+ new_preview_format = V4L2_PIX_FMT_YUYV;
+ else if (!strcmp(new_str_preview_format, "yuv422p"))
+ new_preview_format = V4L2_PIX_FMT_YUV422P;
+ else
+ new_preview_format = V4L2_PIX_FMT_NV21; //for 3rd party
+
+ int current_preview_width, current_preview_height, current_frame_size;
+ mSecCamera->getPreviewSize(¤t_preview_width,
+ ¤t_preview_height,
+ ¤t_frame_size);
+ int current_pixel_format = mSecCamera->getPreviewPixelFormat();
+
+ if (current_preview_width != new_preview_width ||
+ current_preview_height != new_preview_height ||
+ current_pixel_format != new_preview_format) {
+ if (mSecCamera->setPreviewSize(new_preview_width, new_preview_height,
+ new_preview_format) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))",
+ __func__, new_preview_width, new_preview_height, new_preview_format);
+ ret = UNKNOWN_ERROR;
+ } else {
+ if (mPreviewWindow) {
+ if (mPreviewRunning && !mPreviewStartDeferred) {
+ LOGE("ERR(%s): preview is running, cannot change size and format!", __func__);
+ ret = INVALID_OPERATION;
+ }
+ LOGV("%s: mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow);
+ LOGV("%s: mPreviewWindow->set_buffers_geometry (%p)", __func__,
+ mPreviewWindow->set_buffers_geometry);
+ mPreviewWindow->set_buffers_geometry(mPreviewWindow,
+ new_preview_width, new_preview_height,
+ V4L2_PIX_2_HAL_PIXEL_FORMAT(new_preview_format));
+ LOGV("%s: DONE mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow);
+ }
+ mParameters.setPreviewSize(new_preview_width, new_preview_height);
+ mParameters.setPreviewFormat(new_str_preview_format);
+ }
+ }
+ } else {
+ LOGE("%s: Invalid preview size(%dx%d)",
+ __func__, new_preview_width, new_preview_height);
+
+ ret = INVALID_OPERATION;
+ }
+
+ // picture size
+ int new_picture_width = 0;
+ int new_picture_height = 0;
+
+ params.getPictureSize(&new_picture_width, &new_picture_height);
+ LOGV("%s : new_picture_width x new_picture_height = %dx%d", __func__, new_picture_width, new_picture_height);
+
+ int current_picture_width, current_picture_height, current_picture_size;
+ mSecCamera->getSnapshotSize(¤t_picture_width, ¤t_picture_height, ¤t_picture_size);
+
+ if (new_picture_width != current_picture_width ||
+ new_picture_height != current_picture_height) {
+ if (mSecCamera->setSnapshotSize(new_picture_width, new_picture_height) < 0) {
+ LOGE("ERR(%s):fail on mSecCamera->setSnapshotSize(width(%d), height(%d))",
+ __func__, new_picture_width, new_picture_height);
+ ret = UNKNOWN_ERROR;
+ } else {
+#ifdef ZERO_SHUTTER_LAG
+ mSecCamera->stopSnapshot();
+ if (mUseInternalISP && !mRecordHint && mPreviewRunning){
+ mSecCamera->startSnapshot(NULL);
+ }
+#endif
+ mParameters.setPictureSize(new_picture_width, new_picture_height);
+ }
+ }
+
+ // picture format
+ const char *new_str_picture_format = params.getPictureFormat();
+ LOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format);
+ if (new_str_picture_format != NULL) {
+ int new_picture_format = 0;
+
+ if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGB565))
+ new_picture_format = V4L2_PIX_FMT_RGB565;
+ else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGBA8888))
+ new_picture_format = V4L2_PIX_FMT_RGB32;
+ else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_YUV420SP))
+ new_picture_format = V4L2_PIX_FMT_NV21;
+ else if (!strcmp(new_str_picture_format, "yuv420sp_custom"))
+ new_picture_format = V4L2_PIX_FMT_NV12T;
+ else if (!strcmp(new_str_picture_format, "yuv420p"))
+ new_picture_format = V4L2_PIX_FMT_YUV420;
+ else if (!strcmp(new_str_picture_format, "yuv422i"))
+ new_picture_format = V4L2_PIX_FMT_YUYV;
+ else if (!strcmp(new_str_picture_format, "uyv422i_custom")) //Zero copy UYVY format
+ new_picture_format = V4L2_PIX_FMT_UYVY;
+ else if (!strcmp(new_str_picture_format, "uyv422i")) //Non-zero copy UYVY format
+ new_picture_format = V4L2_PIX_FMT_UYVY;
+ else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_JPEG))
+ new_picture_format = V4L2_PIX_FMT_YUYV;
+ else if (!strcmp(new_str_picture_format, "yuv422p"))
+ new_picture_format = V4L2_PIX_FMT_YUV422P;
+ else
+ new_picture_format = V4L2_PIX_FMT_NV21; //for 3rd party
+
+ if (mSecCamera->setSnapshotPixelFormat(new_picture_format) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format);
+ ret = UNKNOWN_ERROR;
+ } else
+ mParameters.setPictureFormat(new_str_picture_format);
+ }
+
+ // JPEG image quality
+ int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
+ LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
+ /* we ignore bad values */
+ if (new_jpeg_quality >=1 && new_jpeg_quality <= 100) {
+ if (mSecCamera->setJpegQuality(new_jpeg_quality) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality);
+ ret = UNKNOWN_ERROR;
+ } else
+ mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality);
+ }
+
+ // JPEG thumbnail size
+ int new_jpeg_thumbnail_width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
+ int new_jpeg_thumbnail_height= params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
+ if (0 <= new_jpeg_thumbnail_width && 0 <= new_jpeg_thumbnail_height) {
+ if (mSecCamera->setJpegThumbnailSize(new_jpeg_thumbnail_width, new_jpeg_thumbnail_height) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, new_jpeg_thumbnail_width);
+ mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, new_jpeg_thumbnail_height);
+ }
+ }
+
+ // JPEG thumbnail quality
+ int new_jpeg_thumbnail_quality = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
+ LOGV("%s : new_jpeg_thumbnail_quality %d", __func__, new_jpeg_thumbnail_quality);
+ /* we ignore bad values */
+ if (new_jpeg_thumbnail_quality >=1 && new_jpeg_thumbnail_quality <= 100) {
+ if (mSecCamera->setJpegThumbnailQuality(new_jpeg_thumbnail_quality) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailQuality(quality(%d))",
+ __func__, new_jpeg_thumbnail_quality);
+ ret = UNKNOWN_ERROR;
+ } else
+ mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, new_jpeg_thumbnail_quality);
+ }
+
+ // frame rate
+ int new_frame_rate = params.getPreviewFrameRate();
+ /* ignore any fps request, we're determine fps automatically based
+ * on scene mode. don't return an error because it causes CTS failure.
+ */
+ if (mRecordHint) {
+ if (new_frame_rate) {
+ if (mUseInternalISP && (mSecCamera->setFrameRate(new_frame_rate) < 0)){
+ LOGE("ERR(%s):Fail on mSecCamera->setFrameRate(%d)", __func__, new_frame_rate);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.setPreviewFrameRate(new_frame_rate);
+ }
+ }
+ }
+
+ // rotation
+ int new_rotation = params.getInt(CameraParameters::KEY_ROTATION);
+ LOGV("%s : new_rotation %d", __func__, new_rotation);
+ if (0 <= new_rotation) {
+ LOGV("%s : set orientation:%d", __func__, new_rotation);
+ if (mSecCamera->setExifOrientationInfo(new_rotation) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation);
+ ret = UNKNOWN_ERROR;
+ } else
+ mParameters.set(CameraParameters::KEY_ROTATION, new_rotation);
+ }
+
+ // zoom
+ int new_zoom = params.getInt(CameraParameters::KEY_ZOOM);
+ int current_zoom = mParameters.getInt(CameraParameters::KEY_ZOOM);
+ LOGV("%s : new_zoom %d", __func__, new_zoom);
+ if (0 <= new_zoom) {
+ if (new_zoom != current_zoom) {
+ if (mSecCamera->setZoom(new_zoom) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setZoom(zoom(%d))", __func__, new_zoom);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_ZOOM, new_zoom);
+ }
+ }
+ }
+
+ // brightness
+ int new_brightness = params.getInt("brightness");
+ int max_brightness = params.getInt("brightness-max");
+ int min_brightness = params.getInt("brightness-min");
+ LOGV("%s : new_brightness %d", __func__, new_brightness);
+ if ((min_brightness <= new_brightness) &&
+ (max_brightness >= new_brightness)) {
+ if (mSecCamera->setBrightness(new_brightness) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_brightness);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set("brightness", new_brightness);
+ }
+ }
+
+ // saturation
+ int new_saturation = params.getInt("saturation");
+ int max_saturation = params.getInt("saturation-max");
+ int min_saturation = params.getInt("saturation-min");
+ LOGV("%s : new_saturation %d", __func__, new_saturation);
+ if ((min_saturation <= new_saturation) &&
+ (max_saturation >= new_saturation)) {
+ if (mSecCamera->setSaturation(new_saturation) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setSaturation(saturation(%d))", __func__, new_saturation);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set("saturation", new_saturation);
+ }
+ }
+
+ // sharpness
+ int new_sharpness = params.getInt("sharpness");
+ int max_sharpness = params.getInt("sharpness-max");
+ int min_sharpness = params.getInt("sharpness-min");
+ LOGV("%s : new_sharpness %d", __func__, new_sharpness);
+ if ((min_sharpness <= new_sharpness) &&
+ (max_sharpness >= new_sharpness)) {
+ if (mSecCamera->setSharpness(new_sharpness) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setSharpness(sharpness(%d))", __func__, new_sharpness);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set("sharpness", new_sharpness);
+ }
+ }
+
+ // hue
+ int new_hue = params.getInt("hue");
+ int max_hue = params.getInt("hue-max");
+ int min_hue = params.getInt("hue-min");
+ LOGV("%s : new_hue %d", __func__, new_hue);
+ if ((min_hue <= new_hue) &&
+ (max_hue >= new_hue)) {
+ if (mSecCamera->setHue(new_hue) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setHue(hue(%d))", __func__, new_hue);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set("hue", new_hue);
+ }
+ }
+
+ // exposure
+ int new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
+ int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
+ int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
+ LOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation);
+ if ((min_exposure_compensation <= new_exposure_compensation) &&
+ (max_exposure_compensation >= new_exposure_compensation)) {
+ if (mSecCamera->setExposure(new_exposure_compensation) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setExposure(exposure(%d))", __func__, new_exposure_compensation);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, new_exposure_compensation);
+ }
+ }
+
+ const char *new_AE_lock = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
+ const char *old_AE_lock = mParameters.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
+ if ((new_AE_lock != NULL) && mUseInternalISP && mPreviewRunning) {
+ if (strncmp(new_AE_lock, old_AE_lock, 4)) {
+ int ae_value = !strncmp(new_AE_lock, "true", 4);
+ if (mSecCamera->setAutoExposureLock(ae_value) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setExposureLock", __func__);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, new_AE_lock);
+ }
+ }
+ }
+
+ // ISO
+ const char *new_iso_str = params.get("iso");
+ LOGV("%s : new_iso_str %s", __func__, new_iso_str);
+ if (new_iso_str != NULL) {
+ int new_iso = -1;
+
+ if (!strcmp(new_iso_str, "auto")) {
+ new_iso = ISO_AUTO;
+ } else if (!strcmp(new_iso_str, "50")) {
+ new_iso = ISO_50;
+ } else if (!strcmp(new_iso_str, "100")) {
+ new_iso = ISO_100;
+ } else if (!strcmp(new_iso_str, "200")) {
+ new_iso = ISO_200;
+ } else if (!strcmp(new_iso_str, "400")) {
+ new_iso = ISO_400;
+ } else if (!strcmp(new_iso_str, "800")) {
+ new_iso = ISO_800;
+ } else if (!strcmp(new_iso_str, "1600")) {
+ new_iso = ISO_1600;
+ } else {
+ LOGE("ERR(%s):Invalid iso value(%s)", __func__, new_iso_str);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (0 <= new_iso) {
+ if (mSecCamera->setISO(new_iso) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setISO(iso(%d))", __func__, new_iso);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set("iso", new_iso_str);
+ }
+ }
+ }
+
+ // Metering
+ const char *new_metering_str = params.get("metering");
+ LOGV("%s : new_metering_str %s", __func__, new_metering_str);
+ if (new_metering_str != NULL) {
+ int new_metering = -1;
+
+ if (!strcmp(new_metering_str, "center")) {
+ new_metering = METERING_CENTER;
+ } else if (!strcmp(new_metering_str, "spot")) {
+ new_metering = METERING_SPOT;
+ } else if (!strcmp(new_metering_str, "matrix")) {
+ new_metering = METERING_MATRIX;
+ } else {
+ LOGE("ERR(%s):Invalid metering value(%s)", __func__, new_metering_str);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (0 <= new_metering) {
+ if (mSecCamera->setMetering(new_metering) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setMetering(metering(%d))", __func__, new_metering);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set("metering", new_metering_str);
+ }
+ }
+ }
+
+ // AFC
+ const char *new_antibanding_str = params.get(CameraParameters::KEY_ANTIBANDING);
+ LOGV("%s : new_antibanding_str %s", __func__, new_antibanding_str);
+ if (new_antibanding_str != NULL) {
+ int new_antibanding = -1;
+
+ if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_AUTO)) {
+ if (mUseInternalISP)
+ new_antibanding = IS_AFC_AUTO;
+ else
+ new_antibanding = ANTI_BANDING_AUTO;
+ } else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_50HZ)) {
+ if (mUseInternalISP)
+ new_antibanding = IS_AFC_MANUAL_50HZ;
+ else
+ new_antibanding = ANTI_BANDING_50HZ;
+ } else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_60HZ)) {
+ if (mUseInternalISP)
+ new_antibanding = IS_AFC_MANUAL_60HZ;
+ else
+ new_antibanding = ANTI_BANDING_60HZ;
+ } else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_OFF)) {
+ if (mUseInternalISP)
+ new_antibanding = IS_AFC_DISABLE;
+ else
+ new_antibanding = ANTI_BANDING_OFF;
+ } else {
+ LOGE("ERR(%s):Invalid antibanding value(%s)", __func__, new_antibanding_str);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (0 <= new_antibanding) {
+ if (mSecCamera->setAntiBanding(new_antibanding) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setAntiBanding(antibanding(%d))", __func__, new_antibanding);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_ANTIBANDING, new_antibanding_str);
+ }
+ }
+ }
+
+ // scene mode
+ const char *new_scene_mode_str = params.get(CameraParameters::KEY_SCENE_MODE);
+ const char *current_scene_mode_str = mParameters.get(CameraParameters::KEY_SCENE_MODE);
+
+ // fps range
+ int new_min_fps = 0;
+ int new_max_fps = 0;
+ int current_min_fps, current_max_fps;
+ params.getPreviewFpsRange(&new_min_fps, &new_max_fps);
+ mParameters.getPreviewFpsRange(¤t_min_fps, ¤t_max_fps);
+ /* our fps range is determined by the sensor, reject any request
+ * that isn't exactly what we're already at.
+ * but the check is performed when requesting only changing fps range
+ */
+ if (new_scene_mode_str && current_scene_mode_str) {
+ if (!strcmp(new_scene_mode_str, current_scene_mode_str)) {
+ if ((new_min_fps != current_min_fps) || (new_max_fps != current_max_fps)) {
+ LOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed",
+ __func__, new_min_fps, new_max_fps);
+ /* TODO : We need policy for fps. */
+ LOGW("%s : current_min_fps = %d, current_max_fps = %d",
+ __func__, current_min_fps, current_max_fps);
+ //ret = UNKNOWN_ERROR;
+ }
+ }
+ } else {
+ /* Check basic validation if scene mode is different */
+ if ((new_min_fps > new_max_fps) ||
+ (new_min_fps < 0) || (new_max_fps < 0))
+ ret = UNKNOWN_ERROR;
+ }
+
+ const char *new_flash_mode_str = params.get(CameraParameters::KEY_FLASH_MODE);
+ const char *new_focus_mode_str = params.get(CameraParameters::KEY_FOCUS_MODE);
+ const char *new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE);
+
+ // fps range is (15000,30000) by default.
+ mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
+ mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000");
+
+ if ((new_scene_mode_str != NULL) && (current_scene_mode_str != NULL) && strncmp(new_scene_mode_str, current_scene_mode_str, 5)) {
+ int new_scene_mode = -1;
+ if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) {
+ new_scene_mode = SCENE_MODE_NONE;
+ } else {
+ // defaults for non-auto scene modes
+ new_focus_mode_str = CameraParameters::FOCUS_MODE_AUTO;
+ new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
+ new_white_str = CameraParameters::WHITE_BALANCE_AUTO;
+ mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str);
+
+ if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_PORTRAIT)) {
+ new_scene_mode = SCENE_MODE_PORTRAIT;
+ if (mCameraID == SecCamera::CAMERA_ID_BACK)
+ new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO;
+ } else if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_LANDSCAPE)) {
+ new_scene_mode = SCENE_MODE_LANDSCAPE;
+ } else if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_SPORTS)) {
+ new_scene_mode = SCENE_MODE_SPORTS;
+ } else if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_PARTY)) {
+ new_scene_mode = SCENE_MODE_PARTY_INDOOR;
+ if (mCameraID == SecCamera::CAMERA_ID_BACK)
+ new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO;
+ } else if ((!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_BEACH)) ||
+ (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_SNOW))) {
+ new_scene_mode = SCENE_MODE_BEACH_SNOW;
+ } else if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_SUNSET)) {
+ new_scene_mode = SCENE_MODE_SUNSET;
+ } else if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_NIGHT)) {
+ new_scene_mode = SCENE_MODE_NIGHTSHOT;
+ mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(4000,30000)");
+ mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "4000,30000");
+ } else if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_FIREWORKS)) {
+ new_scene_mode = SCENE_MODE_FIREWORKS;
+ } else if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_CANDLELIGHT)) {
+ new_scene_mode = SCENE_MODE_CANDLE_LIGHT;
+ } else {
+ LOGE("%s::unmatched scene_mode(%s)",
+ __func__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto
+ ret = UNKNOWN_ERROR;
+ }
+ }
+
+ if (0 <= new_scene_mode) {
+ if (mSecCamera->setSceneMode(new_scene_mode) < 0) {
+ LOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_SCENE_MODE, new_scene_mode_str);
+ }
+ }
+ }
+
+ // focus mode
+ /* TODO : currently only posible focus modes at BACK camera */
+ if ((new_focus_mode_str != NULL) && (mCameraID == SecCamera::CAMERA_ID_BACK)) {
+ int new_focus_mode = -1;
+
+ if (!strcmp(new_focus_mode_str,
+ CameraParameters::FOCUS_MODE_AUTO)) {
+ new_focus_mode = FOCUS_MODE_AUTO;
+ mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
+ BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
+ } else if (!strcmp(new_focus_mode_str,
+ CameraParameters::FOCUS_MODE_MACRO)) {
+ new_focus_mode = FOCUS_MODE_MACRO;
+ mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
+ BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR);
+ } else if (!strcmp(new_focus_mode_str,
+ CameraParameters::FOCUS_MODE_INFINITY)) {
+ new_focus_mode = FOCUS_MODE_INFINITY;
+ mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
+ BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR);
+ } else if (!strcmp(new_focus_mode_str,
+ CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ||
+ !strcmp(new_focus_mode_str,
+ CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)) {
+ new_focus_mode = FOCUS_MODE_CONTINOUS;
+ } else {
+ /* TODO */
+ /* This is temperary implementation.
+ When camera support all AF mode, this code will be changing */
+ LOGE("%s::unmatched focus_mode(%s)", __func__, new_focus_mode_str);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (0 <= new_focus_mode) {
+ if (mSecCamera->setFocusMode(new_focus_mode) < 0) {
+ LOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_FOCUS_MODE, new_focus_mode_str);
+ }
+ }
+ }
+
+ // flash..
+ if (new_flash_mode_str != NULL) {
+ int new_flash_mode = -1;
+
+ if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_OFF))
+ new_flash_mode = FLASH_MODE_OFF;
+ else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_AUTO))
+ new_flash_mode = FLASH_MODE_AUTO;
+ else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_ON))
+ new_flash_mode = FLASH_MODE_ON;
+ else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_TORCH))
+ new_flash_mode = FLASH_MODE_TORCH;
+ else {
+ LOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye
+ ret = UNKNOWN_ERROR;
+ }
+ if (0 <= new_flash_mode) {
+ if (mSecCamera->setFlashMode(new_flash_mode) < 0) {
+ LOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_FLASH_MODE, new_flash_mode_str);
+ }
+ }
+ }
+
+ // whitebalance
+ LOGV("%s : new_white_str %s", __func__, new_white_str);
+ if ((new_scene_mode_str != NULL) && !strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) {
+ if (new_white_str != NULL) {
+ int new_white = -1;
+
+ if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO)) {
+ new_white = WHITE_BALANCE_AUTO;
+ } else if (!strcmp(new_white_str,
+ CameraParameters::WHITE_BALANCE_DAYLIGHT)) {
+ new_white = WHITE_BALANCE_SUNNY;
+ } else if (!strcmp(new_white_str,
+ CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT)) {
+ new_white = WHITE_BALANCE_CLOUDY;
+ } else if (!strcmp(new_white_str,
+ CameraParameters::WHITE_BALANCE_FLUORESCENT)) {
+ new_white = WHITE_BALANCE_FLUORESCENT;
+ } else if (!strcmp(new_white_str,
+ CameraParameters::WHITE_BALANCE_INCANDESCENT)) {
+ new_white = WHITE_BALANCE_TUNGSTEN;
+ } else {
+ LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (0 <= new_white) {
+ if (mSecCamera->setWhiteBalance(new_white) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str);
+ }
+ }
+ }
+ }
+
+ const char *new_AWB_lock = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
+ const char *old_AWB_lock = mParameters.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
+ if (new_AWB_lock != NULL && mUseInternalISP && mPreviewRunning) {
+ if (strncmp(new_AWB_lock, old_AWB_lock, 4)) {
+ int awb_value = !strncmp(new_AWB_lock, "true", 4);
+ if (mSecCamera->setAutoWhiteBalanceLock(awb_value) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setoAutoWhiteBalanceLock()", __func__);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, new_AWB_lock);
+ }
+ }
+ }
+
+ const char *new_touch_rect_str = params.get(CameraParameters::KEY_FOCUS_AREAS);
+ LOGV("Touched rect is '%s'", new_touch_rect_str);
+
+ if (new_touch_rect_str != NULL) {
+ int left = 0, top = 0, right = 0, bottom = 0, touched = 0;
+ int objx, objy;
+
+ char *end;
+ char delim = ',';
+ left = (int)strtol(new_touch_rect_str+1, &end, 10);
+ if (*end != delim) {
+ LOGE("Cannot find '%c' in str=%s", delim, new_touch_rect_str);
+ return -1;
+ }
+ top = (int)strtol(end+1, &end, 10);
+ if (*end != delim) {
+ LOGE("Cannot find '%c' in str=%s", delim, new_touch_rect_str);
+ return -1;
+ }
+ right = (int)strtol(end+1, &end, 10);
+ if (*end != delim) {
+ LOGE("Cannot find '%c' in str=%s", delim, new_touch_rect_str);
+ return -1;
+ }
+ bottom = (int)strtol(end+1, &end, 10);
+ if (*end != delim) {
+ LOGE("Cannot find '%c' in str=%s", delim, new_touch_rect_str);
+ return -1;
+ }
+ touched = (int)strtol(end+1, &end, 10);
+ if (*end != ')') {
+ LOGE("Cannot find ')' in str=%s", new_touch_rect_str);
+ return -1;
+ }
+
+ /* TODO : Converting axis and Calcurating center of rect. Because driver need (x, y) point. */
+ objx = (int)((1023 * (left + 1000)) / 2000) + 97;
+ objy = (int)((1023 * (top + 1000)) / 2000) + 128;
+
+ mTouched = touched;
+ mSecCamera->setObjectPosition(objx, objy);
+ }
+
+ // image effect
+ const char *new_image_effect_str = params.get(CameraParameters::KEY_EFFECT);
+ if (new_image_effect_str != NULL) {
+
+ int new_image_effect = -1;
+
+ if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NONE)) {
+ new_image_effect = IMAGE_EFFECT_NONE;
+ } else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_MONO)) {
+ new_image_effect = IMAGE_EFFECT_BNW;
+ } else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_SEPIA)) {
+ new_image_effect = IMAGE_EFFECT_SEPIA;
+ } else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_AQUA))
+ new_image_effect = IMAGE_EFFECT_AQUA;
+ else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NEGATIVE)) {
+ new_image_effect = IMAGE_EFFECT_NEGATIVE;
+ } else {
+ //posterize, whiteboard, blackboard, solarize
+ LOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (new_image_effect >= 0) {
+ if (mSecCamera->setImageEffect(new_image_effect) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect);
+ ret = UNKNOWN_ERROR;
+ } else {
+ const char *old_image_effect_str = mParameters.get(CameraParameters::KEY_EFFECT);
+
+ if (old_image_effect_str) {
+ if (strcmp(old_image_effect_str, new_image_effect_str)) {
+ setSkipFrame(EFFECT_SKIP_FRAME);
+ }
+ }
+
+ mParameters.set(CameraParameters::KEY_EFFECT, new_image_effect_str);
+ }
+ }
+ }
+
+ //contrast
+ const char *new_contrast_str = params.get("contrast");
+ LOGV("%s : new_contrast_str %s", __func__, new_contrast_str);
+ if (new_contrast_str != NULL) {
+ int new_contrast = -1;
+
+ if (!strcmp(new_contrast_str, "auto")) {
+ if (mUseInternalISP)
+ new_contrast = IS_CONTRAST_AUTO;
+ else
+ LOGW("WARN(%s):Invalid contrast value (%s)", __func__, new_contrast_str);
+ } else if (!strcmp(new_contrast_str, "-2")) {
+ if (mUseInternalISP)
+ new_contrast = IS_CONTRAST_MINUS_2;
+ else
+ new_contrast = CONTRAST_MINUS_2;
+ } else if (!strcmp(new_contrast_str, "-1")) {
+ if (mUseInternalISP)
+ new_contrast = IS_CONTRAST_MINUS_1;
+ else
+ new_contrast = CONTRAST_MINUS_1;
+ } else if (!strcmp(new_contrast_str, "0")) {
+ if (mUseInternalISP)
+ new_contrast = IS_CONTRAST_DEFAULT;
+ else
+ new_contrast = CONTRAST_DEFAULT;
+ } else if (!strcmp(new_contrast_str, "1")) {
+ if (mUseInternalISP)
+ new_contrast = IS_CONTRAST_PLUS_1;
+ else
+ new_contrast = CONTRAST_PLUS_1;
+ } else if (!strcmp(new_contrast_str, "2")) {
+ if (mUseInternalISP)
+ new_contrast = IS_CONTRAST_PLUS_2;
+ else
+ new_contrast = CONTRAST_PLUS_2;
+ } else {
+ LOGE("ERR(%s):Invalid contrast value(%s)", __func__, new_contrast_str);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (0 <= new_contrast) {
+ if (mSecCamera->setContrast(new_contrast) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setContrast(contrast(%d))", __func__, new_contrast);
+ ret = UNKNOWN_ERROR;
+ } else {
+ mParameters.set("contrast", new_contrast_str);
+ }
+ }
+ }
+
+ //WDR
+ int new_wdr = params.getInt("wdr");
+ LOGV("%s : new_wdr %d", __func__, new_wdr);
+
+ if (0 <= new_wdr) {
+ if (mSecCamera->setWDR(new_wdr) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_wdr);
+ ret = UNKNOWN_ERROR;
+ }
+ }
+
+ //anti shake
+ int new_anti_shake = mInternalParameters.getInt("anti-shake");
+
+ if (0 <= new_anti_shake) {
+ if (mSecCamera->setAntiShake(new_anti_shake) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_anti_shake);
+ ret = UNKNOWN_ERROR;
+ }
+ }
+
+ // gps latitude
+ const char *new_gps_latitude_str = params.get(CameraParameters::KEY_GPS_LATITUDE);
+ if (mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) {
+ LOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str);
+ ret = UNKNOWN_ERROR;
+ } else {
+ if (new_gps_latitude_str) {
+ mParameters.set(CameraParameters::KEY_GPS_LATITUDE, new_gps_latitude_str);
+ } else {
+ mParameters.remove(CameraParameters::KEY_GPS_LATITUDE);
+ }
+ }
+
+ // gps longitude
+ const char *new_gps_longitude_str = params.get(CameraParameters::KEY_GPS_LONGITUDE);
+
+ if (mSecCamera->setGPSLongitude(new_gps_longitude_str) < 0) {
+ LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str);
+ ret = UNKNOWN_ERROR;
+ } else {
+ if (new_gps_longitude_str) {
+ mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, new_gps_longitude_str);
+ } else {
+ mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE);
+ }
+ }
+
+ // gps altitude
+ const char *new_gps_altitude_str = params.get(CameraParameters::KEY_GPS_ALTITUDE);
+
+ if (mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) {
+ LOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str);
+ ret = UNKNOWN_ERROR;
+ } else {
+ if (new_gps_altitude_str) {
+ mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, new_gps_altitude_str);
+ } else {
+ mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE);
+ }
+ }
+
+ // gps timestamp
+ const char *new_gps_timestamp_str = params.get(CameraParameters::KEY_GPS_TIMESTAMP);
+
+ if (mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) {
+ LOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str);
+ ret = UNKNOWN_ERROR;
+ } else {
+ if (new_gps_timestamp_str) {
+ mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, new_gps_timestamp_str);
+ } else {
+ mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
+ }
+ }
+
+ // gps processing method
+ const char *new_gps_processing_method_str = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
+
+ if (mSecCamera->setGPSProcessingMethod(new_gps_processing_method_str) < 0) {
+ LOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str);
+ ret = UNKNOWN_ERROR;
+ } else {
+ if (new_gps_processing_method_str) {
+ mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, new_gps_processing_method_str);
+ } else {
+ mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
+ }
+ }
+
+ // Recording size
+ /* TODO */
+ /* GED application don't set different recording size before recording button is pushed */
+ int new_recording_width = 0;
+ int new_recording_height = 0;
+ params.getVideoSize(&new_recording_width, &new_recording_height);
+ LOGV("new_recording_width (%d) new_recording_height (%d)",
+ new_recording_width, new_recording_height);
+
+ int current_recording_width, current_recording_height;
+ mParameters.getVideoSize(¤t_recording_width, ¤t_recording_height);
+ LOGV("current_recording_width (%d) current_recording_height (%d)",
+ current_recording_width, current_recording_height);
+
+ if (current_recording_width != new_recording_width ||
+ current_recording_height != new_recording_height) {
+ if (0 < new_recording_width && 0 < new_recording_height) {
+ if (mSecCamera->setRecordingSize(new_recording_width, new_recording_height) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))",
+ __func__, new_recording_width, new_recording_height);
+ ret = UNKNOWN_ERROR;
+ }
+ mParameters.setVideoSize(new_recording_width, new_recording_height);
+ }
+ }
+
+ //gamma
+ const char *new_gamma_str = mInternalParameters.get("video_recording_gamma");
+
+ if (new_gamma_str != NULL) {
+ int new_gamma = -1;
+ if (!strcmp(new_gamma_str, "off"))
+ new_gamma = GAMMA_OFF;
+ else if (!strcmp(new_gamma_str, "on"))
+ new_gamma = GAMMA_ON;
+ else {
+ LOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (0 <= new_gamma) {
+ if (mSecCamera->setGamma(new_gamma) < 0) {
+ LOGE("%s::mSecCamera->setGamma(%d) fail", __func__, new_gamma);
+ ret = UNKNOWN_ERROR;
+ }
+ }
+ }
+
+ //slow ae
+ const char *new_slow_ae_str = mInternalParameters.get("slow_ae");
+
+ if (new_slow_ae_str != NULL) {
+ int new_slow_ae = -1;
+
+ if (!strcmp(new_slow_ae_str, "off"))
+ new_slow_ae = SLOW_AE_OFF;
+ else if (!strcmp(new_slow_ae_str, "on"))
+ new_slow_ae = SLOW_AE_ON;
+ else {
+ LOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str);
+ ret = UNKNOWN_ERROR;
+ }
+
+ if (0 <= new_slow_ae) {
+ if (mSecCamera->setSlowAE(new_slow_ae) < 0) {
+ LOGE("%s::mSecCamera->setSlowAE(%d) fail", __func__, new_slow_ae);
+ ret = UNKNOWN_ERROR;
+ }
+ }
+ }
+
+ /*Camcorder fix fps*/
+ int new_sensor_mode = mInternalParameters.getInt("cam_mode");
+
+ if (0 <= new_sensor_mode) {
+ if (mSecCamera->setSensorMode(new_sensor_mode) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __func__, new_sensor_mode);
+ ret = UNKNOWN_ERROR;
+ }
+ } else {
+ new_sensor_mode=0;
+ }
+
+ /*Shot mode*/
+ int new_shot_mode = mInternalParameters.getInt("shot_mode");
+
+ if (0 <= new_shot_mode) {
+ if (mSecCamera->setShotMode(new_shot_mode) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __func__, new_shot_mode);
+ ret = UNKNOWN_ERROR;
+ }
+ } else {
+ new_shot_mode=0;
+ }
+
+ // chk_dataline
+ int new_dataline = mInternalParameters.getInt("chk_dataline");
+
+ if (0 <= new_dataline) {
+ if (mSecCamera->setDataLineCheck(new_dataline) < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __func__, new_dataline);
+ ret = UNKNOWN_ERROR;
+ }
+ }
+ LOGV("%s return ret = %d", __func__, ret);
+
+ return ret;
+}
+
+CameraParameters CameraHardwareSec::getParameters() const
+{
+ LOGV("%s :", __func__);
+ return mParameters;
+}
+
+status_t CameraHardwareSec::sendCommand(int32_t command, int32_t arg1, int32_t arg2)
+{
+ /* TODO */
+ /* CAMERA_CMD_START_FACE_DETECTION and CAMERA_CMD_STOP_FACE_DETECTION
+ for Face Detection */
+ if(command == CAMERA_CMD_START_FACE_DETECTION) {
+ if (mSecCamera->setFaceDetect(FACE_DETECTION_ON) < 0) {
+ LOGE("ERR(%s): Fail on mSecCamera->startFaceDetection()");
+ return BAD_VALUE;
+ } else {
+ return NO_ERROR;
+ }
+ }
+ if(command == CAMERA_CMD_STOP_FACE_DETECTION) {
+ if (mSecCamera->setFaceDetect(FACE_DETECTION_OFF) < 0) {
+ LOGE("ERR(%s): Fail on mSecCamera->stopFaceDetection()");
+ return BAD_VALUE;
+ } else {
+ return NO_ERROR;
+ }
+ }
+
+ return BAD_VALUE;
+}
+
+void CameraHardwareSec::release()
+{
+ LOGV("%s", __func__);
+
+ /* shut down any threads we have that might be running. do it here
+ * instead of the destructor. we're guaranteed to be on another thread
+ * than the ones below. if we used the destructor, since the threads
+ * have a reference to this object, we could wind up trying to wait
+ * for ourself to exit, which is a deadlock.
+ */
+ if (mPreviewThread != NULL) {
+ /* this thread is normally already in it's threadLoop but blocked
+ * on the condition variable or running. signal it so it wakes
+ * up and can exit.
+ */
+ mPreviewThread->requestExit();
+ mExitPreviewThread = true;
+ mPreviewRunning = true; /* let it run so it can exit */
+ mPreviewCondition.signal();
+ mPreviewThread->requestExitAndWait();
+ mPreviewThread.clear();
+ }
+ if (mAutoFocusThread != NULL) {
+ /* this thread is normally already in it's threadLoop but blocked
+ * on the condition variable. signal it so it wakes up and can exit.
+ */
+ mFocusLock.lock();
+ mAutoFocusThread->requestExit();
+ mExitAutoFocusThread = true;
+ mFocusCondition.signal();
+ mFocusLock.unlock();
+ mAutoFocusThread->requestExitAndWait();
+ mAutoFocusThread.clear();
+ }
+ if (mPictureThread != NULL) {
+ mPictureThread->requestExitAndWait();
+ mPictureThread.clear();
+ }
+
+ if (mRawHeap) {
+ mRawHeap->release(mRawHeap);
+ mRawHeap = 0;
+ }
+ if (mPreviewHeap) {
+ mPreviewHeap->release(mPreviewHeap);
+ mPreviewHeap = 0;
+ }
+ for(int i = 0; i < BUFFER_COUNT_FOR_ARRAY; i++) {
+ if (mRecordHeap[i]) {
+ mRecordHeap[i]->release(mRecordHeap[i]);
+ mRecordHeap[i] = 0;
+ }
+ }
+
+ /* close after all the heaps are cleared since those
+ * could have dup'd our file descriptor.
+ */
+ mSecCamera->DestroyCamera();
+}
+
+static CameraInfo sCameraInfo[] = {
+ {
+ CAMERA_FACING_BACK,
+ 90, /* orientation */
+ },
+ {
+ CAMERA_FACING_FRONT,
+ 90, /* orientation */
+ }
+};
+
+status_t CameraHardwareSec::storeMetaDataInBuffers(bool enable)
+{
+ // FIXME:
+ // metadata buffer mode can be turned on or off.
+ // Samsung needs to fix this.
+ if (!enable) {
+ LOGE("Non-metadata buffer mode is not supported!");
+ return INVALID_OPERATION;
+ }
+ return OK;
+}
+
+/** Close this device */
+
+static camera_device_t *g_cam_device;
+
+static int HAL_camera_device_close(struct hw_device_t* device)
+{
+ LOGI("%s", __func__);
+ if (device) {
+ camera_device_t *cam_device = (camera_device_t *)device;
+ delete static_cast<CameraHardwareSec *>(cam_device->priv);
+ free(cam_device);
+ g_cam_device = 0;
+ }
+ return 0;
+}
+
+static inline CameraHardwareSec *obj(struct camera_device *dev)
+{
+ return reinterpret_cast<CameraHardwareSec *>(dev->priv);
+}
+
+/** Set the preview_stream_ops to which preview frames are sent */
+static int HAL_camera_device_set_preview_window(struct camera_device *dev,
+ struct preview_stream_ops *buf)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->setPreviewWindow(buf);
+}
+
+/** Set the notification and data callbacks */
+static void HAL_camera_device_set_callbacks(struct camera_device *dev,
+ camera_notify_callback notify_cb,
+ camera_data_callback data_cb,
+ camera_data_timestamp_callback data_cb_timestamp,
+ camera_request_memory get_memory,
+ void* user)
+{
+ LOGV("%s", __func__);
+ obj(dev)->setCallbacks(notify_cb, data_cb, data_cb_timestamp,
+ get_memory,
+ user);
+}
+
+/**
+ * The following three functions all take a msg_type, which is a bitmask of
+ * the messages defined in include/ui/Camera.h
+ */
+
+/**
+ * Enable a message, or set of messages.
+ */
+static void HAL_camera_device_enable_msg_type(struct camera_device *dev, int32_t msg_type)
+{
+ LOGV("%s", __func__);
+ obj(dev)->enableMsgType(msg_type);
+}
+
+/**
+ * Disable a message, or a set of messages.
+ *
+ * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
+ * HAL should not rely on its client to call releaseRecordingFrame() to
+ * release video recording frames sent out by the cameral HAL before and
+ * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
+ * clients must not modify/access any video recording frame after calling
+ * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
+ */
+static void HAL_camera_device_disable_msg_type(struct camera_device *dev, int32_t msg_type)
+{
+ LOGV("%s", __func__);
+ obj(dev)->disableMsgType(msg_type);
+}
+
+/**
+ * Query whether a message, or a set of messages, is enabled. Note that
+ * this is operates as an AND, if any of the messages queried are off, this
+ * will return false.
+ */
+static int HAL_camera_device_msg_type_enabled(struct camera_device *dev, int32_t msg_type)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->msgTypeEnabled(msg_type);
+}
+
+/**
+ * Start preview mode.
+ */
+static int HAL_camera_device_start_preview(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->startPreview();
+}
+
+/**
+ * Stop a previously started preview.
+ */
+static void HAL_camera_device_stop_preview(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ obj(dev)->stopPreview();
+}
+
+/**
+ * Returns true if preview is enabled.
+ */
+static int HAL_camera_device_preview_enabled(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->previewEnabled();
+}
+
+/**
+ * Request the camera HAL to store meta data or real YUV data in the video
+ * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
+ * it is not called, the default camera HAL behavior is to store real YUV
+ * data in the video buffers.
+ *
+ * This method should be called before startRecording() in order to be
+ * effective.
+ *
+ * If meta data is stored in the video buffers, it is up to the receiver of
+ * the video buffers to interpret the contents and to find the actual frame
+ * data with the help of the meta data in the buffer. How this is done is
+ * outside of the scope of this method.
+ *
+ * Some camera HALs may not support storing meta data in the video buffers,
+ * but all camera HALs should support storing real YUV data in the video
+ * buffers. If the camera HAL does not support storing the meta data in the
+ * video buffers when it is requested to do do, INVALID_OPERATION must be
+ * returned. It is very useful for the camera HAL to pass meta data rather
+ * than the actual frame data directly to the video encoder, since the
+ * amount of the uncompressed frame data can be very large if video size is
+ * large.
+ *
+ * @param enable if true to instruct the camera HAL to store
+ * meta data in the video buffers; false to instruct
+ * the camera HAL to store real YUV data in the video
+ * buffers.
+ *
+ * @return OK on success.
+ */
+static int HAL_camera_device_store_meta_data_in_buffers(struct camera_device *dev, int enable)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->storeMetaDataInBuffers(enable);
+}
+
+/**
+ * Start record mode. When a record image is available, a
+ * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding
+ * frame. Every record frame must be released by a camera HAL client via
+ * releaseRecordingFrame() before the client calls
+ * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
+ * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
+ * responsibility to manage the life-cycle of the video recording frames,
+ * and the client must not modify/access any video recording frames.
+ */
+static int HAL_camera_device_start_recording(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->startRecording();
+}
+
+/**
+ * Stop a previously started recording.
+ */
+static void HAL_camera_device_stop_recording(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ obj(dev)->stopRecording();
+}
+
+/**
+ * Returns true if recording is enabled.
+ */
+static int HAL_camera_device_recording_enabled(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->recordingEnabled();
+}
+
+/**
+ * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
+ *
+ * It is camera HAL client's responsibility to release video recording
+ * frames sent out by the camera HAL before the camera HAL receives a call
+ * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
+ * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
+ * responsibility to manage the life-cycle of the video recording frames.
+ */
+static void HAL_camera_device_release_recording_frame(struct camera_device *dev,
+ const void *opaque)
+{
+ LOGV("%s", __func__);
+ obj(dev)->releaseRecordingFrame(opaque);
+}
+
+/**
+ * Start auto focus, the notification callback routine is called with
+ * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be
+ * called again if another auto focus is needed.
+ */
+static int HAL_camera_device_auto_focus(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->autoFocus();
+}
+
+/**
+ * Cancels auto-focus function. If the auto-focus is still in progress,
+ * this function will cancel it. Whether the auto-focus is in progress or
+ * not, this function will return the focus position to the default. If
+ * the camera does not support auto-focus, this is a no-op.
+ */
+static int HAL_camera_device_cancel_auto_focus(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->cancelAutoFocus();
+}
+
+/**
+ * Take a picture.
+ */
+static int HAL_camera_device_take_picture(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->takePicture();
+}
+
+/**
+ * Cancel a picture that was started with takePicture. Calling this method
+ * when no picture is being taken is a no-op.
+ */
+static int HAL_camera_device_cancel_picture(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->cancelPicture();
+}
+
+/**
+ * Set the camera parameters. This returns BAD_VALUE if any parameter is
+ * invalid or not supported.
+ */
+static int HAL_camera_device_set_parameters(struct camera_device *dev,
+ const char *parms)
+{
+ LOGV("%s", __func__);
+ String8 str(parms);
+ CameraParameters p(str);
+ return obj(dev)->setParameters(p);
+}
+
+/** Return the camera parameters. */
+char *HAL_camera_device_get_parameters(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ String8 str;
+ CameraParameters parms = obj(dev)->getParameters();
+ str = parms.flatten();
+ return strdup(str.string());
+}
+
+static void HAL_camera_device_put_parameters(struct camera_device *dev, char *parms)
+{
+ LOGV("%s", __func__);
+ free(parms);
+}
+
+/**
+ * Send command to camera driver.
+ */
+static int HAL_camera_device_send_command(struct camera_device *dev,
+ int32_t cmd, int32_t arg1, int32_t arg2)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->sendCommand(cmd, arg1, arg2);
+}
+
+/**
+ * Release the hardware resources owned by this object. Note that this is
+ * *not* done in the destructor.
+ */
+static void HAL_camera_device_release(struct camera_device *dev)
+{
+ LOGV("%s", __func__);
+ obj(dev)->release();
+}
+
+/**
+ * Dump state of the camera hardware
+ */
+static int HAL_camera_device_dump(struct camera_device *dev, int fd)
+{
+ LOGV("%s", __func__);
+ return obj(dev)->dump(fd);
+}
+
+static int HAL_getNumberOfCameras()
+{
+ LOGV("%s", __func__);
+
+ int cam_fd;
+ static struct v4l2_input input;
+
+ cam_fd = open(CAMERA_DEV_NAME, O_RDONLY);
+ if (cam_fd < 0) {
+ LOGE("ERR(%s):Cannot open %s (error : %s)", __func__, CAMERA_DEV_NAME, strerror(errno));
+ return -1;
+ }
+
+ input.index = 0;
+ while (ioctl(cam_fd, VIDIOC_ENUMINPUT, &input) == 0) {
+ LOGI("Name of input channel[%d] is %s", input.index, input.name);
+ input.index++;
+ }
+
+ close(cam_fd);
+
+ return --input.index;
+}
+
+static int HAL_getCameraInfo(int cameraId, struct camera_info *cameraInfo)
+{
+ LOGV("%s", __func__);
+ memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo));
+ return 0;
+}
+
+#define SET_METHOD(m) m : HAL_camera_device_##m
+
+static camera_device_ops_t camera_device_ops = {
+ SET_METHOD(set_preview_window),
+ SET_METHOD(set_callbacks),
+ SET_METHOD(enable_msg_type),
+ SET_METHOD(disable_msg_type),
+ SET_METHOD(msg_type_enabled),
+ SET_METHOD(start_preview),
+ SET_METHOD(stop_preview),
+ SET_METHOD(preview_enabled),
+ SET_METHOD(store_meta_data_in_buffers),
+ SET_METHOD(start_recording),
+ SET_METHOD(stop_recording),
+ SET_METHOD(recording_enabled),
+ SET_METHOD(release_recording_frame),
+ SET_METHOD(auto_focus),
+ SET_METHOD(cancel_auto_focus),
+ SET_METHOD(take_picture),
+ SET_METHOD(cancel_picture),
+ SET_METHOD(set_parameters),
+ SET_METHOD(get_parameters),
+ SET_METHOD(put_parameters),
+ SET_METHOD(send_command),
+ SET_METHOD(release),
+ SET_METHOD(dump),
+};
+
+#undef SET_METHOD
+
+static int HAL_camera_device_open(const struct hw_module_t* module,
+ const char *id,
+ struct hw_device_t** device)
+{
+ LOGV("%s", __func__);
+
+ int cameraId = atoi(id);
+ if (cameraId < 0 || cameraId >= HAL_getNumberOfCameras()) {
+ LOGE("Invalid camera ID %s", id);
+ return -EINVAL;
+ }
+
+ if (g_cam_device) {
+ if (obj(g_cam_device)->getCameraId() == cameraId) {
+ LOGV("returning existing camera ID %s", id);
+ goto done;
+ } else {
+ LOGE("Cannot open camera %d. camera %d is already running!",
+ cameraId, obj(g_cam_device)->getCameraId());
+ return -ENOSYS;
+ }
+ }
+
+ g_cam_device = (camera_device_t *)malloc(sizeof(camera_device_t));
+ if (!g_cam_device)
+ return -ENOMEM;
+
+ g_cam_device->common.tag = HARDWARE_DEVICE_TAG;
+ g_cam_device->common.version = 1;
+ g_cam_device->common.module = const_cast<hw_module_t *>(module);
+ g_cam_device->common.close = HAL_camera_device_close;
+
+ g_cam_device->ops = &camera_device_ops;
+
+ LOGI("%s: open camera %s", __func__, id);
+
+ g_cam_device->priv = new CameraHardwareSec(cameraId, g_cam_device);
+
+done:
+ *device = (hw_device_t *)g_cam_device;
+ LOGI("%s: opened camera %s (%p)", __func__, id, *device);
+ return 0;
+}
+
+static hw_module_methods_t camera_module_methods = {
+ open : HAL_camera_device_open
+};
+
+extern "C" {
+ struct camera_module HAL_MODULE_INFO_SYM = {
+ common : {
+ tag : HARDWARE_MODULE_TAG,
+ version_major : 1,
+ version_minor : 0,
+ id : CAMERA_HARDWARE_MODULE_ID,
+ name : "orion camera HAL",
+ author : "Samsung Corporation",
+ methods : &camera_module_methods,
+ },
+ get_number_of_cameras : HAL_getNumberOfCameras,
+ get_camera_info : HAL_getCameraInfo
+ };
+}
+
+}; // namespace android
diff --git a/exynos4/hal/libcamera/SecCameraHWInterface.h b/exynos4/hal/libcamera/SecCameraHWInterface.h
new file mode 100644
index 0000000..321eb15
--- /dev/null
+++ b/exynos4/hal/libcamera/SecCameraHWInterface.h
@@ -0,0 +1,242 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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 ANDROID_HARDWARE_CAMERA_HARDWARE_SEC_H
+#define ANDROID_HARDWARE_CAMERA_HARDWARE_SEC_H
+
+#include "SecCamera.h"
+#include <utils/threads.h>
+#include <utils/RefBase.h>
+#include <binder/MemoryBase.h>
+#include <binder/MemoryHeapBase.h>
+#include <hardware/camera.h>
+#include <hardware/gralloc.h>
+#include <camera/CameraParameters.h>
+#ifdef BOARD_USE_V4L2_ION
+#include <binder/MemoryHeapBaseIon.h>
+#include "gralloc_priv.h"
+
+#define BUFFER_COUNT_FOR_GRALLOC (MAX_BUFFERS + 4)
+#define BUFFER_COUNT_FOR_ARRAY (MAX_BUFFERS)
+#else
+#define BUFFER_COUNT_FOR_GRALLOC (MAX_BUFFERS)
+#define BUFFER_COUNT_FOR_ARRAY (1)
+#endif
+
+namespace android {
+ class CameraHardwareSec : public virtual RefBase {
+public:
+ virtual void setCallbacks(camera_notify_callback notify_cb,
+ camera_data_callback data_cb,
+ camera_data_timestamp_callback data_cb_timestamp,
+ camera_request_memory get_memory,
+ void *user);
+
+ virtual void enableMsgType(int32_t msgType);
+ virtual void disableMsgType(int32_t msgType);
+ virtual bool msgTypeEnabled(int32_t msgType);
+
+ virtual status_t startPreview();
+ virtual void stopPreview();
+ virtual bool previewEnabled();
+
+ virtual status_t startRecording();
+ virtual void stopRecording();
+ virtual bool recordingEnabled();
+ virtual void releaseRecordingFrame(const void *opaque);
+
+ virtual status_t autoFocus();
+ virtual status_t cancelAutoFocus();
+ virtual status_t takePicture();
+ virtual status_t cancelPicture();
+ virtual status_t dump(int fd) const;
+ virtual status_t setParameters(const CameraParameters& params);
+ virtual CameraParameters getParameters() const;
+ virtual status_t sendCommand(int32_t command, int32_t arg1, int32_t arg2);
+ virtual status_t setPreviewWindow(preview_stream_ops *w);
+ virtual status_t storeMetaDataInBuffers(bool enable);
+ virtual void release();
+
+ inline int getCameraId() const;
+
+ CameraHardwareSec(int cameraId, camera_device_t *dev);
+ virtual ~CameraHardwareSec();
+private:
+ status_t startPreviewInternal();
+ void stopPreviewInternal();
+
+ class PreviewThread : public Thread {
+ CameraHardwareSec *mHardware;
+ public:
+ PreviewThread(CameraHardwareSec *hw):
+ Thread(false),
+ mHardware(hw) { }
+ virtual void onFirstRef() {
+ run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY);
+ }
+ virtual bool threadLoop() {
+ mHardware->previewThreadWrapper();
+ return false;
+ }
+ };
+
+ class PictureThread : public Thread {
+ CameraHardwareSec *mHardware;
+ public:
+ PictureThread(CameraHardwareSec *hw):
+ Thread(false),
+ mHardware(hw) { }
+ virtual bool threadLoop() {
+ mHardware->pictureThread();
+ return false;
+ }
+ };
+
+ class AutoFocusThread : public Thread {
+ CameraHardwareSec *mHardware;
+ public:
+ AutoFocusThread(CameraHardwareSec *hw): Thread(false), mHardware(hw) { }
+ virtual void onFirstRef() {
+ run("CameraAutoFocusThread", PRIORITY_DEFAULT);
+ }
+ virtual bool threadLoop() {
+ mHardware->autoFocusThread();
+ return true;
+ }
+ };
+
+ void initDefaultParameters(int cameraId);
+ void initHeapLocked();
+
+ sp<PreviewThread> mPreviewThread;
+ int previewThread();
+ int previewThreadWrapper();
+
+ sp<AutoFocusThread> mAutoFocusThread;
+ int autoFocusThread();
+
+ sp<PictureThread> mPictureThread;
+ int pictureThread();
+ bool mCaptureInProgress;
+
+ int save_jpeg(unsigned char *real_jpeg, int jpeg_size);
+ void save_postview(const char *fname, uint8_t *buf,
+ uint32_t size);
+ int decodeInterleaveData(unsigned char *pInterleaveData,
+ int interleaveDataSize,
+ int yuvWidth,
+ int yuvHeight,
+ int *pJpegSize,
+ void *pJpegData,
+ void *pYuvData);
+ bool YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight);
+ bool scaleDownYuv422(char *srcBuf, uint32_t srcWidth,
+ uint32_t srcHight, char *dstBuf,
+ uint32_t dstWidth, uint32_t dstHight);
+
+ bool CheckVideoStartMarker(unsigned char *pBuf);
+ bool CheckEOIMarker(unsigned char *pBuf);
+ bool FindEOIMarkerInJPEG(unsigned char *pBuf,
+ int dwBufSize, int *pnJPEGsize);
+ bool SplitFrame(unsigned char *pFrame, int dwSize,
+ int dwJPEGLineLength, int dwVideoLineLength,
+ int dwVideoHeight, void *pJPEG,
+ int *pdwJPEGSize, void *pVideo,
+ int *pdwVideoSize);
+ void setSkipFrame(int frame);
+ bool isSupportedPreviewSize(const int width,
+ const int height) const;
+ bool getVideosnapshotSize(int *width, int *height);
+ /* used by auto focus thread to block until it's told to run */
+ mutable Mutex mFocusLock;
+ mutable Condition mFocusCondition;
+ bool mExitAutoFocusThread;
+ int mTouched;
+
+ /* used by preview thread to block until it's told to run */
+ mutable Mutex mPreviewLock;
+ mutable Condition mPreviewCondition;
+ mutable Condition mPreviewStoppedCondition;
+ bool mPreviewRunning;
+ bool mPreviewStartDeferred;
+ bool mExitPreviewThread;
+
+ preview_stream_ops *mPreviewWindow;
+
+ /* used to guard threading state */
+ mutable Mutex mStateLock;
+
+ enum PREVIEW_FMT {
+ PREVIEW_FMT_1_PLANE = 0,
+ PREVIEW_FMT_2_PLANE,
+ PREVIEW_FMT_3_PLANE,
+ };
+
+ int mPreviewFmtPlane;
+
+ CameraParameters mParameters;
+ CameraParameters mInternalParameters;
+
+ int mFrameSizeDelta;
+ camera_memory_t *mPreviewHeap;
+ camera_memory_t *mRawHeap;
+ sp<MemoryHeapBase> mPostviewHeap[CAP_BUFFERS];
+ sp<MemoryHeapBase> mThumbnailHeap;
+ camera_memory_t *mRecordHeap[BUFFER_COUNT_FOR_ARRAY];
+
+ camera_frame_metadata_t *mFaceData;
+ camera_memory_t *mFaceDataHeap;
+
+ buffer_handle_t *mBufferHandle[BUFFER_COUNT_FOR_ARRAY];
+ int mStride[BUFFER_COUNT_FOR_ARRAY];
+
+
+ SecCamera *mSecCamera;
+ const __u8 *mCameraSensorName;
+ bool mUseInternalISP;
+
+ mutable Mutex mSkipFrameLock;
+ int mSkipFrame;
+
+ camera_notify_callback mNotifyCb;
+ camera_data_callback mDataCb;
+ camera_data_timestamp_callback mDataCbTimestamp;
+ camera_request_memory mGetMemoryCb;
+ void *mCallbackCookie;
+
+ int32_t mMsgEnabled;
+
+ bool mRecordRunning;
+ bool mRecordHint;
+ mutable Mutex mRecordLock;
+ int mPostViewWidth;
+ int mPostViewHeight;
+ int mPostViewSize;
+ struct SecBuffer mCapBuffer;
+ int mCapIndex;
+ int mCameraID;
+
+ Vector<Size> mSupportedPreviewSizes;
+
+ camera_device_t *mHalDevice;
+ static gralloc_module_t const* mGrallocHal;
+};
+
+}; // namespace android
+
+#endif
diff --git a/exynos4/hal/libfimc/Android.mk b/exynos4/hal/libfimc/Android.mk
new file mode 100644
index 0000000..624d39e
--- /dev/null
+++ b/exynos4/hal/libfimc/Android.mk
@@ -0,0 +1,55 @@
+# 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.
+
+ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_SHARED_LIBRARIES := liblog libutils libcutils
+ifeq ($(BOARD_SUPPORT_SYSMMU),true)
+LOCAL_SHARED_LIBRARIES+= libMali
+endif
+
+ifeq ($(BOARD_SUPPORT_SYSMMU),true)
+LOCAL_CFLAGS+=-DBOARD_SUPPORT_SYSMMU
+endif
+
+ifeq ($(TARGET_SOC),exynos4210)
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4210
+endif
+
+ifeq ($(TARGET_SOC),exynos4x12)
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4x12
+endif
+
+ifeq ($(BOARD_USE_V4L2),true)
+LOCAL_CFLAGS += -DBOARD_USE_V4L2
+endif
+
+LOCAL_CFLAGS += \
+ -DDEFAULT_FB_NUM=$(DEFAULT_FB_NUM)
+
+LOCAL_C_INCLUDES := \
+ $(LOCAL_PATH)/../include \
+ framework/base/include
+
+LOCAL_SRC_FILES := SecFimc.cpp
+
+LOCAL_MODULE_TAGS := eng
+LOCAL_MODULE := libfimc
+include $(BUILD_SHARED_LIBRARY)
+
+endif
diff --git a/exynos4/hal/libfimc/SecFimc.cpp b/exynos4/hal/libfimc/SecFimc.cpp
new file mode 100644
index 0000000..ab744a2
--- /dev/null
+++ b/exynos4/hal/libfimc/SecFimc.cpp
@@ -0,0 +1,1701 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * 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.
+ */
+
+/*!
+ * \file SecFimc.cpp
+ * \brief source file for Fimc HAL MODULE
+ * \author Hyunkyung, Kim(hk310.kim@samsung.com)
+ * \date 2010/10/13
+ *
+ * <b>Revision History: </b>
+ * - 2010/10/13 : Hyunkyung, Kim(hk310.kim@samsung.com) \n
+ * Initial version
+ *
+ * - 2011/11/15 : Sunmi, Lee(carrotsm.lee@samsung.com) \n
+ * Adjust V4L2 architecture \n
+ */
+
+#define LOG_TAG "libfimc"
+#include <cutils/log.h>
+
+#include "SecFimc.h"
+
+#define FIMC2_DEV_NAME "/dev/video2"
+
+//#define DEBUG_LIB_FIMC
+
+#ifdef BOARD_USE_V4L2
+#define V4L2_BUF_TYPE_OUTPUT V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
+#define V4L2_BUF_TYPE_CAPTURE V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
+#define V4L2_ROTATE V4L2_CID_ROTATE
+#else
+#define V4L2_BUF_TYPE_OUTPUT V4L2_BUF_TYPE_VIDEO_OUTPUT
+#define V4L2_BUF_TYPE_CAPTURE V4L2_BUF_TYPE_VIDEO_CAPTURE
+#define V4L2_ROTATE V4L2_CID_ROTATION
+#endif
+
+#define V4L2_BUF_TYPE_SRC V4L2_BUF_TYPE_OUTPUT
+#define V4L2_MEMORY_TYPE_SRC V4L2_MEMORY_USERPTR
+#ifdef BOARD_USE_V4L2
+#define V4L2_BUF_TYPE_DST V4L2_BUF_TYPE_CAPTURE
+#define V4L2_MEMORY_TYPE_DST V4L2_MEMORY_MMAP
+#else
+#define V4L2_BUF_TYPE_DST V4L2_BUF_TYPE_VIDEO_OVERLAY
+#define V4L2_MEMORY_TYPE_DST V4L2_MEMORY_USERPTR
+#endif
+
+struct yuv_fmt_list yuv_list[] = {
+ { "V4L2_PIX_FMT_NV12", "YUV420/2P/LSB_CBCR", V4L2_PIX_FMT_NV12, 12, 2 },
+#ifdef BOARD_USE_V4L2
+ { "V4L2_PIX_FMT_NV12M", "YUV420/2P/LSB_CBCR", V4L2_PIX_FMT_NV12M, 12, 2 },
+ { "V4L2_PIX_FMT_NV12MT", "YUV420/2P/LSB_CBCR", V4L2_PIX_FMT_NV12MT, 12, 2 },
+#endif
+ { "V4L2_PIX_FMT_NV12T", "YUV420/2P/LSB_CBCR", V4L2_PIX_FMT_NV12T, 12, 2 },
+ { "V4L2_PIX_FMT_NV21", "YUV420/2P/LSB_CRCB", V4L2_PIX_FMT_NV21, 12, 2 },
+ { "V4L2_PIX_FMT_NV21X", "YUV420/2P/MSB_CBCR", V4L2_PIX_FMT_NV21X, 12, 2 },
+ { "V4L2_PIX_FMT_NV12X", "YUV420/2P/MSB_CRCB", V4L2_PIX_FMT_NV12X, 12, 2 },
+#ifdef BOARD_USE_V4L2
+ { "V4L2_PIX_FMT_YUV420M", "YUV420/3P", V4L2_PIX_FMT_YUV420M, 12, 3 },
+#endif
+ { "V4L2_PIX_FMT_YUV420", "YUV420/3P", V4L2_PIX_FMT_YUV420, 12, 3 },
+ { "V4L2_PIX_FMT_YUYV", "YUV422/1P/YCBYCR", V4L2_PIX_FMT_YUYV, 16, 1 },
+ { "V4L2_PIX_FMT_YVYU", "YUV422/1P/YCRYCB", V4L2_PIX_FMT_YVYU, 16, 1 },
+ { "V4L2_PIX_FMT_UYVY", "YUV422/1P/CBYCRY", V4L2_PIX_FMT_UYVY, 16, 1 },
+ { "V4L2_PIX_FMT_VYUY", "YUV422/1P/CRYCBY", V4L2_PIX_FMT_VYUY, 16, 1 },
+ { "V4L2_PIX_FMT_UV12", "YUV422/2P/LSB_CBCR", V4L2_PIX_FMT_NV16, 16, 2 },
+ { "V4L2_PIX_FMT_UV21", "YUV422/2P/LSB_CRCB", V4L2_PIX_FMT_NV61, 16, 2 },
+ { "V4L2_PIX_FMT_UV12X", "YUV422/2P/MSB_CBCR", V4L2_PIX_FMT_NV16X, 16, 2 },
+ { "V4L2_PIX_FMT_UV21X", "YUV422/2P/MSB_CRCB", V4L2_PIX_FMT_NV61X, 16, 2 },
+ { "V4L2_PIX_FMT_YUV422P", "YUV422/3P", V4L2_PIX_FMT_YUV422P, 16, 3 },
+};
+
+#ifdef BOARD_USE_V4L2
+void dump_pixfmt_mp(struct v4l2_pix_format_mplane *pix_mp)
+{
+ LOGI("w: %d", pix_mp->width);
+ LOGI("h: %d", pix_mp->height);
+ LOGI("color: %x", pix_mp->colorspace);
+
+ switch (pix_mp->pixelformat) {
+ case V4L2_PIX_FMT_YUYV:
+ LOGI ("YUYV");
+ break;
+ case V4L2_PIX_FMT_UYVY:
+ LOGI ("UYVY");
+ break;
+ case V4L2_PIX_FMT_RGB565:
+ LOGI ("RGB565");
+ break;
+ case V4L2_PIX_FMT_RGB565X:
+ LOGI ("RGB565X");
+ break;
+ default:
+ LOGI("not supported");
+ }
+}
+#endif
+
+void dump_pixfmt(struct v4l2_pix_format *pix)
+{
+ LOGI("w: %d", pix->width);
+ LOGI("h: %d", pix->height);
+ LOGI("color: %x", pix->colorspace);
+
+ switch (pix->pixelformat) {
+ case V4L2_PIX_FMT_YUYV:
+ LOGI ("YUYV");
+ break;
+ case V4L2_PIX_FMT_UYVY:
+ LOGI ("UYVY");
+ break;
+ case V4L2_PIX_FMT_RGB565:
+ LOGI ("RGB565");
+ break;
+ case V4L2_PIX_FMT_RGB565X:
+ LOGI ("RGB565X");
+ break;
+ default:
+ LOGI("not supported");
+ }
+}
+
+void dump_crop(struct v4l2_crop *crop)
+{
+ LOGI("crop l: %d", crop->c.left);
+ LOGI("crop t: %d", crop->c.top);
+ LOGI("crop w: %d", crop->c.width);
+ LOGI("crop h: %d", crop->c.height);
+}
+
+void dump_window(struct v4l2_window *win)
+{
+ LOGI("window l: %d", win->w.left);
+ LOGI("window t: %d", win->w.top);
+ LOGI("window w: %d", win->w.width);
+ LOGI("window h: %d", win->w.height);
+}
+
+void v4l2_overlay_dump_state(int fd)
+{
+ struct v4l2_format format;
+ struct v4l2_crop crop;
+
+ format.type = V4L2_BUF_TYPE_OUTPUT;
+ if (ioctl(fd, VIDIOC_G_FMT, &format) < 0)
+ return;
+
+ LOGI("dumping driver state:");
+#ifdef BOARD_USE_V4L2
+ dump_pixfmt_mp(&format.fmt.pix_mp);
+#else
+ dump_pixfmt(&format.fmt.pix);
+#endif
+
+ crop.type = format.type;
+ if (ioctl(fd, VIDIOC_G_CROP, &crop) < 0)
+ return;
+
+ LOGI("input window(crop):");
+ dump_crop(&crop);
+
+ crop.type = V4L2_BUF_TYPE_CAPTURE;
+ if (ioctl(fd, VIDIOC_G_CROP, &crop) < 0)
+ return;
+
+ LOGI("output crop:");
+ dump_crop(&crop);
+
+}
+
+int fimc_v4l2_query_buf(int fd, SecBuffer *secBuf, enum v4l2_buf_type type, enum v4l2_memory memory, int buf_index, int num_plane)
+{
+ struct v4l2_buffer buf;
+ memset(&buf, 0, sizeof(struct v4l2_buffer));
+
+#ifdef BOARD_USE_V4L2
+ struct v4l2_plane planes[MAX_PLANES];
+ for (int i = 0; i < MAX_PLANES; i++)
+ memset(&planes[i], 0, sizeof(struct v4l2_plane));
+#endif
+
+ if (MAX_DST_BUFFERS <= buf_index || MAX_PLANES <= num_plane) {
+ LOGE("%s::exceed MAX! : buf_index=%d, num_plane=%d", __func__, buf_index, num_plane);
+ return -1;
+ }
+
+ buf.type = type;
+ buf.memory = V4L2_MEMORY_MMAP;
+ buf.index = buf_index;
+#ifdef BOARD_USE_V4L2
+ buf.m.planes = planes;
+ buf.length = num_plane;
+#endif
+
+ if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) {
+ LOGE("%s::VIDIOC_QUERYBUF failed, plane_cnt=%d", __func__, buf.length);
+ return -1;
+ }
+
+#ifdef BOARD_USE_V4L2
+ for (int i = 0; i < num_plane; i++) {
+ secBuf->phys.extP[i] = (unsigned int)buf.m.planes[i].cookie;
+ secBuf->size.extS[i] = buf.m.planes[i].length;
+
+ if ((secBuf->virt.extP[i] = (char *)mmap(0, buf.m.planes[i].length,
+ PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.planes[i].m.mem_offset)) < 0) {
+ LOGE("%s::mmap failed", __func__);
+ LOGE("%s::Offset = 0x%x", __func__, buf.m.planes[i].m.mem_offset);
+ LOGE("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
+ LOGE("%s::vaddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
+ LOGE("%s::paddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->phys.extP[i]);
+ return -1;
+ }
+ }
+#else
+ secBuf->size.s = buf.length;
+
+ if ((secBuf->virt.p = (char *)mmap(0, buf.length,
+ PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset)) < 0) {
+ LOGE("%s::mmap failed", __func__);
+ return -1;
+ }
+ LOGI("%s::buffers[%d] vaddr = 0x%x", __func__, buf_index, (unsigned int)secBuf->virt.p);
+#endif
+
+ return 0;
+}
+
+int fimc_v4l2_req_buf(int fd, unsigned int num_bufs, enum v4l2_buf_type type, enum v4l2_memory memory)
+{
+ struct v4l2_requestbuffers reqbuf;
+
+ reqbuf.type = type;
+ reqbuf.memory = memory;
+ reqbuf.count = num_bufs;
+
+ if (ioctl(fd, VIDIOC_REQBUFS, &reqbuf) < 0) {
+ LOGE("%s::VIDIOC_REQBUFS failed", __func__);
+ return -1;
+ }
+
+#ifdef DEBUG_LIB_FIMC
+ LOGI("%d buffers allocated %d requested", reqbuf.count, 4);
+#endif
+
+ if (reqbuf.count < num_bufs) {
+ LOGE("%s::VIDIOC_REQBUFS failed ((reqbuf.count(%d) < num_bufs(%d))",
+ __func__, reqbuf.count, num_bufs);
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_s_ctrl(int fd, int id, int value)
+{
+ struct v4l2_control vc;
+ vc.id = id;
+ vc.value = value;
+
+ if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
+ LOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, id, value);
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_set_fmt(int fd, enum v4l2_buf_type type, enum v4l2_field field, s5p_fimc_img_info *img_info, unsigned int addr)
+{
+ struct v4l2_framebuffer fbuf;
+ struct v4l2_format fmt;
+ struct v4l2_crop crop;
+ struct fimc_buf fimc_dst_buf;
+ struct v4l2_control vc;
+
+ fmt.type = type;
+ if (ioctl(fd, VIDIOC_G_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_G_FMT failed", __func__);
+ return -1;
+ }
+
+ switch (fmt.type) {
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+ fmt.fmt.pix.width = img_info->full_width;
+ fmt.fmt.pix.height = img_info->full_height;
+ fmt.fmt.pix.pixelformat = img_info->color_space;
+ fmt.fmt.pix.field = field;
+ break;
+#ifdef BOARD_USE_V4L2
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
+ fmt.fmt.pix_mp.width = img_info->full_width;
+ fmt.fmt.pix_mp.height = img_info->full_height;
+ fmt.fmt.pix_mp.pixelformat = img_info->color_space;
+ fmt.fmt.pix_mp.field = field;
+ fmt.fmt.pix_mp.num_planes = img_info->planes;
+ break;
+#endif
+ case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+ if (ioctl(fd, VIDIOC_G_FBUF, &fbuf) < 0) {
+ LOGE("%s::VIDIOC_G_FBUF failed", __func__);
+ return -1;
+ }
+
+ fbuf.base = (void *)addr;
+ fbuf.fmt.width = img_info->full_width;
+ fbuf.fmt.height = img_info->full_height;
+ fbuf.fmt.pixelformat = img_info->color_space;
+
+ if (ioctl(fd, VIDIOC_S_FBUF, &fbuf) < 0) {
+ LOGE("%s::VIDIOC_S_FBUF (w=%d, h=%d, color=%d) failed",
+ __func__,
+ img_info->full_width,
+ img_info->full_height,
+ img_info->color_space);
+ return -1;
+ }
+
+ fimc_dst_buf.base[0] = (unsigned int)img_info->buf_addr_phy_rgb_y;
+ fimc_dst_buf.base[1] = (unsigned int)img_info->buf_addr_phy_cb;
+ fimc_dst_buf.base[2] = (unsigned int)img_info->buf_addr_phy_cr;
+
+ vc.id = V4L2_CID_DST_INFO;
+ vc.value = (unsigned int)&fimc_dst_buf.base[0];
+
+ if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
+ LOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, vc.id, vc.value);
+ return -1;
+ }
+
+ fmt.fmt.win.w.left = img_info->start_x;
+ fmt.fmt.win.w.top = img_info->start_y;
+ fmt.fmt.win.w.width = img_info->width;
+ fmt.fmt.win.w.height = img_info->height;
+ break;
+ default:
+ LOGE("invalid buffer type");
+ return -1;
+ break;
+ }
+
+ if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_S_FMT failed", __func__);
+ return -1;
+ }
+
+ if (fmt.type != V4L2_BUF_TYPE_VIDEO_OVERLAY) {
+ crop.type = type;
+ crop.c.left = img_info->start_x;
+ crop.c.top = img_info->start_y;
+ crop.c.width = img_info->width;
+ crop.c.height = img_info->height;
+
+ if (ioctl(fd, VIDIOC_S_CROP, &crop) < 0) {
+ LOGE("%s::VIDIOC_S_CROP (x=%d, y=%d, w=%d, h=%d) failed",
+ __func__,
+ img_info->start_x,
+ img_info->start_y,
+ img_info->width,
+ img_info->height);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_stream_on(int fd, enum v4l2_buf_type type)
+{
+ if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) {
+ LOGE("%s::VIDIOC_STREAMON failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_queue(int fd, SecBuffer *secBuf, enum v4l2_buf_type type, enum v4l2_memory memory, int index, int num_plane)
+{
+ struct v4l2_buffer buf;
+ memset(&buf, 0, sizeof(struct v4l2_buffer));
+
+#ifdef BOARD_USE_V4L2
+ struct v4l2_plane planes[MAX_PLANES];
+ for (int i = 0; i < MAX_PLANES; i++)
+ memset(&planes[i], 0, sizeof(struct v4l2_plane));
+#else
+ struct fimc_buf fimcbuf;
+#endif
+
+ buf.type = type;
+ buf.memory = memory;
+ buf.length = num_plane;
+ buf.index = index;
+#ifdef BOARD_USE_V4L2
+ buf.m.planes = planes;
+
+ for (unsigned int i = 0; i < buf.length; i++) {
+ buf.m.planes[i].length = secBuf->size.extS[i];
+ buf.m.planes[i].m.userptr = (unsigned long)secBuf->phys.extP[i];
+ }
+#else
+ for (int i = 0; i < 3 ; i++) {
+ fimcbuf.base[i] = secBuf->phys.extP[i];
+ fimcbuf.length[i] = secBuf->size.extS[i];
+ }
+
+ buf.m.userptr = (unsigned long)(&fimcbuf);
+ //buf.m.userptr = secBuf->phys.p;
+#endif
+
+ if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
+ LOGE("%s::VIDIOC_QBUF failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_dequeue(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int *index, int num_plane)
+{
+ struct v4l2_buffer buf;
+ memset(&buf, 0, sizeof(struct v4l2_buffer));
+
+#ifdef BOARD_USE_V4L2
+ struct v4l2_plane planes[MAX_PLANES];
+ for (int i = 0; i < MAX_PLANES; i++)
+ memset(&planes[i], 0, sizeof(struct v4l2_plane));
+#endif
+
+ buf.type = type;
+ buf.memory = memory;
+ buf.length = num_plane;
+#ifdef BOARD_USE_V4L2
+ buf.m.planes = planes;
+#endif
+ if (ioctl(fd, VIDIOC_DQBUF, &buf) < 0) {
+ LOGE("%s::VIDIOC_DQBUF failed", __func__);
+ return -1;
+ }
+ *index = buf.index;
+
+ return 0;
+}
+
+int fimc_v4l2_stream_off(int fd, enum v4l2_buf_type type)
+{
+ if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) {
+ LOGE("%s::VIDIOC_STREAMOFF failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_clr_buf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory)
+{
+ struct v4l2_requestbuffers req;
+
+ req.count = 0;
+ req.type = type;
+ req.memory = memory;
+
+ if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
+ LOGE("%s::VIDIOC_REQBUFS", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+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;
+}
+
+extern "C" SecFimc* create_instance()
+{
+ return new SecFimc;
+}
+
+extern "C" void destroy_instance(SecFimc* handle)
+{
+ if (handle != NULL)
+ delete handle;
+}
+
+SecFimc::SecFimc()
+: mFlagCreate(false)
+{
+ memset(&mFimcCap, 0, sizeof(struct v4l2_capability));
+ memset(&mS5pFimc, 0, sizeof(s5p_fimc_t));
+
+ mRotVal = 0;
+ mRealDev = -1;
+ mNumOfBuf = 0;
+ mHwVersion = 0;
+ mGlobalAlpha = 0x0;
+ mFlagStreamOn = false;
+ mFlagSetSrcParam = false;
+ mFlagSetDstParam = false;
+ mFlagGlobalAlpha = false;
+ mFlagLocalAlpha = false;
+ mFlagColorKey = false;
+ mFimcMode = 0;
+ mFd = 0;
+ mDev = 0;
+ mColorKey = 0x0;
+}
+
+SecFimc::~SecFimc()
+{
+ if (mFlagCreate == true) {
+ LOGE("%s::this is not Destroyed fail", __func__);
+ if (destroy() == false)
+ LOGE("%s::destroy failed", __func__);
+ }
+}
+
+bool SecFimc::create(enum DEV dev, enum MODE mode, int numOfBuf)
+{
+ if (mFlagCreate == true) {
+ LOGE("%s::Already Created fail", __func__);
+ return false;
+ }
+
+ char node[20];
+ struct v4l2_format fmt;
+ struct v4l2_control vc;
+ SecBuffer zeroBuf;
+
+ mDev = dev;
+ mRealDev = dev;
+
+ switch (mode) {
+ case MODE_SINGLE_BUF:
+ mFimcMode = FIMC_OVLY_NONE_SINGLE_BUF;
+ break;
+ case MODE_MULTI_BUF:
+ mFimcMode = FIMC_OVLY_NONE_MULTI_BUF;
+ break;
+ case MODE_DMA_AUTO:
+ mFimcMode = FIMC_OVLY_DMA_AUTO;
+ break;
+ default:
+ LOGE("%s::Invalid mode(%d) fail", __func__, mode);
+ mFimcMode = FIMC_OVLY_NOT_FIXED;
+ goto err;
+ break;
+ }
+
+ mNumOfBuf = numOfBuf;
+
+ for (int i = 0; i < MAX_DST_BUFFERS; i++)
+ mDstBuffer[i] = zeroBuf;
+
+#ifdef BOARD_USE_V4L2
+ switch(mDev) {
+ case DEV_0:
+ mRealDev = 0;
+ break;
+ case DEV_1:
+ mRealDev = 2;
+ break;
+ case DEV_2:
+ mRealDev = 4;
+ break;
+ case DEV_3:
+ mRealDev = 5;
+ break;
+ default:
+ LOGE("%s::invalid mDev(%d)", __func__, mDev);
+ goto err;
+ break;
+ }
+#endif
+
+ sprintf(node, "%s%d", PFX_NODE_FIMC, (int)mRealDev);
+
+ mFd = open(node, O_RDWR);
+ if (mFd < 0) {
+ LOGE("%s::open(%s) failed", __func__, node);
+ mFd = 0;
+ goto err;
+ }
+
+ /* check capability */
+ if (ioctl(mFd, VIDIOC_QUERYCAP, &mFimcCap) < 0) {
+ LOGE("%s::VIDIOC_QUERYCAP failed", __func__);
+ goto err;
+ }
+
+ if (!(mFimcCap.capabilities & V4L2_CAP_STREAMING)) {
+ LOGE("%s::%s has no streaming support", __func__, node);
+ goto err;
+ }
+
+#ifdef BOARD_USE_V4L2
+ if (!(mFimcCap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)) {
+ LOGE("%s::%s is no video output mplane", __func__, node);
+ goto err;
+ }
+
+ if (!(mFimcCap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)) {
+ LOGE("%s::%s is no video capture mplane", __func__, node);
+ goto err;
+ }
+#else
+ if (!(mFimcCap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
+ LOGE("%s::%s is no video output", __func__, node);
+ goto err;
+ }
+
+ fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+ if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_G_FMT failed", __func__);
+ goto err;
+ }
+
+ vc.id = V4L2_CID_RESERVED_MEM_BASE_ADDR;
+ vc.value = 0;
+ if (ioctl(mFd, VIDIOC_G_CTRL, &vc) < 0) {
+ LOGE("%s::VIDIOC_G_CTRL - V4L2_CID_RESERVED_MEM_BAES_ADDR", __func__);
+ goto err;
+ }
+
+ mDstBuffer[0].phys.p = (unsigned int)vc.value;
+
+ mS5pFimc.out_buf.phys_addr = (void *)mDstBuffer[0].phys.p;
+
+ vc.id = V4L2_CID_FIMC_VERSION;
+ vc.value = 0;
+ if (ioctl(mFd, VIDIOC_G_CTRL, &vc) < 0) {
+ LOGE("%s::VIDIOC_G_CTRL - V4L2_CID_FIMC_VERSION failed, FIMC version is set with default", __func__);
+ vc.value = 0x43;
+ }
+
+ mHwVersion = vc.value;
+
+ vc.id = V4L2_CID_OVLY_MODE;
+ vc.value = mFimcMode;
+ if (ioctl(mFd, VIDIOC_S_CTRL, &vc) < 0) {
+ LOGE("%s::VIDIOC_S_CTRL - V4L2_CID_OVLY_MODE failed", __func__);
+ goto err;
+ }
+#endif
+
+ mFlagCreate = true;
+
+ return true;
+
+err :
+ if (0 < mFd)
+ close(mFd);
+ mFd = 0;
+
+ return false;
+}
+
+bool SecFimc::destroy()
+{
+ s5p_fimc_params_t *params = &(mS5pFimc.params);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Already Destroyed fail", __func__);
+ return false;
+ }
+
+ if (mFlagStreamOn == true) {
+ if (fimc_v4l2_stream_off(mFd, V4L2_BUF_TYPE_SRC) < 0) {
+ LOGE("%s::fimc_v4l2_stream_off() failed", __func__);
+ return false;
+ }
+#ifdef BOARD_USE_V4L2
+ if (fimc_v4l2_stream_off(mFd, V4L2_BUF_TYPE_DST) < 0) {
+ LOGE("%s::fimc_v4l2_stream_off() failed", __func__);
+ return false;
+ }
+#endif
+ mFlagStreamOn = false;
+ }
+
+ if (fimc_v4l2_clr_buf(mFd, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC) < 0) {
+ LOGE("%s::fimc_v4l2_clr_buf()[src] failed", __func__);
+ return false;
+ }
+
+#ifdef BOARD_USE_V4L2
+ if (fimc_v4l2_clr_buf(mFd, V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST) < 0) {
+ LOGE("%s::fimc_v4l2_clr_buf()[dst] failed", __func__);
+ return false;
+ }
+#endif
+ if (mS5pFimc.out_buf.phys_addr != NULL) {
+ mS5pFimc.out_buf.phys_addr = NULL;
+ mS5pFimc.out_buf.length = 0;
+ }
+
+ if (0 < mFd)
+ close(mFd);
+ mFd = 0;
+
+ mFlagCreate = false;
+
+ return true;
+}
+
+bool SecFimc::flagCreate(void)
+{
+ return mFlagCreate;
+}
+
+int SecFimc::getFd(void)
+{
+ return mFd;
+}
+
+SecBuffer * SecFimc::getMemAddr(int index)
+{
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ return &mDstBuffer[index];
+}
+
+int SecFimc::getHWVersion(void)
+{
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ return mHwVersion;
+}
+
+bool SecFimc::setSrcParams(unsigned int width, unsigned int height,
+ unsigned int cropX, unsigned int cropY,
+ unsigned int *cropWidth, unsigned int *cropHeight,
+ int colorFormat,
+ bool forceChange)
+{
+#ifdef DEBUG_LIB_FIMC
+ LOGD("%s", __func__);
+#endif
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(colorFormat);
+ if (v4l2ColorFormat < 0) {
+ LOGE("%s::not supported color format", __func__);
+ return false;
+ }
+
+ s5p_fimc_params_t *params = &(mS5pFimc.params);
+
+ unsigned int fimcWidth = *cropWidth;
+ unsigned int fimcHeight = *cropHeight;
+ int src_planes = m_getYuvPlanes(v4l2ColorFormat);
+
+ m_checkSrcSize(width, height,
+ cropX, cropY,
+ &fimcWidth, &fimcHeight,
+ v4l2ColorFormat,
+ false);
+
+ if (fimcWidth != *cropWidth || fimcHeight != *cropHeight) {
+ if (forceChange == true) {
+#ifdef DEBUG_LIB_FIMC
+ LOGD("size is changed from [w = %d, h= %d] to [w = %d, h = %d]",
+ *cropWidth, *cropHeight, fimcWidth, fimcHeight);
+#endif
+ } else {
+ LOGE("%s::invalid source params", __func__);
+ return false;
+ }
+ }
+
+ if ( (params->src.full_width == width)
+ && (params->src.full_height == height)
+ && (params->src.start_x == cropX)
+ && (params->src.start_y == cropY)
+ && (params->src.width == fimcWidth)
+ && (params->src.height == fimcHeight)
+ && (params->src.color_space == (unsigned int)v4l2ColorFormat))
+ return true;
+
+ params->src.full_width = width;
+ params->src.full_height = height;
+ params->src.start_x = cropX;
+ params->src.start_y = cropY;
+ params->src.width = fimcWidth;
+ params->src.height = fimcHeight;
+ params->src.color_space = v4l2ColorFormat;
+ src_planes = (src_planes == -1) ? 1 : src_planes;
+
+ if (mFlagSetSrcParam == true) {
+ if (fimc_v4l2_clr_buf(mFd, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC) < 0) {
+ LOGE("%s::fimc_v4l2_clr_buf_src() failed", __func__);
+ return false;
+ }
+ }
+
+ if (fimc_v4l2_set_fmt(mFd, V4L2_BUF_TYPE_SRC, V4L2_FIELD_NONE, &(params->src), 0) < 0) {
+ LOGE("%s::fimc_v4l2_set_fmt()[src] failed", __func__);
+ return false;
+ }
+
+ if (fimc_v4l2_req_buf(mFd, 1, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC) < 0) {
+ LOGE("%s::fimc_v4l2_req_buf()[src] failed", __func__);
+ return false;
+ }
+
+ *cropWidth = fimcWidth;
+ *cropHeight = fimcHeight;
+
+ mFlagSetSrcParam = true;
+ return true;
+}
+
+bool SecFimc::getSrcParams(unsigned int *width, unsigned int *height,
+ unsigned int *cropX, unsigned int *cropY,
+ unsigned int *cropWidth, unsigned int *cropHeight,
+ int *colorFormat)
+{
+ struct v4l2_format fmt;
+ struct v4l2_crop crop;
+
+ fmt.type = V4L2_BUF_TYPE_SRC;
+
+ if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_G_FMT(fmt.type : %d) failed", __func__, fmt.type);
+ return false;
+ }
+
+ switch (fmt.type) {
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+ case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+ *width = fmt.fmt.pix.width;
+ *height = fmt.fmt.pix.height;
+ *colorFormat = fmt.fmt.pix.pixelformat;
+ break;
+#ifdef BOARD_USE_V4L2
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
+ *width = fmt.fmt.pix_mp.width;
+ *height = fmt.fmt.pix_mp.height;
+ *colorFormat = fmt.fmt.pix_mp.pixelformat;
+ break;
+#endif
+ default:
+ LOGE("%s::Invalid buffer type", __func__);
+ return false;
+ break;
+ }
+
+ crop.type = V4L2_BUF_TYPE_SRC;
+ if (ioctl(mFd, VIDIOC_G_CROP, &crop) < 0) {
+ LOGE("%s::VIDIOC_G_CROP failed", __func__);
+ return false;
+ }
+
+ *cropX = crop.c.left;
+ *cropY = crop.c.top;
+ *cropWidth = crop.c.width;
+ *cropHeight = crop.c.height;
+
+ return true;
+}
+
+bool SecFimc::setSrcAddr(unsigned int physYAddr,
+ unsigned int physCbAddr,
+ unsigned int physCrAddr,
+ int colorFormat)
+{
+#ifdef DEBUG_LIB_FIMC
+ LOGD("%s", __func__);
+#endif
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ s5p_fimc_params_t *params = &(mS5pFimc.params);
+ int src_planes = m_getYuvPlanes(params->src.color_space);
+ int src_bpp = m_getYuvBpp(params->src.color_space);
+ unsigned int frame_size = params->src.full_width * params->src.full_height;
+ src_planes = (src_planes == -1) ? 1 : src_planes;
+
+ mSrcBuffer.phys.extP[0] = physYAddr;
+
+ if (colorFormat == HAL_PIXEL_FORMAT_YV12) {
+ mSrcBuffer.phys.extP[1] = physCrAddr;
+ mSrcBuffer.phys.extP[2] = physCbAddr;
+ } else {
+ mSrcBuffer.phys.extP[1] = physCbAddr;
+ mSrcBuffer.phys.extP[2] = physCrAddr;
+ }
+
+ if (2 <= src_planes && mSrcBuffer.phys.extP[1] == 0)
+ mSrcBuffer.phys.extP[1] = mSrcBuffer.phys.extP[0] + frame_size;
+
+ if (3 == src_planes && mSrcBuffer.phys.extP[2] == 0) {
+ if (colorFormat == HAL_PIXEL_FORMAT_YV12) {
+ if (12 == src_bpp)
+ mSrcBuffer.phys.extP[1] = mSrcBuffer.phys.extP[2] + (frame_size >> 2);
+ else
+ mSrcBuffer.phys.extP[1] = mSrcBuffer.phys.extP[2] + (frame_size >> 1);
+ } else {
+ if (12 == src_bpp)
+ mSrcBuffer.phys.extP[2] = mSrcBuffer.phys.extP[1] + (frame_size >> 2);
+ else
+ mSrcBuffer.phys.extP[2] = mSrcBuffer.phys.extP[1] + (frame_size >> 1);
+ }
+ }
+
+ return true;
+}
+
+bool SecFimc::setDstParams(unsigned int width, unsigned int height,
+ unsigned int cropX, unsigned int cropY,
+ unsigned int *cropWidth, unsigned int *cropHeight,
+ int colorFormat,
+ bool forceChange)
+{
+#ifdef DEBUG_LIB_FIMC
+ LOGD("%s", __func__);
+#endif
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(colorFormat);
+ if (v4l2ColorFormat < 0) {
+ LOGE("%s::not supported color format", __func__);
+ return false;
+ }
+
+ s5p_fimc_params_t *params = &(mS5pFimc.params);
+
+ unsigned int fimcWidth = *cropWidth;
+ unsigned int fimcHeight = *cropHeight;
+ int dst_planes = m_getYuvPlanes(v4l2ColorFormat);
+
+ m_checkDstSize(width, height,
+ cropX, cropY,
+ &fimcWidth, &fimcHeight,
+ v4l2ColorFormat,
+ mRotVal,
+ true);
+
+ if (fimcWidth != *cropWidth || fimcHeight != *cropHeight) {
+ if (forceChange == true) {
+#ifdef DEBUG_LIB_FIMC
+ LOGD("size is changed from [w = %d, h= %d] to [w = %d, h = %d]",
+ *cropWidth, *cropHeight, fimcWidth, fimcHeight);
+#endif
+ } else {
+ LOGE("%s::Invalid destination params", __func__);
+ return false;
+ }
+ }
+
+ if (90 == mRotVal || 270 == mRotVal) {
+ params->dst.full_width = height;
+ params->dst.full_height = width;
+
+ if (90 == mRotVal) {
+ params->dst.start_x = cropY;
+ params->dst.start_y = width - (cropX + fimcWidth);
+ } else {
+ params->dst.start_x = height - (cropY + fimcHeight);
+ params->dst.start_y = cropX;
+ }
+
+ params->dst.width = fimcHeight;
+ params->dst.height = fimcWidth;
+
+ if (0x50 != mHwVersion)
+ params->dst.start_y += (fimcWidth - params->dst.height);
+
+ } else {
+ params->dst.full_width = width;
+ params->dst.full_height = height;
+
+ if (180 == mRotVal) {
+ params->dst.start_x = width - (cropX + fimcWidth);
+ params->dst.start_y = height - (cropY + fimcHeight);
+ } else {
+ params->dst.start_x = cropX;
+ params->dst.start_y = cropY;
+ }
+
+ params->dst.width = fimcWidth;
+ params->dst.height = fimcHeight;
+ }
+ params->dst.color_space = v4l2ColorFormat;
+ dst_planes = (dst_planes == -1) ? 1 : dst_planes;
+
+#ifdef BOARD_USE_V4L2
+ if (mFlagSetDstParam == true) {
+ if (fimc_v4l2_clr_buf(mFd, V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST) < 0) {
+ LOGE("%s::fimc_v4l2_clr_buf_dst() failed", __func__);
+ return false;
+ }
+ }
+#endif
+
+ if (fimc_v4l2_s_ctrl(mFd, V4L2_ROTATE, mRotVal) < 0) {
+ LOGE("%s::fimc_v4l2_s_ctrl(V4L2_ROTATE)", __func__);
+ return false;
+ }
+
+ if (fimc_v4l2_set_fmt(mFd, V4L2_BUF_TYPE_DST, V4L2_FIELD_ANY, &(params->dst), (unsigned int)mS5pFimc.out_buf.phys_addr) < 0) {
+ LOGE("%s::fimc_v4l2_set_fmt()[dst] failed", __func__);
+ return false;
+ }
+
+#ifdef BOARD_USE_V4L2
+ if (fimc_v4l2_req_buf(mFd, mNumOfBuf, V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST) < 0) {
+ LOGE("%s::fimc_v4l2_req_buf()[dst] failed", __func__);
+ return false;
+ }
+
+ for (int i = 0; i < mNumOfBuf; i++) {
+ if (fimc_v4l2_query_buf(mFd, &(mDstBuffer[i]),
+ V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST, i, dst_planes) < 0) {
+ LOGE("%s::fimc_v4l2_query_buf() failed", __func__);
+ }
+ }
+#endif
+
+ *cropWidth = fimcWidth;
+ *cropHeight = fimcHeight;
+
+ mFlagSetDstParam = true;
+ return true;
+}
+
+bool SecFimc::getDstParams(unsigned int *width, unsigned int *height,
+ unsigned int *cropX, unsigned int *cropY,
+ unsigned int *cropWidth, unsigned int *cropHeight,
+ int *colorFormat)
+{
+ struct v4l2_framebuffer fbuf;
+ struct v4l2_format fmt;
+ struct v4l2_crop crop;
+
+ fmt.type = V4L2_BUF_TYPE_DST;
+ if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_G_FMT(fmt.type : %d) failed", __func__, fmt.type);
+ return false;
+ }
+ switch (fmt.type) {
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+ *width = fmt.fmt.pix.width;
+ *height = fmt.fmt.pix.height;
+ *colorFormat = fmt.fmt.pix.pixelformat;
+ break;
+#ifdef BOARD_USE_V4L2
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
+ *width = fmt.fmt.pix_mp.width;
+ *height = fmt.fmt.pix_mp.height;
+ *colorFormat = fmt.fmt.pix_mp.pixelformat;
+ break;
+#endif
+ case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+ *cropX = fmt.fmt.win.w.left;
+ *cropY = fmt.fmt.win.w.top;
+ *cropWidth = fmt.fmt.win.w.width;
+ *cropHeight = fmt.fmt.win.w.height;
+
+ if (ioctl(mFd, VIDIOC_G_FBUF, &fbuf) < 0) {
+ LOGE("%s::VIDIOC_G_FBUF failed", __func__);
+ return false;
+ }
+
+ *width = fbuf.fmt.width;
+ *height = fbuf.fmt.height;
+ *colorFormat = fbuf.fmt.pixelformat;
+ break;
+ default:
+ LOGE("%s::Invalid buffer type", __func__);
+ return false;
+ break;
+ }
+
+ if (fmt.type != V4L2_BUF_TYPE_VIDEO_OVERLAY) {
+
+ crop.type = V4L2_BUF_TYPE_DST;
+ if (ioctl(mFd, VIDIOC_G_CROP, &crop) < 0) {
+ LOGE("%s::VIDIOC_G_CROP(crop.type : %d) failed", __func__, crop.type);
+ return false;
+ }
+
+ *cropX = crop.c.left;
+ *cropY = crop.c.top;
+ *cropWidth = crop.c.width;
+ *cropHeight = crop.c.height;
+ }
+
+ return true;
+}
+
+bool SecFimc::setDstAddr(unsigned int physYAddr, unsigned int physCbAddr, unsigned int physCrAddr, int buf_index)
+{
+#ifdef DEBUG_LIB_FIMC
+ LOGD("%s", __func__);
+#endif
+
+ s5p_fimc_params_t *params = &(mS5pFimc.params);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ mS5pFimc.out_buf.phys_addr = (void *)physYAddr;
+
+ mDstBuffer[buf_index].phys.extP[0] = physYAddr;
+ mDstBuffer[buf_index].phys.extP[1] = physCbAddr;
+ mDstBuffer[buf_index].phys.extP[2] = physCrAddr;
+
+#ifdef BOARD_USE_V4L2
+ if (physYAddr != 0)
+ mS5pFimc.use_ext_out_mem = 1;
+#else
+ params->dst.buf_addr_phy_rgb_y = physYAddr;
+ params->dst.buf_addr_phy_cb = physCbAddr;
+ params->dst.buf_addr_phy_cr = physCrAddr;
+
+ if ((physYAddr != 0)
+ && ((unsigned int)mS5pFimc.out_buf.phys_addr != mDstBuffer[0].phys.p))
+ mS5pFimc.use_ext_out_mem = 1;
+
+ if (fimc_v4l2_s_ctrl(mFd, V4L2_ROTATE, mRotVal) < 0) {
+ LOGE("%s::fimc_v4l2_s_ctrl(V4L2_ROTATE)", __func__);
+ return false;
+ }
+
+ if (fimc_v4l2_set_fmt(mFd, V4L2_BUF_TYPE_DST, V4L2_FIELD_ANY, &(params->dst), (unsigned int)mS5pFimc.out_buf.phys_addr) < 0) {
+ LOGE("%s::fimc_v4l2_set_fmt()[dst] failed", __func__);
+ return false;
+ }
+#endif
+
+ return true;
+}
+
+bool SecFimc::setRotVal(unsigned int rotVal)
+{
+ struct v4l2_control vc;
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ if (fimc_v4l2_s_ctrl(mFd, V4L2_ROTATE, rotVal) < 0) {
+ LOGE("%s::fimc_v4l2_s_ctrl(V4L2_ROTATE) failed", __func__);
+ return false;
+ }
+
+ mRotVal = rotVal;
+ return true;
+}
+
+bool SecFimc::setGlobalAlpha(bool enable, int alpha)
+{
+ struct v4l2_framebuffer fbuf;
+ struct v4l2_format fmt;
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ if (mFlagStreamOn == true) {
+ LOGE("%s::mFlagStreamOn == true", __func__);
+ return false;
+ }
+
+ if (mFlagGlobalAlpha == enable && mGlobalAlpha == alpha)
+ return true;
+
+ memset(&fbuf, 0, sizeof(fbuf));
+
+ if (ioctl(mFd, VIDIOC_G_FBUF, &fbuf) < 0) {
+ LOGE("%s::VIDIOC_G_FBUF failed", __func__);
+ return false;
+ }
+
+ if (enable)
+ fbuf.flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
+ else
+ fbuf.flags &= ~V4L2_FBUF_FLAG_GLOBAL_ALPHA;
+
+ if (ioctl(mFd, VIDIOC_S_FBUF, &fbuf) < 0) {
+ LOGE("%s::VIDIOC_S_FBUF failed", __func__);
+ return false;
+ }
+
+ if (enable) {
+ memset(&fmt, 0, sizeof(fmt));
+ fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
+
+ if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_G_FMT failed", __func__);
+ return false;
+ }
+
+ fmt.fmt.win.global_alpha = alpha & 0xFF;
+ if (ioctl(mFd, VIDIOC_S_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_S_FMT failed", __func__);
+ return false;
+ }
+ }
+
+ mFlagGlobalAlpha = enable;
+ mGlobalAlpha = alpha;
+
+ return true;
+
+}
+
+bool SecFimc::setLocalAlpha(bool enable)
+{
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ if (mFlagStreamOn == true) {
+ LOGE("%s::mFlagStreamOn == true", __func__);
+ return false;
+ }
+
+ if (mFlagLocalAlpha == enable)
+ return true;
+
+ return true;
+}
+
+bool SecFimc::setColorKey(bool enable, int colorKey)
+{
+ struct v4l2_framebuffer fbuf;
+ struct v4l2_format fmt;
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ if (mFlagStreamOn == true) {
+ LOGE("%s::mFlagStreamOn == true", __func__);
+ return false;
+ }
+
+ if (mFlagColorKey == enable && mColorKey == colorKey)
+ return true;
+
+ memset(&fbuf, 0, sizeof(fbuf));
+
+ if (ioctl(mFd, VIDIOC_G_FBUF, &fbuf) < 0) {
+ LOGE("%s::VIDIOC_G_FBUF failed", __func__);
+ return false;
+ }
+
+ if (enable)
+ fbuf.flags |= V4L2_FBUF_FLAG_CHROMAKEY;
+ else
+ fbuf.flags &= ~V4L2_FBUF_FLAG_CHROMAKEY;
+
+ if (ioctl(mFd, VIDIOC_S_FBUF, &fbuf) < 0) {
+ LOGE("%s::VIDIOC_S_FBUF failed", __func__);
+ return false;
+ }
+
+ if (enable) {
+ memset(&fmt, 0, sizeof(fmt));
+ fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
+
+ if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_G_FMT failed", __func__);
+ return false;
+ }
+
+ fmt.fmt.win.chromakey = colorKey & 0xFFFFFF;
+
+ if (ioctl(mFd, VIDIOC_S_FMT, &fmt) < 0)
+ LOGE("%s::VIDIOC_S_FMT failed", __func__);
+ }
+ mFlagColorKey = enable;
+ mColorKey = colorKey;
+ return true;
+}
+
+bool SecFimc::draw(int src_index, int dst_index)
+{
+#ifdef DEBUG_LIB_FIMC
+ LOGD("%s", __func__);
+#endif
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not yet created", __func__);
+ return false;
+ }
+
+ if (mFlagSetSrcParam == false) {
+ LOGE("%s::mFlagSetSrcParam == false fail", __func__);
+ return false;
+ }
+
+ if (mFlagSetDstParam == false) {
+ LOGE("%s::mFlagSetDstParam == false fail", __func__);
+ return false;
+ }
+
+ s5p_fimc_params_t *params = &(mS5pFimc.params);
+ bool flagStreamOn = false;
+ int src_planes = m_getYuvPlanes(params->src.color_space);
+ int dst_planes = m_getYuvPlanes(params->dst.color_space);
+ src_planes = (src_planes == -1) ? 1 : src_planes;
+ dst_planes = (dst_planes == -1) ? 1 : dst_planes;
+
+#ifdef BOARD_USE_V4L2
+ if (mFlagStreamOn == false) {
+ if (m_streamOn() == false) {
+ LOGE("%s::m_streamOn failed", __func__);
+ return false;
+ }
+ mFlagStreamOn = true;
+ }
+ if (fimc_v4l2_dequeue(mFd, V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST, &dst_index, dst_planes) < 0) {
+ LOGE("%s::fimc_v4l2_dequeue[dst](mNumOfBuf : %d) failed", __func__, mNumOfBuf);
+ return false;
+ }
+
+ if (fimc_v4l2_dequeue(mFd, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, &src_index, src_planes) < 0) {
+ LOGE("%s::fimc_v4l2_dequeue[src](mNumOfBuf : %d) failed", __func__, mNumOfBuf);
+ return false;
+ }
+
+ if (fimc_v4l2_queue(mFd, &(mSrcBuffer), V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, src_index, src_planes) < 0) {
+ LOGE("%s::fimc_v4l2_queue[src](index : %d) (mNumOfBuf : %d) failed", __func__, 0, mNumOfBuf);
+ return false;
+ }
+
+ if (fimc_v4l2_queue(mFd, &(mDstBuffer[dst_index]), V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST, dst_index, dst_planes) < 0) {
+ LOGE("%s::fimc_v4l2_queue[dst](index : %d) (mNumOfBuf : %d) failed", __func__, dst_index, mNumOfBuf);
+ return false;
+ }
+#else
+ if (fimc_v4l2_stream_on(mFd, V4L2_BUF_TYPE_SRC) < 0) {
+ LOGE("%s::fimc_v4l2_stream_on() failed", __func__);
+ goto err;
+ }
+
+ flagStreamOn = true;
+
+ if (fimc_v4l2_queue(mFd, &(mSrcBuffer), V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, src_index, src_planes) < 0) {
+ LOGE("%s::fimc_v4l2_queue(index : %d) (mNumOfBuf : %d) failed", __func__, 0, mNumOfBuf);
+ goto err;
+ }
+
+ if (fimc_v4l2_dequeue(mFd, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, &src_index, src_planes) < 0) {
+ LOGE("%s::fimc_v4l2_dequeue (mNumOfBuf : %d) failed", __func__, mNumOfBuf);
+ goto err;
+ }
+#endif
+
+err :
+#ifndef BOARD_USE_V4L2
+ if (flagStreamOn == true) {
+ if (fimc_v4l2_stream_off(mFd, V4L2_BUF_TYPE_SRC) < 0) {
+ LOGE("%s::fimc_v4l2_stream_off() failed", __func__);
+ return false;
+ }
+ }
+#endif
+
+ return true;
+}
+
+bool SecFimc::m_streamOn()
+{
+#ifdef DEBUG_LIB_FIMC
+ LOGD("%s", __func__);
+#endif
+
+#ifdef BOARD_USE_V4L2
+ s5p_fimc_params_t *params = &(mS5pFimc.params);
+ int src_planes = m_getYuvPlanes(params->src.color_space);
+ int dst_planes = m_getYuvPlanes(params->dst.color_space);
+ src_planes = (src_planes == -1) ? 1 : src_planes;
+ dst_planes = (dst_planes == -1) ? 1 : dst_planes;
+
+ if (params->src.color_space == V4L2_PIX_FMT_RGB32) {
+ mSrcBuffer.size.extS[0] = params->src.full_height * params->src.full_width * 4;
+
+ } else if ( (params->src.color_space == V4L2_PIX_FMT_NV12MT)
+ || (params->src.color_space == V4L2_PIX_FMT_NV12M)) {
+ mSrcBuffer.size.extS[0] = params->src.full_height * params->src.full_width;
+ mSrcBuffer.size.extS[1] = params->src.full_height * params->src.full_width / 2;
+ } else if ( (params->src.color_space == V4L2_PIX_FMT_YUV420)
+ || (params->src.color_space == V4L2_PIX_FMT_YUV420M)) {
+ mSrcBuffer.size.extS[0] = params->src.full_height * params->src.full_width;
+ mSrcBuffer.size.extS[1] = params->src.full_height * params->src.full_width / 4;
+ mSrcBuffer.size.extS[2] = params->src.full_height * params->src.full_width / 4;
+ } else {
+ mSrcBuffer.size.extS[0] = params->src.full_height * params->src.full_width * 2;
+ }
+
+ if (fimc_v4l2_queue(mFd, &(mSrcBuffer), V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, 0, src_planes) < 0) {
+ LOGE("%s::fimc_v4l2_queue(index : %d) (mSrcBufNum : %d) failed", __func__, 0, 1);
+ return false;
+ }
+
+ for (int i = 0; i < mNumOfBuf; i++) {
+ if (fimc_v4l2_queue(mFd, &(mDstBuffer[i]),
+ V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST, i, dst_planes) < 0) {
+ LOGE("%s::fimc_v4l2_queue(index : %d) (mDstBufNum : %d) failed", __func__, i, mNumOfBuf);
+ return false;
+ }
+ }
+#endif
+ if (fimc_v4l2_stream_on(mFd, V4L2_BUF_TYPE_SRC) < 0) {
+ LOGE("%s::fimc_v4l2_stream_on() failed", __func__);
+ return false;
+ }
+
+#ifdef BOARD_USE_V4L2
+ if (fimc_v4l2_stream_on(mFd, V4L2_BUF_TYPE_DST) < 0) {
+ LOGE("%s::fimc_v4l2_stream_on() failed", __func__);
+ return false;
+ }
+#endif
+ return true;
+}
+
+bool SecFimc::m_checkSrcSize(unsigned int width, unsigned int height,
+ unsigned int cropX, unsigned int cropY,
+ unsigned int *cropWidth, unsigned int *cropHeight,
+ int colorFormat,
+ bool forceChange)
+{
+ bool ret = true;
+
+ if (8 <= height && *cropHeight < 8) {
+ if (forceChange)
+ *cropHeight = 8;
+ ret = false;
+ }
+
+ if (16 <= width && *cropWidth < 16) {
+ if (forceChange)
+ *cropWidth = 16;
+ ret = false;
+ }
+
+ if (0x50 == mHwVersion) {
+ if (colorFormat == V4L2_PIX_FMT_YUV422P) {
+ if (*cropHeight % 2 != 0) {
+ if (forceChange)
+ *cropHeight = multipleOfN(*cropHeight, 2);
+ ret = false;
+ }
+ if (*cropWidth % 2 != 0) {
+ if (forceChange)
+ *cropWidth = multipleOfN(*cropWidth, 2);
+ ret = false;
+ }
+ }
+ } else {
+ if (height < 8)
+ return false;
+
+ if (width % 16 != 0)
+ return false;
+
+ if (*cropWidth % 16 != 0) {
+ if (forceChange)
+ *cropWidth = multipleOfN(*cropWidth, 16);
+ ret = false;
+ }
+ }
+
+ return ret;
+}
+
+bool SecFimc::m_checkDstSize(unsigned int width, unsigned int height,
+ unsigned int cropX, unsigned int cropY,
+ unsigned int *cropWidth, unsigned int *cropHeight,
+ int colorFormat, int rotVal, bool forceChange)
+{
+ bool ret = true;
+ unsigned int rotWidth;
+ unsigned int rotHeight;
+ unsigned int *rotCropWidth;
+ unsigned int *rotCropHeight;
+
+ if (rotVal == 90 || rotVal == 270) {
+ rotWidth = height;
+ rotHeight = width;
+ rotCropWidth = cropHeight;
+ rotCropHeight = cropWidth;
+ } else {
+ rotWidth = width;
+ rotHeight = height;
+ rotCropWidth = cropWidth;
+ rotCropHeight = cropHeight;
+ }
+
+ if (rotHeight < 8)
+ return false;
+
+ if (rotWidth % 8 != 0)
+ return false;
+
+ switch (colorFormat) {
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV12T:
+#ifdef BOARD_USE_V4L2
+ case V4L2_PIX_FMT_NV12M:
+ case V4L2_PIX_FMT_NV12MT:
+ case V4L2_PIX_FMT_YUV420M:
+#endif
+ case V4L2_PIX_FMT_YUV420:
+ if (*rotCropHeight % 2 != 0) {
+ if (forceChange)
+ *rotCropHeight = multipleOfN(*rotCropHeight, 2);
+ ret = false;
+ }
+ }
+ return ret;
+}
+
+int SecFimc::m_widthOfFimc(int v4l2ColorFormat, int width)
+{
+ int newWidth = width;
+
+ if (0x50 == mHwVersion) {
+ switch (v4l2ColorFormat) {
+ /* 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:
+#ifdef BOARD_USE_V4L2
+ case V4L2_PIX_FMT_NV12MT:
+ case V4L2_PIX_FMT_YUV420M:
+#endif
+ case V4L2_PIX_FMT_YUV420:
+
+ newWidth = multipleOfN(width, 2);
+ break;
+ default :
+ break;
+ }
+ } else {
+ switch (v4l2ColorFormat) {
+ case V4L2_PIX_FMT_RGB565:
+ newWidth = multipleOfN(width, 8);
+ break;
+ case V4L2_PIX_FMT_RGB32:
+ newWidth = multipleOfN(width, 4);
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ case V4L2_PIX_FMT_UYVY:
+ newWidth = multipleOfN(width, 4);
+ break;
+ case V4L2_PIX_FMT_NV61:
+ case V4L2_PIX_FMT_NV16:
+ newWidth = multipleOfN(width, 8);
+ break;
+ case V4L2_PIX_FMT_YUV422P:
+ newWidth = multipleOfN(width, 16);
+ break;
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV12T:
+#ifdef BOARD_USE_V4L2
+ case V4L2_PIX_FMT_NV12MT:
+#endif
+ newWidth = multipleOfN(width, 8);
+ break;
+#ifdef BOARD_USE_V4L2
+ case V4L2_PIX_FMT_YUV420M:
+#endif
+ case V4L2_PIX_FMT_YUV420:
+ newWidth = multipleOfN(width, 16);
+ break;
+ default :
+ break;
+ }
+ }
+ return newWidth;
+}
+
+int SecFimc::m_heightOfFimc(int v4l2ColorFormat, int height)
+{
+ int newHeight = height;
+
+ switch (v4l2ColorFormat) {
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV12T:
+#ifdef BOARD_USE_V4L2
+ case V4L2_PIX_FMT_NV12MT:
+ case V4L2_PIX_FMT_YUV420M:
+#endif
+ case V4L2_PIX_FMT_YUV420:
+ newHeight = multipleOfN(height, 2);
+ break;
+ default :
+ break;
+ }
+ return newHeight;
+}
+
+int SecFimc::m_getYuvBpp(unsigned int fmt)
+{
+ int i, sel = -1;
+
+ for (i = 0; i < (int)(sizeof(yuv_list) / sizeof(struct yuv_fmt_list)); i++) {
+ if (yuv_list[i].fmt == fmt) {
+ sel = i;
+ break;
+ }
+ }
+
+ if (sel == -1)
+ return sel;
+ else
+ return yuv_list[sel].bpp;
+}
+
+int SecFimc::m_getYuvPlanes(unsigned int fmt)
+{
+ int i, sel = -1;
+
+ for (i = 0; i < (int)(sizeof(yuv_list) / sizeof(struct yuv_fmt_list)); i++) {
+ if (yuv_list[i].fmt == fmt) {
+ sel = i;
+ break;
+ }
+ }
+
+ if (sel == -1)
+ return sel;
+ else
+ return yuv_list[sel].planes;
+}
diff --git a/exynos4/hal/libfimg/Android.mk b/exynos4/hal/libfimg/Android.mk
deleted file mode 100644
index 0d607e2..0000000
--- a/exynos4/hal/libfimg/Android.mk
+++ /dev/null
@@ -1,18 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_C_INCLUDES += \
- $(BOARD_HAL_PATH)/include \
-
-LOCAL_SRC_FILES := \
- FimgApi.cpp \
- FimgC210.cpp
-
-LOCAL_SHARED_LIBRARIES:= liblog libutils libbinder
-
-LOCAL_MODULE_TAGS := eng
-LOCAL_MODULE := libfimg
-
-LOCAL_PRELINK_MODULE := false
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/hal/libfimg3x/Android.mk b/exynos4/hal/libfimg3x/Android.mk
new file mode 100644
index 0000000..c60274d
--- /dev/null
+++ b/exynos4/hal/libfimg3x/Android.mk
@@ -0,0 +1,22 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+ifeq ($(BOARD_USES_FIMGAPI),true)
+
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES:= \
+ FimgApi.cpp \
+ FimgC210.cpp
+
+LOCAL_SHARED_LIBRARIES:= liblog libutils libbinder
+
+LOCAL_MODULE:= libfimg
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif
diff --git a/exynos4/hal/libfimg/FimgApi.cpp b/exynos4/hal/libfimg3x/FimgApi.cpp
similarity index 100%
rename from exynos4/hal/libfimg/FimgApi.cpp
rename to exynos4/hal/libfimg3x/FimgApi.cpp
diff --git a/exynos4/hal/libfimg/FimgApi.h b/exynos4/hal/libfimg3x/FimgApi.h
similarity index 100%
rename from exynos4/hal/libfimg/FimgApi.h
rename to exynos4/hal/libfimg3x/FimgApi.h
diff --git a/exynos4/hal/libfimg/FimgC210.cpp b/exynos4/hal/libfimg3x/FimgC210.cpp
similarity index 100%
rename from exynos4/hal/libfimg/FimgC210.cpp
rename to exynos4/hal/libfimg3x/FimgC210.cpp
diff --git a/exynos4/hal/libfimg/FimgC210.h b/exynos4/hal/libfimg3x/FimgC210.h
similarity index 100%
rename from exynos4/hal/libfimg/FimgC210.h
rename to exynos4/hal/libfimg3x/FimgC210.h
diff --git a/exynos4/hal/libfimg4x/Android.mk b/exynos4/hal/libfimg4x/Android.mk
new file mode 100644
index 0000000..f42da3f
--- /dev/null
+++ b/exynos4/hal/libfimg4x/Android.mk
@@ -0,0 +1,22 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+ifeq ($(BOARD_USES_FIMGAPI),true)
+
+#LOCAL_C_INCLUDES += $(LOCAL_PATH)/../../include
+LOCAL_C_INCLUDES += external/skia/include/core
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES:= \
+ FimgApi.cpp \
+ FimgExynos4.cpp
+
+LOCAL_SHARED_LIBRARIES:= liblog libutils libbinder
+
+LOCAL_MODULE:= libfimg
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif
diff --git a/exynos4/hal/libfimg4x/FimgApi.cpp b/exynos4/hal/libfimg4x/FimgApi.cpp
new file mode 100644
index 0000000..ff11b8d
--- /dev/null
+++ b/exynos4/hal/libfimg4x/FimgApi.cpp
@@ -0,0 +1,376 @@
+/*
+**
+** Copyright 2009 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.
+**
+**
+*/
+
+#define LOG_NDEBUG 0
+#define LOG_TAG "SKIA"
+#include <utils/Log.h>
+
+#include "FimgApi.h"
+
+struct blit_op_table optbl[] = {
+ { (int)BLIT_OP_SOLID_FILL, "FILL" },
+ { (int)BLIT_OP_CLR, "CLR" },
+ { (int)BLIT_OP_SRC, "SRC" },
+ { (int)BLIT_OP_DST, "DST" },
+ { (int)BLIT_OP_SRC_OVER, "SRC_OVER" },
+ { (int)BLIT_OP_DST_OVER, "DST_OVER" },
+ { (int)BLIT_OP_SRC_IN, "SRC_IN" },
+ { (int)BLIT_OP_DST_IN, "DST_IN" },
+ { (int)BLIT_OP_SRC_OUT, "SRC_OUT" },
+ { (int)BLIT_OP_DST_OUT, "DST_OUT" },
+ { (int)BLIT_OP_SRC_ATOP, "SRC_ATOP" },
+ { (int)BLIT_OP_DST_ATOP, "DST_ATOP" },
+ { (int)BLIT_OP_XOR, "XOR" },
+ { (int)BLIT_OP_ADD, "ADD" },
+ { (int)BLIT_OP_MULTIPLY, "MULTIPLY" },
+ { (int)BLIT_OP_SCREEN, "SCREEN" },
+ { (int)BLIT_OP_DARKEN, "DARKEN" },
+ { (int)BLIT_OP_LIGHTEN, "LIGHTEN" },
+ { (int)BLIT_OP_DISJ_SRC_OVER, "DISJ_SRC_OVER" },
+ { (int)BLIT_OP_DISJ_DST_OVER, "DISJ_DST_OVER" },
+ { (int)BLIT_OP_DISJ_SRC_IN, "DISJ_SRC_IN" },
+ { (int)BLIT_OP_DISJ_DST_IN, "DISJ_DST_IN" },
+ { (int)BLIT_OP_DISJ_SRC_OUT, "DISJ_SRC_OUT" },
+ { (int)BLIT_OP_DISJ_DST_OUT, "DISJ_DST_OUT" },
+ { (int)BLIT_OP_DISJ_SRC_ATOP, "DISJ_SRC_ATOP" },
+ { (int)BLIT_OP_DISJ_DST_ATOP, "DISJ_DST_ATOP" },
+ { (int)BLIT_OP_DISJ_XOR, "DISJ_XOR" },
+ { (int)BLIT_OP_CONJ_SRC_OVER, "CONJ_SRC_OVER" },
+ { (int)BLIT_OP_CONJ_DST_OVER, "CONJ_DST_OVER" },
+ { (int)BLIT_OP_CONJ_SRC_IN, "CONJ_SRC_IN" },
+ { (int)BLIT_OP_CONJ_DST_IN, "CONJ_DST_IN" },
+ { (int)BLIT_OP_CONJ_SRC_OUT, "CONJ_SRC_OUT" },
+ { (int)BLIT_OP_CONJ_DST_OUT, "CONJ_DST_OUT" },
+ { (int)BLIT_OP_CONJ_SRC_ATOP, "CONJ_SRC_ATOP" },
+ { (int)BLIT_OP_CONJ_DST_ATOP, "CONJ_DST_ATOP" },
+ { (int)BLIT_OP_CONJ_XOR, "CONJ_XOR" },
+ { (int)BLIT_OP_USER_COEFF, "USER_COEFF" },
+ { (int)BLIT_OP_END, "" },
+};
+
+#ifndef REAL_DEBUG
+ void VOID_FUNC(const char *format, ...)
+ {}
+#endif
+
+FimgApi::FimgApi()
+{
+ m_flagCreate = false;
+}
+
+FimgApi::~FimgApi()
+{
+ if (m_flagCreate == true)
+ PRINT("%s::this is not Destroyed fail\n", __func__);
+}
+
+bool FimgApi::Create(void)
+{
+ bool ret = false;
+
+ if (t_Lock() == false) {
+ PRINT("%s::t_Lock() fail\n", __func__);
+ goto CREATE_DONE;
+ }
+
+ if (m_flagCreate == true) {
+ PRINT("%s::Already Created fail\n", __func__);
+ goto CREATE_DONE;
+ }
+
+ if (t_Create() == false) {
+ PRINT("%s::t_Create() fail\n", __func__);
+ goto CREATE_DONE;
+ }
+
+ m_flagCreate = true;
+
+ ret = true;
+
+CREATE_DONE :
+
+ t_UnLock();
+
+ return ret;
+}
+
+bool FimgApi::Destroy(void)
+{
+ bool ret = false;
+
+ if (t_Lock() == false) {
+ PRINT("%s::t_Lock() fail\n", __func__);
+ goto DESTROY_DONE;
+ }
+
+ if (m_flagCreate == false) {
+ PRINT("%s::Already Destroyed fail\n", __func__);
+ goto DESTROY_DONE;
+ }
+
+ if (t_Destroy() == false) {
+ PRINT("%s::t_Destroy() fail\n", __func__);
+ goto DESTROY_DONE;
+ }
+
+ m_flagCreate = false;
+
+ ret = true;
+
+DESTROY_DONE :
+
+ t_UnLock();
+
+ return ret;
+}
+
+bool FimgApi::Stretch(struct fimg2d_blit *cmd)
+{
+ bool ret = false;
+
+ if (t_Lock() == false) {
+ PRINT("%s::t_Lock() fail\n", __func__);
+ goto STRETCH_DONE;
+ }
+
+ if (m_flagCreate == false) {
+ PRINT("%s::This is not Created fail\n", __func__);
+ goto STRETCH_DONE;
+ }
+
+ if (t_Stretch(cmd) == false) {
+ goto STRETCH_DONE;
+ }
+
+ ret = true;
+
+STRETCH_DONE :
+
+ t_UnLock();
+
+ return ret;
+}
+
+bool FimgApi::Sync(void)
+{
+ bool ret = false;
+
+ if (m_flagCreate == false) {
+ PRINT("%s::This is not Created fail\n", __func__);
+ goto SYNC_DONE;
+ }
+
+ if (t_Sync() == false)
+ goto SYNC_DONE;
+
+ ret = true;
+
+SYNC_DONE :
+
+ return ret;
+}
+
+bool FimgApi::t_Create(void)
+{
+ PRINT("%s::This is empty virtual function fail\n", __func__);
+ return false;
+}
+
+bool FimgApi::t_Destroy(void)
+{
+ PRINT("%s::This is empty virtual function fail\n", __func__);
+ return false;
+}
+
+bool FimgApi::t_Stretch(struct fimg2d_blit *cmd)
+{
+ PRINT("%s::This is empty virtual function fail\n", __func__);
+ return false;
+}
+
+bool FimgApi::t_Sync(void)
+{
+ PRINT("%s::This is empty virtual function fail\n", __func__);
+ return false;
+}
+
+bool FimgApi::t_Lock(void)
+{
+ PRINT("%s::This is empty virtual function fail\n", __func__);
+ return false;
+}
+
+bool FimgApi::t_UnLock(void)
+{
+ PRINT("%s::This is empty virtual function fail\n", __func__);
+ return false;
+}
+
+//---------------------------------------------------------------------------//
+// extern function
+//---------------------------------------------------------------------------//
+extern "C" int stretchFimgApi(struct fimg2d_blit *cmd)
+{
+ FimgApi * fimgApi = createFimgApi();
+
+ if (fimgApi == NULL) {
+ PRINT("%s::createFimgApi() fail\n", __func__);
+ return -1;
+ }
+
+ if (fimgApi->Stretch(cmd) == false) {
+ if (fimgApi != NULL)
+ destroyFimgApi(fimgApi);
+
+ return -1;
+ }
+
+ if (fimgApi != NULL)
+ destroyFimgApi(fimgApi);
+
+ return 0;
+}
+
+extern "C" int SyncFimgApi(void)
+{
+ FimgApi * fimgApi = createFimgApi();
+ if (fimgApi == NULL) {
+ PRINT("%s::createFimgApi() fail\n", __func__);
+ return -1;
+ }
+
+ if (fimgApi->Sync() == false) {
+ if (fimgApi != NULL)
+ destroyFimgApi(fimgApi);
+
+ return -1;
+ }
+
+ if (fimgApi != NULL)
+ destroyFimgApi(fimgApi);
+
+ return 0;
+}
+
+void printDataBlit(char *title, struct fimg2d_blit *cmd)
+{
+ LOGI("%s\n", title);
+
+ LOGI(" sequence_no. = %u\n", cmd->seq_no);
+ LOGI(" blit_op = %d(%s)\n", cmd->op, optbl[cmd->op].str);
+ LOGI(" fill_color = %X\n", cmd->solid_color);
+ LOGI(" global_alpha = %u\n", (unsigned int)cmd->g_alpha);
+ LOGI(" PREMULT = %s\n", cmd->premult == PREMULTIPLIED ? "PREMULTIPLIED" : "NON-PREMULTIPLIED");
+ LOGI(" do_dither = %s\n", cmd->dither == true ? "dither" : "no-dither");
+
+ printDataBlitRotate(cmd->rotate);
+
+ printDataBlitScale(cmd->scaling);
+
+ printDataBlitImage("SRC", cmd->src);
+ printDataBlitImage("DST", cmd->dst);
+ printDataBlitImage("MSK", cmd->msk);
+
+ printDataBlitRect("SRC", cmd->src_rect);
+ printDataBlitRect("DST", cmd->dst_rect);
+ printDataBlitRect("MSK", cmd->msk_rect);
+
+ printDataBlitClip(cmd->clipping);
+}
+
+void printDataBlitImage(char *title, struct fimg2d_image *image)
+{
+ if (NULL != image) {
+ LOGI(" Image_%s\n", title);
+ LOGI(" addr = %X\n", image->addr.start);
+ LOGI(" size = %u\n", image->addr.size);
+ LOGI(" (width, height) = (%d, %d)\n", image->width, image->height);
+ LOGI(" format = %d\n", image->fmt);
+ } else
+ LOGI(" Image_%s : NULL\n", title);
+}
+
+void printDataBlitRect(char *title, struct fimg2d_rect *rect)
+{
+ if (NULL != rect) {
+ LOGI(" RECT_%s\n", title);
+ LOGI(" (x1, y1) = (%d, %d)\n", rect->x1, rect->y1);
+ LOGI(" (x2, y2) = (%d, %d)\n", rect->x2, rect->y2);
+ LOGI(" (width, height) = (%d, %d)\n", rect->x2 - rect->x1, rect->y2 - rect->y1);
+ } else
+ LOGI(" RECT_%s : NULL\n", title);
+}
+
+void printDataBlitRotate(enum rotation rotate)
+{
+ LOGI(" ROTATE : %d\n", rotate);
+}
+
+void printDataBlitClip(struct fimg2d_clip *clip)
+{
+ if (NULL != clip) {
+ LOGI(" CLIP\n");
+ LOGI(" clip %s\n", clip->enable == true ? "enabled" : "disabled");
+ LOGI(" (x1, y1) = (%d, %d)\n", clip->x1, clip->y1);
+ LOGI(" (x2, y2) = (%d, %d)\n", clip->x2, clip->y2);
+ LOGI(" (width, hight) = (%d, %d)\n", clip->x2 - clip->x1, clip->y2 - clip->y1);
+ } else
+ LOGI(" CLIP : NULL\n");
+}
+
+void printDataBlitScale(struct fimg2d_scale *scaling)
+{
+ if (NULL != scaling) {
+ LOGI(" SCALING\n");
+ LOGI(" scale_mode : %s\n", scaling->mode == 0 ?
+ "NO_SCALING" :
+ (scaling->mode == 1 ? "SCALING_NEAREST" : "SCALING_BILINEAR"));
+ LOGI(" scaling_factor_unit : %s\n", scaling->factor == 0 ? "PERCENT" : "PIXEL");
+
+ if (scaling->factor == 0)
+ LOGI(" scaling_factor : (scale_w, scale_y) = (%d, %d)\n", scaling->scale_w, scaling->scale_h);
+ else {
+ LOGI(" src : (src_w, src_h) = (%d, %d)\n", scaling->src_w, scaling->src_h);
+ LOGI(" dst : (dst_w, dst_h) = (%d, %d)\n", scaling->dst_w, scaling->dst_h);
+ LOGI(" scaling_factor : (scale_w, scale_y) = (%3.2f, %3.2f)\n", (double)scaling->dst_w / scaling->src_w, (double)scaling->dst_h / scaling->src_h);
+ }
+ } else
+ LOGI(" SCALING : NULL(NO SCALE MODE)\n");
+
+}
+
+void printDataMatrix(int matrixType)
+{
+ LOGI(" MATRIX\n");
+
+ if (matrixType & SkMatrix::kIdentity_Mask)
+ LOGI(" Matrix_type : Identity_Mask\n");
+
+ if (matrixType & SkMatrix::kTranslate_Mask)
+ LOGI(" Matrix_type : Translate_Mask(the matrix has translation)\n");
+
+ if (matrixType & SkMatrix::kScale_Mask)
+ LOGI(" Matrix_type : Scale_Mask(the matrix has X or Y scale)\n");
+
+ if (matrixType & SkMatrix::kAffine_Mask)
+ LOGI(" Matrix_type : Affine_Mask(the matrix skews or rotates)\n");
+
+ if (matrixType & SkMatrix::kPerspective_Mask)
+ LOGI(" Matrix_type : Perspective_Mask(the matrix is in perspective)\n");
+}
diff --git a/exynos4/hal/libfimg4x/FimgApi.h b/exynos4/hal/libfimg4x/FimgApi.h
new file mode 100644
index 0000000..a2c9eac
--- /dev/null
+++ b/exynos4/hal/libfimg4x/FimgApi.h
@@ -0,0 +1,114 @@
+/*
+**
+** Copyright 2009 Samsung Electronics Co, Ltd.
+** Copyright 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.
+**
+**
+*/
+
+#ifndef FIMG_API_H
+#define FIMG_API_H
+
+#include <utils/Log.h>
+#include "SkMatrix.h"
+#include "sec_g2d_4x.h"
+
+#define REAL_DEBUG
+#define ANDROID_LOG
+
+#if defined(REAL_DEBUG)
+#ifdef ANDROID_LOG
+#define PRINT LOGE
+#define PRINTD LOGD
+#else
+#define PRINT printf
+#define PRINTD printf
+#endif
+#else
+void VOID_FUNC(const char *format, ...);
+
+#define PRINT VOID_FUNC
+#define PRINTD VOID_FUNC
+#endif
+
+#ifdef __cplusplus
+
+struct blit_op_table {
+ int op;
+ const char *str;
+};
+
+extern struct blit_op_table optbl[];
+
+class FimgApi
+{
+public:
+#endif
+
+#ifdef __cplusplus
+private :
+ bool m_flagCreate;
+
+protected :
+ FimgApi();
+ FimgApi(const FimgApi& rhs) {}
+ virtual ~FimgApi();
+
+public:
+ bool Create(void);
+ bool Destroy(void);
+ inline bool FlagCreate(void) { return m_flagCreate; }
+ bool Stretch(struct fimg2d_blit *cmd);
+ bool Sync(void);
+
+protected:
+ virtual bool t_Create(void);
+ virtual bool t_Destroy(void);
+ virtual bool t_Stretch(struct fimg2d_blit *cmd);
+ virtual bool t_Sync(void);
+ virtual bool t_Lock(void);
+ virtual bool t_UnLock(void);
+
+};
+#endif
+
+#ifdef __cplusplus
+extern "C"
+#endif
+struct FimgApi *createFimgApi();
+
+#ifdef __cplusplus
+extern "C"
+#endif
+void destroyFimgApi(FimgApi *ptrFimgApi);
+
+#ifdef __cplusplus
+extern "C"
+#endif
+int stretchFimgApi(struct fimg2d_blit *cmd);
+#ifdef __cplusplus
+extern "C"
+#endif
+int SyncFimgApi(void);
+
+void printDataBlit(char *title, struct fimg2d_blit *cmd);
+void printDataBlitRotate(enum rotation rotate);
+void printDataBlitImage(char *title, struct fimg2d_image *image);
+void printDataBlitRect(char *title, struct fimg2d_rect *rect);
+void printDataBlitClip(struct fimg2d_clip *clip);
+void printDataBlitScale(struct fimg2d_scale *scaling);
+void printDataMatrix(int matrixType);
+
+#endif //FIMG_API_H
diff --git a/exynos4/hal/libfimg4x/FimgExynos4.cpp b/exynos4/hal/libfimg4x/FimgExynos4.cpp
new file mode 100644
index 0000000..f9a7f1e
--- /dev/null
+++ b/exynos4/hal/libfimg4x/FimgExynos4.cpp
@@ -0,0 +1,302 @@
+/*
+**
+** Copyright 2009 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.
+**
+**
+*/
+
+#define LOG_NDEBUG 0
+#define LOG_TAG "FimgExynos4"
+#include <utils/Log.h>
+
+#include "FimgExynos4.h"
+
+namespace android
+{
+Mutex FimgV4x::m_instanceLock;
+unsigned FimgV4x::m_curFimgV4xIndex = 0;
+int FimgV4x::m_numOfInstance = 0;
+FimgApi * FimgV4x::m_ptrFimgApiList[NUMBER_FIMG_LIST] = {NULL, };
+
+//---------------------------------------------------------------------------//
+
+FimgV4x::FimgV4x()
+ : m_g2dFd(0),
+ m_g2dVirtAddr(NULL),
+ m_g2dSize(0),
+ m_g2dSrcVirtAddr(NULL),
+ m_g2dSrcSize(0),
+ m_g2dDstVirtAddr(NULL),
+ m_g2dDstSize(0)
+{
+ memset(&(m_g2dPoll), 0, sizeof(struct pollfd));
+ m_lock = new Mutex(Mutex::SHARED, "FimgV4x");
+}
+
+FimgV4x::~FimgV4x()
+{
+ delete m_lock;
+}
+
+FimgApi *FimgV4x::CreateInstance()
+{
+ Mutex::Autolock autolock(m_instanceLock);
+
+ FimgApi *ptrFimg = NULL;
+
+ for(unsigned int i = m_curFimgV4xIndex; i < NUMBER_FIMG_LIST; i++) {
+ if (m_ptrFimgApiList[i] == NULL)
+ m_ptrFimgApiList[i] = new FimgV4x;
+
+ if (m_ptrFimgApiList[i]->FlagCreate() == false) {
+ if (m_ptrFimgApiList[i]->Create() == false) {
+ PRINT("%s::Create(%d) fail\n", __func__, i);
+ goto CreateInstance_End;
+ }
+ else
+ m_numOfInstance++;
+ }
+
+ if (i < NUMBER_FIMG_LIST - 1)
+ m_curFimgV4xIndex = i + 1;
+ else
+ m_curFimgV4xIndex = 0;
+
+ ptrFimg = m_ptrFimgApiList[i];
+ goto CreateInstance_End;
+ }
+
+CreateInstance_End :
+
+ return ptrFimg;
+}
+
+void FimgV4x::DestroyInstance(FimgApi * ptrFimgApi)
+{
+ Mutex::Autolock autolock(m_instanceLock);
+
+ for(int i = 0; i < NUMBER_FIMG_LIST; i++) {
+ if (m_ptrFimgApiList[i] != NULL && m_ptrFimgApiList[i] == ptrFimgApi) {
+ if (m_ptrFimgApiList[i]->FlagCreate() == true && m_ptrFimgApiList[i]->Destroy() == false) {
+ PRINT("%s::Destroy() fail\n", __func__);
+ } else {
+ FimgV4x * tempFimgV4x = (FimgV4x *)m_ptrFimgApiList[i];
+ delete tempFimgV4x;
+ m_ptrFimgApiList[i] = NULL;
+
+ m_numOfInstance--;
+ }
+
+ break;
+ }
+ }
+}
+
+void FimgV4x::DestroyAllInstance(void)
+{
+ Mutex::Autolock autolock(m_instanceLock);
+
+ for(int i = 0; i < NUMBER_FIMG_LIST; i++) {
+ if (m_ptrFimgApiList[i] != NULL) {
+ if (m_ptrFimgApiList[i]->FlagCreate() == true
+ && m_ptrFimgApiList[i]->Destroy() == false) {
+ PRINT("%s::Destroy() fail\n", __func__);
+ } else {
+ FimgV4x * tempFimgV4x = (FimgV4x *)m_ptrFimgApiList[i];
+ delete tempFimgV4x;
+ m_ptrFimgApiList[i] = NULL;
+ }
+ }
+ }
+}
+
+bool FimgV4x::t_Create(void)
+{
+ bool ret = true;
+
+ if (m_CreateG2D() == false) {
+ PRINT("%s::m_CreateG2D() fail \n", __func__);
+
+ if (m_DestroyG2D() == false)
+ PRINT("%s::m_DestroyG2D() fail \n", __func__);
+
+ ret = false;
+ }
+
+ return ret;
+}
+
+bool FimgV4x::t_Destroy(void)
+{
+ bool ret = true;
+
+ if (m_DestroyG2D() == false) {
+ PRINT("%s::m_DestroyG2D() fail \n", __func__);
+ ret = false;
+ }
+
+ return ret;
+}
+
+bool FimgV4x::t_Stretch(struct fimg2d_blit *cmd)
+{
+#ifdef CHECK_FIMGV4x_PERFORMANCE
+#define NUM_OF_STEP (10)
+ StopWatch stopWatch("CHECK_FIMGV4x_PERFORMANCE");
+ const char *stopWatchName[NUM_OF_STEP];
+ nsecs_t stopWatchTime[NUM_OF_STEP];
+ int stopWatchIndex = 0;
+#endif // CHECK_FIMGV4x_PERFORMANCE
+
+ if (m_DoG2D(cmd) == false) {
+ goto STRETCH_FAIL;
+ }
+
+#ifdef G2D_NONE_BLOCKING_MODE
+ if (m_PollG2D(&m_g2dPoll) == false)
+ {
+ PRINT("%s::m_PollG2D() fail\n", __func__);
+ goto STRETCH_FAIL;
+ }
+#endif
+
+ #ifdef CHECK_FIMGV4x_PERFORMANCE
+ m_PrintFimgV4xPerformance(src, dst, stopWatchIndex, stopWatchName, stopWatchTime);
+ #endif // CHECK_FIMGV4x_PERFORMANCE
+
+ return true;
+
+STRETCH_FAIL:
+ return false;
+
+}
+
+bool FimgV4x::t_Sync(void)
+{
+ if (m_PollG2D(&m_g2dPoll) == false)
+ {
+ PRINT("%s::m_PollG2D() fail\n", __func__);
+ goto SYNC_FAIL;
+ }
+ return true;
+
+SYNC_FAIL:
+ return false;
+
+}
+
+bool FimgV4x::t_Lock(void)
+{
+ m_lock->lock();
+ return true;
+}
+
+bool FimgV4x::t_UnLock(void)
+{
+ m_lock->unlock();
+ return true;
+}
+
+bool FimgV4x::m_CreateG2D(void)
+{
+ void * mmap_base;
+
+ if (m_g2dFd != 0) {
+ PRINT("%s::m_g2dFd(%d) is not 0 fail\n", __func__, m_g2dFd);
+ return false;
+ }
+
+#ifdef G2D_NONE_BLOCKING_MODE
+ m_g2dFd = open(SEC_G2D_DEV_NAME, O_RDWR | O_NONBLOCK);
+#else
+ m_g2dFd = open(SEC_G2D_DEV_NAME, O_RDWR);
+#endif
+ if (m_g2dFd < 0) {
+ PRINT("%s::open(%s) fail(%s)\n", __func__, SEC_G2D_DEV_NAME, strerror(errno));
+ m_g2dFd = 0;
+ return false;
+ }
+
+ memset(&m_g2dPoll, 0, sizeof(m_g2dPoll));
+ m_g2dPoll.fd = m_g2dFd;
+ m_g2dPoll.events = POLLOUT | POLLERR;
+
+ return true;
+}
+
+bool FimgV4x::m_DestroyG2D(void)
+{
+ if (m_g2dVirtAddr != NULL) {
+ munmap(m_g2dVirtAddr, m_g2dSize);
+ m_g2dVirtAddr = NULL;
+ m_g2dSize = 0;
+ }
+
+ if (0 < m_g2dFd) {
+ close(m_g2dFd);
+ }
+ m_g2dFd = 0;
+
+ return true;
+}
+
+bool FimgV4x::m_DoG2D(struct fimg2d_blit *cmd)
+{
+
+ if (ioctl(m_g2dFd, FIMG2D_BITBLT_BLIT, cmd) < 0)
+ return false;
+
+ return true;
+}
+
+inline bool FimgV4x::m_PollG2D(struct pollfd * events)
+{
+#define G2D_POLL_TIME (1000)
+
+ int ret;
+
+ ret = poll(events, 1, G2D_POLL_TIME);
+
+ if (ret < 0) {
+ PRINT("%s::poll fail \n", __func__);
+ return false;
+ }
+ else if (ret == 0) {
+ PRINT("%s::No data in %d milli secs..\n", __func__, G2D_POLL_TIME);
+ return false;
+ }
+
+ return true;
+}
+
+//---------------------------------------------------------------------------//
+// extern function
+//---------------------------------------------------------------------------//
+extern "C" struct FimgApi * createFimgApi()
+{
+ if (fimgApiAutoFreeThread == 0)
+ fimgApiAutoFreeThread = new FimgApiAutoFreeThread();
+ else
+ fimgApiAutoFreeThread->SetOneMoreSleep();
+
+ return FimgV4x::CreateInstance();
+}
+
+extern "C" void destroyFimgApi(FimgApi * ptrFimgApi)
+{
+ // Dont' call DestroyInstance.
+}
+
+}; // namespace android
diff --git a/exynos4/hal/libfimg4x/FimgExynos4.h b/exynos4/hal/libfimg4x/FimgExynos4.h
new file mode 100644
index 0000000..2a7c42f
--- /dev/null
+++ b/exynos4/hal/libfimg4x/FimgExynos4.h
@@ -0,0 +1,169 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** Copyright 2009 Samsung Electronics Co, Ltd. All Rights Reserved.
+**
+** 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 FIMG_EXYNOS4_H
+#define FIMG_EXYNOS4_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <sys/stat.h>
+
+#include <linux/android_pmem.h>
+#include <utils/threads.h>
+#include <utils/StopWatch.h>
+
+#include "FimgApi.h"
+
+#include "sec_g2d_4x.h"
+
+namespace android
+{
+
+#define NUMBER_FIMG_LIST (1) // kcoolsw : because of pmem
+#define GET_RECT_SIZE(rect) ((rect->full_w) * (rect->h) * (rect->bytes_per_pixel))
+#define GET_REAL_SIZE(rect) ((rect->full_w) * (rect->h) * (rect->bytes_per_pixel))
+#define GET_START_ADDR(rect) (rect->virt_addr + ((rect->y * rect->full_w) * rect->bytes_per_pixel))
+#define SLEEP_TIME (3000000) // 3 sec
+
+//---------------------------------------------------------------------------//
+// class FimgV4x : public FimgBase
+//---------------------------------------------------------------------------//
+class FimgV4x : public FimgApi
+{
+private :
+ int m_g2dFd;
+
+ unsigned char *m_g2dVirtAddr;
+ unsigned int m_g2dSize;
+ unsigned char *m_g2dSrcVirtAddr;
+ unsigned int m_g2dSrcSize;
+ unsigned char *m_g2dDstVirtAddr;
+ unsigned int m_g2dDstSize;
+ struct pollfd m_g2dPoll;
+
+ Mutex *m_lock;
+
+ static Mutex m_instanceLock;
+ static unsigned m_curFimgV4xIndex;
+ static int m_numOfInstance;
+
+ static FimgApi *m_ptrFimgApiList[NUMBER_FIMG_LIST];
+
+protected :
+ FimgV4x();
+ virtual ~FimgV4x();
+
+public:
+ static FimgApi *CreateInstance();
+ static void DestroyInstance(FimgApi *ptrFimgApi);
+ static void DestroyAllInstance(void);
+
+protected:
+ virtual bool t_Create(void);
+ virtual bool t_Destroy(void);
+ virtual bool t_Stretch(struct fimg2d_blit *cmd);
+ virtual bool t_Sync(void);
+ virtual bool t_Lock(void);
+ virtual bool t_UnLock(void);
+
+private:
+ bool m_CreateG2D(void);
+ bool m_DestroyG2D(void);
+
+ bool m_DoG2D(struct fimg2d_blit *cmd);
+
+ inline bool m_PollG2D(struct pollfd *events);
+
+ inline int m_ColorFormatFimgApi2FimgHw(int colorFormat);
+};
+
+class FimgApiAutoFreeThread;
+
+static sp<FimgApiAutoFreeThread> fimgApiAutoFreeThread = 0;
+
+class FimgApiAutoFreeThread : public Thread
+{
+private:
+ bool mOneMoreSleep;
+ bool mDestroyed;
+
+public:
+ FimgApiAutoFreeThread(void):
+ Thread(false),
+ mOneMoreSleep(true),
+ mDestroyed(false)
+ { }
+ ~FimgApiAutoFreeThread(void)
+ {
+ if (mDestroyed == false)
+ {
+ FimgV4x::DestroyAllInstance();
+ mDestroyed = true;
+ }
+ }
+
+ virtual void onFirstRef()
+ {
+ run("FimgApiAutoFreeThread", PRIORITY_BACKGROUND);
+ }
+
+ virtual bool threadLoop()
+ {
+
+ if (mOneMoreSleep == true)
+ {
+ mOneMoreSleep = false;
+ usleep(SLEEP_TIME);
+
+ return true;
+ }
+ else
+ {
+ if (mDestroyed == false)
+ {
+ FimgV4x::DestroyAllInstance();
+ mDestroyed = true;
+ }
+
+ fimgApiAutoFreeThread = 0;
+
+ return false;
+ }
+ }
+
+ void SetOneMoreSleep(void)
+ {
+ mOneMoreSleep = true;
+ }
+};
+
+}; // namespace android
+
+#endif // FIMG_EXYNOS4_H
diff --git a/exynos4/hal/libfimg4x/sec_g2d_4x.h b/exynos4/hal/libfimg4x/sec_g2d_4x.h
new file mode 100644
index 0000000..b9ddbb2
--- /dev/null
+++ b/exynos4/hal/libfimg4x/sec_g2d_4x.h
@@ -0,0 +1,326 @@
+/*
+ * Copyright 2011, 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_G2D_4X_H
+#define __SEC_G2D_4X_H __FILE__
+
+#define SEC_G2D_DEV_NAME "/dev/fimg2d"
+
+/* ioctl commands */
+#define FIMG2D_IOCTL_MAGIC 'F'
+#define FIMG2D_BITBLT_BLIT _IOWR(FIMG2D_IOCTL_MAGIC, 0, struct fimg2d_blit)
+#define FIMG2D_BITBLT_SYNC _IO(FIMG2D_IOCTL_MAGIC, 1)
+#define FIMG2D_BITBLT_VERSION _IOR(FIMG2D_IOCTL_MAGIC, 2, struct fimg2d_version)
+
+#define G2D_ALPHA_VALUE_MAX (255)
+
+enum addr_space {
+ ADDR_UNKNOWN,
+ ADDR_PHYS,
+ ADDR_KERN,
+ ADDR_USER,
+ ADDR_DEVICE,
+};
+
+/**
+ * DO NOT CHANGE THIS ORDER
+ */
+enum pixel_order {
+ AX_RGB = 0,
+ RGB_AX,
+ AX_BGR,
+ BGR_AX,
+ ARGB_ORDER_END,
+
+ P1_CRY1CBY0,
+ P1_CBY1CRY0,
+ P1_Y1CRY0CB,
+ P1_Y1CBY0CR,
+ P1_ORDER_END,
+
+ P2_CRCB,
+ P2_CBCR,
+ P2_ORDER_END,
+};
+
+/**
+ * DO NOT CHANGE THIS ORDER
+ */
+enum color_format {
+ CF_XRGB_8888 = 0,
+ CF_ARGB_8888,
+ CF_RGB_565,
+ CF_XRGB_1555,
+ CF_ARGB_1555,
+ CF_XRGB_4444,
+ CF_ARGB_4444,
+ CF_RGB_888,
+ CF_YCBCR_444,
+ CF_YCBCR_422,
+ CF_YCBCR_420,
+ CF_A8,
+ CF_L8,
+ SRC_DST_FORMAT_END,
+
+ CF_MSK_1BIT,
+ CF_MSK_4BIT,
+ CF_MSK_8BIT,
+ CF_MSK_16BIT_565,
+ CF_MSK_16BIT_1555,
+ CF_MSK_16BIT_4444,
+ CF_MSK_32BIT_8888,
+ MSK_FORMAT_END,
+};
+
+enum rotation {
+ ORIGIN,
+ ROT_90, /* clockwise */
+ ROT_180,
+ ROT_270,
+ XFLIP, /* x-axis flip */
+ YFLIP, /* y-axis flip */
+};
+
+/**
+ * @NO_REPEAT: no effect
+ * @REPEAT_NORMAL: repeat horizontally and vertically
+ * @REPEAT_PAD: pad with pad color
+ * @REPEAT_REFLECT: reflect horizontally and vertically
+ * @REPEAT_CLAMP: pad with edge color of original image
+ *
+ * DO NOT CHANGE THIS ORDER
+ */
+enum repeat {
+ NO_REPEAT = 0,
+ REPEAT_NORMAL, /* default setting */
+ REPEAT_PAD,
+ REPEAT_REFLECT, REPEAT_MIRROR = REPEAT_REFLECT,
+ REPEAT_CLAMP,
+};
+
+enum scaling {
+ NO_SCALING,
+ SCALING_NEAREST,
+ SCALING_BILINEAR,
+};
+
+/**
+ * @SCALING_PERCENTAGE: percentage of width, height
+ * @SCALING_PIXELS: coordinate of src, dest
+ */
+enum scaling_factor {
+ SCALING_PERCENTAGE,
+ SCALING_PIXELS,
+};
+
+/**
+ * premultiplied alpha
+ */
+enum premultiplied {
+ PREMULTIPLIED,
+ NON_PREMULTIPLIED,
+};
+
+/**
+ * @TRANSP: discard bluescreen color
+ * @BLUSCR: replace bluescreen color with background color
+ */
+enum bluescreen {
+ OPAQUE,
+ TRANSP,
+ BLUSCR,
+};
+
+/**
+ * DO NOT CHANGE THIS ORDER
+ */
+enum blit_op {
+ BLIT_OP_SOLID_FILL = 0,
+
+ BLIT_OP_CLR,
+ BLIT_OP_SRC, BLIT_OP_SRC_COPY = BLIT_OP_SRC,
+ BLIT_OP_DST,
+ BLIT_OP_SRC_OVER,
+ BLIT_OP_DST_OVER, BLIT_OP_OVER_REV = BLIT_OP_DST_OVER,
+ BLIT_OP_SRC_IN,
+ BLIT_OP_DST_IN, BLIT_OP_IN_REV = BLIT_OP_DST_IN,
+ BLIT_OP_SRC_OUT,
+ BLIT_OP_DST_OUT, BLIT_OP_OUT_REV = BLIT_OP_DST_OUT,
+ BLIT_OP_SRC_ATOP,
+ BLIT_OP_DST_ATOP, BLIT_OP_ATOP_REV = BLIT_OP_DST_ATOP,
+ BLIT_OP_XOR,
+
+ BLIT_OP_ADD,
+ BLIT_OP_MULTIPLY,
+ BLIT_OP_SCREEN,
+ BLIT_OP_DARKEN,
+ BLIT_OP_LIGHTEN,
+
+ BLIT_OP_DISJ_SRC_OVER,
+ BLIT_OP_DISJ_DST_OVER, BLIT_OP_SATURATE = BLIT_OP_DISJ_DST_OVER,
+ BLIT_OP_DISJ_SRC_IN,
+ BLIT_OP_DISJ_DST_IN, BLIT_OP_DISJ_IN_REV = BLIT_OP_DISJ_DST_IN,
+ BLIT_OP_DISJ_SRC_OUT,
+ BLIT_OP_DISJ_DST_OUT, BLIT_OP_DISJ_OUT_REV = BLIT_OP_DISJ_DST_OUT,
+ BLIT_OP_DISJ_SRC_ATOP,
+ BLIT_OP_DISJ_DST_ATOP, BLIT_OP_DISJ_ATOP_REV = BLIT_OP_DISJ_DST_ATOP,
+ BLIT_OP_DISJ_XOR,
+
+ BLIT_OP_CONJ_SRC_OVER,
+ BLIT_OP_CONJ_DST_OVER, BLIT_OP_CONJ_OVER_REV = BLIT_OP_CONJ_DST_OVER,
+ BLIT_OP_CONJ_SRC_IN,
+ BLIT_OP_CONJ_DST_IN, BLIT_OP_CONJ_IN_REV = BLIT_OP_CONJ_DST_IN,
+ BLIT_OP_CONJ_SRC_OUT,
+ BLIT_OP_CONJ_DST_OUT, BLIT_OP_CONJ_OUT_REV = BLIT_OP_CONJ_DST_OUT,
+ BLIT_OP_CONJ_SRC_ATOP,
+ BLIT_OP_CONJ_DST_ATOP, BLIT_OP_CONJ_ATOP_REV = BLIT_OP_CONJ_DST_ATOP,
+ BLIT_OP_CONJ_XOR,
+
+ /* Add new operation type here */
+
+ /* user select coefficient manually */
+ BLIT_OP_USER_COEFF,
+
+ /* end of blit operation */
+ BLIT_OP_END,
+
+ /* driver not supporting format */
+ BLIT_OP_NOT_SUPPORTED
+};
+
+#define MAX_FIMG2D_BLIT_OP (int)BLIT_OP_END
+
+struct fimg2d_version {
+ unsigned int hw;
+ unsigned int sw;
+};
+
+/**
+ * @start: start address or unique id of image
+ * @size: whole length of allocated image
+ * @cacheable: memory is cacheable
+ * @pinnable: memory is pinnable. currently not supported.
+ */
+struct fimg2d_addr {
+ enum addr_space type;
+ unsigned long start;
+ size_t size;
+ int cacheable;
+ int pinnable;
+};
+
+struct fimg2d_rect {
+ int x1;
+ int y1;
+ int x2; /* x1 + width */
+ int y2; /* y1 + height */
+};
+
+/**
+ * if factor is percentage, scale_w and scale_h are valid
+ * if factor is pixels, src_w, src_h, dst_w, dst_h are valid
+ */
+struct fimg2d_scale {
+ enum scaling mode;
+ enum scaling_factor factor;
+
+ /* percentage */
+ int scale_w;
+ int scale_h;
+
+ /* pixels */
+ int src_w, src_h;
+ int dst_w, dst_h;
+};
+
+/**
+ * coordinate from start address(0,0) of image
+ */
+struct fimg2d_clip {
+ bool enable;
+ int x1;
+ int y1;
+ int x2; /* x1 + width */
+ int y2; /* y1 + height */
+};
+
+struct fimg2d_repeat {
+ enum repeat mode;
+ unsigned long pad_color;
+};
+
+/**
+ * @bg_color: bg_color is valid only if bluescreen mode is BLUSCR.
+ */
+struct fimg2d_bluscr {
+ enum bluescreen mode;
+ unsigned long bs_color;
+ unsigned long bg_color;
+};
+
+/**
+ * @plane2: address info for CbCr in YCbCr 2plane mode
+ */
+struct fimg2d_image {
+ struct fimg2d_addr addr;
+ struct fimg2d_addr plane2;
+ int width;
+ int height;
+ int stride;
+ enum pixel_order order;
+ enum color_format fmt;
+};
+
+struct fimg2d_param {
+ enum blit_op op;
+ unsigned long fillcolor;
+ unsigned char g_alpha;
+ enum premultiplied premult;
+ bool dither;
+ enum rotation rotate;
+ struct fimg2d_scale *scaling;
+ struct fimg2d_repeat *repeat;
+ struct fimg2d_bluscr *bluscr;
+ struct fimg2d_clip *clipping;
+};
+
+/**
+ * @g_alpha: 0xff is opaque, 0x0 is transparnet
+ * @seq_no: used for debugging
+ */
+struct fimg2d_blit {
+ enum blit_op op;
+
+ enum premultiplied premult;
+ unsigned char g_alpha;
+ bool dither;
+ enum rotation rotate;
+ struct fimg2d_scale *scaling;
+ struct fimg2d_repeat *repeat;
+ struct fimg2d_bluscr *bluscr;
+ struct fimg2d_clip *clipping;
+
+ unsigned long solid_color;
+ struct fimg2d_image *src;
+ struct fimg2d_image *dst;
+ struct fimg2d_image *msk;
+
+ struct fimg2d_rect *src_rect;
+ struct fimg2d_rect *dst_rect;
+ struct fimg2d_rect *msk_rect;
+
+ unsigned int seq_no;
+};
+#endif /* __SEC_G2D_4X_H__ */
diff --git a/exynos4/hal/libgralloc_ump/Android.mk b/exynos4/hal/libgralloc_ump/Android.mk
new file mode 100644
index 0000000..20584a4
--- /dev/null
+++ b/exynos4/hal/libgralloc_ump/Android.mk
@@ -0,0 +1,56 @@
+#
+# Copyright (C) 2010 ARM Limited. All rights reserved.
+#
+# Portions of this code have been modified from the original.
+# These modifications are:
+# * The build configuration for the Gralloc module
+#
+# 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/<OVERLAY_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 libUMP libGLESv1_CM libion
+
+# Include the UMP header files
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
+
+LOCAL_SRC_FILES := \
+ gralloc_module.cpp \
+ alloc_device.cpp \
+ framebuffer_device.cpp
+
+LOCAL_MODULE_TAGS := eng
+#LOCAL_MODULE := gralloc.default
+LOCAL_MODULE := gralloc.$(TARGET_DEVICE)
+LOCAL_CFLAGS:= -DLOG_TAG=\"gralloc\" -DGRALLOC_32_BITS -DSTANDARD_LINUX_SCREEN
+#LOCAL_CFLAGS+= -DMALI_VSYNC_EVENT_REPORT_ENABLE
+
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS_CACHE_UMP
+
+ifeq ($(TARGET_SOC),exynos4210)
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4210
+endif
+
+ifeq ($(TARGET_SOC),exynos4x12)
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4x12
+endif
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/hal/libgralloc_ump/alloc_device.cpp b/exynos4/hal/libgralloc_ump/alloc_device.cpp
new file mode 100644
index 0000000..982f1b8
--- /dev/null
+++ b/exynos4/hal/libgralloc_ump/alloc_device.cpp
@@ -0,0 +1,498 @@
+/*
+ * Copyright (C) 2010 ARM Limited. All rights reserved.
+ *
+ * Portions of this code have been modified from the original.
+ * These modifications are:
+ * * includes
+ * * gralloc_alloc_buffer()
+ * * gralloc_alloc_framebuffer_locked()
+ * * gralloc_alloc_framebuffer()
+ * * alloc_device_alloc()
+ * * alloc_device_free()
+ * * alloc_device_close()
+ * * alloc_device_open()
+ *
+ * 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.
+ */
+
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+
+#include <cutils/log.h>
+#include <cutils/atomic.h>
+#include <hardware/hardware.h>
+#include <hardware/gralloc.h>
+#include "sec_format.h"
+
+#include "gralloc_priv.h"
+#include "gralloc_helper.h"
+#include "framebuffer_device.h"
+
+#include "ump.h"
+#include "ump_ref_drv.h"
+
+/*****************************************************************************/
+#include <limits.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdlib.h>
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+#if HAVE_ANDROID_OS
+#include <linux/android_pmem.h>
+#include <pixelflinger/format.h>
+#endif
+
+#include "videodev2.h"
+#include "s5p_fimc.h"
+
+#ifdef SAMSUNG_EXYNOS4x12
+#define PFX_NODE_FIMC1 "/dev/video3"
+#endif
+#ifdef SAMSUNG_EXYNOS4210
+#define PFX_NODE_FIMC1 "/dev/video1"
+#endif
+
+#ifndef OMX_COLOR_FormatYUV420Planar
+#define OMX_COLOR_FormatYUV420Planar 0x13
+#endif
+
+#ifndef OMX_COLOR_FormatYUV420SemiPlanar
+#define OMX_COLOR_FormatYUV420SemiPlanar 0x15
+#endif
+
+bool ion_dev_open = true;
+static pthread_mutex_t l_surface= PTHREAD_MUTEX_INITIALIZER;
+static int buffer_offset = 0;
+static int gfd = 0;
+
+#ifdef USE_PARTIAL_FLUSH
+extern struct private_handle_rect *rect_list;
+extern private_handle_rect *find_rect(int secure_id);
+extern private_handle_rect *find_last_rect(int secure_id);
+extern int release_rect(int secure_id);
+#endif
+
+#define EXYNOS4_ALIGN( value, base ) (((value) + ((base) - 1)) & ~((base) - 1))
+
+static int gralloc_alloc_buffer(alloc_device_t* dev, size_t size, int usage,
+ buffer_handle_t* pHandle, int w, int h,
+ int format, int bpp, int stride_raw, int stride)
+{
+ ump_handle ump_mem_handle;
+ void *cpu_ptr;
+ ump_secure_id ump_id;
+
+ size = round_up_to_page_size(size);
+ if (usage & GRALLOC_USAGE_HW_FIMC1) {
+ int dev_fd=0;
+ char node[20];
+ int ret;
+ int paddr=0;
+ int offset=0;
+
+ struct v4l2_control vc;
+ sprintf(node, "%s", PFX_NODE_FIMC1);
+
+ if (gfd == 0) {
+ gfd = open(node, O_RDWR);
+
+ if (gfd < 0) {
+ LOGE("%s:: %s Post processor open error\n", __func__, node);
+ return false;
+ }
+ }
+
+ vc.id = V4L2_CID_RESERVED_MEM_BASE_ADDR;
+ vc.value = 0;
+ ret = ioctl(gfd, VIDIOC_G_CTRL, &vc);
+ if (ret < 0) {
+ LOGE("Error in video VIDIOC_G_CTRL - V4L2_CID_RESERVED_MEM_BAES_ADDR (%d)\n", ret);
+ return false;
+ }
+ paddr = (unsigned int)vc.value;
+
+ if ((buffer_offset + size) >= FIMC1_RESERVED_SIZE * 1024)
+ buffer_offset = 0;
+
+ paddr += buffer_offset;
+ private_handle_t* hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_IOCTL, size, 0,
+ private_handle_t::LOCK_STATE_MAPPED, 0, 0);
+
+ *pHandle = hnd;
+ hnd->format = format;
+ hnd->usage = usage;
+ hnd->width = w;
+ hnd->height = h;
+ hnd->bpp = bpp;
+ hnd->paddr = paddr;
+ hnd->offset = buffer_offset;
+ hnd->stride = stride;
+ hnd->fd = gfd;
+ hnd->uoffset = (EXYNOS4_ALIGN((EXYNOS4_ALIGN(hnd->width, 16) * EXYNOS4_ALIGN(hnd->height, 16)), 4096));
+ hnd->voffset = (EXYNOS4_ALIGN((EXYNOS4_ALIGN((hnd->width >> 1), 16) * EXYNOS4_ALIGN((hnd->height >> 1), 16)), 4096));
+ buffer_offset += size;
+
+ return 0;
+ } else {
+ ion_buffer ion_fd = 0;
+ unsigned int ion_flags = 0;
+ int priv_alloc_flag = private_handle_t::PRIV_FLAGS_USES_UMP;
+
+ if (usage & GRALLOC_USAGE_HW_ION) {
+ if (!ion_dev_open) {
+ LOGE("ERROR, failed to open ion");
+ return -1;
+ }
+
+ private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
+ ion_flags = ION_HEAP_EXYNOS_MASK;
+ ion_fd = ion_alloc(m->ion_client, size, 0, ion_flags);
+
+ if (ion_fd < 0) {
+ LOGE("Failed to ion_alloc");
+ return -1;
+ }
+
+ cpu_ptr = ion_map(ion_fd, size, 0);
+
+ if (NULL == cpu_ptr) {
+ LOGE("Failed to ion_map");
+ ion_free(ion_fd);
+ return -1;
+ }
+
+ ump_mem_handle = ump_ref_drv_ion_import(ion_fd, UMP_REF_DRV_CONSTRAINT_NONE);
+
+ if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle) {
+ priv_alloc_flag = private_handle_t::PRIV_FLAGS_USES_ION;
+ } else {
+ LOGE("gralloc_alloc_buffer() failed to import ION memory");
+ ion_unmap(cpu_ptr, size);
+ ion_free(ion_fd);
+ return -1;
+ }
+ }
+#ifdef SAMSUNG_EXYNOS_CACHE_UMP
+ else if ((usage&GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN)
+ ump_mem_handle = ump_ref_drv_allocate(size, UMP_REF_DRV_CONSTRAINT_USE_CACHE);
+ else
+ ump_mem_handle = ump_ref_drv_allocate(size, UMP_REF_DRV_CONSTRAINT_NONE);
+#else
+ else
+ ump_mem_handle = ump_ref_drv_allocate(size, UMP_REF_DRV_CONSTRAINT_NONE);
+#endif
+ if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle) {
+ if (!(usage & GRALLOC_USAGE_HW_ION))
+ cpu_ptr = ump_mapped_pointer_get(ump_mem_handle);
+ if (NULL != cpu_ptr) {
+ ump_id = ump_secure_id_get(ump_mem_handle);
+ if (UMP_INVALID_SECURE_ID != ump_id) {
+ private_handle_t* hnd;
+ hnd = new private_handle_t(priv_alloc_flag, size, (int)cpu_ptr,
+ private_handle_t::LOCK_STATE_MAPPED, ump_id, ump_mem_handle, ion_fd, 0, 0);
+ if (NULL != hnd) {
+ *pHandle = hnd;
+#ifdef USE_PARTIAL_FLUSH
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
+ private_handle_rect *psRect;
+ private_handle_rect *psFRect;
+ psRect = (private_handle_rect *)calloc(1, sizeof(private_handle_rect));
+ psRect->handle = (int)hnd->ump_id;
+ psRect->stride = (int)hnd->stride_raw;
+ psFRect = find_last_rect((int)hnd->ump_id);
+ psFRect->next = psRect;
+ }
+#endif
+ hnd->format = format;
+ hnd->usage = usage;
+ hnd->width = w;
+ hnd->height = h;
+ hnd->bpp = bpp;
+ hnd->stride = stride;
+ hnd->uoffset = ((EXYNOS4_ALIGN(hnd->width, 16) * EXYNOS4_ALIGN(hnd->height, 16)));
+ hnd->voffset = ((EXYNOS4_ALIGN((hnd->width >> 1), 16) * EXYNOS4_ALIGN((hnd->height >> 1), 16)));
+ return 0;
+ } else {
+ LOGE("gralloc_alloc_buffer() failed to allocate handle");
+ }
+ } else {
+ LOGE("gralloc_alloc_buffer() failed to retrieve valid secure id");
+ }
+
+ ump_mapped_pointer_release(ump_mem_handle);
+ } else {
+ LOGE("gralloc_alloc_buffer() failed to map UMP memory");
+ }
+
+ ump_reference_release(ump_mem_handle);
+ } else {
+ LOGE("gralloc_alloc_buffer() failed to allcoate UMP memory");
+ }
+ }
+ return -1;
+}
+
+static int gralloc_alloc_framebuffer_locked(alloc_device_t* dev, size_t size, int usage,
+ buffer_handle_t* pHandle, int w, int h,
+ int format, int bpp)
+{
+ private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
+ /* allocate the framebuffer */
+ if (m->framebuffer == NULL) {
+ /* initialize the framebuffer, the framebuffer is mapped once and forever. */
+ int err = init_frame_buffer_locked(m);
+ if (err < 0)
+ return err;
+ }
+
+ const uint32_t bufferMask = m->bufferMask;
+ const uint32_t numBuffers = m->numBuffers;
+ const size_t bufferSize = m->finfo.line_length * m->info.yres;
+ if (numBuffers == 1) {
+ /*
+ * If we have only one buffer, we never use page-flipping. Instead,
+ * we return a regular buffer which will be memcpy'ed to the main
+ * screen when post is called.
+ */
+ int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;
+ LOGE("fallback to single buffering");
+ return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle, w, h, format, bpp, 0, 0);
+ }
+
+ if (bufferMask >= ((1LU<<numBuffers)-1))
+ return -ENOMEM;
+
+ int vaddr = m->framebuffer->base;
+ /* find a free slot */
+ for (uint32_t i = 0; i < numBuffers; i++) {
+ if ((bufferMask & (1LU<<i)) == 0) {
+ m->bufferMask |= (1LU<<i);
+ break;
+ }
+ vaddr += bufferSize;
+ }
+
+ /*
+ * The entire framebuffer memory is already mapped,
+ * now create a buffer object for parts of this memory
+ */
+ private_handle_t* hnd = new private_handle_t
+ (private_handle_t::PRIV_FLAGS_FRAMEBUFFER, size, vaddr,
+ 0, dup(m->framebuffer->fd), vaddr - m->framebuffer->base);
+
+ hnd->format = format;
+ hnd->usage = usage;
+ hnd->width = w;
+ hnd->height = h;
+ hnd->bpp = bpp;
+
+ *pHandle = hnd;
+
+ return 0;
+}
+
+static int gralloc_alloc_framebuffer(alloc_device_t* dev, size_t size, int usage,
+ buffer_handle_t* pHandle, int w, int h,
+ int format, int bpp)
+{
+ private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
+ pthread_mutex_lock(&m->lock);
+ int err = gralloc_alloc_framebuffer_locked(dev, size, usage, pHandle, w, h, format, bpp);
+ pthread_mutex_unlock(&m->lock);
+ return err;
+}
+
+static int alloc_device_alloc(alloc_device_t* dev, int w, int h, int format,
+ int usage, buffer_handle_t* pHandle, int* pStride)
+{
+ if (!pHandle || !pStride)
+ return -EINVAL;
+
+ size_t size = 0;
+ size_t stride = 0;
+ size_t stride_raw = 0;
+
+ if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP ||
+ format == HAL_PIXEL_FORMAT_YCrCb_420_SP ||
+ format == HAL_PIXEL_FORMAT_YCbCr_422_SP ||
+ format == HAL_PIXEL_FORMAT_YCbCr_420_P ||
+ format == HAL_PIXEL_FORMAT_YV12 ||
+ format == HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP ||
+ format == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED ||
+ format == GGL_PIXEL_FORMAT_L_8 ||
+ format == OMX_COLOR_FormatYUV420Planar ||
+ format == OMX_COLOR_FormatYUV420SemiPlanar) {
+ /* FIXME: there is no way to return the vstride */
+ int vstride;
+ stride = (w + 15) & ~15;
+ vstride = (h + 15) & ~15;
+ switch (format) {
+ case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+ case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+ case HAL_PIXEL_FORMAT_YCbCr_420_P:
+ case HAL_PIXEL_FORMAT_YV12:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED:
+ case OMX_COLOR_FormatYUV420Planar:
+ case OMX_COLOR_FormatYUV420SemiPlanar:
+ size = stride * vstride * 2;
+ if(usage & GRALLOC_USAGE_HW_FIMC1)
+ size += PAGE_SIZE * 2;
+ break;
+ case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+ size = (stride * vstride) + (w/2 * h/2) * 2;
+ break;
+ case GGL_PIXEL_FORMAT_L_8:
+ size = (stride * vstride);
+ break;
+ default:
+ return -EINVAL;
+ }
+ } else {
+ int align = 8;
+ int bpp = 0;
+ switch (format) {
+ case HAL_PIXEL_FORMAT_RGBA_8888:
+ case HAL_PIXEL_FORMAT_RGBX_8888:
+ case HAL_PIXEL_FORMAT_BGRA_8888:
+ bpp = 4;
+ break;
+ case HAL_PIXEL_FORMAT_RGB_888:
+ bpp = 3;
+ break;
+ case HAL_PIXEL_FORMAT_RGB_565:
+ case HAL_PIXEL_FORMAT_RGBA_5551:
+ case HAL_PIXEL_FORMAT_RGBA_4444:
+ bpp = 2;
+ break;
+ default:
+ return -EINVAL;
+ }
+ size_t bpr = (w*bpp + (align-1)) & ~(align-1);
+ size = bpr * h;
+ stride = bpr / bpp;
+ stride_raw = bpr;
+ }
+
+ int err;
+ pthread_mutex_lock(&l_surface);
+ if (usage & GRALLOC_USAGE_HW_FB)
+ err = gralloc_alloc_framebuffer(dev, size, usage, pHandle, w, h, format, 32);
+ else
+ err = gralloc_alloc_buffer(dev, size, usage, pHandle, w, h, format, 0, (int)stride_raw, (int)stride);
+
+ pthread_mutex_unlock(&l_surface);
+
+ if (err < 0)
+ return err;
+
+ *pStride = stride;
+ return 0;
+}
+
+static int alloc_device_free(alloc_device_t* dev, buffer_handle_t handle)
+{
+ if (private_handle_t::validate(handle) < 0)
+ return -EINVAL;
+
+ private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);
+ private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
+ pthread_mutex_lock(&l_surface);
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
+ /* free this buffer */
+ const size_t bufferSize = m->finfo.line_length * m->info.yres;
+ int index = (hnd->base - m->framebuffer->base) / bufferSize;
+ m->bufferMask &= ~(1<<index);
+ close(hnd->fd);
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
+#ifdef USE_PARTIAL_FLUSH
+ if (!release_rect((int)hnd->ump_id))
+ LOGE("secure id: 0x%x, release error",(int)hnd->ump_id);
+#endif
+ ump_mapped_pointer_release((ump_handle)hnd->ump_mem_handle);
+ ump_reference_release((ump_handle)hnd->ump_mem_handle);
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
+#ifdef USE_PARTIAL_FLUSH
+ if (!release_rect((int)hnd->ump_id))
+ LOGE("secure id: 0x%x, release error",(int)hnd->ump_id);
+#endif
+ ump_mapped_pointer_release((ump_handle)hnd->ump_mem_handle);
+ ump_reference_release((ump_handle)hnd->ump_mem_handle);
+
+ ion_unmap((void*)hnd->base, hnd->size);
+ ion_free(hnd->fd);
+ }
+ pthread_mutex_unlock(&l_surface);
+ delete hnd;
+
+ return 0;
+}
+
+static int alloc_device_close(struct hw_device_t *device)
+{
+ alloc_device_t* dev = reinterpret_cast<alloc_device_t*>(device);
+ if (dev) {
+ private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
+ if (ion_dev_open)
+ ion_client_destroy(m->ion_client);
+ delete dev;
+ ump_close();
+ }
+ return 0;
+}
+
+int alloc_device_open(hw_module_t const* module, const char* name, hw_device_t** device)
+{
+ alloc_device_t *dev;
+
+ dev = new alloc_device_t;
+ if (NULL == dev)
+ return -1;
+
+ dev->common.module = const_cast<hw_module_t*>(module);
+ private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
+ m->ion_client = ion_client_create();
+ ump_result ump_res = ump_open();
+ if (0 > m->ion_client)
+ ion_dev_open = false;
+ if (UMP_OK != ump_res) {
+ LOGE("UMP open failed ump_res %d", ump_res);
+ delete dev;
+ return -1;
+ }
+
+ /* initialize our state here */
+ memset(dev, 0, sizeof(*dev));
+
+ /* initialize the procs */
+ dev->common.tag = HARDWARE_DEVICE_TAG;
+ dev->common.version = 0;
+ dev->common.module = const_cast<hw_module_t*>(module);
+ dev->common.close = alloc_device_close;
+ dev->alloc = alloc_device_alloc;
+ dev->free = alloc_device_free;
+
+ *device = &dev->common;
+
+ return 0;
+}
diff --git a/exynos4/hal/libgralloc_ump/alloc_device.h b/exynos4/hal/libgralloc_ump/alloc_device.h
new file mode 100644
index 0000000..4609787
--- /dev/null
+++ b/exynos4/hal/libgralloc_ump/alloc_device.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2010 ARM Limited. All rights reserved.
+ *
+ * Portions of this code have been modified from the original.
+ * These modifications are:
+ * * includes
+ * * alloc_device_open()
+ *
+ * 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.
+ */
+
+#include <hardware/hardware.h>
+
+// Create an alloc device
+int alloc_device_open(hw_module_t const* module, const char* name, hw_device_t** device);
diff --git a/exynos4/hal/libgralloc_ump/framebuffer_device.cpp b/exynos4/hal/libgralloc_ump/framebuffer_device.cpp
new file mode 100644
index 0000000..9413112
--- /dev/null
+++ b/exynos4/hal/libgralloc_ump/framebuffer_device.cpp
@@ -0,0 +1,465 @@
+/*
+ * Copyright (C) 2010 ARM Limited. All rights reserved.
+ *
+ * Portions of this code have been modified from the original.
+ * These modifications are:
+ * * includes
+ * * enums
+ * * fb_set_swap_interval()
+ * * fb_post()
+ * * init_frame_buffer_locked()
+ * * init_frame_buffer()
+ * * fb_close()
+ * * framebuffer_device_open()
+ *
+ * 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.
+ */
+
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/fb.h>
+#include <stdlib.h>
+
+#include <cutils/log.h>
+#include <cutils/atomic.h>
+#include <cutils/properties.h>
+#include <hardware/hardware.h>
+#include <hardware/gralloc.h>
+
+#include <GLES/gl.h>
+
+#ifdef MALI_VSYNC_EVENT_REPORT_ENABLE
+#include "gralloc_vsync_report.h"
+#endif
+
+#include "gralloc_priv.h"
+#include "gralloc_helper.h"
+
+#include "linux/fb.h"
+
+/* numbers of buffers for page flipping */
+#define NUM_BUFFERS 2
+
+enum {
+ PAGE_FLIP = 0x00000001,
+};
+
+static int fb_set_swap_interval(struct framebuffer_device_t* dev, int interval)
+{
+ if (interval < dev->minSwapInterval || interval > dev->maxSwapInterval)
+ return -EINVAL;
+
+ /* Currently not implemented */
+ return 0;
+}
+
+static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer)
+{
+ if (private_handle_t::validate(buffer) < 0)
+ return -EINVAL;
+
+ private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(buffer);
+ private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
+
+ if (m->currentBuffer) {
+ m->base.unlock(&m->base, m->currentBuffer);
+ m->currentBuffer = 0;
+ }
+
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
+ m->base.lock(&m->base, buffer, private_module_t::PRIV_USAGE_LOCKED_FOR_POST,
+ 0, 0, m->info.xres, m->info.yres, NULL);
+
+ const size_t offset = hnd->base - m->framebuffer->base;
+ int interrupt;
+ m->info.activate = FB_ACTIVATE_VBL;
+ m->info.yoffset = offset / m->finfo.line_length;
+
+#ifdef STANDARD_LINUX_SCREEN
+#define FBIO_WAITFORVSYNC _IOW('F', 0x20, __u32)
+#define S3CFB_SET_VSYNC_INT _IOW('F', 206, unsigned int)
+ if (ioctl(m->framebuffer->fd, FBIOPAN_DISPLAY, &m->info) == -1) {
+ LOGE("FBIOPAN_DISPLAY failed");
+ m->base.unlock(&m->base, buffer);
+ return 0;
+ }
+
+ if (m->enableVSync) {
+ /* enable VSYNC */
+ interrupt = 1;
+ if (ioctl(m->framebuffer->fd, S3CFB_SET_VSYNC_INT, &interrupt) < 0) {
+ LOGE("S3CFB_SET_VSYNC_INT enable failed");
+ return 0;
+ }
+ /* wait for VSYNC */
+
+#ifdef MALI_VSYNC_EVENT_REPORT_ENABLE
+ gralloc_mali_vsync_report(MALI_VSYNC_EVENT_BEGIN_WAIT);
+#endif
+ int crtc;
+ crtc = 0;
+ if (ioctl(m->framebuffer->fd, FBIO_WAITFORVSYNC, &crtc) < 0) {
+ LOGE("FBIO_WAITFORVSYNC failed");
+#ifdef MALI_VSYNC_EVENT_REPORT_ENABLE
+ gralloc_mali_vsync_report(MALI_VSYNC_EVENT_END_WAIT);
+#endif
+ return 0;
+ }
+#ifdef MALI_VSYNC_EVENT_REPORT_ENABLE
+ gralloc_mali_vsync_report(MALI_VSYNC_EVENT_END_WAIT);
+#endif
+ // disable VSYNC
+ interrupt = 0;
+ if (ioctl(m->framebuffer->fd, S3CFB_SET_VSYNC_INT, &interrupt) < 0) {
+ LOGE("S3CFB_SET_VSYNC_INT disable failed");
+ return 0;
+ }
+#else
+ /*Standard Android way*/
+#ifdef MALI_VSYNC_EVENT_REPORT_ENABLE
+ gralloc_mali_vsync_report(MALI_VSYNC_EVENT_BEGIN_WAIT);
+#endif
+ if (ioctl(m->framebuffer->fd, FBIOPUT_VSCREENINFO, &m->info) == -1) {
+ LOGE("FBIOPUT_VSCREENINFO failed");
+#ifdef MALI_VSYNC_EVENT_REPORT_ENABLE
+ gralloc_mali_vsync_report(MALI_VSYNC_EVENT_END_WAIT);
+#endif
+ m->base.unlock(&m->base, buffer);
+ return -errno;
+ }
+#ifdef MALI_VSYNC_EVENT_REPORT_ENABLE
+ gralloc_mali_vsync_report(MALI_VSYNC_EVENT_END_WAIT);
+#endif
+#endif
+ }
+ m->currentBuffer = buffer;
+ } else {
+ /*
+ * If we can't do the page_flip, just copy the buffer to the front
+ * FIXME: use copybit HAL instead of memcpy
+ */
+ void* fb_vaddr;
+ void* buffer_vaddr;
+
+ m->base.lock(&m->base, m->framebuffer, GRALLOC_USAGE_SW_WRITE_RARELY,
+ 0, 0, m->info.xres, m->info.yres, &fb_vaddr);
+
+ m->base.lock(&m->base, buffer, GRALLOC_USAGE_SW_READ_RARELY,
+ 0, 0, m->info.xres, m->info.yres, &buffer_vaddr);
+
+ memcpy(fb_vaddr, buffer_vaddr, m->finfo.line_length * m->info.yres);
+
+ m->base.unlock(&m->base, buffer);
+ m->base.unlock(&m->base, m->framebuffer);
+ }
+ return 0;
+}
+
+int init_frame_buffer_locked(struct private_module_t* module)
+{
+ /* Nothing to do, already initialized */
+ if (module->framebuffer)
+ return 0;
+
+ char const * const device_template[] = {
+ "/dev/graphics/fb%u",
+ "/dev/fb%u",
+ NULL
+ };
+
+ int fd = -1;
+ int i = 0;
+ char name[64];
+
+ while ((fd == -1) && device_template[i]) {
+ snprintf(name, 64, device_template[i], 0);
+ fd = open(name, O_RDWR, 0);
+ i++;
+ }
+
+ if (fd < 0)
+ return -errno;
+
+ struct fb_fix_screeninfo finfo;
+ if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1)
+ return -errno;
+
+ struct fb_var_screeninfo info;
+ if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1)
+ return -errno;
+
+ info.reserved[0] = 0;
+ info.reserved[1] = 0;
+ info.reserved[2] = 0;
+ info.xoffset = 0;
+ info.yoffset = 0;
+ info.activate = FB_ACTIVATE_NOW;
+
+#ifdef GRALLOC_16_BITS
+ /*
+ * Explicitly request 5/6/5
+ */
+ info.bits_per_pixel = 16;
+ info.red.offset = 11;
+ info.red.length = 5;
+ info.green.offset = 5;
+ info.green.length = 6;
+ info.blue.offset = 0;
+ info.blue.length = 5;
+ info.transp.offset = 0;
+ info.transp.length = 0;
+#else
+ /*
+ * Explicitly request 8/8/8
+ */
+ info.bits_per_pixel = 32;
+ info.red.offset = 16;
+ info.red.length = 8;
+ info.green.offset = 8;
+ info.green.length = 8;
+ info.blue.offset = 0;
+ info.blue.length = 8;
+ info.transp.offset = 0;
+ info.transp.length = 0;
+#endif
+
+ /*
+ * Request NUM_BUFFERS screens (at lest 2 for page flipping)
+ */
+ info.yres_virtual = info.yres * NUM_BUFFERS;
+
+ uint32_t flags = PAGE_FLIP;
+ if (ioctl(fd, FBIOPUT_VSCREENINFO, &info) == -1) {
+ info.yres_virtual = info.yres;
+ flags &= ~PAGE_FLIP;
+ LOGW("FBIOPUT_VSCREENINFO failed, page flipping not supported");
+ }
+
+ if (info.yres_virtual < info.yres * 2) {
+ // we need at least 2 for page-flipping
+ info.yres_virtual = info.yres;
+ flags &= ~PAGE_FLIP;
+ LOGW("page flipping not supported (yres_virtual=%d, requested=%d)",
+ info.yres_virtual, info.yres * 2);
+ }
+
+ if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1)
+ return -errno;
+
+ int refreshRate = 1000000000000000LLU /
+ (
+ uint64_t( info.upper_margin + info.lower_margin + info.yres )
+ * ( info.left_margin + info.right_margin + info.xres )
+ * info.pixclock
+ );
+
+ if (refreshRate == 0)
+ refreshRate = 60 * 1000; /* 60 Hz */
+
+ if (int(info.width) <= 0 || int(info.height) <= 0) {
+ /* the driver doesn't return that information. default to 160 dpi */
+ info.width = ((info.xres * 25.4f)/160.0f + 0.5f);
+ info.height = ((info.yres * 25.4f)/160.0f + 0.5f);
+ }
+
+ float xdpi = (info.xres * 25.4f) / info.width;
+ float ydpi = (info.yres * 25.4f) / info.height;
+ float fps = refreshRate / 1000.0f;
+
+ LOGI("using (fd=%d)\n"
+ "id = %s\n"
+ "xres = %d px\n"
+ "yres = %d px\n"
+ "xres_virtual = %d px\n"
+ "yres_virtual = %d px\n"
+ "bpp = %d\n"
+ "r = %2u:%u\n"
+ "g = %2u:%u\n"
+ "b = %2u:%u\n",
+ fd,
+ finfo.id,
+ info.xres,
+ info.yres,
+ info.xres_virtual,
+ info.yres_virtual,
+ info.bits_per_pixel,
+ info.red.offset, info.red.length,
+ info.green.offset, info.green.length,
+ info.blue.offset, info.blue.length);
+
+ LOGI("width = %d mm (%f dpi)\n"
+ "height = %d mm (%f dpi)\n"
+ "refresh rate = %.2f Hz\n",
+ info.width, xdpi,
+ info.height, ydpi,
+ fps);
+
+ if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1)
+ return -errno;
+
+ if (finfo.smem_len <= 0)
+ return -errno;
+
+ module->flags = flags;
+ module->info = info;
+ module->finfo = finfo;
+ module->xdpi = xdpi;
+ module->ydpi = ydpi;
+ module->fps = fps;
+
+ char value[32];
+ property_get("debug.gralloc.vsync", value, "1");
+ module->enableVSync = atoi(value);
+ /*
+ * map the framebuffer
+ */
+ size_t fbSize = round_up_to_page_size(finfo.line_length * info.yres_virtual);
+ void* vaddr = mmap(0, fbSize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+ if (vaddr == MAP_FAILED) {
+ LOGE("Error mapping the framebuffer (%s)", strerror(errno));
+ return -errno;
+ }
+
+ memset(vaddr, 0, fbSize);
+
+ /*
+ * Create a "fake" buffer object for the entire frame buffer memory,
+ * and store it in the module
+ */
+ module->framebuffer = new private_handle_t(private_handle_t::PRIV_FLAGS_FRAMEBUFFER,
+ fbSize, intptr_t(vaddr), 0, dup(fd), 0);
+
+ module->numBuffers = info.yres_virtual / info.yres;
+ module->bufferMask = 0;
+
+ return 0;
+}
+
+int enableScreen(struct framebuffer_device_t* dev, int enable)
+{
+ private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
+
+ if (enable == 1) {
+ if (ioctl(m->framebuffer->fd, FBIOBLANK, FB_BLANK_UNBLANK) < 0) {
+ LOGE("%s: FBIOBLANK failed : (%d:%s)",
+ __func__, m->framebuffer->fd, strerror(errno));
+ return -EINVAL;
+ }
+ } else if (enable == 0) {
+ if (ioctl(m->framebuffer->fd, FBIOBLANK, FB_BLANK_POWERDOWN) < 0) {
+ LOGE("%s: FBIOBLANK failed : (%d:%s)",
+ __func__, m->framebuffer->fd, strerror(errno));
+ return -EINVAL;
+ }
+ } else {
+ return -EINVAL;
+ }
+ return 0;
+}
+static int init_frame_buffer(struct private_module_t* module)
+{
+ pthread_mutex_lock(&module->lock);
+ int err = init_frame_buffer_locked(module);
+ pthread_mutex_unlock(&module->lock);
+ return err;
+}
+
+static int fb_close(struct hw_device_t *device)
+{
+ framebuffer_device_t* dev = reinterpret_cast<framebuffer_device_t*>(device);
+ if (dev) {
+ ump_close();
+ delete dev;
+ }
+ return 0;
+}
+
+int compositionComplete(struct framebuffer_device_t* dev)
+{
+#ifndef HWC_HWOVERLAY
+ unsigned char pixels[4];
+ /* By doing a readpixel here we force the GL driver to start rendering
+ all the drawcalls up to this point, and to wait for the rendering to be complete.
+ Readpixel() also reads a dummy pixel, but this is not used. We only use this
+ function here to flush the render pipeline. */
+ glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+ /* The rendering of the backbuffer is now completed.
+ When SurfaceFlinger later does a call to eglSwapBuffer(), the swap will be done
+ synchronously in the same thread, and not asynchronoulsy in a background thread later.
+ The SurfaceFlinger requires this behaviour since it releases the lock on all the
+ SourceBuffers (Layers) after the compositionComplete() function returns.
+ However this "bad" behaviour by SurfaceFlinger should not affect performance,
+ since the Applications that render the SourceBuffers (Layers) still get the
+ full renderpipeline using asynchronouls rendering. So they perform at maximum speed,
+ and because of their complexity compared to the Surface flinger jobs, the Surface flinger
+ is normally faster even if it does everyhing synchronous and serial.
+ */
+#endif
+ return 0;
+}
+
+int framebuffer_device_open(hw_module_t const* module, const char* name, hw_device_t** device)
+{
+ int status = -EINVAL;
+
+ alloc_device_t* gralloc_device;
+ status = gralloc_open(module, &gralloc_device);
+ if (status < 0)
+ return status;
+
+ private_module_t* m = (private_module_t*)module;
+ status = init_frame_buffer(m);
+ if (status < 0) {
+ gralloc_close(gralloc_device);
+ return status;
+ }
+
+ /* initialize our state here */
+ framebuffer_device_t *dev = new framebuffer_device_t;
+ memset(dev, 0, sizeof(*dev));
+
+ /* initialize the procs */
+ dev->common.tag = HARDWARE_DEVICE_TAG;
+ dev->common.version = 0;
+ dev->common.module = const_cast<hw_module_t*>(module);
+ dev->common.close = fb_close;
+ dev->setSwapInterval = fb_set_swap_interval;
+ dev->post = fb_post;
+ dev->setUpdateRect = 0;
+ dev->compositionComplete = &compositionComplete;
+ dev->enableScreen = &enableScreen;
+
+ int stride = m->finfo.line_length / (m->info.bits_per_pixel >> 3);
+ const_cast<uint32_t&>(dev->flags) = 0;
+ const_cast<uint32_t&>(dev->width) = m->info.xres;
+ const_cast<uint32_t&>(dev->height) = m->info.yres;
+ const_cast<int&>(dev->stride) = stride;
+#ifdef GRALLOC_16_BITS
+ const_cast<int&>(dev->format) = HAL_PIXEL_FORMAT_RGB_565;
+#else
+ const_cast<int&>(dev->format) = HAL_PIXEL_FORMAT_BGRA_8888;
+#endif
+ const_cast<float&>(dev->xdpi) = m->xdpi;
+ const_cast<float&>(dev->ydpi) = m->ydpi;
+ const_cast<float&>(dev->fps) = m->fps;
+ const_cast<int&>(dev->minSwapInterval) = 1;
+ const_cast<int&>(dev->maxSwapInterval) = 1;
+ *device = &dev->common;
+ status = 0;
+
+ return status;
+}
diff --git a/exynos4/hal/libgralloc_ump/framebuffer_device.h b/exynos4/hal/libgralloc_ump/framebuffer_device.h
new file mode 100644
index 0000000..efcf1c3
--- /dev/null
+++ b/exynos4/hal/libgralloc_ump/framebuffer_device.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2010 ARM Limited. All rights reserved.
+ *
+ * Portions of this code have been modified from the original.
+ * These modifications are:
+ * * includes
+ * * framebuffer_device_open()
+ * * init_frame_buffer_locked()
+ *
+ * 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.
+ */
+
+#include <hardware/hardware.h>
+
+// Create a framebuffer device
+int framebuffer_device_open(hw_module_t const* module, const char* name, hw_device_t** device);
+
+// Initialize the framebuffer (must keep module lock before calling
+int init_frame_buffer_locked(struct private_module_t* module);
\ No newline at end of file
diff --git a/exynos4/hal/libgralloc_ump/gr.h b/exynos4/hal/libgralloc_ump/gr.h
new file mode 100644
index 0000000..3a43aa7
--- /dev/null
+++ b/exynos4/hal/libgralloc_ump/gr.h
@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+
+#ifndef GR_H_
+#define GR_H_
+
+#include <stdint.h>
+#ifdef HAVE_ANDROID_OS // just want PAGE_SIZE define
+# include <asm/page.h>
+#else
+# include <sys/user.h>
+#endif
+#include <limits.h>
+#include <sys/cdefs.h>
+#include <hardware/gralloc.h>
+#include <pthread.h>
+#include <errno.h>
+
+#include <cutils/native_handle.h>
+
+/*****************************************************************************/
+
+struct private_module_t;
+struct private_handle_t;
+
+inline size_t roundUpToPageSize(size_t x) {
+ return (x + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
+}
+
+int mapFrameBufferLocked(struct private_module_t* module);
+int terminateBuffer(gralloc_module_t const* module, private_handle_t* hnd);
+int mapBuffer(gralloc_module_t const* module, private_handle_t* hnd);
+
+/*****************************************************************************/
+
+class Locker {
+ pthread_mutex_t mutex;
+public:
+ class Autolock {
+ Locker& locker;
+ public:
+ inline Autolock(Locker& locker) : locker(locker) { locker.lock(); }
+ inline ~Autolock() { locker.unlock(); }
+ };
+ inline Locker() { pthread_mutex_init(&mutex, 0); }
+ inline ~Locker() { pthread_mutex_destroy(&mutex); }
+ inline void lock() { pthread_mutex_lock(&mutex); }
+ inline void unlock() { pthread_mutex_unlock(&mutex); }
+};
+
+#endif /* GR_H_ */
diff --git a/exynos4/hal/libgralloc_ump/gralloc_helper.h b/exynos4/hal/libgralloc_ump/gralloc_helper.h
new file mode 100644
index 0000000..21a5135
--- /dev/null
+++ b/exynos4/hal/libgralloc_ump/gralloc_helper.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2010 ARM Limited. All rights reserved.
+ *
+ * Portions of this code have been modified from the original.
+ * These modifications are:
+ * * includes
+ * * round_up_to_page_size()
+ *
+ * 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.
+ */
+
+#ifndef GRALLOC_HELPER_H_
+#define GRALLOC_HELPER_H_
+
+#include <sys/mman.h>
+
+inline size_t round_up_to_page_size(size_t x)
+{
+ return (x + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
+}
+
+#endif /* GRALLOC_HELPER_H_ */
diff --git a/exynos4/hal/libgralloc_ump/gralloc_module.cpp b/exynos4/hal/libgralloc_ump/gralloc_module.cpp
new file mode 100644
index 0000000..fb8fc43
--- /dev/null
+++ b/exynos4/hal/libgralloc_ump/gralloc_module.cpp
@@ -0,0 +1,480 @@
+/*
+ * Copyright (C) 2010 ARM Limited. All rights reserved.
+ *
+ * Portions of this code have been modified from the original.
+ * These modifications are:
+ * * includes
+ * * enums
+ * * gralloc_device_open()
+ * * gralloc_register_buffer()
+ * * gralloc_unregister_buffer()
+ * * gralloc_lock()
+ * * gralloc_unlock()
+ * * gralloc_module_methods
+ * * HAL_MODULE_INFO_SYM
+ *
+ * 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.
+ */
+
+#include <errno.h>
+#include <pthread.h>
+
+#include <sys/mman.h>
+#include <cutils/log.h>
+#include <cutils/atomic.h>
+#include <hardware/hardware.h>
+#include <hardware/gralloc.h>
+#include <fcntl.h>
+
+#include "gralloc_priv.h"
+#include "alloc_device.h"
+#include "framebuffer_device.h"
+
+#include "ump.h"
+#include "ump_ref_drv.h"
+#include "s5p_fimc.h"
+#include "exynos_mem.h"
+static pthread_mutex_t s_map_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t sMapLock = PTHREAD_MUTEX_INITIALIZER;
+
+static int s_ump_is_open = 0;
+static int gMemfd = 0;
+#define PFX_NODE_MEM "/dev/exynos-mem"
+
+/* we need this for now because pmem cannot mmap at an offset */
+#define PMEM_HACK 1
+#ifdef USE_PARTIAL_FLUSH
+struct private_handle_rect *rect_list;
+
+private_handle_rect *find_rect(int secure_id)
+{
+ private_handle_rect *psRect;
+
+ for (psRect = rect_list; psRect; psRect = psRect->next)
+ if (psRect->handle == secure_id)
+ break;
+ if (!psRect)
+ return NULL;
+
+ return psRect;
+}
+
+private_handle_rect *find_last_rect(int secure_id)
+{
+ private_handle_rect *psRect;
+ private_handle_rect *psFRect;
+
+ if (rect_list == NULL) {
+ rect_list = (private_handle_rect *)calloc(1, sizeof(private_handle_rect));
+ return rect_list;
+ }
+
+ for (psRect = rect_list; psRect; psRect = psRect->next) {
+ if (psRect->handle == secure_id)
+ return psFRect;
+ psFRect = psRect;
+ }
+ return psFRect;
+}
+
+int release_rect(int secure_id)
+{
+ private_handle_rect *psRect;
+ private_handle_rect *psTRect;
+
+ for (psRect = rect_list; psRect; psRect = psRect->next) {
+ if (psRect->next) {
+ if (psRect->next->handle == secure_id) {
+ if (psRect->next->next)
+ psTRect = psRect->next->next;
+ else
+ psTRect = NULL;
+
+ free(psRect->next);
+ psRect->next = psTRect;
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
+#endif
+
+static int gralloc_map(gralloc_module_t const* module,
+ buffer_handle_t handle, void** vaddr)
+{
+ private_handle_t* hnd = (private_handle_t*)handle;
+ if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_IOCTL) {
+ size_t size = FIMC1_RESERVED_SIZE * 1024;
+ void *mappedAddress = mmap(0, size,
+ PROT_READ|PROT_WRITE, MAP_SHARED, gMemfd, (hnd->paddr - hnd->offset));
+ if (mappedAddress == MAP_FAILED) {
+ LOGE("Could not mmap %s fd(%d)", strerror(errno),hnd->fd);
+ return -errno;
+ }
+ hnd->base = intptr_t(mappedAddress) + hnd->offset;
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
+ size_t size = hnd->size;
+ hnd->ion_client = ion_client_create();
+ void *mappedAddress = ion_map(hnd->fd, size, 0);
+
+ if (mappedAddress == MAP_FAILED) {
+ LOGE("Could not ion_map %s fd(%d)", strerror(errno), hnd->fd);
+ return -errno;
+ }
+
+ hnd->base = intptr_t(mappedAddress) + hnd->offset;
+ } else {
+ size_t size = hnd->size;
+#if PMEM_HACK
+ size += hnd->offset;
+#endif
+ void *mappedAddress = mmap(0, size,
+ PROT_READ|PROT_WRITE, MAP_SHARED, hnd->fd, 0);
+ if (mappedAddress == MAP_FAILED) {
+ LOGE("Could not mmap %s fd(%d)", strerror(errno),hnd->fd);
+ return -errno;
+ }
+ hnd->base = intptr_t(mappedAddress) + hnd->offset;
+ }
+ }
+ *vaddr = (void*)hnd->base;
+ return 0;
+}
+
+static int gralloc_unmap(gralloc_module_t const* module,
+ buffer_handle_t handle)
+{
+ private_handle_t* hnd = (private_handle_t*)handle;
+ if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_IOCTL) {
+ void* base = (void*)(intptr_t(hnd->base) - hnd->offset);
+ size_t size = FIMC1_RESERVED_SIZE * 1024;
+ if (munmap(base, size) < 0)
+ LOGE("Could not unmap %s", strerror(errno));
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
+ void* base = (void*)hnd->base;
+ size_t size = hnd->size;
+ if (ion_unmap(base, size) < 0)
+ LOGE("Could not ion_unmap %s", strerror(errno));
+ ion_client_destroy(hnd->ion_client);
+ } else {
+ void* base = (void*)hnd->base;
+ size_t size = hnd->size;
+#if PMEM_HACK
+ base = (void*)(intptr_t(base) - hnd->offset);
+ size += hnd->offset;
+#endif
+ if (munmap(base, size) < 0)
+ LOGE("Could not unmap %s", strerror(errno));
+ }
+ }
+ hnd->base = 0;
+ return 0;
+}
+
+static int gralloc_device_open(const hw_module_t* module, const char* name, hw_device_t** device)
+{
+ int status = -EINVAL;
+
+ if (!strcmp(name, GRALLOC_HARDWARE_GPU0))
+ status = alloc_device_open(module, name, device);
+ else if (!strcmp(name, GRALLOC_HARDWARE_FB0))
+ status = framebuffer_device_open(module, name, device);
+
+ return status;
+}
+
+static int gralloc_register_buffer(gralloc_module_t const* module, buffer_handle_t handle)
+{
+ int err = 0;
+ int retval = -EINVAL;
+ void *vaddr;
+ if (private_handle_t::validate(handle) < 0) {
+ LOGE("Registering invalid buffer, returning error");
+ return -EINVAL;
+ }
+
+ /* if this handle was created in this process, then we keep it as is. */
+ private_handle_t* hnd = (private_handle_t*)handle;
+
+#ifdef USE_PARTIAL_FLUSH
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
+ private_handle_rect *psRect;
+ private_handle_rect *psFRect;
+ psRect = (private_handle_rect *)calloc(1, sizeof(private_handle_rect));
+ psRect->handle = (int)hnd->ump_id;
+ psRect->stride = (int)hnd->stride;
+ psFRect = find_last_rect((int)hnd->ump_id);
+ psFRect->next = psRect;
+ }
+#endif
+ if (hnd->pid == getpid())
+ return 0;
+
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION)
+ err = gralloc_map(module, handle, &vaddr);
+
+ pthread_mutex_lock(&s_map_lock);
+
+ if (!s_ump_is_open) {
+ ump_result res = ump_open(); /* TODO: Fix a ump_close() somewhere??? */
+ if (res != UMP_OK) {
+ pthread_mutex_unlock(&s_map_lock);
+ LOGE("Failed to open UMP library");
+ return retval;
+ }
+ s_ump_is_open = 1;
+ }
+
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
+ hnd->ump_mem_handle = (int)ump_handle_create_from_secure_id(hnd->ump_id);
+ if (UMP_INVALID_MEMORY_HANDLE != (ump_handle)hnd->ump_mem_handle) {
+ hnd->base = (int)ump_mapped_pointer_get((ump_handle)hnd->ump_mem_handle);
+ if (0 != hnd->base) {
+ hnd->lockState = private_handle_t::LOCK_STATE_MAPPED;
+ hnd->writeOwner = 0;
+ hnd->lockState = 0;
+
+ pthread_mutex_unlock(&s_map_lock);
+ return 0;
+ } else {
+ LOGE("Failed to map UMP handle");
+ }
+
+ ump_reference_release((ump_handle)hnd->ump_mem_handle);
+ } else {
+ LOGE("Failed to create UMP handle");
+ }
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_PMEM) {
+ pthread_mutex_unlock(&s_map_lock);
+ return 0;
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_IOCTL) {
+ void* vaddr = NULL;
+
+ if (gMemfd == 0) {
+ gMemfd = open(PFX_NODE_MEM, O_RDWR);
+ if (gMemfd < 0) {
+ LOGE("%s:: %s exynos-mem open error\n", __func__, PFX_NODE_MEM);
+ return false;
+ }
+ }
+
+ gralloc_map(module, handle, &vaddr);
+ pthread_mutex_unlock(&s_map_lock);
+ return 0;
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
+ hnd->ump_mem_handle = (int)ump_handle_create_from_secure_id(hnd->ump_id);
+ if (UMP_INVALID_MEMORY_HANDLE != (ump_handle)hnd->ump_mem_handle) {
+ vaddr = (void*)ump_mapped_pointer_get((ump_handle)hnd->ump_mem_handle);
+ if (0 != vaddr) {
+ hnd->lockState = private_handle_t::LOCK_STATE_MAPPED;
+ hnd->writeOwner = 0;
+ hnd->lockState = 0;
+
+ pthread_mutex_unlock(&s_map_lock);
+ return 0;
+ } else {
+ LOGE("Failed to map UMP handle");
+ }
+ ump_reference_release((ump_handle)hnd->ump_mem_handle);
+ } else {
+ LOGE("Failed to create UMP handle");
+ }
+ } else {
+ LOGE("registering non-UMP buffer not supported");
+ }
+
+ pthread_mutex_unlock(&s_map_lock);
+ return retval;
+}
+
+static int gralloc_unregister_buffer(gralloc_module_t const* module, buffer_handle_t handle)
+{
+ if (private_handle_t::validate(handle) < 0) {
+ LOGE("unregistering invalid buffer, returning error");
+ return -EINVAL;
+ }
+
+ private_handle_t* hnd = (private_handle_t*)handle;
+
+#ifdef USE_PARTIAL_FLUSH
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP)
+ if (!release_rect((int)hnd->ump_id))
+ LOGE("secureID: 0x%x, release error", (int)hnd->ump_id);
+#endif
+ LOGE_IF(hnd->lockState & private_handle_t::LOCK_STATE_READ_MASK,
+ "[unregister] handle %p still locked (state=%08x)", hnd, hnd->lockState);
+
+ /* never unmap buffers that were created in this process */
+ if (hnd->pid != getpid()) {
+ pthread_mutex_lock(&s_map_lock);
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
+ ump_mapped_pointer_release((ump_handle)hnd->ump_mem_handle);
+ hnd->base = 0;
+ ump_reference_release((ump_handle)hnd->ump_mem_handle);
+ hnd->ump_mem_handle = (int)UMP_INVALID_MEMORY_HANDLE;
+ hnd->lockState = 0;
+ hnd->writeOwner = 0;
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_IOCTL) {
+ if(hnd->base != 0)
+ gralloc_unmap(module, handle);
+
+ pthread_mutex_unlock(&s_map_lock);
+ return 0;
+ } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
+ ump_mapped_pointer_release((ump_handle)hnd->ump_mem_handle);
+ ump_reference_release((ump_handle)hnd->ump_mem_handle);
+ if (hnd->base)
+ gralloc_unmap(module, handle);
+
+ hnd->base = 0;
+ hnd->ump_mem_handle = (int)UMP_INVALID_MEMORY_HANDLE;
+ hnd->lockState = 0;
+ hnd->writeOwner = 0;
+ } else {
+ LOGE("unregistering non-UMP buffer not supported");
+ }
+
+ pthread_mutex_unlock(&s_map_lock);
+ }
+
+ return 0;
+}
+
+static int gralloc_lock(gralloc_module_t const* module, buffer_handle_t handle,
+ int usage, int l, int t, int w, int h, void** vaddr)
+{
+ int err = 0;
+ if (private_handle_t::validate(handle) < 0) {
+ LOGE("Locking invalid buffer, returning error");
+ return -EINVAL;
+ }
+
+ private_handle_t* hnd = (private_handle_t*)handle;
+
+#ifdef SAMSUNG_EXYNOS_CACHE_UMP
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
+#ifdef USE_PARTIAL_FLUSH
+ private_handle_rect *psRect;
+ psRect = find_rect((int)hnd->ump_id);
+ psRect->l = l;
+ psRect->t = t;
+ psRect->w = w;
+ psRect->h= h;
+ psRect->locked = 1;
+#endif
+ }
+#endif
+ if (usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK))
+ *vaddr = (void*)hnd->base;
+
+ if (usage & GRALLOC_USAGE_YUV_ADDR) {
+ vaddr[0] = (void*)hnd->base;
+ vaddr[1] = (void*)(hnd->base + hnd->uoffset);
+ vaddr[2] = (void*)(hnd->base + hnd->uoffset + hnd->voffset);
+ }
+ return err;
+}
+
+static int gralloc_unlock(gralloc_module_t const* module, buffer_handle_t handle)
+{
+ if (private_handle_t::validate(handle) < 0) {
+ LOGE("Unlocking invalid buffer, returning error");
+ return -EINVAL;
+ }
+
+ private_handle_t* hnd = (private_handle_t*)handle;
+
+#ifdef SAMSUNG_EXYNOS_CACHE_UMP
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
+#ifdef USE_PARTIAL_FLUSH
+ private_handle_rect *psRect;
+ psRect = find_rect((int)hnd->ump_id);
+ ump_cpu_msync_now((ump_handle)hnd->ump_mem_handle, UMP_MSYNC_CLEAN,
+ (void *)(hnd->base + (psRect->stride * psRect->t)), psRect->stride * psRect->h );
+ return 0;
+#endif
+ ump_cpu_msync_now((ump_handle)hnd->ump_mem_handle, UMP_MSYNC_CLEAN_AND_INVALIDATE, NULL, 0);
+ }
+#endif
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION)
+ ion_msync(hnd->ion_client, hnd->fd, IMSYNC_DEV_TO_RW | IMSYNC_SYNC_FOR_DEV, hnd->size, hnd->offset);
+
+ if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_IOCTL) {
+ int ret;
+ exynos_mem_flush_range mem;
+ mem.start = hnd->paddr;
+ mem.length = hnd->size;
+
+ ret = ioctl(gMemfd, EXYNOS_MEM_PADDR_CACHE_FLUSH, &mem);
+ if (ret < 0) {
+ LOGE("Error in exynos-mem : EXYNOS_MEM_PADDR_CACHE_FLUSH (%d)\n", ret);
+ return false;
+ }
+ }
+
+ return 0;
+}
+
+static int gralloc_getphys(gralloc_module_t const* module, buffer_handle_t handle, void** paddr)
+{
+ private_handle_t* hnd = (private_handle_t*)handle;
+ paddr[0] = (void*)hnd->paddr;
+ paddr[1] = (void*)(hnd->paddr + hnd->uoffset);
+ paddr[2] = (void*)(hnd->paddr + hnd->uoffset + hnd->voffset);
+ return 0;
+}
+
+/* There is one global instance of the module */
+static struct hw_module_methods_t gralloc_module_methods =
+{
+ open: gralloc_device_open
+};
+
+struct private_module_t HAL_MODULE_INFO_SYM =
+{
+ base:
+ {
+ common:
+ {
+ tag: HARDWARE_MODULE_TAG,
+ version_major: 1,
+ version_minor: 0,
+ id: GRALLOC_HARDWARE_MODULE_ID,
+ name: "Graphics Memory Allocator Module",
+ author: "ARM Ltd.",
+ methods: &gralloc_module_methods,
+ dso: NULL,
+ reserved : {0,},
+ },
+ registerBuffer: gralloc_register_buffer,
+ unregisterBuffer: gralloc_unregister_buffer,
+ lock: gralloc_lock,
+ unlock: gralloc_unlock,
+ getphys: gralloc_getphys,
+ perform: NULL,
+ reserved_proc: {0,},
+ },
+ framebuffer: NULL,
+ flags: 0,
+ numBuffers: 0,
+ bufferMask: 0,
+ lock: PTHREAD_MUTEX_INITIALIZER,
+ currentBuffer: NULL,
+ ion_client: -1,
+};
diff --git a/exynos4/Android.mk b/exynos4/hal/libhdmi/Android.mk
similarity index 67%
copy from exynos4/Android.mk
copy to exynos4/hal/libhdmi/Android.mk
index 3c99f1a..237c53c 100644
--- a/exynos4/Android.mk
+++ b/exynos4/hal/libhdmi/Android.mk
@@ -1,4 +1,4 @@
-# Copyright (C) 2012 The Android Open Source Project
+# 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.
@@ -12,12 +12,6 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-ifeq ($(TARGET_BOARD_PLATFORM),exynos4)
-
-BOARD_HAL_PATH := hardware/samsung/exynos4/hal
-BOARD_HMM_PATH := hardware/samsung/exynos4/multimedia
-
-include $(BOARD_HAL_PATH)/Android.mk
-include $(BOARD_HMM_PATH)/Android.mk
-
+ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
+include $(all-subdir-makefiles)
endif
diff --git a/exynos4/hal/libhdmi/SecHdmi/Android.mk b/exynos4/hal/libhdmi/SecHdmi/Android.mk
new file mode 100644
index 0000000..e728309
--- /dev/null
+++ b/exynos4/hal/libhdmi/SecHdmi/Android.mk
@@ -0,0 +1,88 @@
+# 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.
+
+ifeq ($(BOARD_USES_HDMI),true)
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := eng
+
+LOCAL_PRELINK_MODULE := false
+#LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_SHARED_LIBRARIES := libutils liblog libedid libcec
+
+LOCAL_SRC_FILES := \
+ SecHdmiV4L2Utils.cpp \
+ SecHdmi.cpp \
+ fimd_api.c
+
+LOCAL_C_INCLUDES += $(LOCAL_PATH)
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/../../include
+
+ifeq ($(TARGET_SOC),exynos4210)
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4210
+endif
+
+ifeq ($(TARGET_SOC),exynos4x12)
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4x12
+endif
+
+LOCAL_CFLAGS += \
+ -DSCREEN_WIDTH=$(SCREEN_WIDTH) \
+ -DSCREEN_HEIGHT=$(SCREEN_HEIGHT) \
+ -DDEFAULT_FB_NUM=$(DEFAULT_FB_NUM)
+
+LOCAL_SHARED_LIBRARIES += libfimc
+
+ifeq ($(BOARD_USES_HDMI_SUBTITLES),true)
+LOCAL_CFLAGS += -DBOARD_USES_HDMI_SUBTITLES
+endif
+
+ifeq ($(BOARD_USES_FIMGAPI),true)
+LOCAL_CFLAGS += -DBOARD_USES_FIMGAPI
+LOCAL_C_INCLUDES += $(TARGET_HAL_PATH)/libfimg4x
+LOCAL_C_INCLUDES += external/skia/include/core
+LOCAL_SHARED_LIBRARIES += libfimg
+endif
+
+ifeq ($(BOARD_HDMI_STD), STD_NTSC_M)
+LOCAL_CFLAGS += -DSTD_NTSC_M
+endif
+
+ifeq ($(BOARD_HDMI_STD),STD_480P)
+LOCAL_CFLAGS += -DSTD_480P
+endif
+
+ifeq ($(BOARD_HDMI_STD),STD_720P)
+LOCAL_CFLAGS += -DSTD_720P
+endif
+
+ifeq ($(BOARD_HDMI_STD),STD_1080P)
+LOCAL_CFLAGS += -DSTD_1080P
+endif
+
+ifeq ($(BOARD_USE_V4L2),true)
+LOCAL_CFLAGS += -DBOARD_USE_V4L2
+endif
+
+ifeq ($(BOARD_USE_V4L2_ION),true)
+LOCAL_CFLAGS += -DBOARD_USE_V4L2_ION
+LOCAL_SHARED_LIBRARIES += libion
+endif
+
+LOCAL_MODULE := libhdmi
+include $(BUILD_SHARED_LIBRARY)
+
+endif
diff --git a/exynos4/hal/libhdmi/SecHdmi/SecHdmi.cpp b/exynos4/hal/libhdmi/SecHdmi/SecHdmi.cpp
new file mode 100644
index 0000000..444a9db
--- /dev/null
+++ b/exynos4/hal/libhdmi/SecHdmi/SecHdmi.cpp
@@ -0,0 +1,1957 @@
+/*
+ * 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.
+ */
+
+//#define LOG_NDEBUG 0
+//#define LOG_TAG "libhdmi"
+#include <cutils/log.h>
+
+#if defined(BOARD_USE_V4L2_ION)
+#include "ion.h"
+#endif
+
+#include "SecHdmi.h"
+#include "SecHdmiV4L2Utils.h"
+
+#define CHECK_GRAPHIC_LAYER_TIME (0)
+
+namespace android {
+
+extern unsigned int output_type;
+#if defined(BOARD_USE_V4L2)
+extern unsigned int g_preset_id;
+#endif
+extern v4l2_std_id t_std_id;
+extern int g_hpd_state;
+extern unsigned int g_hdcp_en;
+
+#if !defined(BOARD_USE_V4L2)
+extern int fp_tvout;
+extern int fp_tvout_v;
+extern int fp_tvout_g0;
+extern int fp_tvout_g1;
+#endif
+
+#if defined(BOARD_USES_FIMGAPI)
+extern unsigned int g2d_reserved_memory[HDMI_G2D_OUTPUT_BUF_NUM];
+extern unsigned int g2d_reserved_memory_size;
+extern unsigned int cur_g2d_address;
+extern unsigned int g2d_buf_index;
+#endif
+
+#if defined(BOARD_USES_CEC)
+SecHdmi::CECThread::~CECThread()
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+ mFlagRunning = false;
+}
+
+bool SecHdmi::CECThread::threadLoop()
+{
+ unsigned char buffer[CEC_MAX_FRAME_SIZE];
+ int size;
+ unsigned char lsrc, ldst, opcode;
+
+ {
+ Mutex::Autolock lock(mThreadLoopLock);
+ mFlagRunning = true;
+
+ size = CECReceiveMessage(buffer, CEC_MAX_FRAME_SIZE, 100000);
+
+ if (!size) // no data available or ctrl-c
+ return true;
+
+ if (size == 1)
+ return true; // "Polling Message"
+
+ lsrc = buffer[0] >> 4;
+
+ /* ignore messages with src address == mLaddr*/
+ if (lsrc == mLaddr)
+ return true;
+
+ opcode = buffer[1];
+
+ if (CECIgnoreMessage(opcode, lsrc)) {
+ LOGE("### ignore message coming from address 15 (unregistered)\n");
+ return true;
+ }
+
+ if (!CECCheckMessageSize(opcode, size)) {
+ LOGE("### invalid message size: %d(opcode: 0x%x) ###\n", size, opcode);
+ return true;
+ }
+
+ /* check if message broadcasted/directly addressed */
+ if (!CECCheckMessageMode(opcode, (buffer[0] & 0x0F) == CEC_MSG_BROADCAST ? 1 : 0)) {
+ LOGE("### invalid message mode (directly addressed/broadcast) ###\n");
+ return true;
+ }
+
+ ldst = lsrc;
+
+ //TODO: macroses to extract src and dst logical addresses
+ //TODO: macros to extract opcode
+
+ switch (opcode) {
+ case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
+ /* responce with "Report Physical Address" */
+ buffer[0] = (mLaddr << 4) | CEC_MSG_BROADCAST;
+ buffer[1] = CEC_OPCODE_REPORT_PHYSICAL_ADDRESS;
+ buffer[2] = (mPaddr >> 8) & 0xFF;
+ buffer[3] = mPaddr & 0xFF;
+ buffer[4] = mDevtype;
+ size = 5;
+ break;
+
+ case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
+ LOGD("[CEC_OPCODE_REQUEST_ACTIVE_SOURCE]\n");
+ /* responce with "Active Source" */
+ buffer[0] = (mLaddr << 4) | CEC_MSG_BROADCAST;
+ buffer[1] = CEC_OPCODE_ACTIVE_SOURCE;
+ buffer[2] = (mPaddr >> 8) & 0xFF;
+ buffer[3] = mPaddr & 0xFF;
+ size = 4;
+ LOGD("Tx : [CEC_OPCODE_ACTIVE_SOURCE]\n");
+ break;
+
+ case CEC_OPCODE_ABORT:
+ case CEC_OPCODE_FEATURE_ABORT:
+ default:
+ /* send "Feature Abort" */
+ buffer[0] = (mLaddr << 4) | ldst;
+ buffer[1] = CEC_OPCODE_FEATURE_ABORT;
+ buffer[2] = CEC_OPCODE_ABORT;
+ buffer[3] = 0x04; // "refused"
+ size = 4;
+ break;
+ }
+
+ if (CECSendMessage(buffer, size) != size)
+ LOGE("CECSendMessage() failed!!!\n");
+
+ }
+ return true;
+}
+
+bool SecHdmi::CECThread::start()
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ Mutex::Autolock lock(mThreadControlLock);
+ if (exitPending()) {
+ if (requestExitAndWait() == WOULD_BLOCK) {
+ LOGE("mCECThread.requestExitAndWait() == WOULD_BLOCK");
+ return false;
+ }
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("EDIDGetCECPhysicalAddress");
+#endif
+ /* set to not valid physical address */
+ mPaddr = CEC_NOT_VALID_PHYSICAL_ADDRESS;
+
+ if (!EDIDGetCECPhysicalAddress(&mPaddr)) {
+ LOGE("Error: EDIDGetCECPhysicalAddress() failed.\n");
+ return false;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("CECOpen");
+#endif
+ if (!CECOpen()) {
+ LOGE("CECOpen() failed!!!\n");
+ return false;
+ }
+
+ /* a logical address should only be allocated when a device \
+ has a valid physical address, at all other times a device \
+ should take the 'Unregistered' logical address (15)
+ */
+
+ /* if physical address is not valid device should take \
+ the 'Unregistered' logical address (15)
+ */
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("CECAllocLogicalAddress");
+#endif
+ mLaddr = CECAllocLogicalAddress(mPaddr, mDevtype);
+
+ if (!mLaddr) {
+ LOGE("CECAllocLogicalAddress() failed!!!\n");
+ if (!CECClose())
+ LOGE("CECClose() failed!\n");
+ return false;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("request to run CECThread");
+#endif
+
+ status_t ret = run("SecHdmi::CECThread", PRIORITY_DISPLAY);
+ if (ret != NO_ERROR) {
+ LOGE("%s fail to run thread", __func__);
+ return false;
+ }
+ return true;
+}
+
+bool SecHdmi::CECThread::stop()
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s request Exit", __func__);
+#endif
+ Mutex::Autolock lock(mThreadControlLock);
+ if (requestExitAndWait() == WOULD_BLOCK) {
+ LOGE("mCECThread.requestExitAndWait() == WOULD_BLOCK");
+ return false;
+ }
+
+ if (!CECClose())
+ LOGE("CECClose() failed!\n");
+
+ mFlagRunning = false;
+ return true;
+}
+#endif
+
+SecHdmi::SecHdmi():
+#if defined(BOARD_USES_CEC)
+ mCECThread(NULL),
+#endif
+ mFlagCreate(false),
+ mFlagConnected(false),
+ mHdmiDstWidth(0),
+ mHdmiDstHeight(0),
+ mHdmiSrcYAddr(0),
+ mHdmiSrcCbCrAddr(0),
+ mHdmiOutputMode(DEFAULT_OUPUT_MODE),
+ mHdmiResolutionValue(DEFAULT_HDMI_RESOLUTION_VALUE), // V4L2_STD_480P_60_4_3
+ mCompositeStd(DEFAULT_COMPOSITE_STD),
+ mHdcpMode(false),
+ mAudioMode(2),
+ mUIRotVal(0),
+ mG2DUIRotVal(0),
+ mCurrentHdmiOutputMode(-1),
+ mCurrentHdmiResolutionValue(0), // 1080960
+ mCurrentHdcpMode(false),
+ mCurrentAudioMode(-1),
+ mHdmiInfoChange(true),
+ mFimcDstColorFormat(0),
+ mFimcCurrentOutBufIndex(0),
+ mFBaddr(NULL),
+ mFBsize(0),
+ mFBionfd(-1),
+ mFBIndex(0),
+ mDefaultFBFd(-1),
+ mDisplayWidth(DEFALULT_DISPLAY_WIDTH),
+ mDisplayHeight(DEFALULT_DISPLAY_HEIGHT)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+ for (int i = 0; i < HDMI_LAYER_MAX; i++) {
+ mFlagLayerEnable[i] = false;
+ mFlagHdmiStart[i] = false;
+
+ mSrcWidth [i] = 0;
+ mSrcHeight [i] = 0;
+ mSrcColorFormat[i] = 0;
+ mHdmiResolutionWidth [i] = 0;
+ mHdmiResolutionHeight [i] = 0;
+ mHdmiFd[i] = -1;
+ mDstWidth [i] = 0;
+ mDstHeight [i] = 0;
+ mPrevDstWidth [i] = 0;
+ mPrevDstHeight [i] = 0;
+ }
+
+ mHdmiPresetId = DEFAULT_HDMI_PRESET_ID;
+ mHdmiStdId = DEFAULT_HDMI_STD_ID;
+
+ //All layer is on
+ mFlagLayerEnable[HDMI_LAYER_VIDEO] = true;
+ mFlagLayerEnable[HDMI_LAYER_GRAPHIC_0] = true;
+ mFlagLayerEnable[HDMI_LAYER_GRAPHIC_1] = true;
+
+ mHdmiSizeOfResolutionValueList = 14;
+
+ mHdmiResolutionValueList[0] = 1080960;
+ mHdmiResolutionValueList[1] = 1080950;
+ mHdmiResolutionValueList[2] = 1080930;
+ mHdmiResolutionValueList[3] = 1080924;
+ mHdmiResolutionValueList[4] = 1080160;
+ mHdmiResolutionValueList[5] = 1080150;
+ mHdmiResolutionValueList[6] = 720960;
+ mHdmiResolutionValueList[7] = 7209601;
+ mHdmiResolutionValueList[8] = 720950;
+ mHdmiResolutionValueList[9] = 7209501;
+ mHdmiResolutionValueList[10] = 5769501;
+ mHdmiResolutionValueList[11] = 5769502;
+ mHdmiResolutionValueList[12] = 4809601;
+ mHdmiResolutionValueList[13] = 4809602;
+
+#if defined(BOARD_USES_CEC)
+ mCECThread = new CECThread(this);
+#endif
+
+ SecBuffer zeroBuf;
+ for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
+ mFimcReservedMem[i] = zeroBuf;
+#if defined(BOARD_USE_V4L2)
+ for (int i = 0; i < HDMI_LAYER_MAX; i++)
+ for (int j = 0; j < MAX_BUFFERS_MIXER; j++)
+ mMixerBuffer[i][j] = zeroBuf;
+#endif
+
+ memset(&mDstRect, 0 , sizeof(struct v4l2_rect));
+}
+
+SecHdmi::~SecHdmi()
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+ if (mFlagCreate == true)
+ LOGE("%s::this is not Destroyed fail", __func__);
+ else
+ disconnect();
+}
+
+bool SecHdmi::create(int width, int height)
+{
+ Mutex::Autolock lock(mLock);
+ unsigned int fimc_buf_size = 0;
+ unsigned int gralloc_buf_size = 0;
+ mFimcCurrentOutBufIndex = 0;
+ int stride;
+ int vstride;
+ int BufNum = 0;
+#if defined(BOARD_USE_V4L2_ION)
+ int IonClient = -1;
+ int IonFd = -1;
+ void *ion_base_addr = NULL;
+#endif
+
+/*
+ * Video plaback (I420): output buffer size of FIMC3 is (1920 x 1088 x 1.5)
+ * Video plaback (NV12): FIMC3 is not used.
+ * Camera preview (YV12): output buffer size of FIMC3 is (640 x 480 x 1.5)
+ * UI mode (ARGB8888) : output buffer size of FIMC3 is (480 x 800 x 1.5)
+ */
+#ifndef SUPPORT_1080P_FIMC_OUT
+ setDisplaySize(width, height);
+#endif
+
+ stride = ALIGN(HDMI_MAX_WIDTH, 16);
+ vstride = ALIGN(HDMI_MAX_HEIGHT, 16);
+
+ fimc_buf_size = stride * vstride * HDMI_FIMC_BUFFER_BPP_SIZE;
+ gralloc_buf_size = GRALLOC_BUF_SIZE * SIZE_1K;
+#if defined(BOARD_USES_FIMGAPI)
+ g2d_reserved_memory_size = stride * vstride * HDMI_G2D_BUFFER_BPP_SIZE;
+#endif
+
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ if (mFlagCreate == true) {
+ LOGE("%s::Already Created fail", __func__);
+ goto CREATE_FAIL;
+ }
+
+ if (mDefaultFBFd <= 0) {
+ if ((mDefaultFBFd = fb_open(DEFAULT_FB)) < 0) {
+ LOGE("%s:Failed to open default FB", __func__);
+ return false;
+ }
+ }
+
+#ifdef BOARD_USE_V4L2
+ BufNum = HDMI_FIMC_OUTPUT_BUF_NUM;
+#else
+ BufNum = 1;
+#endif
+
+ if (mSecFimc.create(SecFimc::DEV_3, SecFimc::MODE_SINGLE_BUF, BufNum) == false) {
+ LOGE("%s::SecFimc create() fail", __func__);
+ goto CREATE_FAIL;
+ }
+
+#if defined(BOARD_USE_V4L2_ION)
+ IonClient = ion_client_create();
+ if (IonClient < 0) {
+ LOGE("%s::ion_client_create() failed", __func__);
+ goto CREATE_FAIL;
+ }
+#if defined(BOARD_USES_FIMGAPI)
+ IonFd = ion_alloc(IonClient, g2d_reserved_memory_size * HDMI_G2D_OUTPUT_BUF_NUM, 0, ION_HEAP_EXYNOS_MASK);
+
+ if (IonFd < 0) {
+ LOGE("%s::ION memory allocation failed", __func__);
+ } else {
+ ion_base_addr = ion_map(IonFd, ALIGN(g2d_reserved_memory_size * HDMI_G2D_OUTPUT_BUF_NUM, PAGE_SIZE), 0);
+ if (ion_base_addr == MAP_FAILED)
+ LOGE("%s::ION mmap failed", __func__);
+ }
+
+ for (int i = 0; i < HDMI_G2D_OUTPUT_BUF_NUM; i++)
+ g2d_reserved_memory[i] = ion_base_addr + (g2d_reserved_memory_size * i);
+#endif
+#else
+#ifndef BOARD_USE_V4L2
+ for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
+ mFimcReservedMem[i].phys.p = mSecFimc.getMemAddr()->phys.p + gralloc_buf_size + (fimc_buf_size * i);
+#endif
+
+#if defined(BOARD_USES_FIMGAPI)
+#if defined(BOARD_USES_HDMI_SUBTITLES)
+ for (int i = 0; i < HDMI_G2D_OUTPUT_BUF_NUM; i++)
+ g2d_reserved_memory[i] = mFimcReservedMem[HDMI_FIMC_OUTPUT_BUF_NUM - 1].phys.p + fimc_buf_size + (g2d_reserved_memory_size * i);
+#else
+ for (int i = 0; i < HDMI_G2D_OUTPUT_BUF_NUM; i++)
+ g2d_reserved_memory[i] = mSecFimc.getMemAddr()->phys.p + gralloc_buf_size + (g2d_reserved_memory_size * i);
+#endif
+#endif
+#endif
+
+ v4l2_std_id std_id;
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::mHdmiOutputMode(%d) \n", __func__, mHdmiOutputMode);
+#endif
+ if (mHdmiOutputMode == COMPOSITE_OUTPUT_MODE) {
+ std_id = composite_std_2_v4l2_std_id(mCompositeStd);
+ if ((int)std_id < 0) {
+ LOGE("%s::composite_std_2_v4l2_std_id(%d) fail\n", __func__, mCompositeStd);
+ goto CREATE_FAIL;
+ }
+ if (m_setCompositeResolution(mCompositeStd) == false) {
+ LOGE("%s::m_setCompositeResolution(%d) fail\n", __func__, mCompositeStd);
+ goto CREATE_FAIL;
+ }
+ } else if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
+ mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
+#if defined(BOARD_USE_V4L2)
+ unsigned int preset_id;
+
+ if (hdmi_resolution_2_preset_id(mHdmiResolutionValue, &mHdmiDstWidth, &mHdmiDstHeight, &preset_id) < 0) {
+ LOGE("%s::hdmi_resolution_2_preset_id(%d) fail\n", __func__, mHdmiResolutionValue);
+ goto CREATE_FAIL;
+ }
+#else
+ if (hdmi_resolution_2_std_id(mHdmiResolutionValue, &mHdmiDstWidth, &mHdmiDstHeight, &std_id) < 0) {
+ LOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, mHdmiResolutionValue);
+ goto CREATE_FAIL;
+ }
+#endif
+ }
+
+ mFlagCreate = true;
+
+ return true;
+
+CREATE_FAIL :
+
+ if (mSecFimc.flagCreate() == true &&
+ mSecFimc.destroy() == false)
+ LOGE("%s::fimc destory fail", __func__);
+
+ return false;
+}
+
+bool SecHdmi::destroy(void)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Already Destroyed fail \n", __func__);
+ goto DESTROY_FAIL;
+ }
+
+ for (int layer = HDMI_LAYER_BASE + 1; layer <= HDMI_LAYER_GRAPHIC_0; layer++) {
+ if (mFlagHdmiStart[layer] == true && m_stopHdmi(layer) == false) {
+ LOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, layer);
+ goto DESTROY_FAIL;
+ }
+
+ if (hdmi_deinit_layer(layer) < 0) {
+ LOGE("%s::hdmi_deinit_layer(%d) fail \n", __func__, layer);
+ goto DESTROY_FAIL;
+ }
+ }
+
+#if !defined(BOARD_USE_V4L2)
+ tvout_deinit();
+#endif
+
+ if (mSecFimc.flagCreate() == true && mSecFimc.destroy() == false) {
+ LOGE("%s::fimc destory fail \n", __func__);
+ goto DESTROY_FAIL;
+ }
+
+#ifdef USE_LCD_ADDR_IN_HERE
+ {
+ if (0 < mDefaultFBFd) {
+ close(mDefaultFBFd);
+ mDefaultFBFd = -1;
+ }
+ }
+#endif //USE_LCD_ADDR_IN_HERE
+
+#if defined(BOARD_USE_V4L2_ION)
+ if (mFBaddr != NULL)
+ ion_unmap((void *)mFBaddr, ALIGN(mFBsize * 4 * 2, PAGE_SIZE));
+
+ if (mFBionfd > 0)
+ ion_free(mFBionfd);
+
+ mFBaddr = NULL;
+ mFBionfd = -1;
+ mFBsize = 0;
+#endif
+
+#if defined(BOARD_USE_V4L2_ION) && defined(BOARD_USES_FIMGAPI)
+ ion_unmap((void *)g2d_reserved_memory[0], ALIGN(g2d_reserved_memory_size * HDMI_G2D_OUTPUT_BUF_NUM, PAGE_SIZE));
+#endif
+
+ mFlagCreate = false;
+
+ return true;
+
+DESTROY_FAIL :
+
+ return false;
+}
+
+bool SecHdmi::connect(void)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ {
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+
+ if (mFlagConnected == true) {
+ LOGD("%s::Already Connected.. \n", __func__);
+ return true;
+ }
+
+ if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
+ mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
+ if (m_flagHWConnected() == false) {
+ LOGD("%s::m_flagHWConnected() fail \n", __func__);
+ return false;
+ }
+
+#if defined(BOARD_USES_EDID)
+ if (!EDIDOpen())
+ LOGE("EDIDInit() failed!\n");
+
+ if (!EDIDRead()) {
+ LOGE("EDIDRead() failed!\n");
+ if (!EDIDClose())
+ LOGE("EDIDClose() failed!\n");
+ }
+#endif
+
+#if defined(BOARD_USES_CEC)
+ if (!(mCECThread->mFlagRunning))
+ mCECThread->start();
+#endif
+ }
+ }
+
+ if (this->setHdmiOutputMode(mHdmiOutputMode, true) == false)
+ LOGE("%s::setHdmiOutputMode(%d) fail \n", __func__, mHdmiOutputMode);
+
+ if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
+ mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
+ if (this->setHdmiResolution(mHdmiResolutionValue, true) == false)
+ LOGE("%s::setHdmiResolution(%d) fail \n", __func__, mHdmiResolutionValue);
+
+ if (this->setHdcpMode(mHdcpMode, false) == false)
+ LOGE("%s::setHdcpMode(%d) fail \n", __func__, mHdcpMode);
+
+ mHdmiInfoChange = true;
+ mFlagConnected = true;
+
+#if defined(BOARD_USES_EDID)
+ // show display..
+ display_menu();
+#endif
+ }
+
+ return true;
+}
+
+bool SecHdmi::disconnect(void)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+
+ if (mFlagConnected == false) {
+ LOGE("%s::Already Disconnected.. \n", __func__);
+ return true;
+ }
+
+ if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
+ mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
+#if defined(BOARD_USES_CEC)
+ if (mCECThread->mFlagRunning)
+ mCECThread->stop();
+#endif
+
+#if defined(BOARD_USES_EDID)
+ if (!EDIDClose()) {
+ LOGE("EDIDClose() failed!\n");
+ return false;
+ }
+#endif
+ }
+
+ for (int layer = SecHdmi::HDMI_LAYER_BASE + 1; layer <= SecHdmi::HDMI_LAYER_GRAPHIC_0; layer++) {
+ if (mFlagHdmiStart[layer] == true && m_stopHdmi(layer) == false) {
+ LOGE("%s::hdmiLayer(%d) layer fail \n", __func__, layer);
+ return false;
+ }
+ }
+
+#if defined(BOARD_USE_V4L2)
+ for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
+ if (hdmi_deinit_layer(layer) < 0)
+ LOGE("%s::hdmi_deinit_layer(%d) fail", __func__, layer);
+ }
+#else
+ tvout_deinit();
+#endif
+
+ mFlagConnected = false;
+
+ mHdmiOutputMode = DEFAULT_OUPUT_MODE;
+ mHdmiResolutionValue = DEFAULT_HDMI_RESOLUTION_VALUE;
+#if defined(BOARD_USE_V4L2)
+ mHdmiPresetId = DEFAULT_HDMI_PRESET_ID;
+#else
+ mHdmiStdId = DEFAULT_HDMI_STD_ID;
+#endif
+ mCompositeStd = DEFAULT_COMPOSITE_STD;
+ mAudioMode = 2;
+ mCurrentHdmiOutputMode = -1;
+ mCurrentHdmiResolutionValue = 0;
+ mCurrentAudioMode = -1;
+ mFimcCurrentOutBufIndex = 0;
+
+ return true;
+}
+
+bool SecHdmi::flagConnected(void)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+
+ return mFlagConnected;
+}
+
+bool SecHdmi::flush(int srcW, int srcH, int srcColorFormat,
+ unsigned int srcYAddr, unsigned int srcCbAddr, unsigned int srcCrAddr,
+ int dstX, int dstY,
+ int hdmiLayer,
+ int num_of_hwc_layer)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s [srcW=%d, srcH=%d, srcColorFormat=0x%x, srcYAddr=0x%x, srcCbAddr=0x%x, srcCrAddr=0x%x, dstX=%d, dstY=%d, hdmiLayer=%d]",
+ __func__, srcW, srcH, srcColorFormat, srcYAddr, srcCbAddr, srcCrAddr, dstX, dstY, hdmiLayer);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+
+#if defined(BOARD_USE_V4L2)
+ if (hdmiLayer == HDMI_LAYER_VIDEO) {
+ mDstWidth[hdmiLayer] = mHdmiDstWidth;
+ mDstHeight[hdmiLayer] = mHdmiDstHeight;
+ } else {
+ if (num_of_hwc_layer == 0) {
+ struct v4l2_rect rect;
+ int tempSrcW, tempSrcH;
+
+ if (mG2DUIRotVal == 0 || mG2DUIRotVal == 180) {
+ tempSrcW = srcW;
+ tempSrcH = srcH;
+ } else {
+ tempSrcW = srcH;
+ tempSrcH = srcW;
+ }
+
+ hdmi_cal_rect(tempSrcW, tempSrcH, mHdmiDstWidth, mHdmiDstHeight, &rect);
+ mDstWidth[hdmiLayer] = rect.width;
+ mDstHeight[hdmiLayer] = rect.height;
+ mDstWidth[HDMI_LAYER_VIDEO] = 0;
+ mDstHeight[HDMI_LAYER_VIDEO] = 0;
+ } else {
+ mDstWidth[hdmiLayer] = mHdmiDstWidth;
+ mDstHeight[hdmiLayer] = mHdmiDstHeight;
+ }
+ }
+#ifdef DEBUG_MSG_ENABLE
+ LOGE("m_reset param(%d, %d, %d, %d)",
+ mDstWidth[hdmiLayer], mDstHeight[hdmiLayer], \
+ mPrevDstWidth[hdmiLayer], mPrevDstHeight[hdmiLayer]);
+#endif
+#endif
+
+ if (srcW != mSrcWidth[hdmiLayer] ||
+ srcH != mSrcHeight[hdmiLayer] ||
+ srcColorFormat != mSrcColorFormat[hdmiLayer] ||
+ mHdmiDstWidth != mHdmiResolutionWidth[hdmiLayer] ||
+ mHdmiDstHeight != mHdmiResolutionHeight[hdmiLayer] ||
+#if defined(BOARD_USE_V4L2)
+ mDstWidth[hdmiLayer] != mPrevDstWidth[hdmiLayer] ||
+ mDstHeight[hdmiLayer] != mPrevDstHeight[hdmiLayer] ||
+#endif
+ mHdmiInfoChange == true) {
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("m_reset param(%d, %d, %d, %d, %d, %d, %d)",
+ srcW, mSrcWidth[hdmiLayer], \
+ srcH, mSrcHeight[hdmiLayer], \
+ srcColorFormat,mSrcColorFormat[hdmiLayer], \
+ hdmiLayer);
+#endif
+
+ if (m_reset(srcW, srcH, srcColorFormat, hdmiLayer, num_of_hwc_layer) == false) {
+ LOGE("%s::m_reset(%d, %d, %d, %d, %d) fail", __func__, srcW, srcH, srcColorFormat, hdmiLayer, num_of_hwc_layer);
+ return false;
+ }
+ }
+
+ if (srcYAddr == 0) {
+#if defined(BOARD_USE_V4L2_ION)
+ unsigned int FB_size = ALIGN(srcW, 16) * ALIGN(srcH, 16) * HDMI_FB_BPP_SIZE;
+ void *virFBAddr = 0;
+ struct s3c_fb_user_ion_client ion_handle;
+
+ if (mFBaddr != NULL) {
+ ion_unmap((void *)mFBaddr, ALIGN(mFBsize * 2, PAGE_SIZE));
+ ion_free(mFBionfd);
+ }
+
+ // get framebuffer virtual address for LCD
+ if (ioctl(mDefaultFBFd, S3CFB_GET_ION_USER_HANDLE, &ion_handle) < 0) {
+ LOGE("%s:ioctl(S3CFB_GET_ION_USER_HANDLE) fail", __func__);
+ return false;
+ }
+
+ virFBAddr = ion_map(ion_handle.fd, ALIGN(FB_size * 2, PAGE_SIZE), 0);
+ if (virFBAddr == MAP_FAILED) {
+ LOGE("%s::ion_map fail", __func__);
+ ion_free(ion_handle.fd);
+ mFBaddr = NULL;
+ return false;
+ }
+
+ if ((mFBIndex % 2) == 0)
+ srcYAddr = (unsigned int)virFBAddr;
+ else
+ srcYAddr = (unsigned int)virFBAddr + FB_size;
+
+ srcCbAddr = srcYAddr;
+
+ mFBIndex++;
+ mFBaddr = virFBAddr;
+ mFBsize = FB_size;
+ mFBionfd = ion_handle.fd;
+#else
+ unsigned int phyFBAddr = 0;
+
+ // get physical framebuffer address for LCD
+ if (ioctl(mDefaultFBFd, S3CFB_GET_FB_PHY_ADDR, &phyFBAddr) == -1) {
+ LOGE("%s:ioctl(S3CFB_GET_FB_PHY__ADDR) fail", __func__);
+ return false;
+ }
+
+ /*
+ * when early suspend, FIMD IP off.
+ * so physical framebuffer address for LCD is 0x00000000
+ * so JUST RETURN.
+ */
+ if (phyFBAddr == 0) {
+ LOGE("%s::S3CFB_GET_FB_PHY_ADDR fail", __func__);
+ return true;
+ }
+ srcYAddr = phyFBAddr;
+ srcCbAddr = srcYAddr;
+#endif
+ }
+
+ if (hdmiLayer == HDMI_LAYER_VIDEO) {
+ if (srcColorFormat == HAL_PIXEL_FORMAT_YCbCr_420_SP ||
+ srcColorFormat == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP) {
+#if defined(BOARD_USE_V4L2)
+ mMixerBuffer[hdmiLayer][0].virt.extP[0] = (char *)srcYAddr;
+ mMixerBuffer[hdmiLayer][0].virt.extP[1] = (char *)srcCbAddr;
+#else
+ hdmi_set_v_param(hdmiLayer,
+ srcW, srcH, V4L2_PIX_FMT_NV12,
+ srcYAddr, srcCbAddr,
+ mHdmiDstWidth, mHdmiDstHeight);
+#endif
+ } else if (srcColorFormat == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED) {
+#if defined(BOARD_USE_V4L2)
+ mMixerBuffer[hdmiLayer][0].virt.extP[0] = (char *)srcYAddr;
+ mMixerBuffer[hdmiLayer][0].virt.extP[1] = (char *)srcCbAddr;
+#else
+ hdmi_set_v_param(hdmiLayer,
+ srcW, srcH, V4L2_PIX_FMT_NV12T,
+ srcYAddr, srcCbAddr,
+ mHdmiDstWidth, mHdmiDstHeight);
+#endif
+ } else if (srcColorFormat == HAL_PIXEL_FORMAT_YCrCb_420_SP ||
+ srcColorFormat == HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP) {
+#if defined(BOARD_USE_V4L2)
+ mMixerBuffer[hdmiLayer][0].virt.extP[0] = (char *)srcYAddr;
+ mMixerBuffer[hdmiLayer][0].virt.extP[1] = (char *)srcCbAddr;
+#else
+ hdmi_set_v_param(hdmiLayer,
+ srcW, srcH, V4L2_PIX_FMT_NV21,
+ srcYAddr, srcCbAddr,
+ mHdmiDstWidth, mHdmiDstHeight);
+#endif
+ } else {
+ if (mSecFimc.setSrcAddr(srcYAddr, srcCbAddr, srcCrAddr, srcColorFormat) == false) {
+ LOGE("%s::setSrcAddr(%d, %d, %d) fail",
+ __func__, srcYAddr, srcCbAddr, srcCrAddr);
+ return false;
+ }
+
+ int y_size = 0;
+ if (mUIRotVal == 0 || mUIRotVal == 180)
+ y_size = ALIGN(ALIGN(srcW,128) * ALIGN(srcH, 32), SZ_8K);
+ else
+ y_size = ALIGN(ALIGN(srcH,128) * ALIGN(srcW, 32), SZ_8K);
+
+ mHdmiSrcYAddr = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[0];
+#ifdef BOARD_USE_V4L2
+ mHdmiSrcCbCrAddr = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[1];
+#else
+ mHdmiSrcCbCrAddr = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[0] + y_size;
+#endif
+ if (mSecFimc.setDstAddr(mHdmiSrcYAddr, mHdmiSrcCbCrAddr, 0, mFimcCurrentOutBufIndex) == false) {
+ LOGE("%s::mSecFimc.setDstAddr(%d, %d) fail \n",
+ __func__, mHdmiSrcYAddr, mHdmiSrcCbCrAddr);
+ return false;
+ }
+
+ if (mSecFimc.draw(0, mFimcCurrentOutBufIndex) == false) {
+ LOGE("%s::mSecFimc.draw() fail \n", __func__);
+ return false;
+ }
+#if defined(BOARD_USE_V4L2)
+ mMixerBuffer[hdmiLayer][0].virt.extP[0] = (char *)mHdmiSrcYAddr;
+ mMixerBuffer[hdmiLayer][0].virt.extP[1] = (char *)mHdmiSrcCbCrAddr;
+#else
+ if (mUIRotVal == 0 || mUIRotVal == 180)
+ hdmi_set_v_param(hdmiLayer,
+ srcW, srcH, V4L2_PIX_FMT_NV12T,
+ mHdmiSrcYAddr, mHdmiSrcCbCrAddr,
+ mHdmiDstWidth, mHdmiDstHeight);
+ else
+ hdmi_set_v_param(hdmiLayer,
+ srcH, srcW, V4L2_PIX_FMT_NV12T,
+ mHdmiSrcYAddr, mHdmiSrcCbCrAddr,
+ mHdmiDstWidth, mHdmiDstHeight);
+#endif
+ mFimcCurrentOutBufIndex++;
+ if (mFimcCurrentOutBufIndex >= HDMI_FIMC_OUTPUT_BUF_NUM)
+ mFimcCurrentOutBufIndex = 0;
+ }
+
+ } else {
+ if (srcColorFormat != HAL_PIXEL_FORMAT_BGRA_8888 &&
+ srcColorFormat != HAL_PIXEL_FORMAT_RGBA_8888 &&
+ srcColorFormat != HAL_PIXEL_FORMAT_RGB_565) {
+ if (mSecFimc.setSrcAddr(srcYAddr, srcCbAddr, srcCrAddr, srcColorFormat) == false) {
+ LOGE("%s::setSrcAddr(%d, %d, %d) fail",
+ __func__, srcYAddr, srcCbAddr, srcCrAddr);
+ return false;
+ }
+
+ if (mSecFimc.draw(0, mFimcCurrentOutBufIndex) == false) {
+ LOGE("%s::mSecFimc.draw() failed", __func__);
+ return false;
+ }
+#if defined(BOARD_USE_V4L2)
+ if (hdmi_set_g_scaling(hdmiLayer,
+ HAL_PIXEL_FORMAT_BGRA_8888,
+ mDstRect.width, mDstRect.height,
+ mHdmiSrcYAddr, &mMixerBuffer[hdmiLayer][0],
+ mDstRect.left , mDstRect.top,
+ mHdmiDstWidth, mHdmiDstHeight,
+ mG2DUIRotVal,
+ num_of_hwc_layer) < 0)
+ return false;
+#else
+ if (hdmi_gl_set_param(hdmiLayer,
+ HAL_PIXEL_FORMAT_BGRA_8888,
+ mDstRect.width, mDstRect.height,
+ mHdmiSrcYAddr, mHdmiSrcCbCrAddr,
+ mDstRect.left , mDstRect.top,
+ mHdmiDstWidth, mHdmiDstHeight,
+ mG2DUIRotVal) < 0)
+#endif
+ return false;
+ } else {
+#if CHECK_GRAPHIC_LAYER_TIME
+ nsecs_t start, end;
+ start = systemTime();
+#endif
+ if (num_of_hwc_layer == 0) { /* UI only mode */
+ struct v4l2_rect rect;
+
+ if (mG2DUIRotVal == 0 || mG2DUIRotVal == 180)
+ hdmi_cal_rect(srcW, srcH, mHdmiDstWidth, mHdmiDstHeight, &rect);
+ else
+ hdmi_cal_rect(srcH, srcW, mHdmiDstWidth, mHdmiDstHeight, &rect);
+
+ rect.left = ALIGN(rect.left, 16);
+
+#if defined(BOARD_USE_V4L2)
+ if (hdmi_set_g_scaling(hdmiLayer,
+ srcColorFormat,
+ srcW, srcH,
+ srcYAddr, &mMixerBuffer[hdmiLayer][0],
+ rect.left, rect.top,
+ rect.width, rect.height,
+ mG2DUIRotVal,
+ num_of_hwc_layer) < 0)
+ return false;
+#else
+ if (hdmi_gl_set_param(hdmiLayer,
+ srcColorFormat,
+ srcW, srcH,
+ srcYAddr, srcCbAddr,
+ rect.left, rect.top,
+ rect.width, rect.height,
+ mG2DUIRotVal) < 0)
+ return false;
+#endif
+ } else { /* Video Playback Mode */
+#if defined(BOARD_USE_V4L2)
+ if (hdmi_set_g_scaling(hdmiLayer,
+ srcColorFormat,
+ srcW, srcH,
+ srcYAddr, &mMixerBuffer[hdmiLayer][0],
+ dstX, dstY,
+ mHdmiDstWidth, mHdmiDstHeight,
+ mG2DUIRotVal,
+ num_of_hwc_layer) < 0)
+ return false;
+#else
+ if (hdmi_gl_set_param(hdmiLayer,
+ srcColorFormat,
+ srcW, srcH,
+ srcYAddr, srcCbAddr,
+ dstX, dstY,
+ mHdmiDstWidth, mHdmiDstHeight,
+ mG2DUIRotVal) < 0)
+ return false;
+#endif
+ }
+#if CHECK_GRAPHIC_LAYER_TIME
+ end = systemTime();
+ LOGD("[UI] hdmi_gl_set_param[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+#endif
+ }
+ }
+
+ if (mFlagConnected) {
+#if defined(BOARD_USE_V4L2)
+ unsigned int num_of_plane;
+
+ if (hdmi_get_src_plane(srcColorFormat, &num_of_plane) < 0) {
+ LOGE("%s::hdmi_get_src_plane(%d) fail", __func__, srcColorFormat);
+ return false;
+ }
+
+ if (mFlagHdmiStart[hdmiLayer] == false && m_startHdmi(hdmiLayer, num_of_plane) == false) {
+ LOGE("%s::hdmiLayer(%d) fail", __func__, hdmiLayer);
+ return false;
+ }
+#else
+ if (mFlagHdmiStart[hdmiLayer] == false && m_startHdmi(hdmiLayer) == false) {
+ LOGE("%s::hdmiLayer(%d) fail", __func__, hdmiLayer);
+ return false;
+ }
+#endif
+ }
+
+ return true;
+}
+
+bool SecHdmi::clear(int hdmiLayer)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s || hdmiLayer = %d", __func__, hdmiLayer);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+ if (mFlagHdmiStart[hdmiLayer] == true && m_stopHdmi(hdmiLayer) == false) {
+ LOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, hdmiLayer);
+ return false;
+ }
+ return true;
+}
+
+bool SecHdmi::setHdmiOutputMode(int hdmiOutputMode, bool forceRun)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::hdmiOutputMode = %d, forceRun = %d", __func__, hdmiOutputMode, forceRun);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+
+ if (forceRun == false && mHdmiOutputMode == hdmiOutputMode) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::same hdmiOutputMode(%d) \n", __func__, hdmiOutputMode);
+#endif
+ return true;
+ }
+
+ int newHdmiOutputMode = hdmiOutputMode;
+
+ int v4l2OutputType = hdmi_outputmode_2_v4l2_output_type(hdmiOutputMode);
+ if (v4l2OutputType < 0) {
+ LOGD("%s::hdmi_outputmode_2_v4l2_output_type(%d) fail\n", __func__, hdmiOutputMode);
+ return false;
+ }
+
+#if defined(BOARD_USES_EDID)
+ int newV4l2OutputType = hdmi_check_output_mode(v4l2OutputType);
+ if (newV4l2OutputType != v4l2OutputType) {
+ newHdmiOutputMode = hdmi_v4l2_output_type_2_outputmode(newV4l2OutputType);
+ if (newHdmiOutputMode < 0) {
+ LOGD("%s::hdmi_v4l2_output_type_2_outputmode(%d) fail\n", __func__, newV4l2OutputType);
+ return false;
+ }
+
+ LOGD("%s::calibration mode(%d -> %d)... \n", __func__, hdmiOutputMode, newHdmiOutputMode);
+ mHdmiInfoChange = true;
+ }
+#endif
+
+ if (mHdmiOutputMode != newHdmiOutputMode) {
+ mHdmiOutputMode = newHdmiOutputMode;
+ mHdmiInfoChange = true;
+ }
+
+ return true;
+}
+
+bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s:: hdmiResolutionValue = %d, forceRun = %d", __func__, hdmiResolutionValue, forceRun);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+
+ if (forceRun == false && mHdmiResolutionValue == hdmiResolutionValue) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
+#endif
+ return true;
+ }
+
+ unsigned int newHdmiResolutionValue = hdmiResolutionValue;
+ int w = 0;
+ int h = 0;
+
+#if defined(BOARD_USES_EDID)
+ // find perfect resolutions..
+#if defined(BOARD_USE_V4L2)
+ unsigned int preset_id;
+ if (hdmi_resolution_2_preset_id(newHdmiResolutionValue, &w, &h, &preset_id) < 0 ||
+ hdmi_check_resolution(preset_id) < 0) {
+ bool flagFoundIndex = false;
+ int resolutionValueIndex = m_resolutionValueIndex(newHdmiResolutionValue);
+
+ for (int i = resolutionValueIndex + 1; i < mHdmiSizeOfResolutionValueList; i++) {
+ if (hdmi_resolution_2_preset_id(mHdmiResolutionValueList[i], &w, &h, &preset_id) == 0 &&
+ hdmi_check_resolution(preset_id) == 0) {
+ newHdmiResolutionValue = mHdmiResolutionValueList[i];
+ flagFoundIndex = true;
+ break;
+ }
+ }
+
+ if (flagFoundIndex == false) {
+ LOGE("%s::hdmi cannot control this resolution(%d) fail \n", __func__, hdmiResolutionValue);
+ // Set resolution to 480P
+ newHdmiResolutionValue = mHdmiResolutionValueList[mHdmiSizeOfResolutionValueList-2];
+ } else {
+ LOGD("%s::HDMI resolutions size is calibrated(%d -> %d)..\n", __func__, hdmiResolutionValue, newHdmiResolutionValue);
+ }
+ }
+#else
+ v4l2_std_id std_id;
+ if (hdmi_resolution_2_std_id(newHdmiResolutionValue, &w, &h, &std_id) < 0 ||
+ hdmi_check_resolution(std_id) < 0) {
+ bool flagFoundIndex = false;
+ int resolutionValueIndex = m_resolutionValueIndex(newHdmiResolutionValue);
+
+ for (int i = resolutionValueIndex + 1; i < mHdmiSizeOfResolutionValueList; i++) {
+ if (hdmi_resolution_2_std_id(mHdmiResolutionValueList[i], &w, &h, &std_id) == 0 &&
+ hdmi_check_resolution(std_id) == 0) {
+ newHdmiResolutionValue = mHdmiResolutionValueList[i];
+ flagFoundIndex = true;
+ break;
+ }
+ }
+
+ if (flagFoundIndex == false) {
+ LOGE("%s::hdmi cannot control this resolution(%d) fail \n", __func__, hdmiResolutionValue);
+ // Set resolution to 480P
+ newHdmiResolutionValue = mHdmiResolutionValueList[mHdmiSizeOfResolutionValueList-2];
+ } else {
+ LOGD("%s::HDMI resolutions size is calibrated(%d -> %d)..\n", __func__, hdmiResolutionValue, newHdmiResolutionValue);
+ }
+ }
+#endif
+ else {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::find resolutions(%d) at once\n", __func__, hdmiResolutionValue);
+#endif
+ }
+#endif
+
+ if (mHdmiResolutionValue != newHdmiResolutionValue) {
+ mHdmiResolutionValue = newHdmiResolutionValue;
+ mHdmiInfoChange = true;
+ }
+
+ return true;
+}
+
+bool SecHdmi::setHdcpMode(bool hdcpMode, bool forceRun)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+
+ if (forceRun == false && mHdcpMode == hdcpMode) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::same hdcpMode(%d) \n", __func__, hdcpMode);
+#endif
+ return true;
+ }
+
+ mHdcpMode = hdcpMode;
+ mHdmiInfoChange = true;
+
+ return true;
+}
+
+bool SecHdmi::setUIRotation(unsigned int rotVal, unsigned int hwcLayer)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ Mutex::Autolock lock(mLock);
+
+ if (mFlagCreate == false) {
+ LOGE("%s::Not Yet Created \n", __func__);
+ return false;
+ }
+
+ if (rotVal % 90 != 0) {
+ LOGE("%s::Invalid rotation value(%d)", __func__, rotVal);
+ return false;
+ }
+
+ /* G2D rotation */
+ if (rotVal != mG2DUIRotVal) {
+ mG2DUIRotVal = rotVal;
+ mHdmiInfoChange = true;
+ }
+
+ /* FIMC rotation */
+ if (hwcLayer == 0) { /* Rotate in UI only mode */
+ if (rotVal != mUIRotVal) {
+ mSecFimc.setRotVal(rotVal);
+ mUIRotVal = rotVal;
+ mHdmiInfoChange = true;
+ }
+ } else { /* Don't rotate video layer when video is played. */
+ rotVal = 0;
+ if (rotVal != mUIRotVal) {
+ mSecFimc.setRotVal(rotVal);
+ mUIRotVal = rotVal;
+ mHdmiInfoChange = true;
+ }
+ }
+
+ return true;
+}
+
+bool SecHdmi::setDisplaySize(int width, int height)
+{
+ mDisplayWidth = width;
+ mDisplayHeight = height;
+
+ return true;
+}
+
+bool SecHdmi::m_reset(int w, int h, int colorFormat, int hdmiLayer, int hwcLayer)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s called", __func__);
+#endif
+ v4l2_std_id std_id = 0;
+ mFimcCurrentOutBufIndex = 0;
+
+ int srcW = w;
+ int srcH = h;
+
+#if defined(BOARD_USE_V4L2)
+ if (mFlagHdmiStart[hdmiLayer] == true && m_stopHdmi(hdmiLayer) == false) {
+ LOGE("%s::m_stopHdmi: layer[%d] fail", __func__, hdmiLayer);
+ return false;
+ }
+#else
+ // stop all..
+ for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
+ if (mFlagHdmiStart[layer] == true && m_stopHdmi(layer) == false) {
+ LOGE("%s::m_stopHdmi: layer[%d] fail", __func__, layer);
+ return false;
+ }
+ }
+#endif
+
+#if defined(BOARD_USE_V4L2)
+ if (hdmi_deinit_layer(hdmiLayer) < 0)
+ LOGE("%s::hdmi_deinit_layer(%d) fail", __func__, hdmiLayer);
+
+ mHdmiFd[hdmiLayer] = hdmi_init_layer(hdmiLayer);
+ if (mHdmiFd[hdmiLayer] < 0)
+ LOGE("%s::hdmi_init_layer(%d) fail", __func__, hdmiLayer);
+
+ if (tvout_std_v4l2_init(mHdmiFd[hdmiLayer], mHdmiPresetId) < 0)
+ LOGE("%s::tvout_std_v4l2_init fail", __func__);
+#endif
+
+ if (w != mSrcWidth [hdmiLayer] ||
+ h != mSrcHeight [hdmiLayer] ||
+ mHdmiDstWidth != mHdmiResolutionWidth[hdmiLayer] ||
+ mHdmiDstHeight != mHdmiResolutionHeight[hdmiLayer] ||
+#if defined(BOARD_USE_V4L2)
+ mDstWidth[hdmiLayer] != mPrevDstWidth[hdmiLayer] ||
+ mDstHeight[hdmiLayer] != mPrevDstHeight[hdmiLayer] ||
+#endif
+ colorFormat != mSrcColorFormat[hdmiLayer]) {
+ int preVideoSrcColorFormat = mSrcColorFormat[hdmiLayer];
+ int videoSrcColorFormat = colorFormat;
+
+ if (preVideoSrcColorFormat != HAL_PIXEL_FORMAT_YCbCr_420_SP &&
+ preVideoSrcColorFormat != HAL_PIXEL_FORMAT_YCrCb_420_SP &&
+ preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP &&
+ preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP &&
+ preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED) {
+ LOGI("%s: Unsupported preVideoSrcColorFormat = 0x%x\n", __func__, preVideoSrcColorFormat);
+ preVideoSrcColorFormat = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED;
+ }
+
+ if (hdmiLayer == HDMI_LAYER_VIDEO) {
+ if (colorFormat != HAL_PIXEL_FORMAT_YCbCr_420_SP &&
+ colorFormat != HAL_PIXEL_FORMAT_YCrCb_420_SP &&
+ colorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP &&
+ colorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP &&
+ colorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s call mSecFimc.setSrcParams\n", __func__);
+#endif
+ unsigned int full_wdith = ALIGN(w, 16);
+ unsigned int full_height = ALIGN(h, 2);
+
+ if (mSecFimc.setSrcParams(full_wdith, full_height, 0, 0,
+ (unsigned int*)&w, (unsigned int*)&h, colorFormat, true) == false) {
+ LOGE("%s::mSecFimc.setSrcParams(%d, %d, %d) fail \n",
+ __func__, w, h, colorFormat);
+ return false;
+ }
+
+ mFimcDstColorFormat = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED;
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s call mSecFimc.setDstParams\n", __func__);
+#endif
+ if (mUIRotVal == 0 || mUIRotVal == 180) {
+ if (mSecFimc.setDstParams((unsigned int)w, (unsigned int)h, 0, 0,
+ (unsigned int*)&w, (unsigned int*)&h, mFimcDstColorFormat, true) == false) {
+ LOGE("%s::mSecFimc.setDstParams(%d, %d, %d) fail \n",
+ __func__, w, h, mFimcDstColorFormat);
+ return false;
+ }
+#if defined(BOARD_USE_V4L2)
+ hdmi_set_v_param(mHdmiFd[hdmiLayer], hdmiLayer,
+ mFimcDstColorFormat, srcW, srcH,
+ &mMixerBuffer[hdmiLayer][0],
+ 0, 0, mHdmiDstWidth, mHdmiDstHeight);
+#endif
+ } else {
+ if (mSecFimc.setDstParams((unsigned int)h, (unsigned int)w, 0, 0,
+ (unsigned int*)&h, (unsigned int*)&w, mFimcDstColorFormat, true) == false) {
+ LOGE("%s::mSecFimc.setDstParams(%d, %d, %d) fail \n",
+ __func__, w, h, mFimcDstColorFormat);
+ return false;
+ }
+#if defined(BOARD_USE_V4L2)
+ hdmi_set_v_param(mHdmiFd[hdmiLayer], hdmiLayer,
+ mFimcDstColorFormat, srcH, srcW,
+ &mMixerBuffer[hdmiLayer][0],
+ 0, 0, mHdmiDstWidth, mHdmiDstHeight);
+#endif
+ }
+ }
+#if defined(BOARD_USE_V4L2)
+ else {
+ hdmi_set_v_param(mHdmiFd[hdmiLayer], hdmiLayer,
+ colorFormat, srcW, srcH,
+ &mMixerBuffer[hdmiLayer][0],
+ 0, 0, mHdmiDstWidth, mHdmiDstHeight);
+ }
+#endif
+ mPrevDstWidth[hdmiLayer] = mHdmiDstWidth;
+ mPrevDstHeight[hdmiLayer] = mHdmiDstHeight;
+ } else {
+#if defined(BOARD_USE_V4L2)
+ struct v4l2_rect rect;
+ int tempSrcW, tempSrcH;
+
+ if (mG2DUIRotVal == 0 || mG2DUIRotVal == 180) {
+ tempSrcW = srcW;
+ tempSrcH = srcH;
+ } else {
+ tempSrcW = srcH;
+ tempSrcH = srcW;
+ }
+
+ hdmi_cal_rect(tempSrcW, tempSrcH, mHdmiDstWidth, mHdmiDstHeight, &rect);
+ rect.left = ALIGN(rect.left, 16);
+
+ if (hwcLayer == 0) { /* UI only mode */
+ hdmi_set_g_param(mHdmiFd[hdmiLayer], hdmiLayer,
+ colorFormat, srcW, srcH,
+ &mMixerBuffer[hdmiLayer][0],
+ rect.left, rect.top, rect.width, rect.height);
+ mPrevDstWidth[hdmiLayer] = rect.width;
+ mPrevDstHeight[hdmiLayer] = rect.height;
+ mPrevDstWidth[HDMI_LAYER_VIDEO] = 0;
+ mPrevDstHeight[HDMI_LAYER_VIDEO] = 0;
+ } else { /* Video Playback + UI Mode */
+ hdmi_set_g_param(mHdmiFd[hdmiLayer], hdmiLayer,
+ colorFormat, srcW, srcH,
+ &mMixerBuffer[hdmiLayer][0],
+ 0, 0, mHdmiDstWidth, mHdmiDstHeight);
+ mPrevDstWidth[hdmiLayer] = mHdmiDstWidth;
+ mPrevDstHeight[hdmiLayer] = mHdmiDstHeight;
+ }
+#endif
+ }
+
+ if (preVideoSrcColorFormat != videoSrcColorFormat)
+ mHdmiInfoChange = true;
+
+ mSrcWidth[hdmiLayer] = srcW;
+ mSrcHeight[hdmiLayer] = srcH;
+ mSrcColorFormat[hdmiLayer] = colorFormat;
+
+ mHdmiResolutionWidth[hdmiLayer] = mHdmiDstWidth;
+ mHdmiResolutionHeight[hdmiLayer] = mHdmiDstHeight;
+
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("m_reset saved param(%d, %d, %d, %d, %d, %d, %d) \n",
+ srcW, mSrcWidth[hdmiLayer], \
+ srcH, mSrcHeight[hdmiLayer], \
+ colorFormat,mSrcColorFormat[hdmiLayer], \
+ hdmiLayer);
+#endif
+ }
+
+ if (mHdmiInfoChange == true) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("mHdmiInfoChange: %d\n", mHdmiInfoChange);
+#endif
+ // stop all..
+#if defined(BOARD_USES_CEC)
+ if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
+ mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
+ if (mCECThread->mFlagRunning)
+ mCECThread->stop();
+ }
+#endif
+
+ if (m_setHdmiOutputMode(mHdmiOutputMode) == false) {
+ LOGE("%s::m_setHdmiOutputMode() fail \n", __func__);
+ return false;
+ }
+ if (mHdmiOutputMode == COMPOSITE_OUTPUT_MODE) {
+ std_id = composite_std_2_v4l2_std_id(mCompositeStd);
+ if ((int)std_id < 0) {
+ LOGE("%s::composite_std_2_v4l2_std_id(%d) fail\n", __func__, mCompositeStd);
+ return false;
+ }
+ if (m_setCompositeResolution(mCompositeStd) == false) {
+ LOGE("%s::m_setCompositeRsolution() fail \n", __func__);
+ return false;
+ }
+ } else if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
+ mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
+ if (m_setHdmiResolution(mHdmiResolutionValue) == false) {
+ LOGE("%s::m_setHdmiResolution() fail \n", __func__);
+ return false;
+ }
+
+ if (m_setHdcpMode(mHdcpMode) == false) {
+ LOGE("%s::m_setHdcpMode() fail \n", __func__);
+ return false;
+ }
+#if !defined(BOARD_USE_V4L2)
+ std_id = mHdmiStdId;
+#endif
+ }
+
+#if !defined(BOARD_USE_V4L2)
+ fp_tvout = tvout_init(std_id);
+
+ for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
+ if (hdmi_deinit_layer(layer) < 0)
+ LOGE("%s::hdmi_init_layer(%d) fail \n", __func__, layer);
+ }
+
+ for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
+ if (hdmi_init_layer(layer) < 0)
+ LOGE("%s::hdmi_init_layer(%d) fail \n", __func__, layer);
+ }
+#endif
+
+ if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
+ mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
+#if defined(BOARD_USES_CEC)
+ if (!(mCECThread->mFlagRunning))
+ mCECThread->start();
+#endif
+
+ if (m_setAudioMode(mAudioMode) == false)
+ LOGE("%s::m_setAudioMode() fail \n", __func__);
+ }
+
+ mHdmiInfoChange = false;
+#ifdef BOARD_USE_V4L2
+ for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
+ mFimcReservedMem[i] = *(mSecFimc.getMemAddr(i));
+#endif
+ }
+
+ return true;
+}
+
+#if defined(BOARD_USE_V4L2)
+bool SecHdmi::m_startHdmi(int hdmiLayer, unsigned int num_of_plane)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ bool ret = true;
+ int buf_index = 0;
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s: hdmiLayer(%d) called\n", __func__, hdmiLayer);
+#endif
+
+ if (mFlagLayerEnable[hdmiLayer]) {
+ static unsigned int index = 0;
+
+ if (mFlagHdmiStart[hdmiLayer] == false) {
+ index = 0;
+ if (tvout_std_v4l2_qbuf(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR,
+ index, num_of_plane, &mMixerBuffer[hdmiLayer][0]) < 0) {
+ LOGE("%s::tvout_std_v4l2_qbuf(index : %d) (mSrcBufNum : %d) failed", __func__, index, HDMI_NUM_MIXER_BUF);
+ return false;
+ }
+ index++;
+
+ if (tvout_std_v4l2_streamon(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
+ LOGE("%s::tvout_std_v4l2_streamon() failed", __func__);
+ return false;
+ }
+
+ mFlagHdmiStart[hdmiLayer] = true;
+ } else {
+ if (tvout_std_v4l2_qbuf(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR,
+ index, num_of_plane, &mMixerBuffer[hdmiLayer][0]) < 0) {
+ LOGE("%s::tvout_std_v4l2_qbuf() failed", __func__);
+ return false;
+ }
+
+ if (tvout_std_v4l2_dqbuf(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, &buf_index, num_of_plane) < 0) {
+ LOGE("%s::tvout_std_v4l2_dqbuf() failed", __func__);
+ return false;
+ }
+ index = buf_index;
+ }
+ }
+
+ return true;
+}
+#else
+bool SecHdmi::m_startHdmi(int hdmiLayer)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ bool ret = true;
+ int buf_index = 0;
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s: hdmiLayer(%d) called\n", __func__, hdmiLayer);
+#endif
+
+ switch (hdmiLayer) {
+ case HDMI_LAYER_VIDEO:
+ tvout_v4l2_start_overlay(fp_tvout_v);
+ mFlagHdmiStart[hdmiLayer] = true;
+ break;
+ case HDMI_LAYER_GRAPHIC_0 :
+ if (mFlagLayerEnable[hdmiLayer]) {
+ if (ioctl(fp_tvout_g0, FBIOBLANK, (void *)FB_BLANK_UNBLANK) != -1)
+ mFlagHdmiStart[hdmiLayer] = true;
+ }
+ break;
+ case HDMI_LAYER_GRAPHIC_1 :
+ if (mFlagLayerEnable[hdmiLayer]) {
+ if (ioctl(fp_tvout_g1, FBIOBLANK, (void *)FB_BLANK_UNBLANK) != -1)
+ mFlagHdmiStart[hdmiLayer] = true;
+ }
+ break;
+ default :
+ LOGE("%s::unmathced layer(%d) fail", __func__, hdmiLayer);
+ ret = false;
+ break;
+ }
+
+ return true;
+}
+#endif
+
+bool SecHdmi::m_stopHdmi(int hdmiLayer)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ bool ret = true;
+ if (mFlagHdmiStart[hdmiLayer] == false) {
+ LOGD("%s::already HDMI(%d layer) stopped.. \n", __func__, hdmiLayer);
+ return true;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s : layer[%d] called\n", __func__, hdmiLayer);
+#endif
+
+#if defined(BOARD_USE_V4L2)
+ int fd;
+
+ switch (hdmiLayer) {
+ case HDMI_LAYER_VIDEO:
+ break;
+ case HDMI_LAYER_GRAPHIC_0 :
+ break;
+ case HDMI_LAYER_GRAPHIC_1 :
+#if defined(BOARD_USES_FIMGAPI)
+ cur_g2d_address = 0;
+ g2d_buf_index = 0;
+#endif
+ break;
+ default :
+ LOGE("%s::unmathced layer(%d) fail", __func__, hdmiLayer);
+ ret = false;
+ break;
+ }
+
+ if (mFlagLayerEnable[hdmiLayer]) {
+ if (tvout_std_v4l2_streamoff(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
+ LOGE("%s::tvout_std_v4l2_streamon layer(%d) failed", __func__, hdmiLayer);
+ return false;
+ }
+
+ /* clear buffer */
+ if (tvout_std_v4l2_reqbuf(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, 0) < 0) {
+ LOGE("%s::tvout_std_v4l2_reqbuf(buf_num=%d)[graphic layer] failed", __func__, 0);
+ return -1;
+ }
+
+ mFlagHdmiStart[hdmiLayer] = false;
+ }
+#else
+ switch (hdmiLayer) {
+ case HDMI_LAYER_VIDEO:
+ tvout_v4l2_stop_overlay(fp_tvout_v);
+ mFlagHdmiStart[hdmiLayer] = false;
+ break;
+ case HDMI_LAYER_GRAPHIC_0 :
+ if (mFlagLayerEnable[hdmiLayer]) {
+ if (ioctl(fp_tvout_g0, FBIOBLANK, (void *)FB_BLANK_POWERDOWN) != -1)
+ mFlagHdmiStart[hdmiLayer] = false;
+ }
+ break;
+ case HDMI_LAYER_GRAPHIC_1 :
+#if defined(BOARD_USES_FIMGAPI)
+ cur_g2d_address = 0;
+ g2d_buf_index = 0;
+#endif
+ if (mFlagLayerEnable[hdmiLayer]) {
+ if (ioctl(fp_tvout_g1, FBIOBLANK, (void *)FB_BLANK_POWERDOWN) != -1)
+ mFlagHdmiStart[hdmiLayer] = false;
+ }
+ break;
+ default :
+ LOGE("%s::unmathced layer(%d) fail", __func__, hdmiLayer);
+ ret = false;
+ break;
+ }
+#endif
+
+ return true;
+}
+
+bool SecHdmi::m_setHdmiOutputMode(int hdmiOutputMode)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ if (hdmiOutputMode == mCurrentHdmiOutputMode) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::same hdmiOutputMode(%d) \n", __func__, hdmiOutputMode);
+#endif
+ return true;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s called\n", __func__);
+#endif
+
+ int v4l2OutputType = hdmi_outputmode_2_v4l2_output_type(hdmiOutputMode);
+ if (v4l2OutputType < 0) {
+ LOGE("%s::hdmi_outputmode_2_v4l2_output_type(%d) fail\n", __func__, hdmiOutputMode);
+ return false;
+ }
+
+ output_type = v4l2OutputType;
+
+ mCurrentHdmiOutputMode = hdmiOutputMode;
+
+ return true;
+}
+
+bool SecHdmi::m_setCompositeResolution(unsigned int compositeStdId)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s called\n", __func__);
+#endif
+
+ int w = 0;
+ int h = 0;
+
+ if (mHdmiOutputMode != COMPOSITE_OUTPUT_MODE) {
+ LOGE("%s:: not supported output type \n", __func__);
+ return false;
+ }
+
+ switch (compositeStdId) {
+ case COMPOSITE_STD_NTSC_M:
+ case COMPOSITE_STD_NTSC_443:
+ w = 704;
+ h = 480;
+ break;
+ case COMPOSITE_STD_PAL_BDGHI:
+ case COMPOSITE_STD_PAL_M:
+ case COMPOSITE_STD_PAL_N:
+ case COMPOSITE_STD_PAL_Nc:
+ case COMPOSITE_STD_PAL_60:
+ w = 704;
+ h = 576;
+ break;
+ default:
+ LOGE("%s::unmathced composite_std(%d)", __func__, compositeStdId);
+ return false;
+ }
+
+ t_std_id = composite_std_2_v4l2_std_id(mCompositeStd);
+
+ mHdmiDstWidth = w;
+ mHdmiDstHeight = h;
+
+ mCurrentHdmiResolutionValue = -1;
+ return true;
+}
+
+bool SecHdmi::m_setHdmiResolution(unsigned int hdmiResolutionValue)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ if (hdmiResolutionValue == mCurrentHdmiResolutionValue) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
+#endif
+ return true;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s called\n", __func__);
+#endif
+
+ int w = 0;
+ int h = 0;
+
+#if defined(BOARD_USE_V4L2)
+ unsigned int preset_id;
+#else
+ v4l2_std_id std_id;
+#endif
+
+ if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
+ mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
+#if defined(BOARD_USE_V4L2)
+ if (hdmi_resolution_2_preset_id(hdmiResolutionValue, &w, &h, &preset_id) < 0) {
+ LOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, hdmiResolutionValue);
+ return false;
+ }
+ mHdmiPresetId = preset_id;
+#else
+ if (hdmi_resolution_2_std_id(hdmiResolutionValue, &w, &h, &std_id) < 0) {
+ LOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, hdmiResolutionValue);
+ return false;
+ }
+ mHdmiStdId = std_id;
+#endif
+ } else {
+ LOGE("%s:: not supported output type \n", __func__);
+ return false;
+ }
+
+#if defined(BOARD_USE_V4L2)
+ g_preset_id = preset_id;
+#else
+ t_std_id = std_id;
+#endif
+
+ mHdmiDstWidth = w;
+ mHdmiDstHeight = h;
+
+ mCurrentHdmiResolutionValue = hdmiResolutionValue;
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+#if defined(BOARD_USE_V4L2)
+ LOGD("%s:: mHdmiDstWidth = %d, mHdmiDstHeight = %d, mHdmiPresetId = 0x%x, hdmiResolutionValue = 0x%x\n",
+ __func__,
+ mHdmiDstWidth,
+ mHdmiDstHeight,
+ mHdmiPresetId,
+ hdmiResolutionValue);
+#else
+ LOGD("%s:: mHdmiDstWidth = %d, mHdmiDstHeight = %d, mHdmiStdId = 0x%x, hdmiResolutionValue = 0x%x\n",
+ __func__,
+ mHdmiDstWidth,
+ mHdmiDstHeight,
+ mHdmiStdId,
+ hdmiResolutionValue);
+#endif
+#endif
+
+ return true;
+}
+
+bool SecHdmi::m_setHdcpMode(bool hdcpMode)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ if (hdcpMode == mCurrentHdcpMode) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::same hdcpMode(%d) \n", __func__, hdcpMode);
+#endif
+
+ return true;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s called\n", __func__);
+#endif
+
+ if (hdcpMode == true)
+ g_hdcp_en = 1;
+ else
+ g_hdcp_en = 0;
+
+ mCurrentHdcpMode = hdcpMode;
+
+ return true;
+}
+
+bool SecHdmi::m_setAudioMode(int audioMode)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ if (audioMode == mCurrentAudioMode) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::same audioMode(%d) \n", __func__, audioMode);
+#endif
+ return true;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s called\n", __func__);
+#endif
+
+ if (hdmi_check_audio() < 0) {
+ LOGE("%s::hdmi_check_audio() fail \n", __func__);
+ return false;
+ }
+
+ mCurrentAudioMode = audioMode;
+
+ return true;
+}
+
+int SecHdmi::m_resolutionValueIndex(unsigned int ResolutionValue)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+ int index = -1;
+
+ for (int i = 0; i < mHdmiSizeOfResolutionValueList; i++) {
+ if (mHdmiResolutionValueList[i] == ResolutionValue) {
+ index = i;
+ break;
+ }
+ }
+ return index;
+}
+
+bool SecHdmi::m_flagHWConnected(void)
+{
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s", __func__);
+#endif
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s called\n", __func__);
+#endif
+
+ bool ret = true;
+ int hdmiStatus = hdmi_cable_status();
+
+ if (hdmiStatus <= 0) {
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::hdmi_cable_status() fail \n", __func__);
+#endif
+ ret = false;
+ } else {
+ ret = true;
+ }
+
+ return ret;
+}
+
+}; // namespace android
diff --git a/exynos4/hal/libhdmi/SecHdmi/SecHdmiCommon.h b/exynos4/hal/libhdmi/SecHdmi/SecHdmiCommon.h
new file mode 100644
index 0000000..203dfe4
--- /dev/null
+++ b/exynos4/hal/libhdmi/SecHdmi/SecHdmiCommon.h
@@ -0,0 +1,138 @@
+/*
+ * 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.
+**
+** @author Sangwoo, Park(sw5771.park@samsung.com)
+** @date 2010-09-10
+**
+*/
+
+//#define LOG_NDEBUG 0
+//#define LOG_TAG "libhdmi"
+#include <cutils/log.h>
+
+#include "videodev2.h"
+#if defined(BOARD_USE_V4L2)
+#include "s5p_tvout_v4l2.h"
+#else
+#include "s5p_tvout.h"
+#endif
+
+//#define DEBUG_MSG_ENABLE
+//#define DEBUG_HDMI_HW_LEVEL
+#define BOARD_USES_EDID
+//#define BOARD_USES_CEC
+#if defined(SAMSUNG_EXYNOS4x12)
+//#define SUPPORT_G2D_UI_MODE
+#endif
+
+#define DEFAULT_FB (0)
+#define TVOUT_FB_G0 (10)
+#define TVOUT_FB_G1 (11)
+
+#define MAX_BUFFERS_MIXER (1)
+#define MAX_PLANES_MIXER (3)
+
+#define HDMI_NUM_MIXER_BUF (2)
+#define GRALLOC_BUF_SIZE (32768)
+#define SIZE_1K (1024)
+
+#define HDMI_FIMC_OUTPUT_BUF_NUM (4)
+#define HDMI_G2D_OUTPUT_BUF_NUM (2)
+#define HDMI_FIMC_BUFFER_BPP_SIZE (1.5) //NV12 Tiled is 1.5 bytes, RGB565 is 2, RGB888 is 4, Default is NV12 Tiled
+#define HDMI_G2D_BUFFER_BPP_SIZE (4) //NV12 Tiled is 1.5 bytes, RGB565 is 2, RGB888 is 4
+#define HDMI_FB_BPP_SIZE (4) //ARGB888 is 4
+#define SUPPORT_1080P_FIMC_OUT
+#define HDMI_MAX_WIDTH (1920)
+#define HDMI_MAX_HEIGHT (1080)
+
+#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
+
+#if defined(STD_NTSC_M)
+ #define DEFAULT_OUPUT_MODE (COMPOSITE_OUTPUT_MODE)
+ #define DEFAULT_HDMI_RESOLUTION_VALUE (1080960) // 1080P_60
+ #define DEFAULT_HDMI_PRESET_ID (V4L2_DV_1080P60)
+ #define DEFAULT_HDMI_STD_ID (V4L2_STD_1080P_60)
+ #define DEFALULT_DISPLAY_WIDTH (720)
+ #define DEFALULT_DISPLAY_HEIGHT (480)
+ #define DEFAULT_COMPOSITE_STD (COMPOSITE_STD_NTSC_M)
+#elif (STD_1080P)
+ #define DEFAULT_OUPUT_MODE (HDMI_OUTPUT_MODE_RGB)
+ #define DEFAULT_HDMI_RESOLUTION_VALUE (1080960) // 1080P_60
+ #define DEFAULT_HDMI_PRESET_ID (V4L2_DV_1080P60)
+ #define DEFAULT_HDMI_STD_ID (V4L2_STD_1080P_60)
+ #define DEFALULT_DISPLAY_WIDTH (1920)
+ #define DEFALULT_DISPLAY_HEIGHT (1080)
+ #define DEFAULT_COMPOSITE_STD (COMPOSITE_STD_NTSC_M)
+#elif defined(STD_720P)
+ #define DEFAULT_OUPUT_MODE (HDMI_OUTPUT_MODE_YCBCR)
+ #define DEFAULT_HDMI_RESOLUTION_VALUE (720960) // 720P_60
+ #define DEFAULT_HDMI_PRESET_ID (V4L2_DV_720P60)
+ #define DEFAULT_HDMI_STD_ID (V4L2_STD_720P_60)
+ #define DEFALULT_DISPLAY_WIDTH (1280)
+ #define DEFALULT_DISPLAY_HEIGHT (720)
+ #define DEFAULT_COMPOSITE_STD (COMPOSITE_STD_NTSC_M)
+#elif defined(STD_480P)
+ #define DEFAULT_OUPUT_MODE (HDMI_OUTPUT_MODE_YCBCR)
+ #define DEFAULT_HDMI_RESOLUTION_VALUE (4809601) // 480P_60_4_3
+ #define DEFAULT_HDMI_PRESET_ID (V4L2_DV_480P60)
+ #define DEFAULT_HDMI_STD_ID (V4L2_STD_480P_60_16_9)
+ #define DEFALULT_DISPLAY_WIDTH (720)
+ #define DEFALULT_DISPLAY_HEIGHT (480)
+ #define DEFAULT_COMPOSITE_STD (COMPOSITE_STD_NTSC_M)
+#else
+ #define DEFAULT_OUPUT_MODE (HDMI_OUTPUT_MODE_YCBCR)
+ #define DEFAULT_HDMI_RESOLUTION_VALUE (4809602) // 480P_60_4_3
+ #define DEFAULT_HDMI_PRESET_ID (V4L2_DV_480P60)
+ #define DEFAULT_HDMI_STD_ID (V4L2_STD_480P_60_4_3)
+ #define DEFALULT_DISPLAY_WIDTH (720)
+ #define DEFALULT_DISPLAY_HEIGHT (480)
+ #define DEFAULT_COMPOSITE_STD (COMPOSITE_STD_NTSC_M)
+#endif
+
+enum hdp_cable_status {
+ HPD_CABLE_OUT = 0, // HPD_CABLE_OUT indicates HDMI cable out.
+ HPD_CABLE_IN // HPD_CABLE_IN indicates HDMI cable in.
+};
+
+enum state {
+ OFF = 0,
+ ON = 1,
+ NOT_SUPPORT = 2,
+};
+
+enum tv_mode {
+ HDMI_OUTPUT_MODE_YCBCR = 0,
+ HDMI_OUTPUT_MODE_RGB = 1,
+ HDMI_OUTPUT_MODE_DVI = 2,
+ COMPOSITE_OUTPUT_MODE = 3
+};
+
+enum composite_std {
+ COMPOSITE_STD_NTSC_M = 0,
+ COMPOSITE_STD_PAL_BDGHI = 1,
+ COMPOSITE_STD_PAL_M = 2,
+ COMPOSITE_STD_PAL_N = 3,
+ COMPOSITE_STD_PAL_Nc = 4,
+ COMPOSITE_STD_PAL_60 = 5,
+ COMPOSITE_STD_NTSC_443 = 6
+};
+
+enum hdmi_layer {
+ HDMI_LAYER_BASE = 0,
+ HDMI_LAYER_VIDEO,
+ HDMI_LAYER_GRAPHIC_0,
+ HDMI_LAYER_GRAPHIC_1,
+ HDMI_LAYER_MAX,
+};
diff --git a/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp b/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp
new file mode 100644
index 0000000..217ce51
--- /dev/null
+++ b/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp
@@ -0,0 +1,2434 @@
+/*
+ * 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.
+ */
+
+//#define LOG_NDEBUG 0
+//#define LOG_TAG "libhdmi"
+#include <cutils/log.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+
+#if defined(BOARD_USE_V4L2)
+#include "sec_utils_v4l2.h"
+#include "s5p_tvout_v4l2.h"
+#include "videodev2.h"
+#else
+#include "sec_utils.h"
+#include "s5p_tvout.h"
+#endif
+#include "SecFimc.h"
+#if defined(BOARD_USES_FIMGAPI)
+#include "sec_g2d_4x.h"
+#include "FimgApi.h"
+#endif
+
+#include "audio.h"
+#include "video.h"
+#include "../libhdmi/libsForhdmi/libedid/libedid.h"
+#include "../libhdmi/libsForhdmi/libcec/libcec.h"
+
+#include "SecHdmiCommon.h"
+#include "SecHdmiV4L2Utils.h"
+
+namespace android {
+
+unsigned int output_type = V4L2_OUTPUT_TYPE_DIGITAL;
+#if defined(BOARD_USE_V4L2)
+unsigned int g_preset_id = V4L2_DV_1080P30;
+#endif
+v4l2_std_id t_std_id = V4L2_STD_1080P_30;
+int g_hpd_state = HPD_CABLE_OUT;
+unsigned int g_hdcp_en = 0;
+
+int fp_tvout = -1;
+int fp_tvout_v = -1;
+int fp_tvout_g0 = -1;
+int fp_tvout_g1 = -1;
+
+struct vid_overlay_param vo_param;
+
+#if defined(BOARD_USES_FIMGAPI)
+unsigned int g2d_reserved_memory[HDMI_G2D_OUTPUT_BUF_NUM];
+unsigned int g2d_reserved_memory_size = 0;
+unsigned int cur_g2d_address = 0;
+unsigned int g2d_buf_index = 0;
+#endif
+
+void display_menu(void)
+{
+ struct HDMIVideoParameter video;
+ struct HDMIAudioParameter audio;
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ audio.formatCode = LPCM_FORMAT;
+ audio.outPacket = HDMI_ASP;
+ audio.channelNum = CH_2;
+ audio.sampleFreq = SF_44KHZ;
+
+ LOGI("=============== HDMI Audio =============\n");
+
+ if (EDIDAudioModeSupport(&audio))
+ LOGI("= 2CH_PCM 44100Hz audio supported =\n");
+
+ LOGI("========= HDMI Mode & Color Space =======\n");
+
+ video.mode = HDMI;
+ if (EDIDHDMIModeSupport(&video)) {
+ video.colorSpace = HDMI_CS_YCBCR444;
+ if (EDIDColorSpaceSupport(&video))
+ LOGI("= 1. HDMI(YCbCr) =\n");
+
+ video.colorSpace = HDMI_CS_RGB;
+ if (EDIDColorSpaceSupport(&video))
+ LOGI("= 2. HDMI(RGB) =\n");
+ } else {
+ video.mode = DVI;
+ if (EDIDHDMIModeSupport(&video))
+ LOGI("= 3. DVI =\n");
+ }
+
+ LOGI("=========== HDMI Rseolution ========\n");
+
+ /* 480P */
+ video.resolution = v720x480p_60Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_16_9;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 4. 480P_60_16_9 (0x04000000) =\n");
+
+ video.resolution = v640x480p_60Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_4_3;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 5. 480P_60_4_3 (0x05000000) =\n");
+
+ /* 576P */
+ video.resolution = v720x576p_50Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_16_9;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 6. 576P_50_16_9 (0x06000000) =\n");
+
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_4_3;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 7. 576P_50_4_3 (0x07000000) =\n");
+
+ /* 720P 60 */
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 8. 720P_60 (0x08000000) =\n");
+
+ /* 720P_50 */
+ video.resolution = v1280x720p_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 9. 720P_50 (0x09000000) =\n");
+
+ /* 1080P_60 */
+ video.resolution = v1920x1080p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= a. 1080P_60 (0x0a000000) =\n");
+
+ /* 1080P_50 */
+ video.resolution = v1920x1080p_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= b. 1080P_50 (0x0b000000) =\n");
+
+ /* 1080I_60 */
+ video.resolution = v1920x1080i_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= c. 1080I_60 (0x0c000000) =\n");
+
+ /* 1080I_50 */
+ video.resolution = v1920x1080i_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= d. 1080I_50 (0x0d000000) =\n");
+
+ /* 1080P_30 */
+ video.resolution = v1920x1080p_30Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= e. 1080P_30 (0x12000000) =\n");
+
+ LOGI("=========== HDMI 3D Format ========\n");
+
+ /* 720P_60_SBS_HALF */
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_3D_SSH_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= f. 720P_60_SBS_HALF (0x13000000) =\n");
+
+ /* 720P_59_SBS_HALF */
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_3D_SSH_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 10. 720P_59_SBS_HALF (0x14000000) =\n");
+
+ /* 720P_50_TB */
+ video.resolution = v1280x720p_50Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 11. 720P_50_TB (0x15000000) =\n");
+
+ /* 1080P_24_TB */
+ video.resolution = v1920x1080p_24Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 12. 1080P_24_TB (0x16000000) =\n");
+
+ /* 1080P_23_TB */
+ video.resolution = v1920x1080p_24Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ if (EDIDVideoResolutionSupport(&video))
+ LOGI("= 13. 1080P_24_TB (0x17000000) =\n");
+ LOGI("=========================================\n");
+}
+
+int tvout_open(const char *fp_name)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int fp;
+
+ fp = open(fp_name, O_RDWR);
+ if (fp < 0)
+ LOGE("drv (%s) open failed!!\n", fp_name);
+
+ return fp;
+}
+#if defined(BOARD_USE_V4L2)
+int tvout_std_v4l2_init(int fd, unsigned int preset_id)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s:: preset_id = 0x%x", __func__, preset_id);
+#endif
+
+ int ret;
+ struct v4l2_output output;
+ struct v4l2_dv_preset preset;
+
+ unsigned int matched = 0, i = 0;
+ int output_index;
+
+/*
+ if (output_type >= V4L2_OUTPUT_TYPE_DIGITAL &&
+ output_type <= V4L2_OUTPUT_TYPE_DVI)
+ if (ioctl(fd_tvout, VIDIOC_HDCP_ENABLE, g_hdcp_en) < 0)
+ LOGE("%s::VIDIOC_HDCP_ENABLE failed %d", __func__, errno);
+*/
+
+ i = 0;
+
+ do {
+ output.index = i;
+ ret = tvout_std_v4l2_enum_output(fd, &output);
+ LOGD("tvout_v4l2_enum_output():: output_type=%d output.index=%d output.name=%s", output.type, output.index, output.name);
+ if (output.type == output_type) {
+ matched = 1;
+ break;
+ }
+ i++;
+ } while (ret >=0);
+
+ if (!matched) {
+ LOGE("%s::no matched output type [type=%d]", __func__, output_type);
+// return -1;
+ }
+
+ // set output
+// tvout_std_v4l2_s_output(fp_tvout, output.index);
+// output_index = 0;
+// tvout_std_v4l2_g_output(fp_tvout, &output_index);
+
+// if (output.capabilities & V4L2_OUT_CAP_PRESETS) {
+ tvout_std_v4l2_enum_dv_presets(fd);
+ preset.preset = preset_id;
+ if (tvout_std_v4l2_s_dv_preset(fd, &preset) < 0 ) {
+ LOGE("%s::tvout_std_v4l2_s_dv_preset failed", __func__);
+ return -1;
+ }
+// }
+
+ return 0;
+}
+
+int tvout_std_v4l2_querycap(int fd, char *node)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_capability v4l2cap;
+
+ if (ioctl(fd, VIDIOC_QUERYCAP, &v4l2cap) < 0) {
+ LOGE("%s::VIDIOC_QUERYCAP failed", __func__);
+ return -1;
+ }
+
+ if (!(v4l2cap.capabilities & V4L2_CAP_STREAMING)) {
+ LOGE("%s::%s is not support streaming", __func__, node);
+ return -1;
+ }
+
+ if (!(v4l2cap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)) {
+ LOGE("%s::%s is not support video output mplane", __func__, node);
+ return -1;
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_enum_dv_presets(int fd)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_dv_enum_preset enum_preset;
+ int ret = -1;
+
+ for (int index = 0; ; index++) {
+ enum_preset.index = index;
+ ret = ioctl(fd, VIDIOC_ENUM_DV_PRESETS, &enum_preset);
+
+ if (ret < 0) {
+ if (errno == EINVAL)
+ break;
+ LOGE("%s::VIDIOC_ENUM_DV_PRESETS", __func__);
+ return -1;
+ }
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s::index=%d, preset=0x%08x, name=%s, w=%d, h=%d",
+ __func__, enum_preset.index, enum_preset.preset, enum_preset.name, enum_preset.width, enum_preset.height);
+#endif
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_s_dv_preset(int fd, struct v4l2_dv_preset *preset)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ if (ioctl(fd, VIDIOC_S_DV_PRESET, preset) < 0) {
+ LOGE("%s::VIDIOC_S_DV_PRESET failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+/*
+ ioctl VIDIOC_ENUMOUTPUT
+ To query the attributes of a video outputs applications initialize the index field of struct v4l2_output
+ and call the VIDIOC_ENUMOUTPUT ioctl with a pointer to this structure. Drivers fill the rest of the
+ structure or return an EINVAL error code when the index is out of bounds
+ */
+int tvout_std_v4l2_enum_output(int fd, struct v4l2_output *output)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+
+ ret = ioctl(fd, VIDIOC_ENUMOUTPUT, output);
+
+ if (ret >=0)
+ LOGV("tvout_v4l2_enum_output" "enum. output [index = %d] :: type : 0x%08x , name = %s\n",
+ output->index,output->type,output->name);
+
+ return ret;
+}
+
+/*
+ ioctl VIDIOC_G_OUTPUT, VIDIOC_S_OUTPUT
+ To query the current video output applications call the VIDIOC_G_OUTPUT ioctl with a pointer to an
+ integer where the driver stores the number of the output, as in the struct v4l2_output index field.
+ This ioctl will fail only when there are no video outputs, returning the EINVAL error code
+ */
+int tvout_std_v4l2_s_output(int fd, int index)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s:: index = 0x%x", __func__, index);
+#endif
+
+ int ret;
+
+ ret = ioctl(fd, VIDIOC_S_OUTPUT, &index);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_s_output" "VIDIOC_S_OUTPUT failed %d\n", errno);
+ return ret;
+ }
+
+ return ret;
+}
+
+int tvout_std_v4l2_g_output(int fd, int *index)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+
+ ret = ioctl(fd, VIDIOC_G_OUTPUT, index);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_g_output" "VIDIOC_G_OUTPUT failed %d\n", errno);
+ return ret;
+ } else {
+ LOGV("tvout_v4l2_g_output" "Current output index %d\n", *index);
+ }
+
+ return ret;
+}
+
+int tvout_std_v4l2_s_fmt(int fd, enum v4l2_buf_type type, enum v4l2_field field, int w, int h, int colorformat, int num_planes)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_format fmt;
+
+ fmt.type = type;
+// if (ioctl(fd, VIDIOC_G_FMT, &fmt) < 0) {
+// LOGE("%s::VIDIOC_G_FMT failed", __func__);
+// return -1;
+// }
+
+ switch (fmt.type) {
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+ fmt.fmt.pix.width = w;
+ fmt.fmt.pix.height = h;
+ fmt.fmt.pix.pixelformat = colorformat;
+ fmt.fmt.pix.field = field;
+ break;
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
+ fmt.fmt.pix_mp.width = w;
+ fmt.fmt.pix_mp.height = h;
+ fmt.fmt.pix_mp.pixelformat = colorformat;
+ fmt.fmt.pix_mp.field = field;
+ fmt.fmt.pix_mp.num_planes = num_planes;
+ break;
+ default:
+ LOGE("%s::invalid buffer type", __func__);
+ return -1;
+ break;
+ }
+
+ if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
+ LOGE("%s::VIDIOC_S_FMT failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_s_crop(int fd, enum v4l2_buf_type type, enum v4l2_field, int x, int y, int w, int h)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_crop crop;
+
+ crop.type = type;
+ crop.c.left = x;
+ crop.c.top = y;
+ crop.c.width = w;
+ crop.c.height = h;
+
+ if (ioctl(fd, VIDIOC_S_CROP, &crop) < 0) {
+ LOGE("%s::VIDIOC_S_CROP (x=%d, y=%d, w=%d, h=%d) failed",
+ __func__, x, y, w, h);
+ return -1;
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_s_ctrl(int fd, int id, int value)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_control vc;
+
+ vc.id = id;
+ vc.value = value;
+
+ if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
+ LOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, id, value);
+ return -1;
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_reqbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int num_bufs)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_requestbuffers reqbuf;
+
+ reqbuf.type = type;
+ reqbuf.memory = memory;
+ reqbuf.count = num_bufs;
+
+ if (ioctl(fd, VIDIOC_REQBUFS, &reqbuf) < 0) {
+ LOGE("%s::VIDIOC_REQBUFS failed", __func__);
+ return -1;
+ }
+
+ if (reqbuf.count < num_bufs) {
+ LOGE("%s::VIDIOC_REQBUFS failed ((reqbuf.count(%d) < num_bufs(%d))",
+ __func__, reqbuf.count, num_bufs);
+ return -1;
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_querybuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int buf_index, unsigned int num_planes, SecBuffer *secBuf)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_buffer buf;
+ struct v4l2_plane planes[MAX_PLANES_MIXER];
+
+ memset(&buf, 0, sizeof(struct v4l2_buffer));
+
+ for (int i = 0; i < MAX_PLANES_MIXER; i++)
+ memset(&planes[i], 0, sizeof(struct v4l2_plane));
+
+ if (MAX_BUFFERS_MIXER <= buf_index || MAX_PLANES_MIXER <= num_planes) {
+ LOGE("%s::exceed MAX! : buf_index=%d, num_plane=%d", __func__, buf_index, num_planes);
+ return -1;
+ }
+
+ buf.type = type;
+ buf.memory = V4L2_MEMORY_MMAP;
+ buf.index = buf_index;
+ buf.length = num_planes;
+ buf.m.planes = planes;
+
+ if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) {
+ LOGE("%s::VIDIOC_QUERYBUF failed, plane_cnt=%d", __func__, buf.length);
+ return -1;
+ }
+
+ for (unsigned int i = 0; i < num_planes; i++) {
+ if ((secBuf->virt.extP[i] = (char *)mmap(0, buf.m.planes[i].length,
+ PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.planes[i].m.mem_offset)) < 0) {
+ LOGE("%s::mmap failed", __func__);
+ LOGE("%s::Offset = 0x%x", __func__, buf.m.planes[i].m.mem_offset);
+ LOGE("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
+ LOGE("%s::vaddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
+ return -1;
+ }
+ secBuf->size.extS[i] = buf.m.planes[i].length;
+
+#ifdef DEBUG_LIB_FIMC
+ LOGD("%s::vaddr[bufidx=%d][planeidx=%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
+ LOGD("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
+#endif
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_qbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int buf_index, int num_planes, SecBuffer *secBuf)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_buffer buf;
+ struct v4l2_plane planes[MAX_PLANES_MIXER];
+
+ memset(&buf, 0, sizeof(struct v4l2_buffer));
+
+ for (int i = 0; i < MAX_PLANES_MIXER; i++)
+ memset(&planes[i], 0, sizeof(struct v4l2_plane));
+
+ buf.type = type;
+ buf.memory = memory;
+ buf.length = num_planes;
+ buf.index = buf_index;
+ buf.m.planes = planes;
+
+ for (unsigned int i = 0; i < buf.length; i++) {
+ buf.m.planes[i].m.userptr = (unsigned long)secBuf->virt.extP[i];
+ buf.m.planes[i].length = secBuf->size.extS[i];
+ }
+
+ if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
+ LOGE("%s::VIDIOC_QBUF failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_dqbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int *buf_index, int num_planes)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_buffer buf;
+ struct v4l2_plane planes[MAX_PLANES_MIXER];
+
+ memset(&buf, 0, sizeof(struct v4l2_buffer));
+
+ for (int i = 0; i < MAX_PLANES_MIXER; i++)
+ memset(&planes[i], 0, sizeof(struct v4l2_plane));
+
+ buf.type = type;
+ buf.memory = memory;
+ buf.length = num_planes;
+ buf.m.planes = planes;
+
+ if (ioctl(fd, VIDIOC_DQBUF, &buf) < 0) {
+ LOGE("%s::VIDIOC_DQBUF failed", __func__);
+ return -1;
+ }
+ *buf_index = buf.index;
+
+ return 0;
+}
+
+int tvout_std_v4l2_streamon(int fd, enum v4l2_buf_type type)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) {
+ LOGE("%s::VIDIOC_STREAMON failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int tvout_std_v4l2_streamoff(int fd, enum v4l2_buf_type type)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) {
+ LOGE("%s::VIDIOC_STREAMOFF failed", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+#else
+int tvout_init(v4l2_std_id std_id)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s:: std_id = 0x%x", __func__, std_id);
+#endif
+
+ int ret;
+ struct v4l2_output output;
+ struct v4l2_standard std;
+ v4l2_std_id std_g_id;
+ struct tvout_param tv_g_param;
+
+ unsigned int matched = 0, i = 0;
+ int output_index;
+
+ // It was initialized already
+ if (fp_tvout <= 0) {
+ fp_tvout = tvout_open(TVOUT_DEV);
+ if (fp_tvout < 0) {
+ LOGE("tvout video drv open failed\n");
+ return -1;
+ }
+ }
+
+ if (output_type >= V4L2_OUTPUT_TYPE_DIGITAL &&
+ output_type <= V4L2_OUTPUT_TYPE_DVI)
+ if (ioctl(fp_tvout, VIDIOC_HDCP_ENABLE, g_hdcp_en) < 0)
+ LOGE("tvout_init" "VIDIOC_HDCP_ENABLE failed %d\n", errno);
+
+ /* ============== query capability============== */
+ tvout_v4l2_querycap(fp_tvout);
+
+ tvout_v4l2_enum_std(fp_tvout, &std, std_id);
+
+ // set std
+ tvout_v4l2_s_std(fp_tvout, std_id);
+ tvout_v4l2_g_std(fp_tvout, &std_g_id);
+
+ i = 0;
+
+ do {
+ output.index = i;
+ ret = tvout_v4l2_enum_output(fp_tvout, &output);
+ if (output.type == output_type) {
+ matched = 1;
+ break;
+ }
+ i++;
+ } while (ret >=0);
+
+ if (!matched) {
+ LOGE("no matched output type [type : 0x%08x]\n", output_type);
+ return -1;
+ }
+
+ // set output
+ tvout_v4l2_s_output(fp_tvout, output.index);
+ output_index = 0;
+ tvout_v4l2_g_output(fp_tvout, &output_index);
+
+ //set fmt param
+ vo_param.src.base_y = (void *)0x0;
+ vo_param.src.base_c = (void *)0x0;
+ vo_param.src.pix_fmt.width = 0;
+ vo_param.src.pix_fmt.height = 0;
+ vo_param.src.pix_fmt.field = V4L2_FIELD_NONE;
+ vo_param.src.pix_fmt.pixelformat = V4L2_PIX_FMT_NV12T;
+
+ vo_param.src_crop.left = 0;
+ vo_param.src_crop.top = 0;
+ vo_param.src_crop.width = 0;
+ vo_param.src_crop.height = 0;
+
+ return fp_tvout;
+}
+
+int tvout_deinit()
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ if (0 < fp_tvout) {
+ close(fp_tvout);
+ fp_tvout = -1;
+ }
+ return 0;
+}
+
+int tvout_v4l2_querycap(int fp)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s:: fp = 0x%x", __func__, fp);
+#endif
+
+ struct v4l2_capability cap;
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_QUERYCAP, &cap);
+
+ if (ret < 0) {
+ LOGE("tvout_v4l2_querycap" "VIDIOC_QUERYCAP failed %d\n", errno);
+ return ret;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("tvout_v4l2_querycap" "DRIVER : %s, CARD : %s, CAP.: 0x%08x\n",
+ cap.driver, cap.card, cap.capabilities);
+#endif
+
+ return ret;
+}
+
+/*
+ ioctl VIDIOC_G_STD, VIDIOC_S_STD
+ To query and select the current video standard applications use the VIDIOC_G_STD and
+ VIDIOC_S_STD ioctls which take a pointer to a v4l2_std_id type as argument. VIDIOC_G_STD can
+ return a single flag or a set of flags as in struct v4l2_standard field id
+ */
+
+int tvout_v4l2_g_std(int fp, v4l2_std_id *std_id)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_G_STD, std_id);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_g_std" "VIDIOC_G_STD failed %d\n", errno);
+ return ret;
+ }
+
+ return ret;
+}
+
+int tvout_v4l2_s_std(int fp, v4l2_std_id std_id)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s:: std_id = 0x%x", __func__, std_id);
+#endif
+
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_S_STD, &std_id);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_s_std" "VIDIOC_S_STD failed %d\n", errno);
+ return ret;
+ }
+
+ return ret;
+}
+
+/*
+ ioctl VIDIOC_ENUMSTD
+ To query the attributes of a video standard, especially a custom (driver defined) one, applications
+ initialize the index field of struct v4l2_standard and call the VIDIOC_ENUMSTD ioctl with a pointer
+ to this structure. Drivers fill the rest of the structure or return an EINVAL error code when the index
+ is out of bounds.
+ */
+int tvout_v4l2_enum_std(int fp, struct v4l2_standard *std, v4l2_std_id std_id)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ std->index = 0;
+ while (0 == ioctl (fp, VIDIOC_ENUMSTD, std)) {
+ if (std->id & std_id)
+ LOGV("tvout_v4l2_enum_std" "Current video standard: %s\n", std->name);
+
+ std->index++;
+ }
+
+ return 0;
+}
+
+/*
+ ioctl VIDIOC_ENUMOUTPUT
+ To query the attributes of a video outputs applications initialize the index field of struct v4l2_output
+ and call the VIDIOC_ENUMOUTPUT ioctl with a pointer to this structure. Drivers fill the rest of the
+ structure or return an EINVAL error code when the index is out of bounds
+ */
+int tvout_v4l2_enum_output(int fp, struct v4l2_output *output)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_ENUMOUTPUT, output);
+
+ if (ret >=0)
+ LOGV("tvout_v4l2_enum_output" "enum. output [index = %d] :: type : 0x%08x , name = %s\n",
+ output->index,output->type,output->name);
+
+ return ret;
+}
+
+/*
+ ioctl VIDIOC_G_OUTPUT, VIDIOC_S_OUTPUT
+ To query the current video output applications call the VIDIOC_G_OUTPUT ioctl with a pointer to an
+ integer where the driver stores the number of the output, as in the struct v4l2_output index field.
+ This ioctl will fail only when there are no video outputs, returning the EINVAL error code
+ */
+int tvout_v4l2_s_output(int fp, int index)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s:: index = 0x%x", __func__, index);
+#endif
+
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_S_OUTPUT, &index);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_s_output" "VIDIOC_S_OUTPUT failed %d\n", errno);
+ return ret;
+ }
+
+ return ret;
+}
+
+int tvout_v4l2_g_output(int fp, int *index)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_G_OUTPUT, index);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_g_output" "VIDIOC_G_OUTPUT failed %d\n", errno);
+ return ret;
+ } else {
+ LOGV("tvout_v4l2_g_output" "Current output index %d\n", *index);
+ }
+
+ return ret;
+}
+
+/*
+ ioctl VIDIOC_ENUM_FMT
+ To enumerate image formats applications initialize the type and index field of struct v4l2_fmtdesc
+ and call the VIDIOC_ENUM_FMT ioctl with a pointer to this structure. Drivers fill the rest of the
+ structure or return an EINVAL error code. All formats are enumerable by beginning at index zero
+ and incrementing by one until EINVAL is returned.
+ */
+int tvout_v4l2_enum_fmt(int fp, struct v4l2_fmtdesc *desc)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ desc->index = 0;
+ while (0 == ioctl(fp, VIDIOC_ENUM_FMT, desc)) {
+ LOGV("tvout_v4l2_enum_fmt" "enum. fmt [id : 0x%08x] :: type = 0x%08x, name = %s, pxlfmt = 0x%08x\n",
+ desc->index,
+ desc->type,
+ desc->description,
+ desc->pixelformat);
+ desc->index++;
+ }
+
+ return 0;
+}
+
+int tvout_v4l2_g_fmt(int fp, int buf_type, void* ptr)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+ struct v4l2_format format;
+ struct v4l2_pix_format_s5p_tvout *fmt_param = (struct v4l2_pix_format_s5p_tvout*)ptr;
+
+ format.type = (enum v4l2_buf_type)buf_type;
+
+ ret = ioctl(fp, VIDIOC_G_FMT, &format);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_g_fmt" "type : %d, VIDIOC_G_FMT failed %d\n", buf_type, errno);
+ return ret;
+ } else {
+ memcpy(fmt_param, format.fmt.raw_data, sizeof(struct v4l2_pix_format_s5p_tvout));
+ LOGV("tvout_v4l2_g_fmt" "get. fmt [base_c : 0x%08x], [base_y : 0x%08x] type = 0x%08x, width = %d, height = %d\n",
+ fmt_param->base_c,
+ fmt_param->base_y,
+ fmt_param->pix_fmt.pixelformat,
+ fmt_param->pix_fmt.width,
+ fmt_param->pix_fmt.height);
+ }
+
+ return 0;
+}
+
+int tvout_v4l2_s_fmt(int fp, int buf_type, void *ptr)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_format format;
+ int ret;
+
+ format.type = (enum v4l2_buf_type)buf_type;
+ switch (buf_type) {
+ case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+ format.fmt.win = *((struct v4l2_window *) ptr);
+ break;
+
+ case V4L2_BUF_TYPE_PRIVATE: {
+ struct v4l2_vid_overlay_src *fmt_param =
+ (struct v4l2_vid_overlay_src *) ptr;
+
+ memcpy(format.fmt.raw_data, fmt_param,
+ sizeof(struct v4l2_vid_overlay_src));
+ break;
+ }
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT: {
+ struct v4l2_pix_format_s5p_tvout *fmt_param =
+ (struct v4l2_pix_format_s5p_tvout *)ptr;
+ memcpy(format.fmt.raw_data, fmt_param,
+ sizeof(struct v4l2_pix_format_s5p_tvout));
+ break;
+ }
+ default:
+ break;
+ }
+
+ ret = ioctl(fp, VIDIOC_S_FMT, &format);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_s_fmt [tvout_v4l2_s_fmt] : type : %d, VIDIOC_S_FMT failed %d\n",
+ buf_type, errno);
+ return ret;
+ }
+ return 0;
+
+}
+
+int tvout_v4l2_g_fbuf(int fp, struct v4l2_framebuffer *frame)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_G_FBUF, frame);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_g_fbuf" "VIDIOC_STREAMON failed %d\n", errno);
+ return ret;
+ }
+
+ LOGV("tvout_v4l2_g_fbuf" "get. fbuf: base = 0x%08X, pixel format = %d\n",
+ frame->base,
+ frame->fmt.pixelformat);
+ return 0;
+}
+
+int tvout_v4l2_s_fbuf(int fp, struct v4l2_framebuffer *frame)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+
+ ret = ioctl(fp, VIDIOC_S_FBUF, frame);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_s_fbuf" "VIDIOC_STREAMON failed %d\n", errno);
+ return ret;
+ }
+ return 0;
+}
+
+int tvout_v4l2_s_baseaddr(int fp, void *base_addr)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+
+ ret = ioctl(fp, S5PTVFB_WIN_SET_ADDR, base_addr);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_baseaddr" "VIDIOC_S_BASEADDR failed %d\n", errno);
+ return ret;
+ }
+ return 0;
+}
+
+int tvout_v4l2_g_crop(int fp, unsigned int type, struct v4l2_rect *rect)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret;
+ struct v4l2_crop crop;
+ crop.type = (enum v4l2_buf_type)type;
+ ret = ioctl(fp, VIDIOC_G_CROP, &crop);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_g_crop" "VIDIOC_G_CROP failed %d\n", errno);
+ return ret;
+ }
+
+ rect->left = crop.c.left;
+ rect->top = crop.c.top;
+ rect->width = crop.c.width;
+ rect->height = crop.c.height;
+
+ LOGV("tvout_v4l2_g_crop" "get. crop : left = %d, top = %d, width = %d, height = %d\n",
+ rect->left,
+ rect->top,
+ rect->width,
+ rect->height);
+ return 0;
+}
+
+int tvout_v4l2_s_crop(int fp, unsigned int type, struct v4l2_rect *rect)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_crop crop;
+ int ret;
+
+ crop.type = (enum v4l2_buf_type)type;
+
+ crop.c.left = rect->left;
+ crop.c.top = rect->top;
+ crop.c.width = rect->width;
+ crop.c.height = rect->height;
+
+ ret = ioctl(fp, VIDIOC_S_CROP, &crop);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_s_crop" "VIDIOC_S_CROP failed %d\n", errno);
+ return ret;
+ }
+
+ return 0;
+}
+
+int tvout_v4l2_start_overlay(int fp)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret, start = 1;
+
+ ret = ioctl(fp, VIDIOC_OVERLAY, &start);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_start_overlay" "VIDIOC_OVERLAY failed\n");
+ return ret;
+ }
+
+ return ret;
+}
+
+int tvout_v4l2_stop_overlay(int fp)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int ret, stop =0;
+
+ ret = ioctl(fp, VIDIOC_OVERLAY, &stop);
+ if (ret < 0) {
+ LOGE("tvout_v4l2_stop_overlay" "VIDIOC_OVERLAY failed\n");
+ return ret;
+ }
+
+ return ret;
+}
+#endif
+
+int hdmi_init_layer(int layer)
+{
+ int fd = -1;
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s (layer = %d) called", __func__, layer);
+#endif
+
+ switch (layer) {
+ case HDMI_LAYER_VIDEO :
+ if (fp_tvout_v <= 0) {
+ fp_tvout_v = tvout_open(TVOUT_DEV_V);
+ if (fp_tvout_v < 0) {
+ LOGE("tvout video layer open failed\n");
+ return -1;
+ }
+ fd = fp_tvout_v;
+ }
+ break;
+ case HDMI_LAYER_GRAPHIC_0 :
+ if (fp_tvout_g0 <= 0) {
+#if defined(BOARD_USE_V4L2)
+ fp_tvout_g0 = tvout_open(TVOUT_DEV_G0);
+#else
+ fp_tvout_g0 = fb_open(TVOUT_FB_G0);
+#endif
+ if (fp_tvout_g0 < 0) {
+ LOGE("tvout graphic layer 0 open failed\n");
+ return -1;
+ }
+ fd = fp_tvout_g0;
+ }
+ break;
+ case HDMI_LAYER_GRAPHIC_1 :
+ if (fp_tvout_g1 <= 0) {
+#if defined(BOARD_USE_V4L2)
+ fp_tvout_g1 = tvout_open(TVOUT_DEV_G1);
+#else
+ fp_tvout_g1 = fb_open(TVOUT_FB_G1);
+#endif
+ if (fp_tvout_g1 < 0) {
+ LOGE("tvout graphic layer 1 open failed\n");
+ return -1;
+ }
+ fd = fp_tvout_g1;
+ }
+ break;
+ default :
+ LOGE("%s::unmathced layer(%d) fail", __func__, layer);
+ fd = -1;
+ break;
+ }
+
+ return fd;
+}
+
+int hdmi_deinit_layer(int layer)
+{
+ int ret = 0;
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("### %s(layer = %d) called", __func__, layer);
+#endif
+ switch (layer) {
+ case HDMI_LAYER_VIDEO :
+ if (0 < fp_tvout_v) {
+ close(fp_tvout_v);
+ fp_tvout_v = -1;
+ }
+ break;
+ case HDMI_LAYER_GRAPHIC_0 :
+ if (0 < fp_tvout_g0) {
+ close(fp_tvout_g0);
+ fp_tvout_g0 = -1;
+ }
+ break;
+ case HDMI_LAYER_GRAPHIC_1 :
+ if (0 < fp_tvout_g1) {
+ close(fp_tvout_g1);
+ fp_tvout_g1 = -1;
+ }
+ break;
+ default :
+ LOGE("%s::unmathced layer(%d) fail", __func__, layer);
+ ret = -1;
+ break;
+ }
+
+ return ret;
+}
+
+#define ROUND_UP(value, boundary) ((((uint32_t)(value)) + \
+ (((uint32_t) boundary)-1)) & \
+ (~(((uint32_t) boundary)-1)))
+
+void hdmi_cal_rect(int src_w, int src_h, int dst_w, int dst_h, struct v4l2_rect *dst_rect)
+{
+ if (dst_w * src_h <= dst_h * src_w) {
+ dst_rect->left = 0;
+ dst_rect->top = (dst_h - ((dst_w * src_h) / src_w)) >> 1;
+ dst_rect->width = dst_w;
+ dst_rect->height = ((dst_w * src_h) / src_w);
+ } else {
+ dst_rect->left = (dst_w - ((dst_h * src_w) / src_h)) >> 1;
+ dst_rect->top = 0;
+ dst_rect->width = ((dst_h * src_w) / src_h);
+ dst_rect->height = dst_h;
+ }
+}
+
+#if defined(BOARD_USE_V4L2)
+int hdmi_get_src_plane(int srcColorFormat, unsigned int *num_of_plane)
+{
+ int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(srcColorFormat);
+
+ switch (v4l2ColorFormat) {
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_BGR32:
+ case V4L2_PIX_FMT_RGB32:
+ case V4L2_PIX_FMT_RGB565X:
+ *num_of_plane = 1;
+ break;
+ case V4L2_PIX_FMT_NV12M:
+ case V4L2_PIX_FMT_NV12MT:
+ case V4L2_PIX_FMT_NV21M:
+ *num_of_plane = 2;
+ break;
+ default:
+ LOGE("%s::invalid color type", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+#endif
+
+#if defined(BOARD_USE_V4L2)
+int hdmi_set_v_param(int fd, int layer,
+ int srcColorFormat,
+ int src_w, int src_h,
+ SecBuffer * dstBuffer,
+ int dst_x, int dst_y, int dst_w, int dst_h)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(srcColorFormat);
+ int round_up_src_w;
+ int round_up_src_h;
+ unsigned int num_of_plane;
+ struct v4l2_rect rect;
+
+ /* src_w, src_h round up to DWORD because of VP restriction */
+#if defined(SAMSUNG_EXYNOS4x12)
+ round_up_src_w = ROUND_UP(src_w, 16);
+#else defined(SAMSUNG_EXYNOS4210)
+ round_up_src_w = ROUND_UP(src_w, 8);
+#endif
+ round_up_src_h = ROUND_UP(src_h, 8);
+
+ switch (v4l2ColorFormat) {
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV21:
+ dstBuffer->size.s = (round_up_src_w * round_up_src_h * 3) >> 1;
+ num_of_plane = 1;
+ break;
+ case V4L2_PIX_FMT_NV12M:
+ case V4L2_PIX_FMT_NV12MT:
+ case V4L2_PIX_FMT_NV21M:
+ dstBuffer->size.extS[0] = (round_up_src_w * round_up_src_h * 3) >> 1;
+ dstBuffer->size.extS[1] = (round_up_src_w * round_up_src_h * 3) >> 2;
+ num_of_plane = 2;
+ break;
+ default:
+ LOGE("%s::invalid color type", __func__);
+ return false;
+ break;
+ }
+
+ hdmi_cal_rect(src_w, src_h, dst_w, dst_h, &rect);
+ rect.left = ALIGN(rect.left, 16);
+
+ /* set format for VP input */
+ if (tvout_std_v4l2_s_fmt(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_FIELD_ANY, round_up_src_w, round_up_src_h, v4l2ColorFormat, num_of_plane) < 0) {
+ LOGE("%s::tvout_std_v4l2_s_fmt()[video layer] failed", __func__);
+ return -1;
+ }
+
+ /* set crop for VP input */
+ if (tvout_std_v4l2_s_crop(fd, V4L2_BUF_TYPE_VIDEO_OVERLAY, V4L2_FIELD_ANY, 0, 0, src_w, src_h) < 0) {
+ LOGE("%s::tvout_std_v4l2_s_crop()[video layer] failed", __func__);
+ return -1;
+ }
+
+ /* set crop for VP output */
+ if (tvout_std_v4l2_s_crop(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_FIELD_ANY, rect.left, rect.top, rect.width, rect.height) < 0) {
+ LOGE("%s::tvout_std_v4l2_s_crop()[video layer] failed", __func__);
+ return -1;
+ }
+
+ /* request buffer for VP input */
+ if (tvout_std_v4l2_reqbuf(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, HDMI_NUM_MIXER_BUF) < 0) {
+ LOGE("%s::tvout_std_v4l2_reqbuf(buf_num=%d)[video layer] failed", __func__, HDMI_NUM_MIXER_BUF);
+ return -1;
+ }
+
+ return 0;
+}
+
+int hdmi_set_g_param(int fd, int layer,
+ int srcColorFormat,
+ int src_w, int src_h,
+ SecBuffer * dstBuffer,
+ int dst_x, int dst_y, int dst_w, int dst_h)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ struct v4l2_rect rect;
+ int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(srcColorFormat);
+
+ rect.left = dst_x;
+ rect.top = dst_y;
+
+#if defined(BOARD_USES_FIMGAPI)
+ rect.width = dst_w;
+ rect.height = dst_h;
+#else
+ rect.width = src_w;
+ rect.height = src_h;
+#endif
+
+ switch (v4l2ColorFormat) {
+ case V4L2_PIX_FMT_BGR32:
+ case V4L2_PIX_FMT_RGB32:
+ dstBuffer->size.s = rect.width * rect.height << 2;
+ break;
+ case V4L2_PIX_FMT_RGB565X:
+ dstBuffer->size.s = rect.width * rect.height << 1;
+ break;
+ default:
+ LOGE("%s::invalid color type", __func__);
+ return false;
+ break;
+ }
+
+ /* set format for mixer graphic layer input device*/
+ if (tvout_std_v4l2_s_fmt(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_FIELD_ANY, rect.width, rect.height, v4l2ColorFormat, 1) < 0) {
+ LOGE("%s::tvout_std_v4l2_s_fmt() [layer=%d] failed", __func__, layer);
+ return -1;
+ }
+
+ /* set crop for mixer graphic layer input device*/
+ if (tvout_std_v4l2_s_crop(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_FIELD_ANY, rect.left, rect.top, rect.width, rect.height) < 0) {
+ LOGE("%s::tvout_std_v4l2_s_crop() [layer=%d] failed", __func__, layer);
+ return -1;
+ }
+
+ /* request buffer for mixer graphic layer input device */
+ if (tvout_std_v4l2_reqbuf(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, HDMI_NUM_MIXER_BUF) < 0) {
+ LOGE("%s::tvout_std_v4l2_reqbuf(buf_num=%d) [layer=%d] failed", __func__, HDMI_NUM_MIXER_BUF, layer);
+ return -1;
+ }
+
+ /* enable alpha blending for mixer graphic layer */
+ if (tvout_std_v4l2_s_ctrl(fd, V4L2_CID_TV_LAYER_BLEND_ENABLE, 1) < 0) {
+ LOGE("%s::tvout_std_v4l2_s_ctrl() [layer=%d] failed", __func__, layer);
+ return -1;
+ }
+
+ /* enable per-pixel blending for mixer graphic layer */
+ if (tvout_std_v4l2_s_ctrl(fd, V4L2_CID_TV_PIXEL_BLEND_ENABLE, 1) < 0) {
+ LOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] failed", __func__, layer);
+ return false;
+ }
+
+ /* set global alpha value for mixer graphic layer */
+ if (tvout_std_v4l2_s_ctrl(fd, V4L2_CID_TV_LAYER_BLEND_ALPHA, 255) < 0) {
+ LOGE("%s::tvout_std_v4l2_s_ctrl() [layer=%d] failed", __func__, layer);
+ return -1;
+ }
+
+ return 0;
+}
+
+int hdmi_set_g_scaling(int layer,
+ int srcColorFormat,
+ int src_w, int src_h,
+ unsigned int src_address, SecBuffer * dstBuffer,
+ int dst_x, int dst_y, int dst_w, int dst_h,
+ int rotVal, unsigned int hwc_layer)
+{
+#if defined(BOARD_USES_FIMGAPI)
+ int dst_color_format;
+ int dst_bpp;
+ unsigned char *dst_addr;
+ fimg2d_blit BlitParam;
+ rotation g2d_rotation;
+
+ fimg2d_addr srcAddr;
+ fimg2d_image srcImage;
+ fimg2d_rect srcRect;
+
+ fimg2d_addr dstAddr;
+ fimg2d_image dstImage;
+ fimg2d_rect dstRect;
+
+ fimg2d_clip dstClip;
+ fimg2d_scale Scaling;
+
+ switch (g_preset_id) {
+ case V4L2_DV_1080P60:
+ case V4L2_DV_1080P30:
+ case V4L2_DV_1080I60:
+ case V4L2_DV_720P60_SB_HALF:
+ case V4L2_DV_720P59_94_SB_HALF:
+ case V4L2_DV_1080P24_TB:
+ case V4L2_DV_1080P23_98_TB:
+ dst_color_format = CF_ARGB_8888;
+ dst_bpp = 4;
+ break;
+ case V4L2_DV_480P60:
+ case V4L2_DV_576P50:
+ case V4L2_DV_720P60:
+ case V4L2_DV_720P50_TB:
+ default:
+ dst_color_format = CF_ARGB_4444;
+ dst_bpp = 2;
+ break;
+ }
+
+ static unsigned int prev_src_addr = 0;
+
+ if ((cur_g2d_address == 0) || (src_address != prev_src_addr)) {
+ dst_addr = (unsigned char *)g2d_reserved_memory[g2d_buf_index];
+
+ g2d_buf_index++;
+ if (g2d_buf_index >= HDMI_G2D_OUTPUT_BUF_NUM)
+ g2d_buf_index = 0;
+
+ cur_g2d_address = (unsigned int)dst_addr;
+ prev_src_addr = src_address;
+
+ srcAddr = {(addr_space)ADDR_USER, (unsigned long)src_address, src_w * src_h * 4, 1, 0};
+ srcImage = {srcAddr, srcAddr, src_w, src_h, src_w*4, AX_RGB, CF_ARGB_8888};
+ srcRect = {0, 0, src_w, src_h};
+
+ dstAddr = {(addr_space)ADDR_USER, (unsigned long)dst_addr, dst_w * dst_h * dst_bpp, 1, 0};
+ dstImage = {dstAddr, dstAddr, dst_w, dst_h, dst_w*dst_bpp, AX_RGB, (color_format)dst_color_format};
+ dstRect = {0, 0, dst_w, dst_h};
+ dstClip = {0, 0, 0, dst_w, dst_h};
+
+ if (rotVal == 0 || rotVal == 180)
+ Scaling = {SCALING_BILINEAR, SCALING_PIXELS, 0, 0, src_w, src_h, dst_w, dst_h};
+ else
+ Scaling = {SCALING_BILINEAR, SCALING_PIXELS, 0, 0, src_w, src_h, dst_h, dst_w};
+
+ switch (rotVal) {
+ case 0:
+ g2d_rotation = ORIGIN;
+ break;
+ case 90:
+ g2d_rotation = ROT_90;
+ break;
+ case 180:
+ g2d_rotation = ROT_180;
+ break;
+ case 270:
+ g2d_rotation = ROT_270;
+ break;
+ default:
+ LOGE("%s::invalid rotVal(%d) fail", __func__, rotVal);
+ return -1;
+ break;
+ }
+
+ BlitParam = {BLIT_OP_SRC, NON_PREMULTIPLIED, 0xff, 0, g2d_rotation, &Scaling, 0, 0, &dstClip, 0, &srcImage, &dstImage, NULL, &srcRect, &dstRect, NULL, 0};
+
+ if (stretchFimgApi(&BlitParam) < 0) {
+ LOGE("%s::stretchFimgApi() fail", __func__);
+ return -1;
+ }
+
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("hdmi_set_g_scaling:: \n \\
+ layer=%d,\n \\
+ srcColorFormat=%d,\n \\
+ src_w=%d, src_h=%d,\n\\
+ src_address=0x%x, dst_addr=0x%x,\n\\
+ dst_x=%d, dst_y=%d, dst_w=%d, dst_h=%d ",
+ layer,
+ srcColorFormat,
+ src_w, src_h,
+ src_address, dst_addr,
+ dst_x, dst_y, dst_w, dst_h);
+#endif
+ dstBuffer->virt.p = (char *)dst_addr;
+ }
+#else
+ dstBuffer->virt.p = (char *)src_address;
+#endif
+
+ return 0;
+}
+#else
+int hdmi_set_v_param(int layer,
+ int src_w, int src_h, int colorFormat,
+ unsigned int src_y_address, unsigned int src_c_address,
+ int dst_w, int dst_h)
+{
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int round_up_src_w;
+ int round_up_src_h;
+ if (fp_tvout_v <= 0) {
+ LOGE("fp_tvout is < 0 fail\n");
+ return -1;
+ }
+
+ /* src_w, src_h round up to DWORD because of VP restriction */
+#if defined(SAMSUNG_EXYNOS4x12)
+ round_up_src_w = ROUND_UP(src_w, 16);
+#else defined(SAMSUNG_EXYNOS4210)
+ round_up_src_w = ROUND_UP(src_w, 8);
+#endif
+ round_up_src_h = ROUND_UP(src_h, 8);
+
+ vo_param.src.base_y = (void *)src_y_address;
+ vo_param.src.base_c = (void *)src_c_address;
+ vo_param.src.pix_fmt.width = round_up_src_w;
+ vo_param.src.pix_fmt.height = round_up_src_h;
+ vo_param.src.pix_fmt.field = V4L2_FIELD_NONE;
+ vo_param.src.pix_fmt.pixelformat = colorFormat;
+
+ tvout_v4l2_s_fmt(fp_tvout_v, V4L2_BUF_TYPE_PRIVATE, &vo_param.src);
+
+ vo_param.src_crop.width = src_w;
+ vo_param.src_crop.height = src_h;
+
+ tvout_v4l2_s_crop(fp_tvout_v, V4L2_BUF_TYPE_PRIVATE, &vo_param.src_crop);
+
+ if (dst_w * src_h <= dst_h * src_w) {
+ vo_param.dst_win.w.left = 0;
+ vo_param.dst_win.w.top = (dst_h - ((dst_w * src_h) / src_w)) >> 1;
+ vo_param.dst_win.w.width = dst_w;
+ vo_param.dst_win.w.height = ((dst_w * src_h) / src_w);
+ } else {
+ vo_param.dst_win.w.left = (dst_w - ((dst_h * src_w) / src_h)) >> 1;
+ vo_param.dst_win.w.top = 0;
+ vo_param.dst_win.w.width = ((dst_h * src_w) / src_h);
+ vo_param.dst_win.w.height = dst_h;
+ }
+
+ vo_param.dst.fmt.priv = 10;
+ vo_param.dst_win.global_alpha = 255;
+ tvout_v4l2_s_fbuf(fp_tvout_v, &vo_param.dst);
+ tvout_v4l2_s_fmt(fp_tvout_v, V4L2_BUF_TYPE_VIDEO_OVERLAY, &vo_param.dst_win);
+
+ return 0;
+}
+
+int hdmi_gl_set_param(int layer,
+ int srcColorFormat,
+ int src_w, int src_h,
+ unsigned int src_y_address, unsigned int src_c_address,
+ int dst_x, int dst_y, int dst_w, int dst_h,
+ int rotVal)
+{
+#if defined(BOARD_USES_FIMGAPI)
+ int dst_color_format;
+ int dst_bpp;
+ unsigned char *dst_addr;
+ fimg2d_blit BlitParam;
+ rotation g2d_rotation;
+
+ fimg2d_addr srcAddr;
+ fimg2d_image srcImage;
+ fimg2d_rect srcRect;
+
+ fimg2d_addr dstAddr;
+ fimg2d_image dstImage;
+ fimg2d_rect dstRect;
+
+ fimg2d_clip dstClip;
+ fimg2d_scale Scaling;
+
+ struct fb_var_screeninfo var;
+ struct s5ptvfb_user_window window;
+
+ int fp_tvout_g;
+
+ if(layer == HDMI_LAYER_GRAPHIC_0)
+ fp_tvout_g = fp_tvout_g0;
+ else
+ fp_tvout_g = fp_tvout_g1;
+
+ switch (t_std_id) {
+ case V4L2_STD_1080P_60:
+ case V4L2_STD_1080P_30:
+ case V4L2_STD_1080I_60:
+ case V4L2_STD_TVOUT_720P_60_SBS_HALF:
+ case V4L2_STD_TVOUT_720P_59_SBS_HALF:
+ case V4L2_STD_TVOUT_1080P_24_TB:
+ case V4L2_STD_TVOUT_1080P_23_TB:
+ dst_color_format = CF_ARGB_8888;
+ dst_bpp = 4;
+ var.bits_per_pixel = 32;
+ var.transp.length = 8;
+ break;
+ case V4L2_STD_480P_60_16_9:
+ case V4L2_STD_576P_50_16_9:
+ case V4L2_STD_720P_60:
+ case V4L2_STD_TVOUT_720P_50_TB:
+ default:
+ dst_color_format = CF_ARGB_4444;
+ dst_bpp = 2;
+ var.bits_per_pixel = 16;
+ var.transp.length = 4;
+ break;
+ }
+
+ static unsigned int prev_src_addr = 0;
+
+ if ((cur_g2d_address == 0) || (src_y_address != prev_src_addr)) {
+ dst_addr = (unsigned char *)g2d_reserved_memory[g2d_buf_index];
+
+ g2d_buf_index++;
+ if (g2d_buf_index >= HDMI_G2D_OUTPUT_BUF_NUM)
+ g2d_buf_index = 0;
+
+ cur_g2d_address = (unsigned int)dst_addr;
+ prev_src_addr = src_y_address;
+
+ srcAddr = {(addr_space)ADDR_PHYS, (unsigned long)src_y_address, src_w*src_h*4, 1, 0};
+ srcImage = {srcAddr, srcAddr, src_w, src_h, src_w*4, AX_RGB, CF_ARGB_8888};
+ srcRect = {0, 0, src_w, src_h};
+
+ dstAddr = {(addr_space)ADDR_PHYS, (unsigned long)dst_addr, dst_w*dst_h*dst_bpp, 1, 0};
+ dstImage = {dstAddr, dstAddr, dst_w, dst_h, dst_w*dst_bpp, AX_RGB, (color_format)dst_color_format};
+ dstRect = {0, 0, dst_w, dst_h};
+ dstClip = {0, 0, 0, dst_w, dst_h};
+
+ if (rotVal == 0 || rotVal == 180)
+ Scaling = {SCALING_BILINEAR, SCALING_PIXELS, 0, 0, src_w, src_h, dst_w, dst_h};
+ else
+ Scaling = {SCALING_BILINEAR, SCALING_PIXELS, 0, 0, src_w, src_h, dst_h, dst_w};
+
+ switch (rotVal) {
+ case 0:
+ g2d_rotation = ORIGIN;
+ break;
+ case 90:
+ g2d_rotation = ROT_90;
+ break;
+ case 180:
+ g2d_rotation = ROT_180;
+ break;
+ case 270:
+ g2d_rotation = ROT_270;
+ break;
+ default:
+ LOGE("%s::invalid rotVal(%d) fail", __func__, rotVal);
+ return -1;
+ break;
+ }
+
+ BlitParam = {BLIT_OP_SRC, NON_PREMULTIPLIED, 0xff, 0, g2d_rotation, &Scaling, 0, 0, &dstClip, 0, &srcImage, &dstImage, NULL, &srcRect, &dstRect, NULL, 0};
+
+ if (stretchFimgApi(&BlitParam) < 0) {
+ LOGE("%s::stretchFimgApi() fail", __func__);
+ return -1;
+ }
+
+ var.xres = dst_w;
+ var.yres = dst_h;
+
+ var.xres_virtual = var.xres;
+ var.yres_virtual = var.yres;
+ var.xoffset = 0;
+ var.yoffset = 0;
+ var.width = 0;
+ var.height = 0;
+ var.activate = FB_ACTIVATE_FORCE;
+
+ window.x = dst_x;
+ window.y = dst_y;
+
+ tvout_v4l2_s_baseaddr(fp_tvout_g, (void *)dst_addr);
+ put_vscreeninfo(fp_tvout_g, &var);
+
+ if (ioctl(fp_tvout_g, S5PTVFB_WIN_POSITION, &window) < 0) {
+ LOGE("%s::S5PTVFB_WIN_POSITION ioctl failed.", __func__);
+ return -1;
+ }
+ }
+
+ return 0;
+#else
+ struct fb_var_screeninfo var;
+ struct s5ptvfb_user_window window;
+
+ struct overlay_param ov_param;
+
+ // set base address for grp layer0 of mixer
+ int fp_tvout_g;
+
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("hdmi_gl_set_param:: \n \\
+ layer=%d,\n \\
+ srcColorFormat=%d,\n \\
+ src_w=%d, src_h=%d,\n\\
+ src_y_address=0x%x, src_c_address=0x%x,\n\\
+ dst_x=%d, dst_y=%d, dst_w=%d, dst_h=%d ",
+ layer,
+ srcColorFormat,
+ src_w, src_h,
+ src_y_address, src_c_address,
+ dst_x, dst_y, dst_w, dst_h);
+#endif
+
+ if (layer == HDMI_LAYER_GRAPHIC_0)
+ fp_tvout_g = fp_tvout_g0;
+ else
+ fp_tvout_g = fp_tvout_g1;
+
+ var.xres = src_w;
+ var.yres = src_h;
+ var.xres_virtual = var.xres;
+ var.yres_virtual = var.yres;
+ var.xoffset = 0;
+ var.yoffset = 0;
+ var.width = src_w;
+ var.height = src_h;
+ var.activate = FB_ACTIVATE_FORCE;
+ if (srcColorFormat == HAL_PIXEL_FORMAT_RGB_565) {
+ var.bits_per_pixel = 16;
+ var.transp.length = 0;
+ }
+ else {
+ var.bits_per_pixel = 32;
+ var.transp.length = 8;
+ }
+
+ window.x = dst_x;
+ window.y = dst_y;
+
+ tvout_v4l2_s_baseaddr(fp_tvout_g, (void *)src_y_address);
+ put_vscreeninfo(fp_tvout_g, &var);
+ if (ioctl(fp_tvout_g, S5PTVFB_WIN_POSITION, &window) < 0) {
+ LOGE("%s:: S5PTVFB_WIN_POSITION ioctl failed.", __func__);
+ return -1;
+ }
+
+ return 0;
+#endif
+}
+#endif
+
+int hdmi_cable_status()
+{
+#if defined(BOARD_USE_V4L2)
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("%s", __func__);
+#endif
+
+ int cable_status = 0;
+ int fd = 0;
+ struct v4l2_control ctrl;
+
+ fd = open(TVOUT_DEV_G0, O_RDWR);
+ if (fd <= 0) {
+ LOGE("%s: graphic layer 0 drv open failed", __func__);
+ return -1;
+ }
+
+ ctrl.id = V4L2_CID_TV_HPD_STATUS;
+
+ if (ioctl(fd, VIDIOC_S_CTRL, &ctrl) < 0) {
+ LOGE("Get HPD_STATUS fail");
+ cable_status = -1;
+ } else {
+ cable_status = ctrl.value;
+ }
+
+#ifdef DEBUG_HDMI_HW_LEVEL
+ LOGD("HPD_STATUS = %d", cable_status);
+#endif
+
+ close(fd);
+
+ return cable_status;
+#else
+ int cable_status = 0;
+ int fp_hpd = 0;
+
+ fp_hpd = open(HPD_DEV, O_RDWR);
+ if (fp_hpd <= 0) {
+ LOGE("hpd drv open failed\n");
+ return -1;
+ }
+
+ //Delay about 0.3s
+ usleep(500000);
+ if (ioctl(fp_hpd, HPD_GET_STATE, &cable_status) < 0) {
+ LOGE("hpd drv HPD_GET_STATE ioctl failed\n");
+ cable_status = -1;
+ }
+
+ close(fp_hpd);
+
+ return cable_status;
+#endif
+}
+
+int hdmi_outputmode_2_v4l2_output_type(int output_mode)
+{
+ int v4l2_output_type = -1;
+
+ switch (output_mode) {
+ case HDMI_OUTPUT_MODE_YCBCR:
+ v4l2_output_type = V4L2_OUTPUT_TYPE_DIGITAL;
+ break;
+ case HDMI_OUTPUT_MODE_RGB:
+ v4l2_output_type = V4L2_OUTPUT_TYPE_HDMI_RGB;
+ break;
+ case HDMI_OUTPUT_MODE_DVI:
+ v4l2_output_type = V4L2_OUTPUT_TYPE_DVI;
+ break;
+ case COMPOSITE_OUTPUT_MODE:
+ v4l2_output_type = V4L2_OUTPUT_TYPE_COMPOSITE;
+ break;
+ default:
+ LOGE("%s::unmathced HDMI_mode(%d)", __func__, output_mode);
+ v4l2_output_type = -1;
+ break;
+ }
+
+ return v4l2_output_type;
+}
+
+int hdmi_v4l2_output_type_2_outputmode(int v4l2_output_type)
+{
+ int outputMode = -1;
+
+ switch (v4l2_output_type) {
+ case V4L2_OUTPUT_TYPE_DIGITAL:
+ outputMode = HDMI_OUTPUT_MODE_YCBCR;
+ break;
+ case V4L2_OUTPUT_TYPE_HDMI_RGB:
+ outputMode = HDMI_OUTPUT_MODE_RGB;
+ break;
+ case V4L2_OUTPUT_TYPE_DVI:
+ outputMode = HDMI_OUTPUT_MODE_DVI;
+ break;
+ case V4L2_OUTPUT_TYPE_COMPOSITE:
+ outputMode = COMPOSITE_OUTPUT_MODE;
+ break;
+ default:
+ LOGE("%s::unmathced v4l2_output_type(%d)", __func__, v4l2_output_type);
+ outputMode = -1;
+ break;
+ }
+
+ return outputMode;
+}
+
+int composite_std_2_v4l2_std_id(int std)
+{
+ int std_id = -1;
+
+ switch (std) {
+ case COMPOSITE_STD_NTSC_M:
+ std_id = V4L2_STD_NTSC_M;
+ break;
+ case COMPOSITE_STD_NTSC_443:
+ std_id = V4L2_STD_NTSC_443;
+ break;
+ case COMPOSITE_STD_PAL_BDGHI:
+ std_id = V4L2_STD_PAL_BDGHI;
+ break;
+ case COMPOSITE_STD_PAL_M:
+ std_id = V4L2_STD_PAL_M;
+ break;
+ case COMPOSITE_STD_PAL_N:
+ std_id = V4L2_STD_PAL_N;
+ break;
+ case COMPOSITE_STD_PAL_Nc:
+ std_id = V4L2_STD_PAL_Nc;
+ break;
+ case COMPOSITE_STD_PAL_60:
+ std_id = V4L2_STD_PAL_60;
+ break;
+ default:
+ LOGE("%s::unmathced composite_std(%d)", __func__, std);
+ break;
+ }
+
+ return std_id;
+}
+
+int hdmi_check_output_mode(int v4l2_output_type)
+{
+ struct HDMIVideoParameter video;
+ struct HDMIAudioParameter audio;
+ int calbirate_v4l2_mode = v4l2_output_type;
+
+ audio.formatCode = LPCM_FORMAT;
+ audio.outPacket = HDMI_ASP;
+ audio.channelNum = CH_2;
+ audio.sampleFreq = SF_44KHZ;
+
+ switch (v4l2_output_type) {
+ case V4L2_OUTPUT_TYPE_DIGITAL :
+ video.mode = HDMI;
+ if (!EDIDHDMIModeSupport(&video)) {
+ calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_DVI;
+ LOGI("Change mode into DVI\n");
+ break;
+ }
+
+ video.colorSpace = HDMI_CS_YCBCR444;
+ if (!EDIDColorSpaceSupport(&video)) {
+ calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_HDMI_RGB;
+ LOGI("Change mode into HDMI_RGB\n");
+ }
+ break;
+
+ case V4L2_OUTPUT_TYPE_HDMI_RGB:
+ video.mode = HDMI;
+ if (!EDIDHDMIModeSupport(&video)) {
+ calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_DVI;
+ LOGI("Change mode into DVI\n");
+ break;
+ }
+
+ video.colorSpace = HDMI_CS_RGB;
+ if (!EDIDColorSpaceSupport(&video)) {
+ calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_DIGITAL;
+ LOGI("Change mode into HDMI_YCBCR\n");
+ }
+ break;
+
+ case V4L2_OUTPUT_TYPE_DVI:
+ video.mode = DVI;
+ if (!EDIDHDMIModeSupport(&video)) {
+ video.colorSpace = HDMI_CS_YCBCR444;
+ if (!EDIDColorSpaceSupport(&video)) {
+ calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_HDMI_RGB;
+ LOGI("Change mode into HDMI_RGB\n");
+ } else {
+ calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_DIGITAL;
+ LOGI("Change mode into HDMI_YCBCR\n");
+ }
+ break;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+ return calbirate_v4l2_mode;
+}
+
+#if defined(BOARD_USE_V4L2)
+int hdmi_check_resolution(unsigned int preset_id)
+{
+ struct HDMIVideoParameter video;
+ struct HDMIAudioParameter audio;
+
+ switch (preset_id) {
+ case V4L2_DV_480P60:
+ video.resolution = v720x480p_60Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_16_9;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_576P50:
+ video.resolution = v720x576p_50Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_16_9;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_720P60:
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_720P50:
+ video.resolution = v1280x720p_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_1080P60:
+ video.resolution = v1920x1080p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_1080P50:
+ video.resolution = v1920x1080p_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_1080I60:
+ video.resolution = v1920x1080i_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_1080I50:
+ video.resolution = v1920x1080i_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_480P59_94:
+ video.resolution = v720x480p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_720P59_94:
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_1080I59_94:
+ video.resolution = v1920x1080i_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_1080P59_94:
+ video.resolution = v1920x1080p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_1080P30:
+ video.resolution = v1920x1080p_30Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_DV_720P60_SB_HALF:
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_3D_SSH_FORMAT;
+ break;
+ case V4L2_DV_720P59_94_SB_HALF:
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_3D_SSH_FORMAT;
+ break;
+ case V4L2_DV_720P50_TB:
+ video.resolution = v1280x720p_50Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ break;
+ case V4L2_DV_1080P24_TB:
+ video.resolution = v1920x1080p_24Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ break;
+ case V4L2_DV_1080P23_98_TB:
+ video.resolution = v1920x1080p_24Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ break;
+ default:
+ LOGE("%s::unmathced preset_id(%d)", __func__, preset_id);
+ return -1;
+ break;
+ }
+
+ if (!EDIDVideoResolutionSupport(&video)) {
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s::EDIDVideoResolutionSupport(%d) fail (not suppoted preset_id) \n", __func__, preset_id);
+#endif
+ return -1;
+ }
+
+ return 0;
+}
+
+int hdmi_resolution_2_preset_id(unsigned int resolution, int * w, int * h, unsigned int *preset_id)
+{
+ int ret = 0;
+
+ switch (resolution) {
+ case 1080960:
+ *w = 1920;
+ *h = 1080;
+ *preset_id = V4L2_DV_1080P60;
+ break;
+ case 1080950:
+ *w = 1920;
+ *h = 1080;
+ *preset_id = V4L2_DV_1080P50;
+ break;
+ case 1080930:
+ *w = 1920;
+ *h = 1080;
+ *preset_id = V4L2_DV_1080P30;
+ break;
+ case 1080924:
+ *w = 1920;
+ *h = 1080;
+ *preset_id = V4L2_DV_1080P24_TB;
+ break;
+ case 1080160:
+ *w = 1920;
+ *h = 1080;
+ *preset_id = V4L2_DV_1080I60;
+ break;
+ case 1080150:
+ *w = 1920;
+ *h = 1080;
+ *preset_id = V4L2_DV_1080I50;
+ break;
+ case 720960:
+ *w = 1280;
+ *h = 720;
+ *preset_id = V4L2_DV_720P60;
+ break;
+ case 7209601:
+ *w = 1280;
+ *h = 720;
+ *preset_id = V4L2_DV_720P60_SB_HALF;
+ break;
+ case 720950:
+ *w = 1280;
+ *h = 720;
+ *preset_id = V4L2_DV_720P50;
+ break;
+ case 7209501:
+ *w = 1280;
+ *h = 720;
+ *preset_id = V4L2_DV_720P50_TB;
+ break;
+ case 5769501:
+ *w = 720;
+ *h = 576;
+ *preset_id = V4L2_DV_576P50;
+ break;
+ case 5769502:
+ *w = 720;
+ *h = 576;
+ *preset_id = V4L2_DV_576P50;
+ break;
+ case 4809601:
+ *w = 720;
+ *h = 480;
+ *preset_id = V4L2_DV_480P60;
+ break;
+ case 4809602:
+ *w = 720;
+ *h = 480;
+ *preset_id = V4L2_DV_480P60;
+ break;
+ default:
+ LOGE("%s::unmathced resolution(%d)", __func__, resolution);
+ ret = -1;
+ break;
+ }
+
+ return ret;
+}
+#else
+int hdmi_check_resolution(v4l2_std_id std_id)
+{
+ struct HDMIVideoParameter video;
+ struct HDMIAudioParameter audio;
+
+ switch (std_id) {
+ case V4L2_STD_480P_60_16_9:
+ video.resolution = v720x480p_60Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_16_9;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_480P_60_4_3:
+ video.resolution = v640x480p_60Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_4_3;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_576P_50_16_9:
+ video.resolution = v720x576p_50Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_16_9;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_576P_50_4_3:
+ video.resolution = v720x576p_50Hz;
+ video.pixelAspectRatio = HDMI_PIXEL_RATIO_4_3;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_720P_60:
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_720P_50:
+ video.resolution = v1280x720p_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_1080P_60:
+ video.resolution = v1920x1080p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_1080P_50:
+ video.resolution = v1920x1080p_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_1080I_60:
+ video.resolution = v1920x1080i_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_1080I_50:
+ video.resolution = v1920x1080i_50Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_480P_59:
+ video.resolution = v720x480p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_720P_59:
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_1080I_59:
+ video.resolution = v1920x1080i_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_1080P_59:
+ video.resolution = v1920x1080p_60Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_1080P_30:
+ video.resolution = v1920x1080p_30Hz;
+ video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
+ break;
+ case V4L2_STD_TVOUT_720P_60_SBS_HALF:
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_3D_SSH_FORMAT;
+ break;
+ case V4L2_STD_TVOUT_720P_59_SBS_HALF:
+ video.resolution = v1280x720p_60Hz;
+ video.hdmi_3d_format = HDMI_3D_SSH_FORMAT;
+ break;
+ case V4L2_STD_TVOUT_720P_50_TB:
+ video.resolution = v1280x720p_50Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ break;
+ case V4L2_STD_TVOUT_1080P_24_TB:
+ video.resolution = v1920x1080p_24Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ break;
+ case V4L2_STD_TVOUT_1080P_23_TB:
+ video.resolution = v1920x1080p_24Hz;
+ video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
+ break;
+ default:
+ LOGE("%s::unmathced std_id(%lld)", __func__, std_id);
+ return -1;
+ break;
+ }
+
+ if (!EDIDVideoResolutionSupport(&video)) {
+#ifdef DEBUG_MSG_ENABLE
+ LOGD("%s::EDIDVideoResolutionSupport(%llx) fail (not suppoted std_id) \n", __func__, std_id);
+#endif
+ return -1;
+ }
+
+ return 0;
+}
+
+int hdmi_resolution_2_std_id(unsigned int resolution, int * w, int * h, v4l2_std_id * std_id)
+{
+ int ret = 0;
+
+ switch (resolution) {
+ case 1080960:
+ *std_id = V4L2_STD_1080P_60;
+ *w = 1920;
+ *h = 1080;
+ break;
+ case 1080950:
+ *std_id = V4L2_STD_1080P_50;
+ *w = 1920;
+ *h = 1080;
+ break;
+ case 1080930:
+ *std_id = V4L2_STD_1080P_30;
+ *w = 1920;
+ *h = 1080;
+ break;
+ case 1080924:
+ *std_id = V4L2_STD_TVOUT_1080P_24_TB;
+ *w = 1920;
+ *h = 1080;
+ break;
+ case 1080160:
+ *std_id = V4L2_STD_1080I_60;
+ *w = 1920;
+ *h = 1080;
+ break;
+ case 1080150:
+ *std_id = V4L2_STD_1080I_50;
+ *w = 1920;
+ *h = 1080;
+ break;
+ case 720960:
+ *std_id = V4L2_STD_720P_60;
+ *w = 1280;
+ *h = 720;
+ break;
+ case 7209601:
+ *std_id = V4L2_STD_TVOUT_720P_60_SBS_HALF;
+ *w = 1280;
+ *h = 720;
+ break;
+ case 720950:
+ *std_id = V4L2_STD_720P_50;
+ *w = 1280;
+ *h = 720;
+ break;
+ case 7209501:
+ *std_id = V4L2_STD_TVOUT_720P_50_TB;
+ *w = 1280;
+ *h = 720;
+ break;
+ case 5769501:
+ *std_id = V4L2_STD_576P_50_16_9;
+ *w = 720;
+ *h = 576;
+ break;
+ case 5769502:
+ *std_id = V4L2_STD_576P_50_4_3;
+ *w = 720;
+ *h = 576;
+ break;
+ case 4809601:
+ *std_id = V4L2_STD_480P_60_16_9;
+ *w = 720;
+ *h = 480;
+ break;
+ case 4809602:
+ *std_id = V4L2_STD_480P_60_4_3;
+ *w = 720;
+ *h = 480;
+ break;
+ default:
+ LOGE("%s::unmathced resolution(%d)", __func__, resolution);
+ ret = -1;
+ break;
+ }
+
+ return ret;
+}
+#endif
+
+int hdmi_enable_hdcp(unsigned int hdcp_en)
+{
+ if (ioctl(fp_tvout, VIDIOC_HDCP_ENABLE, hdcp_en) < 0) {
+ LOGD("%s::VIDIOC_HDCP_ENABLE(%d) fail \n", __func__, hdcp_en);
+ return -1;
+ }
+
+ return 0;
+}
+
+int hdmi_check_audio(void)
+{
+ struct HDMIAudioParameter audio;
+ enum state audio_state = ON;
+ int ret = 0;
+
+ audio.formatCode = LPCM_FORMAT;
+ audio.outPacket = HDMI_ASP;
+ audio.channelNum = CH_2;
+ audio.sampleFreq = SF_44KHZ;
+
+#if defined(BOARD_USES_EDID)
+ if (!EDIDAudioModeSupport(&audio))
+ audio_state = NOT_SUPPORT;
+ else
+ audio_state = ON;
+#endif
+ if (audio_state == ON) {
+ if (ioctl(fp_tvout, VIDIOC_INIT_AUDIO, 1) < 0) {
+ LOGE("%s::VIDIOC_INIT_AUDIO(1) fail", __func__);
+ ret = -1;
+ }
+ } else {
+ if (ioctl(fp_tvout, VIDIOC_INIT_AUDIO, 0) < 0) {
+ LOGE("%s::VIDIOC_INIT_AUDIO(0) fail", __func__);
+ ret = -1;
+ }
+ }
+
+ return ret;
+}
+
+}
diff --git a/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h b/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h
new file mode 100644
index 0000000..a4aa69c
--- /dev/null
+++ b/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h
@@ -0,0 +1,132 @@
+/*
+ * 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 __HDMI_HAL_V4L2_UTILS_H__
+#define __HDMI_HAL_V4L2_UTILS_H__
+
+//#define LOG_NDEBUG 0
+//#define LOG_TAG "libhdmi"
+#if defined(BOARD_USE_V4L2)
+#include "SecBuffer.h"
+#endif
+#include "fimd_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace android {
+
+void display_menu(void);
+
+int tvout_open(const char *fp_name);
+#if defined(BOARD_USE_V4L2)
+int tvout_std_v4l2_init(int fd, unsigned int preset_id);
+int tvout_std_v4l2_querycap(int fd, char *node);
+int tvout_std_v4l2_enum_dv_presets(int fd);
+int tvout_std_v4l2_s_dv_preset(int fd, struct v4l2_dv_preset *preset);
+int tvout_std_v4l2_enum_output(int fd, struct v4l2_output *output);
+int tvout_std_v4l2_s_output(int fd, int index);
+int tvout_std_v4l2_g_output(int fd, int *index);
+int tvout_std_v4l2_s_fmt(int fd, enum v4l2_buf_type type, enum v4l2_field field, int w, int h, int colorformat, int num_planes);
+int tvout_std_v4l2_s_crop(int fd, enum v4l2_buf_type type, enum v4l2_field field, int x, int y, int w, int h);
+int tvout_std_v4l2_s_ctrl(int fd, int id, int value);
+int tvout_std_v4l2_reqbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int num_bufs);
+int tvout_std_v4l2_querybuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int buf_index, unsigned int num_planes, SecBuffer *secBuf);
+int tvout_std_v4l2_qbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int buf_index, int num_planes, SecBuffer *secBuf);
+int tvout_std_v4l2_dqbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int *buf_index, int num_planes);
+int tvout_std_v4l2_streamon(int fd, enum v4l2_buf_type type);
+int tvout_std_v4l2_streamoff(int fd, enum v4l2_buf_type type);
+#else
+int tvout_init(v4l2_std_id std_id);
+int tvout_deinit();
+int tvout_v4l2_querycap(int fp);
+int tvout_v4l2_g_std(int fp, v4l2_std_id *std_id);
+int tvout_v4l2_s_std(int fp, v4l2_std_id std_id);
+int tvout_v4l2_enum_std(int fp, struct v4l2_standard *std, v4l2_std_id std_id);
+int tvout_v4l2_enum_output(int fp, struct v4l2_output *output);
+int tvout_v4l2_s_output(int fp, int index);
+int tvout_v4l2_g_output(int fp, int *index);
+int tvout_v4l2_enum_fmt(int fp, struct v4l2_fmtdesc *desc);
+int tvout_v4l2_g_fmt(int fp, int buf_type, void* ptr);
+int tvout_v4l2_s_fmt(int fp, int buf_type, void *ptr);
+int tvout_v4l2_g_fbuf(int fp, struct v4l2_framebuffer *frame);
+int tvout_v4l2_s_fbuf(int fp, struct v4l2_framebuffer *frame);
+int tvout_v4l2_s_baseaddr(int fp, void *base_addr);
+int tvout_v4l2_g_crop(int fp, unsigned int type, struct v4l2_rect *rect);
+int tvout_v4l2_s_crop(int fp, unsigned int type, struct v4l2_rect *rect);
+int tvout_v4l2_start_overlay(int fp);
+int tvout_v4l2_stop_overlay(int fp);
+#endif
+
+int hdmi_init_layer(int layer);
+int hdmi_deinit_layer(int layer);
+#if defined(BOARD_USE_V4L2)
+int hdmi_set_v_param(int fd, int layer,
+ int srcColorFormat,
+ int src_w, int src_h,
+ SecBuffer * dstBuffer,
+ int dst_x, int dst_y, int dst_w, int dst_h);
+int hdmi_set_g_param(int fd, int layer,
+ int srcColorFormat,
+ int src_w, int src_h,
+ SecBuffer * dstBuffer,
+ int dst_x, int dst_y, int dst_w, int dst_h);
+int hdmi_set_g_scaling(int layer,
+ int srcColorFormat,
+ int src_w, int src_h,
+ unsigned int src_address, SecBuffer * dstBuffer,
+ int dst_x, int dst_y, int dst_w, int dst_h,
+ int rotVal, unsigned int hwc_layer);
+#else
+int hdmi_set_v_param(int layer,
+ int src_w, int src_h, int colorFormat,
+ unsigned int src_y_address, unsigned int src_c_address,
+ int dst_w, int dst_h);
+int hdmi_gl_set_param(int layer,
+ int srcColorFormat,
+ int src_w, int src_h,
+ unsigned int src_y_address, unsigned int src_c_address,
+ int dst_x, int dst_y, int dst_w, int dst_h,
+ int rotVal);
+#endif
+void hdmi_cal_rect(int src_w, int src_h, int dst_w, int dst_h, struct v4l2_rect *dst_rect);
+#if defined(BOARD_USE_V4L2)
+int hdmi_get_src_plane(int srcColorFormat, unsigned int *num_of_plane);
+#endif
+int hdmi_cable_status();
+int hdmi_outputmode_2_v4l2_output_type(int output_mode);
+int hdmi_v4l2_output_type_2_outputmode(int v4l2_output_type);
+int composite_std_2_v4l2_std_id(int std);
+
+int hdmi_check_output_mode(int v4l2_output_type);
+#if defined(BOARD_USE_V4L2)
+int hdmi_check_resolution(unsigned int preset_id);
+int hdmi_resolution_2_preset_id(unsigned int resolution, int * w, int * h, unsigned int *preset_id);
+#else
+int hdmi_check_resolution(v4l2_std_id std_id);
+int hdmi_resolution_2_std_id(unsigned int resolution, int *w, int *h, v4l2_std_id *std_id);
+#endif
+int hdmi_enable_hdcp(unsigned int hdcp_en);
+int hdmi_check_audio(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+} //namespace android
+
+#endif //__HDMI_HAL_V4L2_UTILS_H__
diff --git a/exynos4/hal/libhdmi/SecHdmi/fimd_api.c b/exynos4/hal/libhdmi/SecHdmi/fimd_api.c
new file mode 100644
index 0000000..0e07ef3
--- /dev/null
+++ b/exynos4/hal/libhdmi/SecHdmi/fimd_api.c
@@ -0,0 +1,229 @@
+/*
+* 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.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <linux/vt.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <poll.h>
+#include <signal.h>
+#include <cutils/log.h>
+
+#include "fimd_api.h"
+
+int fb_open(int win)
+{
+ char node[20];
+ int fp = -1;
+
+ sprintf(node, "%s%d", PFX_NODE_FB, win);
+
+ fp = open(node, O_RDWR);
+ if (fp < 0)
+ LOGE("%s: fb[%d] open failed", __func__, win);
+
+ return fp;
+}
+
+int fb_close(int fp)
+{
+ if (fp)
+ close(fp);
+ else
+ LOGE("%s: fb is not allocated %d", __func__, fp);
+
+ return 0;
+}
+
+int get_fscreeninfo(int fp, struct fb_fix_screeninfo *fix)
+{
+ int ret = -1;
+
+ ret = ioctl(fp, FBIOGET_FSCREENINFO, fix);
+ if (ret)
+ LOGE("%s: FBIOGET_FSCREENINFO failed", __func__);
+
+ return ret;
+}
+
+int get_vscreeninfo(int fp, struct fb_var_screeninfo *var)
+{
+ int ret = -1;
+
+ ret = ioctl(fp, FBIOGET_VSCREENINFO, var);
+ if (ret)
+ LOGE("%s:: FBIOGET_VSCREENINFO failed", __func__);
+
+ return ret;
+}
+
+int put_vscreeninfo(int fp, struct fb_var_screeninfo *var)
+{
+ int ret = -1;
+
+ ret = ioctl(fp, FBIOPUT_VSCREENINFO, var);
+ if (ret)
+ LOGE("%s:: FBIOPUT_VSCREENINFO failed", __func__);
+
+ return ret;
+}
+
+int get_bytes_per_pixel(int bits_per_pixel)
+{
+ return (bits_per_pixel == 24 || bits_per_pixel == 25 ||
+ bits_per_pixel == 28) ? 4 : bits_per_pixel / 8;
+}
+
+char *fb_mmap(__u32 size, int fp)
+{
+ char *buffer;
+
+ buffer = (char *)mmap(0, size, PROT_READ | PROT_WRITE,
+ MAP_SHARED, fp, 0);
+ if (!buffer) {
+ LOGE("%s:: mmap failed", __func__);
+ return NULL;
+ }
+
+ return buffer;
+}
+
+int fb_ioctl(int fp, __u32 cmd, void *arg)
+{
+ int ret = -1;
+
+ ret = ioctl(fp, cmd, arg);
+ if (ret < 0)
+ LOGE("%s:: ioctl (%d) failed", __func__, cmd);
+
+ return ret;
+}
+
+int fb_on(int fp)
+{
+ int ret = -1;
+
+ ret = ioctl(fp, FBIOBLANK, FB_BLANK_UNBLANK);
+ if (ret)
+ LOGE("%s:: FBIOBLANK failed", __func__);
+
+ return ret;
+}
+
+int fb_off(int fp)
+{
+ int ret = -1;
+
+ ret = ioctl(fp, FBIOBLANK, FB_BLANK_POWERDOWN);
+ if (ret)
+ LOGE("%s:: FBIOBLANK failed", __func__);
+
+ return ret;
+}
+
+int fb_off_all()
+{
+ int fp, i;
+
+ for (i = 0; i < TOTAL_FB_NUM; i++) {
+ fp = fb_open(i);
+ if (fp < 0)
+ return -1;
+
+ if (ioctl(fp, FBIOBLANK, FB_BLANK_POWERDOWN) < 0)
+ LOGE("%s:: FBIOBLANK failed", __func__);
+
+ fb_off(fp);
+ fb_close(fp);
+ }
+
+ return 0;
+}
+
+char *fb_init_display(int fp, int width, int height, int left_x, int top_y,
+ int bpp)
+{
+ struct fb_var_screeninfo var;
+ struct s5ptvfb_user_window window;
+ int fb_size;
+ char *fb = NULL;
+
+ var.xres = width;
+ var.yres = height;
+ var.bits_per_pixel = bpp;
+ window.x = left_x;
+ window.y = top_y;
+
+ var.xres_virtual = var.xres;
+ var.yres_virtual = var.yres;
+ var.xoffset = 0;
+ var.yoffset = 0;
+ var.width = 0;
+ var.height = 0;
+ var.transp.length = 0;
+ var.activate = FB_ACTIVATE_FORCE;
+ fb_size = var.xres_virtual * var.yres_virtual * bpp / 8;
+
+ /* FBIOPUT_VSCREENINFO should be first */
+ put_vscreeninfo(fp, &var);
+ fb_ioctl(fp, S5PTVFB_WIN_POSITION, &window);
+
+ /* draw image */
+ fb = fb_mmap(fb_size, fp);
+ memset(fb, 0x0, fb_size);
+
+ return fb;
+}
+
+int simple_draw(char *dest, const char *src, int img_width,
+ struct fb_var_screeninfo *var)
+{
+ int bytes_per_pixel = get_bytes_per_pixel(var->bits_per_pixel);
+ unsigned int y;
+
+ for (y = 0; y < var->yres; y++)
+ memcpy(dest + y * var->xres * bytes_per_pixel,
+ src + y * img_width * bytes_per_pixel,
+ var->xres * bytes_per_pixel);
+
+ return 0;
+}
+
+int draw(char *dest, const char *src, int img_width,
+ struct fb_var_screeninfo *var)
+{
+ int bytes_per_pixel = get_bytes_per_pixel(var->bits_per_pixel);
+ unsigned int y;
+
+ if (var->bits_per_pixel == 16) {
+ memcpy(dest, src, var->xres * var->yres * 2);
+ } else {
+ for (y = 0; y < var->yres; y++)
+ memcpy(dest + y * var->xres * bytes_per_pixel,
+ src + y * img_width * bytes_per_pixel,
+ var->xres * bytes_per_pixel);
+ }
+
+ return 0;
+}
diff --git a/exynos4/hal/libhdmi/SecHdmi/fimd_api.h b/exynos4/hal/libhdmi/SecHdmi/fimd_api.h
new file mode 100644
index 0000000..a8561a4
--- /dev/null
+++ b/exynos4/hal/libhdmi/SecHdmi/fimd_api.h
@@ -0,0 +1,51 @@
+/*
+ * 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 __FIMD_API_H__
+#define __FIMD_API_H__
+
+#include <linux/fb.h>
+#include "s5p_tvout.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define TOTAL_FB_NUM 5
+
+int fb_open(int win);
+int fb_close(int fp);
+int fb_on(int fp);
+int fb_off(int fp);
+int fb_off_all(void);
+char *fb_init_display(int fp, int width, int height,\
+ int left_x, int top_y, int bpp);
+int fb_ioctl(int fp, __u32 cmd, void *arg);
+char *fb_mmap(__u32 size, int fp);
+int simple_draw(char *dest, const char *src,\
+ int img_width, struct fb_var_screeninfo *var);
+int draw(char *dest, const char *src,\
+ int img_width, struct fb_var_screeninfo *var);
+int get_fscreeninfo(int fp, struct fb_fix_screeninfo *fix);
+int get_vscreeninfo(int fp, struct fb_var_screeninfo *var);
+int put_vscreeninfo(int fp, struct fb_var_screeninfo *var);
+int get_bytes_per_pixel(int bits_per_pixel);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __FIMD_API_H__ */
diff --git a/exynos4/hal/libhdmi/libhdmiservice/Android.mk b/exynos4/hal/libhdmi/libhdmiservice/Android.mk
new file mode 100644
index 0000000..ebfa9d5
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/Android.mk
@@ -0,0 +1,126 @@
+# 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.
+
+ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
+ifeq ($(BOARD_USES_HDMI),true)
+
+LOCAL_PATH:= $(call my-dir)
+
+#
+# libTVOut
+#
+
+include $(CLEAR_VARS)
+LOCAL_MODULE_TAGS := optional
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_SRC_FILES := \
+ SecTVOutService.cpp \
+ ISecTVOut.cpp \
+ MessageQueue.cpp
+
+LOCAL_C_INCLUDES := \
+
+LOCAL_SHARED_LIBRARIES := \
+ libbinder \
+ libutils \
+ libcutils
+
+LOCAL_C_INCLUDES += $(TARGET_HAL_PATH)/include
+LOCAL_C_INCLUDES += $(TARGET_HAL_PATH)/libhdmi
+LOCAL_C_INCLUDES += $(TARGET_HAL_PATH)/libfimc
+LOCAL_SHARED_LIBRARIES += libhdmi libfimc
+
+ifeq ($(BOARD_USES_HDMI_SUBTITLES),true)
+ LOCAL_CFLAGS += -DBOARD_USES_HDMI_SUBTITLES
+endif
+
+ifeq ($(TARGET_SOC),exynos4210)
+ LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4210
+endif
+
+ifeq ($(TARGET_SOC),exynos4x12)
+ LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4x12
+endif
+
+LOCAL_CFLAGS += -DBOARD_USES_HDMI
+
+ifeq ($(BOARD_USE_V4L2),true)
+ LOCAL_CFLAGS += -DBOARD_USE_V4L2
+endif
+
+ifeq ($(BOARD_USE_V4L2_ION),true)
+ LOCAL_CFLAGS += -DBOARD_USE_V4L2_ION
+endif
+
+LOCAL_MODULE := libTVOut
+
+include $(BUILD_SHARED_LIBRARY)
+
+#
+# libhdmiclient
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_SRC_FILES:= \
+ SecHdmiClient.cpp
+
+LOCAL_C_INCLUDES += \
+ $(JNI_H_INCLUDE)
+
+LOCAL_SHARED_LIBRARIES := \
+ libbinder \
+ libutils \
+ libTVOut
+
+ifeq ($(TARGET_SIMULATOR),true)
+ifeq ($(TARGET_OS),linux)
+ifeq ($(TARGET_ARCH),x86)
+LOCAL_LDLIBS += -lpthread -ldl -lrt
+endif
+endif
+endif
+
+ifeq ($(WITH_MALLOC_LEAK_CHECK),true)
+ LOCAL_CFLAGS += -DMALLOC_LEAK_CHECK
+endif
+
+ifeq ($(TARGET_SOC),exynos4210)
+ LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4210
+endif
+
+ifeq ($(TARGET_SOC),exynos4x12)
+ LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4x12
+endif
+
+LOCAL_CFLAGS += -DBOARD_USES_HDMI
+
+ifeq ($(BOARD_USE_V4L2),true)
+ LOCAL_CFLAGS += -DBOARD_USE_V4L2
+endif
+
+ifeq ($(BOARD_USE_V4L2_ION),true)
+ LOCAL_CFLAGS += -DBOARD_USE_V4L2_ION
+endif
+
+LOCAL_MODULE:= libhdmiclient
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif
+endif
diff --git a/exynos4/hal/libhdmi/libhdmiservice/Barrier.h b/exynos4/hal/libhdmi/libhdmiservice/Barrier.h
new file mode 100644
index 0000000..6f8507e
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/Barrier.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2007 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_BARRIER_H
+#define ANDROID_BARRIER_H
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <utils/threads.h>
+
+namespace android {
+
+class Barrier
+{
+public:
+ inline Barrier() : state(CLOSED) { }
+ inline ~Barrier() { }
+ void open() {
+ Mutex::Autolock _l(lock);
+ state = OPENED;
+ cv.broadcast();
+ }
+ void close() {
+ Mutex::Autolock _l(lock);
+ state = CLOSED;
+ }
+ void wait() const {
+ Mutex::Autolock _l(lock);
+ while (state == CLOSED) {
+ cv.wait(lock);
+ }
+ }
+private:
+ enum { OPENED, CLOSED };
+ mutable Mutex lock;
+ mutable Condition cv;
+ volatile int state;
+};
+
+}; // namespace android
+
+#endif // ANDROID_BARRIER_H
diff --git a/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.cpp b/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.cpp
new file mode 100644
index 0000000..a013bf1
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.cpp
@@ -0,0 +1,111 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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.
+*/
+
+/*
+**
+** @author Taikyung, Yu(taikyung.yu@samsung.com)
+** @date 2011-07-06
+*/
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <binder/Parcel.h>
+#include <utils/Log.h>
+#include "ISecTVOut.h"
+
+namespace android {
+
+ enum {
+ SET_HDMI_STATUS = IBinder::FIRST_CALL_TRANSACTION,
+ SET_HDMI_MODE,
+ SET_HDMI_RESOLUTION,
+ SET_HDMI_HDCP,
+ SET_HDMI_ROTATE,
+ SET_HDMI_HWCLAYER,
+ BLIT_2_HDMI
+ };
+
+ void BpSecTVOut::setHdmiCableStatus(uint32_t status)
+ {
+ Parcel data, reply;
+ data.writeInt32(status);
+ remote()->transact(SET_HDMI_STATUS, data, &reply);
+ }
+
+ void BpSecTVOut::setHdmiMode(uint32_t mode)
+ {
+ Parcel data, reply;
+ data.writeInt32(mode);
+ remote()->transact(SET_HDMI_MODE, data, &reply);
+ }
+
+ void BpSecTVOut::setHdmiResolution(uint32_t resolution)
+ {
+ Parcel data, reply;
+ data.writeInt32(resolution);
+ remote()->transact(SET_HDMI_RESOLUTION, data, &reply);
+ }
+
+ void BpSecTVOut::setHdmiHdcp(uint32_t resolution)
+ {
+ Parcel data, reply;
+ data.writeInt32(resolution);
+ remote()->transact(SET_HDMI_HDCP, data, &reply);
+ }
+
+ void BpSecTVOut::setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer)
+ {
+ Parcel data, reply;
+ data.writeInt32(rotVal);
+ data.writeInt32(hwcLayer);
+ remote()->transact(SET_HDMI_ROTATE, data, &reply);
+ }
+
+ void BpSecTVOut::setHdmiHwcLayer(uint32_t hwcLayer)
+ {
+ Parcel data, reply;
+ data.writeInt32(hwcLayer);
+ remote()->transact(SET_HDMI_HWCLAYER, data, &reply);
+ }
+
+ void BpSecTVOut::blit2Hdmi(uint32_t w, uint32_t h,
+ uint32_t colorFormat,
+ uint32_t physYAddr,
+ uint32_t physCbAddr,
+ uint32_t physCrAddr,
+ uint32_t dstX,
+ uint32_t dstY,
+ uint32_t hdmiLayer,
+ uint32_t num_of_hwc_layer)
+ {
+ Parcel data, reply;
+ data.writeInt32(w);
+ data.writeInt32(h);
+ data.writeInt32(colorFormat);
+ data.writeInt32(physYAddr);
+ data.writeInt32(physCbAddr);
+ data.writeInt32(physCrAddr);
+ data.writeInt32(dstX);
+ data.writeInt32(dstY);
+ data.writeInt32(hdmiLayer);
+ data.writeInt32(num_of_hwc_layer);
+ remote()->transact(BLIT_2_HDMI, data, &reply);
+ }
+
+ IMPLEMENT_META_INTERFACE(SecTVOut, "android.os.ISecTVOut");
+};
diff --git a/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.h b/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.h
new file mode 100644
index 0000000..5506b57
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.h
@@ -0,0 +1,74 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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.
+*/
+
+/*
+**
+** @author Taikyung, Yu(taikyung.yu@samsung.com)
+** @date 2011-07-06
+*/
+
+#ifndef ISECTVOUT_H
+#define ISECTVOUT_H
+#include <utils/RefBase.h>
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+
+namespace android {
+ class ISecTVOut: public IInterface
+ {
+ public:
+ DECLARE_META_INTERFACE(SecTVOut);
+ virtual void setHdmiCableStatus(uint32_t status) = 0;
+ virtual void setHdmiMode(uint32_t mode) = 0;
+ virtual void setHdmiResolution(uint32_t resolution) = 0;
+ virtual void setHdmiHdcp(uint32_t enHdcp) = 0;
+ virtual void setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer) = 0;
+ virtual void setHdmiHwcLayer(uint32_t hwcLayer) = 0;
+ virtual void blit2Hdmi(uint32_t w, uint32_t h,
+ uint32_t colorFormat,
+ uint32_t physYAddr,
+ uint32_t physCbAddr,
+ uint32_t physCrAddr,
+ uint32_t dstX,
+ uint32_t dstY,
+ uint32_t hdmiLayer,
+ uint32_t num_of_hwc_layer) = 0;
+ };
+ //--------------------------------------------------------------
+ class BpSecTVOut: public BpInterface<ISecTVOut>
+ {
+ public:
+ BpSecTVOut(const sp<IBinder>& impl): BpInterface<ISecTVOut>(impl){}
+ virtual void setHdmiCableStatus(uint32_t status);
+ virtual void setHdmiMode(uint32_t mode);
+ virtual void setHdmiResolution(uint32_t resolution);
+ virtual void setHdmiHdcp(uint32_t enHdcp);
+ virtual void setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer);
+ virtual void setHdmiHwcLayer(uint32_t hwcLayer);
+ virtual void blit2Hdmi(uint32_t w, uint32_t h,
+ uint32_t colorFormat,
+ uint32_t physYAddr,
+ uint32_t physCbAddr,
+ uint32_t physCrAddr,
+ uint32_t dstX,
+ uint32_t dstY,
+ uint32_t hdmiLayer,
+ uint32_t num_of_hwc_layer);
+ };
+};
+#endif
diff --git a/exynos4/hal/libhdmi/libhdmiservice/MessageQueue.cpp b/exynos4/hal/libhdmi/libhdmiservice/MessageQueue.cpp
new file mode 100644
index 0000000..aebe1b8
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/MessageQueue.cpp
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2009 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 <stdint.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include <utils/threads.h>
+#include <utils/Timers.h>
+#include <utils/Log.h>
+#include <binder/IPCThreadState.h>
+
+#include "MessageQueue.h"
+
+namespace android {
+
+// ---------------------------------------------------------------------------
+
+void MessageList::insert(const sp<MessageBase>& node)
+{
+ LIST::iterator cur(mList.begin());
+ LIST::iterator end(mList.end());
+ while (cur != end) {
+ if (*node < **cur) {
+ mList.insert(cur, node);
+ return;
+ }
+ ++cur;
+ }
+ mList.insert(++end, node);
+}
+
+void MessageList::remove(MessageList::LIST::iterator pos)
+{
+ mList.erase(pos);
+}
+
+// ---------------------------------------------------------------------------
+
+MessageQueue::MessageQueue()
+ : mInvalidate(false)
+{
+ mInvalidateMessage = new MessageBase(INVALIDATE);
+}
+
+MessageQueue::~MessageQueue()
+{
+}
+
+sp<MessageBase> MessageQueue::waitMessage(nsecs_t timeout)
+{
+ sp<MessageBase> result;
+
+ bool again;
+ do {
+ const nsecs_t timeoutTime = systemTime() + timeout;
+ while (true) {
+ Mutex::Autolock _l(mLock);
+ nsecs_t now = systemTime();
+ nsecs_t nextEventTime = -1;
+
+ LIST::iterator cur(mMessages.begin());
+ if (cur != mMessages.end()) {
+ result = *cur;
+ }
+
+ if (result != 0) {
+ if (result->when <= now) {
+ // there is a message to deliver
+ mMessages.remove(cur);
+ break;
+ }
+ nextEventTime = result->when;
+ result = 0;
+ }
+
+ // see if we have an invalidate message
+ if (mInvalidate) {
+ mInvalidate = false;
+ mInvalidateMessage->when = now;
+ result = mInvalidateMessage;
+ break;
+ }
+
+ if (timeout >= 0) {
+ if (timeoutTime < now) {
+ // we timed-out, return a NULL message
+ result = 0;
+ break;
+ }
+ if (nextEventTime > 0) {
+ if (nextEventTime > timeoutTime) {
+ nextEventTime = timeoutTime;
+ }
+ } else {
+ nextEventTime = timeoutTime;
+ }
+ }
+
+ if (nextEventTime >= 0) {
+ //LOGD("nextEventTime = %lld ms", nextEventTime);
+ if (nextEventTime > 0) {
+ // we're about to wait, flush the binder command buffer
+ IPCThreadState::self()->flushCommands();
+ const nsecs_t reltime = nextEventTime - systemTime();
+ if (reltime > 0) {
+ mCondition.waitRelative(mLock, reltime);
+ }
+ }
+ } else {
+ //LOGD("going to wait");
+ // we're about to wait, flush the binder command buffer
+ IPCThreadState::self()->flushCommands();
+ mCondition.wait(mLock);
+ }
+ }
+ // here we're not holding the lock anymore
+
+ if (result == 0)
+ break;
+
+ again = result->handler();
+ if (again) {
+ // the message has been processed. release our reference to it
+ // without holding the lock.
+ result->notify();
+ result = 0;
+ }
+
+ } while (again);
+
+ return result;
+}
+
+status_t MessageQueue::postMessage(
+ const sp<MessageBase>& message, nsecs_t relTime, uint32_t flags)
+{
+ return queueMessage(message, relTime, flags);
+}
+
+status_t MessageQueue::invalidate() {
+ Mutex::Autolock _l(mLock);
+ mInvalidate = true;
+ mCondition.signal();
+ return NO_ERROR;
+}
+
+status_t MessageQueue::queueMessage(
+ const sp<MessageBase>& message, nsecs_t relTime, uint32_t flags)
+{
+ Mutex::Autolock _l(mLock);
+ message->when = systemTime() + relTime;
+ mMessages.insert(message);
+
+ //LOGD("MessageQueue::queueMessage time = %lld ms", message->when);
+ //dumpLocked(message);
+
+ mCondition.signal();
+ return NO_ERROR;
+}
+
+void MessageQueue::dump(const sp<MessageBase>& message)
+{
+ Mutex::Autolock _l(mLock);
+ dumpLocked(message);
+}
+
+void MessageQueue::dumpLocked(const sp<MessageBase>& message)
+{
+ LIST::const_iterator cur(mMessages.begin());
+ LIST::const_iterator end(mMessages.end());
+ int c = 0;
+ while (cur != end) {
+ const char tick = (*cur == message) ? '>' : ' ';
+ LOGD("%c %d: msg{.what=%08x, when=%lld}",
+ tick, c, (*cur)->what, (*cur)->when);
+ ++cur;
+ c++;
+ }
+}
+
+// ---------------------------------------------------------------------------
+
+}; // namespace android
diff --git a/exynos4/hal/libhdmi/libhdmiservice/MessageQueue.h b/exynos4/hal/libhdmi/libhdmiservice/MessageQueue.h
new file mode 100644
index 0000000..890f809
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/MessageQueue.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2009 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_MESSAGE_QUEUE_H
+#define ANDROID_MESSAGE_QUEUE_H
+
+#include <stdint.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include <utils/threads.h>
+#include <utils/Timers.h>
+#include <utils/List.h>
+
+#include "Barrier.h"
+
+namespace android {
+
+// ---------------------------------------------------------------------------
+
+class MessageBase;
+
+class MessageList
+{
+ List< sp<MessageBase> > mList;
+ typedef List< sp<MessageBase> > LIST;
+public:
+ inline LIST::iterator begin() { return mList.begin(); }
+ inline LIST::const_iterator begin() const { return mList.begin(); }
+ inline LIST::iterator end() { return mList.end(); }
+ inline LIST::const_iterator end() const { return mList.end(); }
+ inline bool isEmpty() const { return mList.empty(); }
+ void insert(const sp<MessageBase>& node);
+ void remove(LIST::iterator pos);
+};
+
+// ============================================================================
+
+class MessageBase :
+ public LightRefBase<MessageBase>
+{
+public:
+ nsecs_t when;
+ uint32_t what;
+ int32_t arg0;
+
+ MessageBase() : when(0), what(0), arg0(0) { }
+ MessageBase(uint32_t what, int32_t arg0=0)
+ : when(0), what(what), arg0(arg0) { }
+
+ // return true if message has a handler
+ virtual bool handler() { return false; }
+
+ // waits for the handler to be processed
+ void wait() const { barrier.wait(); }
+
+ // releases all waiters. this is done automatically if
+ // handler returns true
+ void notify() const { barrier.open(); }
+
+protected:
+ virtual ~MessageBase() { }
+
+private:
+ mutable Barrier barrier;
+ friend class LightRefBase<MessageBase>;
+};
+
+inline bool operator < (const MessageBase& lhs, const MessageBase& rhs) {
+ return lhs.when < rhs.when;
+}
+
+// ---------------------------------------------------------------------------
+
+class MessageQueue
+{
+ typedef List< sp<MessageBase> > LIST;
+public:
+
+ MessageQueue();
+ ~MessageQueue();
+
+ // pre-defined messages
+ enum {
+ INVALIDATE = '_upd'
+ };
+
+ sp<MessageBase> waitMessage(nsecs_t timeout = -1);
+
+ status_t postMessage(const sp<MessageBase>& message,
+ nsecs_t reltime=0, uint32_t flags = 0);
+
+ status_t invalidate();
+
+ void dump(const sp<MessageBase>& message);
+
+private:
+ status_t queueMessage(const sp<MessageBase>& message,
+ nsecs_t reltime, uint32_t flags);
+ void dumpLocked(const sp<MessageBase>& message);
+
+ Mutex mLock;
+ Condition mCondition;
+ MessageList mMessages;
+ bool mInvalidate;
+ sp<MessageBase> mInvalidateMessage;
+};
+
+// ---------------------------------------------------------------------------
+
+}; // namespace android
+
+#endif /* ANDROID_MESSAGE_QUEUE_H */
diff --git a/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp b/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp
new file mode 100644
index 0000000..c5cca78
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp
@@ -0,0 +1,148 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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.
+*/
+
+/*
+**
+** @author Taikyung, Yu(taikyung.yu@samsung.com)
+** @date 2011-07-06
+*/
+
+#define LOG_TAG "libhdmiclient"
+
+#include "SecHdmiClient.h"
+
+namespace android {
+
+static sp<ISecTVOut> g_SecTVOutService = 0;
+
+SecHdmiClient::SecHdmiClient()
+{
+ g_SecTVOutService = m_getSecTVOutService();
+ mEnable = 0;
+}
+
+SecHdmiClient::~SecHdmiClient()
+{
+}
+
+SecHdmiClient * SecHdmiClient::getInstance(void)
+{
+ static SecHdmiClient singleton;
+ return &singleton;
+}
+
+void SecHdmiClient::setHdmiCableStatus(int status)
+{
+ //LOGD("%s HDMI status: %d\n", __func__, status);
+
+ if (g_SecTVOutService != 0)
+ g_SecTVOutService->setHdmiCableStatus(status);
+}
+
+void SecHdmiClient::setHdmiMode(int mode)
+{
+ //LOGD("%s HDMI Mode: %d\n", __func__, mode);
+
+ if (g_SecTVOutService != 0)
+ g_SecTVOutService->setHdmiMode(mode);
+}
+
+void SecHdmiClient::setHdmiResolution(int resolution)
+{
+ //LOGD("%s HDMI Resolution: %d\n", __func__, resolution);
+
+ if (g_SecTVOutService != 0)
+ g_SecTVOutService->setHdmiResolution(resolution);
+}
+
+void SecHdmiClient::setHdmiHdcp(int enHdcp)
+{
+ //LOGD("%s HDMI HDCP: %d\n", __func__, enHdcp);
+
+ if (g_SecTVOutService != 0)
+ g_SecTVOutService->setHdmiHdcp(enHdcp);
+}
+
+void SecHdmiClient::setHdmiRotate(int rotVal, uint32_t hwcLayer)
+{
+ //LOGD("%s HDMI ROTATE: %d\n", __func__, rotVal);
+
+ if (g_SecTVOutService != 0)
+ g_SecTVOutService->setHdmiRotate(rotVal, hwcLayer);
+}
+
+void SecHdmiClient::setHdmiHwcLayer(uint32_t hwcLayer)
+{
+ //LOGD("%s HDMI HWCLAYER: %d\n", __func__, hwcLayer);
+
+ if (g_SecTVOutService != 0)
+ g_SecTVOutService->setHdmiHwcLayer(hwcLayer);
+}
+
+void SecHdmiClient::setHdmiEnable(uint32_t enable)
+{
+ //LOGD("%s HDMI ENABLE: %d\n", __func__, enable);
+
+ if (g_SecTVOutService != 0)
+ mEnable = enable;
+}
+
+void SecHdmiClient::blit2Hdmi(uint32_t w, uint32_t h,
+ uint32_t colorFormat,
+ uint32_t physYAddr,
+ uint32_t physCbAddr,
+ uint32_t physCrAddr,
+ uint32_t dstX,
+ uint32_t dstY,
+ uint32_t hdmiLayer,
+ uint32_t num_of_hwc_layer)
+{
+ if (g_SecTVOutService != 0 && mEnable == 1)
+ g_SecTVOutService->blit2Hdmi(w, h, colorFormat, physYAddr, physCbAddr, physCrAddr, dstX, dstY, hdmiLayer, num_of_hwc_layer);
+}
+
+sp<ISecTVOut> SecHdmiClient::m_getSecTVOutService(void)
+{
+ int ret = 0;
+
+ if (g_SecTVOutService == 0) {
+ sp<IBinder> binder;
+ sp<ISecTVOut> sc;
+ sp<IServiceManager> sm = defaultServiceManager();
+ int getSvcTimes = 0;
+ for(getSvcTimes = 0; getSvcTimes < GETSERVICETIMEOUT; getSvcTimes++) {
+ binder = sm->getService(String16("SecTVOutService"));
+ if (binder == 0) {
+ LOGW("SecTVOutService not published, waiting...");
+ usleep(500000); // 0.5 s
+ } else {
+ break;
+ }
+ }
+ // grab the lock again for updating g_surfaceFlinger
+ if (getSvcTimes < GETSERVICETIMEOUT) {
+ sc = interface_cast<ISecTVOut>(binder);
+ g_SecTVOutService = sc;
+ } else {
+ LOGW("Failed to get SecTVOutService... SecHdmiClient will get it later..");
+ }
+ }
+ return g_SecTVOutService;
+}
+
+}
diff --git a/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.h b/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.h
new file mode 100644
index 0000000..ebee763
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.h
@@ -0,0 +1,86 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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.
+*/
+
+/*
+**
+** @author Taikyung, Yu(taikyung.yu@samsung.com)
+** @date 2011-07-06
+*/
+
+#ifndef __SEC_HDMI_CLIENT_H__
+#define __SEC_HDMI_CLIENT_H__
+
+#include "utils/Log.h"
+
+#include <linux/errno.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <utils/RefBase.h>
+#include <cutils/log.h>
+#include <binder/IBinder.h>
+#include <binder/IServiceManager.h>
+#include <surfaceflinger/ISurfaceComposer.h>
+#include <surfaceflinger/SurfaceComposerClient.h>
+#include "ISecTVOut.h"
+
+#define GETSERVICETIMEOUT (5)
+
+namespace android {
+
+class SecHdmiClient
+{
+public:
+ enum HDMI_MODE
+ {
+ HDMI_MODE_NONE = 0,
+ HDMI_MODE_UI,
+ HDMI_MODE_VIDEO,
+ };
+
+private:
+ SecHdmiClient();
+ virtual ~SecHdmiClient();
+ uint32_t mEnable;
+
+public:
+ static SecHdmiClient * getInstance(void);
+ void setHdmiCableStatus(int status);
+ void setHdmiMode(int mode);
+ void setHdmiResolution(int resolution);
+ void setHdmiHdcp(int enHdcp);
+ void setHdmiRotate(int rotVal, uint32_t hwcLayer);
+ void setHdmiHwcLayer(uint32_t hwcLayer);
+ void setHdmiEnable(uint32_t enable);
+ virtual void blit2Hdmi(uint32_t w, uint32_t h,
+ uint32_t colorFormat,
+ uint32_t physYAddr,
+ uint32_t physCbAddr,
+ uint32_t physCrAddr,
+ uint32_t dstX,
+ uint32_t dstY,
+ uint32_t hdmiLayer,
+ uint32_t num_of_hwc_layer);
+
+private:
+ sp<ISecTVOut> m_getSecTVOutService(void);
+
+};
+
+};
+
+#endif
diff --git a/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.cpp b/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.cpp
new file mode 100644
index 0000000..de98810
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.cpp
@@ -0,0 +1,387 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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.
+*/
+
+/*
+**
+** @author Taikyung, Yu(taikyung.yu@samsung.com)
+** @date 2011-07-06
+*/
+
+#define LOG_TAG "SecTVOutService"
+
+#include <binder/IServiceManager.h>
+#include <utils/RefBase.h>
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <utils/Log.h>
+#include "SecTVOutService.h"
+#include <linux/fb.h>
+
+namespace android {
+#define DEFAULT_LCD_WIDTH 800
+#define DEFAULT_LCD_HEIGHT 480
+
+#define DIRECT_VIDEO_RENDERING (1)
+#define DIRECT_UI_RENDERING (0)
+
+ enum {
+ SET_HDMI_STATUS = IBinder::FIRST_CALL_TRANSACTION,
+ SET_HDMI_MODE,
+ SET_HDMI_RESOLUTION,
+ SET_HDMI_HDCP,
+ SET_HDMI_ROTATE,
+ SET_HDMI_HWCLAYER,
+ BLIT_2_HDMI
+ };
+
+ int SecTVOutService::HdmiFlushThread()
+ {
+ while (!mExitHdmiFlushThread) {
+ nsecs_t timeout = -1;
+ sp<MessageBase> msg = mHdmiEventQueue.waitMessage(timeout);
+ }
+
+ return 0;
+ }
+
+ int SecTVOutService::instantiate()
+ {
+ LOGD("SecTVOutService instantiate");
+ int r = defaultServiceManager()->addService(String16( "SecTVOutService"), new SecTVOutService ());
+ LOGD("SecTVOutService r=%d", r);
+
+ return r;
+ }
+
+ SecTVOutService::SecTVOutService () {
+ LOGV("SecTVOutService created");
+ mHdmiCableInserted = false;
+#ifdef SUPPORT_G2D_UI_MODE
+ mUILayerMode = SecHdmi::HDMI_LAYER_GRAPHIC_1;
+#else
+ mUILayerMode = SecHdmi::HDMI_LAYER_VIDEO;
+#endif
+ mHwcLayer = 0;
+ mExitHdmiFlushThread = false;
+
+ setLCDsize();
+ if (mSecHdmi.create(mLCD_width, mLCD_height) == false)
+ LOGE("%s::mSecHdmi.create() fail", __func__);
+ else
+ setHdmiStatus(1);
+
+ mHdmiFlushThread = new HDMIFlushThread(this);
+ }
+
+ void SecTVOutService::setLCDsize(void) {
+ char const * const device_template[] = {
+ "/dev/graphics/fb%u",
+ "/dev/fb%u",
+ 0 };
+
+ int fd = -1;
+ int i = 0;
+ char name[64];
+
+ while ((fd==-1) && device_template[i]) {
+ snprintf(name, 64, device_template[i], 0);
+ fd = open(name, O_RDWR, 0);
+ i++;
+ }
+ if (fd > 0) {
+ struct fb_var_screeninfo info;
+ if (ioctl(fd, FBIOGET_VSCREENINFO, &info) != -1) {
+ mLCD_width = info.xres;
+ mLCD_height = info.yres;
+ } else {
+ mLCD_width = DEFAULT_LCD_WIDTH;
+ mLCD_height = DEFAULT_LCD_HEIGHT;
+ }
+ close(fd);
+ }
+ return;
+ }
+
+ SecTVOutService::~SecTVOutService () {
+ LOGV ("SecTVOutService destroyed");
+
+ if (mHdmiFlushThread != NULL) {
+ mHdmiFlushThread->requestExit();
+ mExitHdmiFlushThread = true;
+ mHdmiFlushThread->requestExitAndWait();
+ mHdmiFlushThread.clear();
+ }
+ }
+
+ status_t SecTVOutService::onTransact(uint32_t code, const Parcel & data, Parcel * reply, uint32_t flags)
+ {
+ switch (code) {
+ case SET_HDMI_STATUS: {
+ int status = data.readInt32();
+ setHdmiStatus(status);
+ } break;
+
+ case SET_HDMI_MODE: {
+ int mode = data.readInt32();
+ setHdmiMode(mode);
+ } break;
+
+ case SET_HDMI_RESOLUTION: {
+ int resolution = data.readInt32();
+ setHdmiResolution(resolution);
+ } break;
+
+ case SET_HDMI_HDCP: {
+ int enHdcp = data.readInt32();
+ setHdmiHdcp(enHdcp);
+ } break;
+
+ case SET_HDMI_ROTATE: {
+ int rotVal = data.readInt32();
+ int hwcLayer = data.readInt32();
+ setHdmiRotate(rotVal, hwcLayer);
+ } break;
+
+ case SET_HDMI_HWCLAYER: {
+ int hwcLayer = data.readInt32();
+ setHdmiHwcLayer((uint32_t)hwcLayer);
+ } break;
+
+ case BLIT_2_HDMI: {
+ uint32_t w = data.readInt32();
+ uint32_t h = data.readInt32();
+ uint32_t colorFormat = data.readInt32();
+ uint32_t physYAddr = data.readInt32();
+ uint32_t physCbAddr = data.readInt32();
+ uint32_t physCrAddr = data.readInt32();
+ uint32_t dstX = data.readInt32();
+ uint32_t dstY = data.readInt32();
+ uint32_t hdmiLayer = data.readInt32();
+ uint32_t num_of_hwc_layer = data.readInt32();
+
+ blit2Hdmi(w, h, colorFormat, physYAddr, physCbAddr, physCrAddr, dstX, dstY, hdmiLayer, num_of_hwc_layer);
+ } break;
+
+ default :
+ LOGE ( "onTransact::default");
+ return BBinder::onTransact (code, data, reply, flags);
+ }
+
+ return NO_ERROR;
+ }
+
+ void SecTVOutService::setHdmiStatus(uint32_t status)
+ {
+
+ LOGD("%s HDMI cable status = %d", __func__, status);
+ {
+ Mutex::Autolock _l(mLock);
+
+ bool hdmiCableInserted = (bool)status;
+
+ if (mHdmiCableInserted == hdmiCableInserted)
+ return;
+
+ if (hdmiCableInserted == true) {
+ if (mSecHdmi.connect() == false) {
+ LOGE("%s::mSecHdmi.connect() fail", __func__);
+ hdmiCableInserted = false;
+ }
+ } else {
+ if (mSecHdmi.disconnect() == false)
+ LOGE("%s::mSecHdmi.disconnect() fail", __func__);
+ }
+
+ mHdmiCableInserted = hdmiCableInserted;
+ }
+
+ if (hdmiCableInserted() == true)
+ this->blit2Hdmi(mLCD_width, mLCD_height, HAL_PIXEL_FORMAT_BGRA_8888, 0, 0, 0, 0, 0, HDMI_MODE_UI, 0);
+ }
+
+ void SecTVOutService::setHdmiMode(uint32_t mode)
+ {
+ LOGD("%s TV mode = %d", __func__, mode);
+ Mutex::Autolock _l(mLock);
+
+ if ((hdmiCableInserted() == true) && (mSecHdmi.setHdmiOutputMode(mode)) == false) {
+ LOGE("%s::mSecHdmi.setHdmiOutputMode() fail", __func__);
+ return;
+ }
+ }
+
+ void SecTVOutService::setHdmiResolution(uint32_t resolution)
+ {
+ //LOGD("%s TV resolution = %d", __func__, resolution);
+ Mutex::Autolock _l(mLock);
+
+ if ((hdmiCableInserted() == true) && (mSecHdmi.setHdmiResolution(resolution)) == false) {
+ LOGE("%s::mSecHdmi.setHdmiResolution() fail", __func__);
+ return;
+ }
+ }
+
+ void SecTVOutService::setHdmiHdcp(uint32_t hdcp_en)
+ {
+ LOGD("%s TV HDCP = %d", __func__, hdcp_en);
+ Mutex::Autolock _l(mLock);
+
+ if ((hdmiCableInserted() == true) && (mSecHdmi.setHdcpMode(hdcp_en)) == false) {
+ LOGE("%s::mSecHdmi.setHdcpMode() fail", __func__);
+ return;
+ }
+ }
+
+ void SecTVOutService::setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer)
+ {
+ //LOGD("%s TV ROTATE = %d", __func__, rotVal);
+ Mutex::Autolock _l(mLock);
+
+ if ((hdmiCableInserted() == true) && (mSecHdmi.setUIRotation(rotVal, hwcLayer)) == false) {
+ LOGE("%s::mSecHdmi.setUIRotation() fail", __func__);
+ return;
+ }
+ }
+
+ void SecTVOutService::setHdmiHwcLayer(uint32_t hwcLayer)
+ {
+ //LOGD("%s TV HWCLAYER = %d", __func__, hwcLayer);
+ Mutex::Autolock _l(mLock);
+
+ mHwcLayer = hwcLayer;
+ return;
+ }
+
+ void SecTVOutService::blit2Hdmi(uint32_t w, uint32_t h, uint32_t colorFormat,
+ uint32_t pPhyYAddr, uint32_t pPhyCbAddr, uint32_t pPhyCrAddr,
+ uint32_t dstX, uint32_t dstY,
+ uint32_t hdmiMode,
+ uint32_t num_of_hwc_layer)
+ {
+ Mutex::Autolock _l(mLock);
+
+ if (hdmiCableInserted() == false)
+ return;
+
+ int hdmiLayer = SecHdmi::HDMI_LAYER_VIDEO;
+#if defined(CHECK_UI_TIME) || defined(CHECK_VIDEO_TIME)
+ nsecs_t start, end;
+#endif
+
+ sp<MessageBase> msg;
+
+ switch (hdmiMode) {
+ case HDMI_MODE_UI :
+ if (mHwcLayer >= 2)
+ hdmiLayer = SecHdmi::HDMI_LAYER_GRAPHIC_0;
+ else if (mHwcLayer == 1)
+ hdmiLayer = SecHdmi::HDMI_LAYER_GRAPHIC_1;
+ else
+#ifdef SUPPORT_G2D_UI_MODE
+ hdmiLayer = SecHdmi::HDMI_LAYER_GRAPHIC_1;
+#else
+ hdmiLayer = SecHdmi::HDMI_LAYER_VIDEO;
+#endif
+
+#ifdef SUPPORT_G2D_UI_MODE
+ if (mHwcLayer == 0) {
+ if (mSecHdmi.clear(SecHdmi::HDMI_LAYER_VIDEO) == false)
+ LOGE("%s::mSecHdmi.clear(%d) fail", __func__, SecHdmi::HDMI_LAYER_VIDEO);
+ if (mSecHdmi.clear(SecHdmi::HDMI_LAYER_GRAPHIC_0) == false)
+ LOGE("%s::mSecHdmi.clear(%d) fail", __func__, SecHdmi::HDMI_LAYER_GRAPHIC_0);
+ }
+#endif
+
+ if (mUILayerMode != hdmiLayer) {
+ if (mSecHdmi.clear(mUILayerMode) == false)
+ LOGE("%s::mSecHdmi.clear(%d) fail", __func__, mUILayerMode);
+ }
+
+ mUILayerMode = hdmiLayer;
+
+#if !defined(BOARD_USES_HDMI_SUBTITLES)
+ if (mHwcLayer == 0)
+#endif
+#if (DIRECT_UI_RENDERING == 1)
+ {
+#ifdef CHECK_UI_TIME
+ start = systemTime();
+#endif
+ if (mSecHdmi.flush(w, h, colorFormat, pPhyYAddr, pPhyCbAddr, pPhyCrAddr, dstX, dstY,
+ mUILayerMode, mHwcLayer) == false)
+ LOGE("%s::mSecHdmi.flush() on HDMI_MODE_UI fail", __func__);
+#ifdef CHECK_UI_TIME
+ end = systemTime();
+ LOGD("[UI] mSecHdmi.flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+#endif
+ }
+#else
+ {
+ msg = new SecHdmiEventMsg(&mSecHdmi, w, h, colorFormat, pPhyYAddr, pPhyCbAddr, pPhyCrAddr,
+ dstX, dstY, mUILayerMode, mHwcLayer, HDMI_MODE_UI);
+
+ /* post to HdmiEventQueue */
+ mHdmiEventQueue.postMessage(msg, 0, 0);
+ }
+#endif
+ break;
+
+ case HDMI_MODE_VIDEO :
+#if !defined(BOARD_USES_HDMI_SUBTITLES)
+#ifdef SUPPORT_G2D_UI_MODE
+ if (mSecHdmi.clear(SecHdmi::HDMI_LAYER_GRAPHIC_0) == false)
+ LOGE("%s::mSecHdmi.clear(%d) fail", __func__, SecHdmi::HDMI_LAYER_GRAPHIC_0);
+ if (mSecHdmi.clear(SecHdmi::HDMI_LAYER_GRAPHIC_1) == false)
+ LOGE("%s::mSecHdmi.clear(%d) fail", __func__, SecHdmi::HDMI_LAYER_GRAPHIC_1);
+#endif
+#endif
+
+#if (DIRECT_VIDEO_RENDERING == 1)
+#ifdef CHECK_VIDEO_TIME
+ start = systemTime();
+#endif
+ if (mSecHdmi.flush(w, h, colorFormat, pPhyYAddr, pPhyCbAddr, pPhyCrAddr, dstX, dstY,
+ SecHdmi::HDMI_LAYER_VIDEO, mHwcLayer) == false)
+ LOGE("%s::mSecHdmi.flush() on HDMI_MODE_VIDEO fail", __func__);
+#ifdef CHECK_VIDEO_TIME
+ end = systemTime();
+ LOGD("[Video] mSecHdmi.flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+#endif
+#else
+ msg = new SecHdmiEventMsg(&mSecHdmi, w, h, colorFormat, pPhyYAddr, pPhyCbAddr, pPhyCrAddr,
+ dstX, dstY, SecHdmi::HDMI_LAYER_VIDEO, mHwcLayer, HDMI_MODE_VIDEO);
+
+ /* post to HdmiEventQueue */
+ mHdmiEventQueue.postMessage(msg, 0, 0);
+#endif
+ break;
+
+ default:
+ LOGE("unmatched HDMI_MODE : %d", hdmiMode);
+ break;
+ }
+
+ return;
+ }
+
+ bool SecTVOutService::hdmiCableInserted(void)
+ {
+ return mHdmiCableInserted;
+ }
+
+}
diff --git a/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.h b/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.h
new file mode 100644
index 0000000..1f5f251
--- /dev/null
+++ b/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.h
@@ -0,0 +1,174 @@
+/*
+**
+** Copyright 2008, The Android Open Source Project
+** 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.
+*/
+
+/*
+**
+** @author Taikyung, Yu(taikyung.yu@samsung.com)
+** @date 2011-07-06
+*/
+
+#ifndef SECTVOUTSERVICE_H
+#define SECTVOUTSERVICE_H
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <binder/Parcel.h>
+#include <utils/KeyedVector.h>
+
+#include "ISecTVOut.h"
+#include "SecHdmi.h"
+#include "sec_format.h"
+#include "sec_utils.h"
+#include "MessageQueue.h"
+
+namespace android {
+//#define CHECK_VIDEO_TIME
+//#define CHECK_UI_TIME
+
+ class SecTVOutService : public BBinder
+ {
+ public :
+ enum {
+ HDMI_MODE_NONE = 0,
+ HDMI_MODE_UI,
+ HDMI_MODE_VIDEO,
+ };
+
+ mutable Mutex mLock;
+
+ class HDMIFlushThread : public Thread {
+ SecTVOutService *mTVOutService;
+ public:
+ HDMIFlushThread(SecTVOutService *service):
+ Thread(false),
+ mTVOutService(service) { }
+ virtual void onFirstRef() {
+ run("HDMIFlushThread", PRIORITY_URGENT_DISPLAY);
+ }
+ virtual bool threadLoop() {
+ mTVOutService->HdmiFlushThread();
+ return false;
+ }
+ };
+
+ sp<HDMIFlushThread> mHdmiFlushThread;
+ int HdmiFlushThread();
+
+ mutable MessageQueue mHdmiEventQueue;
+ bool mExitHdmiFlushThread;
+
+ SecTVOutService();
+ static int instantiate ();
+ virtual status_t onTransact(uint32_t, const Parcel &, Parcel *, uint32_t);
+ virtual ~SecTVOutService ();
+
+ virtual void setHdmiStatus(uint32_t status);
+ virtual void setHdmiMode(uint32_t mode);
+ virtual void setHdmiResolution(uint32_t resolution);
+ virtual void setHdmiHdcp(uint32_t enHdcp);
+ virtual void setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer);
+ virtual void setHdmiHwcLayer(uint32_t hwcLayer);
+ virtual void blit2Hdmi(uint32_t w, uint32_t h,
+ uint32_t colorFormat,
+ uint32_t pPhyYAddr, uint32_t pPhyCbAddr, uint32_t pPhyCrAddr,
+ uint32_t dstX, uint32_t dstY,
+ uint32_t hdmiMode, uint32_t num_of_hwc_layer);
+ bool hdmiCableInserted(void);
+ void setLCDsize(void);
+
+ private:
+ SecHdmi mSecHdmi;
+ bool mHdmiCableInserted;
+ int mUILayerMode;
+ uint32_t mLCD_width, mLCD_height;
+ uint32_t mHwcLayer;
+ };
+
+ class SecHdmiEventMsg : public MessageBase {
+ public:
+ enum {
+ HDMI_MODE_NONE = 0,
+ HDMI_MODE_UI,
+ HDMI_MODE_VIDEO,
+ };
+
+ mutable Mutex mBlitLock;
+
+ SecHdmi *pSecHdmi;
+ uint32_t mSrcWidth, mSrcHeight;
+ uint32_t mSrcColorFormat;
+ uint32_t mSrcYAddr, mSrcCbAddr, mSrcCrAddr;
+ uint32_t mDstX, mDstY;
+ uint32_t mHdmiMode;
+ uint32_t mHdmiLayer, mHwcLayer;
+
+ SecHdmiEventMsg(SecHdmi *SecHdmi, uint32_t srcWidth, uint32_t srcHeight, uint32_t srcColorFormat,
+ uint32_t srcYAddr, uint32_t srcCbAddr, uint32_t srcCrAddr,
+ uint32_t dstX, uint32_t dstY, uint32_t hdmiLayer, uint32_t hwcLayer, uint32_t hdmiMode)
+ : pSecHdmi(SecHdmi), mSrcWidth(srcWidth), mSrcHeight(srcHeight), mSrcColorFormat(srcColorFormat),
+ mSrcYAddr(srcYAddr), mSrcCbAddr(srcCbAddr), mSrcCrAddr(srcCrAddr),
+ mDstX(dstX), mDstY(dstY), mHdmiLayer(hdmiLayer), mHwcLayer(hwcLayer), mHdmiMode(hdmiMode) {
+ }
+
+ virtual bool handler() {
+ Mutex::Autolock _l(mBlitLock);
+ bool ret = true;
+#if defined(CHECK_UI_TIME) || defined(CHECK_VIDEO_TIME)
+ nsecs_t start, end;
+#endif
+
+ switch (mHdmiMode) {
+ case HDMI_MODE_UI:
+#ifdef CHECK_UI_TIME
+ start = systemTime();
+#endif
+ if (pSecHdmi->flush(mSrcWidth, mSrcHeight, mSrcColorFormat, mSrcYAddr, mSrcCbAddr, mSrcCrAddr,
+ mDstX, mDstY, mHdmiLayer, mHwcLayer) == false) {
+ LOGE("%s::pSecHdmi->flush() fail on HDMI_MODE_UI", __func__);
+ ret = false;
+ }
+#ifdef CHECK_UI_TIME
+ end = systemTime();
+ LOGD("[UI] pSecHdmi->flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+#endif
+ break;
+ case HDMI_MODE_VIDEO:
+#ifdef CHECK_VIDEO_TIME
+ start = systemTime();
+#endif
+ if (pSecHdmi->flush(mSrcWidth, mSrcHeight, mSrcColorFormat, mSrcYAddr, mSrcCbAddr, mSrcCrAddr,
+ mDstX, mDstY, mHdmiLayer, mHwcLayer) == false) {
+ LOGE("%s::pSecHdmi->flush() fail on HDMI_MODE_VIDEO", __func__);
+ ret = false;
+ }
+#ifdef CHECK_VIDEO_TIME
+ end = systemTime();
+ LOGD("[VIDEO] pSecHdmi->flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+#endif
+ break;
+ default:
+ LOGE("Undefined HDMI_MODE");
+ ret = false;
+ break;
+ }
+ return ret;
+ }
+ };
+
+};
+#endif
diff --git a/exynos4/Android.mk b/exynos4/hal/libhdmi/libsForhdmi/Android.mk
similarity index 67%
copy from exynos4/Android.mk
copy to exynos4/hal/libhdmi/libsForhdmi/Android.mk
index 3c99f1a..237c53c 100644
--- a/exynos4/Android.mk
+++ b/exynos4/hal/libhdmi/libsForhdmi/Android.mk
@@ -1,4 +1,4 @@
-# Copyright (C) 2012 The Android Open Source Project
+# 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.
@@ -12,12 +12,6 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-ifeq ($(TARGET_BOARD_PLATFORM),exynos4)
-
-BOARD_HAL_PATH := hardware/samsung/exynos4/hal
-BOARD_HMM_PATH := hardware/samsung/exynos4/multimedia
-
-include $(BOARD_HAL_PATH)/Android.mk
-include $(BOARD_HMM_PATH)/Android.mk
-
+ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
+include $(all-subdir-makefiles)
endif
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libcec/Android.mk b/exynos4/hal/libhdmi/libsForhdmi/libcec/Android.mk
new file mode 100644
index 0000000..9a4b721
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libcec/Android.mk
@@ -0,0 +1,33 @@
+# 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.
+
+ifeq ($(BOARD_USES_HDMI),true)
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := eng
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_SHARED_LIBRARIES := liblog
+LOCAL_SRC_FILES := libcec.c
+
+LOCAL_C_INCLUDES := \
+ $(LOCAL_PATH) \
+ $(LOCAL_PATH)/../../../include
+
+LOCAL_MODULE := libcec
+include $(BUILD_SHARED_LIBRARY)
+
+endif
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libcec/cec.h b/exynos4/hal/libhdmi/libsForhdmi/libcec/cec.h
new file mode 100644
index 0000000..4b0d3af
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libcec/cec.h
@@ -0,0 +1,11 @@
+#ifndef _LINUX_CEC_H_
+#define _LINUX_CEC_H_
+
+#define CEC_IOC_MAGIC 'c'
+
+/**
+ * CEC device request code to set logical address.
+ */
+#define CEC_IOC_SETLADDR _IOW(CEC_IOC_MAGIC, 0, unsigned int)
+
+#endif /* _LINUX_CEC_H_ */
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libcec/libcec.c b/exynos4/hal/libhdmi/libsForhdmi/libcec/libcec.c
new file mode 100644
index 0000000..e688051
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libcec/libcec.c
@@ -0,0 +1,386 @@
+/*
+* 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.
+*/
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <cutils/log.h>
+
+/* drv. header */
+#include "cec.h"
+
+#include "libcec.h"
+
+#define CEC_DEBUG 0
+
+/**
+ * @def CEC_DEVICE_NAME
+ * Defines simbolic name of the CEC device.
+ */
+#define CEC_DEVICE_NAME "/dev/CEC"
+
+static struct {
+ enum CECDeviceType devtype;
+ unsigned char laddr;
+} laddresses[] = {
+ { CEC_DEVICE_RECODER, 1 },
+ { CEC_DEVICE_RECODER, 2 },
+ { CEC_DEVICE_TUNER, 3 },
+ { CEC_DEVICE_PLAYER, 4 },
+ { CEC_DEVICE_AUDIO, 5 },
+ { CEC_DEVICE_TUNER, 6 },
+ { CEC_DEVICE_TUNER, 7 },
+ { CEC_DEVICE_PLAYER, 8 },
+ { CEC_DEVICE_RECODER, 9 },
+ { CEC_DEVICE_TUNER, 10 },
+ { CEC_DEVICE_PLAYER, 11 },
+};
+
+static int CECSetLogicalAddr(unsigned int laddr);
+
+#ifdef CEC_DEBUG
+inline static void CECPrintFrame(unsigned char *buffer, unsigned int size);
+#endif
+
+static int fd = -1;
+
+/**
+ * Open device driver and assign CEC file descriptor.
+ *
+ * @return If success to assign CEC file descriptor, return 1; otherwise, return 0.
+ */
+int CECOpen()
+{
+ int res = 1;
+
+ if (fd != -1)
+ CECClose();
+
+ if ((fd = open(CEC_DEVICE_NAME, O_RDWR)) < 0) {
+ LOGE("Can't open %s!\n", CEC_DEVICE_NAME);
+ res = 0;
+ }
+
+ return res;
+}
+
+/**
+ * Close CEC file descriptor.
+ *
+ * @return If success to close CEC file descriptor, return 1; otherwise, return 0.
+ */
+int CECClose()
+{
+ int res = 1;
+
+ if (fd != -1) {
+ if (close(fd) != 0) {
+ LOGE("close() failed!\n");
+ res = 0;
+ }
+ fd = -1;
+ }
+
+ return res;
+}
+
+/**
+ * Allocate logical address.
+ *
+ * @param paddr [in] CEC device physical address.
+ * @param devtype [in] CEC device type.
+ *
+ * @return new logical address, or 0 if an arror occured.
+ */
+int CECAllocLogicalAddress(int paddr, enum CECDeviceType devtype)
+{
+ unsigned char laddr = CEC_LADDR_UNREGISTERED;
+ int i = 0;
+
+ if (fd == -1) {
+ LOGE("open device first!\n");
+ return 0;
+ }
+
+ if (CECSetLogicalAddr(laddr) < 0) {
+ LOGE("CECSetLogicalAddr() failed!\n");
+ return 0;
+ }
+
+ if (paddr == CEC_NOT_VALID_PHYSICAL_ADDRESS)
+ return CEC_LADDR_UNREGISTERED;
+
+ /* send "Polling Message" */
+ while (i < sizeof(laddresses)/sizeof(laddresses[0])) {
+ if (laddresses[i].devtype == devtype) {
+ unsigned char _laddr = laddresses[i].laddr;
+ unsigned char message = ((_laddr << 4) | _laddr);
+ if (CECSendMessage(&message, 1) != 1) {
+ laddr = _laddr;
+ break;
+ }
+ }
+ i++;
+ }
+
+ if (laddr == CEC_LADDR_UNREGISTERED) {
+ LOGE("All LA addresses in use!!!\n");
+ return CEC_LADDR_UNREGISTERED;
+ }
+
+ if (CECSetLogicalAddr(laddr) < 0) {
+ LOGE("CECSetLogicalAddr() failed!\n");
+ return 0;
+ }
+
+ /* broadcast "Report Physical Address" */
+ unsigned char buffer[5];
+ buffer[0] = (laddr << 4) | CEC_MSG_BROADCAST;
+ buffer[1] = CEC_OPCODE_REPORT_PHYSICAL_ADDRESS;
+ buffer[2] = (paddr >> 8) & 0xFF;
+ buffer[3] = paddr & 0xFF;
+ buffer[4] = devtype;
+
+ if (CECSendMessage(buffer, 5) != 5) {
+ LOGE("CECSendMessage() failed!\n");
+ return 0;
+ }
+
+ return laddr;
+}
+
+/**
+ * Send CEC message.
+ *
+ * @param *buffer [in] pointer to buffer address where message located.
+ * @param size [in] message size.
+ *
+ * @return number of bytes written, or 0 if an arror occured.
+ */
+int CECSendMessage(unsigned char *buffer, int size)
+{
+ if (fd == -1) {
+ LOGE("open device first!\n");
+ return 0;
+ }
+
+ if (size > CEC_MAX_FRAME_SIZE) {
+ LOGE("size should not exceed %d\n", CEC_MAX_FRAME_SIZE);
+ return 0;
+ }
+
+#if CEC_DEBUG
+ LOGI("CECSendMessage() : ");
+ CECPrintFrame(buffer, size);
+#endif
+
+ return write(fd, buffer, size);
+}
+
+/**
+ * Receive CEC message.
+ *
+ * @param *buffer [in] pointer to buffer address where message will be stored.
+ * @param size [in] buffer size.
+ * @param timeout [in] timeout in microseconds.
+ *
+ * @return number of bytes received, or 0 if an arror occured.
+ */
+int CECReceiveMessage(unsigned char *buffer, int size, long timeout)
+{
+ int bytes = 0;
+ fd_set rfds;
+ struct timeval tv;
+ int retval;
+
+ if (fd == -1) {
+ LOGE("open device first!\n");
+ return 0;
+ }
+
+ tv.tv_sec = 0;
+ tv.tv_usec = timeout;
+
+ FD_ZERO(&rfds);
+ FD_SET(fd, &rfds);
+
+ retval = select(fd + 1, &rfds, NULL, NULL, &tv);
+
+ if (retval == -1) {
+ return 0;
+ } else if (retval) {
+ bytes = read(fd, buffer, size);
+#if CEC_DEBUG
+ LOGI("CECReceiveMessage() : size(%d)", bytes);
+ if(bytes > 0)
+ CECPrintFrame(buffer, bytes);
+#endif
+ }
+
+ return bytes;
+}
+
+/**
+ * Set CEC logical address.
+ *
+ * @return 1 if success, otherwise, return 0.
+ */
+int CECSetLogicalAddr(unsigned int laddr)
+{
+ if (ioctl(fd, CEC_IOC_SETLADDR, &laddr)) {
+ LOGE("ioctl(CEC_IOC_SETLA) failed!\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+#if CEC_DEBUG
+/**
+ * Print CEC frame.
+ */
+void CECPrintFrame(unsigned char *buffer, unsigned int size)
+{
+ if (size > 0) {
+ int i;
+ LOGI("fsize: %d ", size);
+ LOGI("frame: ");
+ for (i = 0; i < size; i++)
+ LOGI("0x%02x ", buffer[i]);
+
+ LOGI("\n");
+ }
+}
+#endif
+
+/**
+ * Check CEC message.
+ *
+ * @param opcode [in] pointer to buffer address where message will be stored.
+ * @param lsrc [in] buffer size.
+ *
+ * @return 1 if message should be ignored, otherwise, return 0.
+ */
+//TODO: not finished
+int CECIgnoreMessage(unsigned char opcode, unsigned char lsrc)
+{
+ int retval = 0;
+
+ /* if a message coming from address 15 (unregistered) */
+ if (lsrc == CEC_LADDR_UNREGISTERED) {
+ switch (opcode) {
+ case CEC_OPCODE_DECK_CONTROL:
+ case CEC_OPCODE_PLAY:
+ retval = 1;
+ default:
+ break;
+ }
+ }
+
+ return retval;
+}
+
+/**
+ * Check CEC message.
+ *
+ * @param opcode [in] pointer to buffer address where message will be stored.
+ * @param size [in] message size.
+ *
+ * @return 0 if message should be ignored, otherwise, return 1.
+ */
+//TODO: not finished
+int CECCheckMessageSize(unsigned char opcode, int size)
+{
+ int retval = 1;
+
+ switch (opcode) {
+ case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
+ if (size != 1)
+ retval = 0;
+ break;
+ case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
+ if (size != 2)
+ retval = 0;
+ break;
+ case CEC_OPCODE_PLAY:
+ case CEC_OPCODE_DECK_CONTROL:
+ case CEC_OPCODE_SET_MENU_LANGUAGE:
+ case CEC_OPCODE_ACTIVE_SOURCE:
+ case CEC_OPCODE_ROUTING_INFORMATION:
+ case CEC_OPCODE_SET_STREAM_PATH:
+ if (size != 3)
+ retval = 0;
+ break;
+ case CEC_OPCODE_FEATURE_ABORT:
+ case CEC_OPCODE_DEVICE_VENDOR_ID:
+ case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
+ if (size != 4)
+ retval = 0;
+ break;
+ case CEC_OPCODE_ROUTING_CHANGE:
+ if (size != 5)
+ retval = 0;
+ break;
+ /* CDC - 1.4 */
+ case 0xf8:
+ if (!(size > 5 && size <= 16))
+ retval = 0;
+ break;
+ default:
+ break;
+ }
+
+ return retval;
+}
+
+/**
+ * Check CEC message.
+ *
+ * @param opcode [in] pointer to buffer address where message will be stored.
+ * @param broadcast [in] broadcast/direct message.
+ *
+ * @return 0 if message should be ignored, otherwise, return 1.
+ */
+//TODO: not finished
+int CECCheckMessageMode(unsigned char opcode, int broadcast)
+{
+ int retval = 1;
+
+ switch (opcode) {
+ case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
+ case CEC_OPCODE_SET_MENU_LANGUAGE:
+ case CEC_OPCODE_ACTIVE_SOURCE:
+ if (!broadcast)
+ retval = 0;
+ break;
+ case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
+ case CEC_OPCODE_DECK_CONTROL:
+ case CEC_OPCODE_PLAY:
+ case CEC_OPCODE_FEATURE_ABORT:
+ case CEC_OPCODE_ABORT:
+ if (broadcast)
+ retval = 0;
+ break;
+ default:
+ break;
+ }
+
+ return retval;
+}
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libcec/libcec.h b/exynos4/hal/libhdmi/libsForhdmi/libcec/libcec.h
new file mode 100644
index 0000000..5bbfc15
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libcec/libcec.h
@@ -0,0 +1,209 @@
+/*
+ * 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 _LIBCEC_H_
+#define _LIBCEC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Maximum CEC frame size */
+#define CEC_MAX_FRAME_SIZE 16
+/** Not valid CEC physical address */
+#define CEC_NOT_VALID_PHYSICAL_ADDRESS 0xFFFF
+
+/** CEC broadcast address (as destination address) */
+#define CEC_MSG_BROADCAST 0x0F
+/** CEC unregistered address (as initiator address) */
+#define CEC_LADDR_UNREGISTERED 0x0F
+
+/*
+ * CEC Messages
+ */
+
+//@{
+/** @name Messages for the One Touch Play Feature */
+#define CEC_OPCODE_ACTIVE_SOURCE 0x82
+#define CEC_OPCODE_IMAGE_VIEW_ON 0x04
+#define CEC_OPCODE_TEXT_VIEW_ON 0x0D
+//@}
+
+//@{
+/** @name Messages for the Routing Control Feature */
+#define CEC_OPCODE_INACTIVE_SOURCE 0x9D
+#define CEC_OPCODE_REQUEST_ACTIVE_SOURCE 0x85
+#define CEC_OPCODE_ROUTING_CHANGE 0x80
+#define CEC_OPCODE_ROUTING_INFORMATION 0x81
+#define CEC_OPCODE_SET_STREAM_PATH 0x86
+//@}
+
+//@{
+/** @name Messages for the Standby Feature */
+#define CEC_OPCODE_STANDBY 0x36
+//@}
+
+//@{
+/** @name Messages for the One Touch Record Feature */
+#define CEC_OPCODE_RECORD_OFF 0x0B
+#define CEC_OPCODE_RECORD_ON 0x09
+#define CEC_OPCODE_RECORD_STATUS 0x0A
+#define CEC_OPCODE_RECORD_TV_SCREEN 0x0F
+//@}
+
+//@{
+/** @name Messages for the Timer Programming Feature */
+#define CEC_OPCODE_CLEAR_ANALOGUE_TIMER 0x33
+#define CEC_OPCODE_CLEAR_DIGITAL_TIMER 0x99
+#define CEC_OPCODE_CLEAR_EXTERNAL_TIMER 0xA1
+#define CEC_OPCODE_SET_ANALOGUE_TIMER 0x34
+#define CEC_OPCODE_SET_DIGITAL_TIMER 0x97
+#define CEC_OPCODE_SET_EXTERNAL_TIMER 0xA2
+#define CEC_OPCODE_SET_TIMER_PROGRAM_TITLE 0x67
+#define CEC_OPCODE_TIMER_CLEARED_STATUS 0x43
+#define CEC_OPCODE_TIMER_STATUS 0x35
+//@}
+
+//@{
+/** @name Messages for the System Information Feature */
+#define CEC_OPCODE_CEC_VERSION 0x9E
+#define CEC_OPCODE_GET_CEC_VERSION 0x9F
+#define CEC_OPCODE_GIVE_PHYSICAL_ADDRESS 0x83
+#define CEC_OPCODE_GET_MENU_LANGUAGE 0x91
+//#define CEC_OPCODE_POLLING_MESSAGE
+#define CEC_OPCODE_REPORT_PHYSICAL_ADDRESS 0x84
+#define CEC_OPCODE_SET_MENU_LANGUAGE 0x32
+//@}
+
+//@{
+/** @name Messages for the Deck Control Feature */
+#define CEC_OPCODE_DECK_CONTROL 0x42
+#define CEC_OPCODE_DECK_STATUS 0x1B
+#define CEC_OPCODE_GIVE_DECK_STATUS 0x1A
+#define CEC_OPCODE_PLAY 0x41
+//@}
+
+//@{
+/** @name Messages for the Tuner Control Feature */
+#define CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS 0x08
+#define CEC_OPCODE_SELECT_ANALOGUE_SERVICE 0x92
+#define CEC_OPCODE_SELECT_DIGITAL_SERVICE 0x93
+#define CEC_OPCODE_TUNER_DEVICE_STATUS 0x07
+#define CEC_OPCODE_TUNER_STEP_DECREMENT 0x06
+#define CEC_OPCODE_TUNER_STEP_INCREMENT 0x05
+//@}
+
+//@{
+/** @name Messages for the Vendor Specific Commands Feature */
+#define CEC_OPCODE_DEVICE_VENDOR_ID 0x87
+#define CEC_OPCODE_GET_DEVICE_VENDOR_ID 0x8C
+#define CEC_OPCODE_VENDOR_COMMAND 0x89
+#define CEC_OPCODE_VENDOR_COMMAND_WITH_ID 0xA0
+#define CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN 0x8A
+#define CEC_OPCODE_VENDOR_REMOVE_BUTTON_UP 0x8B
+//@}
+
+//@{
+/** @name Messages for the OSD Display Feature */
+#define CEC_OPCODE_SET_OSD_STRING 0x64
+//@}
+
+//@{
+/** @name Messages for the Device OSD Transfer Feature */
+#define CEC_OPCODE_GIVE_OSD_NAME 0x46
+#define CEC_OPCODE_SET_OSD_NAME 0x47
+//@}
+
+//@{
+/** @name Messages for the Device Menu Control Feature */
+#define CEC_OPCODE_MENU_REQUEST 0x8D
+#define CEC_OPCODE_MENU_STATUS 0x8E
+#define CEC_OPCODE_USER_CONTROL_PRESSED 0x44
+#define CEC_OPCODE_USER_CONTROL_RELEASED 0x45
+//@}
+
+//@{
+/** @name Messages for the Remote Control Passthrough Feature */
+//@}
+
+//@{
+/** @name Messages for the Power Status Feature */
+#define CEC_OPCODE_GIVE_DEVICE_POWER_STATUS 0x8F
+#define CEC_OPCODE_REPORT_POWER_STATUS 0x90
+//@}
+
+//@{
+/** @name Messages for General Protocol messages */
+#define CEC_OPCODE_FEATURE_ABORT 0x00
+#define CEC_OPCODE_ABORT 0xFF
+//@}
+
+//@{
+/** @name Messages for the System Audio Control Feature */
+#define CEC_OPCODE_GIVE_AUDIO_STATUS 0x71
+#define CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS 0x7D
+#define CEC_OPCODE_REPORT_AUDIO_STATUS 0x7A
+#define CEC_OPCODE_SET_SYSTEM_AUDIO_MODE 0x72
+#define CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST 0x70
+#define CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS 0x7E
+//@}
+
+//@{
+/** @name Messages for the Audio Rate Control Feature */
+#define CEC_OPCODE_SET_AUDIO_RATE 0x9A
+//@}
+
+//@{
+/** @name CEC Operands */
+
+//TODO: not finished
+
+#define CEC_DECK_CONTROL_MODE_STOP 0x03
+#define CEC_PLAY_MODE_PLAY_FORWARD 0x24
+//@}
+
+/**
+ * @enum CECDeviceType
+ * Type of CEC device
+ */
+enum CECDeviceType {
+ /** TV */
+ CEC_DEVICE_TV,
+ /** Recording Device */
+ CEC_DEVICE_RECODER,
+ /** Tuner */
+ CEC_DEVICE_TUNER,
+ /** Playback Device */
+ CEC_DEVICE_PLAYER,
+ /** Audio System */
+ CEC_DEVICE_AUDIO,
+};
+
+int CECOpen();
+int CECClose();
+int CECAllocLogicalAddress(int paddr, enum CECDeviceType devtype);
+int CECSendMessage(unsigned char *buffer, int size);
+int CECReceiveMessage(unsigned char *buffer, int size, long timeout);
+
+int CECIgnoreMessage(unsigned char opcode, unsigned char lsrc);
+int CECCheckMessageSize(unsigned char opcode, int size);
+int CECCheckMessageMode(unsigned char opcode, int broadcast);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LIBCEC_H_ */
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libddc/Android.mk b/exynos4/hal/libhdmi/libsForhdmi/libddc/Android.mk
new file mode 100644
index 0000000..38891be
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libddc/Android.mk
@@ -0,0 +1,45 @@
+# 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.
+
+ifeq ($(BOARD_USES_HDMI),true)
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := eng
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_SHARED_LIBRARIES := liblog
+LOCAL_SRC_FILES := libddc.c
+
+LOCAL_C_INCLUDES := \
+ $(LOCAL_PATH) \
+ $(LOCAL_PATH)/../../../include
+
+ifeq ($(BOARD_HDMI_DDC_CH), DDC_CH_I2C_7)
+LOCAL_CFLAGS += -DDDC_CH_I2C_7
+endif
+
+ifeq ($(BOARD_HDMI_DDC_CH), DDC_CH_I2C_1)
+LOCAL_CFLAGS += -DDDC_CH_I2C_1
+endif
+
+ifeq ($(BOARD_HDMI_DDC_CH), DDC_CH_I2C_2)
+LOCAL_CFLAGS += -DDDC_CH_I2C_2
+endif
+
+LOCAL_MODULE := libddc
+include $(BUILD_SHARED_LIBRARY)
+
+endif
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libddc/libddc.c b/exynos4/hal/libhdmi/libsForhdmi/libddc/libddc.c
new file mode 100644
index 0000000..12910fb
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libddc/libddc.c
@@ -0,0 +1,285 @@
+/*
+* 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.
+*/
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <linux/i2c.h>
+#include <cutils/log.h>
+#include "i2c-dev.h"
+
+#include "libddc.h"
+
+#define DDC_DEBUG 0
+
+/**
+ * @brief DDC device name.
+ * User should change this.
+ */
+#ifdef DDC_CH_I2C_1
+#define DEV_NAME "/dev/i2c-1"
+#endif
+
+#ifdef DDC_CH_I2C_2
+#define DEV_NAME "/dev/i2c-2"
+#endif
+
+#ifdef DDC_CH_I2C_7
+#define DEV_NAME "/dev/i2c-7"
+#endif
+
+/**
+ * DDC file descriptor
+ */
+static int ddc_fd = -1;
+
+/**
+ * Reference count of DDC file descriptor
+ */
+static unsigned int ref_cnt = 0;
+
+/**
+ * Check if DDC file is already opened or not
+ * @return If DDC file is already opened, return 1; Otherwise, return 0.
+ */
+static int DDCFileAvailable()
+{
+ return (ddc_fd < 0) ? 0 : 1;
+}
+
+/**
+ * Initialze DDC library. Open DDC device
+ * @return If succeed in opening DDC device or it is already opened, return 1;@n
+ * Otherwise, return 0.
+ */
+int DDCOpen()
+{
+ int ret = 1;
+
+ // check already open??
+ if (ref_cnt > 0) {
+ ref_cnt++;
+ return 1;
+ }
+
+ // open
+ if ((ddc_fd = open(DEV_NAME,O_RDWR)) < 0) {
+ LOGE("%s: Cannot open I2C_DDC : %s",__func__, DEV_NAME);
+ ret = 0;
+ }
+
+ ref_cnt++;
+ return ret;
+}
+
+/**
+ * Finalize DDC library. Close DDC device
+ * @return If succeed in closing DDC device or it is being used yet, return 1;@n
+ * Otherwise, return 0.
+ */
+int DDCClose()
+{
+ int ret = 1;
+ // check if fd is available
+ if (ref_cnt == 0) {
+#if DDC_DEBUG
+ LOGE("%s: I2C_DDC is not available!!!!", __func__);
+#endif
+ return 1;
+ }
+
+ // close
+ if (ref_cnt > 1) {
+ ref_cnt--;
+ return 1;
+ }
+
+ if (close(ddc_fd) < 0) {
+#if DDC_DEBUG
+ LOGE("%s: Cannot close I2C_DDC : %s",__func__,DEV_NAME);
+#endif
+ ret = 0;
+ }
+
+ ref_cnt--;
+ ddc_fd = -1;
+
+ return ret;
+}
+
+/**
+ * Read data though DDC. For more information of DDC, refer DDC Spec.
+ * @param addr [in] Device address
+ * @param offset [in] Byte offset
+ * @param size [in] Sizes of data
+ * @param buffer [out] Pointer to buffer to store data
+ * @return If succeed in reading, return 1; Otherwise, return 0.
+ */
+int DDCRead(unsigned char addr, unsigned char offset,
+ unsigned int size, unsigned char* buffer)
+{
+ struct i2c_rdwr_ioctl_data msgset;
+ struct i2c_msg msgs[2];
+ int ret = 1;
+
+ if (!DDCFileAvailable()) {
+#if DDC_DEBUG
+ LOGE("%s: I2C_DDC is not available!!!!", __func__);
+#endif
+ return 0;
+ }
+
+ // set offset
+ msgs[0].addr = addr>>1;
+ msgs[0].flags = 0;
+ msgs[0].len = 1;
+ msgs[0].buf = &offset;
+
+ // read data
+ msgs[1].addr = addr>>1;
+ msgs[1].flags = I2C_M_RD;
+ msgs[1].len = size;
+ msgs[1].buf = buffer;
+
+ // set rdwr ioctl data
+ msgset.nmsgs = 2;
+ msgset.msgs = msgs;
+
+ // i2c fast read
+ if ((ret = ioctl(ddc_fd, I2C_RDWR, &msgset)) < 0) {
+ perror("ddc error:");
+ ret = 0;
+ }
+
+ return ret;
+}
+
+/**
+ * Read data though E-DDC. For more information of E-DDC, refer E-DDC Spec.
+ * @param segpointer [in] Segment pointer
+ * @param segment [in] Segment number
+ * @param addr [in] Device address
+ * @param offset [in] Byte offset
+ * @param size [in] Sizes of data
+ * @param buffer [out] Pointer to buffer to store data
+ * @return If succeed in reading, return 1; Otherwise, return 0.
+ */
+
+int EDDCRead(unsigned char segpointer, unsigned char segment, unsigned char addr,
+ unsigned char offset, unsigned int size, unsigned char* buffer)
+{
+ struct i2c_rdwr_ioctl_data msgset;
+ struct i2c_msg msgs[3];
+ int ret = 1;
+
+ if (!DDCFileAvailable()) {
+#if DDC_DEBUG
+ LOGE("%s: I2C_DDC is not available!!!!", __func__);
+#endif
+ return 0;
+ }
+
+ // set segment pointer
+ msgs[0].addr = segpointer>>1;
+ // ignore ack only if segment is "0"
+ if (segment == 0)
+ msgs[0].flags = I2C_M_IGNORE_NAK;
+ else
+ msgs[0].flags = 0;
+
+ msgs[0].len = 1;
+ msgs[0].buf = &segment;
+
+ // set offset
+ msgs[1].addr = addr>>1;
+ msgs[1].flags = 0;
+ msgs[1].len = 1;
+ msgs[1].buf = &offset;
+
+ // read data
+ msgs[2].addr = addr>>1;
+ msgs[2].flags = I2C_M_RD;
+ msgs[2].len = size;
+ msgs[2].buf = buffer;
+
+ msgset.nmsgs = 3;
+ msgset.msgs = msgs;
+
+ // eddc read
+ if (ioctl(ddc_fd, I2C_RDWR, &msgset) < 0) {
+#if DDC_DEBUG
+ LOGE("%s: ioctl(I2C_RDWR) failed!!!", __func__);
+#endif
+ ret = 0;
+ }
+ return ret;
+}
+
+/**
+ * Write data though DDC. For more information of DDC, refer DDC Spec.
+ * @param addr [in] Device address
+ * @param offset [in] Byte offset
+ * @param size [in] Sizes of data
+ * @param buffer [out] Pointer to buffer to write
+ * @return If succeed in writing, return 1; Otherwise, return 0.
+ */
+int DDCWrite(unsigned char addr, unsigned char offset, unsigned int size, unsigned char* buffer)
+{
+ unsigned char* temp;
+ int bytes;
+ int retval = 0;
+
+ // allocate temporary buffer
+ temp = (unsigned char*) malloc((size+1)*sizeof(unsigned char));
+ if (!temp) {
+ LOGE("%s: not enough resources at %s", __FUNCTION__);
+ goto exit;
+ }
+
+ temp[0] = offset;
+ memcpy(temp+1,buffer,size);
+
+ if (!DDCFileAvailable()) {
+ LOGE("%s: I2C_DDC is not available!!!!", __func__);
+ goto exit;
+ }
+
+ if (ioctl(ddc_fd, I2C_SLAVE, addr>>1) < 0) {
+ LOGE("%s: cannot set slave address 0x%02x", __func__,addr);
+ goto exit;
+ }
+
+ // write temp buffer
+ if ((bytes = write(ddc_fd,temp,size+1)) != (size+1)) {
+ LOGE("%s: fail to write %d bytes, only write %d bytes",__func__, size, bytes);
+ goto exit;
+ }
+
+ retval = 1;
+
+exit:
+ // free temp buffer
+ if (temp)
+ free(temp);
+
+ return retval;
+}
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libddc/libddc.h b/exynos4/hal/libhdmi/libsForhdmi/libddc/libddc.h
new file mode 100644
index 0000000..368855b
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libddc/libddc.h
@@ -0,0 +1,35 @@
+/*
+ * 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 _LIBDDC_H_
+#define _LIBDDC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int DDCOpen();
+int DDCRead(unsigned char addr, unsigned char offset, unsigned int size, unsigned char* buffer);
+int DDCWrite(unsigned char addr, unsigned char offset, unsigned int size, unsigned char* buffer);
+int EDDCRead(unsigned char segpointer, unsigned char segment, unsigned char addr,
+ unsigned char offset, unsigned int size, unsigned char* buffer);
+int DDCClose();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LIBDDC_H_ */
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libedid/Android.mk b/exynos4/hal/libhdmi/libsForhdmi/libedid/Android.mk
new file mode 100644
index 0000000..602ae4d
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libedid/Android.mk
@@ -0,0 +1,34 @@
+# 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.
+
+ifeq ($(BOARD_USES_HDMI),true)
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := eng
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)
+LOCAL_SHARED_LIBRARIES := liblog libddc
+LOCAL_SRC_FILES := libedid.c
+
+LOCAL_C_INCLUDES := \
+ $(LOCAL_PATH) \
+ $(LOCAL_PATH)/../../../include
+
+LOCAL_MODULE := libedid
+include $(BUILD_SHARED_LIBRARY)
+
+endif
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libedid/edid.h b/exynos4/hal/libhdmi/libsForhdmi/libedid/edid.h
new file mode 100644
index 0000000..aea1309
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libedid/edid.h
@@ -0,0 +1,181 @@
+/*
+ * 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 _EDID_H_
+#define _EDID_H_
+
+//@{
+/**
+ * @name EDID Addresses
+ */
+#define EDID_ADDR (0xA0)
+#define EDID_SEGMENT_POINTER (0x60)
+//@}
+
+//@{
+/**
+ * @name EDID offset and bit values
+ */
+#define SIZEOFBYTE (8)
+#define SIZEOFEDIDBLOCK (0x80)
+#define EDID_EXTENSION_NUMBER_POS (0x7E)
+
+#define EDID_TIMING_EXT_TAG_ADDR_POS (0)
+#define EDID_TIMING_EXT_REV_NUMBER_POS (1)
+#define EDID_DETAILED_TIMING_OFFSET_POS (2)
+#define EDID_DATA_BLOCK_START_POS (4)
+
+// for Extension Data Block
+#define EDID_TIMING_EXT_TAG_VAL (0x02)
+#define EDID_BLOCK_MAP_EXT_TAG_VAL (0xF0)
+
+#define EDID_SHORT_AUD_DEC_TAG_VAL (1<<5)
+#define EDID_SHORT_VID_DEC_TAG_VAL (2<<5)
+#define EDID_VSDB_TAG_VAL (3<<5)
+#define EDID_SPEAKER_ALLOCATION_TAG_VAL (4<<5)
+#define EDID_VESA_DTC_TAG_VAL (5<<5)
+#define EDID_RESERVED_TAG_VAL (6<<5)
+
+#define EDID_EXTENDED_TAG_VAL (7<<5)
+#define EDID_EXTENDED_COLORIMETRY_VAL (5)
+#define EDID_EXTENDED_COLORIMETRY_BLOCK_LEN (3)
+
+#define EDID_TAG_CODE_MASK (1<<7 | 1<<6 | 1<<5)
+#define EDID_DATA_BLOCK_SIZE_MASK (1<<4 | 1<<3 | 1<<2 | 1<<1 | 1<<0)
+
+#define EDID_VSDB_MIN_LENGTH_VAL (5)
+
+// for Established Timings
+#define EDID_ET_POS (0x23)
+#define EDID_ET_640x480p_VAL (0x20)
+
+// for DTD
+#define EDID_DTD_START_ADDR (0x36)
+#define EDID_DTD_BYTE_LENGTH (18)
+#define EDID_DTD_TOTAL_LENGTH (EDID_DTD_BYTE_LENGTH*4)
+
+#define EDID_DTD_PIXELCLOCK_POS1 (0)
+#define EDID_DTD_PIXELCLOCK_POS2 (1)
+
+#define EDID_DTD_HBLANK_POS1 (3)
+#define EDID_DTD_HBLANK_POS2 (4)
+#define EDID_DTD_HBLANK_POS2_MASK (0xF)
+
+#define EDID_DTD_HACTIVE_POS1 (2)
+#define EDID_DTD_HACTIVE_POS2 (4)
+#define EDID_DTD_HACTIVE_POS2_MASK (0xF0)
+
+#define EDID_DTD_VBLANK_POS1 (6)
+#define EDID_DTD_VBLANK_POS2 (7)
+#define EDID_DTD_VBLANK_POS2_MASK (0x0F)
+
+#define EDID_DTD_VACTIVE_POS1 (5)
+#define EDID_DTD_VACTIVE_POS2 (7)
+#define EDID_DTD_VACTIVE_POS2_MASK (0xF0)
+
+#define EDID_DTD_INTERLACE_POS (17)
+#define EDID_DTD_INTERLACE_MASK (1<<7)
+
+// for SVD
+#define EDID_SVD_VIC_MASK (0x7F)
+
+// for CS
+#define EDID_COLOR_SPACE_POS (3)
+#define EDID_YCBCR444_CS_MASK (1<<5)
+#define EDID_YCBCR422_CS_MASK (1<<4)
+
+// for Color Depth
+#define EDID_DC_48_VAL (1<<6)
+#define EDID_DC_36_VAL (1<<5)
+#define EDID_DC_30_VAL (1<<4)
+#define EDID_DC_YCBCR_VAL (1<<3)
+
+#define EDID_DC_POS (6)
+#define EDID_DC_MASK (EDID_DC_48_VAL | EDID_DC_36_VAL| EDID_DC_30_VAL | EDID_DC_YCBCR_VAL)
+
+// for colorimetry
+#define EDID_XVYCC601_MASK (1<<0)
+#define EDID_XVYCC709_MASK (1<<1)
+#define EDID_EXTENDED_MASK (1<<0|1<<1|1<<2)
+
+// for SAD
+#define SHORT_AUD_DESCRIPTOR_LPCM (1<<0)
+#define SHORT_AUD_DESCRIPTOR_AC3 (1<<1)
+#define SHORT_AUD_DESCRIPTOR_MPEG1 (1<<2)
+#define SHORT_AUD_DESCRIPTOR_MP3 (1<<3)
+#define SHORT_AUD_DESCRIPTOR_MPEG2 (1<<4)
+#define SHORT_AUD_DESCRIPTOR_AAC (1<<5)
+#define SHORT_AUD_DESCRIPTOR_DTS (1<<6)
+#define SHORT_AUD_DESCRIPTOR_ATRAC (1<<7)
+
+#define EDID_SAD_CODE_MASK (1<<6 | 1<<5 | 1<<4 | 1<<3)
+#define EDID_SAD_CHANNEL_MASK (1<<2 | 1<<1 | 1<<0)
+#define EDID_SAD_192KHZ_MASK (1<<6)
+#define EDID_SAD_176KHZ_MASK (1<<5)
+#define EDID_SAD_96KHZ_MASK (1<<4)
+#define EDID_SAD_88KHZ_MASK (1<<3)
+#define EDID_SAD_48KHZ_MASK (1<<2)
+#define EDID_SAD_44KHZ_MASK (1<<1)
+#define EDID_SAD_32KHZ_MASK (1<<0)
+
+#define EDID_SAD_WORD_24_MASK (1<<2)
+#define EDID_SAD_WORD_20_MASK (1<<1)
+#define EDID_SAD_WORD_16_MASK (1<<0)
+
+// for CEC
+#define EDID_CEC_PHYICAL_ADDR (4)
+
+// for 3D
+#define EDID_HDMI_EXT_POS (8)
+#define EDID_HDMI_VIDEO_PRESENT_MASK (1<<5)
+
+// latency
+#define EDID_HDMI_LATENCY_MASK (1<<7|1<<6)
+#define EDID_HDMI_LATENCY_POS (6)
+
+#define EDID_HDMI_3D_PRESENT_POS (13)
+#define EDID_HDMI_3D_PRESENT_MASK (1<<7)
+#define EDID_HDMI_3D_MULTI_PRESENT_MASK (1<<6 | 1<<5)
+#define EDID_HDMI_3D_MULTI_PRESENT_BIT 5
+
+#define EDID_3D_STRUCTURE_ONLY_EXIST (1<<5)
+#define EDID_3D_STRUCTURE_MASK_EXIST (1<<6)
+
+#define EDID_3D_STRUCTURE_FP (0)
+#define EDID_3D_STRUCTURE_FA (1)
+#define EDID_3D_STRUCTURE_LA (2)
+#define EDID_3D_STRUCTURE_SSF (3)
+#define EDID_3D_STRUCTURE_LD (4)
+#define EDID_3D_STRUCTURE_LDGFX (5)
+#define EDID_3D_STRUCTURE_TB (6)
+#define EDID_3D_STRUCTURE_SSH (8)
+
+#define EDID_HDMI_EXT_LENGTH_POS (14)
+#define EDID_HDMI_VSDB_VIC_LEN_BIT (5)
+#define EDID_HDMI_VSDB_VIC_LEN_MASK (1<<7|1<<6|1<<5)
+#define EDID_HDMI_VSDB_3D_LEN_MASK (1<<4|1<<3|1<<2|1<<1|1<<0)
+
+#define EDID_HDMI_2D_VIC_ORDER_MASK (1<<7|1<<6|1<<5|1<<4)
+#define EDID_HDMI_3D_STRUCTURE_MASK (1<<3|1<<2|1<<1|1<<0)
+
+// for MAX TMDS
+#define EDID_MAX_TMDS_POS (7)
+
+// for 3D Structure
+#define NUM_OF_VIC_FOR_3D 16
+//@}
+
+#endif /* _EDID_H_ */
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libedid/libedid.c b/exynos4/hal/libhdmi/libsForhdmi/libedid/libedid.c
new file mode 100644
index 0000000..c4af587
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libedid/libedid.c
@@ -0,0 +1,1262 @@
+/*
+* 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.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <cutils/log.h>
+
+#include "edid.h"
+#include "libedid.h"
+#include "../libddc/libddc.h"
+
+//#define EDID_DEBUG 1
+
+#ifdef EDID_DEBUG
+#define DPRINTF(args...) LOGI(args)
+#else
+#define DPRINTF(args...)
+#endif
+
+#define NUM_OF_VIC_FOR_3D 16
+
+/**
+ * @var gEdidData
+ * Pointer to EDID data
+ */
+static unsigned char* gEdidData;
+
+/**
+ * @var gExtensions
+ * Number of EDID extensions
+ */
+static int gExtensions;
+
+
+/**
+ * @var aVIC
+ * This contains first 16 VIC in EDID
+ */
+static unsigned char aVIC[NUM_OF_VIC_FOR_3D];
+
+//! Structure for parsing video timing parameter in EDID
+static const struct edid_params {
+ /** H Total */
+ unsigned int HTotal;
+
+ /** H Blank */
+ unsigned int HBlank;
+
+ /** V Total */
+ unsigned int VTotal;
+
+ /** V Blank */
+ unsigned int VBlank;
+
+ /** CEA VIC */
+ unsigned char VIC;
+
+ /** CEA VIC for 16:9 aspect ratio */
+ unsigned char VIC16_9;
+
+ /** 0 if progressive, 1 if interlaced */
+ unsigned char interlaced;
+
+ /** Pixel frequency */
+ enum PixelFreq PixelClock;
+} aVideoParams[] =
+{
+ { 800 , 160 , 525 , 45, 1 , 1 , 0, PIXEL_FREQ_25_200 ,}, // v640x480p_60Hz
+ { 858 , 138 , 525 , 45, 2 , 3 , 0, PIXEL_FREQ_27_027 ,}, // v720x480p_60Hz
+ { 1650, 370 , 750 , 30, 4 , 4 , 0, PIXEL_FREQ_74_250 ,}, // v1280x720p_60Hz
+ { 2200, 280 , 1125, 22, 5 , 5 , 1, PIXEL_FREQ_74_250 ,}, // v1920x1080i_60H
+ { 1716, 276 , 525 , 22, 6 , 7 , 1, PIXEL_FREQ_74_250 ,}, // v720x480i_60Hz
+ { 1716, 276 , 262 , 22, 8 , 9 , 0, PIXEL_FREQ_27_027 ,}, // v720x240p_60Hz
+ //{ 1716, 276 , 263 , 23, 8 , 9 , 0, PIXEL_FREQ_27_027 , }, // v720x240p_60Hz(mode 2)
+ { 3432, 552 , 525 , 22, 10, 11, 1, PIXEL_FREQ_54_054 , }, // v2880x480i_60Hz
+ { 3432, 552 , 262 , 22, 12, 13, 0, PIXEL_FREQ_54_054 , }, // v2880x240p_60Hz
+ //{ 3432, 552 , 263 , 23, 12, 13, 0, PIXEL_FREQ_54_054 , }, // v2880x240p_60Hz(mode 2)
+ { 1716, 276 , 525 , 45, 14, 15, 0, PIXEL_FREQ_54_054 , }, // v1440x480p_60Hz
+ { 2200, 280 , 1125, 45, 16, 16, 0, PIXEL_FREQ_148_500, }, // v1920x1080p_60H
+ { 864 , 144 , 625 , 49, 17, 18, 0, PIXEL_FREQ_27 , }, // v720x576p_50Hz
+ { 1980, 700 , 750 , 30, 19, 19, 0, PIXEL_FREQ_74_250 , }, // v1280x720p_50Hz
+ { 2640, 720 , 1125, 22, 20, 20, 1, PIXEL_FREQ_74_250 , }, // v1920x1080i_50H
+ { 1728, 288 , 625 , 24, 21, 22, 1, PIXEL_FREQ_27 , }, // v720x576i_50Hz
+ { 1728, 288 , 312 , 24, 23, 24, 0, PIXEL_FREQ_27 , }, // v720x288p_50Hz
+ //{ 1728, 288 , 313 , 25, 23, 24, 0, PIXEL_FREQ_27 , }, // v720x288p_50Hz(mode 2)
+ //{ 1728, 288 , 314 , 26, 23, 24, 0, PIXEL_FREQ_27 , }, // v720x288p_50Hz(mode 3)
+ { 3456, 576 , 625 , 24, 25, 26, 1, PIXEL_FREQ_54 , }, // v2880x576i_50Hz
+ { 3456, 576 , 312 , 24, 27, 28, 0, PIXEL_FREQ_54 , }, // v2880x288p_50Hz
+ //{ 3456, 576 , 313 , 25, 27, 28, 0, PIXEL_FREQ_54 , }, // v2880x288p_50Hz(mode 2)
+ //{ 3456, 576 , 314 , 26, 27, 28, 0, PIXEL_FREQ_54 , }, // v2880x288p_50Hz(mode 3)
+ { 1728, 288 , 625 , 49, 29, 30, 0, PIXEL_FREQ_54 , }, // v1440x576p_50Hz
+ { 2640, 720 , 1125, 45, 31, 31, 0, PIXEL_FREQ_148_500,}, // v1920x1080p_50Hz
+ { 2750, 830 , 1125, 45, 32, 32, 0, PIXEL_FREQ_74_250 ,}, // v1920x1080p_24Hz
+ { 2640, 720 , 1125, 45, 33, 33, 0, PIXEL_FREQ_74_250 ,}, // v1920x1080p_25Hz
+ { 2200, 280 , 1125, 45, 34, 34, 0, PIXEL_FREQ_74_250 ,}, // v1920x1080p_30Hz
+ { 3432, 552 , 525 , 45, 35, 36, 0, PIXEL_FREQ_108_108,}, // v2880x480p_60Hz
+ { 3456, 576 , 625 , 49, 37, 38, 0, PIXEL_FREQ_108 ,}, // v2880x576p_50Hz
+ { 2304, 384 , 1250, 85, 39, 39, 1, PIXEL_FREQ_72 ,}, // v1920x1080i_50Hz(1250)
+ { 2640, 720 , 1125, 22, 40, 40, 1, PIXEL_FREQ_148_500, }, // v1920x1080i_100Hz
+ { 1980, 700 , 750 , 30, 41, 41, 0, PIXEL_FREQ_148_500, }, // v1280x720p_100Hz
+ { 864 , 144 , 625 , 49, 42, 43, 0, PIXEL_FREQ_54 , }, // v720x576p_100Hz
+ { 1728, 288 , 625 , 24, 44, 45, 1, PIXEL_FREQ_54 , }, // v720x576i_100Hz
+ { 2200, 280 , 1125, 22, 46, 46, 1, PIXEL_FREQ_148_500, }, // v1920x1080i_120Hz
+ { 1650, 370 , 750 , 30, 47, 47, 0, PIXEL_FREQ_148_500, }, // v1280x720p_120Hz
+ { 858 , 138 , 525 , 54, 48, 49, 0, PIXEL_FREQ_54_054 , }, // v720x480p_120Hz
+ { 1716, 276 , 525 , 22, 50, 51, 1, PIXEL_FREQ_54_054 , }, // v720x480i_120Hz
+ { 864 , 144 , 625 , 49, 52, 53, 0, PIXEL_FREQ_108 , }, // v720x576p_200Hz
+ { 1728, 288 , 625 , 24, 54, 55, 1, PIXEL_FREQ_108 , }, // v720x576i_200Hz
+ { 858 , 138 , 525 , 45, 56, 57, 0, PIXEL_FREQ_108_108, }, // v720x480p_240Hz
+ { 1716, 276 , 525 , 22, 58, 59, 1, PIXEL_FREQ_108_108, }, // v720x480i_240Hz
+ // PHY Freq is not available yet
+ //{ 3300, 2020, 750 , 30, 60, 60, 0, PIXEL_FREQ_59_400 ,}, // v1280x720p24Hz
+ { 3960, 2680, 750 , 30, 61, 61, 0, PIXEL_FREQ_74_250 , }, // v1280x720p25Hz
+ { 3300, 2020, 750 , 30, 62, 62, 0, PIXEL_FREQ_74_250 ,}, // v1280x720p30Hz
+ // PHY Freq is not available yet
+ //{ 2200, 280 , 1125, 45, 63, 63, 0, PIXEL_FREQ_297, }, // v1920x1080p120Hz
+ //{ 2640, 720 , 1125, 45, 64, 64, 0, PIXEL_FREQ_297, }, // v1920x1080p100Hz
+ //{ 4400, 560 , 2250, 90, 1, 1, 0, 0, PIXEL_FREQ_297, }, // v4Kx2K30Hz
+};
+
+//! Structure for Checking 3D Mandatory Format in EDID
+static const struct edid_3d_mandatory {
+ /** video Format */
+ enum VideoFormat resolution;
+
+ /** 3D Structure */
+ enum HDMI3DVideoStructure hdmi_3d_format;
+} edid_3d [] =
+{
+ { v1920x1080p_24Hz, HDMI_3D_FP_FORMAT }, // 1920x1080p @ 23.98/24Hz
+ { v1280x720p_60Hz, HDMI_3D_FP_FORMAT }, // 1280x720p @ 59.94/60Hz
+ { v1920x1080i_60Hz, HDMI_3D_SSH_FORMAT }, // 1920x1080i @ 59.94/60Hz
+ { v1920x1080p_24Hz, HDMI_3D_TB_FORMAT }, // 1920x1080p @ 23.98/24Hz
+ { v1280x720p_60Hz, HDMI_3D_TB_FORMAT }, // 1280x720p @ 59.94/60Hz
+ { v1280x720p_50Hz, HDMI_3D_FP_FORMAT }, // 1280x720p @ 50Hz
+ { v1920x1080i_50Hz, HDMI_3D_SSH_FORMAT }, // 1920x1080i @ 50Hz
+ { v1280x720p_50Hz, HDMI_3D_TB_FORMAT }, // 1280x720p @ 50Hz
+};
+
+/**
+ * Calculate a checksum.
+ *
+ * @param buffer [in] Pointer to data to calculate a checksum
+ * @param size [in] Sizes of data
+ *
+ * @return If checksum result is 0, return 1; Otherwise, return 0.
+ */
+static int CalcChecksum(const unsigned char* const buffer, const int size)
+{
+ unsigned char i,sum;
+ int ret = 1;
+
+ // check parameter
+ if (buffer == NULL ) {
+ DPRINTF("invalid parameter : buffer\n");
+ return 0;
+ }
+ for (sum = 0, i = 0 ; i < size; i++)
+ sum += buffer[i];
+
+ // check checksum
+ if (sum != 0)
+ ret = 0;
+
+ return ret;
+}
+
+/**
+ * Read EDID Block(128 bytes)
+ *
+ * @param blockNum [in] Number of block to read @n
+ * For example, EDID block = 0, EDID first Extension = 1, and so on.
+ * @param outBuffer [out] Pointer to buffer to store EDID data
+ *
+ * @return If fail to read, return 0; Otherwise, return 1.
+ */
+static int ReadEDIDBlock(const unsigned int blockNum, unsigned char* const outBuffer)
+{
+ int segNum, offset, dataPtr;
+
+ // check parameter
+ if (outBuffer == NULL) {
+ DPRINTF("invalid parameter : outBuffer\n");
+ return 0;
+ }
+
+ // calculate
+ segNum = blockNum / 2;
+ offset = (blockNum % 2) * SIZEOFEDIDBLOCK;
+ dataPtr = (blockNum) * SIZEOFEDIDBLOCK;
+
+ // read block
+ if (!EDDCRead(EDID_SEGMENT_POINTER, segNum, EDID_ADDR, offset, SIZEOFEDIDBLOCK, outBuffer)) {
+ DPRINTF("Fail to Read %dth EDID Block\n", blockNum);
+ return 0;
+ }
+
+ if (!CalcChecksum(outBuffer, SIZEOFEDIDBLOCK)) {
+ DPRINTF("CheckSum fail : %dth EDID Block\n", blockNum);
+ return 0;
+ }
+
+ // print data
+#ifdef EDID_DEBUG
+ offset = 0;
+ do {
+ LOGI("0x%02X", outBuffer[offset++]);
+ if (offset % 16)
+ LOGI(" ");
+ else
+ LOGI("\n");
+ } while (SIZEOFEDIDBLOCK > offset);
+#endif // EDID_DEBUG
+ return 1;
+}
+
+/**
+ * Check if EDID data is valid or not.
+ *
+ * @return if EDID data is valid, return 1; Otherwise, return 0.
+ */
+static inline int EDIDValid(void)
+{
+ return (gEdidData == NULL) ? 0 : 1;
+}
+
+/**
+ * Search HDMI Vender Specific Data Block(VSDB) in EDID extension block.
+ *
+ * @param extension [in] the number of EDID extension block to check
+ *
+ * @return if there is a HDMI VSDB, return the offset from start of @n
+ * EDID extension block. if there is no VSDB, return 0.
+ */
+static int GetVSDBOffset(const int extension)
+{
+ unsigned int BlockOffset = extension*SIZEOFEDIDBLOCK;
+ unsigned int offset = BlockOffset + EDID_DATA_BLOCK_START_POS;
+ unsigned int tag,blockLen,DTDOffset;
+
+ if (!EDIDValid() || (extension > gExtensions)) {
+ DPRINTF("EDID Data is not available\n");
+ return 0;
+ }
+
+ DTDOffset = gEdidData[BlockOffset + EDID_DETAILED_TIMING_OFFSET_POS];
+
+ // check if there is HDMI VSDB
+ while (offset < BlockOffset + DTDOffset) {
+ // find the block tag and length
+ // tag
+ tag = gEdidData[offset] & EDID_TAG_CODE_MASK;
+ // block len
+ blockLen = (gEdidData[offset] & EDID_DATA_BLOCK_SIZE_MASK) + 1;
+
+ // check if it is HDMI VSDB
+ // if so, check identifier value, if it's hdmi vsbd - return offset
+ if (tag == EDID_VSDB_TAG_VAL &&
+ gEdidData[offset+1] == 0x03 &&
+ gEdidData[offset+2] == 0x0C &&
+ gEdidData[offset+3] == 0x0 &&
+ blockLen > EDID_VSDB_MIN_LENGTH_VAL )
+ return offset;
+
+ // else find next block
+ offset += blockLen;
+ }
+
+ // return error
+ return 0;
+}
+
+/**
+ * Check if Sink supports the HDMI mode.
+ * @return If Sink supports HDMI mode, return 1; Otherwise, return 0.
+ */
+static int CheckHDMIMode(void)
+{
+ int i;
+
+ // read EDID
+ if (!EDIDRead())
+ return 0;
+
+ // find VSDB
+ for (i = 1; i <= gExtensions; i++)
+ if (GetVSDBOffset(i) > 0) // if there is a VSDB, it means RX support HDMI mode
+ return 1;
+
+ return 0;
+}
+
+/**
+ * Check if EDID extension block is timing extension block or not.
+ * @param extension [in] The number of EDID extension block to check
+ * @return If the block is timing extension, return 1; Otherwise, return 0.
+ */
+static int IsTimingExtension(const int extension)
+{
+ int ret = 0;
+ if (!EDIDValid() || (extension > gExtensions)) {
+ DPRINTF("EDID Data is not available\n");
+ return ret;
+ }
+
+ if (gEdidData[extension*SIZEOFEDIDBLOCK] == EDID_TIMING_EXT_TAG_VAL) {
+ // check extension revsion number
+ // revision num == 3
+ if (gEdidData[extension*SIZEOFEDIDBLOCK + EDID_TIMING_EXT_REV_NUMBER_POS] == 3)
+ ret = 1;
+ // revison num != 3 && DVI mode
+ else if (!CheckHDMIMode() &&
+ gEdidData[extension*SIZEOFEDIDBLOCK + EDID_TIMING_EXT_REV_NUMBER_POS] != 2)
+ ret = 1;
+ }
+ return ret;
+}
+
+/**
+ * Check if the video format is contained in - @n
+ * Detailed Timing Descriptor(DTD) of EDID extension block.
+ * @param extension [in] Number of EDID extension block to check
+ * @param videoFormat [in] Video format to check
+ * @return If the video format is contained in DTD of EDID extension block, -@n
+ * return 1; Otherwise, return 0.
+ */
+static int IsContainVideoDTD(const int extension,const enum VideoFormat videoFormat)
+{
+ int i, StartOffset, EndOffset;
+
+ if (!EDIDValid() || (extension > gExtensions)) {
+ DPRINTF("EDID Data is not available\n");
+ return 0;
+ }
+
+ // if edid block( 0th block )
+ if (extension == 0) {
+ StartOffset = EDID_DTD_START_ADDR;
+ EndOffset = StartOffset + EDID_DTD_TOTAL_LENGTH;
+ } else { // if edid extension block
+ StartOffset = extension*SIZEOFEDIDBLOCK + gEdidData[extension*SIZEOFEDIDBLOCK + EDID_DETAILED_TIMING_OFFSET_POS];
+ EndOffset = (extension+1)*SIZEOFEDIDBLOCK;
+ }
+
+ // check DTD(Detailed Timing Description)
+ for (i = StartOffset; i < EndOffset; i+= EDID_DTD_BYTE_LENGTH) {
+ unsigned int hblank = 0, hactive = 0, vblank = 0, vactive = 0, interlaced = 0, pixelclock = 0;
+ unsigned int vHActive = 0, vVActive = 0, vVBlank = 0;
+
+ // get pixel clock
+ pixelclock = (gEdidData[i+EDID_DTD_PIXELCLOCK_POS2] << SIZEOFBYTE);
+ pixelclock |= gEdidData[i+EDID_DTD_PIXELCLOCK_POS1];
+
+ if (!pixelclock)
+ continue;
+
+ // get HBLANK value in pixels
+ hblank = gEdidData[i+EDID_DTD_HBLANK_POS2] & EDID_DTD_HBLANK_POS2_MASK;
+ hblank <<= SIZEOFBYTE; // lower 4 bits
+ hblank |= gEdidData[i+EDID_DTD_HBLANK_POS1];
+
+ // get HACTIVE value in pixels
+ hactive = gEdidData[i+EDID_DTD_HACTIVE_POS2] & EDID_DTD_HACTIVE_POS2_MASK;
+ hactive <<= (SIZEOFBYTE/2); // upper 4 bits
+ hactive |= gEdidData[i+EDID_DTD_HACTIVE_POS1];
+
+ // get VBLANK value in pixels
+ vblank = gEdidData[i+EDID_DTD_VBLANK_POS2] & EDID_DTD_VBLANK_POS2_MASK;
+ vblank <<= SIZEOFBYTE; // lower 4 bits
+ vblank |= gEdidData[i+EDID_DTD_VBLANK_POS1];
+
+ // get VACTIVE value in pixels
+ vactive = gEdidData[i+EDID_DTD_VACTIVE_POS2] & EDID_DTD_VACTIVE_POS2_MASK;
+ vactive <<= (SIZEOFBYTE/2); // upper 4 bits
+ vactive |= gEdidData[i+EDID_DTD_VACTIVE_POS1];
+
+ vHActive = aVideoParams[videoFormat].HTotal - aVideoParams[videoFormat].HBlank;
+ if (aVideoParams[videoFormat].interlaced == 1) {
+ if (aVideoParams[videoFormat].VIC == v1920x1080i_50Hz_1250) { // VTOP and VBOT are same
+ vVActive = (aVideoParams[videoFormat].VTotal - aVideoParams[videoFormat].VBlank*2)/2;
+ vVBlank = aVideoParams[videoFormat].VBlank;
+ } else {
+ vVActive = (aVideoParams[videoFormat].VTotal - aVideoParams[videoFormat].VBlank*2 - 1)/2;
+ vVBlank = aVideoParams[videoFormat].VBlank;
+ }
+ } else {
+ vVActive = aVideoParams[videoFormat].VTotal - aVideoParams[videoFormat].VBlank;
+ vVBlank = aVideoParams[videoFormat].VBlank;
+ }
+
+ // get Interlaced Mode Value
+ interlaced = (int)(gEdidData[i+EDID_DTD_INTERLACE_POS] & EDID_DTD_INTERLACE_MASK);
+ if (interlaced)
+ interlaced = 1;
+
+ DPRINTF("EDID: hblank = %d,vblank = %d, hactive = %d, vactive = %d\n"
+ ,hblank,vblank,hactive,vactive);
+ DPRINTF("REQ: hblank = %d,vblank = %d, hactive = %d, vactive = %d\n"
+ ,aVideoParams[videoFormat].HBlank
+ ,vVBlank,vHActive,vVActive);
+
+ if (hblank == aVideoParams[videoFormat].HBlank && vblank == vVBlank // blank
+ && hactive == vHActive && vactive == vVActive) { //line
+ unsigned int EDIDpixelclock = aVideoParams[videoFormat].PixelClock;
+ EDIDpixelclock /= 100; pixelclock /= 100;
+
+ if (pixelclock == EDIDpixelclock) {
+ DPRINTF("Sink Support the Video mode\n");
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+/**
+ * Check if a VIC(Video Identification Code) is contained in -@n
+ * EDID extension block.
+ * @param extension [in] Number of EDID extension block to check
+ * @param VIC [in] VIC to check
+ * @return If the VIC is contained in contained in EDID extension block, -@n
+ * return 1; Otherwise, return 0.
+ */
+static int IsContainVIC(const int extension, const int VIC)
+{
+ unsigned int StartAddr = extension*SIZEOFEDIDBLOCK;
+ unsigned int ExtAddr = StartAddr + EDID_DATA_BLOCK_START_POS;
+ unsigned int tag,blockLen;
+ unsigned int DTDStartAddr = gEdidData[StartAddr + EDID_DETAILED_TIMING_OFFSET_POS];
+
+ if (!EDIDValid() || (extension > gExtensions)) {
+ DPRINTF("EDID Data is not available\n");
+ return 0;
+ }
+
+ // while
+ while (ExtAddr < StartAddr + DTDStartAddr) {
+ // find the block tag and length
+ // tag
+ tag = gEdidData[ExtAddr] & EDID_TAG_CODE_MASK;
+ // block len
+ blockLen = (gEdidData[ExtAddr] & EDID_DATA_BLOCK_SIZE_MASK) + 1;
+ DPRINTF("tag = %d\n",tag);
+ DPRINTF("blockLen = %d\n",blockLen-1);
+
+ // check if it is short video description
+ if (tag == EDID_SHORT_VID_DEC_TAG_VAL) {
+ // if so, check SVD
+ unsigned int i;
+ for (i = 1; i < blockLen; i++) {
+ DPRINTF("EDIDVIC = %d\n",gEdidData[ExtAddr+i] & EDID_SVD_VIC_MASK);
+ DPRINTF("VIC = %d\n",VIC);
+
+ // check VIC with SVDB
+ if (VIC == (gEdidData[ExtAddr+i] & EDID_SVD_VIC_MASK)) {
+ DPRINTF("Sink Device supports requested video mode\n");
+ return 1;
+ }
+ }
+ }
+ // else find next block
+ ExtAddr += blockLen;
+ }
+
+ return 0;
+}
+
+/**
+ * Check if EDID contains the video format.
+ * @param videoFormat [in] Video format to check
+ * @param pixelRatio [in] Pixel aspect ratio of video format to check
+ * @return if EDID contains the video format, return 1; Otherwise, return 0.
+ */
+static int CheckResolution(const enum VideoFormat videoFormat,
+ const enum PixelAspectRatio pixelRatio)
+{
+ int i, vic;
+
+ // read EDID
+ if (!EDIDRead())
+ return 0;
+
+ // check ET(Established Timings) for 640x480p@60Hz
+ if (videoFormat == v640x480p_60Hz // if it's 640x480p@60Hz
+ && (gEdidData[EDID_ET_POS] & EDID_ET_640x480p_VAL)) // it support
+ return 1;
+
+ // check STI(Standard Timing Identification)
+ // do not need
+
+ // check DTD(Detailed Timing Description) of EDID block(0th)
+ if (IsContainVideoDTD(0,videoFormat))
+ return 1;
+
+ // check EDID Extension
+ vic = (pixelRatio == HDMI_PIXEL_RATIO_16_9) ?
+ aVideoParams[videoFormat].VIC16_9 : aVideoParams[videoFormat].VIC;
+
+ // find VSDB
+ for (i = 1; i <= gExtensions; i++) {
+ if (IsTimingExtension(i)) // if it's timing block
+ if (IsContainVIC(i, vic) || IsContainVideoDTD(i, videoFormat))
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * Check if EDID supports the color depth.
+ * @param depth [in] Color depth
+ * @param space [in] Color space
+ * @return If EDID supports the color depth, return 1; Otherwise, return 0.
+ */
+static int CheckColorDepth(const enum ColorDepth depth,const enum ColorSpace space)
+{
+ int i;
+ unsigned int StartAddr;
+
+ // if color depth == 24 bit, no need to check
+ if (depth == HDMI_CD_24)
+ return 1;
+
+ // check EDID data is valid or not
+ // read EDID
+ if (!EDIDRead())
+ return 0;
+
+ // find VSDB
+ for (i = 1; i <= gExtensions; i++) {
+ if (IsTimingExtension(i) // if it's timing block
+ && ((StartAddr = GetVSDBOffset(i)) > 0)) { // check block
+ int blockLength = gEdidData[StartAddr] & EDID_DATA_BLOCK_SIZE_MASK;
+ if (blockLength >= EDID_DC_POS) {
+ // get supported DC value
+ int deepColor = gEdidData[StartAddr + EDID_DC_POS] & EDID_DC_MASK;
+ DPRINTF("EDID deepColor = %x\n",deepColor);
+ // check supported DeepColor
+ // if YCBCR444
+ if (space == HDMI_CS_YCBCR444) {
+ if ( !(deepColor & EDID_DC_YCBCR_VAL))
+ return 0;
+ }
+
+ // check colorDepth
+ switch (depth) {
+ case HDMI_CD_36:
+ deepColor &= EDID_DC_36_VAL;
+ break;
+ case HDMI_CD_30:
+ deepColor &= EDID_DC_30_VAL;
+ break;
+ default :
+ deepColor = 0;
+ }
+ if (deepColor)
+ return 1;
+ else
+ return 0;
+ }
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Check if EDID supports the color space.
+ * @param space [in] Color space
+ * @return If EDID supports the color space, return 1; Otherwise, return 0.
+ */
+static int CheckColorSpace(const enum ColorSpace space)
+{
+ int i;
+
+ // RGB is default
+ if (space == HDMI_CS_RGB)
+ return 1;
+
+ // check EDID data is valid or not
+ // read EDID
+ if (!EDIDRead())
+ return 0;
+
+ // find VSDB
+ for (i = 1; i <= gExtensions; i++) {
+ if (IsTimingExtension(i)) { // if it's timing block
+ // read Color Space
+ int CS = gEdidData[i*SIZEOFEDIDBLOCK + EDID_COLOR_SPACE_POS];
+
+ if ((space == HDMI_CS_YCBCR444 && (CS & EDID_YCBCR444_CS_MASK)) || // YCBCR444
+ (space == HDMI_CS_YCBCR422 && (CS & EDID_YCBCR422_CS_MASK))) // YCBCR422
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/**
+ * Check if EDID supports the colorimetry.
+ * @param color [in] Colorimetry
+ * @return If EDID supports the colorimetry, return 1; Otherwise, return 0.
+ */
+static int CheckColorimetry(const enum HDMIColorimetry color)
+{
+ int i;
+
+ // do not need to parse if not extended colorimetry
+ if (color == HDMI_COLORIMETRY_NO_DATA ||
+ color == HDMI_COLORIMETRY_ITU601 ||
+ color == HDMI_COLORIMETRY_ITU709)
+ return 1;
+
+ // read EDID
+ if (!EDIDRead())
+ return 0;
+
+ // find VSDB
+ for (i = 1; i <= gExtensions; i++) {
+ if (IsTimingExtension(i)) { // if it's timing block
+ // check address
+ unsigned int ExtAddr = i*SIZEOFEDIDBLOCK + EDID_DATA_BLOCK_START_POS;
+ unsigned int EndAddr = i*SIZEOFEDIDBLOCK + gEdidData[i*SIZEOFEDIDBLOCK + EDID_DETAILED_TIMING_OFFSET_POS];
+ unsigned int tag,blockLen;
+
+ while (ExtAddr < EndAddr) {
+ // find the block tag and length
+ // tag
+ tag = gEdidData[ExtAddr] & EDID_TAG_CODE_MASK;
+ // block len
+ blockLen = (gEdidData[ExtAddr] & EDID_DATA_BLOCK_SIZE_MASK) + 1;
+
+ // check if it is colorimetry block
+ if (tag == EDID_EXTENDED_TAG_VAL && // extended tag
+ gEdidData[ExtAddr+1] == EDID_EXTENDED_COLORIMETRY_VAL && // colorimetry block
+ (blockLen-1) == EDID_EXTENDED_COLORIMETRY_BLOCK_LEN) { // check length
+ // get supported DC value
+ int colorimetry = (gEdidData[ExtAddr + 2]);
+ int metadata = (gEdidData[ExtAddr + 3]);
+
+ DPRINTF("EDID extened colorimetry = %x\n",colorimetry);
+ DPRINTF("EDID gamut metadata profile = %x\n",metadata);
+
+ // check colorDepth
+ switch (color) {
+ case HDMI_COLORIMETRY_EXTENDED_xvYCC601:
+ if (colorimetry & EDID_XVYCC601_MASK && metadata)
+ return 1;
+ break;
+ case HDMI_COLORIMETRY_EXTENDED_xvYCC709:
+ if (colorimetry & EDID_XVYCC709_MASK && metadata)
+ return 1;
+ break;
+ default:
+ break;
+ }
+ return 0;
+ }
+ // else find next block
+ ExtAddr += blockLen;
+ }
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Get Max TMDS clock that HDMI Rx can receive.
+ * @return If available, return MaxTMDS clock; Otherwise, return 0.
+ */
+static unsigned int GetMaxTMDS(void)
+{
+ int i;
+ unsigned int StartAddr;
+
+ // find VSDB
+ for (i = 1; i <= gExtensions; i++) {
+ if (IsTimingExtension(i) // if it's timing block
+ && ((StartAddr = GetVSDBOffset(i)) > 0)) { // check block
+ int blockLength = gEdidData[StartAddr] & EDID_DATA_BLOCK_SIZE_MASK;
+ if (blockLength >= EDID_MAX_TMDS_POS) {
+ // get supported DC value
+ return gEdidData[StartAddr + EDID_MAX_TMDS_POS];
+ }
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Save first 16 VIC of EDID
+ */
+static void SaveVIC(void)
+{
+ int extension;
+ int vic_count = 0;
+ for (extension = 1; extension <= gExtensions && vic_count < NUM_OF_VIC_FOR_3D; extension++) {
+ unsigned int StartAddr = extension*SIZEOFEDIDBLOCK;
+ unsigned int ExtAddr = StartAddr + EDID_DATA_BLOCK_START_POS;
+ unsigned int tag,blockLen;
+ unsigned int DTDStartAddr = gEdidData[StartAddr + EDID_DETAILED_TIMING_OFFSET_POS];
+
+ while (ExtAddr < StartAddr + DTDStartAddr) {
+ // find the block tag and length
+ // tag
+ tag = gEdidData[ExtAddr] & EDID_TAG_CODE_MASK;
+ // block len
+ blockLen = (gEdidData[ExtAddr] & EDID_DATA_BLOCK_SIZE_MASK) + 1;
+
+ // check if it is short video description
+ if (tag == EDID_SHORT_VID_DEC_TAG_VAL) {
+ // if so, check SVD
+ unsigned int edid_index;
+ for (edid_index = 1; edid_index < blockLen && vic_count < NUM_OF_VIC_FOR_3D; edid_index++) {
+ DPRINTF("EDIDVIC = %d\r\n", gEdidData[ExtAddr+edid_index] & EDID_SVD_VIC_MASK);
+
+ // check VIC with SVDB
+ aVIC[vic_count++] = (gEdidData[ExtAddr+edid_index] & EDID_SVD_VIC_MASK);
+ }
+ }
+ // else find next block
+ ExtAddr += blockLen;
+ }
+ }
+}
+
+/**
+ * Check if Rx supports requested 3D format.
+ * @param pVideo [in] HDMI Video Parameter
+ * @return If Rx supports requested 3D format, return 1; Otherwise, return 0.
+ */
+static int EDID3DFormatSupport(const struct HDMIVideoParameter * const pVideo)
+{
+ int edid_index;
+ unsigned int StartAddr;
+ unsigned int vic;
+ vic = (pVideo->pixelAspectRatio == HDMI_PIXEL_RATIO_16_9) ?
+ aVideoParams[pVideo->resolution].VIC16_9 : aVideoParams[pVideo->resolution].VIC;
+
+ // if format == 2D, no need to check
+ if (pVideo->hdmi_3d_format == HDMI_2D_VIDEO_FORMAT)
+ return 1;
+
+ // check EDID data is valid or not
+ if (!EDIDRead())
+ return 0;
+
+ // save first 16 VIC to check
+ SaveVIC();
+
+ // find VSDB
+ for (edid_index = 1; edid_index <= gExtensions; edid_index++) {
+ if (IsTimingExtension(edid_index) // if it's timing block
+ && ((StartAddr = GetVSDBOffset(edid_index)) > 0)) { // check block
+ unsigned int blockLength = gEdidData[StartAddr] & EDID_DATA_BLOCK_SIZE_MASK;
+ unsigned int VSDBHdmiVideoPre = 0;
+ unsigned int VSDB3DPresent = 0;
+ unsigned int VSDB3DMultiPresent = 0;
+ unsigned int HDMIVICLen;
+ unsigned int HDMI3DLen;
+ int Hdmi3DStructure = 0;
+ unsigned int Hdmi3DMask = 0xFFFF;
+ unsigned int latency_offset = 0;
+
+ DPRINTF("VSDB Block length[0x%x] = 0x%x\r\n",StartAddr,blockLength);
+
+ // get HDMI Video Present value
+ if (blockLength >= EDID_HDMI_EXT_POS) {
+ VSDBHdmiVideoPre = gEdidData[StartAddr + EDID_HDMI_EXT_POS]
+ & EDID_HDMI_VIDEO_PRESENT_MASK;
+ DPRINTF("EDID HDMI Video Present = 0x%x\n",VSDBHdmiVideoPre);
+ } else { // data related to 3D format is not available
+ return 0;
+ }
+
+ // check if latency field is available
+ latency_offset = (gEdidData[StartAddr + EDID_HDMI_EXT_POS]
+ & EDID_HDMI_LATENCY_MASK) >> EDID_HDMI_LATENCY_POS;
+ if (latency_offset == 0)
+ latency_offset = 4;
+ else if (latency_offset == 3)
+ latency_offset = 0;
+ else
+ latency_offset = 2;
+
+ StartAddr -= latency_offset;
+
+ // HDMI_VIC_LEN
+ HDMIVICLen = (gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS]
+ & EDID_HDMI_VSDB_VIC_LEN_MASK) >> EDID_HDMI_VSDB_VIC_LEN_BIT;
+
+ if (pVideo->hdmi_3d_format == HDMI_VIC_FORMAT) {
+ if (HDMIVICLen) {
+ for (edid_index = 0; edid_index < (int)HDMIVICLen; edid_index++) {
+ if (vic == gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + edid_index])
+ return 1;
+ }
+ return 0;
+ } else {
+ return 0;
+ }
+ }
+
+ // HDMI_3D_LEN
+ HDMI3DLen = gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS]
+ & EDID_HDMI_VSDB_3D_LEN_MASK;
+
+ DPRINTF("HDMI VIC LENGTH[%x] = %x\r\n",
+ StartAddr + EDID_HDMI_EXT_LENGTH_POS, HDMIVICLen);
+ DPRINTF("HDMI 3D LENGTH[%x] = %x\r\n",
+ StartAddr + EDID_HDMI_EXT_LENGTH_POS, HDMI3DLen);
+
+ // check 3D_Present bit
+ if (blockLength >= (EDID_HDMI_3D_PRESENT_POS - latency_offset)) {
+ VSDB3DPresent = gEdidData[StartAddr + EDID_HDMI_3D_PRESENT_POS]
+ & EDID_HDMI_3D_PRESENT_MASK;
+ VSDB3DMultiPresent = gEdidData[StartAddr + EDID_HDMI_3D_PRESENT_POS]
+ & EDID_HDMI_3D_MULTI_PRESENT_MASK;
+ }
+
+ if (VSDB3DPresent) {
+ DPRINTF("VSDB 3D Present!!!\r\n");
+ // check with 3D madatory format
+ if (CheckResolution(pVideo->resolution, pVideo->pixelAspectRatio)) {
+ int size = sizeof(edid_3d)/sizeof(struct edid_3d_mandatory);
+ for (edid_index = 0; edid_index < size; edid_index++) {
+ if (edid_3d[edid_index].resolution == pVideo->resolution &&
+ edid_3d[edid_index].hdmi_3d_format == pVideo->hdmi_3d_format )
+ return 1;
+ }
+ }
+ }
+
+ // check 3D_Multi_Present bit
+ if (VSDB3DMultiPresent) {
+ DPRINTF("VSDB 3D Multi Present!!! = 0x%02x\r\n",VSDB3DMultiPresent);
+ // 3D Structure only
+ if (VSDB3DMultiPresent == EDID_3D_STRUCTURE_ONLY_EXIST) {
+ // 3D Structure All
+ Hdmi3DStructure = (gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + HDMIVICLen + 1] << 8);
+ Hdmi3DStructure |= gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + HDMIVICLen + 2];
+ DPRINTF("VSDB 3D Structure!!! = [0x%02x]\r\n",Hdmi3DStructure);
+ }
+
+ // 3D Structure and Mask
+ if (VSDB3DMultiPresent == EDID_3D_STRUCTURE_MASK_EXIST) {
+ // 3D Structure All
+ Hdmi3DStructure = (gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + HDMIVICLen + 1] << 8);
+ Hdmi3DStructure |= gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + HDMIVICLen + 2];
+ // 3D Structure Mask
+ Hdmi3DMask |= (gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + HDMIVICLen + 3] << 8);
+ Hdmi3DMask |= gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + HDMIVICLen + 4];
+ DPRINTF("VSDB 3D Structure!!! = [0x%02x]\r\n",Hdmi3DStructure);
+ DPRINTF("VSDB 3D Mask!!! = [0x%02x]\r\n",Hdmi3DMask);
+ DPRINTF("Current 3D Video format!!! = [%d]\r\n",pVideo->hdmi_3d_format);
+ DPRINTF("Current 3D Video format!!! = [0x%02x]\r\n",1<<pVideo->hdmi_3d_format);
+ }
+
+ // check 3D Structure and Mask
+ if (Hdmi3DStructure & (1<<pVideo->hdmi_3d_format)) {
+ DPRINTF("VSDB 3D Structure Contains Current Video Structure!!!\r\n");
+ // check first 16 EDID
+ for (edid_index = 0; edid_index < NUM_OF_VIC_FOR_3D; edid_index++) {
+ DPRINTF("VIC = %d, EDID Vic = %d!!!\r\n",vic,aVIC[edid_index]);
+ if (Hdmi3DMask & (1<<edid_index)) {
+ if (vic == aVIC[edid_index]) {
+ DPRINTF("VSDB 3D Mask Contains Current Video format!!!\r\n");
+ return 1;
+ }
+ }
+ }
+ }
+ }
+
+ // check block length if HDMI_VIC or HDMI Multi available
+ if (blockLength >= (EDID_HDMI_EXT_LENGTH_POS - latency_offset)) {
+ unsigned int HDMI3DExtLen = HDMI3DLen - (VSDB3DMultiPresent>>EDID_HDMI_3D_MULTI_PRESENT_BIT)*2;
+ unsigned int VICOrder;
+
+ // check if there is 3D extra data ?
+ //TODO: check 3D_Detail in case of SSH
+ if (HDMI3DExtLen) {
+ // check HDMI 3D Extra Data
+ for (edid_index = 0; edid_index < (int)(HDMI3DExtLen / 2); edid_index++) {
+ VICOrder = gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + HDMIVICLen +
+ (VSDB3DMultiPresent>>EDID_HDMI_3D_MULTI_PRESENT_BIT) * 2 + edid_index * 2]
+ & EDID_HDMI_2D_VIC_ORDER_MASK;
+ VICOrder = (1<<VICOrder);
+ Hdmi3DStructure = gEdidData[StartAddr + EDID_HDMI_EXT_LENGTH_POS + HDMIVICLen +
+ (VSDB3DMultiPresent>>EDID_HDMI_3D_MULTI_PRESENT_BIT) * 2 + edid_index * 2]
+ & EDID_HDMI_3D_STRUCTURE_MASK;
+ Hdmi3DStructure = (1<<Hdmi3DStructure);
+ if (Hdmi3DStructure == pVideo->hdmi_3d_format && vic == aVIC[VICOrder])
+ return 1;
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Initialize EDID library. This will intialize DDC library.
+ * @return If success, return 1; Otherwise, return 0.
+ */
+int EDIDOpen(void)
+{
+ // init DDC
+ return DDCOpen();
+}
+
+/**
+ * Finalize EDID library. This will finalize DDC library.
+ * @return If success, return 1; Otherwise, return 0.
+ */
+int EDIDClose(void)
+{
+ // reset EDID
+ EDIDReset();
+
+ // close EDDC
+ return DDCClose();
+}
+
+/**
+ * Read EDID data of Rx.
+ * @return If success, return 1; Otherwise, return 0;
+ */
+int EDIDRead(void)
+{
+ int block,dataPtr;
+ unsigned char temp[SIZEOFEDIDBLOCK];
+
+ // if already read??
+ if (EDIDValid())
+ return 1;
+
+ // read EDID Extension Number
+ // read EDID
+ if (!ReadEDIDBlock(0,temp))
+ return 0;
+
+ // get extension
+ gExtensions = temp[EDID_EXTENSION_NUMBER_POS];
+
+ // prepare buffer
+ gEdidData = (unsigned char*)malloc((gExtensions+1)*SIZEOFEDIDBLOCK);
+ if (!gEdidData)
+ return 0;
+
+ // copy EDID Block 0
+ memcpy(gEdidData,temp,SIZEOFEDIDBLOCK);
+
+ // read EDID Extension
+ for (block = 1,dataPtr = SIZEOFEDIDBLOCK; block <= gExtensions; block++,dataPtr+=SIZEOFEDIDBLOCK) {
+ // read extension 1~gExtensions
+ if (!ReadEDIDBlock(block, gEdidData+dataPtr)) {
+ // reset buffer
+ EDIDReset();
+ return 0;
+ }
+ }
+
+ // check if extension is more than 1, and first extension block is not block map.
+ if (gExtensions > 1 && gEdidData[SIZEOFEDIDBLOCK] != EDID_BLOCK_MAP_EXT_TAG_VAL) {
+ // reset buffer
+ DPRINTF("EDID has more than 1 extension but, first extension block is not block map\n");
+ EDIDReset();
+ return 0;
+ }
+
+ return 1;
+}
+
+/**
+ * Reset stored EDID data.
+ */
+void EDIDReset(void)
+{
+ if (gEdidData) {
+ free(gEdidData);
+ gEdidData = NULL;
+ DPRINTF("\t\t\t\tEDID is reset!!!\n");
+ }
+}
+
+/**
+ * Get CEC physical address.
+ * @param outAddr [out] CEC physical address. LSB 2 bytes is available. [0:0:AB:CD]
+ * @return If success, return 1; Otherwise, return 0.
+ */
+int EDIDGetCECPhysicalAddress(int* const outAddr)
+{
+ int i;
+ unsigned int StartAddr;
+
+ // check EDID data is valid or not
+ // read EDID
+ if (!EDIDRead())
+ return 0;
+
+ // find VSDB
+ for (i = 1; i <= gExtensions; i++) {
+ if (IsTimingExtension(i) // if it's timing block
+ && (StartAddr = GetVSDBOffset(i)) > 0) { // check block
+ // get supported DC value
+ // int tempDC1 = (int)(gEdidData[tempAddr+EDID_DC_POS]);
+ int phyAddr = gEdidData[StartAddr + EDID_CEC_PHYICAL_ADDR] << 8;
+ phyAddr |= gEdidData[StartAddr + EDID_CEC_PHYICAL_ADDR+1];
+
+ DPRINTF("phyAddr = %x\n",phyAddr);
+
+ *outAddr = phyAddr;
+
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Check if Rx supports HDMI/DVI mode or not.
+ * @param video [in] HDMI or DVI mode to check
+ * @return If Rx supports requested mode, return 1; Otherwise, return 0.
+ */
+int EDIDHDMIModeSupport(struct HDMIVideoParameter * const video)
+{
+ // check if read edid?
+ if (!EDIDRead()) {
+ DPRINTF("EDID Read Fail!!!\n");
+ return 0;
+ }
+
+ // check hdmi mode
+ if (video->mode == HDMI) {
+ if (!CheckHDMIMode()) {
+ DPRINTF("HDMI mode Not Supported\n");
+ return 0;
+ }
+ }
+ return 1;
+}
+
+/**
+ * Check if Rx supports requested video resoultion or not.
+ * @param video [in] Video parameters to check
+ * @return If Rx supports video parameters, return 1; Otherwise, return 0.
+ */
+int EDIDVideoResolutionSupport(struct HDMIVideoParameter * const video)
+{
+ unsigned int TMDSClock;
+ unsigned int MaxTMDS = 0;
+
+ // check if read edid?
+ if (!EDIDRead()) {
+ DPRINTF("EDID Read Fail!!!\n");
+ return 0;
+ }
+
+ // get max tmds
+ MaxTMDS = GetMaxTMDS()*5;
+
+ // Check MAX TMDS
+ TMDSClock = aVideoParams[video->resolution].PixelClock/100;
+ if (video->colorDepth == HDMI_CD_36)
+ TMDSClock *= 1.5;
+ else if (video->colorDepth == HDMI_CD_30)
+ TMDSClock *=1.25;
+
+ DPRINTF("MAX TMDS = %d, Current TMDS = %d\n",MaxTMDS, TMDSClock);
+ if (MaxTMDS != 0 && MaxTMDS < TMDSClock) {
+ DPRINTF("Pixel clock is beyond Maximun TMDS in EDID\n");
+ return 0;
+ }
+
+ // check resolution
+ if (!CheckResolution(video->resolution,video->pixelAspectRatio)) {
+ DPRINTF("Video Resolution Not Supported\n");
+ return 0;
+ }
+
+ // check 3D format
+ if (!EDID3DFormatSupport(video)) {
+ DPRINTF("3D Format Not Supported\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+/**
+ * Check if Rx supports requested color depth or not.
+ * @param video [in] Video parameters to check
+ * @return If Rx supports video parameters, return 1; Otherwise, return 0.
+ */
+int EDIDColorDepthSupport(struct HDMIVideoParameter * const video)
+{
+ // check if read edid?
+ if (!EDIDRead()) {
+ DPRINTF("EDID Read Fail!!!\n");
+ return 0;
+ }
+
+ // check resolution
+ if (!CheckColorDepth(video->colorDepth,video->colorSpace)) {
+ DPRINTF("Color Depth Not Supported\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+/**
+ * Check if Rx supports requested color space or not.
+ * @param video [in] Video parameters to check
+ * @return If Rx supports video parameters, return 1; Otherwise, return 0.
+ */
+int EDIDColorSpaceSupport(struct HDMIVideoParameter * const video)
+{
+ // check if read edid?
+ if (!EDIDRead()) {
+ DPRINTF("EDID Read Fail!!!\n");
+ return 0;
+ }
+ // check color space
+ if (!CheckColorSpace(video->colorSpace)) {
+ DPRINTF("Color Space Not Supported\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+/**
+ * Check if Rx supports requested colorimetry or not.
+ * @param video [in] Video parameters to check
+ * @return If Rx supports video parameters, return 1; Otherwise, return 0.
+ */
+int EDIDColorimetrySupport(struct HDMIVideoParameter * const video)
+{
+ // check if read edid?
+ if (!EDIDRead()) {
+ DPRINTF("EDID Read Fail!!!\n");
+ return 0;
+ }
+
+ // check colorimetry
+ if (!CheckColorimetry(video->colorimetry)) {
+ DPRINTF("Colorimetry Not Supported\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+/**
+ * Check if Rx supports requested audio parameters or not.
+ * @param audio [in] Audio parameters to check
+ * @return If Rx supports audio parameters, return 1; Otherwise, return 0.
+ */
+int EDIDAudioModeSupport(struct HDMIAudioParameter * const audio)
+{
+ int i;
+
+ // read EDID
+ if (!EDIDRead()) {
+ DPRINTF("EDID Read Fail!!!\n");
+ return 0;
+ }
+
+ // check EDID Extension
+ // find timing block
+ for (i = 1; i <= gExtensions; i++) {
+ if (IsTimingExtension(i)) { // if it's timing block
+ // find Short Audio Description
+ unsigned int StartAddr = i*SIZEOFEDIDBLOCK;
+ unsigned int ExtAddr = StartAddr + EDID_DATA_BLOCK_START_POS;
+ unsigned int tag,blockLen;
+ unsigned int DTDStartAddr = gEdidData[StartAddr + EDID_DETAILED_TIMING_OFFSET_POS];
+
+ while (ExtAddr < StartAddr + DTDStartAddr) {
+ // find the block tag and length
+ // tag
+ tag = gEdidData[ExtAddr] & EDID_TAG_CODE_MASK;
+ // block len
+ blockLen = (gEdidData[ExtAddr] & EDID_DATA_BLOCK_SIZE_MASK) + 1;
+
+ DPRINTF("tag = %d\n",tag);
+ DPRINTF("blockLen = %d\n",blockLen-1);
+
+ // check if it is short video description
+ if (tag == EDID_SHORT_AUD_DEC_TAG_VAL) {
+ // if so, check SAD
+ unsigned int j, channelNum;
+ int audioFormat,sampleFreq,wordLen;
+ for (j = 1; j < blockLen; j += 3) {
+ audioFormat = gEdidData[ExtAddr+j] & EDID_SAD_CODE_MASK;
+ channelNum = gEdidData[ExtAddr+j] & EDID_SAD_CHANNEL_MASK;
+ sampleFreq = gEdidData[ExtAddr+j+1];
+ wordLen = gEdidData[ExtAddr+j+2];
+
+ DPRINTF("request = %d, EDIDAudioFormatCode = %d\n",(audio->formatCode)<<3, audioFormat);
+ DPRINTF("request = %d, EDIDChannelNumber= %d\n",(audio->channelNum)-1, channelNum);
+ DPRINTF("request = %d, EDIDSampleFreq= %d\n",1<<(audio->sampleFreq), sampleFreq);
+ DPRINTF("request = %d, EDIDWordLeng= %d\n",1<<(audio->wordLength), wordLen);
+
+ // check parameter
+ // check audioFormat
+ if (audioFormat & ( (audio->formatCode) << 3) && // format code
+ channelNum >= ( (audio->channelNum) -1) && // channel number
+ (sampleFreq & (1<<(audio->sampleFreq)))) { // sample frequency
+ if (audioFormat == LPCM_FORMAT) { // check wordLen
+ int ret = 0;
+ switch (audio->wordLength) {
+ case WORD_16:
+ case WORD_17:
+ case WORD_18:
+ case WORD_19:
+ case WORD_20:
+ ret = wordLen & (1<<1);
+ break;
+ case WORD_21:
+ case WORD_22:
+ case WORD_23:
+ case WORD_24:
+ ret = wordLen & (1<<2);
+ break;
+ }
+ return ret;
+ }
+ return 1; // if not LPCM
+ }
+ }
+ }
+ // else find next block
+ ExtAddr += blockLen;
+ }
+ }
+ }
+
+ return 0;
+}
diff --git a/exynos4/hal/libhdmi/libsForhdmi/libedid/libedid.h b/exynos4/hal/libhdmi/libsForhdmi/libedid/libedid.h
new file mode 100644
index 0000000..dfd3096
--- /dev/null
+++ b/exynos4/hal/libhdmi/libsForhdmi/libedid/libedid.h
@@ -0,0 +1,42 @@
+/*
+ * 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 _LIBEDID_H_
+#define _LIBEDID_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "video.h"
+#include "audio.h"
+
+int EDIDOpen(void);
+int EDIDRead(void);
+void EDIDReset(void);
+int EDIDHDMIModeSupport(struct HDMIVideoParameter *video);
+int EDIDVideoResolutionSupport(struct HDMIVideoParameter *video);
+int EDIDColorDepthSupport(struct HDMIVideoParameter *video);
+int EDIDColorSpaceSupport(struct HDMIVideoParameter *video);
+int EDIDColorimetrySupport(struct HDMIVideoParameter *video);
+int EDIDAudioModeSupport(struct HDMIAudioParameter *audio);
+int EDIDGetCECPhysicalAddress(int* outAddr);
+int EDIDClose(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* _LIBEDID_H_ */
diff --git a/exynos4/hal/libhwcomposer/Android.mk b/exynos4/hal/libhwcomposer/Android.mk
new file mode 100644
index 0000000..902a72f
--- /dev/null
+++ b/exynos4/hal/libhwcomposer/Android.mk
@@ -0,0 +1,88 @@
+# 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
+
+ifeq ($(BOARD_USE_V4L2_ION),true)
+LOCAL_SHARED_LIBRARIES += libion
+endif
+
+LOCAL_C_INCLUDES := \
+ $(LOCAL_PATH)/../include
+
+LOCAL_SRC_FILES := SecHWCLog.cpp SecHWCUtils.cpp SecHWC.cpp
+
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/../libfimg
+
+ifeq ($(TARGET_SOC),exynos4210)
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4210
+endif
+
+ifeq ($(TARGET_SOC),exynos4x12)
+LOCAL_CFLAGS += -DSAMSUNG_EXYNOS4x12
+endif
+
+ifeq ($(BOARD_USES_HDMI),true)
+LOCAL_C_INCLUDES += \
+ $(TARGET_HAL_PATH)/libhwcomposer \
+ $(TARGET_HAL_PATH)/include \
+ $(TARGET_HAL_PATH)/libhdmi/libhdmiservice
+
+LOCAL_SHARED_LIBRARIES += libhdmiclient libTVOut
+
+LOCAL_CFLAGS += -DBOARD_USES_HDMI
+LOCAL_CFLAGS += -DBOARD_HDMI_STD=$(BOARD_HDMI_STD)
+LOCAL_CFLAGS += -DVIDEO_DUAL_DISPLAY
+
+ifeq ($(BOARD_USES_HDMI_SUBTITLES),true)
+ LOCAL_CFLAGS += -DBOARD_USES_HDMI_SUBTITLES
+endif
+
+ifeq ($(BOARD_HDMI_STD), STD_NTSC_M)
+LOCAL_CFLAGS += -DSTD_NTSC_M
+endif
+
+ifeq ($(BOARD_HDMI_STD),STD_480P)
+LOCAL_CFLAGS += -DSTD_480P
+endif
+
+ifeq ($(BOARD_HDMI_STD),STD_720P)
+LOCAL_CFLAGS += -DSTD_720P
+endif
+
+ifeq ($(BOARD_HDMI_STD),STD_1080P)
+LOCAL_CFLAGS += -DSTD_1080P
+endif
+endif
+
+ifeq ($(BOARD_USE_V4L2),true)
+LOCAL_CFLAGS += -DBOARD_USE_V4L2
+endif
+
+ifeq ($(BOARD_USE_V4L2_ION),true)
+LOCAL_CFLAGS += -DBOARD_USE_V4L2_ION
+endif
+
+LOCAL_MODULE := hwcomposer.$(TARGET_BOARD_PLATFORM)
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/hal/libhwcomposer/SecHWC.cpp b/exynos4/hal/libhwcomposer/SecHWC.cpp
new file mode 100644
index 0000000..d2f3ecc
--- /dev/null
+++ b/exynos4/hal/libhwcomposer/SecHWC.cpp
@@ -0,0 +1,957 @@
+/*
+ * 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-03-11
+ *
+ */
+
+#include <cutils/log.h>
+#include <cutils/atomic.h>
+
+#include <EGL/egl.h>
+
+#include "SecHWCUtils.h"
+
+#include "gralloc_priv.h"
+#ifdef HWC_HWOVERLAY
+#include <GLES/gl.h>
+#endif
+#if defined(BOARD_USES_HDMI)
+#include "SecHdmiClient.h"
+#include "SecTVOutService.h"
+
+#include "SecHdmi.h"
+
+//#define CHECK_EGL_FPS
+#ifdef CHECK_EGL_FPS
+extern void check_fps();
+#endif
+
+static int lcd_width, lcd_height;
+static int prev_usage = 0;
+
+#define CHECK_TIME_DEBUG 0
+#define SUPPORT_AUTO_UI_ROTATE
+#endif
+int testRenderNum =0;
+
+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,
+ version_major: 1,
+ version_minor: 0,
+ id: HWC_HARDWARE_MODULE_ID,
+ name: "Samsung S5PC21X hwcomposer module",
+ author: "SAMSUNG",
+ methods: &hwc_module_methods,
+ }
+};
+
+/*****************************************************************************/
+
+static void dump_layer(hwc_layer_t const* l) {
+ LOGD("\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);
+}
+
+void calculate_rect(struct hwc_win_info_t *win, hwc_layer_t *cur,
+ sec_rect *rect)
+{
+ rect->x = cur->displayFrame.left;
+ rect->y = cur->displayFrame.top;
+ rect->w = cur->displayFrame.right - cur->displayFrame.left;
+ rect->h = cur->displayFrame.bottom - cur->displayFrame.top;
+
+ if (rect->x < 0) {
+ if (rect->w + rect->x > win->lcd_info.xres)
+ rect->w = win->lcd_info.xres;
+ else
+ rect->w = rect->w + rect->x;
+ rect->x = 0;
+ } else {
+ if (rect->w + rect->x > win->lcd_info.xres)
+ rect->w = win->lcd_info.xres - rect->x;
+ }
+ if (rect->y < 0) {
+ if (rect->h + rect->y > win->lcd_info.yres)
+ rect->h = win->lcd_info.yres;
+ else
+ rect->h = rect->h + rect->y;
+ rect->y = 0;
+ } else {
+ if (rect->h + rect->y > win->lcd_info.yres)
+ rect->h = win->lcd_info.yres - rect->y;
+ }
+}
+
+static int set_src_dst_img_rect(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)
+{
+ private_handle_t *prev_handle = (private_handle_t *)(cur->handle);
+ sec_rect rect;
+
+ /* 1. Set src_img from prev_handle */
+ src_img->f_w = prev_handle->width;
+ src_img->f_h = prev_handle->height;
+ src_img->w = prev_handle->width;
+ src_img->h = prev_handle->height;
+ src_img->format = prev_handle->format;
+ src_img->base = (uint32_t)prev_handle->base;
+ src_img->offset = prev_handle->offset;
+ src_img->mem_id = prev_handle->fd;
+ src_img->paddr = prev_handle->paddr;
+ src_img->usage = prev_handle->usage;
+ src_img->uoffset = prev_handle->uoffset;
+ src_img->voffset = prev_handle->voffset;
+
+ src_img->mem_type = HWC_VIRT_MEM_TYPE;
+
+ switch (src_img->format) {
+ case HAL_PIXEL_FORMAT_YV12: /* To support video editor */
+ case HAL_PIXEL_FORMAT_YCbCr_420_P: /* To support SW codec */
+ case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+ case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED:
+ 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:
+ src_img->f_w = (src_img->f_w + 15) & ~15;
+ src_img->f_h = (src_img->f_h + 1) & ~1;
+ break;
+ default:
+ src_img->f_w = src_img->w;
+ src_img->f_h = src_img->h;
+ break;
+ }
+
+ /* 2. Set dst_img from window(lcd) */
+ calculate_rect(win, cur, &rect);
+ dst_img->f_w = win->lcd_info.xres;
+ dst_img->f_h = win->lcd_info.yres;
+ dst_img->w = rect.w;
+ dst_img->h = rect.h;
+
+ 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;
+
+ /* 3. Set src_rect(crop rect) */
+ if (cur->displayFrame.left < 0) {
+ src_rect->x =
+ (0 - cur->displayFrame.left)
+ *(src_img->w)
+ /(cur->displayFrame.right - cur->displayFrame.left + 1);
+ if (cur->displayFrame.right + 1 > win->lcd_info.xres) {
+ src_rect->w =
+ (cur->sourceCrop.right - cur->sourceCrop.left + 1) -
+ src_rect->x -
+ (cur->displayFrame.right - win->lcd_info.xres)
+ *(src_img->w)
+ /(cur->displayFrame.right - cur->displayFrame.left + 1);
+ } else {
+ src_rect->w =
+ (cur->sourceCrop.right - cur->sourceCrop.left + 1) -
+ src_rect->x;
+ }
+ } else {
+ src_rect->x = cur->sourceCrop.left;
+ if (cur->displayFrame.right + 1 > win->lcd_info.xres) {
+ src_rect->w =
+ (cur->sourceCrop.right - cur->sourceCrop.left + 1) -
+ src_rect->x -
+ (cur->displayFrame.right - win->lcd_info.xres)
+ *(src_img->w)
+ /(cur->displayFrame.right - cur->displayFrame.left + 1);
+ } else {
+ src_rect->w =
+ (cur->sourceCrop.right - cur->sourceCrop.left + 1);
+ }
+ }
+ if (cur->displayFrame.top < 0) {
+ src_rect->y =
+ (0 - cur->displayFrame.top)
+ *(src_img->h)
+ /(cur->displayFrame.bottom - cur->displayFrame.top + 1);
+ if (cur->displayFrame.bottom + 1 > win->lcd_info.yres) {
+ src_rect->h =
+ (cur->sourceCrop.bottom - cur->sourceCrop.top + 1) -
+ src_rect->y -
+ (cur->displayFrame.bottom - win->lcd_info.yres)
+ *(src_img->h)
+ /(cur->displayFrame.bottom - cur->displayFrame.top + 1);
+ } else {
+ src_rect->h =
+ (cur->sourceCrop.bottom - cur->sourceCrop.top + 1) -
+ src_rect->y;
+ }
+ } else {
+ src_rect->y = cur->sourceCrop.top;
+ if (cur->displayFrame.bottom + 1 > win->lcd_info.yres) {
+ src_rect->h =
+ (cur->sourceCrop.bottom - cur->sourceCrop.top + 1) -
+ src_rect->y -
+ (cur->displayFrame.bottom - win->lcd_info.yres)
+ *(src_img->h)
+ /(cur->displayFrame.bottom - cur->displayFrame.top + 1);
+ } else {
+ src_rect->h =
+ (cur->sourceCrop.bottom - cur->sourceCrop.top + 1);
+ }
+ }
+
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "crop information()::"
+ "sourceCrop left(%d),top(%d),right(%d),bottom(%d),"
+ "src_rect x(%d),y(%d),w(%d),h(%d),"
+ "prev_handle w(%d),h(%d)",
+ cur->sourceCrop.left,
+ cur->sourceCrop.top,
+ cur->sourceCrop.right,
+ cur->sourceCrop.bottom,
+ src_rect->x, src_rect->y, src_rect->w, src_rect->h,
+ prev_handle->width, prev_handle->height);
+
+ src_rect->x = SEC_MAX(src_rect->x, 0);
+ src_rect->y = SEC_MAX(src_rect->y, 0);
+ src_rect->w = SEC_MAX(src_rect->w, 0);
+ src_rect->w = SEC_MIN(src_rect->w, prev_handle->width);
+ src_rect->h = SEC_MAX(src_rect->h, 0);
+ src_rect->h = SEC_MIN(src_rect->h, prev_handle->height);
+
+ /* 4. Set dst_rect(fb or lcd)
+ * 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;
+
+ /* Summery */
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "set_src_dst_img_rect()::"
+ "SRC w(%d),h(%d),f_w(%d),f_h(%d),fmt(0x%x),"
+ "base(0x%x),offset(%d),paddr(0x%X),mem_id(%d),mem_type(%d)=>\r\n"
+ " DST w(%d),h(%d),f(0x%x),base(0x%x),"
+ "offset(%d),mem_id(%d),mem_type(%d),"
+ "rot(%d),win_idx(%d)"
+ " SRC_RECT x(%d),y(%d),w(%d),h(%d)=>"
+ "DST_RECT x(%d),y(%d),w(%d),h(%d)",
+ src_img->w, src_img->h, src_img->f_w, src_img->f_h, src_img->format,
+ src_img->base, src_img->offset, src_img->paddr, src_img->mem_id, src_img->mem_type,
+ dst_img->w, dst_img->h, dst_img->format, dst_img->base,
+ dst_img->offset, dst_img->mem_id, dst_img->mem_type,
+ cur->transform, win_idx,
+ 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, int iter, int win_cnt)
+{
+ if(cur->flags & HWC_SKIP_LAYER || !cur->handle) {
+ SEC_HWC_Log(HWC_LOG_DEBUG, "%s::is_skip_layer %d cur->handle %x ",
+ __func__, cur->flags & HWC_SKIP_LAYER, cur->handle);
+
+ return HWC_FRAMEBUFFER;
+ }
+
+ private_handle_t *prev_handle = (private_handle_t *)(cur->handle);
+ int compositionType = HWC_FRAMEBUFFER;
+
+ if (iter == 0) {
+ /* check here....if we have any resolution constraints */
+ if (((cur->sourceCrop.right - cur->sourceCrop.left + 1) < 16) ||
+ ((cur->sourceCrop.bottom - cur->sourceCrop.top + 1) < 8))
+ return compositionType;
+
+ if ((cur->transform == HAL_TRANSFORM_ROT_90) ||
+ (cur->transform == HAL_TRANSFORM_ROT_270)) {
+ if (((cur->displayFrame.right - cur->displayFrame.left + 1) < 4) ||
+ ((cur->displayFrame.bottom - cur->displayFrame.top + 1) < 8))
+ return compositionType;
+ } else if (((cur->displayFrame.right - cur->displayFrame.left + 1) < 8) ||
+ ((cur->displayFrame.bottom - cur->displayFrame.top + 1) < 4)) {
+ return compositionType;
+ }
+
+ switch (prev_handle->format) {
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED:
+ compositionType = HWC_OVERLAY;
+ break;
+ case HAL_PIXEL_FORMAT_YV12: /* YCrCb_420_P */
+ case HAL_PIXEL_FORMAT_YCbCr_420_P:
+ case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+ case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+ if ((prev_handle->usage & GRALLOC_USAGE_HWC_HWOVERLAY) &&
+ (cur->blending == HWC_BLENDING_NONE))
+ compositionType = HWC_OVERLAY;
+ else
+ compositionType = HWC_FRAMEBUFFER;
+ break;
+ default:
+ compositionType = HWC_FRAMEBUFFER;
+ break;
+ }
+ }
+
+#ifdef SUB_TITLES_HWC
+ else if ((win_cnt > 0) &&
+ (prev_handle->usage & GRALLOC_USAGE_EXTERNAL_DISP)) {
+ switch (prev_handle->format) {
+ case HAL_PIXEL_FORMAT_RGBA_8888:
+ case HAL_PIXEL_FORMAT_RGBX_8888:
+ case HAL_PIXEL_FORMAT_BGRA_8888:
+ case HAL_PIXEL_FORMAT_RGB_888:
+ case HAL_PIXEL_FORMAT_RGB_565:
+ case HAL_PIXEL_FORMAT_RGBA_5551:
+ case HAL_PIXEL_FORMAT_RGBA_4444:
+ compositionType = HWC_OVERLAY;
+ break;
+ default:
+ compositionType = HWC_FRAMEBUFFER;
+ break;
+ }
+
+ SEC_HWC_Log(HWC_LOG_DEBUG, "2nd iter###%s:: compositionType %d bpp %d"
+ " format %x src[%d %d %d %d] dst[%d %d %d %d] srcImg[%d %d]",
+ __func__, compositionType, prev_handle->bpp,
+ prev_handle->format,
+ cur->sourceCrop.left, cur->sourceCrop.right,
+ cur->sourceCrop.top, cur->sourceCrop.bottom,
+ cur->displayFrame.left, cur->displayFrame.right,
+ cur->displayFrame.top, cur->displayFrame.bottom,
+ prev_handle->width, prev_handle->height);
+ }
+#endif
+
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "%s::compositionType(%d)=>0:FB,1:OVERLAY \r\n"
+ " format(0x%x),magic(0x%x),flags(%d),size(%d),offset(%d)"
+ "b_addr(0x%x),usage(%d),w(%d),h(%d),bpp(%d)",
+ "get_hwc_compos_decision()", compositionType,
+ prev_handle->format, prev_handle->magic, prev_handle->flags,
+ prev_handle->size, prev_handle->offset, prev_handle->base,
+ prev_handle->usage, prev_handle->width, prev_handle->height,
+ prev_handle->bpp);
+
+ return compositionType;
+}
+
+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 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];
+
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "%s:: left(%d),top(%d),right(%d),bottom(%d),transform(%d)"
+ "lcd_info.xres(%d),lcd_info.yres(%d)",
+ "++assign_overlay_window()",
+ cur->displayFrame.left, cur->displayFrame.top,
+ cur->displayFrame.right, cur->displayFrame.bottom, cur->transform,
+ win->lcd_info.xres, win->lcd_info.yres);
+
+ calculate_rect(win, cur, &rect);
+
+ 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;
+ //turnoff the window and set the window position with new conf...
+ if (window_set_pos(win) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_set_pos is failed : %s",
+ __func__, strerror(errno));
+ ret = -1;
+ }
+ ctx->layer_prev_buf[win_idx] = 0;
+ }
+
+ win->layer_index = layer_idx;
+ win->status = HWC_WIN_RESERVED;
+
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "%s:: win_x %d win_y %d win_w %d win_h %d lay_idx %d win_idx %d\n",
+ "--assign_overlay_window()",
+ win->rect_info.x, win->rect_info.y, win->rect_info.w,
+ win->rect_info.h, win->layer_index, win_idx );
+
+ return 0;
+}
+
+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;
+ ctx->num_2d_blit_layer = 0;
+
+ 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, 0, overlay_win_cnt);
+
+ 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) {
+ LOGE("assign_overlay_window fail, change to frambuffer");
+ 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++;
+ }
+ }
+
+#ifdef SUB_TITLES_HWC
+ for (int i = 0; i < list->numHwLayers ; i++) {
+ if (overlay_win_cnt < NUM_OF_WIN) {
+ hwc_layer_t* cur = &list->hwLayers[i];
+ if (get_hwc_compos_decision(cur, 1, overlay_win_cnt) == HWC_OVERLAY) {
+ ret = assign_overlay_window(ctx, cur, overlay_win_cnt, i);
+ if (ret == 0) {
+ cur->compositionType = HWC_OVERLAY;
+ cur->hints = HWC_HINT_CLEAR_FB;
+ overlay_win_cnt++;
+ ctx->num_of_hwc_layer++;
+ ctx->num_of_fb_layer--;
+ ctx->num_2d_blit_layer = 1;
+ }
+ }
+ }
+ else
+ break;
+ }
+#endif
+
+#if defined(BOARD_USES_HDMI)
+ android::SecHdmiClient *mHdmiClient = android::SecHdmiClient::getInstance();
+ mHdmiClient->setHdmiHwcLayer(ctx->num_of_hwc_layer);
+#endif
+
+ if (list->numHwLayers != (ctx->num_of_fb_layer + ctx->num_of_hwc_layer))
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "%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;
+ int skipped_window_mask = 0;
+ hwc_layer_t* cur;
+ struct hwc_win_info_t *win;
+ int ret;
+ int pmem_phyaddr;
+ static int egl_check;
+ int egl_run = 0;
+ struct sec_img src_img;
+ struct sec_img dst_img;
+ struct sec_rect src_work_rect;
+ struct sec_rect dst_work_rect;
+
+ memset(&src_img, 0, sizeof(src_img));
+ memset(&dst_img, 0, sizeof(dst_img));
+ memset(&src_work_rect, 0, sizeof(src_work_rect));
+ memset(&dst_work_rect, 0, sizeof(dst_work_rect));
+
+#if defined(BOARD_USES_HDMI)
+ int skip_hdmi_rendering = 0;
+ int rotVal = 0;
+#endif
+
+ 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;
+
+ if (sur == NULL && dpy == NULL)
+ return HWC_EGL_ERROR;
+ }
+
+ if(ctx->num_of_hwc_layer > NUM_OF_WIN)
+ ctx->num_of_hwc_layer = NUM_OF_WIN;
+
+ //compose hardware layers here
+ for (int i = 0; i < ctx->num_of_hwc_layer - ctx->num_2d_blit_layer; i++) {
+ win = &ctx->win[i];
+ if (win->status == HWC_WIN_RESERVED) {
+ cur = &list->hwLayers[win->layer_index];
+
+ if (cur->compositionType == HWC_OVERLAY) {
+ if (ctx->layer_prev_buf[i] == (uint32_t)cur->handle) {
+ /*
+ * In android platform, all the graphic buffer are at least
+ * double buffered (2 or more) this buffer is already rendered.
+ * It is the redundant src buffer for FIMC rendering.
+ */
+ LOGD("SKIP FIMC rendering for Layer%d", win->layer_index);
+#if defined(BOARD_USES_HDMI)
+ skip_hdmi_rendering = 1;
+#endif
+ continue;
+ }
+ ctx->layer_prev_buf[i] = (uint32_t)cur->handle;
+ // initialize the src & dist context for fimc
+ set_src_dst_img_rect(cur, win, &src_img, &dst_img,
+ &src_work_rect, &dst_work_rect, i);
+
+ ret = runFimc(ctx,
+ &src_img, &src_work_rect,
+ &dst_img, &dst_work_rect,
+ cur->transform);
+
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::runFimc fail : ret=%d\n",
+ __func__, ret);
+ skipped_window_mask |= (1 << i);
+ continue;
+ }
+
+ window_pan_display(win);
+
+ win->buf_index = (win->buf_index + 1) % NUM_OF_WIN_BUF;
+ if (win->power_state == 0)
+ window_show(win);
+ } else {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%s:: error : layer %d compositionType should have been"
+ " HWC_OVERLAY ", __func__, win->layer_index);
+ skipped_window_mask |= (1 << i);
+ continue;
+ }
+ } else {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s:: error : window status should have "
+ "been HWC_WIN_RESERVED by now... ", __func__);
+ skipped_window_mask |= (1 << i);
+ continue;
+ }
+ }
+
+#ifdef SUB_TITLES_HWC
+ if (ctx->num_2d_blit_layer) {
+ g2d_rect srcRect;
+ g2d_rect dstRect;
+
+ win = &ctx->win[ctx->num_of_hwc_layer - 1];
+ cur = &list->hwLayers[win->layer_index];
+ set_src_dst_g2d_rect(cur, win, &srcRect, &dstRect);
+ ret = runG2d(ctx, &srcRect, &dstRect,
+ cur->transform);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::runG2d fail : ret=%d\n",
+ __func__, ret);
+ skipped_window_mask |= (1 << (ctx->num_of_hwc_layer - 1));
+ goto g2d_error;
+ }
+
+ window_pan_display(win);
+
+ win->buf_index = (win->buf_index + 1) % NUM_OF_WIN_BUF;
+ if (win->power_state == 0)
+ window_show(win);
+ }
+
+g2d_error:
+#endif
+
+ 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]);
+ reset_win_rect_info(&ctx->win[i]);
+ }
+ }
+ }
+
+ if (0 < ctx->num_of_fb_layer) {
+#ifdef CHECK_EGL_FPS
+ check_fps();
+#endif
+#ifdef HWC_HWOVERLAY
+ unsigned char pixels[4];
+ glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+#endif
+ egl_check = 1;
+ egl_run = 1;
+ } else {
+ if (egl_check == 1) {
+ egl_check = 0;
+ egl_run = 1;
+ }
+ }
+
+ if (egl_run == 1) {
+ EGLBoolean sucess = eglSwapBuffers((EGLDisplay)dpy, (EGLSurface)sur);
+ if (!sucess)
+ return HWC_EGL_ERROR;
+ }
+
+#if defined(BOARD_USES_HDMI)
+ android::SecHdmiClient *mHdmiClient = android::SecHdmiClient::getInstance();
+
+ if (skip_hdmi_rendering == 1)
+ return 0;
+
+ if (list == NULL) {
+ // Don't display unnecessary image
+ mHdmiClient->setHdmiEnable(0);
+ return 0;
+ } else {
+ mHdmiClient->setHdmiEnable(1);
+ }
+
+#ifdef SUPPORT_AUTO_UI_ROTATE
+ cur = &list->hwLayers[0];
+
+ if (cur->transform == HAL_TRANSFORM_ROT_90 || cur->transform == HAL_TRANSFORM_ROT_270)
+ mHdmiClient->setHdmiRotate(270, ctx->num_of_hwc_layer);
+ else
+ mHdmiClient->setHdmiRotate(0, ctx->num_of_hwc_layer);
+#endif
+
+ // To support S3D video playback (automatic TV mode change to 3D mode)
+ if (ctx->num_of_hwc_layer == 1) {
+ if (src_img.usage != prev_usage)
+ mHdmiClient->setHdmiResolution(DEFAULT_HDMI_RESOLUTION_VALUE); // V4L2_STD_1080P_60
+
+ if ((src_img.usage & GRALLOC_USAGE_PRIVATE_SBS_LR) ||
+ (src_img.usage & GRALLOC_USAGE_PRIVATE_SBS_RL))
+ mHdmiClient->setHdmiResolution(7209601); // V4L2_STD_TVOUT_720P_60_SBS_HALF
+ else if ((src_img.usage & GRALLOC_USAGE_PRIVATE_TB_LR) ||
+ (src_img.usage & GRALLOC_USAGE_PRIVATE_TB_RL))
+ mHdmiClient->setHdmiResolution(1080924); // V4L2_STD_TVOUT_1080P_24_TB
+
+ prev_usage = src_img.usage;
+ } else {
+ if ((prev_usage & GRALLOC_USAGE_PRIVATE_SBS_LR) ||
+ (prev_usage & GRALLOC_USAGE_PRIVATE_SBS_RL) ||
+ (prev_usage & GRALLOC_USAGE_PRIVATE_TB_LR) ||
+ (prev_usage & GRALLOC_USAGE_PRIVATE_TB_RL))
+ mHdmiClient->setHdmiResolution(DEFAULT_HDMI_RESOLUTION_VALUE); // V4L2_STD_1080P_60
+
+ prev_usage = 0;
+ }
+
+ if (ctx->num_of_hwc_layer == 1) {
+ if ((src_img.format == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED)||
+ (src_img.format == HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP)) {
+ ADDRS * addr = (ADDRS *)(src_img.base);
+
+ mHdmiClient->blit2Hdmi(src_img.w, src_img.h,
+ src_img.format,
+ (unsigned int)addr->addr_y, (unsigned int)addr->addr_cbcr, (unsigned int)addr->addr_cbcr,
+ 0, 0,
+ android::SecHdmiClient::HDMI_MODE_VIDEO,
+ ctx->num_of_hwc_layer);
+ } else if ((src_img.format == HAL_PIXEL_FORMAT_YCbCr_420_SP) ||
+ (src_img.format == HAL_PIXEL_FORMAT_YCrCb_420_SP) ||
+ (src_img.format == HAL_PIXEL_FORMAT_YCbCr_420_P) ||
+ (src_img.format == HAL_PIXEL_FORMAT_YV12)) {
+ mHdmiClient->blit2Hdmi(src_img.w, src_img.h,
+ src_img.format,
+ (unsigned int)ctx->fimc.params.src.buf_addr_phy_rgb_y,
+ (unsigned int)ctx->fimc.params.src.buf_addr_phy_cb,
+ (unsigned int)ctx->fimc.params.src.buf_addr_phy_cr,
+ 0, 0,
+ android::SecHdmiClient::HDMI_MODE_VIDEO,
+ ctx->num_of_hwc_layer);
+ } else {
+ LOGE("%s: Unsupported format = %d", __func__, src_img.format);
+ }
+ }
+#endif
+ return 0;
+}
+
+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) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyFimc fail", __func__);
+ ret = -1;
+ }
+#ifdef SUB_TITLES_HWC
+ if (destroyG2d(&ctx->g2d) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyG2d() fail", __func__);
+ ret = -1;
+ }
+#endif
+ if (destroyMem(&ctx->s3c_mem) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyMem fail", __func__);
+ ret = -1;
+ }
+
+#ifdef USE_HW_PMEM
+ if (destroyPmem(&ctx->sec_pmem) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyPmem fail", __func__);
+ ret = -1;
+ }
+#endif
+ for (i = 0; i < NUM_OF_WIN; i++) {
+ if (window_close(&ctx->win[i]) < 0)
+ SEC_HWC_Log(HWC_LOG_DEBUG, "%s::window_close() fail", __func__);
+ }
+
+ free(ctx);
+ }
+ return ret;
+}
+
+static int hwc_device_open(const struct hw_module_t* module, const char* name,
+ struct hw_device_t** device)
+{
+ int status = 0;
+ struct hwc_win_info_t *win;
+
+ 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 = 0;
+ 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;
+
+ *device = &dev->device.common;
+
+ //initializing
+ memset(&(dev->fimc), 0, sizeof(s5p_fimc_t));
+ memset(&(dev->s3c_mem), 0, sizeof(struct s3c_mem_t));
+#ifdef USE_HW_PMEM
+ memset(&(dev->sec_pmem), 0, sizeof(sec_pmem_t));
+#endif
+ /* open WIN0 & WIN1 here */
+ for (int i = 0; i < NUM_OF_WIN; i++) {
+ if (window_open(&(dev->win[i]), i) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%s:: Failed to open window %d device ", __func__, i);
+ status = -EINVAL;
+ goto err;
+ }
+ }
+
+ if (window_get_global_lcd_info(dev->win[0].fd, &dev->lcd_info) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%s::window_get_global_lcd_info is failed : %s",
+ __func__, strerror(errno));
+ status = -EINVAL;
+ goto err;
+ }
+
+#if defined(BOARD_USES_HDMI)
+ lcd_width = dev->lcd_info.xres;
+ lcd_height = dev->lcd_info.yres;
+#endif
+
+ /* 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) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_set_pos is failed : %s",
+ __func__, strerror(errno));
+ status = -EINVAL;
+ goto err;
+ }
+
+ if (window_get_info(win, i) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_get_info is failed : %s",
+ __func__, strerror(errno));
+ status = -EINVAL;
+ goto err;
+ }
+
+ }
+
+#ifdef USE_HW_PMEM
+ if (createPmem(&dev->sec_pmem, PMEM_SIZE) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::initPmem(%d) fail", __func__, PMEM_SIZE);
+ }
+#endif
+
+ if (createMem(&dev->s3c_mem, 0, 0) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::createMem() fail (size=0)", __func__);
+ status = -EINVAL;
+ goto err;
+ }
+
+ //create PP
+ if (createFimc(&dev->fimc) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::creatFimc() fail", __func__);
+ status = -EINVAL;
+ goto err;
+ }
+
+#ifdef SUB_TITLES_HWC
+ if (createG2d(&dev->g2d) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::createG2d() fail", __func__);
+ status = -EINVAL;
+ goto err;
+ }
+#endif
+
+ SEC_HWC_Log(HWC_LOG_DEBUG, "%s:: hwc_device_open: SUCCESS", __func__);
+
+ return 0;
+
+err:
+ if (destroyFimc(&dev->fimc) < 0)
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyFimc() fail", __func__);
+#ifdef SUB_TITLES_HWC
+ if (destroyG2d(&dev->g2d) < 0)
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyG2d() fail", __func__);
+#endif
+ if (destroyMem(&dev->s3c_mem) < 0)
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyMem() fail", __func__);
+
+#ifdef USE_HW_PMEM
+ if (destroyPmem(&dev->sec_pmem) < 0)
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyPmem() fail", __func__);
+#endif
+
+ for (int i = 0; i < NUM_OF_WIN; i++) {
+ if (window_close(&dev->win[i]) < 0)
+ SEC_HWC_Log(HWC_LOG_DEBUG, "%s::window_close() fail", __func__);
+ }
+
+ return status;
+}
diff --git a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Log.c b/exynos4/hal/libhwcomposer/SecHWCLog.cpp
similarity index 67%
rename from exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Log.c
rename to exynos4/hal/libhwcomposer/SecHWCLog.cpp
index 0aa956a..6ad4283 100644
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Log.c
+++ b/exynos4/hal/libhwcomposer/SecHWCLog.cpp
@@ -1,6 +1,5 @@
/*
- *
- * Copyright 2010 Samsung Electronics S.LSI 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.
@@ -16,36 +15,32 @@
*/
/*
- * @file SEC_OSAL_Log.c
- * @brief
- * @author Yunji Kim (yunji.kim@samsung.com)
- * @version 1.1.0
- * @history
- * 2010.7.15 : Create
+ *
+ * @author Rama, Meka(v.meka@samsung.com)
+ Sangwoo, Park(sw5771.park@samsung.com)
+ Jamie Oh (jung-min.oh@samsung.com)
+ * @date 2011-03-11
+ *
*/
#include <utils/Log.h>
-#include "SEC_OSAL_Log.h"
+#include "SecHWCUtils.h"
-
-void _SEC_OSAL_Log(SEC_LOG_LEVEL logLevel, const char *tag, const char *msg, ...)
+void _SEC_HWC_Log(HWC_LOG_LEVEL logLevel, const char *tag, const char *msg, ...)
{
va_list argptr;
va_start(argptr, msg);
switch (logLevel) {
- case SEC_LOG_TRACE:
+ case HWC_LOG_DEBUG:
__android_log_vprint(ANDROID_LOG_DEBUG, tag, msg, argptr);
break;
- case SEC_LOG_INFO:
- __android_log_vprint(ANDROID_LOG_INFO, tag, msg, argptr);
- break;
- case SEC_LOG_WARNING:
+ case HWC_LOG_WARNING:
__android_log_vprint(ANDROID_LOG_WARN, tag, msg, argptr);
break;
- case SEC_LOG_ERROR:
+ case HWC_LOG_ERROR:
__android_log_vprint(ANDROID_LOG_ERROR, tag, msg, argptr);
break;
default:
diff --git a/exynos4/hal/libhwcomposer/SecHWCUtils.cpp b/exynos4/hal/libhwcomposer/SecHWCUtils.cpp
new file mode 100644
index 0000000..5214e40
--- /dev/null
+++ b/exynos4/hal/libhwcomposer/SecHWCUtils.cpp
@@ -0,0 +1,2077 @@
+/*
+ * 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.
+ */
+
+/*
+ * Revision History:
+ * - 2011/03/11 : Rama, Meka(v.meka@samsung.com)
+ * Initial version
+ *
+ * - 2011/12/07 : Jeonghee, Kim(jhhhh.kim@samsung.com)
+ * Add V4L2_PIX_FMT_YUV420M V4L2_PIX_FMT_NV12M
+ *
+ */
+
+#include "SecHWCUtils.h"
+
+#ifdef BOARD_USE_V4L2_ION
+#define V4L2_BUF_TYPE_OUTPUT V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
+#define V4L2_BUF_TYPE_CAPTURE V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
+#else
+#define V4L2_BUF_TYPE_OUTPUT V4L2_BUF_TYPE_VIDEO_OUTPUT
+#define V4L2_BUF_TYPE_CAPTURE V4L2_BUF_TYPE_VIDEO_CAPTURE
+#endif
+
+#define EXYNOS4_ALIGN( value, base ) (((value) + ((base) - 1)) & ~((base) - 1))
+
+//#define CHECK_FPS
+#ifdef CHECK_FPS
+#include <sys/time.h>
+#include <unistd.h>
+#define CHK_FRAME_CNT 30
+
+void check_fps()
+{
+ static struct timeval tick, tick_old;
+ static int total = 0;
+ static int cnt = 0;
+ int FPS;
+ cnt++;
+ gettimeofday(&tick, NULL);
+ if (cnt > 10) {
+ if (tick.tv_sec > tick_old.tv_sec)
+ total += ((tick.tv_usec/1000) + (tick.tv_sec - tick_old.tv_sec)*1000 - (tick_old.tv_usec/1000));
+ else
+ total += ((tick.tv_usec - tick_old.tv_usec)/1000);
+
+ memcpy(&tick_old, &tick, sizeof(timeval));
+ if (cnt == (10 + CHK_FRAME_CNT)) {
+ FPS = 1000*CHK_FRAME_CNT/total;
+ LOGE("[FPS]:%d\n", FPS);
+ total = 0;
+ cnt = 10;
+ }
+ } else {
+ memcpy(&tick_old, &tick, sizeof(timeval));
+ total = 0;
+ }
+}
+#endif
+
+struct yuv_fmt_list yuv_list[] = {
+ { "V4L2_PIX_FMT_NV12", "YUV420/2P/LSB_CBCR", V4L2_PIX_FMT_NV12, 12, 2 },
+ { "V4L2_PIX_FMT_NV12T", "YUV420/2P/LSB_CBCR", V4L2_PIX_FMT_NV12T, 12, 2 },
+ { "V4L2_PIX_FMT_NV21", "YUV420/2P/LSB_CRCB", V4L2_PIX_FMT_NV21, 12, 2 },
+ { "V4L2_PIX_FMT_NV21X", "YUV420/2P/MSB_CBCR", V4L2_PIX_FMT_NV21X, 12, 2 },
+ { "V4L2_PIX_FMT_NV12X", "YUV420/2P/MSB_CRCB", V4L2_PIX_FMT_NV12X, 12, 2 },
+ { "V4L2_PIX_FMT_YUV420", "YUV420/3P", V4L2_PIX_FMT_YUV420, 12, 3 },
+#ifdef BOARD_USE_V4L2_ION
+ { "V4L2_PIX_FMT_YUV420M", "YUV420/3P", V4L2_PIX_FMT_YUV420M, 12, 3 },
+ { "V4L2_PIX_FMT_NV12M", "YUV420/2P", V4L2_PIX_FMT_NV12M, 12, 2 },
+#endif
+ { "V4L2_PIX_FMT_YUYV", "YUV422/1P/YCBYCR", V4L2_PIX_FMT_YUYV, 16, 1 },
+ { "V4L2_PIX_FMT_YVYU", "YUV422/1P/YCRYCB", V4L2_PIX_FMT_YVYU, 16, 1 },
+ { "V4L2_PIX_FMT_UYVY", "YUV422/1P/CBYCRY", V4L2_PIX_FMT_UYVY, 16, 1 },
+ { "V4L2_PIX_FMT_VYUY", "YUV422/1P/CRYCBY", V4L2_PIX_FMT_VYUY, 16, 1 },
+ { "V4L2_PIX_FMT_UV12", "YUV422/2P/LSB_CBCR", V4L2_PIX_FMT_NV16, 16, 2 },
+ { "V4L2_PIX_FMT_UV21", "YUV422/2P/LSB_CRCB", V4L2_PIX_FMT_NV61, 16, 2 },
+ { "V4L2_PIX_FMT_UV12X", "YUV422/2P/MSB_CBCR", V4L2_PIX_FMT_NV16X, 16, 2 },
+ { "V4L2_PIX_FMT_UV21X", "YUV422/2P/MSB_CRCB", V4L2_PIX_FMT_NV61X, 16, 2 },
+ { "V4L2_PIX_FMT_YUV422P", "YUV422/3P", V4L2_PIX_FMT_YUV422P, 16, 3 },
+};
+
+int window_open(struct hwc_win_info_t *win, int id)
+{
+ int fd = 0;
+ char name[64];
+ int vsync = 1;
+ int real_id = id;
+
+ 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:
+#ifdef BOARD_USE_V4L2_ION
+ real_id = 2;
+#else
+ real_id = 3;
+#endif
+ break;
+ case 1:
+#ifdef BOARD_USE_V4L2_ION
+ real_id = 1;
+#else
+ real_id = 4;
+#endif
+ break;
+ default:
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::id(%d) is weird", __func__, id);
+ goto error;
+}
+
+// 0/10
+// snprintf(name, 64, device_template, id + 3);
+// 5/10
+// snprintf(name, 64, device_template, id + 0);
+// 0/10
+// snprintf(name, 64, device_template, id + 1);
+ snprintf(name, 64, device_template, real_id);
+
+ win->fd = open(name, O_RDWR);
+ if (win->fd <= 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Failed to open window device (%s) : %s",
+ __func__, strerror(errno), name);
+ goto error;
+ }
+
+#ifdef ENABLE_FIMD_VSYNC
+ if (ioctl(win->fd, S3CFB_SET_VSYNC_INT, &vsync) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::S3CFB_SET_VSYNC_INT fail", __func__);
+ goto error;
+ }
+#endif
+
+ return 0;
+
+error:
+ if (0 < win->fd)
+ close(win->fd);
+ win->fd = 0;
+
+ return -1;
+}
+
+int window_close(struct hwc_win_info_t *win)
+{
+ int ret = 0;
+
+ if (0 < win->fd) {
+
+#ifdef BOARD_USE_V4L2_ION
+ ion_unmap((void *)win->addr[0], ALIGN(win->size * NUM_OF_WIN_BUF, PAGE_SIZE));
+ ion_free(win->ion_fd);
+#endif
+
+#ifdef ENABLE_FIMD_VSYNC
+ int vsync = 0;
+ if (ioctl(win->fd, S3CFB_SET_VSYNC_INT, &vsync) < 0)
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::S3CFB_SET_VSYNC_INT fail", __func__);
+#endif
+ ret = close(win->fd);
+ }
+ win->fd = 0;
+
+ return ret;
+}
+
+int window_set_pos(struct hwc_win_info_t *win)
+{
+ struct s3cfb_user_window window;
+
+ //before changing the screen configuration...powerdown the window
+ if (window_hide(win) != 0)
+ return -1;
+
+ SEC_HWC_Log(HWC_LOG_DEBUG, "%s:: x(%d), y(%d)",
+ __func__, win->rect_info.x, win->rect_info.y);
+
+ win->var_info.xres_virtual = (win->lcd_info.xres + 15) & ~ 15;
+ win->var_info.yres_virtual = win->lcd_info.yres * NUM_OF_WIN_BUF;
+ 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) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%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, S3CFB_WIN_POSITION, &window) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%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, int win_num)
+{
+ int temp_size = 0;
+
+ if (ioctl(win->fd, FBIOGET_FSCREENINFO, &win->fix_info) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "FBIOGET_FSCREENINFO failed : %s",
+ strerror(errno));
+ goto error;
+ }
+
+ win->size = win->fix_info.line_length * win->var_info.yres;
+
+#ifdef BOARD_USE_V4L2_ION
+ struct s3c_fb_user_ion_client ion_handle;
+ void *ion_start_addr;
+
+ if (ioctl(win->fd, S3CFB_GET_ION_USER_HANDLE, &ion_handle) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Get fb ion client is failed\n");
+ return -1;
+ }
+
+ win->ion_fd = ion_handle.fd;
+ ion_start_addr = ion_map(win->ion_fd, ALIGN(win->size * NUM_OF_WIN_BUF, PAGE_SIZE), 0);
+#endif
+
+ for (int j = 0; j < NUM_OF_WIN_BUF; j++) {
+ temp_size = win->size * j;
+#ifdef BOARD_USE_V4L2_ION
+ win->addr[j] = (uint32_t)ion_start_addr + temp_size;
+#else
+ win->addr[j] = win->fix_info.smem_start + temp_size;
+#endif
+ SEC_HWC_Log(HWC_LOG_DEBUG, "%s::win-%d add[%d] %x ",
+ __func__, win_num, j, win->addr[j]);
+ }
+ 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);
+
+#ifdef ENABLE_FIMD_VSYNC
+#ifdef BOARD_USE_V4L2_ION
+ int fimd_num = 0;
+ if (ioctl(win->fd, FBIO_WAITFORVSYNC, &fimd_num) < 0)
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::FBIO_WAITFORVSYNC fail(%s)",
+ __func__, strerror(errno));
+#else
+ if (ioctl(win->fd, FBIO_WAITFORVSYNC, 0) < 0)
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::FBIO_WAITFORVSYNC fail(%s)",
+ __func__, strerror(errno));
+#endif
+#endif
+
+ lcd_info->yoffset = lcd_info->yres * win->buf_index;
+
+ if (ioctl(win->fd, FBIOPAN_DISPLAY, lcd_info) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%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) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%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) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::FBIOBLANK failed : (%d:%s)",
+ __func__, win->fd, strerror(errno));
+ return -1;
+ }
+ win->power_state = 0;
+ }
+ return 0;
+}
+
+int window_get_global_lcd_info(int fd, struct fb_var_screeninfo *lcd_info)
+{
+ if (ioctl(fd, FBIOGET_VSCREENINFO, lcd_info) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "FBIOGET_VSCREENINFO failed : %s",
+ strerror(errno));
+ return -1;
+ }
+
+ SEC_HWC_Log(HWC_LOG_DEBUG, "%s:: Default LCD x(%d),y(%d)",
+ __func__, lcd_info->xres, lcd_info->yres);
+ 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;
+
+#ifdef BOARD_USE_V4L2_ION
+ /* You MUST initialize structure for v4l2 */
+ memset(&fmt, 0, sizeof(fmt));
+ memset(&cropcap, 0, sizeof(cropcap));
+ memset(&crop, 0, sizeof(crop));
+ memset(&req, 0, sizeof(req));
+
+ /* To set size & format for source image (DMA-INPUT) */
+ fmt.fmt.pix_mp.num_planes = src->planes;
+ fmt.fmt.pix_mp.width = src->full_width;
+ fmt.fmt.pix_mp.height = src->full_height;
+ fmt.fmt.pix_mp.pixelformat = src->color_space;
+ fmt.fmt.pix_mp.field = V4L2_FIELD_ANY;
+#else
+ 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;
+#endif
+ fmt.type = V4L2_BUF_TYPE_OUTPUT;
+
+ if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::VIDIOC_S_FMT failed : errno=%d (%s)"
+ " : fd=%d\n", __func__, errno, strerror(errno), fd);
+ return -1;
+ }
+
+ /* crop input size */
+ crop.type = V4L2_BUF_TYPE_OUTPUT;
+ crop.c.width = src->width;
+ crop.c.height = src->height;
+#ifdef BOARD_USE_V4L2_ION
+ crop.c.left = src->start_x;
+ crop.c.top = src->start_y;
+#else
+ 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;
+ }
+
+#endif
+
+ if (ioctl(fd, VIDIOC_S_CROP, &crop) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in video VIDIOC_S_CROP :"
+ "crop.c.left : (%d), crop.c.top : (%d), crop.c.width : (%d), crop.c.height : (%d)",
+ __func__, crop.c.left, crop.c.top, crop.c.width, crop.c.height);
+ return -1;
+ }
+
+ /* input buffer type */
+ req.count = 1;
+ req.memory = V4L2_MEMORY_USERPTR;
+ req.type = V4L2_BUF_TYPE_OUTPUT;
+
+ if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in VIDIOC_REQBUFS", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_set_dst(int fd, s5p_fimc_img_info *dst,
+ int rotation, int hflip, int vflip, unsigned int addr)
+{
+ struct v4l2_format sFormat;
+ struct v4l2_control vc;
+ struct v4l2_framebuffer fbuf;
+#ifdef BOARD_USE_V4L2_ION
+ struct v4l2_crop crop;
+ struct v4l2_requestbuffers req;
+#endif
+ int ret;
+
+#ifdef BOARD_USE_V4L2_ION
+ /* You MUST initialize structure for v4l2 */
+ memset(&sFormat, 0, sizeof(sFormat));
+ memset(&vc, 0, sizeof(vc));
+ memset(&fbuf, 0, sizeof(fbuf));
+ memset(&crop, 0, sizeof(crop));
+ memset(&req, 0, sizeof(req));
+#endif
+
+ /* set rotation configuration */
+#ifdef BOARD_USE_V4L2_ION
+ vc.id = V4L2_CID_ROTATE;
+#else
+ vc.id = V4L2_CID_ROTATION;
+#endif
+ vc.value = rotation;
+
+ ret = ioctl(fd, VIDIOC_S_CTRL, &vc);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%s::Error in video VIDIOC_S_CTRL - rotation (%d)"
+ "vc.id : (%d), vc.value : (%d)", __func__, ret, vc.id, vc.value);
+ return -1;
+ }
+
+ vc.id = V4L2_CID_HFLIP;
+ vc.value = hflip;
+
+ ret = ioctl(fd, VIDIOC_S_CTRL, &vc);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%s::Error in video VIDIOC_S_CTRL - hflip (%d)"
+ "vc.id : (%d), vc.value : (%d)", __func__, ret, vc.id, vc.value);
+ return -1;
+ }
+
+ vc.id = V4L2_CID_VFLIP;
+ vc.value = vflip;
+
+ ret = ioctl(fd, VIDIOC_S_CTRL, &vc);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%s::Error in video VIDIOC_S_CTRL - vflip (%d)"
+ "vc.id : (%d), vc.value : (%d)", __func__, ret, vc.id, vc.value);
+ return -1;
+ }
+
+#ifdef BOARD_USE_V4L2_ION
+ /* set destination */
+ sFormat.type = V4L2_BUF_TYPE_CAPTURE;
+ sFormat.fmt.pix_mp.width = dst->full_width;
+ sFormat.fmt.pix_mp.height = dst->full_height;
+ sFormat.fmt.pix_mp.pixelformat = dst->color_space;
+ sFormat.fmt.pix_mp.num_planes = dst->planes;
+ sFormat.fmt.pix.field = V4L2_FIELD_ANY;
+
+ ret = ioctl(fd, VIDIOC_S_FMT, &sFormat);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in video VIDIOC_S_FMT (%d)", __func__, ret);
+ return -1;
+ }
+
+ /* set destination window */
+ crop.type = V4L2_BUF_TYPE_CAPTURE;
+ crop.c.left = dst->start_x;
+ crop.c.top = dst->start_y;
+ crop.c.width = dst->width;
+ crop.c.height = dst->height;
+
+ ret = ioctl(fd, VIDIOC_S_CROP, &crop);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in video VIDIOC_S_CROP (%d)", __func__, ret);
+ return -1;
+ }
+
+ /* input buffer type */
+ req.count = 1;
+ req.type = V4L2_BUF_TYPE_CAPTURE;
+ req.memory = V4L2_MEMORY_USERPTR;
+
+ ret = ioctl (fd, VIDIOC_REQBUFS, &req);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in VIDIOC_REQBUFS (%d)", __func__, ret);
+ return -1;
+ }
+#else
+ /* set size, format & address for destination image (DMA-OUTPUT) */
+ ret = ioctl(fd, VIDIOC_G_FBUF, &fbuf);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in video VIDIOC_G_FBUF (%d)", __func__, ret);
+ return -1;
+ }
+
+ fbuf.base = (void *)addr;
+ fbuf.fmt.width = dst->full_width;
+ fbuf.fmt.height = dst->full_height;
+ fbuf.fmt.pixelformat = dst->color_space;
+
+ ret = ioctl(fd, VIDIOC_S_FBUF, &fbuf);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in video VIDIOC_S_FBUF (%d)", __func__, ret);
+ 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;
+
+ ret = ioctl(fd, VIDIOC_S_FMT, &sFormat);
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in video VIDIOC_S_FMT (%d)", __func__, ret);
+ return -1;
+ }
+#endif
+
+ return 0;
+}
+
+int fimc_v4l2_stream_on(int fd, enum v4l2_buf_type type)
+{
+ if (-1 == ioctl(fd, VIDIOC_STREAMON, &type)) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Error in VIDIOC_STREAMON\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_queue(int fd, struct fimc_buf *fimc_buf, enum v4l2_buf_type type, int index)
+{
+#ifdef BOARD_USE_V4L2_ION
+ struct v4l2_plane plane[3];
+ int i;
+#endif
+ struct v4l2_buffer buf;
+ int ret;
+
+#ifdef BOARD_USE_V4L2_ION
+ buf.length = fimc_buf->planes;
+#else
+ buf.length = 0;
+ buf.m.userptr = (unsigned long)fimc_buf;
+#endif
+ buf.memory = V4L2_MEMORY_USERPTR;
+ buf.index = index;
+ buf.type = type;
+
+#ifdef BOARD_USE_V4L2_ION
+ if (buf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
+ buf.type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
+ for (i = 0; i < buf.length; i++) {
+ plane[i].m.userptr = fimc_buf->base[i];
+ plane[i].length = fimc_buf->size[i];
+ }
+ }
+ buf.m.planes = plane;
+#endif
+
+ ret = ioctl(fd, VIDIOC_QBUF, &buf);
+ if (0 > ret) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Error in VIDIOC_QBUF : (%d)", ret);
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_dequeue(int fd, struct fimc_buf *fimc_buf, enum v4l2_buf_type type)
+{
+ struct v4l2_buffer buf;
+#ifdef BOARD_USE_V4L2_ION
+ struct v4l2_plane plane[3];
+#endif
+
+#ifdef BOARD_USE_V4L2_ION
+ buf.m.planes = plane;
+ buf.length = fimc_buf->planes;
+#endif
+ buf.memory = V4L2_MEMORY_USERPTR;
+ buf.type = type;
+
+ if (-1 == ioctl(fd, VIDIOC_DQBUF, &buf)) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Error in VIDIOC_DQBUF\n");
+ return -1;
+ }
+
+ return buf.index;
+}
+
+int fimc_v4l2_stream_off(int fd, enum v4l2_buf_type type)
+{
+ if (-1 == ioctl(fd, VIDIOC_STREAMOFF, &type)) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Error in VIDIOC_STREAMOFF\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_clr_buf(int fd, enum v4l2_buf_type type)
+{
+ struct v4l2_requestbuffers req;
+
+ req.count = 0;
+ req.memory = V4L2_MEMORY_USERPTR;
+ req.type = type;
+
+ if (ioctl(fd, VIDIOC_REQBUFS, &req) == -1) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Error in VIDIOC_REQBUFS");
+ }
+
+ return 0;
+}
+
+int fimc_v4l2_S_ctrl(int fd)
+{
+ struct v4l2_control vc;
+
+ vc.id = V4L2_CID_CACHEABLE;
+ vc.value = 1;
+
+ if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Error in VIDIOC_S_CTRL");
+ return -1;
+ }
+
+ return 0;
+}
+
+int fimc_handle_oneshot(int fd, struct fimc_buf *fimc_src_buf, struct fimc_buf *fimc_dst_buf)
+{
+#ifdef CHECK_FPS
+ check_fps();
+#endif
+
+#ifdef BOARD_USE_V4L2_ION
+ if (fimc_v4l2_queue(fd, fimc_src_buf, V4L2_BUF_TYPE_OUTPUT, 0) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : SRC v4l2_queue()");
+ return -1;
+ }
+
+ if (fimc_v4l2_queue(fd, fimc_dst_buf, V4L2_BUF_TYPE_CAPTURE, 0) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : DST v4l2_queue()");
+ return -2;
+ }
+
+ if (fimc_v4l2_stream_on(fd, V4L2_BUF_TYPE_OUTPUT) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : SRC v4l2_stream_on()");
+ return -3;
+ }
+
+ if (fimc_v4l2_stream_on(fd, V4L2_BUF_TYPE_CAPTURE) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : DST v4l2_stream_on()");
+ return -4;
+ }
+#else
+ if (fimc_v4l2_stream_on(fd, V4L2_BUF_TYPE_OUTPUT) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : SRC v4l2_stream_on()");
+ return -5;
+ }
+
+ if (fimc_v4l2_queue(fd, fimc_src_buf, V4L2_BUF_TYPE_OUTPUT, 0) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : SRC v4l2_queue()");
+ goto STREAM_OFF;
+ }
+#endif
+ if (fimc_v4l2_dequeue(fd, fimc_src_buf, V4L2_BUF_TYPE_OUTPUT) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : SRC v4l2_dequeue()");
+ return -6;
+ }
+#ifdef BOARD_USE_V4L2_ION
+ if (fimc_v4l2_dequeue(fd, fimc_dst_buf, V4L2_BUF_TYPE_CAPTURE) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : DST v4l2_dequeue()");
+ return -7;
+ }
+#endif
+STREAM_OFF:
+ if (fimc_v4l2_stream_off(fd, V4L2_BUF_TYPE_OUTPUT) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : SRC v4l2_stream_off()");
+ return -8;
+ }
+#ifdef BOARD_USE_V4L2_ION
+ if (fimc_v4l2_stream_off(fd, V4L2_BUF_TYPE_CAPTURE) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : DST v4l2_stream_off()");
+ return -9;
+ }
+#endif
+ if (fimc_v4l2_clr_buf(fd, V4L2_BUF_TYPE_OUTPUT) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : SRC v4l2_clr_buf()");
+ return -10;
+ }
+#ifdef BOARD_USE_V4L2_ION
+ if (fimc_v4l2_clr_buf(fd, V4L2_BUF_TYPE_CAPTURE)< 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "Fail : DST v4l2_clr_buf()");
+ return -11;
+ }
+#endif
+ return 0;
+}
+
+static int memcpy_rect(void *dst, void *src, int fullW, int fullH, int realW, int realH, int format)
+{
+ unsigned char *srcCb, *srcCr;
+ unsigned char *dstCb, *dstCr;
+ unsigned char *srcY, *dstY;
+ int srcCbOffset, srcCrOffset;
+ int dstCbOffset, dstFrameOffset, dstCrOffset;
+ int cbFullW, cbRealW, cbFullH, cbRealH;
+ int ySrcFW, ySrcFH, ySrcRW, ySrcRH;
+ int planes;
+ int i;
+
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "++memcpy_rect()::"
+ "dst(0x%x),src(0x%x),f.w(%d),f.h(%d),r.w(%d),r.h(%d),format(0x%x)",
+ (unsigned int)dst, (unsigned int)src, fullW, fullH, realW, realH, format);
+
+// Set dst Y, Cb, Cr address for FIMC
+ {
+ cbFullW = fullW >> 1;
+ cbRealW = realW >> 1;
+ cbFullH = fullH >> 1;
+ cbRealH = realH >> 1;
+ dstFrameOffset = fullW * fullH;
+ dstCrOffset = cbFullW * cbFullH;
+ dstY = (unsigned char *)dst;
+ dstCb = (unsigned char *)dst + dstFrameOffset;
+ dstCr = (unsigned char *)dstCb + dstCrOffset;
+ }
+
+// Get src Y, Cb, Cr address for source buffer.
+// Each address is aligned by 16's multiple for GPU both width and height.
+ {
+ ySrcFW = fullW;
+ ySrcFH = fullH;
+ ySrcRW = realW;
+ ySrcRH = realH;
+ srcCbOffset = EXYNOS4_ALIGN(ySrcRW,16)* EXYNOS4_ALIGN(ySrcRH,16);
+ srcCrOffset = EXYNOS4_ALIGN(cbRealW,16)* EXYNOS4_ALIGN(cbRealH,16);
+ srcY = (unsigned char *)src;
+ srcCb = (unsigned char *)src + srcCbOffset;
+ srcCr = (unsigned char *)srcCb + srcCrOffset;
+ }
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "--memcpy_rect()::\n"
+ "dstY(0x%x),dstCb(0x%x),dstCr(0x%x) \n"
+ "srcY(0x%x),srcCb(0x%x),srcCr(0x%x) \n"
+ "cbRealW(%d),cbRealH(%d)",
+ (unsigned int)dstY,(unsigned int)dstCb,(unsigned int)dstCr,
+ (unsigned int)srcY,(unsigned int)srcCb,(unsigned int)srcCr,
+ cbRealW, cbRealH);
+
+ if (format == HAL_PIXEL_FORMAT_YV12) { //YV12(Y,Cr,Cv)
+ planes = 3;
+//This is code for VE, deleted temporory by SSONG 2011.09.22
+// This will be enabled later.
+/*
+ //as defined in hardware.h, cb & cr full_width should be aligned to 16. ALIGN(y_stride/2, 16).
+ ////Alignment is hard coded to 16.
+ ////for example...check frameworks/media/libvideoeditor/lvpp/VideoEditorTools.cpp file for UV stride cal
+ cbSrcFW = (cbSrcFW + 15) & (~15);
+ srcCbOffset = ySrcFW * fullH;
+ srcCrOffset = srcCbOffset + ((cbSrcFW * fullH) >> 1);
+ srcY = (unsigned char *)src;
+ srcCb = (unsigned char *)src + srcCbOffset;
+ srcCr = (unsigned char *)src + srcCrOffset;
+*/
+ } else if ((format == HAL_PIXEL_FORMAT_YCbCr_420_P)) {
+ planes = 3;
+ } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP || format == HAL_PIXEL_FORMAT_YCrCb_420_SP) {
+ planes = 2;
+ } else {
+ SEC_HWC_Log(HWC_LOG_ERROR, "use default memcpy instead of memcpy_rect");
+ return -1;
+ }
+//#define CHECK_PERF
+#ifdef CHECK_PERF
+ struct timeval start, end;
+ gettimeofday(&start, NULL);
+#endif
+ for (i = 0; i < realH; i++)
+ memcpy(dstY + fullW * i, srcY + ySrcFW * i, ySrcRW);
+ if (planes == 2) {
+ for (i = 0; i < cbRealH; i++)
+ memcpy(dstCb + ySrcFW * i, srcCb + ySrcFW * i, ySrcRW);
+ } else if (planes == 3) {
+ for (i = 0; i < cbRealH; i++)
+ memcpy(dstCb + cbFullW * i, srcCb + cbFullW * i, cbRealW);
+ for (i = 0; i < cbRealH; i++)
+ memcpy(dstCr + cbFullW * i, srcCr + cbFullW * i, cbRealW);
+ }
+#ifdef CHECK_PERF
+ gettimeofday(&end, NULL);
+ SEC_HWC_Log(HWC_LOG_ERROR, "[COPY]=%d,",(end.tv_sec - start.tv_sec)*1000+(end.tv_usec - start.tv_usec)/1000);
+#endif
+
+ return 0;
+}
+
+/*****************************************************************************/
+static int get_src_phys_addr(struct hwc_context_t *ctx,
+ sec_img *src_img, sec_rect *src_rect)
+{
+ s5p_fimc_t *fimc = &ctx->fimc;
+ struct s3c_mem_alloc *ptr_mem_alloc = &ctx->s3c_mem.mem_alloc[0];
+ struct s3c_mem_dma_param s3c_mem_dma;
+#ifdef USE_HW_PMEM
+ sec_pmem_alloc_t *pm_alloc = &ctx->sec_pmem.sec_pmem_alloc[0];
+#endif
+
+ unsigned int src_virt_addr = 0;
+ unsigned int src_phys_addr = 0;
+ unsigned int src_frame_size = 0;
+
+ struct pmem_region region;
+ ADDRS * addr;
+
+ // error check routine
+ if (0 == src_img->base && !(src_img->usage & GRALLOC_USAGE_HW_FIMC1)) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s invalid src image base\n", __func__);
+ return 0;
+ }
+
+ switch (src_img->mem_type) {
+ case HWC_PHYS_MEM_TYPE:
+ src_phys_addr = src_img->base + src_img->offset;
+ break;
+
+ case HWC_VIRT_MEM_TYPE:
+ case HWC_UNKNOWN_MEM_TYPE:
+ switch (src_img->format) {
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_SP:
+ addr = (ADDRS *)(src_img->base);
+ fimc->params.src.buf_addr_phy_rgb_y = addr->addr_y;
+ fimc->params.src.buf_addr_phy_cb = addr->addr_cbcr;
+
+ src_phys_addr = fimc->params.src.buf_addr_phy_rgb_y;
+ if (0 == src_phys_addr) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s address error "
+ "(format=CUSTOM_YCbCr/YCrCb_420_SP Y-addr=0x%x "
+ "CbCr-Addr=0x%x)",
+ __func__, fimc->params.src.buf_addr_phy_rgb_y,
+ fimc->params.src.buf_addr_phy_cb);
+ return 0;
+ }
+ break;
+ 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:
+ addr = (ADDRS *)(src_img->base + src_img->offset);
+ fimc->params.src.buf_addr_phy_rgb_y = addr->addr_y;
+ src_phys_addr = fimc->params.src.buf_addr_phy_rgb_y;
+ if (0 == src_phys_addr) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s address error "
+ "(format=CUSTOM_YCbCr/CbYCrY_422_I Y-addr=0x%x)",
+ __func__, fimc->params.src.buf_addr_phy_rgb_y);
+ return 0;
+ }
+ break;
+ default:
+#ifdef BOARD_USE_V4L2_ION
+ fimc->params.src.buf_addr_phy_rgb_y = src_img->base;
+ fimc->params.src.buf_addr_phy_cb = src_img->base + src_img->uoffset;
+ fimc->params.src.buf_addr_phy_cr = src_img->base + src_img->uoffset + src_img->voffset;
+ src_phys_addr = fimc->params.src.buf_addr_phy_rgb_y;
+ break;
+#endif
+ if (src_img->usage & GRALLOC_USAGE_HW_FIMC1) {
+ fimc->params.src.buf_addr_phy_rgb_y = src_img->paddr;
+ fimc->params.src.buf_addr_phy_cb = src_img->paddr + src_img->uoffset;
+ fimc->params.src.buf_addr_phy_cr = src_img->paddr + src_img->uoffset + src_img->voffset;
+ src_phys_addr = fimc->params.src.buf_addr_phy_rgb_y;
+ break;
+ }
+ // copy
+ src_frame_size = FRAME_SIZE(src_img->format, src_img->w, src_img->h);
+ if (src_frame_size == 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::FRAME_SIZE fail", __func__);
+ return 0;
+ }
+
+#ifdef USE_HW_PMEM
+ if (0 <= checkPmem(&ctx->sec_pmem, 0, src_frame_size)) {
+ src_virt_addr = pm_alloc->virt_addr;
+ src_phys_addr = pm_alloc->phys_addr;
+ pm_alloc->size = src_frame_size;
+ } else
+#endif
+ if (0 <= checkMem(&ctx->s3c_mem, 0, src_frame_size)) {
+ src_virt_addr = ptr_mem_alloc->vir_addr;
+ src_phys_addr = ptr_mem_alloc->phy_addr;
+ ptr_mem_alloc->size = src_frame_size;
+ } else {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::check_mem fail", __func__);
+ return 0;
+ }
+ if ((src_img->format == HAL_PIXEL_FORMAT_YCbCr_420_P) ||
+ (src_img->format == HAL_PIXEL_FORMAT_YV12) ||
+ (src_img->format == HAL_PIXEL_FORMAT_YCbCr_420_SP) ||
+ (src_img->format == HAL_PIXEL_FORMAT_YCrCb_420_SP)) {
+ if (memcpy_rect((void *)src_virt_addr, (void*)((unsigned int)src_img->base),
+ src_img->f_w, src_img->f_h, src_rect->w, src_rect->h, src_img->format) != 0)
+ return 0;
+ } else {
+ memcpy((void *)src_virt_addr, (void*)((unsigned int)src_img->base), src_frame_size);
+ }
+
+#ifdef USE_HW_PMEM
+ if (pm_alloc->size == src_frame_size) {
+ region.offset = 0;
+ region.len = src_frame_size;
+ if (ioctl(ctx->sec_pmem.pmem_master_fd, PMEM_CACHE_FLUSH, ®ion) < 0)
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::pmem cache flush fail ", __func__);
+ }
+#endif
+ break;
+ }
+ }
+
+ return src_phys_addr;
+}
+
+static int get_dst_phys_addr(struct hwc_context_t *ctx, sec_img *dst_img,
+ sec_rect *dst_rect, int *dst_memcpy_flag)
+{
+ 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
+ dst_phys_addr = dst_img->base;
+
+ return dst_phys_addr;
+}
+
+static inline int rotateValueHAL2PP(unsigned char transform)
+{
+ int rotate_flag = transform & 0x7;
+
+ switch (rotate_flag) {
+ case HAL_TRANSFORM_ROT_90: return 90;
+ case HAL_TRANSFORM_ROT_180: return 180;
+ case HAL_TRANSFORM_ROT_270: return 270;
+ case HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90: return 90;
+ case HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90: return 90;
+ case HAL_TRANSFORM_FLIP_H: return 0;
+ case HAL_TRANSFORM_FLIP_V: return 0;
+ }
+ return 0;
+}
+
+static inline int hflipValueHAL2PP(unsigned char transform)
+{
+ int flip_flag = transform & 0x7;
+ switch (flip_flag) {
+ case HAL_TRANSFORM_FLIP_H:
+ case HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90:
+ return 1;
+ case HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90:
+ case HAL_TRANSFORM_ROT_90:
+ case HAL_TRANSFORM_ROT_180:
+ case HAL_TRANSFORM_ROT_270:
+ case HAL_TRANSFORM_FLIP_V:
+ break;
+ }
+ return 0;
+}
+
+static inline int vflipValueHAL2PP(unsigned char transform)
+{
+ int flip_flag = transform & 0x7;
+ switch (flip_flag) {
+ case HAL_TRANSFORM_FLIP_V:
+ case HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90:
+ return 1;
+ case HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90:
+ case HAL_TRANSFORM_ROT_90:
+ case HAL_TRANSFORM_ROT_180:
+ case HAL_TRANSFORM_ROT_270:
+ case HAL_TRANSFORM_FLIP_H:
+ break;
+ }
+ return 0;
+}
+
+static inline int multipleOf2(int number)
+{
+ if (number % 2 == 1)
+ return (number - 1);
+ else
+ return number;
+}
+
+static inline int multipleOf4(int number)
+{
+ int remain_number = number % 4;
+
+ if (remain_number != 0)
+ return (number - remain_number);
+ else
+ return number;
+}
+
+static inline int multipleOf8(int number)
+{
+ int remain_number = number % 8;
+
+ if (remain_number != 0)
+ return (number - remain_number);
+ else
+ return number;
+}
+
+static inline int multipleOf16(int number)
+{
+ int remain_number = number % 16;
+
+ if (remain_number != 0)
+ return (number - remain_number);
+ else
+ return number;
+}
+
+static inline int widthOfPP(unsigned int ver, int pp_color_format, int number)
+{
+#ifdef BOARD_USE_V4L2_ION
+ if (1) {
+#else
+ if (0x50 <= ver) {
+#endif
+ 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 multipleOf2(number);
+
+ default :
+ return number;
+ }
+ } else {
+ switch (pp_color_format) {
+ case V4L2_PIX_FMT_RGB565:
+ return multipleOf8(number);
+
+ case V4L2_PIX_FMT_RGB32:
+ return multipleOf4(number);
+
+ case V4L2_PIX_FMT_YUYV:
+ case V4L2_PIX_FMT_UYVY:
+ return multipleOf4(number);
+
+ case V4L2_PIX_FMT_NV61:
+ case V4L2_PIX_FMT_NV16:
+ return multipleOf8(number);
+
+ case V4L2_PIX_FMT_YUV422P:
+ return multipleOf16(number);
+
+ case V4L2_PIX_FMT_NV21:
+ case V4L2_PIX_FMT_NV12:
+ case V4L2_PIX_FMT_NV12T:
+ return multipleOf8(number);
+
+ case V4L2_PIX_FMT_YUV420:
+ return multipleOf16(number);
+
+ 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 multipleOf2(number);
+
+ default :
+ return number;
+ break;
+ }
+ return number;
+}
+
+static unsigned int get_yuv_bpp(unsigned int fmt)
+{
+ int i, sel = -1;
+
+ for (i = 0; i < (int)(sizeof(yuv_list) / sizeof(struct yuv_fmt_list)); i++) {
+ if (yuv_list[i].fmt == fmt) {
+ sel = i;
+ break;
+ }
+ }
+
+ if (sel == -1)
+ return sel;
+ else
+ return yuv_list[sel].bpp;
+}
+
+static unsigned int get_yuv_planes(unsigned int fmt)
+{
+ int i, sel = -1;
+
+ for (i = 0; i < (int)(sizeof(yuv_list) / sizeof(struct yuv_fmt_list)); i++) {
+ if (yuv_list[i].fmt == fmt) {
+ sel = i;
+ break;
+ }
+ }
+
+ if (sel == -1)
+ return sel;
+ else
+ return yuv_list[sel].planes;
+}
+
+static int runcFimcCore(struct hwc_context_t *ctx,
+ unsigned int src_phys_addr, 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);
+
+ struct fimc_buf fimc_src_buf;
+ int src_bpp, src_planes;
+
+#ifdef BOARD_USE_V4L2_ION
+ struct fimc_buf fimc_dst_buf;
+ int dst_bpp, dst_planes;
+ unsigned int src_frame_size = 0;
+ unsigned int dst_frame_size = 0;
+#endif
+ unsigned int frame_size = 0;
+
+ bool src_cbcr_order = true;
+ int rotate_value = rotateValueHAL2PP(transform);
+ int hflip = hflipValueHAL2PP(transform);
+ int vflip = vflipValueHAL2PP(transform);
+
+ /* 1. param(fimc config)->src information
+ * - src_img,src_rect => s_fw,s_fh,s_w,s_h,s_x,s_y
+ */
+ params->src.full_width = src_img->f_w;
+ params->src.full_height = src_img->f_h;
+ params->src.width = src_rect->w;
+ params->src.height = src_rect->h;
+ params->src.start_x = src_rect->x;
+ params->src.start_y = src_rect->y;
+ params->src.color_space = src_color_space;
+ params->src.buf_addr_phy_rgb_y = src_phys_addr;
+
+#ifdef BOARD_USE_V4L2_ION
+ params->dst.full_width = dst_img->f_w;
+ params->dst.full_height = dst_img->f_h;
+ params->dst.width = widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
+ params->dst.height = heightOfPP(dst_color_space, dst_rect->h);
+ params->dst.start_x = dst_rect->x;
+ params->dst.start_y = dst_rect->y;
+ params->dst.color_space = dst_color_space;
+ params->dst.buf_addr_phy_rgb_y = dst_phys_addr;
+#endif
+
+ /* check src minimum */
+ if (src_rect->w < 16 || src_rect->h < 8) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%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;
+ }
+
+#ifdef BOARD_USE_V4L2_ION
+#else
+ /* 2. param(fimc config)->dst information
+ * - dst_img,dst_rect,rot => d_fw,d_fh,d_w,d_h,d_x,d_y
+ */
+ switch (rotate_value) {
+ case 0:
+ params->dst.full_width = dst_img->f_w;
+ params->dst.full_height = dst_img->f_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->f_h;
+ params->dst.full_height = dst_img->f_w;
+
+ params->dst.start_x = dst_rect->y;
+ params->dst.start_y = dst_img->f_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->f_w;
+ params->dst.full_height = dst_img->f_h;
+
+ params->dst.start_x = dst_img->f_w - (dst_rect->x + dst_rect->w);
+ params->dst.start_y = dst_img->f_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->f_h;
+ params->dst.full_height = dst_img->f_w;
+
+ params->dst.start_x = dst_img->f_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;
+#endif
+
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "runcFimcCore()::"
+ "SRC f.w(%d),f.h(%d),x(%d),y(%d),w(%d),h(%d)=>"
+ "DST f.w(%d),f.h(%d),x(%d),y(%d),w(%d),h(%d)",
+ params->src.full_width, params->src.full_height,
+ params->src.start_x, params->src.start_y,
+ params->src.width, params->src.height,
+ params->dst.full_width, params->dst.full_height,
+ params->dst.start_x, params->dst.start_y,
+ params->dst.width, params->dst.height);
+
+ /* check dst minimum */
+ if (dst_rect->w < 8 || dst_rect->h < 4) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%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))) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "%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;
+ }
+
+ /* 3. Set configuration related to destination (DMA-OUT)
+ * - set input format & size
+ * - crop input size
+ * - set input buffer
+ * - set buffer type (V4L2_MEMORY_USERPTR)
+ */
+#ifdef BOARD_USE_V4L2_ION
+ switch (dst_img->format) {
+ case HAL_PIXEL_FORMAT_RGBA_8888:
+ case HAL_PIXEL_FORMAT_RGBX_8888:
+ case HAL_PIXEL_FORMAT_RGB_888:
+ case HAL_PIXEL_FORMAT_BGRA_8888:
+ dst_planes = 1;
+ dst_bpp = 32;
+ break;
+
+ case HAL_PIXEL_FORMAT_RGB_565:
+ case HAL_PIXEL_FORMAT_RGBA_5551:
+ case HAL_PIXEL_FORMAT_RGBA_4444:
+ dst_planes = 1;
+ dst_bpp = 16;
+ break;
+ }
+
+ dst_frame_size = params->dst.width * params->dst.height ;
+ params->dst.planes = dst_planes;
+
+ if (dst_planes == 1) {
+ fimc_dst_buf.base[0] = params->dst.buf_addr_phy_rgb_y;
+ if (dst_bpp == 32)
+ fimc_dst_buf.size[0] = dst_frame_size * 4;
+ else if (dst_bpp == 16)
+ fimc_dst_buf.size[0] = dst_frame_size * 2;
+ }
+#endif
+
+ if (fimc_v4l2_set_dst(fimc->dev_fd, ¶ms->dst, rotate_value, hflip, vflip, dst_phys_addr) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "fimc_v4l2_set_dst is failed\n");
+ return -1;
+ }
+
+ /* 4. Set configuration related to source (DMA-INPUT)
+ * - set input format & size
+ * - crop input size
+ * - set input buffer
+ * - set buffer type (V4L2_MEMORY_USERPTR)
+ */
+#ifndef BOARD_USE_V4L2_ION
+ if (fimc_v4l2_set_src(fimc->dev_fd, fimc->hw_ver, ¶ms->src) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "fimc_v4l2_set_src is failed\n");
+ return -1;
+ }
+#endif
+
+ /* 5. Set input dma address (Y/RGB, Cb, Cr)
+ * - zero copy : mfc, camera
+ * - memcpy to pmem : SW dec(420P), video editor(YV12)
+ */
+ switch (src_img->format) {
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_SP:
+ case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_SP:
+ /* for video contents 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;
+
+ 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:
+ case HAL_PIXEL_FORMAT_RGB_565:
+ case HAL_PIXEL_FORMAT_YV12:
+ default:
+ if (src_img->format == HAL_PIXEL_FORMAT_YV12)
+ src_cbcr_order = false;
+
+#ifdef BOARD_USE_V4L2_ION
+ fimc_src_buf.base[0] = params->src.buf_addr_phy_rgb_y;
+ if (src_cbcr_order == true) {
+ fimc_src_buf.base[1] = params->src.buf_addr_phy_cb;
+ fimc_src_buf.base[2] = params->src.buf_addr_phy_cr;
+ } else {
+ fimc_src_buf.base[1] = params->src.buf_addr_phy_cr;
+ fimc_src_buf.base[2] = params->src.buf_addr_phy_cb;
+ }
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "runFimcCore - Y=0x%X, U=0x%X, V=0x%X\n",
+ fimc_src_buf.base[0], fimc_src_buf.base[1],fimc_src_buf.base[2]);
+ src_frame_size = params->src.full_width * params->src.full_height;
+ fimc_src_buf.size[0] = src_frame_size;
+ fimc_src_buf.size[1] = src_frame_size >> 2;
+ fimc_src_buf.size[2] = src_frame_size >> 2;
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "runFimcCore - Y_length=%d, U_length=%d, V_length=%d\n",
+ fimc_src_buf.size[0], fimc_src_buf.size[1],fimc_src_buf.size[2]);
+ src_planes = get_yuv_planes(src_color_space);
+
+ break;
+#endif
+
+ if (src_img->usage & GRALLOC_USAGE_HW_FIMC1) {
+ fimc_src_buf.base[0] = params->src.buf_addr_phy_rgb_y;
+ if (src_cbcr_order == true) {
+ fimc_src_buf.base[1] = params->src.buf_addr_phy_cb;
+ fimc_src_buf.base[2] = params->src.buf_addr_phy_cr;
+ }
+ else {
+ fimc_src_buf.base[2] = params->src.buf_addr_phy_cb;
+ fimc_src_buf.base[1] = params->src.buf_addr_phy_cr;
+ }
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "runFimcCore - Y=0x%X, U=0x%X, V=0x%X\n",
+ fimc_src_buf.base[0], fimc_src_buf.base[1],fimc_src_buf.base[2]);
+ break;
+ }
+
+ /* set source Y image */
+ fimc_src_buf.base[0] = params->src.buf_addr_phy_rgb_y;
+ /* set source Cb,Cr images for 2 or 3 planes */
+ src_bpp = get_yuv_bpp(src_color_space);
+ src_planes = get_yuv_planes(src_color_space);
+ if (2 == src_planes) { /* 2 planes */
+ frame_size = params->src.full_width * params->src.full_height;
+ params->src.buf_addr_phy_cb =
+ params->src.buf_addr_phy_rgb_y + frame_size;
+ /* CbCr */
+ fimc_src_buf.base[1] = params->src.buf_addr_phy_cb;
+ } else if (3 == src_planes) { /* 3 planes */
+ frame_size = params->src.full_width * params->src.full_height;
+ params->src.buf_addr_phy_cb =
+ params->src.buf_addr_phy_rgb_y + frame_size;
+ if (12 == src_bpp)
+ params->src.buf_addr_phy_cr =
+ params->src.buf_addr_phy_cb + (frame_size >> 2);
+ else
+ params->src.buf_addr_phy_cr =
+ params->src.buf_addr_phy_cb + (frame_size >> 1);
+ /* Cb, Cr */
+ if (src_cbcr_order == true) {
+ fimc_src_buf.base[1] = params->src.buf_addr_phy_cb;
+ fimc_src_buf.base[2] = params->src.buf_addr_phy_cr;
+ }
+ else {
+ fimc_src_buf.base[2] = params->src.buf_addr_phy_cb;
+ fimc_src_buf.base[1] = params->src.buf_addr_phy_cr;
+ }
+ }
+ break;
+ }
+
+ /* 6. Run FIMC
+ * - stream on => queue => dequeue => stream off => clear buf
+ */
+#ifdef BOARD_USE_V4L2_ION
+ int ret = 0;
+ params->src.planes = src_planes;
+
+ if (fimc_v4l2_set_src(fimc->dev_fd, fimc->hw_ver, ¶ms->src) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "fimc_v4l2_set_src is failed\n");
+ return -1;
+ }
+
+ fimc_src_buf.planes = src_planes;
+ fimc_dst_buf.planes = dst_planes;
+
+ ret = fimc_handle_oneshot(fimc->dev_fd, &fimc_src_buf, &fimc_dst_buf);
+
+ if (ret < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR,"fimc_handle_oneshot = %d\n",ret);
+ if (ret == -2) {
+ fimc_v4l2_clr_buf(fimc->dev_fd, V4L2_BUF_TYPE_OUTPUT);
+ } else if (ret == -3) {
+ fimc_v4l2_clr_buf(fimc->dev_fd, V4L2_BUF_TYPE_OUTPUT);
+ fimc_v4l2_clr_buf(fimc->dev_fd, V4L2_BUF_TYPE_CAPTURE);
+ }
+ return ret;
+ }
+#else
+ if (fimc_handle_oneshot(fimc->dev_fd, &fimc_src_buf, NULL) < 0) {
+ fimc_v4l2_clr_buf(fimc->dev_fd, V4L2_BUF_TYPE_OUTPUT);
+ return -1;
+ }
+#endif
+
+ return 0;
+}
+
+#ifdef SUB_TITLES_HWC
+int createG2d(sec_g2d_t *g2d)
+{
+ g2d->dev_fd = open(SEC_G2D_DEV_NAME, O_RDWR);
+
+ if (g2d->dev_fd <= 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::G2d open error (%d)", __func__, errno);
+ goto err;
+ }
+
+ return 0;
+err:
+ if (0 < g2d->dev_fd)
+ close(g2d->dev_fd);
+ g2d->dev_fd =0;
+
+ return -1;
+}
+
+int destroyG2d(sec_g2d_t *g2d)
+{
+ // close
+ if (0 < g2d->dev_fd)
+ close(g2d->dev_fd);
+ g2d->dev_fd = 0;
+
+ return 0;
+}
+#endif
+
+int createFimc(s5p_fimc_t *fimc)
+{
+ struct v4l2_capability cap;
+ struct v4l2_format fmt;
+ struct v4l2_control vc;
+
+ // open device file
+ if (fimc->dev_fd <= 0)
+ fimc->dev_fd = open(PP_DEVICE_DEV_NAME, O_RDWR);
+
+ if (fimc->dev_fd <= 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Post processor open error (%d)",
+ __func__, errno);
+ goto err;
+ }
+
+ // check capability
+ if (ioctl(fimc->dev_fd, VIDIOC_QUERYCAP, &cap) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "VIDIOC_QUERYCAP failed");
+ goto err;
+ }
+
+ if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%d has no streaming support", fimc->dev_fd);
+ goto err;
+ }
+
+ if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%d is no video output", fimc->dev_fd);
+ goto err;
+ }
+
+ /*
+ * malloc fimc_outinfo structure
+ */
+ fmt.type = V4L2_BUF_TYPE_OUTPUT;
+ if (ioctl(fimc->dev_fd, VIDIOC_G_FMT, &fmt) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in video VIDIOC_G_FMT", __func__);
+ goto err;
+ }
+
+#ifdef BOARD_USE_V4L2_ION
+#else
+ vc.id = V4L2_CID_FIMC_VERSION;
+ vc.value = 0;
+
+ if (ioctl(fimc->dev_fd, VIDIOC_G_CTRL, &vc) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::Error in video VIDIOC_G_CTRL", __func__);
+ goto err;
+ }
+ fimc->hw_ver = vc.value;
+#endif
+
+ return 0;
+
+err:
+ if (0 < fimc->dev_fd)
+ close(fimc->dev_fd);
+ fimc->dev_fd =0;
+
+ 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 = 0;
+
+ 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,
+ uint32_t transform)
+{
+ s5p_fimc_t * fimc = &ctx->fimc;
+
+ unsigned int src_phys_addr = 0;
+ unsigned int dst_phys_addr = 0;
+ int rotate_value = 0;
+ int flag_force_memcpy = 0;
+ int32_t src_color_space;
+ int32_t dst_color_space;
+
+ /* 1. source address and size */
+ src_phys_addr = get_src_phys_addr(ctx, src_img, src_rect);
+ if (0 == src_phys_addr)
+ return -1;
+
+ /* 2. destination address and size */
+ dst_phys_addr = get_dst_phys_addr(ctx, dst_img, dst_rect, &flag_force_memcpy);
+ if (0 == dst_phys_addr)
+ return -2;
+
+ /* 3. check whether fimc supports the src format */
+ src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format);
+ if (0 > src_color_space)
+ return -3;
+ dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format);
+ if (0 > dst_color_space)
+ return -4;
+
+ /* 4. FIMC: src_rect of src_img => dst_rect of dst_img */
+ if (runcFimcCore(ctx, src_phys_addr, 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;
+
+ if (flag_force_memcpy == 1) {
+#ifdef USE_HW_PMEM
+ if (0 != ctx->sec_pmem.sec_pmem_alloc[1].size) {
+ struct s3c_mem_dma_param s3c_mem_dma;
+
+ s3c_mem_dma.src_addr =
+ (unsigned long)(ctx->sec_pmem.sec_pmem_alloc[1].virt_addr);
+ s3c_mem_dma.size = ctx->sec_pmem.sec_pmem_alloc[1].size;
+
+ ioctl(ctx->s3c_mem.fd, S3C_MEM_CACHE_INVAL, &s3c_mem_dma);
+
+ memcpy((void*)((unsigned int)dst_img->base),
+ (void *)(ctx->sec_pmem.sec_pmem_alloc[1].virt_addr),
+ ctx->sec_pmem.sec_pmem_alloc[1].size);
+ } else
+#endif
+ {
+ struct s3c_mem_alloc *ptr_mem_alloc = &ctx->s3c_mem.mem_alloc[1];
+ struct s3c_mem_dma_param s3c_mem_dma;
+
+ s3c_mem_dma.src_addr = (unsigned long)ptr_mem_alloc->vir_addr;
+ s3c_mem_dma.size = ptr_mem_alloc->size;
+
+ ioctl(ctx->s3c_mem.fd, S3C_MEM_CACHE_INVAL, &s3c_mem_dma);
+
+ memcpy((void*)((unsigned int)dst_img->base),
+ (void *)ptr_mem_alloc->vir_addr, ptr_mem_alloc->size);
+ }
+ }
+
+ return 0;
+}
+
+#ifdef SUB_TITLES_HWC
+static int get_g2d_src_phys_addr(struct hwc_context_t *ctx, g2d_rect *src_rect)
+{
+ sec_g2d_t *g2d = &ctx->g2d;
+ struct s3c_mem_alloc *ptr_mem_alloc = &ctx->s3c_mem.mem_alloc[0];
+#ifdef USE_HW_PMEM
+ sec_pmem_alloc_t *pm_alloc = &ctx->sec_pmem.sec_pmem_alloc[0];
+#endif
+
+ unsigned int src_virt_addr = 0;
+ unsigned int src_phys_addr = 0;
+ unsigned int src_frame_size = 0;
+
+ struct pmem_region region;
+
+ // error check routine
+ if (0 == src_rect->virt_addr) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s invalid src address\n", __func__);
+ return 0;
+ }
+
+ src_frame_size = FRAME_SIZE(src_rect->color_format,
+ src_rect->full_w, src_rect->full_h);
+ if (src_frame_size == 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::FRAME_SIZE fail", __func__);
+ return 0;
+ }
+
+#ifdef USE_HW_PMEM
+ if (0 <= checkPmem(&ctx->sec_pmem, 0, src_frame_size)) {
+ src_virt_addr = pm_alloc->virt_addr;
+ src_phys_addr = pm_alloc->phys_addr;
+ pm_alloc->size = src_frame_size;
+ } else
+#endif
+ if (0 <= checkMem(&ctx->s3c_mem, 0, src_frame_size)) {
+ src_virt_addr = ptr_mem_alloc->vir_addr;
+ src_phys_addr = ptr_mem_alloc->phy_addr;
+ ptr_mem_alloc->size = src_frame_size;
+ } else {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::check_mem fail", __func__);
+ return 0;
+ }
+ memcpy((void *)src_virt_addr, (void*)((unsigned int)src_rect->virt_addr), src_frame_size);
+
+ return src_phys_addr;
+}
+
+int get_HAL_2_G2D_FORMAT(int format)
+{
+ switch (format) {
+ case HAL_PIXEL_FORMAT_RGBA_8888: return G2D_ABGR_8888;
+ case HAL_PIXEL_FORMAT_RGBX_8888: return G2D_XBGR_8888;
+ case HAL_PIXEL_FORMAT_BGRA_8888: return G2D_ARGB_8888;
+ case HAL_PIXEL_FORMAT_RGB_888: return G2D_PACKED_BGR_888;
+ case HAL_PIXEL_FORMAT_RGB_565: return G2D_RGB_565;
+ case HAL_PIXEL_FORMAT_RGBA_5551: return G2D_RGBA_5551;
+ case HAL_PIXEL_FORMAT_RGBA_4444: return G2D_RGBA_4444;
+ default:
+ return -1;
+ }
+}
+
+static inline int rotateValueHAL2G2D(unsigned char transform)
+{
+ int rotate_flag = transform & 0x7;
+
+ switch (rotate_flag) {
+ case HAL_TRANSFORM_ROT_90: return G2D_ROT_90;
+ case HAL_TRANSFORM_ROT_180: return G2D_ROT_180;
+ case HAL_TRANSFORM_ROT_270: return G2D_ROT_270;
+ default:
+ return G2D_ROT_0;
+ }
+}
+
+int runG2d(struct hwc_context_t *ctx, g2d_rect *src_rect, g2d_rect *dst_rect,
+ uint32_t transform)
+{
+ sec_g2d_t * g2d = &ctx->g2d;
+ g2d_flag flag = {G2D_ROT_0, G2D_ALPHA_BLENDING_OPAQUE, 0, 0, 0, 0, 0, 0};
+ int rotate_value = 0;
+
+ // 1 : source address and size
+ src_rect->phys_addr = get_g2d_src_phys_addr(ctx, src_rect);
+ if (0 == src_rect->phys_addr)
+ return -1;
+
+ // 2 : destination address and size
+ if (0 == dst_rect->phys_addr)
+ return -2;
+
+ // check whether g2d supports the src format
+ src_rect->color_format = get_HAL_2_G2D_FORMAT(src_rect->color_format);
+ if (0 > src_rect->color_format)
+ return -3;
+
+ dst_rect->color_format = get_HAL_2_G2D_FORMAT(dst_rect->color_format);
+ if (0 > dst_rect->color_format)
+ return -4;
+
+ flag.rotate_val = rotateValueHAL2G2D(transform);
+
+ // scale and rotate and alpha with FIMG
+ if(stretchSecFimg(src_rect, dst_rect, &flag) < 0)
+ return -5;
+
+ return 0;
+}
+#endif
+
+int createMem(struct s3c_mem_t *mem, unsigned int index, unsigned int size)
+{
+ struct s3c_mem_alloc *ptr_mem_alloc;
+ struct s3c_mem_alloc mem_alloc_info;
+
+ if (index >= NUM_OF_MEM_OBJ) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::invalid index (%d >= %d)",
+ __func__, index, NUM_OF_MEM_OBJ);
+ goto err;
+ }
+
+ ptr_mem_alloc = &mem->mem_alloc[index];
+
+ if (mem->fd <= 0) {
+ mem->fd = open(S3C_MEM_DEV_NAME, O_RDWR);
+ if (mem->fd <= 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::open(%s) fail(%s)",
+ __func__, S3C_MEM_DEV_NAME, strerror(errno));
+ goto err;
+ }
+ }
+
+ // kcoolsw : what the hell of this line??
+ if (0 == size)
+ return 0;
+
+ mem_alloc_info.size = size;
+
+ if (ioctl(mem->fd, S3C_MEM_CACHEABLE_ALLOC, &mem_alloc_info) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::S3C_MEM_ALLOC(size : %d) fail",
+ __func__, mem_alloc_info.size);
+ goto err;
+ }
+
+ ptr_mem_alloc->phy_addr = mem_alloc_info.phy_addr;
+ ptr_mem_alloc->vir_addr = mem_alloc_info.vir_addr;
+ ptr_mem_alloc->size = mem_alloc_info.size;
+
+ return 0;
+
+err:
+ if (0 < mem->fd)
+ close(mem->fd);
+ mem->fd = 0;
+
+ return 0;
+}
+
+int destroyMem(struct s3c_mem_t *mem)
+{
+ int i;
+ struct s3c_mem_alloc *ptr_mem_alloc;
+
+ if (mem->fd <= 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::invalied fd(%d) fail", __func__, mem->fd);
+ return -1;
+ }
+
+ for (i = 0; i < NUM_OF_MEM_OBJ; i++) {
+ ptr_mem_alloc = &mem->mem_alloc[i];
+
+ if (0 != ptr_mem_alloc->vir_addr) {
+ if (ioctl(mem->fd, S3C_MEM_FREE, ptr_mem_alloc) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::S3C_MEM_FREE fail", __func__);
+ return -1;
+ }
+
+ ptr_mem_alloc->phy_addr = 0;
+ ptr_mem_alloc->vir_addr = 0;
+ ptr_mem_alloc->size = 0;
+ }
+ }
+
+ close(mem->fd);
+ mem->fd = 0;
+
+ return 0;
+}
+
+int checkMem(struct s3c_mem_t *mem, unsigned int index, unsigned int size)
+{
+ int ret;
+ struct s3c_mem_alloc *ptr_mem_alloc;
+ struct s3c_mem_alloc mem_alloc_info;
+
+ if (index >= NUM_OF_MEM_OBJ) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::invalid index (%d >= %d)", __func__,
+ index, NUM_OF_MEM_OBJ);
+ return -1;
+ }
+
+ if (mem->fd <= 0) {
+ ret = createMem(mem, index, size);
+ return ret;
+ }
+
+ ptr_mem_alloc = &mem->mem_alloc[index];
+
+ if (ptr_mem_alloc->size < (int)size) {
+ if (0 < ptr_mem_alloc->size) {
+ // free allocated mem
+ if (ioctl(mem->fd, S3C_MEM_FREE, ptr_mem_alloc) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::S3C_MEM_FREE fail", __func__);
+ return -1;
+ }
+ }
+
+ // allocate mem with requested size
+ mem_alloc_info.size = size;
+ if (ioctl(mem->fd, S3C_MEM_CACHEABLE_ALLOC, &mem_alloc_info) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::S3C_MEM_ALLOC(size : %d) fail",
+ __func__, mem_alloc_info.size);
+ return -1;
+ }
+
+ ptr_mem_alloc->phy_addr = mem_alloc_info.phy_addr;
+ ptr_mem_alloc->vir_addr = mem_alloc_info.vir_addr;
+ ptr_mem_alloc->size = mem_alloc_info.size;
+ }
+
+ return 0;
+}
+
+#ifdef USE_HW_PMEM
+int createPmem(sec_pmem_t *pm, unsigned int buf_size)
+{
+ int master_fd, err = 0, i;
+ void *base;
+ unsigned int phys_base;
+ size_t size, sub_size[NUM_OF_MEM_OBJ];
+ struct pmem_region region;
+
+ master_fd = open(PMEM_DEVICE_DEV_NAME, O_RDWR, 0);
+ if (master_fd < 0) {
+ pm->pmem_master_fd = -1;
+ if (EACCES == errno) {
+ return 0;
+ } else {
+ SEC_HWC_Log(HWC_LOG_ERROR, "%s::open(%s) fail(%s)",
+ __func__, PMEM_DEVICE_DEV_NAME, strerror(errno));
+ return -errno;
+ }
+ }
+
+ if (ioctl(master_fd, PMEM_GET_TOTAL_SIZE, ®ion) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "PMEM_GET_TOTAL_SIZE failed, default mode");
+ size = 8<<20; // 8 MiB
+ } else {
+ size = region.len;
+ }
+
+ base = mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, master_fd, 0);
+ if (base == MAP_FAILED) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "[%s] mmap failed : %d (%s)", __func__,
+ errno, strerror(errno));
+ base = 0;
+ close(master_fd);
+ master_fd = -1;
+ return -errno;
+ }
+
+ if (ioctl(master_fd, PMEM_GET_PHYS, ®ion) < 0) {
+ SEC_HWC_Log(HWC_LOG_ERROR, "PMEM_GET_PHYS failed, limp mode");
+ region.offset = 0;
+ }
+
+ pm->pmem_master_fd = master_fd;
+ pm->pmem_master_base = base;
+ pm->pmem_total_size = size;
+ //pm->pmem_master_phys_base = region.offset;
+ phys_base = region.offset;
+
+ // sec_pmem_alloc[0] for temporary buffer for source
+ sub_size[0] = buf_size;
+ sub_size[0] = roundUpToPageSize(sub_size[0]);
+
+ for (i = 0; i < NUM_OF_MEM_OBJ; i++) {
+ sec_pmem_alloc_t *pm_alloc = &(pm->sec_pmem_alloc[i]);
+ int fd, ret;
+ int offset = i ? sub_size[i-1] : 0;
+ struct pmem_region sub = { offset, sub_size[i] };
+
+ // create the "sub-heap"
+ if (0 > (fd = open(PMEM_DEVICE_DEV_NAME, O_RDWR, 0))) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "[%s][index=%d] open failed (%dL) : %d (%s)",
+ __func__, i, __LINE__, errno, strerror(errno));
+ return -errno;
+ }
+
+ // connect to it
+ if (0 != (ret = ioctl(fd, PMEM_CONNECT, pm->pmem_master_fd))) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "[%s][index=%d] ioctl(PMEM_CONNECT) failed : %d (%s)",
+ __func__, i, errno, strerror(errno));
+ close(fd);
+ return -errno;
+ }
+
+ // make it available to the client process
+ if (0 != (ret = ioctl(fd, PMEM_MAP, &sub))) {
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "[%s][index=%d] ioctl(PMEM_MAP) failed : %d (%s)",
+ __func__, i, errno, strerror(errno));
+ close(fd);
+ return -errno;
+ }
+
+ pm_alloc->fd = fd;
+ pm_alloc->total_size = sub_size[i];
+ pm_alloc->offset = offset;
+ pm_alloc->virt_addr = (unsigned int)base + (unsigned int)offset;
+ pm_alloc->phys_addr = (unsigned int)phys_base + (unsigned int)offset;
+
+#if defined (PMEM_DEBUG)
+ SEC_HWC_Log(HWC_LOG_DEBUG, "[%s] pm_alloc[%d] fd=%d total_size=%d "
+ "offset=0x%x virt_addr=0x%x phys_addr=0x%x",
+ __func__, i, pm_alloc->fd, pm_alloc->total_size,
+ pm_alloc->offset, pm_alloc->virt_addr, pm_alloc->phys_addr);
+#endif
+ }
+
+ return err;
+}
+
+int destroyPmem(sec_pmem_t *pm)
+{
+ int i, err;
+
+ for (i=0; i<NUM_OF_MEM_OBJ; i++) {
+ sec_pmem_alloc_t *pm_alloc = &(pm->sec_pmem_alloc[i]);
+
+ if (0 <= pm_alloc->fd) {
+ struct pmem_region sub = { pm_alloc->offset, pm_alloc->total_size };
+
+ if (0 > (err = ioctl(pm_alloc->fd, PMEM_UNMAP, &sub)))
+ SEC_HWC_Log(HWC_LOG_ERROR,
+ "[%s][index=%d] ioctl(PMEM_UNMAP) failed : %d (%s)",
+ __func__, i, errno, strerror(errno));
+#if defined (PMEM_DEBUG)
+ else
+ SEC_HWC_Log(HWC_LOG_DEBUG,
+ "[%s] pm_alloc[%d] unmap fd=%d total_size=%d offset=0x%x",
+ __func__, i, pm_alloc->fd, pm_alloc->total_size,
+ pm_alloc->offset);
+#endif
+ close(pm_alloc->fd);
+
+ pm_alloc->fd = -1;
+ pm_alloc->total_size = 0;
+ pm_alloc->offset = 0;
+ pm_alloc->virt_addr = 0;
+ pm_alloc->phys_addr = 0;
+ }
+ }
+
+ if (0 <= pm->pmem_master_fd) {
+ munmap(pm->pmem_master_base, pm->pmem_total_size);
+ close(pm->pmem_master_fd);
+ pm->pmem_master_fd = -1;
+ }
+
+ pm->pmem_master_base = 0;
+ pm->pmem_total_size = 0;
+
+ return 0;
+}
+
+int checkPmem(sec_pmem_t *pm, unsigned int index, unsigned int requested_size)
+{
+ sec_pmem_alloc_t *pm_alloc = &(pm->sec_pmem_alloc[index]);
+
+ if (0 < pm_alloc->virt_addr &&
+ requested_size <= (unsigned int)(pm_alloc->total_size))
+ return 0;
+
+ pm_alloc->size = 0;
+ return -1;
+}
+
+#endif
diff --git a/exynos4/hal/libhwcomposer/SecHWCUtils.h b/exynos4/hal/libhwcomposer/SecHWCUtils.h
new file mode 100644
index 0000000..005b694
--- /dev/null
+++ b/exynos4/hal/libhwcomposer/SecHWCUtils.h
@@ -0,0 +1,331 @@
+/*
+ * 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-03-11
+ *
+ */
+
+#ifndef ANDROID_SEC_HWC_UTILS_H_
+#define ANDROID_SEC_HWC_UTILS_H_
+
+#include <stdlib.h>
+#include <hardware/hardware.h>
+#include <hardware/hwcomposer.h>
+
+#include <fcntl.h>
+#include <errno.h>
+#include <cutils/log.h>
+
+#ifdef BOARD_USE_V4L2_ION
+#include <ion.h>
+#include "s5p_fimc_v4l2.h"
+#include "sec_utils_v4l2.h"
+#else
+#include <linux/videodev.h>
+#include "s5p_fimc.h"
+#include "sec_utils.h"
+#endif
+
+#include <linux/android_pmem.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <hardware/gralloc.h>
+
+#include "linux/fb.h"
+
+#include "s3c_lcd.h"
+#include "s3c_mem.h"
+#include "sec_format.h"
+
+//#define HWC_DEBUG
+#if defined(BOARD_USES_FIMGAPI)
+#include "sec_g2d.h"
+//#define SUB_TITLES_HWC
+#endif
+
+#define NUM_OF_WIN (2)
+#define NUM_OF_WIN_BUF (2)
+#define NUM_OF_MEM_OBJ (1)
+
+#if (NUM_OF_WIN_BUF < 2)
+ #define ENABLE_FIMD_VSYNC
+#endif
+
+#define MAX_RESIZING_RATIO_LIMIT (63)
+
+#ifdef SAMSUNG_EXYNOS4x12
+#ifdef BOARD_USE_V4L2_ION
+#define PP_DEVICE_DEV_NAME "/dev/video4"
+#else
+#define PP_DEVICE_DEV_NAME "/dev/video3"
+#endif
+#endif
+
+#ifdef SAMSUNG_EXYNOS4210
+#define PP_DEVICE_DEV_NAME "/dev/video1"
+#endif
+
+#define S3C_MEM_DEV_NAME "/dev/s3c-mem"
+#define PMEM_DEVICE_DEV_NAME "/dev/pmem_gpu1"
+
+#ifdef BOARD_USE_V4L2_ION
+#undef USE_HW_PMEM
+#else
+#define USE_HW_PMEM
+#endif
+
+#define PMEM_SIZE (1920 * 1280 * 2)
+
+struct sec_rect {
+ int32_t x;
+ int32_t y;
+ int32_t w;
+ int32_t h;
+};
+
+struct sec_img {
+ uint32_t f_w;
+ uint32_t f_h;
+ uint32_t w;
+ uint32_t h;
+ uint32_t format;
+ uint32_t base;
+ uint32_t offset;
+ uint32_t paddr;
+ uint32_t uoffset;
+ uint32_t voffset;
+ int usage;
+ 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 s3c_mem_t {
+ int fd;
+ struct s3c_mem_alloc mem_alloc[NUM_OF_MEM_OBJ];
+};
+
+#ifdef USE_HW_PMEM
+typedef struct __sec_pmem_alloc {
+ int fd;
+ int total_size;
+ int offset;
+ int size;
+ unsigned int virt_addr;
+ unsigned int phys_addr;
+} sec_pmem_alloc_t;
+
+typedef struct __sec_pmem {
+ int pmem_master_fd;
+ void *pmem_master_base;
+ int pmem_total_size;
+ sec_pmem_alloc_t sec_pmem_alloc[NUM_OF_MEM_OBJ];
+} sec_pmem_t;
+
+inline size_t roundUpToPageSize(size_t x)
+{
+ return (x + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
+}
+#endif
+
+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;
+ int status;
+ int vsync;
+#ifdef BOARD_USE_V4L2_ION
+ int ion_fd;
+#endif
+
+ 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 fb_var_screeninfo lcd_info;
+ s5p_fimc_t fimc;
+#ifdef SUB_TITLES_HWC
+ sec_g2d_t g2d;
+#endif
+ struct s3c_mem_t s3c_mem;
+#ifdef USE_HW_PMEM
+ sec_pmem_t sec_pmem;
+#endif
+ int num_of_fb_layer;
+ int num_of_hwc_layer;
+ int num_2d_blit_layer;
+ uint32_t layer_prev_buf[NUM_OF_WIN];
+};
+
+typedef enum _LOG_LEVEL {
+ HWC_LOG_DEBUG,
+ HWC_LOG_WARNING,
+ HWC_LOG_ERROR,
+} HWC_LOG_LEVEL;
+
+#define SEC_HWC_LOG_TAG "SECHWC_LOG"
+
+#ifdef HWC_DEBUG
+#define SEC_HWC_Log(a, ...) ((void)_SEC_HWC_Log(a, SEC_HWC_LOG_TAG, __VA_ARGS__))
+#else
+#define SEC_HWC_Log(a, ...) \
+ do { \
+ if (a == HWC_LOG_ERROR) \
+ ((void)_SEC_HWC_Log(a, SEC_HWC_LOG_TAG, __VA_ARGS__)); \
+ } while (0)
+#endif
+
+extern void _SEC_HWC_Log(HWC_LOG_LEVEL logLevel, const char *tag, const char *msg, ...);
+
+/* copied from gralloc module ..*/
+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 1
+ /* 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;
+
+#if 1
+ int format;
+ int magic;
+ int flags;
+ int size;
+ int offset;
+ int base_addr;
+#define IMG_NATIVE_HANDLE_NUMINTS ((sizeof(uint64_t) / sizeof(int)) + 4 + 6)
+#else
+#define IMG_NATIVE_HANDLE_NUMINTS ((sizeof(IMG_UINT64) / sizeof(int)) + 4)
+#endif
+ /* 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.
+ */
+ uint64_t ui64Stamp;
+
+ /* We could live without this, but it lets us perform some additional
+ * validation on the client side. Normally, we'd have no visibility
+ * of the allocated usage, just the lock usage.
+ */
+ int usage;
+
+ /* In order to do efficient cache flushes we need the buffer dimensions
+ * and format. These are available on the android_native_buffer_t,
+ * but the platform doesn't pass them down to the graphics HAL.
+ *
+ * TODO: Ideally the platform would be modified to not require this.
+ */
+ int width;
+ int height;
+ int bpp;
+}
+__attribute__((aligned(sizeof(int)),packed)) sec_native_handle_t;
+
+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 win_num);
+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(int fd, struct fb_var_screeninfo *lcd_info);
+
+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,
+ uint32_t transform);
+
+#ifdef SUB_TITLES_HWC
+int runG2d(struct hwc_context_t *ctx,
+ g2d_rect *src_rect, g2d_rect *dst_rect,
+ uint32_t transform);
+
+int destroyG2d(sec_g2d_t *g2d);
+int createG2d(sec_g2d_t *g2d);
+#endif
+
+int createMem (struct s3c_mem_t *mem, unsigned int index, unsigned int size);
+int destroyMem(struct s3c_mem_t *mem);
+int checkMem (struct s3c_mem_t *mem, unsigned int index, unsigned int size);
+
+#ifdef USE_HW_PMEM
+int createPmem (sec_pmem_t *pm, unsigned int size);
+int destroyPmem(sec_pmem_t *pm);
+int checkPmem (sec_pmem_t *pm, unsigned int index, unsigned int size);
+#endif
+
+#endif /* ANDROID_SEC_HWC_UTILS_H_*/
diff --git a/exynos4/hal/libhwconverter/Android.mk b/exynos4/hal/libhwconverter/Android.mk
index ecda03b..c1ded53 100644
--- a/exynos4/hal/libhwconverter/Android.mk
+++ b/exynos4/hal/libhwconverter/Android.mk
@@ -12,6 +12,8 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
+
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
@@ -21,10 +23,13 @@
LOCAL_SRC_FILES := HardwareConverter.cpp
LOCAL_C_INCLUDES := \
- $(TOP)/$(BOARD_HAL_PATH)/include \
- $(TOP)/$(BOARD_HMM_PATH)/openmax/sec_omx/include/khronos \
- $(TOP)/$(BOARD_HMM_PATH)/openmax/sec_omx/include/sec
+ $(LOCAL_PATH)/../include \
+ $(TOP)/$(TARGET_HAL_PATH)/include \
+ $(TOP)/$(TARGET_OMX_PATH)/include/khronos \
+ $(TOP)/$(TARGET_OMX_PATH)/include/sec
LOCAL_MODULE_TAGS := eng
LOCAL_MODULE := libhwconverter
include $(BUILD_SHARED_LIBRARY)
+
+endif
diff --git a/exynos4/hal/libhwconverter/HardwareConverter.cpp b/exynos4/hal/libhwconverter/HardwareConverter.cpp
index 3a66767..9ff6e55 100644
--- a/exynos4/hal/libhwconverter/HardwareConverter.cpp
+++ b/exynos4/hal/libhwconverter/HardwareConverter.cpp
@@ -15,7 +15,6 @@
*/
#include <utils/Log.h>
-
#include "SEC_OMX_Def.h"
#include "SecFimc.h"
#include "HardwareConverter.h"
@@ -25,7 +24,7 @@
SecFimc* handle_fimc = new SecFimc();
mSecFimc = (void *)handle_fimc;
- if (handle_fimc->create(SecFimc::DEV_2, SecFimc::MODE_MULTI_BUF, 1) == false)
+ if (handle_fimc->create(SecFimc::DEV_0, SecFimc::MODE_MULTI_BUF, 1) == false)
bHWconvert_flag = 0;
else
bHWconvert_flag = 1;
diff --git a/exynos4/Android.mk b/exynos4/hal/libhwjpeg/Android.mk
similarity index 60%
copy from exynos4/Android.mk
copy to exynos4/hal/libhwjpeg/Android.mk
index 3c99f1a..21a99fb 100644
--- a/exynos4/Android.mk
+++ b/exynos4/hal/libhwjpeg/Android.mk
@@ -1,4 +1,4 @@
-# Copyright (C) 2012 The Android Open Source Project
+# 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.
@@ -12,12 +12,22 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-ifeq ($(TARGET_BOARD_PLATFORM),exynos4)
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
-BOARD_HAL_PATH := hardware/samsung/exynos4/hal
-BOARD_HMM_PATH := hardware/samsung/exynos4/multimedia
+LOCAL_C_INCLUDES := $(LOCAL_PATH) \
+ $(LOCAL_PATH)/../include
-include $(BOARD_HAL_PATH)/Android.mk
-include $(BOARD_HMM_PATH)/Android.mk
+LOCAL_SRC_FILES:= \
+ jpeg_hal_unit.c \
-endif
+LOCAL_SHARED_LIBRARIES := \
+ libcutils \
+
+LOCAL_STATIC_LIBRARIES := \
+
+LOCAL_MODULE:= libhwjpeg
+
+LOCAL_MODULE_TAGS := eng
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/hal/libhwjpeg/jpeg_hal_unit.c b/exynos4/hal/libhwjpeg/jpeg_hal_unit.c
new file mode 100644
index 0000000..a0b4224
--- /dev/null
+++ b/exynos4/hal/libhwjpeg/jpeg_hal_unit.c
@@ -0,0 +1,572 @@
+/*
+ * 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.
+ */
+
+#define LOG_TAG "libhwjpeg"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <math.h>
+#include <sys/poll.h>
+
+#include <cutils/log.h>
+
+#include "jpeg_hal.h"
+
+#ifdef JPEG_PERF_MEAS
+unsigned long measure_time(struct timeval *start, struct timeval *stop)
+{
+ unsigned long sec, usec, time;
+
+ sec = stop->tv_sec - start->tv_sec;
+
+ if (stop->tv_usec >= start->tv_usec) {
+ usec = stop->tv_usec - start->tv_usec;
+ } else {
+ usec = stop->tv_usec + 1000000 - start->tv_usec;
+ sec--;
+ }
+
+ time = (sec * 1000000) + usec;
+
+ return time;
+}
+#endif
+
+static int jpeg_v4l2_querycap(int fd)
+{
+ struct v4l2_capability cap;
+ int ret = 0;
+
+ ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);
+
+ if (!(cap.capabilities & V4L2_CAP_STREAMING))
+ LOGE("[%s]: does not support streaming", __func__);
+
+ if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT))
+ LOGE("[%s]: does not support output", __func__);
+
+ if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
+ LOGE("[%s]: does not support capture", __func__);
+
+ return ret;
+}
+
+static int jpeg_v4l2_s_jpegcomp(int fd, int quality)
+{
+ struct v4l2_jpegcompression arg;
+ int ret = 0;
+
+ arg.quality = quality;
+
+ ret = ioctl(fd, VIDIOC_S_JPEGCOMP, &arg);
+
+ return ret;
+}
+
+static int jpeg_v4l2_s_fmt(int fd, enum v4l2_buf_type type, struct jpeg_config *config)
+{
+ struct v4l2_format fmt;
+ int ret = 0;
+
+ fmt.type = type;
+ fmt.fmt.pix_mp.width = config->width;
+ fmt.fmt.pix_mp.height = config->height;
+ fmt.fmt.pix_mp.field = V4L2_FIELD_ANY;
+ fmt.fmt.pix_mp.num_planes = config->num_planes;
+
+ if (config->mode == JPEG_ENCODE)
+ fmt.fmt.pix_mp.colorspace = V4L2_COLORSPACE_JPEG;
+
+ switch (fmt.type) {
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT: /* fall through */
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+ break;
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
+ if (config->mode == JPEG_ENCODE) {
+ fmt.fmt.pix_mp.pixelformat = config->pix.enc_fmt.in_fmt;
+ } else {
+ fmt.fmt.pix_mp.pixelformat = config->pix.dec_fmt.in_fmt;
+ fmt.fmt.pix_mp.plane_fmt[0].sizeimage = config->sizeJpeg;
+ }
+ break;
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
+ if (config->mode == JPEG_ENCODE) {
+ fmt.fmt.pix_mp.pixelformat = config->pix.enc_fmt.out_fmt;
+ } else {
+ fmt.fmt.pix_mp.pixelformat = config->pix.dec_fmt.out_fmt;
+ fmt.fmt.pix_mp.width = config->scaled_width;
+ fmt.fmt.pix_mp.height = config->scaled_height;
+ }
+ break;
+ default:
+ LOGE("[%s]: invalid v4l2 buf type", __func__);
+ return -1;
+ }
+
+ ret = ioctl(fd, VIDIOC_S_FMT, &fmt);
+
+ return ret;
+}
+
+static int jpeg_v4l2_g_fmt(int fd, enum v4l2_buf_type type, struct jpeg_config *config)
+{
+ struct v4l2_format fmt;
+ int ret = 0;
+
+ fmt.type = type;
+ ret = ioctl(fd, VIDIOC_G_FMT, &fmt);
+ if (ret < 0)
+ return -1;
+
+ config->width = fmt.fmt.pix_mp.width;
+ config->height = fmt.fmt.pix_mp.height;
+
+ switch (fmt.type) {
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT: /* fall through */
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+ break;
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
+ if (config->mode == JPEG_ENCODE)
+ config->pix.enc_fmt.in_fmt = fmt.fmt.pix_mp.pixelformat;
+ else
+ config->pix.dec_fmt.in_fmt = fmt.fmt.pix_mp.pixelformat;
+ break;
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
+ if (config->mode == JPEG_ENCODE)
+ config->pix.enc_fmt.out_fmt = fmt.fmt.pix_mp.pixelformat;
+ else
+ config->pix.dec_fmt.out_fmt = fmt.fmt.pix_mp.pixelformat;
+ break;
+ default:
+ LOGE("[%s]: invalid v4l2 buf type", __func__);
+ return -1;
+ }
+
+ return ret;
+}
+
+int jpeghal_getconfig(int fd, struct jpeg_config *config)
+{
+ int ret = 0;
+
+ ret = jpeg_v4l2_g_fmt(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, config);
+ if (ret < 0) {
+ LOGE("[%s]: input G_FMT failed", __func__);
+ return -1;
+ }
+
+ ret = jpeg_v4l2_g_fmt(fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, config);
+ if (ret < 0)
+ LOGE("[%s]: output G_FMT failed", __func__);
+
+ return ret;
+}
+
+static int jpeg_v4l2_reqbufs(int fd, int buf_cnt, struct jpeg_buf *buf)
+{
+ struct v4l2_requestbuffers req;
+ int ret = 0;
+
+ memset(&req, 0, sizeof(req));
+
+ req.type = buf->buf_type;
+ req.memory = buf->memory;
+
+ req.count = buf_cnt;
+
+ ret = ioctl(fd, VIDIOC_REQBUFS, &req);
+
+ return ret;
+}
+
+static int jpeg_v4l2_querybuf(int fd, struct jpeg_buf *buf)
+{
+ struct v4l2_buffer v4l2_buf;
+ struct v4l2_plane plane[JPEG_MAX_PLANE_CNT];
+ int i;
+ int ret = 0;
+
+ memset(plane, 0, (int)JPEG_MAX_PLANE_CNT * sizeof(struct v4l2_plane));
+
+ v4l2_buf.index = 0;
+ v4l2_buf.type = buf->buf_type;
+ v4l2_buf.memory = buf->memory;
+ v4l2_buf.length = buf->num_planes;
+ v4l2_buf.m.planes = plane;
+
+ ret = ioctl(fd, VIDIOC_QUERYBUF, &v4l2_buf);
+ if (ret < 0) {
+ LOGE("[%s:%d]: VIDIOC_QUERYBUF failed", __func__, ret);
+ return ret;
+ }
+
+ for (i= 0; i < buf->num_planes; i++) {
+ buf->length[i] = v4l2_buf.m.planes[i].length;
+ buf->start[i] = (char *) mmap(0, buf->length[i],
+ PROT_READ | PROT_WRITE, MAP_SHARED, fd,
+ v4l2_buf.m.planes[i].m.mem_offset);
+
+ //LOGI("[%s]: buf.start[%d] = %p, length = %d", __func__, 0, buf->start[0], buf->length[0]);
+ if (buf->start[0] == MAP_FAILED) {
+ LOGE("[%s]: mmap failed", __func__);
+ return -1;
+ }
+ }
+
+ return ret;
+}
+
+static int jpeg_v4l2_qbuf(int fd, struct jpeg_buf *buf)
+{
+ struct v4l2_buffer v4l2_buf;
+ struct v4l2_plane plane[JPEG_MAX_PLANE_CNT];
+ int i;
+ int ret = 0;
+
+ memset(&v4l2_buf, 0, sizeof(struct v4l2_buffer));
+ memset(plane, 0, (int)JPEG_MAX_PLANE_CNT * sizeof(struct v4l2_plane));
+
+ v4l2_buf.index = 0;
+ v4l2_buf.type = buf->buf_type;
+ v4l2_buf.memory = buf->memory;
+ v4l2_buf.length = buf->num_planes;
+ v4l2_buf.m.planes = plane;
+
+ if (buf->memory == V4L2_MEMORY_USERPTR) {
+ for (i = 0; i < buf->num_planes; i++) {
+ v4l2_buf.m.planes[i].m.userptr = (unsigned long)buf->start[i];
+ v4l2_buf.m.planes[i].length = buf->length[i];
+ }
+ }
+
+ ret = ioctl(fd, VIDIOC_QBUF, &v4l2_buf);
+ if (ret < 0) {
+ LOGE("[%s:%d] QBUF failed", __func__, ret);
+ return -1;
+ }
+
+ return ret;
+}
+
+static int jpeg_v4l2_dqbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory)
+{
+ struct v4l2_buffer buf;
+ int ret = 0;
+
+ memset(&buf, 0, sizeof(struct v4l2_buffer));
+
+ buf.type = type;
+ buf.memory = memory;
+
+ ret = ioctl(fd, VIDIOC_DQBUF, &buf);
+ if (ret < 0) {
+ LOGE("[%s:%d] DQBUF failed", __func__, ret);
+ return -1;
+ }
+
+ return ret;
+}
+
+static int jpeg_v4l2_streamon(int fd, enum v4l2_buf_type type)
+{
+ int ret = 0;
+
+ ret = ioctl(fd, VIDIOC_STREAMON, &type);
+ if (ret < 0) {
+ LOGE("[%s:%d] STREAMON failed", __func__, ret);
+ return -1;
+ }
+
+ return ret;
+}
+
+static int jpeg_v4l2_streamoff(int fd, enum v4l2_buf_type type)
+{
+ int ret = 0;
+
+ ret = ioctl(fd, VIDIOC_STREAMOFF, &type);
+ if (ret < 0) {
+ LOGE("[%s:%d] STREAMOFF failed", __func__, ret);
+ return -1;
+ }
+
+ return ret;
+}
+
+int jpeghal_dec_init()
+{
+ int fd;
+ int ret = 0;
+
+ fd = open(JPEG_DEC_NODE, O_RDWR, 0);
+
+ if (fd < 0) {
+ LOGE("[%s]: JPEG dec open failed", __func__);
+ return -1;
+ }
+
+ ret = jpeg_v4l2_querycap(fd);
+ if (ret < 0) {
+ LOGE("[%s]: QUERYCAP failed", __func__);
+ return -1;
+ }
+
+ return fd;
+}
+
+int jpeghal_enc_init()
+{
+ int fd;
+ int ret = 0;
+
+ fd = open(JPEG_ENC_NODE, O_RDWR, 0);
+ if (fd < 0) {
+ LOGE("[%s]: JPEG enc open failed", __func__);
+ return -1;
+ }
+
+ ret = jpeg_v4l2_querycap(fd);
+ if (ret < 0) {
+ LOGE("[%s]: QUERYCAP failed", __func__);
+ return -1;
+ }
+
+ return fd;
+}
+
+int jpeghal_dec_setconfig(int fd, struct jpeg_config *config)
+{
+ int ret = 0;
+
+ config->mode = JPEG_DECODE;
+
+ ret = jpeg_v4l2_s_fmt(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, config);
+ if (ret < 0) {
+ LOGE("[%s]: decoder input S_FMT failed", __func__);
+ return -1;
+ }
+
+ ret = jpeg_v4l2_s_fmt(fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, config);
+ if (ret < 0) {
+ LOGE("[%s]: decoder output S_FMT failed", __func__);
+ return -1;
+ }
+
+ return ret;
+}
+
+int jpeghal_dec_getconfig(int fd, struct jpeg_config *config)
+{
+ int ret = 0;
+
+ jpeghal_getconfig(fd, config);
+
+ return ret;
+}
+
+int jpeghal_enc_setconfig(int fd, struct jpeg_config *config)
+{
+ int ret = 0;
+
+ ret = jpeg_v4l2_s_jpegcomp(fd, config->enc_qual);
+ if (ret < 0) {
+ LOGE("[%s]: S_JPEGCOMP failed", __func__);
+ return -1;
+ }
+
+ config->mode = JPEG_ENCODE;
+
+ ret = jpeg_v4l2_s_fmt(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, config);
+ if (ret < 0) {
+ LOGE("[%s]: encoder input S_FMT failed", __func__);
+ return -1;
+ }
+
+ ret = jpeg_v4l2_s_fmt(fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, config);
+ if (ret < 0) {
+ LOGE("[%s]: encoder output S_FMT failed", __func__);
+ return -1;
+ }
+
+ return ret;
+}
+
+int jpeghal_enc_getconfig(int fd, struct jpeg_config *config)
+{
+ int ret = 0;
+
+ jpeghal_getconfig(fd, config);
+
+ return ret;
+}
+
+int jpeghal_set_inbuf(int fd, struct jpeg_buf *buf)
+{
+ int ret = 0;
+
+ buf->buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+
+ ret = jpeg_v4l2_reqbufs(fd, 1, buf);
+ if (ret < 0) {
+ LOGE("[%s:%d]: Input REQBUFS failed", __func__, ret);
+ return -1;
+ }
+
+ if (buf->memory == V4L2_MEMORY_MMAP) {
+ ret = jpeg_v4l2_querybuf(fd, buf);
+ if (ret < 0) {
+ LOGE("[%s:%d]: Input QUERYBUF failed", __func__, ret);
+ return -1;
+ }
+ }
+
+ return ret;
+}
+
+int jpeghal_set_outbuf(int fd, struct jpeg_buf *buf)
+{
+ int ret = 0;
+
+ buf->buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+
+ ret = jpeg_v4l2_reqbufs(fd, 1, buf);
+ if (ret < 0) {
+ LOGE("[%s:%d]: Output REQBUFS failed", __func__, ret);
+ return -1;
+ }
+
+ if (buf->memory == V4L2_MEMORY_MMAP) {
+ ret = jpeg_v4l2_querybuf(fd, buf);
+ if (ret < 0) {
+ LOGE("[%s:%d]: Output QUERYBUF failed", __func__, ret);
+ return -1;
+ }
+ }
+
+ return ret;
+}
+
+static int jpeg_exe(int fd, struct jpeg_buf *in_buf, struct jpeg_buf *out_buf)
+{
+ int ret = 0;
+
+ ret = jpeg_v4l2_qbuf(fd, in_buf);
+ if (ret < 0) {
+ LOGE("[%s:%d]: Input QBUF failed", __func__, ret);
+ return -1;
+ }
+
+ ret = jpeg_v4l2_qbuf(fd, out_buf);
+ if (ret < 0) {
+ LOGE("[%s:%d]: Output QBUF failed", __func__, ret);
+ return -1;
+ }
+
+ ret = jpeg_v4l2_streamon(fd, in_buf->buf_type);
+ ret = jpeg_v4l2_streamon(fd, out_buf->buf_type);
+
+ ret = jpeg_v4l2_dqbuf(fd, in_buf->buf_type, in_buf->memory);
+ ret = jpeg_v4l2_dqbuf(fd, out_buf->buf_type, out_buf->memory);
+
+ return ret;
+}
+
+int jpeghal_dec_exe(int fd, struct jpeg_buf *in_buf, struct jpeg_buf *out_buf)
+{
+ int ret = 0;
+
+ ret = jpeg_exe(fd, in_buf, out_buf);
+ if (ret < 0)
+ LOGE("[%s]: JPEG decoding is failed", __func__);
+
+ return ret;
+}
+
+int jpeghal_enc_exe(int fd, struct jpeg_buf *in_buf, struct jpeg_buf *out_buf)
+{
+ int ret = 0;
+
+ ret = jpeg_exe(fd, in_buf, out_buf);
+ if (ret < 0)
+ LOGE("[%s]: JPEG Encoding is failed", __func__);
+
+ return ret;
+}
+
+int jpeghal_deinit(int fd, struct jpeg_buf *in_buf, struct jpeg_buf *out_buf)
+{
+ int ret = 0;
+
+ jpeg_v4l2_streamoff(fd, in_buf->buf_type);
+ jpeg_v4l2_streamoff(fd, out_buf->buf_type);
+
+ if (in_buf->memory == V4L2_MEMORY_MMAP)
+ munmap((char *)(in_buf->start[0]), in_buf->length[0]);
+
+ if (out_buf->memory == V4L2_MEMORY_MMAP)
+ munmap((char *)(out_buf->start[0]), out_buf->length[0]);
+
+ jpeg_v4l2_reqbufs(fd, 0, in_buf);
+
+ jpeg_v4l2_reqbufs(fd, 0, out_buf);
+
+ ret = close(fd);
+
+ return ret;
+}
+
+int jpeghal_s_ctrl(int fd, int cid, int value)
+{
+ struct v4l2_control vc;
+ int ret = 0;
+
+ vc.id = cid;
+ vc.value = value;
+
+ ret = ioctl(fd, VIDIOC_S_CTRL, &vc);
+ if (ret != 0) {
+ LOGE("[%s] ioctl : cid(%d), value(%d)\n", __func__, cid, value);
+ return -1;
+ }
+
+ return ret;
+}
+
+int jpeghal_g_ctrl(int fd, int id)
+{
+ struct v4l2_control ctrl;
+ int ret = 0;
+
+ ctrl.id = id;
+
+ ret = ioctl(fd, VIDIOC_G_CTRL, &ctrl);
+ if (ret < 0) {
+ LOGE("[%s] ioctl : cid(%d)\n", __func__, ctrl.id);
+ return -1;
+ }
+
+ return ctrl.value;
+}
diff --git a/exynos4/hal/libs5pjpeg/Android.mk b/exynos4/hal/libs5pjpeg/Android.mk
index e1ac187..c6d8cf6 100644
--- a/exynos4/hal/libs5pjpeg/Android.mk
+++ b/exynos4/hal/libs5pjpeg/Android.mk
@@ -15,9 +15,8 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH) \
- $(BOARD_HAL_PATH)/include \
+LOCAL_C_INCLUDES := $(LOCAL_PATH)
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
LOCAL_SRC_FILES:= \
jpeg_api.c \
diff --git a/exynos4/hal/libswconverter/Android.mk b/exynos4/hal/libswconverter/Android.mk
index ce6daf4..e52aea7 100644
--- a/exynos4/hal/libswconverter/Android.mk
+++ b/exynos4/hal/libswconverter/Android.mk
@@ -1,20 +1,9 @@
-# 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_MODULE_TAGS := optional
+
LOCAL_SRC_FILES := \
swconvertor.c \
csc_linear_to_tiled_crop_neon.s \
@@ -24,21 +13,24 @@
csc_interleave_memcpy_neon.s
LOCAL_C_INCLUDES := \
- $(TOP)/$(BOARD_HMM_PATH)/openmax/include/khronos \
- $(TOP)/$(BOARD_HMM_PATH)/openmax/include/sec \
- $(TOP)/$(BOARD_HAL_PATH)/include \
- $(TOP)/$(BOARD_HAL_PATH)/libhwconverter
+ $(TOP)/$(TARGET_OMX_PATH)/include/khronos \
+ $(TOP)/$(TARGET_OMX_PATH)/include/sec \
+ $(TOP)/$(TARGET_HAL_PATH)/include \
+ $(TOP)/$(TARGET_HAL_PATH)/libhwconverter
ifeq ($(BOARD_USE_SAMSUNG_COLORFORMAT), true)
LOCAL_CFLAGS += -DUSE_SAMSUNG_COLORFORMAT
endif
-LOCAL_MODULE_TAGS := eng
LOCAL_MODULE := libswconverter
LOCAL_PRELINK_MODULE := false
+
+LOCAL_CFLAGS :=
+
LOCAL_ARM_MODE := arm
+LOCAL_STATIC_LIBRARIES :=
LOCAL_SHARED_LIBRARIES := liblog libfimc libhwconverter
include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/hal/libump/Android.mk b/exynos4/hal/libump/Android.mk
deleted file mode 100644
index 306b6af..0000000
--- a/exynos4/hal/libump/Android.mk
+++ /dev/null
@@ -1,48 +0,0 @@
-#
-# Copyright (C) 2010 ARM Limited. All rights reserved.
-#
-# 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)
-
-UMP_SRCS := \
- arch_011_udd/ump_frontend.c \
- arch_011_udd/ump_ref_drv.c \
- arch_011_udd/ump_arch.c \
- os/linux/ump_uku.c \
- os/linux/ump_osu_memory.c \
- os/linux/ump_osu_locks.c
-
-# Shared and static library for target
-# ========================================================
-include $(CLEAR_VARS)
-LOCAL_MODULE := libUMP
-LOCAL_SRC_FILES := $(UMP_SRCS)
-
-LOCAL_C_INCLUDES:= \
- $(BOARD_HAL_PATH)/libump/ \
- $(BOARD_HAL_PATH)/libump/include \
-
-LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_PATH := $(TARGET_OUT_STATIC_LIBRARIES)/
-include $(BUILD_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := libUMP
-LOCAL_MODULE_TAGS := optional
-LOCAL_WHOLE_STATIC_LIBRARIES := libUMP
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/hal/libump/Makefile b/exynos4/hal/libump/Makefile
deleted file mode 100644
index b936fe9..0000000
--- a/exynos4/hal/libump/Makefile
+++ /dev/null
@@ -1,38 +0,0 @@
-#
-# Copyright (C) 2010-2011 ARM Limited. All rights reserved.
-#
-# 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.
-#
-
-UMP_DIR ?= .
-UMP_LIB ?= libUMP
-UDD_OS ?= android
-#CROSS_COMPILE ?= arm-none-linux-gnueabi-
-TARGET_CC ?= $(CROSS_COMPILE)gcc
-TARGET_AR ?= $(CROSS_COMPILE)ar
-CFLAGS += -I$(UMP_DIR)/include -I$(UMP_DIR)/include/ump -Wall -march=armv6 -mthumb-interwork -fno-strict-aliasing -Wno-strict-aliasing -Wno-long-long -O3
-
-include ump.mak
-
-%.o: %.c
- $(TARGET_CC) -c -o $@ $< $(CFLAGS)
-
-UMP_OBJS := $(UMP_SRCS:.c=.o)
-
-libUMP.so: $(UMP_OBJS)
- arm-none-linux-gnueabi-gcc -shared -o $@ $(UMP_OBJS) $(CFLAGS)
-libUMP.a: $(UMP_OBJS)
- $(TARGET_AR) rcs $@ $(UMP_OBJS)
-
-clean:
- -rm -f $(UMP_OBJS) libUMP.so libUMP.a
diff --git a/exynos4/hal/libump/arch_011_udd/ump_arch.c b/exynos4/hal/libump/arch_011_udd/ump_arch.c
deleted file mode 100644
index 79c3c18..0000000
--- a/exynos4/hal/libump/arch_011_udd/ump_arch.c
+++ /dev/null
@@ -1,260 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_arch.c
- *
- * UMP arch layer for UMP-UDD
- */
-
-#include <ump/ump.h>
-#include "ump_arch.h"
-#include <ump/ump_debug.h>
-
-#include <ump/ump_uk_types.h>
-#include "../os/ump_uku.h"
-
-/** Pointer to an OS-Specific context that we should pass in _uku_ calls */
-void *ump_uk_ctx = NULL;
-
-/** Reference counting of ump_arch_open() and ump_arch_close(). */
-volatile static int ump_ref_count = 0;
-
-/** Lock for critical section in open/close */
-_ump_osu_lock_t * ump_lock = NULL;
-
-ump_result ump_arch_open(void)
-{
- ump_result retval = UMP_OK;
-
- _ump_osu_lock_auto_init( &ump_lock, 0, 0, 0 );
-
- /* Check that the lock was initialized */
- if (NULL == ump_lock)
- {
- UMP_DEBUG_PRINT(1, ("UMP: ump_arch_open() failed to init lock\n"));
- return UMP_ERROR;
- }
-
- /* Attempt to obtain a lock */
- if( _UMP_OSU_ERR_OK != _ump_osu_lock_wait( ump_lock, _UMP_OSU_LOCKMODE_RW ) )
- {
- UMP_DEBUG_PRINT(1, ("UMP: ump_arch_open() failed to acquire lock\n"));
- return UMP_ERROR;
- }
-
- /* ASSERT NEEDED */
- UMP_DEBUG_ASSERT(0 <= ump_ref_count, ("UMP: Reference count invalid at _ump_base_arch_open()"));
- ump_ref_count++;
-
- if (1 == ump_ref_count)
- {
- /* We are the first, open the UMP device driver */
-
- if (_UMP_OSU_ERR_OK != _ump_uku_open( &ump_uk_ctx ))
- {
- UMP_DEBUG_PRINT(1, ("UMP: ump_arch_open() failed to open UMP device driver\n"));
- retval = UMP_ERROR;
- ump_ref_count--;
- }
- }
-
- /* Signal the lock so someone else can use it */
- _ump_osu_lock_signal( ump_lock, _UMP_OSU_LOCKMODE_RW );
-
- return retval;
-}
-
-
-
-void ump_arch_close(void)
-{
- _ump_osu_lock_auto_init( &ump_lock, 0, 0, 0 );
-
- /* Check that the lock was initialized */
- if(NULL == ump_lock)
- {
- UMP_DEBUG_PRINT(1, ("UMP: ump_arch_close() failed to init lock\n"));
- return;
- }
-
- /* Attempt to obtain a lock */
- if( _UMP_OSU_ERR_OK != _ump_osu_lock_wait( ump_lock, _UMP_OSU_LOCKMODE_RW ) )
- {
- UMP_DEBUG_PRINT(1, ("UMP: ump_arch_close() failed to acquire lock\n"));
- return;
- }
-
- UMP_DEBUG_ASSERT(0 < ump_ref_count, ("UMP: ump_arch_close() called while no references exist"));
- if (ump_ref_count > 0)
- {
- ump_ref_count--;
- if (0 == ump_ref_count)
- {
- _ump_osu_errcode_t retval = _ump_uku_close(&ump_uk_ctx);
- UMP_DEBUG_ASSERT(retval == _UMP_OSU_ERR_OK, ("UMP: Failed to close UMP interface"));
- UMP_IGNORE(retval);
- ump_uk_ctx = NULL;
- _ump_osu_lock_signal( ump_lock, _UMP_OSU_LOCKMODE_RW );
- _ump_osu_lock_term( ump_lock ); /* Not 100% thread safe, since another thread can already be waiting for this lock in ump_arch_open() */
- ump_lock = NULL;
- return;
- }
- }
-
- /* Signal the lock so someone else can use it */
- _ump_osu_lock_signal( ump_lock, _UMP_OSU_LOCKMODE_RW );
-}
-
-
-
-ump_secure_id ump_arch_allocate(unsigned long * size, ump_alloc_constraints constraints)
-{
- _ump_uk_allocate_s call_arg;
-
- if ( NULL == size )
- {
- return UMP_INVALID_SECURE_ID;
- }
-
- call_arg.ctx = ump_uk_ctx;
- call_arg.secure_id = UMP_INVALID_SECURE_ID;
- call_arg.size = *size;
-#ifdef UMP_DEBUG_SKIP_CODE
- /** Run-time ASSERTing that _ump_uk_api_version_s and ump_alloc_constraints are
- * interchangable */
- switch (constraints)
- {
- case UMP_REF_DRV_CONSTRAINT_NONE:
- UMP_DEBUG_ASSERT( UMP_REF_DRV_UK_CONSTRAINT_NONE == constraints, ("ump_uk_alloc_constraints out of sync with ump_alloc_constraints") );
- break;
- case UMP_REF_DRV_CONSTRAINT_PHYSICALLY_LINEAR:
- UMP_DEBUG_ASSERT( UMP_REF_DRV_UK_CONSTRAINT_PHYSICALLY_LINEAR == constraints, ("ump_uk_alloc_constraints out of sync with ump_alloc_constraints") );
- break;
- default:
- UMP_DEBUG_ASSERT( 1, ("ump_uk_alloc_constraints out of sync with ump_alloc_constraints: %d unrecognized", constraints) );
- break;
- }
-#endif
- call_arg.constraints = (ump_uk_alloc_constraints)constraints;
-
- if ( _UMP_OSU_ERR_OK != _ump_uku_allocate(&call_arg) )
- {
- return UMP_INVALID_SECURE_ID;
- }
-
- *size = call_arg.size;
-
- UMP_DEBUG_PRINT(4, ("UMP: Allocated ID %u, size %ul", call_arg.secure_id, call_arg.size));
-
- return call_arg.secure_id;
-}
-
-
-
-unsigned long ump_arch_size_get(ump_secure_id secure_id)
-{
- _ump_uk_size_get_s dd_size_call_arg;
-
- dd_size_call_arg.ctx = ump_uk_ctx;
- dd_size_call_arg.secure_id = secure_id;
- dd_size_call_arg.size = 0;
-
- if (_UMP_OSU_ERR_OK == _ump_uku_size_get( &dd_size_call_arg ) )
- {
- return dd_size_call_arg.size;
- }
-
- return 0;
-}
-
-
-void ump_arch_reference_release(ump_secure_id secure_id)
-{
- _ump_uk_release_s dd_release_call_arg;
- _ump_osu_errcode_t retval;
-
- dd_release_call_arg.ctx = ump_uk_ctx;
- dd_release_call_arg.secure_id = secure_id;
-
- UMP_DEBUG_PRINT(4, ("UMP: Releasing ID %u", secure_id));
-
- retval = _ump_uku_release( &dd_release_call_arg );
- UMP_DEBUG_ASSERT(retval == _UMP_OSU_ERR_OK, ("UMP: Failed to release reference to UMP memory"));
- UMP_IGNORE(retval);
-}
-
-
-void* ump_arch_map(ump_secure_id secure_id, unsigned long size, ump_cache_enabled cache, unsigned long *cookie_out)
-{
- _ump_uk_map_mem_s dd_map_call_arg;
-
- UMP_DEBUG_ASSERT_POINTER( cookie_out );
-
- dd_map_call_arg.ctx = ump_uk_ctx;
- dd_map_call_arg.secure_id = secure_id;
- dd_map_call_arg.size = size;
- dd_map_call_arg.is_cached = (u32) (UMP_CACHE_ENABLE==cache);
-
- if ( -1 == _ump_uku_map_mem( &dd_map_call_arg ) )
- {
- UMP_DEBUG_PRINT(4, ("UMP: Mapping failed for ID %u", secure_id));
- return NULL;
- }
-
- UMP_DEBUG_PRINT(4, ("Mapped %u at 0x%08lx", secure_id, (unsigned long)dd_map_call_arg.mapping));
-
- *cookie_out = dd_map_call_arg.cookie;
- return dd_map_call_arg.mapping;
-}
-
-
-
-void ump_arch_unmap(void* mapping, unsigned long size, unsigned long cookie)
-{
- _ump_uk_unmap_mem_s dd_unmap_call_arg;
-
- dd_unmap_call_arg.ctx = ump_uk_ctx;
- dd_unmap_call_arg.mapping = mapping;
- dd_unmap_call_arg.size = size;
- dd_unmap_call_arg.cookie = cookie;
-
- UMP_DEBUG_PRINT(4, ("Unmapping 0x%08lx", (unsigned long)mapping));
- _ump_uku_unmap_mem( &dd_unmap_call_arg );
-}
-
-/** Memory synchronization - cache flushing of mapped memory */
-int ump_arch_msync(ump_secure_id secure_id, void* mapping, unsigned long cookie, void * address, unsigned long size, ump_cpu_msync_op op)
-{
- _ump_uk_msync_s dd_msync_call_arg;
-
- dd_msync_call_arg.ctx = ump_uk_ctx;
- dd_msync_call_arg.mapping = mapping;
- dd_msync_call_arg.address = address;
- dd_msync_call_arg.size = size;
- dd_msync_call_arg.op = (ump_uk_msync_op)op;
- dd_msync_call_arg.cookie = cookie;
- dd_msync_call_arg.secure_id = secure_id;
- dd_msync_call_arg.is_cached = 0;
-
- UMP_DEBUG_PRINT(4, ("Msync 0x%08lx", (unsigned long)mapping));
- _ump_uku_msynch( &dd_msync_call_arg );
- if ( 0==dd_msync_call_arg.is_cached )
- {
- UMP_DEBUG_PRINT(4, ("Trying to flush uncached UMP mem ID: %d", secure_id));
- }
- return dd_msync_call_arg.is_cached;
-}
diff --git a/exynos4/hal/libump/arch_011_udd/ump_arch.h b/exynos4/hal/libump/arch_011_udd/ump_arch.h
deleted file mode 100644
index 064d7c5..0000000
--- a/exynos4/hal/libump/arch_011_udd/ump_arch.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_arch.h
- *
- * Header file for the arch dependent backend, which will do the communication with the UMP device driver.
- */
-
-#ifndef _UNIFIED_MEMORY_PROVIDER_ARCH_H_
-#define _UNIFIED_MEMORY_PROVIDER_ARCH_H_
-
-#include <ump/ump.h>
-#include <ump/ump_ref_drv.h>
-#include "ump_internal.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-
-/** Open UMP interface. */
-ump_result ump_arch_open(void);
-
-/** Close UMP interface. */
-void ump_arch_close(void);
-
-/** Allocate UMP memory. */
-ump_secure_id ump_arch_allocate(unsigned long * size, ump_alloc_constraints constraints);
-
-/** Query size of specified UMP memory, in bytes. */
-unsigned long ump_arch_size_get(ump_secure_id secure_id);
-
-/** Release a reference from specified UMP memory. */
-void ump_arch_reference_release(ump_secure_id secure_id);
-
-/** Map specified UMP memory into CPU address space */
-void* ump_arch_map(ump_secure_id secure_id, unsigned long size, ump_cache_enabled cache, unsigned long *cookie_out);
-
-/** Unmap specified UMP memory from CPU adderss space */
-void ump_arch_unmap(void* mapping, unsigned long size, unsigned long cookie);
-
-/** Memory synchronization - cache flushing of mapped memory
- * @return Is_cached: 1==True 0==NonCached */
-int ump_arch_msync(ump_secure_id secure_id, void* mapping, unsigned long cookie, void * address, unsigned long size, ump_cpu_msync_op op);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _UNIFIED_MEMORY_PROVIDER_ARCH_H_ */
diff --git a/exynos4/hal/libump/arch_011_udd/ump_frontend.c b/exynos4/hal/libump/arch_011_udd/ump_frontend.c
deleted file mode 100644
index 8c93332..0000000
--- a/exynos4/hal/libump/arch_011_udd/ump_frontend.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_frontend.c
- *
- * This file implements the user space API of the UMP API.
- * It relies heavily on a arch backend to do the communication with the UMP device driver.
- */
-
-#include <ump/ump.h>
-#include "ump_internal.h"
-#include "ump_arch.h"
-#include <ump/ump_debug.h>
-#include <ump/ump_osu.h>
-
-UMP_API_EXPORT ump_result ump_open(void)
-{
- return ump_arch_open();
-}
-
-UMP_API_EXPORT void ump_close(void)
-{
- ump_arch_close();
-}
-
-UMP_API_EXPORT ump_secure_id ump_secure_id_get(ump_handle memh)
-{
- ump_mem * mem = (ump_mem*)memh;
-
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != mem->secure_id, ("Secure ID is inavlid"));
- UMP_DEBUG_ASSERT(0 < mem->ref_count, ("Reference count too low"));
- UMP_DEBUG_ASSERT(0 < mem->size, ("Memory size of passed handle too low"));
-
- return mem->secure_id;
-}
-
-UMP_API_EXPORT ump_handle ump_handle_create_from_secure_id(ump_secure_id secure_id)
-{
- unsigned long size;
-
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != secure_id, ("Secure ID is invalid"));
-
- size = ump_arch_size_get(secure_id);
- if (0 != size)
- {
- unsigned long cookie;
- /*
- * The UMP memory which the secure_id referes to could now be deleted and re-created
- * since we don't have any references to it yet. The mapping below will however fail if
- * we have supplied incorrect size, so we are safe.
- */
- void * mapping = ump_arch_map(secure_id, size, UMP_CACHE_DISABLE, &cookie);
- if (NULL != mapping)
- {
- ump_mem * mem = _ump_osu_calloc(1, sizeof(*mem));
- if (NULL != mem)
- {
- mem->secure_id = secure_id;
- mem->mapped_mem = mapping;
- mem->size = size;
- mem->cookie = cookie;
- mem->is_cached = 1; /* Is set to actually check in the ump_cpu_msync_now() function */
-
- _ump_osu_lock_auto_init(&mem->ref_lock, 0, 0, 0);
- UMP_DEBUG_ASSERT(NULL != mem->ref_lock, ("Failed to initialize lock\n"));
- mem->ref_count = 1;
-
- /* This is called only to set the cache settings in this handle */
- ump_cpu_msync_now((ump_handle)mem, UMP_MSYNC_READOUT_CACHE_ENABLED, NULL, 0);
-
- UMP_DEBUG_PRINT(4, ("UMP handle created for ID %u of size %lu, mapped into address 0x%08lx", mem->secure_id, mem->size, (unsigned long)mem->mapped_mem));
-
- return (ump_handle)mem;
- }
-
- ump_arch_unmap(mapping, size, cookie);
- }
- }
-
- UMP_DEBUG_PRINT(2, ("UMP handle creation failed for ID %u", secure_id));
-
- return UMP_INVALID_MEMORY_HANDLE;
-}
-
-UMP_API_EXPORT unsigned long ump_size_get(ump_handle memh)
-{
- ump_mem * mem = (ump_mem*)memh;
-
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != mem->secure_id, ("Secure ID is inavlid"));
- UMP_DEBUG_ASSERT(0 < mem->ref_count, ("Reference count too low"));
- UMP_DEBUG_ASSERT(0 < mem->size, ("Memory size of passed handle too low"));
-
- return mem->size;
-}
-
-UMP_API_EXPORT void ump_read(void *dst, ump_handle srch, unsigned long offset, unsigned long length)
-{
- ump_mem * src = (ump_mem*)srch;
-
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != srch, ("Handle is invalid"));
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != src->secure_id, ("Secure ID is inavlid"));
- UMP_DEBUG_ASSERT(0 < src->ref_count, ("Reference count too low"));
- UMP_DEBUG_ASSERT(0 < src->size, ("Memory size of passed handle too low"));
- UMP_DEBUG_ASSERT(NULL != src->mapped_mem, ("UMP Memory is not mapped"));
- UMP_DEBUG_ASSERT((src->size) >= (offset + length), ("Requested read beyond end of UMP memory"));
-
- _ump_osu_memcpy(dst,(char*)(src->mapped_mem) + offset, length);
-}
-
-UMP_API_EXPORT void ump_write(ump_handle dsth, unsigned long offset, const void *src, unsigned long length)
-{
- ump_mem * dst = (ump_mem*)dsth;
-
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != dsth, ("Handle is invalid"));
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != dst->secure_id, ("Secure ID is inavlid"));
- UMP_DEBUG_ASSERT(0 < dst->ref_count, ("Reference count too low"));
- UMP_DEBUG_ASSERT(0 < dst->size, ("Memory size of passed handle too low"));
- UMP_DEBUG_ASSERT(NULL != dst->mapped_mem, ("UMP Memory is not mapped"));
- UMP_DEBUG_ASSERT((dst->size) >= (offset + length), ("Requested write beyond end of UMP memory"));
-
- _ump_osu_memcpy((char*)(dst->mapped_mem) + offset, src, length);
-}
-
-
-
-UMP_API_EXPORT void* ump_mapped_pointer_get(ump_handle memh)
-{
- ump_mem * mem = (ump_mem*)memh;
-
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != mem->secure_id, ("Secure ID is inavlid"));
- UMP_DEBUG_ASSERT(0 < mem->ref_count, ("Reference count too low"));
- UMP_DEBUG_ASSERT(0 < mem->size, ("Memory size of passed handle too low"));
- UMP_DEBUG_ASSERT(NULL != mem->mapped_mem, ("Error in mapping pointer (not mapped)"));
-
- return mem->mapped_mem;
-}
-
-
-
-UMP_API_EXPORT void ump_mapped_pointer_release(ump_handle memh)
-{
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != ((ump_mem*)memh)->secure_id, ("Secure ID is inavlid"));
- UMP_DEBUG_ASSERT(0 < ((ump_mem*)memh)->ref_count, ("Reference count too low"));
- UMP_DEBUG_ASSERT(0 < ((ump_mem*)memh)->size, ("Memory size of passed handle too low"));
- UMP_DEBUG_ASSERT(NULL != ((ump_mem*)memh)->mapped_mem, ("Error in mapping pointer (not mapped)"));
-
- /* noop, cos we map in the pointer when handle is created, and unmap it when handle is destroyed */
-}
-
-
-
-UMP_API_EXPORT void ump_reference_add(ump_handle memh)
-{
- ump_mem * mem = (ump_mem*)memh;
-
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != mem->secure_id, ("Secure ID is inavlid"));
- UMP_DEBUG_ASSERT(0 < mem->ref_count, ("Reference count too low"));
- UMP_DEBUG_ASSERT(0 < mem->size, ("Memory size of passed handle too low"));
-
- _ump_osu_lock_wait(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
- mem->ref_count += 1;
- _ump_osu_lock_signal(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
-}
-
-
-
-UMP_API_EXPORT void ump_reference_release(ump_handle memh)
-{
- ump_mem * mem = (ump_mem*)memh;
-
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
- UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != ((ump_mem*)mem)->secure_id, ("Secure ID is inavlid"));
- UMP_DEBUG_ASSERT(0 < (((ump_mem*)mem)->ref_count), ("Reference count too low"));
- UMP_DEBUG_ASSERT(0 < ((ump_mem*)mem)->size, ("Memory size of passed handle too low"));
- UMP_DEBUG_ASSERT(NULL != ((ump_mem*)mem)->mapped_mem, ("Error in mapping pointer (not mapped)"));
-
- _ump_osu_lock_wait(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
- mem->ref_count -= 1;
- if (0 == mem->ref_count)
- {
- /* Remove memory mapping, which holds our only reference towards the UMP kernel space driver */
- ump_arch_unmap(mem->mapped_mem, mem->size, mem->cookie);
-
- _ump_osu_lock_signal(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
-
- /* Free the lock protecting the reference count */
- _ump_osu_lock_term(mem->ref_lock);
-
- /* Free the memory for this handle */
- _ump_osu_free(mem);
- } else {
- _ump_osu_lock_signal(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
- }
-}
diff --git a/exynos4/hal/libump/arch_011_udd/ump_internal.h b/exynos4/hal/libump/arch_011_udd/ump_internal.h
deleted file mode 100644
index bc1f2a9..0000000
--- a/exynos4/hal/libump/arch_011_udd/ump_internal.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_internal.c
- *
- * Internal definitions and debugging macros for the UMP implementation.
- */
-
-#ifndef _UNIFIED_MEMORY_PROVIDER_INTERNAL_H_
-#define _UNIFIED_MEMORY_PROVIDER_INTERNAL_H_
-
-#include <ump/ump.h>
-#include <ump/ump_osu.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum ump_cache_enabled
-{
- UMP_CACHE_DISABLE = 0,
- UMP_CACHE_ENABLE = 1
-} ump_cache_enabled;
-
-/**
- * The actual (hidden) definition of ump_handles.
- */
-typedef struct ump_mem
-{
- ump_secure_id secure_id; /**< UMP device driver cookie */
- void * mapped_mem; /**< Mapped memory; all read and write use this */
- unsigned long size; /**< Size of allocated memory */
- _ump_osu_lock_t* ref_lock; /**< Lock protection ref_count */
- int ref_count; /**< The reference count of the ump_handle in userspace. It is used for finding out
- when to free the memory used by this userspace handle. It is NOT the same as the
- real ump_mem reference count in the devicedriver which do reference counting
- for the memory that this handle reveals. */
- unsigned long cookie; /**< cookie for use in arch_unmap calls */
- ump_cache_enabled is_cached;
-} ump_mem;
-
-#ifdef __cplusplus
-}
-#endif
-
-
-
-#endif /* _UNIFIED_MEMORY_PROVIDER_INTERNAL_H_ */
diff --git a/exynos4/hal/libump/arch_011_udd/ump_ref_drv.c b/exynos4/hal/libump/arch_011_udd/ump_ref_drv.c
deleted file mode 100644
index cf3b9eb..0000000
--- a/exynos4/hal/libump/arch_011_udd/ump_ref_drv.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_ref_drv.c
- *
- * Implementation of the user space API extensions provided by the reference implementation.
- */
-
-#include <ump/ump_ref_drv.h>
-#include <ump/ump.h>
-#include "ump_internal.h"
-#include "ump_arch.h"
-#include <ump/ump_debug.h>
-#include <ump/ump_osu.h>
-
-/* Allocate a buffer which can be used directly by hardware, 4kb aligned */
-static ump_handle ump_ref_drv_allocate_internal(unsigned long size, ump_alloc_constraints constraints, ump_cache_enabled cache);
-
-
-
-/* Allocate a buffer which can be used directly by hardware, 4kb aligned */
-ump_handle ump_ref_drv_allocate(unsigned long size, ump_alloc_constraints constraints)
-{
- ump_cache_enabled cache= UMP_CACHE_DISABLE;
- if ( 0!=(constraints&UMP_REF_DRV_CONSTRAINT_USE_CACHE) )
- {
- cache = UMP_CACHE_ENABLE;
- }
- return ump_ref_drv_allocate_internal(size, constraints, cache);
-}
-
-UMP_API_EXPORT int ump_cpu_msync_now(ump_handle memh, ump_cpu_msync_op op, void* address, int size)
-{
- ump_mem * mem = (ump_mem*)memh;
- UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
-
- /* If the op is readout, we do the readout from DD.
- Else we skip flushing if the userspace handle says that it is uncached */
- if ((UMP_MSYNC_READOUT_CACHE_ENABLED!=op) && (0 == mem->is_cached) ) return 0;
-
- UMP_DEBUG_ASSERT(0 < (((ump_mem*)mem)->ref_count), ("Reference count too low"));
- UMP_DEBUG_ASSERT((size>=0) && (size <= ((ump_mem*)mem)->size), ("Memory size of passed handle too low"));
- UMP_DEBUG_ASSERT(NULL != ((ump_mem*)mem)->mapped_mem, ("Error in mapping pointer (not mapped)"));
-
- if (size > mem->size) size = mem->size;
-
- mem->is_cached = ump_arch_msync(mem->secure_id, mem->mapped_mem, mem->cookie, address, size, op);
- return mem->is_cached ;
-}
-
-/* Allocate a buffer which can be used directly by hardware, 4kb aligned */
-static ump_handle ump_ref_drv_allocate_internal(unsigned long size, ump_alloc_constraints constraints, ump_cache_enabled cache)
-{
- ump_secure_id secure_id;
- unsigned long allocated_size = size;
-
- UMP_DEBUG_PRINT(4, ("Allocating UMP memory of size %lu", size));
-
- secure_id = ump_arch_allocate(&allocated_size, constraints);
- if (secure_id != UMP_INVALID_SECURE_ID)
- {
- unsigned long cookie;
- void * mapping;
-
- mapping = ump_arch_map(secure_id, allocated_size, cache, &cookie);
- if (NULL != mapping)
- {
- /*
- * PS: By now we have actually increased the ref count in the device driver by 2,
- * one for the allocation iteself, and one for the mapping.
- */
- ump_mem * mem;
- mem = _ump_osu_calloc(1, sizeof(*mem));
- if (NULL != mem)
- {
- mem->secure_id = secure_id;
- mem->mapped_mem = mapping;
- mem->size = allocated_size;
- mem->cookie = cookie;
- mem->is_cached = 1; /* Default to ON, is disabled later if not */
-
- _ump_osu_lock_auto_init(&mem->ref_lock, 0, 0, 0);
- UMP_DEBUG_ASSERT(NULL != mem->ref_lock, ("Failed to initialize lock\n"));
- mem->ref_count = 1;
-
- /*
- * ump_arch_allocate() gave us a kernel space reference, and the same did ump_arch_map()
- * We release the one from ump_arch_allocate(), and rely solely on the one from the ump_arch_map()
- * That is, ump_arch_unmap() should now do the final release towards the UMP kernel space driver.
- */
- ump_arch_reference_release(secure_id);
-
- /* This is called only to set the cache settings in this handle */
- ump_cpu_msync_now((ump_handle)mem, UMP_MSYNC_READOUT_CACHE_ENABLED, NULL, 0);
-
- UMP_DEBUG_PRINT(4, ("UMP handle created for ID %u of size %lu, mapped into address 0x%08lx", mem->secure_id, mem->size, (unsigned long)mem->mapped_mem));
-
- return (ump_handle)mem;
- }
-
- ump_arch_unmap(mapping, allocated_size, cookie); /* Unmap the memory */
- ump_arch_reference_release(secure_id); /* Release reference added when we allocated the UMP memory */
- }
-
- ump_arch_reference_release(secure_id); /* Release reference added when we allocated the UMP memory */
- }
-
- UMP_DEBUG_PRINT(4, ("Allocation of UMP memory failed"));
- return UMP_INVALID_MEMORY_HANDLE;
-}
diff --git a/exynos4/hal/libump/include/ump/ump_debug.h b/exynos4/hal/libump/include/ump/ump_debug.h
deleted file mode 100644
index 5ede8a3..0000000
--- a/exynos4/hal/libump/include/ump/ump_debug.h
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_debug.h
- *
- * The file include several useful macros for debugging and printing.
- * - UMP_PRINTF(...) Do not use this function: Will be included in Release builds.
- * - UMP_DEBUG_TRACE() Prints current location in code.
- * - UMP_DEBUG_PRINT(nr, (X) ) Prints the second argument if nr<=UMP_DEBUG_LEVEL.
- * - UMP_DEBUG_TPRINT(nr, X ) Prints the source trace and second argument if nr<=UMP_DEBUG_LEVEL.
- * - UMP_DEBUG_ERROR( (X) ) Prints an errortext, a source trace, and the given error message.
- * - UMP_DEBUG_ASSERT(exp,(X)) If the asserted expr is false, the program will exit.
- * - UMP_DEBUG_ASSERT_RANGE(x, min, max) Triggers if variable x is not between or equal to max and min.
- * - UMP_DEBUG_ASSERT_LEQ(x, max) Triggers if variable x is not less than equal to max.
- * - UMP_DEBUG_ASSERT_POINTER(pointer) Triggers if the pointer is a zero pointer.
- * - UMP_DEBUG_CODE( X ) The code inside the macro is only copiled in Debug builds.
- *
- * The (X) means that you must add an extra parantese around the argumentlist.
- *
- * The printf function: UMP_PRINTF(...) is routed to _ump_sys_printf
- *
- * Suggested range for the DEBUG-LEVEL is [1:6] where
- * [1:2] Is messages with highest priority, indicate possible errors.
- * [3:4] Is messages with medium priority, output important variables.
- * [5:6] Is messages with low priority, used during extensive debugging.
- *
- */
-#ifndef _UMP_DEBUG_H_
-#define _UMP_DEBUG_H_
-
-#include <stdio.h>
-#include <stdlib.h>
-
-/* START: Configuration */
-#ifndef UMP_PRINTF
- #define UMP_PRINTF printf
-#endif /* UMP_PRINTF */
-
-#ifndef UMP_PRINT_FLUSH
- #define UMP_PRINT_FLUSH do {} while (0)
-#endif /* UMP_PRINT_FLUSH */
-
-#ifndef UMP_DEBUG_LEVEL
- #define UMP_DEBUG_LEVEL 1
-#endif /* UMP_DEBUG_LEVEL */
-
-#ifndef UMP_DEBUG_ERROR_START_MSG
- #define UMP_DEBUG_ERROR_START_MSG do {\
- UMP_PRINTF("*********************************************************************\n");\
- UMP_PRINT_FLUSH; } while (0)
-#endif /* UMP_DEBUG_ERROR_START_MSG */
-
-#ifndef UMP_DEBUG_ERROR_STOP_MSG
- #define UMP_DEBUG_ERROR_STOP_MSG do { UMP_PRINTF("\n"); UMP_PRINT_FLUSH; } while (0)
-#endif /* UMP_DEBUG_ERROR_STOP_MSG */
-
-#ifndef UMP_ASSERT_QUIT_CMD
- #define UMP_ASSERT_QUIT_CMD abort()
-#endif /* UMP_ASSERT_QUIT_CMD */
-/* STOP: Configuration */
-
-/**
- * The macro UMP_FUNCTION evaluates to the name of the function enclosing
- * this macro's usage, or "<unknown>" if not supported.
- */
-#if (defined(__SYMBIAN32__) && defined(__ARMCC__)) || defined(_MSC_VER)
-# define UMP_FUNCTION __FUNCTION__
-#elif __STDC__ && __STDC_VERSION__ >= 199901L
-# define UMP_FUNCTION __FUNCTION__
-#elif defined(__GNUC__) && __GNUC__ >= 2
-# define UMP_FUNCTION __FUNCTION__
-#elif defined(__func__)
-# define UMP_FUNCTION __func__
-#else
-# define UMP_FUNCTION "<unknown>"
-#endif
-
-/**
- * Explicitly ignore a parameter passed into a function, to suppress compiler warnings.
- * Should only be used with parameter names.
- */
-#define UMP_IGNORE(x) (void)x
-
-/**
- * @def UMP_DEBUG_TRACE()
- * @brief Prints current location in code.
- * Can be turned off by defining UMP_DEBUG_SKIP_TRACE
- */
-
-#ifndef UMP_DEBUG_SKIP_TRACE
- #ifndef UMP_DEBUG_SKIP_PRINT_FUNCTION_NAME
- #define UMP_DEBUG_TRACE() do { UMP_PRINTF( "In file: "__FILE__ \
- " function: %s() line:%4d\n" , UMP_FUNCTION, __LINE__); UMP_PRINT_FLUSH; } while (0)
- #else
- #define UMP_DEBUG_TRACE() do { UMP_PRINTF( "In file: "__FILE__ " line:%4d\n" , __LINE__); UMP_PRINT_FLUSH; } while (0)
- #endif /* UMP_DEBUG_SKIP_PRINT_FUNCTION_NAME */
-#else
- #define UMP_DEBUG_TRACE()
-#endif /* UMP_DEBUG_SKIP_TRACE */
-
-/**
- * @def UMP_DEBUG_PRINT(nr, (X) )
- * @brief Prints the second argument if nr<=UMP_DEBUG_LEVEL.
- * Can be turned off by defining UMP_DEBUG_SKIP_PRINT
- * @param nr If nr <= UMP_DEBUG_LEVEL, we print the text.
- * @param X A parantese with the contents to be sent to UMP_PRINTF
- */
-#ifndef UMP_DEBUG_SKIP_PRINT
- #define UMP_DEBUG_PRINT(nr, X ) do { if ( nr<=UMP_DEBUG_LEVEL ) { UMP_PRINTF X ; UMP_PRINT_FLUSH; } } while (0)
-#else
- #define UMP_DEBUG_PRINT(nr, X )
-#endif /* UMP_DEBUG_SKIP_PRINT */
-
-/**
- * @def UMP_DEBUG_TPRINT(nr, (X) )
- * @brief Prints the second argument if nr<=UMP_DEBUG_LEVEL.
- * Can be turned off by defining UMP_DEBUG_SKIP_TPRINT.
- * Can be shortened by defining UMP_DEBUG_TPRINT_SKIP_FUNCTION.
- * @param nr If nr <= UMP_DEBUG_LEVEL, we print the text.
- * @param X A parantese with the contents to be sent to UMP_PRINTF
- */
-
-/* helper to handle if the function name should be included or not */
-#ifndef UMP_DEBUG_TPRINT_SKIP_FUNCTION
- #define UMP_DEBUG_TPRINT_INTERN do {UMP_PRINTF( ""__FILE__" %s()%4d " , UMP_FUNCTION, __LINE__); UMP_PRINT_FLUSH; } while (0)
-#else
- #define UMP_DEBUG_TPRINT_INTERN do {UMP_PRINTF( ""__FILE__ "%4d " , __LINE__); UMP_PRINT_FLUSH; } while (0)
-#endif /* UMP_DEBUG_TPRINT_SKIP_FUNCTION */
-
-#ifndef UMP_DEBUG_SKIP_TPRINT
- #define UMP_DEBUG_TPRINT(nr, X ) \
- do{\
- if ( nr<=UMP_DEBUG_LEVEL )\
- {\
- UMP_DEBUG_TPRINT_INTERN;\
- UMP_PRINTF X ;\
- UMP_PRINT_FLUSH;\
- }\
- } while (0)
-#else
- #define UMP_DEBUG_TPRINT(nr, X )
-#endif /* UMP_DEBUG_SKIP_TPRINT */
-
-/**
- * @def UMP_DEBUG_ERROR( (X) )
- * @brief Prints an errortext, a source Trace, and the given error message.
- * Prints filename, function, linenr, and the given error message.
- * The error message must be inside a second parantese.
- * The error message is written on a separate line, and a NL char is added.
- * Can be turned of by defining UMP_DEBUG_SKIP_ERROR;
- * You do not need to type the words ERROR in the message, since it will
- * be added anyway.
- *
- * @note You should not end the text with a newline, since it is added by the macro.
- * @note You should not write "ERROR" in the text, since it is added by the macro.
- * @param X A parantese with the contents to be sent to UMP_PRINTF
- */
-
-#ifndef UMP_DEBUG_SKIP_ERROR
- #define UMP_DEBUG_ERROR( X ) \
- do{ \
- UMP_DEBUG_ERROR_START_MSG;\
- UMP_PRINTF("ERROR: ");\
- UMP_PRINT_FLUSH;\
- UMP_DEBUG_TRACE(); \
- UMP_PRINTF X ; \
- UMP_PRINT_FLUSH;\
- UMP_DEBUG_ERROR_STOP_MSG;\
- } while (0)
-#else
- #define UMP_DEBUG_ERROR( X ) do{ ; } while ( 0 )
-#endif /* UMP_DEBUG_SKIP_ERROR */
-
-/**
- * @def UMP_DEBUG_ASSERT(expr, (X) )
- * @brief If the asserted expr is false, the program will exit.
- * Prints filename, function, linenr, and the given error message.
- * The error message must be inside a second parantese.
- * The error message is written on a separate line, and a NL char is added.
- * Can be turned of by defining UMP_DEBUG_SKIP_ERROR;
- * You do not need to type the words ASSERT in the message, since it will
- * be added anyway.
- *
- * @param X A parantese with the contents to be sent to UMP_PRINTF
- * Prints filename, function, linenr, and the error message
- * on a separte line. A newline char is added at the end.
- * Can be turned of by defining UMP_DEBUG_SKIP_ASSERT
- * @param expr Will exit program if \a expr is false;
- * @param (X) Text that will be written if the assertion toggles.
- */
-
-#ifndef UMP_DEBUG_SKIP_ASSERT
- #define UMP_DEBUG_ASSERT(expr, X ) \
- do{\
- if ( !(expr) ) \
- { \
- UMP_DEBUG_ERROR_START_MSG;\
- UMP_PRINTF("ASSERT EXIT: ");\
- UMP_PRINT_FLUSH;\
- UMP_DEBUG_TRACE(); \
- UMP_PRINTF X ; \
- UMP_PRINT_FLUSH;\
- UMP_DEBUG_ERROR_STOP_MSG;\
- UMP_ASSERT_QUIT_CMD;\
- }\
- } while (0)
-#else
- #define UMP_DEBUG_ASSERT(expr, X)
-#endif /* UMP_DEBUG_SKIP_ASSERT */
-
-
-/**
- * @def UMP_DEBUG_ASSERT_POINTER(pointer)
- * @brief If the asserted pointer is NULL, the program terminates and TRACE info is printed
- * The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
- */
-#define UMP_DEBUG_ASSERT_POINTER(pointer) UMP_DEBUG_ASSERT(pointer, ("Null pointer " #pointer) )
-
-/**
- * @def UMP_DEBUG_ASSERT_HANDLE(handle)
- * @brief If the asserted handle is not a valid handle, the program terminates and TRACE info is printed
- * The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
- */
-#define UMP_DEBUG_ASSERT_HANDLE(handle) UMP_DEBUG_ASSERT(UMP_NO_HANDLE != (handle), ("Invalid handle" #handle) )
-
-/**
- * @def UMP_DEBUG_ASSERT_ALIGNMENT(ptr, align)
- * @brief If the asserted pointer is not aligned to align, the program terminates with trace info printed.
- * The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
- */
-#ifndef UMP_DEBUG_SKIP_ASSERT
- #define UMP_DEBUG_ASSERT_ALIGNMENT(ptr, align) do { \
- UMP_DEBUG_ASSERT(0 == (align & (align - 1)), ("align %d is not a power-of-two", align)); \
- UMP_DEBUG_ASSERT(0 == (((u32)(ptr)) & (align - 1)), ("ptr %p not aligned to %d bytes", (void*)ptr, align)); \
- } while (0)
-#else
- #define UMP_DEBUG_ASSERT_ALIGNMENT(ptr, align)
-#endif /* UMP_DEBUG_SKIP_ASSERT */
-
-/**
- * @def UMP_DEBUG_ASSERT_RANGE(x,min,max)
- * @brief If variable x is not between or equal to max and min, the assertion triggers.
- * The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
- */
-#define UMP_DEBUG_ASSERT_RANGE(x, min, max) \
- UMP_DEBUG_ASSERT( (x) >= (min) && (x) <= (max), \
- (#x " out of range (%2.2f)", (double)x ) \
- )
-
-/**
- * @def UMP_DEBUG_ASSERT_LEQ(x,max)
- * @brief If variable x is less than or equal to max, the assertion triggers.
- * The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
- */
-#define UMP_DEBUG_ASSERT_LEQ(x, max) \
- UMP_DEBUG_ASSERT( (x) <= (max), \
- (#x " out of range (%2.2f)", (double)x ) \
- )
-
-/**
- * @def UMP_DEBUG_CODE( X )
- * @brief Run the code X on debug builds.
- * The code will not be used if UMP_DEBUG_SKIP_CODE is defined .
- *
- */
-#ifdef UMP_DEBUG_SKIP_CODE
- #define UMP_DEBUG_CODE( X )
-#else
- #define UMP_DEBUG_CODE( X ) X
-#endif /* UMP_DEBUG_SKIP_CODE */
-
-#endif /* _UMP_DEBUG_H_ */
-
diff --git a/exynos4/hal/libump/include/ump/ump_osu.h b/exynos4/hal/libump/include/ump/ump_osu.h
deleted file mode 100644
index 5c9a650..0000000
--- a/exynos4/hal/libump/include/ump/ump_osu.h
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_osu.h
- * Defines the OS abstraction layer for the base driver
- */
-
-#ifndef __UMP_OSU_H__
-#define __UMP_OSU_H__
-
-#include <stdarg.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-typedef unsigned int u32;
-#ifdef _MSC_VER
- typedef unsigned __int64 u64;
- typedef signed __int64 s64;
-#else
- typedef unsigned long long u64;
- typedef signed long long s64;
-#endif
-
-#ifndef NULL
-#define NULL ((void*)0)
-#endif
-
-typedef unsigned long ump_bool;
-
-#ifndef UMP_TRUE
-#define UMP_TRUE ((ump_bool)1)
-#endif
-
-#ifndef UMP_FALSE
-#define UMP_FALSE ((ump_bool)0)
-#endif
-
-#define UMP_STATIC static
-
-/**
- * @addtogroup ump_user_space_api Unified Device Driver (UDD) APIs used by UMP
- *
- * @{
- */
-
-/**
- * @defgroup ump_osuapi UDD OS Abstraction for User-side (OSU) APIs for UMP
- *
- * @{
- */
-
-/* The following is necessary to prevent the _ump_osk_errcode_t doxygen from
- * becoming unreadable: */
-/** @cond OSU_COPY_OF__UMP_OSU_ERRCODE_T */
-
-/**
- * @brief OSU/OSK Error codes.
- *
- * Each OS may use its own set of error codes, and may require that the
- * User/Kernel interface take certain error code. This means that the common
- * error codes need to be sufficiently rich to pass the correct error code
- * through from the OSK/OSU to U/K layer, across all OSs.
- *
- * The result is that some error codes will appear redundant on some OSs.
- * Under all OSs, the OSK/OSU layer must translate native OS error codes to
- * _ump_osk/u_errcode_t codes. Similarly, the U/K layer must translate from
- * _ump_osk/u_errcode_t codes to native OS error codes.
- *
- */
-typedef enum
-{
- _UMP_OSK_ERR_OK = 0, /**< Success. */
- _UMP_OSK_ERR_FAULT = -1, /**< General non-success */
- _UMP_OSK_ERR_INVALID_FUNC = -2, /**< Invalid function requested through User/Kernel interface (e.g. bad IOCTL number) */
- _UMP_OSK_ERR_INVALID_ARGS = -3, /**< Invalid arguments passed through User/Kernel interface */
- _UMP_OSK_ERR_NOMEM = -4, /**< Insufficient memory */
- _UMP_OSK_ERR_TIMEOUT = -5, /**< Timeout occured */
- _UMP_OSK_ERR_RESTARTSYSCALL = -6, /**< Special: On certain OSs, must report when an interruptable mutex is interrupted. Ignore otherwise. */
- _UMP_OSK_ERR_ITEM_NOT_FOUND = -7, /**< Table Lookup failed */
- _UMP_OSK_ERR_BUSY = -8, /**< Device/operation is busy. Try again later */
- _UMP_OSK_ERR_UNSUPPORTED = -9, /**< Optional part of the interface used, and is unsupported */
-} _ump_osk_errcode_t;
-
-/** @endcond */ /* end cond OSU_COPY_OF__UMP_OSU_ERRCODE_T */
-
-/**
- * @brief OSU Error codes.
- *
- * OSU error codes - enum values intentionally same as OSK
- */
-typedef enum
-{
- _UMP_OSU_ERR_OK = 0, /**< Success. */
- _UMP_OSU_ERR_FAULT = -1, /**< General non-success */
- _UMP_OSU_ERR_TIMEOUT = -2, /**< Timeout occured */
-} _ump_osu_errcode_t;
-
-/** @brief Translate OSU error code to base driver error code.
- *
- * The _UMP_OSU_TRANSLATE_ERROR macro translates an OSU error code to the
- * error codes in use by the base driver.
- */
-#define _UMP_OSU_TRANSLATE_ERROR(_ump_osu_errcode) ( ( _UMP_OSU_ERR_OK == (_ump_osu_errcode) ) ? UMP_ERR_NO_ERROR : UMP_ERR_FUNCTION_FAILED)
-
-/** @defgroup _ump_osu_lock OSU Mutual Exclusion Locks
- * @{ */
-
-/** @brief OSU Mutual Exclusion Lock flags type.
- *
- * This is made to look like and function identically to the OSK locks (refer
- * to \ref _ump_osk_lock). However, please note the following \b important
- * differences:
- * - the OSU default lock is a Sleeping, non-interruptible mutex.
- * - the OSU adds the ANYUNLOCK type of lock which allows a thread which doesn't
- * own the lock to release the lock.
- * - the order parameter when creating a lock is currently unused
- *
- * @note Pay careful attention to the difference in default locks for OSU and
- * OSK locks; OSU locks are always non-interruptible, but OSK locks are by
- * default, interruptible. This has implications for systems that do not
- * distinguish between user and kernel mode.
- */
-typedef enum
-{
- _UMP_OSU_LOCKFLAG_DEFAULT = 0, /**< Default lock type. */
- /** @enum _ump_osu_lock_flags_t
- *
- * Flags from 0x8000--0x1 are RESERVED for Kernel-mode
- */
- _UMP_OSU_LOCKFLAG_ANYUNLOCK = 0x10000, /**< Mutex that guarantees that any thread can unlock it when locked. Otherwise, this will not be possible. */
- /** @enum _ump_osu_lock_flags_t
- *
- * Flags from 0x80000000 are RESERVED for User-mode
- */
- _UMP_OSU_LOCKFLAG_STATIC = 0x80000000, /* Flag in OSU reserved range to identify lock as a statically initialized lock */
-
- } _ump_osu_lock_flags_t;
-
-typedef enum
-{
- _UMP_OSU_LOCKMODE_UNDEF = -1, /**< Undefined lock mode. For internal use only */
- _UMP_OSU_LOCKMODE_RW = 0x0, /**< Default. Lock is used to protect data that is read from and written to */
- /** @enum _ump_osu_lock_mode_t
- *
- * Lock modes 0x1--0x3F are RESERVED for Kernel-mode */
-} _ump_osu_lock_mode_t;
-
-/** @brief Private type for Mutual Exclusion lock objects. */
-typedef struct _ump_osu_lock_t_struct _ump_osu_lock_t;
-
-/** @brief The number of static locks supported in _ump_osu_lock_static(). */
-#define UMP_OSU_STATIC_LOCK_COUNT (sizeof(_ump_osu_static_locks) / sizeof(_ump_osu_lock_t))
-
-/** @} */ /* end group _ump_osu_lock */
-
-/** @defgroup _ump_osu_memory OSU Memory Allocation
- * @{ */
-
-/** @brief Allocate zero-initialized memory.
- *
- * Returns a buffer capable of containing at least \a n elements of \a size
- * bytes each. The buffer is initialized to zero.
- *
- * The buffer is suitably aligned for storage and subsequent access of every
- * type that the compiler supports. Therefore, the pointer to the start of the
- * buffer may be cast into any pointer type, and be subsequently accessed from
- * such a pointer, without loss of information.
- *
- * When the buffer is no longer in use, it must be freed with _ump_osu_free().
- * Failure to do so will cause a memory leak.
- *
- * @note Most toolchains supply memory allocation functions that meet the
- * compiler's alignment requirements.
- *
- * @param n Number of elements to allocate
- * @param size Size of each element
- * @return On success, the zero-initialized buffer allocated. NULL on failure
- */
-void *_ump_osu_calloc( u32 n, u32 size );
-
-/** @brief Allocate memory.
- *
- * Returns a buffer capable of containing at least \a size bytes. The
- * contents of the buffer are undefined.
- *
- * The buffer is suitably aligned for storage and subsequent access of every
- * type that the compiler supports. Therefore, the pointer to the start of the
- * buffer may be cast into any pointer type, and be subsequently accessed from
- * such a pointer, without loss of information.
- *
- * When the buffer is no longer in use, it must be freed with _ump_osu_free().
- * Failure to do so will cause a memory leak.
- *
- * @note Most toolchains supply memory allocation functions that meet the
- * compiler's alignment requirements.
- *
- * Remember to free memory using _ump_osu_free().
- * @param size Number of bytes to allocate
- * @return On success, the buffer allocated. NULL on failure.
- */
-void *_ump_osu_malloc( u32 size );
-
-/** @brief Free memory.
- *
- * Reclaims the buffer pointed to by the parameter \a ptr for the system.
- * All memory returned from _ump_osu_malloc(), _ump_osu_calloc() and
- * _ump_osu_realloc() must be freed before the application exits. Otherwise,
- * a memory leak will occur.
- *
- * Memory must be freed once. It is an error to free the same non-NULL pointer
- * more than once.
- *
- * It is legal to free the NULL pointer.
- *
- * @param ptr Pointer to buffer to free
- */
-void _ump_osu_free( void *ptr );
-
-/** @brief Copies memory.
- *
- * Copies the \a len bytes from the buffer pointed by the parameter \a src
- * directly to the buffer pointed by \a dst.
- *
- * It is an error for \a src to overlap \a dst anywhere in \a len bytes.
- *
- * @param dst Pointer to the destination array where the content is to be
- * copied.
- * @param src Pointer to the source of data to be copied.
- * @param len Number of bytes to copy.
- * @return \a dst is always passed through unmodified.
- */
-void *_ump_osu_memcpy( void *dst, const void *src, u32 len );
-
-/** @brief Fills memory.
- *
- * Sets the first \a size bytes of the block of memory pointed to by \a ptr to
- * the specified value
- * @param ptr Pointer to the block of memory to fill.
- * @param chr Value to be set, passed as u32. Only the 8 Least Significant Bits (LSB)
- * are used.
- * @param size Number of bytes to be set to the value.
- * @return \a ptr is always passed through unmodified
- */
-void *_ump_osu_memset( void *ptr, u32 chr, u32 size );
-
-/** @} */ /* end group _ump_osu_memory */
-
-
-/** @addtogroup _ump_osu_lock
- * @{ */
-
-/** @brief Initialize a Mutual Exclusion Lock.
- *
- * Locks are created in the signalled (unlocked) state.
- *
- * The parameter \a initial must be zero.
- *
- * At present, the parameter \a order must be zero. It remains for future
- * expansion for mutex order checking.
- *
- * @param flags flags combined with bitwise OR ('|'), or zero. There are
- * restrictions on which flags can be combined, see \ref _ump_osu_lock_flags_t.
- * @param initial For future expansion into semaphores. SBZ.
- * @param order The locking order of the mutex. SBZ.
- * @return On success, a pointer to a \ref _ump_osu_lock_t object. NULL on failure.
- */
-_ump_osu_lock_t *_ump_osu_lock_init( _ump_osu_lock_flags_t flags, u32 initial, u32 order );
-
-/** @brief Obtain a statically initialized Mutual Exclusion Lock.
- *
- * Retrieves a reference to a statically initialized lock. Up to
- * _UMP_OSU_STATIC_LOCK_COUNT statically initialized locks are
- * available. Only _ump_osu_lock_wait(), _ump_osu_lock_trywait(),
- * _ump_osu_lock_signal() can be used with statically initialized locks.
- * _UMP_OSU_LOCKMODE_RW mode should be used when waiting and signalling
- * statically initialized locks.
- *
- * For the same \a nr a pointer to the same statically initialized lock is
- * returned. That is, given the following code:
- * @code
- * extern u32 n;
- *
- * _ump_osu_lock_t *locka = _ump_osu_lock_static(n);
- * _ump_osu_lock_t *lockb = _ump_osu_lock_static(n);
- * @endcode
- * Then (locka == lockb), for all 0 <= n < UMP_OSU_STATIC_LOCK_COUNT.
- *
- * @param nr index of a statically initialized lock [0..UMP_OSU_STATIC_LOCK_COUNT-1]
- * @return On success, a pointer to a _ump_osu_lock_t object. NULL on failure.
- */
-_ump_osu_lock_t *_ump_osu_lock_static( u32 nr );
-
-/** @brief Initialize a Mutual Exclusion Lock safely across multiple threads.
- *
- * The _ump_osu_lock_auto_init() function guarantees that the given lock will
- * be initialized once and precisely once, even in a situation involving
- * multiple threads.
- *
- * This is necessary because the first call to certain Public API functions must
- * initialize the API. However, there can be a race involved to call the first
- * library function in multi-threaded applications. To resolve this race, a
- * mutex can be used. This mutex must be initialized, but initialized only once
- * by any thread that might compete for its initialization. This function
- * guarantees the initialization to happen correctly, even when there is an
- * initialization race between multiple threads.
- *
- * Otherwise, the operation is identical to the _ump_osu_lock_init() function.
- * For more details, refer to _ump_osu_lock_init().
- *
- * @param pplock pointer to storage for a _ump_osu_lock_t pointer. This
- * _ump_osu_lock_t pointer may point to a _ump_osu_lock_t that has been
- * initialized already
- * @param flags flags combined with bitwise OR ('|'), or zero. There are
- * restrictions on which flags can be combined. Refer to
- * \ref _ump_osu_lock_flags_t for more information.
- * The absence of any flags (the value 0) results in a sleeping-mutex,
- * which is non-interruptible.
- * @param initial For future expansion into semaphores. SBZ.
- * @param order The locking order of the mutex. SBZ.
- * @return On success, _UMP_OSU_ERR_OK is returned and a pointer to an
- * initialized \ref _ump_osu_lock_t object is written into \a *pplock.
- * _UMP_OSU_ERR_FAULT is returned on failure.
- */
-_ump_osu_errcode_t _ump_osu_lock_auto_init( _ump_osu_lock_t **pplock, _ump_osu_lock_flags_t flags, u32 initial, u32 order );
-
-/** @brief Wait for a lock to be signalled (obtained).
- *
- * After a thread has successfully waited on the lock, the lock is obtained by
- * the thread, and is marked as unsignalled. The thread releases the lock by
- * signalling it.
- *
- * To prevent deadlock, locks must always be obtained in the same order.
- *
- * @param lock the lock to wait upon (obtain).
- * @param mode the mode in which the lock should be obtained. Currently this
- * must be _UMP_OSU_LOCKMODE_RW.
- * @return On success, _UMP_OSU_ERR_OK, _UMP_OSU_ERR_FAULT on error.
- */
-_ump_osu_errcode_t _ump_osu_lock_wait( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode);
-
-/** @brief Wait for a lock to be signalled (obtained) with timeout
- *
- * After a thread has successfully waited on the lock, the lock is obtained by
- * the thread, and is marked as unsignalled. The thread releases the lock by
- * signalling it.
- *
- * To prevent deadlock, locks must always be obtained in the same order.
- *
- * This version can return early if it cannot obtain the lock within the given timeout.
- *
- * @param lock the lock to wait upon (obtain).
- * @param mode the mode in which the lock should be obtained. Currently this
- * must be _UMP_OSU_LOCKMODE_RW.
- * @param timeout Relative time in microseconds for the timeout
- * @return _UMP_OSU_ERR_OK if the lock was obtained, _UMP_OSU_ERR_TIMEOUT if the timeout expired or _UMP_OSU_ERR_FAULT on error.
- */
-_ump_osu_errcode_t _ump_osu_lock_timed_wait( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode, u64 timeout);
-
-/** @brief Test for a lock to be signalled and obtains the lock when so.
- *
- * Obtains the lock only when it is in signalled state. The lock is then
- * marked as unsignalled. The lock is released again by signalling
- * it by _ump_osu_lock_signal().
- *
- * If the lock could not be obtained immediately (that is, another thread
- * currently holds the lock), then this function \b does \b not wait for the
- * lock to be in a signalled state. Instead, an error code is immediately
- * returned to indicate that the thread could not obtain the lock.
- *
- * To prevent deadlock, locks must always be obtained in the same order.
- *
- * @param lock the lock to wait upon (obtain).
- * @param mode the mode in which the lock should be obtained. Currently this
- * must be _UMP_OSU_LOCKMODE_RW.
- * @return When the lock was obtained, _UMP_OSU_ERR_OK. If the lock could not
- * be obtained, _UMP_OSU_ERR_FAULT.
- */
-_ump_osu_errcode_t _ump_osu_lock_trywait( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode);
-
-/** @brief Signal (release) a lock.
- *
- * Locks may only be signalled by the thread that originally waited upon the
- * lock, unless the lock was created using the _UMP_OSU_LOCKFLAG_ANYUNLOCK flag.
- *
- * @param lock the lock to signal (release).
- * @param mode the mode in which the lock should be obtained. This must match
- * the mode in which the lock was waited upon.
- */
-void _ump_osu_lock_signal( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode );
-
-/** @brief Terminate a lock.
- *
- * This terminates a lock and frees all associated resources.
- *
- * It is a programming error to terminate the lock when it is held (unsignalled)
- * by a thread.
- *
- * @param lock the lock to terminate.
- */
-void _ump_osu_lock_term( _ump_osu_lock_t *lock );
-/** @} */ /* end group _ump_osu_lock */
-
-/** @} */ /* end group osuapi */
-
-/** @} */ /* end group uddapi */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __UMP_OSU_H__ */
diff --git a/exynos4/hal/libump/include/ump/ump_platform.h b/exynos4/hal/libump/include/ump/ump_platform.h
deleted file mode 100644
index 68e01be..0000000
--- a/exynos4/hal/libump/include/ump/ump_platform.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_platform.h
- *
- * This file should define UMP_API_EXPORT,
- * which dictates how the UMP user space API should be exported/imported.
- * Modify this file, if needed, to match your platform setup.
- */
-
-#ifndef __UMP_PLATFORM_H__
-#define __UMP_PLATFORM_H__
-
-/** @addtogroup ump_user_space_api
- * @{ */
-
-/**
- * A define which controls how UMP user space API functions are imported and exported.
- * This define should be set by the implementor of the UMP API.
- */
-#if defined(_WIN32)
-
-#define UMP_API_EXPORT
-
-#elif defined(__SYMBIAN32__)
-
-#define UMP_API_EXPORT IMPORT_C
-
-#else
-
-#if defined(__GNUC__)
-#if __GNUC__ >= 4
-# define MALI_VISIBLE __attribute__ ((visibility ("default"))) /**< Function should be visible from outside the dll */
-#else
-# define MALI_VISIBLE
-#endif
-
-#elif defined(__ARMCC_VERSION)
-/* ARMCC specific */
-# define MALI_VISIBLE __declspec(dllexport)
-
-#else
-# define MALI_VISIBLE
-
-#endif
-
-#define UMP_API_EXPORT MALI_VISIBLE
-
-#endif
-
-/** @} */ /* end group ump_user_space_api */
-
-
-#endif /* __UMP_PLATFORM_H__ */
diff --git a/exynos4/hal/libump/include/ump/ump_uk_types.h b/exynos4/hal/libump/include/ump/ump_uk_types.h
deleted file mode 100644
index 1a4c1c8..0000000
--- a/exynos4/hal/libump/include/ump/ump_uk_types.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright (C) 2010 ARM Limited. All rights reserved.
- *
- * 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 ump_uk_types.h
- * Defines the types and constants used in the user-kernel interface
- */
-
-#ifndef __UMP_UK_TYPES_H__
-#define __UMP_UK_TYPES_H__
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/* Helpers for API version handling */
-#define MAKE_VERSION_ID(x) (((x) << 16UL) | (x))
-#define IS_VERSION_ID(x) (((x) & 0xFFFF) == (((x) >> 16UL) & 0xFFFF))
-#define GET_VERSION(x) (((x) >> 16UL) & 0xFFFF)
-#define IS_API_MATCH(x, y) (IS_VERSION_ID((x)) && IS_VERSION_ID((y)) && (GET_VERSION((x)) == GET_VERSION((y))))
-
-/**
- * API version define.
- * Indicates the version of the kernel API
- * The version is a 16bit integer incremented on each API change.
- * The 16bit integer is stored twice in a 32bit integer
- * So for version 1 the value would be 0x00010001
- */
-#define UMP_IOCTL_API_VERSION MAKE_VERSION_ID(2)
-
-typedef enum
-{
- _UMP_IOC_QUERY_API_VERSION = 1,
- _UMP_IOC_ALLOCATE,
- _UMP_IOC_RELEASE,
- _UMP_IOC_SIZE_GET,
- _UMP_IOC_MAP_MEM, /* not used in Linux */
- _UMP_IOC_UNMAP_MEM, /* not used in Linux */
- _UMP_IOC_MSYNC,
-}_ump_uk_functions;
-
-typedef enum
-{
- UMP_REF_DRV_UK_CONSTRAINT_NONE = 0,
- UMP_REF_DRV_UK_CONSTRAINT_PHYSICALLY_LINEAR = 1,
- UMP_REF_DRV_UK_CONSTRAINT_USE_CACHE = 4,
-} ump_uk_alloc_constraints;
-
-typedef enum
-{
- _UMP_UK_MSYNC_CLEAN = 0,
- _UMP_UK_MSYNC_CLEAN_AND_INVALIDATE = 1,
- _UMP_UK_MSYNC_READOUT_CACHE_ENABLED = 128,
-} ump_uk_msync_op;
-
-/**
- * Get API version ([in,out] u32 api_version, [out] u32 compatible)
- */
-typedef struct _ump_uk_api_version_s
-{
- void *ctx; /**< [in,out] user-kernel context (trashed on output) */
- u32 version; /**< Set to the user space version on entry, stores the device driver version on exit */
- u32 compatible; /**< Non-null if the device is compatible with the client */
-} _ump_uk_api_version_s;
-
-/**
- * ALLOCATE ([out] u32 secure_id, [in,out] u32 size, [in] contraints)
- */
-typedef struct _ump_uk_allocate_s
-{
- void *ctx; /**< [in,out] user-kernel context (trashed on output) */
- u32 secure_id; /**< Return value from DD to Userdriver */
- u32 size; /**< Input and output. Requested size; input. Returned size; output */
- ump_uk_alloc_constraints constraints; /**< Only input to Devicedriver */
-} _ump_uk_allocate_s;
-
-/**
- * SIZE_GET ([in] u32 secure_id, [out]size )
- */
-typedef struct _ump_uk_size_get_s
-{
- void *ctx; /**< [in,out] user-kernel context (trashed on output) */
- u32 secure_id; /**< Input to DD */
- u32 size; /**< Returned size; output */
-} _ump_uk_size_get_s;
-
-/**
- * Release ([in] u32 secure_id)
- */
-typedef struct _ump_uk_release_s
-{
- void *ctx; /**< [in,out] user-kernel context (trashed on output) */
- u32 secure_id; /**< Input to DD */
-} _ump_uk_release_s;
-
-typedef struct _ump_uk_map_mem_s
-{
- void *ctx; /**< [in,out] user-kernel context (trashed on output) */
- void *mapping; /**< [out] Returns user-space virtual address for the mapping */
- void *phys_addr; /**< [in] physical address */
- unsigned long size; /**< [in] size */
- u32 secure_id; /**< [in] secure_id to assign to mapping */
- void * _ukk_private; /**< Only used inside linux port between kernel frontend and common part to store vma */
- u32 cookie;
- u32 is_cached; /**< [in,out] caching of CPU mappings */
-} _ump_uk_map_mem_s;
-
-typedef struct _ump_uk_unmap_mem_s
-{
- void *ctx; /**< [in,out] user-kernel context (trashed on output) */
- void *mapping;
- u32 size;
- void * _ukk_private;
- u32 cookie;
-} _ump_uk_unmap_mem_s;
-
-typedef struct _ump_uk_msync_s
-{
- void *ctx; /**< [in,out] user-kernel context (trashed on output) */
- void *mapping; /**< [in] mapping addr */
- void *address; /**< [in] flush start addr */
- u32 size; /**< [in] size to flush */
- ump_uk_msync_op op; /**< [in] flush operation */
- u32 cookie; /**< [in] cookie stored with reference to the kernel mapping internals */
- u32 secure_id; /**< [in] cookie stored with reference to the kernel mapping internals */
- u32 is_cached; /**< [out] caching of CPU mappings */
-} _ump_uk_msync_s;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __UMP_UK_TYPES_H__ */
diff --git a/exynos4/hal/libump/os/linux/ump_ioctl.h b/exynos4/hal/libump/os/linux/ump_ioctl.h
deleted file mode 100644
index a62c31a..0000000
--- a/exynos4/hal/libump/os/linux/ump_ioctl.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 __UMP_IOCTL_H__
-#define __UMP_IOCTL_H__
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include <linux/types.h>
-#include <linux/ioctl.h>
-
-#include <ump/ump_uk_types.h>
-
-#ifndef __user
-#define __user
-#endif
-
-
-/**
- * @file UMP_ioctl.h
- * This file describes the interface needed to use the Linux device driver.
- * The interface is used by the userpace UMP driver.
- */
-
-#define UMP_IOCTL_NR 0x90
-
-
-#define UMP_IOC_QUERY_API_VERSION _IOR(UMP_IOCTL_NR, _UMP_IOC_QUERY_API_VERSION, _ump_uk_api_version_s)
-#define UMP_IOC_ALLOCATE _IOWR(UMP_IOCTL_NR, _UMP_IOC_ALLOCATE, _ump_uk_allocate_s)
-#define UMP_IOC_RELEASE _IOR(UMP_IOCTL_NR, _UMP_IOC_RELEASE, _ump_uk_release_s)
-#define UMP_IOC_SIZE_GET _IOWR(UMP_IOCTL_NR, _UMP_IOC_SIZE_GET, _ump_uk_size_get_s)
-#define UMP_IOC_MSYNC _IOW(UMP_IOCTL_NR, _UMP_IOC_MSYNC, _ump_uk_size_get_s)
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __UMP_IOCTL_H__ */
diff --git a/exynos4/hal/libump/os/linux/ump_osu_locks.c b/exynos4/hal/libump/os/linux/ump_osu_locks.c
deleted file mode 100644
index 97ba858..0000000
--- a/exynos4/hal/libump/os/linux/ump_osu_locks.c
+++ /dev/null
@@ -1,537 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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.
- */
-
-#if ((!defined _XOPEN_SOURCE) || ((_XOPEN_SOURCE - 0) < 600))
-#undef _XOPEN_SOURCE
-#define _XOPEN_SOURCE 600
-#endif
-
-
-#define _POSIX_C_SOURCE 200112L
-
-#include <ump/ump_osu.h>
-#include <ump/ump_debug.h>
-
-#include <pthread.h>
-#include <time.h>
-#include <sys/time.h>
-#include <errno.h>
-
-/**
- * @file ump_osu_locks.c
- * File implements the user side of the OS interface
- */
-
-/** @opt Most of the time, we use the plain mutex type of osu_lock, and so
- * only require the flags and mutex members. This costs 2 extra DWORDS, but
- * most of the time we don't use those DWORDS.
- * Therefore, ANY_UNLOCK type osu_locks can be implemented as a second
- * structure containing the member _ump_osu_lock_t lock_t, plus the extra
- * state required. Then, we use &container->lock_t when passing out of the
- * OSU api, and CONTAINER_OF() when passing back in to recover the original
- * structure. */
-
-/** Private declaration of the OSU lock type */
-struct _ump_osu_lock_t_struct
-{
- /** At present, only two types of mutex, so we store this information as
- * the flags supplied at init time */
- _ump_osu_lock_flags_t flags;
-
- pthread_mutex_t mutex; /**< Used in both plain and ANY_UNLOCK osu_locks */
-
- /* Extra State for ANY_UNLOCK osu_locks. These are UNINITIALIZED when
- * flags does not contain _UMP_OSU_LOCKFLAG_ANYUNLOCK: */
- pthread_cond_t condition; /**< The condition object to use while blocking */
- ump_bool state; /**< The boolean which indicates the event's state */
-
- UMP_DEBUG_CODE(
- /** debug checking of locks */
- _ump_osu_lock_mode_t locked_as;
- ) /* UMP_DEBUG_CODE */
-
-};
-
-/* Provide two statically initialized locks */
-UMP_STATIC _ump_osu_lock_t _ump_osu_static_locks[] =
-{
- {
- _UMP_OSU_LOCKFLAG_STATIC,
- PTHREAD_MUTEX_INITIALIZER,
- PTHREAD_COND_INITIALIZER,
- UMP_FALSE,
- UMP_DEBUG_CODE( _UMP_OSU_LOCKMODE_UNDEF )
- },
- {
- _UMP_OSU_LOCKFLAG_STATIC,
- PTHREAD_MUTEX_INITIALIZER,
- PTHREAD_COND_INITIALIZER,
- UMP_FALSE,
- UMP_DEBUG_CODE( _UMP_OSU_LOCKMODE_UNDEF )
- },
- {
- _UMP_OSU_LOCKFLAG_STATIC,
- PTHREAD_MUTEX_INITIALIZER,
- PTHREAD_COND_INITIALIZER,
- UMP_FALSE,
- UMP_DEBUG_CODE( _UMP_OSU_LOCKMODE_UNDEF )
- },
- {
- _UMP_OSU_LOCKFLAG_STATIC,
- PTHREAD_MUTEX_INITIALIZER,
- PTHREAD_COND_INITIALIZER,
- UMP_FALSE,
- UMP_DEBUG_CODE( _UMP_OSU_LOCKMODE_UNDEF )
- },
-};
-
-/* Critical section for auto_init */
-UMP_STATIC pthread_mutex_t static_auto_init_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-
-_ump_osu_errcode_t _ump_osu_lock_auto_init( _ump_osu_lock_t **pplock, _ump_osu_lock_flags_t flags, u32 initial, u32 order )
-{
- int call_result;
- /* Validate parameters: */
- UMP_DEBUG_ASSERT_POINTER( pplock );
-
- /** @opt We don't lock the Critical Section or do anything if this is already non-null */
- if ( NULL != *pplock)
- {
- return _UMP_OSU_ERR_OK;
- }
-
- /* We MIGHT need to initialize it, lock the Critical Section and check again */
- call_result = pthread_mutex_lock(&static_auto_init_mutex);
- /* It would be a programming error for this to fail: */
- UMP_DEBUG_ASSERT( 0 == call_result,
- ("failed to lock critical section\n") );
-
- if ( NULL != *pplock )
- {
- /*
- We caught a race condition to initialize this osu_lock.
- The other thread won the race, so the osu_lock is now initialized.
- */
- call_result = pthread_mutex_unlock(&static_auto_init_mutex);
-
- UMP_DEBUG_ASSERT(0 == call_result,
- ("failed to unlock critical section\n"));
-
- return _UMP_OSU_ERR_OK;
- }
-
- /* We're the first thread in: initialize the osu_lock */
- *pplock = _ump_osu_lock_init( flags, initial, order );
-
- if ( NULL == *pplock )
- {
- /* osu_lock creation failed */
- call_result = pthread_mutex_unlock(&static_auto_init_mutex);
- UMP_DEBUG_ASSERT(0 == call_result,
- ("failed to unlock critical section\n"));
-
- return _UMP_OSU_ERR_FAULT;
- }
-
-
- /* osu_lock created OK */
- call_result = pthread_mutex_unlock(&static_auto_init_mutex);
-
- UMP_DEBUG_ASSERT(0 == call_result,
- ("failed to unlock critical section\n"));
-
- UMP_IGNORE( call_result );
-
- return _UMP_OSU_ERR_OK;
-}
-
-
-_ump_osu_lock_t *_ump_osu_lock_init( _ump_osu_lock_flags_t flags, u32 initial, u32 order )
-{
- _ump_osu_lock_t * lock;
- pthread_mutexattr_t mutex_attributes;
-
- /* Validate parameters: */
- /* Flags acceptable */
- UMP_DEBUG_ASSERT( 0 == ( flags & ~( _UMP_OSU_LOCKFLAG_ANYUNLOCK)),
- ("incorrect flags or trying to initialise a statically initialized lock, %.8X\n", flags) );
-
- /* Parameter initial SBZ - for future expansion */
- UMP_DEBUG_ASSERT( 0 == initial,
- ("initial must be zero\n") );
-
- if (0 != pthread_mutexattr_init(&mutex_attributes))
- {
- return NULL;
- }
-
-#if UMP_DEBUG_EXTENDED_MUTEX_LOCK_CHECKING
-#define UMP_PTHREADS_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK
-#else
-#define UMP_PTHREADS_MUTEX_TYPE PTHREAD_MUTEX_DEFAULT
-#endif
-
- if (0 != pthread_mutexattr_settype(&mutex_attributes, UMP_PTHREADS_MUTEX_TYPE))
- {
- /** Return NULL on failure */
- pthread_mutexattr_destroy(&mutex_attributes);
- return NULL;
-
- }
-
-#undef UMP_PTHREADS_MUTEX_TYPE
-
- /** @opt use containing structures for the ANY_UNLOCK type, to
- * save 2 DWORDS when not in use */
- lock = _ump_osu_malloc( sizeof(_ump_osu_lock_t) );
-
- if( NULL == lock )
- {
- /** Return NULL on failure */
- pthread_mutexattr_destroy(&mutex_attributes);
- return NULL;
- }
-
- if (0 != pthread_mutex_init( &lock->mutex, &mutex_attributes ))
- {
- pthread_mutexattr_destroy(&mutex_attributes);
- _ump_osu_free( lock );
- return NULL;
- }
-
- /* done with the mutexattr object */
- pthread_mutexattr_destroy(&mutex_attributes);
-
- /* ANY_UNLOCK type */
- if ( flags & _UMP_OSU_LOCKFLAG_ANYUNLOCK )
- {
- if (0 != pthread_cond_init( &lock->condition, NULL ))
- {
- /* cleanup */
- pthread_mutex_destroy( &lock->mutex );
- _ump_osu_free( lock );
- return NULL;
- }
- lock->state = UMP_FALSE; /* mark as unlocked by default */
- }
-
- lock->flags = flags;
-
- /** Debug lock checking */
- UMP_DEBUG_CODE( lock->locked_as = _UMP_OSU_LOCKMODE_UNDEF );
-
- return lock;
-}
-
-_ump_osu_errcode_t _ump_osu_lock_timed_wait( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode, u64 timeout)
-{
- /* absolute time specifier */
- struct timespec ts;
- struct timeval tv;
-
- /* Parameter validation */
- UMP_DEBUG_ASSERT_POINTER( lock );
-
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_RW == mode,
- ("unrecognised mode, %.8X\n", mode) );
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKFLAG_ANYUNLOCK == lock->flags, ("Timed operations only implemented for ANYUNLOCK type locks"));
-
- /* calculate the realtime timeout value */
-
- if (0 != gettimeofday(&tv, NULL))
- {
- UMP_DEBUG_PRINT(1,("Could not get the current realtime value to calculate the absolute value for a timed mutex lock with a timeout"));
- return _UMP_OSU_ERR_FAULT;
- }
-
- tv.tv_usec += timeout;
-
-#define UMP_USECS_PER_SECOND 1000000ULL
-#define UMP_NANOSECS_PER_USEC 1000ULL
-
- /* did we overflow a second in the usec part? */
- while (tv.tv_usec >= UMP_USECS_PER_SECOND)
- {
- tv.tv_usec -= UMP_USECS_PER_SECOND;
- tv.tv_sec++;
- }
-
- /* copy to the correct struct */
- ts.tv_sec = tv.tv_sec;
- ts.tv_nsec = (tv.tv_usec * UMP_NANOSECS_PER_USEC);
-
-#undef UMP_USECS_PER_SECOND
-#undef UMP_NANOSECS_PER_USEC
-
- /* lock the mutex protecting access to the state field */
- pthread_mutex_lock( &lock->mutex );
- /* loop while locked (state is UMP_TRUE) */
- /* pthread_cond_timedwait unlocks the mutex, wait, and locks the mutex once unblocked (either due to the event or the timeout) */
- while ( UMP_TRUE == lock->state )
- {
- int res;
- res = pthread_cond_timedwait( &lock->condition, &lock->mutex, &ts );
- if (0 == res) continue; /* test the state variable again (loop condition) */
- else if (ETIMEDOUT == res)
- {
- /* timeout, need to clean up and return the correct error code */
- pthread_mutex_unlock(&lock->mutex);
- return _UMP_OSU_ERR_TIMEOUT;
- }
- else
- {
- UMP_DEBUG_PRINT(1, ("Unexpected return from pthread_cond_timedwait 0x%08X\n", res));
-
- pthread_mutex_unlock(&lock->mutex);
- return _UMP_OSU_ERR_FAULT;
- }
-
- }
-
- /* DEBUG tracking of previously locked state - occurs while lock is obtained */
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as,
- ("This lock was already locked\n") );
- UMP_DEBUG_CODE( lock->locked_as = mode );
-
- /* the state is UMP_FALSE (unlocked), so we set it to UMP_TRUE to indicate that it's locked and can return knowing that we own the lock */
- lock->state = UMP_TRUE;
- /* final unlock of the mutex */
- pthread_mutex_unlock(&lock->mutex);
-
- return _UMP_OSU_ERR_OK;
-
-}
-
-_ump_osu_errcode_t _ump_osu_lock_wait( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode)
-{
- /* Parameter validation */
- UMP_DEBUG_ASSERT_POINTER( lock );
-
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_RW == mode,
- ("unrecognised mode, %.8X\n", mode) );
-
- /** @note since only one flag can be set, we use a switch statement here.
- * Otherwise, MUST add an enum into the _ump_osu_lock_t to store the
- * implemented lock type */
- switch ( lock->flags )
- {
- case _UMP_OSU_LOCKFLAG_STATIC:
- case 0:
- /* Usual Mutex type */
- {
- int call_result;
- call_result = pthread_mutex_lock( &lock->mutex );
- UMP_DEBUG_ASSERT( 0 == call_result,
- ("pthread_mutex_lock call failed with error code %d\n", call_result));
- UMP_IGNORE( call_result );
- }
-
- /* DEBUG tracking of previously locked state - occurs while lock is obtained */
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as,
- ("This lock was already locked\n") );
- UMP_DEBUG_CODE( lock->locked_as = mode );
- break;
-
- case _UMP_OSU_LOCKFLAG_ANYUNLOCK:
- /** @note Use of bitflags in a case statement ONLY works because this
- * is the ONLY flag that is supported */
-
- /* lock the mutex protecting access to the state field */
- pthread_mutex_lock( &lock->mutex );
- /* loop while locked (state is UMP_TRUE) */
- /* pthread_cond_wait unlocks the mutex, wait, and locks the mutex once unblocked */
- while ( UMP_TRUE == lock->state ) pthread_cond_wait( &lock->condition, &lock->mutex );
-
- /* DEBUG tracking of previously locked state - occurs while lock is obtained */
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as,
- ("This lock was already locked\n") );
- UMP_DEBUG_CODE( lock->locked_as = mode );
-
- /* the state is UMP_FALSE (unlocked), so we set it to UMP_TRUE to indicate that it's locked and can return knowing that we own the lock */
- lock->state = UMP_TRUE;
- /* final unlock of the mutex */
- pthread_mutex_unlock(&lock->mutex);
- break;
-
- default:
- UMP_DEBUG_ERROR( ("lock has incorrect flags==%.8X\n", lock->flags) );
- break;
- }
-
- return _UMP_OSU_ERR_OK;
-}
-
-_ump_osu_errcode_t _ump_osu_lock_trywait( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode)
-{
- _ump_osu_errcode_t err = _UMP_OSU_ERR_FAULT;
- /* Parameter validation */
- UMP_DEBUG_ASSERT_POINTER( lock );
-
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_RW == mode,
- ("unrecognised mode, %.8X\n", mode) );
-
- /** @note since only one flag can be set, we use a switch statement here.
- * Otherwise, MUST add an enum into the _ump_osu_lock_t to store the
- * implemented lock type */
- switch ( lock->flags )
- {
- case _UMP_OSU_LOCKFLAG_STATIC:
- case 0:
- /* Usual Mutex type */
- {
- /* This is not subject to UMP_CHECK - overriding the result would cause a programming error */
- if ( 0 == pthread_mutex_trylock( &lock->mutex ) )
- {
- err = _UMP_OSU_ERR_OK;
-
- /* DEBUG tracking of previously locked state - occurs while lock is obtained */
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as
- || mode == lock->locked_as,
- ("tried as mode==%.8X, but was locked as %.8X\n", mode, lock->locked_as) );
- UMP_DEBUG_CODE( lock->locked_as = mode );
- }
- }
- break;
-
- case _UMP_OSU_LOCKFLAG_ANYUNLOCK:
- /** @note Use of bitflags in a case statement ONLY works because this
- * is the ONLY flag that is supported */
-
- /* lock the mutex protecting access to the state field */
- pthread_mutex_lock(&lock->mutex);
-
- if ( UMP_FALSE == lock->state)
- {
- /* unlocked, take the lock */
- lock->state = UMP_TRUE;
- err = _UMP_OSU_ERR_OK;
- }
-
- /* DEBUG tracking of previously locked state - occurs while lock is obtained */
- /* Can do this regardless of whether we obtained ANYUNLOCK: */
-
-
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as
- || mode == lock->locked_as,
- ("tried as mode==%.8X, but was locked as %.8X\n", mode, lock->locked_as) );
- /* If we were already locked, this does no harm, because of the above assert: */
- UMP_DEBUG_CODE( lock->locked_as = mode );
-
- pthread_mutex_unlock(&lock->mutex);
- break;
-
- default:
- UMP_DEBUG_ERROR( ("lock has incorrect flags==%.8X\n", lock->flags) );
- break;
- }
-
- return err;
-}
-
-
-void _ump_osu_lock_signal( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode )
-{
- /* Parameter validation */
- UMP_DEBUG_ASSERT_POINTER( lock );
-
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_RW == mode,
- ("unrecognised mode, %.8X\n", mode) );
-
- /** @note since only one flag can be set, we use a switch statement here.
- * Otherwise, MUST add an enum into the _ump_osu_lock_t to store the
- * implemented lock type */
- switch ( lock->flags )
- {
- case _UMP_OSU_LOCKFLAG_STATIC:
- case 0:
- /* Usual Mutex type */
-
- /* DEBUG tracking of previously locked state - occurs while lock is obtained */
- UMP_DEBUG_ASSERT( mode == lock->locked_as,
- ("This lock was locked as==%.8X, but tried to unlock as mode==%.8X\n", lock->locked_as, mode));
- UMP_DEBUG_CODE( lock->locked_as = _UMP_OSU_LOCKMODE_UNDEF );
-
- {
- int call_result;
- call_result = pthread_mutex_unlock( &lock->mutex );
- UMP_DEBUG_ASSERT( 0 == call_result,
- ("pthread_mutex_lock call failed with error code %d\n", call_result));
- UMP_IGNORE( call_result );
- }
- break;
-
- case _UMP_OSU_LOCKFLAG_ANYUNLOCK:
- /** @note Use of bitflags in a case statement ONLY works because this
- * is the ONLY flag that is supported */
-
- pthread_mutex_lock(&lock->mutex);
- UMP_DEBUG_ASSERT( UMP_TRUE == lock->state, ("Unlocking a _ump_osu_lock_t %p which is not locked\n", lock));
-
- /* DEBUG tracking of previously locked state - occurs while lock is obtained */
- UMP_DEBUG_ASSERT( mode == lock->locked_as,
- ("This lock was locked as==%.8X, but tried to unlock as %.8X\n", lock->locked_as, mode ));
- UMP_DEBUG_CODE( lock->locked_as = _UMP_OSU_LOCKMODE_UNDEF );
-
- /* mark as unlocked */
- lock->state = UMP_FALSE;
-
- /* signal the condition, only wake a single thread */
- pthread_cond_signal(&lock->condition);
-
- pthread_mutex_unlock(&lock->mutex);
- break;
-
- default:
- UMP_DEBUG_ERROR( ("lock has incorrect flags==%.8X\n", lock->flags) );
- break;
- }
-}
-
-void _ump_osu_lock_term( _ump_osu_lock_t *lock )
-{
- int call_result;
- UMP_DEBUG_ASSERT_POINTER( lock );
-
- /** Debug lock checking: */
- /* Lock is signalled on terminate - not a guarantee, since we could be locked immediately beforehand */
- UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as,
- ("cannot terminate held lock\n") );
-
- call_result = pthread_mutex_destroy( &lock->mutex );
- UMP_DEBUG_ASSERT( 0 == call_result,
- ("Incorrect mutex use detected: pthread_mutex_destroy call failed with error code %d\n", call_result) );
-
- /* Destroy extra state for ANY_UNLOCK type osu_locks */
- if ( lock->flags & _UMP_OSU_LOCKFLAG_ANYUNLOCK )
- {
- UMP_DEBUG_ASSERT( UMP_FALSE == lock->state, ("terminate called on locked object %p\n", lock));
- call_result = pthread_cond_destroy(&lock->condition);
- UMP_DEBUG_ASSERT( 0 == call_result,
- ("Incorrect condition-variable use detected: pthread_cond_destroy call failed with error code %d\n", call_result) );
- }
-
- UMP_IGNORE(call_result);
-
- _ump_osu_free( lock );
-}
-
-_ump_osu_lock_t *_ump_osu_lock_static( u32 nr )
-{
- UMP_DEBUG_ASSERT( nr < UMP_OSU_STATIC_LOCK_COUNT,
- ("provided static lock index (%d) out of bounds (0 < nr < %d)\n", nr, UMP_OSU_STATIC_LOCK_COUNT) );
- return &_ump_osu_static_locks[nr];
-}
diff --git a/exynos4/hal/libump/os/linux/ump_osu_memory.c b/exynos4/hal/libump/os/linux/ump_osu_memory.c
deleted file mode 100644
index 5807594..0000000
--- a/exynos4/hal/libump/os/linux/ump_osu_memory.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 <ump/ump_osu.h>
-
-#include <stdlib.h>
-#include <string.h> /* memcmp, memchr, memset */
-
-/**
- * @file ump_osu_memory.c
- * File implements the user side of the OS interface
- */
-
-void *_ump_osu_calloc( u32 n, u32 size )
-{
- return calloc( n, size );
-}
-
-void *_ump_osu_malloc( u32 size )
-{
- return malloc( size );
-}
-
-void *_ump_osu_realloc( void *ptr, u32 size )
-{
- return realloc( ptr, size );
-}
-
-void _ump_osu_free( void *ptr )
-{
- free( ptr );
-}
-
-void *_ump_osu_memcpy( void *dst, const void *src, u32 len )
-{
- return memcpy( dst, src, len );
-}
-
-void *_ump_osu_memset( void *ptr, u32 chr, u32 size )
-{
- return memset( ptr, chr, size );
-}
-
-int _ump_osu_memcmp( const void *ptr1, const void *ptr2, u32 size )
-{
- return memcmp( ptr1, ptr2, size );
-}
diff --git a/exynos4/hal/libump/os/linux/ump_uku.c b/exynos4/hal/libump/os/linux/ump_uku.c
deleted file mode 100644
index f46a2c7..0000000
--- a/exynos4/hal/libump/os/linux/ump_uku.c
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_uku.c
- * File implements the user side of the user-kernel interface
- */
-
-#include "../ump_uku.h"
-#include <stdio.h>
-#include "ump_ioctl.h"
-
-#include <sys/mman.h>
-
-/* Needed for file operations on the device file*/
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-
-static _ump_osu_errcode_t ump_driver_ioctl(void *context, u32 command, void *args);
-
-static int ump_ioctl_api_version_used = UMP_IOCTL_API_VERSION;
-
-/**
- * The device file to access the UMP device driver
- * This is a character special file giving access to the device driver.
- * Usually created using the mknod command line utility.
- */
-static const char ump_device_file_name[] = "/dev/ump";
-
-_ump_osu_errcode_t _ump_uku_open( void **context )
-{
- int ump_device_file;
- if(NULL == context)
- {
- return _UMP_OSU_ERR_FAULT;
- }
-
- ump_device_file = open(ump_device_file_name, O_RDWR);
-
- if (-1 == ump_device_file)
- {
- return _UMP_OSU_ERR_FAULT;
- }
-
- {
- struct _ump_uk_api_version_s args;
- args.ctx = (void*)ump_device_file;
- args.version = UMP_IOCTL_API_VERSION;
- args.compatible = 3;
- ump_driver_ioctl(args.ctx, UMP_IOC_QUERY_API_VERSION, &args);
- if ( 1 != args.compatible )
- {
- if (IS_API_MATCH(MAKE_VERSION_ID(1), args.version))
- {
- ump_ioctl_api_version_used = MAKE_VERSION_ID(1);
- UMP_PRINTF("The UMP devicedriver does not support cached UMP. Update it if this is needed.\n");
- }
- else
- {
- UMP_PRINTF("The UMP devicedriver is version: %d, UMP libraries is version: %d.\n", GET_VERSION(args.version), GET_VERSION(UMP_IOCTL_API_VERSION) );
- close(ump_device_file);
- return _UMP_OSU_ERR_FAULT;
- }
- }
- }
-
- *context = (void *) ump_device_file;
- return _UMP_OSU_ERR_OK;
-}
-
-_ump_osu_errcode_t _ump_uku_close( void **context )
-{
- if(NULL == context)
- {
- return _UMP_OSU_ERR_FAULT;
- }
-
- if(-1 == (int)*context)
- {
- return _UMP_OSU_ERR_FAULT;
- }
-
- close((int)*context);
- *context = (void *)-1;
-
- return _UMP_OSU_ERR_OK;
-}
-
-int _ump_uku_allocate(_ump_uk_allocate_s *args)
-{
- return ump_driver_ioctl(args->ctx, UMP_IOC_ALLOCATE, args);
-}
-
-_ump_osu_errcode_t _ump_uku_release(_ump_uk_release_s *args)
-{
- return ump_driver_ioctl(args->ctx, UMP_IOC_RELEASE, args);
-}
-
-_ump_osu_errcode_t _ump_uku_size_get(_ump_uk_size_get_s *args)
-{
- return ump_driver_ioctl(args->ctx, UMP_IOC_SIZE_GET, args);
-}
-
-
-void _ump_uku_msynch(_ump_uk_msync_s *args)
-{
- /* This is for backwards compatibillity */
- if ( MAKE_VERSION_ID(1) == ump_ioctl_api_version_used)
- {
- args->is_cached = 0;
- if ( _UMP_UK_MSYNC_READOUT_CACHE_ENABLED != args->op )
- {
- UMP_DEBUG_PRINT(3, ("Warning: Doing UMP cache flush operations on a Device Driver that does not support cached UMP mem.\n"));
- }
- return;
- }
- ump_driver_ioctl(args->ctx, UMP_IOC_MSYNC, args);
-}
-
-int _ump_uku_map_mem(_ump_uk_map_mem_s *args)
-{
- int flags;
- if( -1 == (int)args->ctx )
- {
- return -1;
- }
-
- flags = MAP_SHARED;
-
- /* This is for backwards compatibillity */
- if ( MAKE_VERSION_ID(1) == ump_ioctl_api_version_used)
- {
- args->is_cached = 0;
- }
-
- /* If we want the Caching to be enabled we set the flags to be PRIVATE. The UMP DD reads this and do proper handling
- Note: this enforces the user to use proper invalidation*/
- if ( args->is_cached ) flags = MAP_PRIVATE;
-
- args->mapping = mmap(NULL, args->size, PROT_READ | PROT_WRITE ,flags , (int)args->ctx, (off_t)args->secure_id * sysconf(_SC_PAGE_SIZE));
- if (MAP_FAILED == args->mapping)
- {
- return -1;
- }
-
- args->cookie = 0; /* Cookie is not used in linux _ump_uku_unmap_mem */
-
- return 0;
-}
-
-void _ump_uku_unmap_mem( _ump_uk_unmap_mem_s *args )
-{
- /*
- * If a smaller size is used Linux will just remove the requested range but don't tell
- * the ump driver before all of it is unmapped, either via another unmap request or upon process shutdown.
- * Unmapping too much will just ignore the overhead or hit undefined behavior,
- * only affecting the calling process which could mess itself up in other ways anyway.
- * So we don't need any security checks here.
- */
- munmap(args->mapping, args->size);
-}
-
-static _ump_osu_errcode_t ump_driver_ioctl(void *context, u32 command, void *args)
-{
- /*UMP_CHECK_NON_NULL(args, _UMP_OSK_ERR_INVALID_ARGS);*/
-
- /* check for a valid file descriptor */
- /** @note manual type safety check-point */
- if( -1 == (int)context )
- {
- return _UMP_OSU_ERR_FAULT;
- }
-
- /* call ioctl handler of driver */
- if (0 != ioctl((int)context, command, args)) return -1;
- return _UMP_OSU_ERR_OK;
-}
diff --git a/exynos4/hal/libump/os/ump_uku.h b/exynos4/hal/libump/os/ump_uku.h
deleted file mode 100644
index 7da7185..0000000
--- a/exynos4/hal/libump/os/ump_uku.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2010-2011 ARM Limited. All rights reserved.
- *
- * 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 ump_uku.h
- * Defines the user-side interface of the user-kernel interface
- */
-
-#ifndef __UMP_UKU_H__
-#define __UMP_UKU_H__
-
-#include <ump/ump_osu.h>
-#include <ump/ump_debug.h>
-#include <ump/ump_uk_types.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-_ump_osu_errcode_t _ump_uku_open( void **context );
-
-_ump_osu_errcode_t _ump_uku_close( void **context );
-
-_ump_osu_errcode_t _ump_uku_allocate( _ump_uk_allocate_s *args );
-
-_ump_osu_errcode_t _ump_uku_release( _ump_uk_release_s *args );
-
-_ump_osu_errcode_t _ump_uku_size_get( _ump_uk_size_get_s *args );
-
-_ump_osu_errcode_t _ump_uku_get_api_version( _ump_uk_api_version_s *args );
-
-int _ump_uku_map_mem( _ump_uk_map_mem_s *args );
-
-void _ump_uku_unmap_mem( _ump_uk_unmap_mem_s *args );
-
-void _ump_uku_msynch(_ump_uk_msync_s *args);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __UMP_UKU_H__ */
diff --git a/exynos4/hal/libump/readme.txt b/exynos4/hal/libump/readme.txt
deleted file mode 100644
index 297df38..0000000
--- a/exynos4/hal/libump/readme.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-#
-# Copyright (C) 2010-2011 ARM Limited. All rights reserved.
-#
-# 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.
-#
-Building the UMP user space library for Linux
----------------------------------------------
-
-A simple Makefile is provided, and the UMP user space library can be built
-simply by issuing make. This Makefile is setup to use the ARM GCC compiler
-from CodeSourcery, and it builds for ARMv6. Modification to this Makefile
-is needed in order to build for other configurations.
-
-In order to use this library from the Mali GPU driver, invoke the Mali GPU
-driver build system with the following two make variables set;
-- UMP_INCLUDE_DIR should point to the include folder inside this package
-- UMP_LIB should point to the built library (libUMP.so)
-
-This does not apply to Android builds, where the Android.mk file for the
-Mali GPU driver needs to be manually edited in order to add the correct
-include path and link against the correct library.
diff --git a/exynos4/hal/libump/ump.mak b/exynos4/hal/libump/ump.mak
deleted file mode 100644
index e417313..0000000
--- a/exynos4/hal/libump/ump.mak
+++ /dev/null
@@ -1,34 +0,0 @@
-#
-# Copyright (C) 2011 ARM Limited. All rights reserved.
-#
-# 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 ($(UMP_NO_UMP),1)
-
-UMP_SRCS = \
- $(UMP_DIR)/arch_999_no_ump/ump_frontend.c \
- $(UMP_DIR)/arch_999_no_ump/ump_ref_drv.c
-
-else
-
-UMP_SRCS = \
- $(UMP_DIR)/arch_011_udd/ump_frontend.c \
- $(UMP_DIR)/arch_011_udd/ump_ref_drv.c \
- $(UMP_DIR)/arch_011_udd/ump_arch.c \
- $(UMP_DIR)/os/$(UDD_OS)/ump_uku.c \
- $(UMP_DIR)/os/$(UDD_OS)/ump_osu_memory.c \
- $(UMP_DIR)/os/$(UDD_OS)/ump_osu_locks.c
-
-endif
-
diff --git a/exynos4/multimedia/Android.mk b/exynos4/multimedia/Android.mk
deleted file mode 100644
index 6571161..0000000
--- a/exynos4/multimedia/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-include $(all-subdir-makefiles)
diff --git a/exynos4/multimedia/codecs/Android.mk b/exynos4/multimedia/codecs/Android.mk
deleted file mode 100644
index 6571161..0000000
--- a/exynos4/multimedia/codecs/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-include $(all-subdir-makefiles)
diff --git a/exynos4/multimedia/codecs/sec_codecs/Android.mk b/exynos4/multimedia/codecs/sec_codecs/Android.mk
deleted file mode 100644
index 6571161..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-include $(all-subdir-makefiles)
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/Android.mk b/exynos4/multimedia/codecs/sec_codecs/audio/Android.mk
deleted file mode 100644
index 3bc3577..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/Android.mk
+++ /dev/null
@@ -1,11 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
-include $(LOCAL_PATH)/exynos4/Android.mk
-endif
-
-ifeq ($(filter-out exynos5,$(TARGET_BOARD_PLATFORM)),)
-include $(LOCAL_PATH)/exynos5/Android.mk
-endif
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/Android.mk b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/Android.mk
deleted file mode 100644
index df938be..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/Android.mk
+++ /dev/null
@@ -1,14 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_AUDIO_PATH :=$(LOCAL_PATH)
-
-ifeq ($(BOARD_USE_ALP_AUDIO), true)
- include $(LOCAL_AUDIO_PATH)/srp/alp/Android.mk
-else
- ifeq ($(USE_ULP_AUDIO), true)
- include $(LOCAL_AUDIO_PATH)/srp/ulp/Android.mk
- include $(LOCAL_AUDIO_PATH)/srp/libsa_jni/Android.mk
- endif
-endif
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/Android.mk b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/Android.mk
deleted file mode 100644
index 7393f68..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/Android.mk
+++ /dev/null
@@ -1,26 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_COPY_HEADERS_TO := libsecmm
-LOCAL_COPY_HEADERS := \
- include/srp_api.h \
- include/srp_ioctl.h \
- include/srp_error.h
-
-LOCAL_SRC_FILES := \
- src/srp_api.c
-
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/include
-
-LOCAL_MODULE := libsrpapi
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES :=
-
-LOCAL_SHARED_LIBRARIES :=
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_api.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_api.h
deleted file mode 100644
index ad65b90..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_api.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef __SRP_API_H__
-#define __SRP_API_H__
-
-#include "srp_ioctl.h"
-#include "srp_error.h"
-
-#define SRP_DEV_NAME "dev/srp"
-
-#define SRP_INIT_BLOCK_MODE 0
-#define SRP_INIT_NONBLOCK_MODE 1
-
-#define SRP_PENDING_STATE_RUNNING 0
-#define SRP_PENDING_STATE_PENDING 1
-
-struct srp_buf_info {
- void *mmapped_addr;
- void *addr;
- unsigned int mmapped_size;
- unsigned int size;
- int num;
-};
-
-struct srp_dec_info {
- unsigned int sample_rate;
- unsigned int channels;
-};
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int SRP_Create(int block_mode);
-int SRP_Init();
-int SRP_Decode(void *buff, int size_byte);
-int SRP_Send_EOS(void);
-int SRP_SetParams(int id, unsigned long val);
-int SRP_GetParams(int id, unsigned long *pval);
-int SRP_Deinit(void);
-int SRP_Terminate(void);
-int SRP_IsOpen(void);
-
-int SRP_Get_Ibuf_Info(void **addr, unsigned int *size, unsigned int *num);
-int SRP_Get_Obuf_Info(void **addr, unsigned int *size, unsigned int *num);
-int SRP_Get_Dec_Info(struct srp_dec_info *dec_info);
-int SRP_Get_PCM(void **addr, unsigned int *size);
-int SRP_Flush(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*__SRP_API_H__ */
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_error.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_error.h
deleted file mode 100644
index 7f79452..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_error.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef _SRP_ERROR_H_
-#define _SRP_ERROR_H_
-
-typedef enum {
- SRP_RETURN_OK = 0,
-
- SRP_ERROR_OPEN_FAIL = -1000,
- SRP_ERROR_ALREADY_OPEN = -1001,
- SRP_ERROR_NOT_READY = -1002,
-
- SRP_ERROR_IBUF_OVERFLOW = -2000,
- SRP_ERROR_IBUF_INFO = -2001,
-
- SRP_ERROR_OBUF_READ = -3000,
- SRP_ERROR_OBUF_INFO = -3001,
- SRP_ERROR_OBUF_MMAP = -3002,
-
- SRP_ERROR_INVALID_SETTING = -4000,
- SRP_ERROR_GETINFO_FAIL = -4001
-} SRP_ERRORTYPE;
-
-#endif /* _SRP_ERROR_H_ */
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_ioctl.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_ioctl.h
deleted file mode 100644
index 21d55df..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_ioctl.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef __SRP_IOCTL_H__
-#define __SRP_IOCTL_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define SRP_INIT (0x10000)
-#define SRP_DEINIT (0x10001)
-#define SRP_GET_MMAP_SIZE (0x10002)
-#define SRP_FLUSH (0x20002)
-#define SRP_SEND_EOS (0x20005)
-#define SRP_GET_IBUF_INFO (0x20007)
-#define SRP_GET_OBUF_INFO (0x20008)
-#define SRP_STOP_EOS_STATE (0x30007)
-#define SRP_GET_DEC_INFO (0x30008)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __SRP_IOCTL_H__ */
-
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/src/srp_api.c b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/src/srp_api.c
deleted file mode 100644
index 56125fb..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/src/srp_api.c
+++ /dev/null
@@ -1,265 +0,0 @@
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <stdio.h>
-
-#include "srp_api.h"
-
-#define LOG_NDEBUG 1
-#define LOG_TAG "libsrpapi"
-#include <utils/Log.h>
-
-static struct srp_buf_info ibuf_info;
-static struct srp_buf_info obuf_info;
-static struct srp_buf_info pcm_info;
-
-static int srp_dev = -1;
-static int srp_block_mode = SRP_INIT_BLOCK_MODE;
-
-int SRP_Create(int block_mode)
-{
- if (srp_dev == -1) {
- srp_block_mode = block_mode;
- srp_dev = open(SRP_DEV_NAME, O_RDWR |
- ((block_mode == SRP_INIT_NONBLOCK_MODE) ? O_NDELAY : 0));
- if (srp_dev > 0)
- return srp_dev;
- else
- return SRP_ERROR_OPEN_FAIL;
- }
-
- LOGE("%s: Device is already opened", __func__);
- return SRP_ERROR_ALREADY_OPEN;
-}
-
-int SRP_Init()
-{
- int ret = SRP_RETURN_OK;
- unsigned int mmapped_size = 0;
-
- if (srp_dev != -1) {
- ret = ioctl(srp_dev, SRP_INIT);
- if (ret < 0)
- return ret;
-
- /* mmap for OBUF */
- ret = ioctl(srp_dev, SRP_GET_MMAP_SIZE, &mmapped_size);
- if (ret < 0) {
- LOGE("%s: SRP_GET_MMAP_SIZE is failed", __func__);
- return SRP_ERROR_OBUF_MMAP;
- }
- obuf_info.mmapped_addr = mmap(0, mmapped_size,
- PROT_READ | PROT_WRITE, MAP_SHARED, srp_dev, 0);
- if (!obuf_info.mmapped_addr) {
- LOGE("%s: mmap is failed", __func__);
- return SRP_ERROR_OBUF_MMAP;
- }
- obuf_info.mmapped_size = mmapped_size;
-
- ret = SRP_RETURN_OK;
- } else {
- LOGE("%s: Device is not ready", __func__);
- ret = SRP_ERROR_NOT_READY; /* device is not created */
- }
-
- return ret;
-}
-
-int SRP_Decode(void *buff, int size_byte)
-{
- int ret = SRP_RETURN_OK;
-
- if (srp_dev != -1) {
- if (size_byte > 0) {
- LOGV("%s: Send data to RP (%d bytes)", __func__, size_byte);
-
- ret = write(srp_dev, buff, size_byte); /* Write Buffer to RP Driver */
- if (ret < 0) {
- if (ret != SRP_ERROR_IBUF_OVERFLOW)
- LOGE("SRP_Decode returned error code: %d", ret);
- }
- return ret; /* Write Success */
- } else {
- return ret;
- }
- }
-
- LOGE("%s: Device is not ready", __func__);
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_Send_EOS(void)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, SRP_SEND_EOS);
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_SetParams(int id, unsigned long val)
-{
- if (srp_dev != -1)
- return 0; /* not yet */
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_GetParams(int id, unsigned long *pval)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, id, pval);
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_Flush(void)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, SRP_FLUSH);
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_Get_PCM(void **addr, unsigned int *size)
-{
- int ret = SRP_RETURN_OK;
-
- if (srp_dev != -1) {
- ret = read(srp_dev, &pcm_info, 0);
- if (ret == -1) {
- *size = 0;
- LOGE("%s: PCM read fail", __func__);
- return SRP_ERROR_OBUF_READ;
- }
-
- *addr = pcm_info.addr;
- *size = pcm_info.size;
- } else {
- return SRP_ERROR_NOT_READY;
- }
-
- return ret; /* Read Success */
-}
-
-int SRP_Get_Dec_Info(struct srp_dec_info *dec_info)
-{
- int ret;
-
- if (srp_dev != -1) {
- ret = ioctl(srp_dev, SRP_GET_DEC_INFO, dec_info);
- if (ret < 0) {
- LOGE("%s: Failed to get dec info", __func__);
- return SRP_ERROR_GETINFO_FAIL;
- }
-
- LOGV("numChannels(%d), samplingRate(%d)", dec_info->channels, dec_info->sample_rate);
-
- ret = SRP_RETURN_OK;
- } else {
- ret = SRP_ERROR_NOT_READY;
- }
-
- return ret;
-}
-
-int SRP_Get_Ibuf_Info(void **addr, unsigned int *size, unsigned int *num)
-{
- int ret = SRP_RETURN_OK;
-
- if (srp_dev != -1) {
- ret = ioctl(srp_dev, SRP_GET_IBUF_INFO, &ibuf_info);
- if (ret == -1) {
- LOGE("%s: Failed to get Ibuf info", __func__);
- return SRP_ERROR_IBUF_INFO;
- }
-
- *addr = ibuf_info.addr;
- *size = ibuf_info.size;
- *num = ibuf_info.num;
-
- if (*num == 0) {
- LOGE("%s: IBUF num is 0", __func__);
- return SRP_ERROR_INVALID_SETTING;
- }
-
- ret = SRP_RETURN_OK;
- } else {
- ret = SRP_ERROR_NOT_READY;
- }
-
- return ret;
-}
-
-int SRP_Get_Obuf_Info(void **addr, unsigned int *size, unsigned int *num)
-{
- int ret = SRP_RETURN_OK;
-
- if (srp_dev != -1) {
- if (obuf_info.addr == NULL) {
- ret = ioctl(srp_dev, SRP_GET_OBUF_INFO, &obuf_info);
- if (ret < 0) {
- LOGE("%s: SRP_GET_OBUF_INFO is failed", __func__);
- return SRP_ERROR_OBUF_INFO;
- }
- }
-
- *addr = obuf_info.addr;
- *size = obuf_info.size;
- *num = obuf_info.num;
-
- if (*num == 0) {
- LOGE("%s: OBUF num is 0", __func__);
- return SRP_ERROR_INVALID_SETTING;
- }
-
- ret = SRP_RETURN_OK;
- } else {
- ret = SRP_ERROR_NOT_READY;
- }
-
- return ret;
-}
-
-int SRP_Deinit(void)
-{
- if (srp_dev != -1) {
- munmap(obuf_info.mmapped_addr, obuf_info.mmapped_size);
- return ioctl(srp_dev, SRP_DEINIT);
- }
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_Terminate(void)
-{
- int ret;
-
- if (srp_dev != -1) {
- ret = close(srp_dev);
-
- if (ret == 0) {
- srp_dev = -1; /* device closed */
- return SRP_RETURN_OK;
- }
- }
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_IsOpen(void)
-{
- if (srp_dev == -1) {
- LOGV("%s: Device is not opened", __func__);
- return 0;
- }
-
- LOGV("%s: Device is opened", __func__);
- return 1;
-}
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/libsa_jni/Android.mk b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/libsa_jni/Android.mk
deleted file mode 100644
index 8450845..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/libsa_jni/Android.mk
+++ /dev/null
@@ -1,13 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-LOCAL_PRELINK_MODULE := false
-
-LOCAL_MODULE := libsa_jni
-LOCAL_SRC_FILES := SACtrl.c
-
-LOCAL_SHARED_LIBRARIES := libcutils
-LOCAL_STATIC_LIBRARIES := libsrpapi
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/libsa_jni/SACtrl.c b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/libsa_jni/SACtrl.c
deleted file mode 100644
index 6b99dc3..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/libsa_jni/SACtrl.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <jni.h>
-#include <time.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-#include "srp_api_ctrl.h"
-
-#define LOG_TAG "libsa_jni"
-#include <cutils/log.h>
-
-void Java_com_android_music_SetSACtrlJNI_set(JNIEnv * env, jobject obj, int effect_num)
-{
- unsigned long effect_enable = effect_num ? 1 : 0;
- unsigned int ret;
-
- LOGD("Sound effect[%d]", effect_num);
-
- ret = SRP_Ctrl_Enable_Effect(effect_enable);
- if (ret < 0) {
- LOGE("%s: Couldn't enabled effect\n", __func__);
- return;
- }
-
- SRP_Ctrl_Set_Effect_Def(effect_num << 5);
- if (ret < 0) {
- LOGE("%s: Couldn't defined effect\n", __func__);
- return;
- }
-
- return;
-}
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/Android.mk b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/Android.mk
deleted file mode 100644
index 5b1d397..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/Android.mk
+++ /dev/null
@@ -1,23 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
- src/srp_api.c \
- src/srp_api_ctrl.c
-
-LOCAL_MODULE := libsrpapi
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES :=
-
-LOCAL_SHARED_LIBRARIES :=
-
-LOCAL_COPY_HEADERS := \
- include/srp_api.h \
- include/srp_api_ctrl.h \
- include/srp_ioctl.h
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_api.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_api.h
deleted file mode 100644
index 74598e5..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_api.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef __SRP_API_H__
-#define __SRP_API_H__
-
-#include "srp_ioctl.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int SRP_Create(int block_mode);
-int SRP_Init(unsigned int ibuf_size);
-int SRP_Decode(void *buff, int size_byte);
-int SRP_Send_EOS(void);
-int SRP_Resume_EOS(void);
-int SRP_Pause(void);
-int SRP_Stop(void);
-int SRP_Flush(void);
-int SRP_SetParams(int id, unsigned long val);
-int SRP_GetParams(int id, unsigned long *pval);
-int SRP_Deinit(void);
-int SRP_Terminate(void);
-int SRP_IsOpen(void);
-
-#define SRP_DEV_NAME "dev/srp"
-
-#define SRP_INIT_BLOCK_MODE 0
-#define SRP_INIT_NONBLOCK_MODE 1
-
-#define SRP_PENDING_STATE_RUNNING 0
-#define SRP_PENDING_STATE_PENDING 1
-
-#define SRP_ERROR_LOSTSYNC 0x00101
-#define SRP_ERROR_BADLAYER 0x00102
-#define SRP_ERROR_BADBITRATE 0x00103
-#define SRP_ERROR_BADSAMPLERATE 0x00104
-#define SRP_ERROR_BADEMPHASIS 0x00105
-
-#define SRP_ERROR_BADCRC 0x00201
-#define SRP_ERROR_BADBITALLOC 0x00211
-#define SRP_ERROR_BADBADSCALEFACTOR 0x00221
-#define SRP_ERROR_BADFRAMELEN 0x00231
-#define SRP_ERROR_BADBIGVALUES 0x00232
-#define SRP_ERROR_BADBLOCKTYPE 0x00233
-#define SRP_ERROR_BADSCFSI 0x00234
-#define SRP_ERROR_BADDATAPTR 0x00235
-#define SRP_ERROR_BADPART3LEN 0x00236
-#define SRP_ERROR_BADHUFFTABLE 0x00237
-#define SRP_ERROR_BADHUFFDATA 0x00238
-#define SRP_ERROR_BADSTEREO 0x00239
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*__SRP_API_H__ */
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_api_ctrl.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_api_ctrl.h
deleted file mode 100644
index 3b17acf..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_api_ctrl.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef __SRP_API_CTRL_H__
-#define __SRP_API_CTRL_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define SRP_CTRL_DEV_NAME "dev/srp_ctrl"
-
-int SRP_Ctrl_Set_Effect(int effect); /* test only */
-int SRP_Ctrl_Enable_Effect(int on);
-int SRP_Ctrl_Set_Effect_Def(unsigned long effect_def);
-int SRP_Ctrl_Set_Effect_EQ_User(unsigned long eq_user);
-int SRP_Ctrl_Set_Pcm_Dump(int on);
-int SRP_Ctrl_Get_Pcm_Dump_State(void);
-int SRP_Ctrl_Set_Gain(float value);
-int SRP_Ctrl_Get_Running_Stat(void);
-int SRP_Ctrl_Get_Open_Stat(void);
-short *SRP_Ctrl_Get_Pcm(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __SRP_API_CTRL_H__ */
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_ioctl.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_ioctl.h
deleted file mode 100644
index a20b1ac..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_ioctl.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef __SRP_IOCTL_H__
-#define __SRP_IOCTL_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* constants for srp device node */
-#define SRP_INIT (0x10000)
-#define SRP_DEINIT (0x10001)
-
-#define SRP_PAUSE (0x20000)
-#define SRP_STOP (0x20001)
-#define SRP_FLUSH (0x20002)
-#define SRP_WAIT_EOS (0x20003)
-#define SRP_EFFECT (0x20004)
-#define SRP_SEND_EOS (0x20005)
-#define SRP_RESUME_EOS (0x20006)
-
-#define SRP_PENDING_STATE (0x30000)
-#define SRP_ERROR_STATE (0x30001)
-#define SRP_DECODED_FRAME_NO (0x30002)
-#define SRP_DECODED_ONE_FRAME_SIZE (0x30003)
-#define SRP_DECODED_FRAME_SIZE (0x30004)
-#define SRP_DECODED_PCM_SIZE (0x30005)
-#define SRP_CHANNEL_COUNT (0x30006)
-#define SRP_STOP_EOS_STATE (0x30007)
-
-/* constants for srp_ctrl device node*/
-#define SRP_CTRL_SET_GAIN (0xFF000)
-#define SRP_CTRL_SET_EFFECT (0xFF001)
-#define SRP_CTRL_GET_PCM_1KFRAME (0xFF002)
-#define SRP_CTRL_PCM_DUMP_OP (0xFF003)
-
-#define SRP_CTRL_EFFECT_ENABLE (0xFF010)
-#define SRP_CTRL_EFFECT_DEF (0xFF011)
-#define SRP_CTRL_EFFECT_EQ_USR (0xFF012)
-#define SRP_CTRL_EFFECT_SPEAKER (0xFF013)
-
-#define SRP_CTRL_IS_RUNNING (0xFF100)
-#define SRP_CTRL_IS_OPENED (0xFF101)
-#define SRP_CTRL_GET_OP_LEVEL (0xFF102)
-#define SRP_CTRL_IS_PCM_DUMP (0xFF103)
-
-#define SRP_CTRL_ALTFW_STATE (0xFF200)
-#define SRP_CTRL_ALTFW_LOAD (0xFF201)
-
-/* constants for SRP firmware */
-#define SRP_FW_CODE1 0
-#define SRP_FW_CODE20 1
-#define SRP_FW_CODE21 2
-#define SRP_FW_CODE22 3
-#define SRP_FW_CODE30 4
-#define SRP_FW_CODE31 5
-
-#define SRP_FW_VLIW 0
-#define SRP_FW_CGA 1
-#define SRP_FW_CGA_SA 2
-#define SRP_FW_DATA 3
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __SRP_IOCTL_H__ */
-
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/src/srp_api.c b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/src/srp_api.c
deleted file mode 100644
index b0c0e5e..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/src/srp_api.c
+++ /dev/null
@@ -1,381 +0,0 @@
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <stdio.h>
-
-#include "srp_api.h"
-
-#define LOG_TAG "libsrpapi"
-#include <cutils/log.h>
-
-/* Disable LOGD message */
-#ifdef LOGD
-#undef LOGD
-#endif
-#define LOGD(...)
-
-//#define _USE_WBUF_ /* Buffering before writing srp-rp device */
-//#define _DUMP_TO_FILE_
-//#define _USE_FW_FROM_DISK_
-
-#ifdef _USE_WBUF_
-#define WBUF_LEN_MUL 2
-#endif
-
-static int srp_dev = -1;
-static int srp_ibuf_size = 0;
-static int srp_block_mode = SRP_INIT_BLOCK_MODE;
-
-static unsigned char *wbuf;
-static int wbuf_size;
-static int wbuf_pos;
-
-#ifdef _DUMP_TO_FILE_
-static FILE *fp_dump = NULL;
-#endif
-
-#ifdef _USE_WBUF_
-static int WriteBuff_Init(void)
-{
- if (wbuf == NULL) {
- wbuf_size = srp_ibuf_size * WBUF_LEN_MUL;
- wbuf_pos = 0;
- wbuf = (unsigned char *)malloc(wbuf_size);
- LOGD("%s: WriteBuffer %dbytes allocated", __func__, wbuf_size);
- return 0;
- }
-
- LOGE("%s: WriteBuffer already allocated", __func__);
- return -1;
-}
-
-static int WriteBuff_Deinit(void)
-{
- if (wbuf != NULL) {
- free(wbuf);
- wbuf = NULL;
- return 0;
- }
-
- LOGE("%s: WriteBuffer is not ready", __func__);
- return -1;
-}
-
-static int WriteBuff_Write(unsigned char *buff, int size_byte)
-{
- int write_byte;
-
- if ((wbuf_pos + size_byte) < wbuf_size) {
- memcpy(&wbuf[wbuf_pos], buff, size_byte);
- wbuf_pos += size_byte;
- } else {
- LOGE("%s: WriteBuffer is filled [%d], ignoring write [%d]", __func__, wbuf_pos, size_byte);
- return -1; /* Insufficient buffer */
- }
-
- return wbuf_pos;
-}
-
-static void WriteBuff_Consume(void)
-{
- memcpy(wbuf, &wbuf[srp_ibuf_size], srp_ibuf_size * (WBUF_LEN_MUL - 1));
- wbuf_pos -= srp_ibuf_size;
-}
-
-static void WriteBuff_Flush(void)
-{
- wbuf_pos = 0;
-}
-#endif
-
-int SRP_Create(int block_mode)
-{
- if (srp_dev == -1) {
-#ifdef _USE_FW_FROM_DISK_
- SRP_Check_AltFirmware();
-#endif
-
- srp_block_mode = block_mode;
- srp_dev = open(SRP_DEV_NAME, O_RDWR |
- ((block_mode == SRP_INIT_NONBLOCK_MODE) ? O_NDELAY : 0));
-
- return srp_dev;
- }
-
- LOGE("%s: Device is not ready", __func__);
- return -1; /* device alreay opened */
-}
-
-int SRP_Init(unsigned int ibuf_size)
-{
- int ret;
-
- if (srp_dev != -1) {
- srp_ibuf_size = ibuf_size;
- ret = ioctl(srp_dev, SRP_INIT, srp_ibuf_size); /* Initialize IBUF size (4KB ~ 18KB) */
-
-#ifdef _DUMP_TO_FILE_
- char outname[256];
- int cnt = 0;
-
- while (1) {
- sprintf(outname, "/data/rp_dump_%04d.mp3", cnt++);
- if (fp_dump = fopen(outname, "rb")) { /* file exist? */
- fclose(fp_dump);
- } else {
- break;
- }
- }
-
- LOGD("%s: Dump MP3 to %s", __func__, outname);
- if (fp_dump = fopen(outname, "wb"))
- LOGD("%s: Success to open %s", __func__, outname);
- else
- LOGD("%s: Fail to open %s", __func__, outname);
-#endif
-
-#ifdef _USE_WBUF_
- if (ret != -1)
- return WriteBuff_Init();
-#else
- return ret;
-#endif
- }
-
- LOGE("%s: Device is not ready", __func__);
- return -1; /* device is not created */
-}
-
-#ifdef _USE_WBUF_
-int SRP_Decode(void *buff, int size_byte)
-{
- int ret;
- int val;
- int err_code = 0;
-
- if (srp_dev != -1) {
- /* Check wbuf before writing buff */
- while (wbuf_pos >= srp_ibuf_size) { /* Write_Buffer filled? (IBUF Size)*/
- LOGD("%s: Write Buffer is full, Send data to RP", __func__);
-
- ret = write(srp_dev, wbuf, srp_ibuf_size); /* Write Buffer to RP Driver */
- if (ret == -1) { /* Fail? */
- ioctl(srp_dev, SRP_ERROR_STATE, &val);
- if (!val) { /* Write error? */
- LOGE("%s: IBUF write fail", __func__);
- return -1;
- } else { /* Write OK, but RP decode error? */
- err_code = val;
- LOGE("%s: RP decode error [0x%05X]", __func__, err_code);
- }
- }
-#ifdef _DUMP_TO_FILE_
- if (fp_dump)
- fwrite(wbuf, srp_ibuf_size, 1, fp_dump);
-#endif
- WriteBuff_Consume();
- }
-
- ret = WriteBuff_Write((unsigned char *)buff, size_byte);
- if (ret == -1)
- return -1; /* Buffering error */
-
- LOGD("%s: Write Buffer remain [%d]", __func__, wbuf_pos);
- return err_code; /* Write Success */
- }
-
- LOGE("%s: Device is not ready", __func__);
- return -1; /* device is not created */
-}
-
-int SRP_Send_EOS(void)
-{
- int ret;
- int val;
-
- if (srp_dev != -1) {
- /* Check wbuf before writing buff */
- while (wbuf_pos) { /* Write_Buffer ramain?*/
- if (wbuf_pos < srp_ibuf_size) {
- memset(wbuf + wbuf_pos, 0xFF, srp_ibuf_size - wbuf_pos); /* Fill dummy data */
- wbuf_pos = srp_ibuf_size;
- }
-
- ret = write(srp_dev, wbuf, srp_ibuf_size); /* Write Buffer to RP Driver */
- if (ret == -1) { /* Fail? */
- ret = ioctl(srp_dev, SRP_ERROR_STATE, &val);
- if (!val) { /* Write error? */
- LOGE("%s: IBUF write fail", __func__);
- return -1;
- } else { /* RP decoe error? */
- LOGE("%s: RP decode error [0x%05X]", __func__, val);
- return -1;
- }
- } else { /* Success? */
-#ifdef _DUMP_TO_FILE_
- if (fp_dump)
- fwrite(wbuf, srp_ibuf_size, 1, fp_dump);
-#endif
- WriteBuff_Consume();
- }
- }
-
- memset(wbuf, 0xFF, srp_ibuf_size); /* Fill dummy data */
- write(srp_dev, wbuf, srp_ibuf_size); /* Write Buffer to RP Driver */
-
- /* Wait until RP decoding over */
- return ioctl(srp_dev, SRP_WAIT_EOS);
- }
-
- return -1; /* device is not created */
-}
-#else /* Without WBUF */
-int SRP_Decode(void *buff, int size_byte)
-{
- int ret;
- int val;
- int err_code = 0;
-
- if (srp_dev != -1) {
- LOGD("%s: Send data to RP (%d bytes)", __func__, size_byte);
-
- ret = write(srp_dev, buff, size_byte); /* Write Buffer to RP Driver */
- if (ret == -1) { /* Fail? */
- ioctl(srp_dev, SRP_ERROR_STATE, &val);
- if (!val) { /* Write error? */
- LOGE("%s: IBUF write fail", __func__);
- return -1;
- } else { /* Write OK, but RP decode error? */
- err_code = val;
- LOGE("%s: RP decode error [0x%05X]", __func__, err_code);
- }
- }
-#ifdef _DUMP_TO_FILE_
- if (fp_dump)
- fwrite(buff, size_byte, 1, fp_dump);
-#endif
-
- return err_code; /* Write Success */
- }
-
- LOGE("%s: Device is not ready", __func__);
- return -1; /* device is not created */
-}
-
-int SRP_Send_EOS(void)
-{
- /* Wait until RP decoding over */
- if (srp_dev != -1)
- return ioctl(srp_dev, SRP_SEND_EOS);
-
- return -1; /* device is not created */
-}
-
-int SRP_Resume_EOS(void)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, SRP_RESUME_EOS);
-
- return -1; /* device is not created */
-}
-#endif
-
-int SRP_Pause(void)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, SRP_PAUSE);
-
- return -1; /* device is not created */
-}
-
-int SRP_Stop(void)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, SRP_STOP);
-
- return -1; /* device is not created */
-}
-
-int SRP_Flush(void)
-{
- if (srp_dev != -1) {
- if (ioctl(srp_dev, SRP_FLUSH) != -1) {
-#ifdef _USE_WBUF_
- WriteBuff_Flush();
-#endif
- return 0;
- }
- }
-
- return -1; /* device is not created */
-}
-
-
-int SRP_SetParams(int id, unsigned long val)
-{
- if (srp_dev != -1)
- return 0; /* not yet */
-
- return -1; /* device is not created */
-}
-
-int SRP_GetParams(int id, unsigned long *pval)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, id, pval);
-
- return -1; /* device is not created */
-}
-
-int SRP_Deinit(void)
-{
- if (srp_dev != -1) {
-#ifdef _DUMP_TO_FILE_
- if (fp_dump)
- fclose(fp_dump);
-#endif
-
-#ifdef _USE_WBUF_
- WriteBuff_Deinit();
-#endif
- return ioctl(srp_dev, SRP_DEINIT); /* Deinialize */
- }
-
- LOGE("%s: Device is not ready", __func__);
- return -1; /* device is not created */
-}
-
-int SRP_Terminate(void)
-{
- int ret;
-
- if (srp_dev != -1) {
- ret = close(srp_dev);
-
- if (ret == 0) {
- srp_dev = -1; /* device closed */
- return 0;
- }
- }
-
- LOGE("%s: Device is not ready", __func__);
- return -1; /* device is not created or close error*/
-}
-
-int SRP_IsOpen(void)
-{
- if (srp_dev == -1) {
- LOGD("%s: Device is not opened", __func__);
- return 0;
- }
-
- LOGD("%s: Device is opened", __func__);
- return 1;
-}
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/src/srp_api_ctrl.c b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/src/srp_api_ctrl.c
deleted file mode 100644
index bdc2310..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/src/srp_api_ctrl.c
+++ /dev/null
@@ -1,331 +0,0 @@
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <stdio.h>
-
-#include "srp_api_ctrl.h"
-#include "srp_ioctl.h"
-
-#define LOG_TAG "libsrpapi"
-#include <cutils/log.h>
-
-/* Disable LOGD message */
-#ifdef LOGD
-#undef LOGD
-#endif
-#define LOGD(...)
-
-static int srp_ctrl = -1;
-static int srp_ctrl_cnt = 0;
-static short pcm_buf[2048]; /* 4KBytes data, 1K frames (16bit stereo data) */
-
-#ifdef _USE_FW_FROM_DISK_
-static char srp_alt_fw_name_pre[6][32] = {
- "sdcard/rp_fw/rp_fw_code1",
- "sdcard/rp_fw/rp_fw_code20",
- "sdcard/rp_fw/rp_fw_code21",
- "sdcard/rp_fw/rp_fw_code22",
- "sdcard/rp_fw/rp_fw_code30",
- "sdcard/rp_fw/rp_fw_code31",
-};
-#endif
-
-static int SRP_Ctrl_Open(void)
-{
- if (srp_ctrl_cnt == 0) {
- srp_ctrl = open(SRP_CTRL_DEV_NAME, O_RDWR | O_NDELAY);
- if (srp_ctrl < 0) {
- LOGE("%s: Failed open device file %d", __func__, srp_ctrl);
- return -1;
- }
- srp_ctrl_cnt++;
- LOGV("%s: Device is opened[%d]: cnt %d", __func__, srp_ctrl, srp_ctrl_cnt);
- }
-
- return srp_ctrl;
-}
-
-static int SRP_Ctrl_Close(void)
-{
- int ret = 0;
-
- if (srp_ctrl_cnt == 1) {
- ret = close(srp_ctrl);
- if (ret < 0) {
- LOGE("%s: Failed closen device file %d", __func__, srp_ctrl);
- return -1;
- }
- srp_ctrl_cnt--;
- LOGV("%s: Device is closed[%d]: cnt %d", __func__, srp_ctrl, srp_ctrl_cnt);
- srp_ctrl = -1;
- }
-
- return ret;
-}
-
-#ifdef _USE_FW_FROM_DISK_
-/* This will check & download alternate firmware */
-static int SRP_Check_AltFirmware(void)
-{
- unsigned long *temp_buff;
- FILE *fp = NULL;
-
- char alt_fw_name[128];
- unsigned long alt_fw_set;
- unsigned long alt_fw_loaded = 0;
- int alt_fw_text_ok,alt_fw_data_ok;
-
- if ((srp_ctrl = SRP_Ctrl_Open()) >= 0) {
- ioctl(srp_ctrl, SRP_CTRL_ALTFW_STATE, &alt_fw_loaded);
-
- if (!alt_fw_loaded) { /* Not loaded yet? */
- LOGE("Try to download alternate RP firmware");
- temp_buff = (unsigned long *)malloc(256*1024); /* temp buffer */
-
- for (alt_fw_set = 0; alt_fw_set < 6; alt_fw_set++) {
- sprintf(alt_fw_name, "%s_text.bin", srp_alt_fw_name_pre[alt_fw_set]);
- if (fp = fopen(alt_fw_name, "rb")) {
- LOGE("RP Alt-Firmware Loading: %s", alt_fw_name);
- fread(temp_buff, 64*1024, 1, fp);
- close(fp);
- alt_fw_text_ok = 1;
- } else {
- alt_fw_text_ok = 0;
- }
-
- sprintf(alt_fw_name, "%s_data.bin", srp_alt_fw_name_pre[alt_fw_set]);
- if (fp = fopen(alt_fw_name, "rb")) {
- LOGE("RP Alt-Firmware Loading: %s", alt_fw_name);
- fread(&temp_buff[64*1024/4], 96*1024, 1, fp);
- close(fp);
- alt_fw_data_ok = 1;
- } else {
- alt_fw_data_ok = 0;
- }
-
- if (alt_fw_text_ok && alt_fw_data_ok) {
- temp_buff[160*1024/4] = alt_fw_set;
- ioctl(srp_ctrl, SRP_CTRL_ALTFW_LOAD, temp_buff);
- }
- }
- free(temp_buff);
- }
- SRP_Ctrl_Close();
- }
-
- return 0;
-}
-#endif
-
-int SRP_Ctrl_Set_Effect(int effect)
-{
- int ret;
- unsigned long effect_mode = (unsigned long)effect;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_SET_EFFECT, effect_mode);
-
- SRP_Ctrl_Close();
-
- return 0;
-}
-
-int SRP_Ctrl_Enable_Effect(int on)
-{
- int ret;
- unsigned long effect_switch = on ? 1 : 0;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_EFFECT_ENABLE, effect_switch);
-
- SRP_Ctrl_Close();
-
- return 0;
-}
-
-int SRP_Ctrl_Set_Effect_Def(unsigned long effect_def)
-{
- int ret;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_EFFECT_DEF, effect_def);
-
- SRP_Ctrl_Close();
-
- return 0;
-}
-
-int SRP_Ctrl_Set_Effect_EQ_User(unsigned long eq_user)
-{
- int ret;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_EFFECT_EQ_USR, eq_user);
-
- SRP_Ctrl_Close();
-
- return 0;
-}
-
-int SRP_Ctrl_Set_Pcm_Dump(int on)
-{
- int ret;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_PCM_DUMP_OP, on);
-
- LOGV("dump_op: %d", on);
-
- SRP_Ctrl_Close();
-
- return 0;
-}
-
-int SRP_Ctrl_Get_Pcm_Dump_State(void)
-{
- int ret;
- int srp_dump_stat = 0;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_IS_PCM_DUMP, &srp_dump_stat);
-
- LOGV("srp_dump_stat: %d", srp_dump_stat);
-
- SRP_Ctrl_Close();
-
- return srp_dump_stat;
-}
-
-int SRP_Ctrl_Set_Gain(float value)
-{
- int ret;
- unsigned long gain = 0;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- gain = (unsigned long)((1 << 24) * value);
- ioctl(srp_ctrl, SRP_CTRL_SET_GAIN, gain);
-
- SRP_Ctrl_Close();
-
- return 0;
-}
-
-int SRP_Ctrl_Get_Running_Stat(void)
-{
- int ret;
- int srp_running_stat = 0;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_IS_RUNNING, &srp_running_stat);
-
- LOGV("srp_running_stat: %d", srp_running_stat);
-
- SRP_Ctrl_Close();
-
- return srp_running_stat;
-}
-
-int SRP_Ctrl_Get_Open_Stat(void)
-{
- int ret;
- int srp_open_stat = 0;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return -1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_IS_OPENED, &srp_open_stat);
-
- LOGV("srp_open_stat: %d", srp_open_stat);
-
- SRP_Ctrl_Close();
-
- return srp_open_stat;
-}
-
-short *SRP_Ctrl_Get_Pcm(void)
-{
- int ret;
- int rp_is_running = 0;
- int dump_is_on = 0;
- int rp_is_opened = 0;
-
- ret = SRP_Ctrl_Open();
- if (ret < 0) {
- LOGE("%s: SRP_Ctrl_Open error", __func__);
- return NULL;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_IS_RUNNING, &rp_is_running);
- if (rp_is_running) {
- ioctl(srp_ctrl, SRP_CTRL_IS_PCM_DUMP, &dump_is_on);
- if (dump_is_on == 0) {
- ioctl(srp_ctrl, SRP_CTRL_PCM_DUMP_OP, 1);
- dump_is_on = 1;
- }
-
- ioctl(srp_ctrl, SRP_CTRL_GET_PCM_1KFRAME, pcm_buf);
- return pcm_buf;
- }
-
- /* SRP is not running */
- if (srp_ctrl > 0) {
- if (dump_is_on) {
- ioctl(srp_ctrl, SRP_CTRL_IS_OPENED, &rp_is_opened);
- if (rp_is_opened)
- ioctl(srp_ctrl, SRP_CTRL_PCM_DUMP_OP, 0);
- }
- SRP_Ctrl_Close();
- }
-
- return NULL;
-}
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/Android.mk b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/Android.mk
deleted file mode 100644
index 4b113e7..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/Android.mk
+++ /dev/null
@@ -1,9 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_AUDIO_PATH :=$(LOCAL_PATH)
-
-ifeq ($(BOARD_USE_ALP_AUDIO), true)
- include $(LOCAL_AUDIO_PATH)/srp/alp/Android.mk
-endif
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/Android.mk b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/Android.mk
deleted file mode 100644
index 7393f68..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/Android.mk
+++ /dev/null
@@ -1,26 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_COPY_HEADERS_TO := libsecmm
-LOCAL_COPY_HEADERS := \
- include/srp_api.h \
- include/srp_ioctl.h \
- include/srp_error.h
-
-LOCAL_SRC_FILES := \
- src/srp_api.c
-
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/include
-
-LOCAL_MODULE := libsrpapi
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES :=
-
-LOCAL_SHARED_LIBRARIES :=
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_api.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_api.h
deleted file mode 100644
index ad65b90..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_api.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef __SRP_API_H__
-#define __SRP_API_H__
-
-#include "srp_ioctl.h"
-#include "srp_error.h"
-
-#define SRP_DEV_NAME "dev/srp"
-
-#define SRP_INIT_BLOCK_MODE 0
-#define SRP_INIT_NONBLOCK_MODE 1
-
-#define SRP_PENDING_STATE_RUNNING 0
-#define SRP_PENDING_STATE_PENDING 1
-
-struct srp_buf_info {
- void *mmapped_addr;
- void *addr;
- unsigned int mmapped_size;
- unsigned int size;
- int num;
-};
-
-struct srp_dec_info {
- unsigned int sample_rate;
- unsigned int channels;
-};
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int SRP_Create(int block_mode);
-int SRP_Init();
-int SRP_Decode(void *buff, int size_byte);
-int SRP_Send_EOS(void);
-int SRP_SetParams(int id, unsigned long val);
-int SRP_GetParams(int id, unsigned long *pval);
-int SRP_Deinit(void);
-int SRP_Terminate(void);
-int SRP_IsOpen(void);
-
-int SRP_Get_Ibuf_Info(void **addr, unsigned int *size, unsigned int *num);
-int SRP_Get_Obuf_Info(void **addr, unsigned int *size, unsigned int *num);
-int SRP_Get_Dec_Info(struct srp_dec_info *dec_info);
-int SRP_Get_PCM(void **addr, unsigned int *size);
-int SRP_Flush(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*__SRP_API_H__ */
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_error.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_error.h
deleted file mode 100644
index 7f79452..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_error.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef _SRP_ERROR_H_
-#define _SRP_ERROR_H_
-
-typedef enum {
- SRP_RETURN_OK = 0,
-
- SRP_ERROR_OPEN_FAIL = -1000,
- SRP_ERROR_ALREADY_OPEN = -1001,
- SRP_ERROR_NOT_READY = -1002,
-
- SRP_ERROR_IBUF_OVERFLOW = -2000,
- SRP_ERROR_IBUF_INFO = -2001,
-
- SRP_ERROR_OBUF_READ = -3000,
- SRP_ERROR_OBUF_INFO = -3001,
- SRP_ERROR_OBUF_MMAP = -3002,
-
- SRP_ERROR_INVALID_SETTING = -4000,
- SRP_ERROR_GETINFO_FAIL = -4001
-} SRP_ERRORTYPE;
-
-#endif /* _SRP_ERROR_H_ */
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_ioctl.h b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_ioctl.h
deleted file mode 100644
index 21d55df..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_ioctl.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef __SRP_IOCTL_H__
-#define __SRP_IOCTL_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define SRP_INIT (0x10000)
-#define SRP_DEINIT (0x10001)
-#define SRP_GET_MMAP_SIZE (0x10002)
-#define SRP_FLUSH (0x20002)
-#define SRP_SEND_EOS (0x20005)
-#define SRP_GET_IBUF_INFO (0x20007)
-#define SRP_GET_OBUF_INFO (0x20008)
-#define SRP_STOP_EOS_STATE (0x30007)
-#define SRP_GET_DEC_INFO (0x30008)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __SRP_IOCTL_H__ */
-
diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/src/srp_api.c b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/src/srp_api.c
deleted file mode 100644
index 56125fb..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/src/srp_api.c
+++ /dev/null
@@ -1,265 +0,0 @@
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <stdio.h>
-
-#include "srp_api.h"
-
-#define LOG_NDEBUG 1
-#define LOG_TAG "libsrpapi"
-#include <utils/Log.h>
-
-static struct srp_buf_info ibuf_info;
-static struct srp_buf_info obuf_info;
-static struct srp_buf_info pcm_info;
-
-static int srp_dev = -1;
-static int srp_block_mode = SRP_INIT_BLOCK_MODE;
-
-int SRP_Create(int block_mode)
-{
- if (srp_dev == -1) {
- srp_block_mode = block_mode;
- srp_dev = open(SRP_DEV_NAME, O_RDWR |
- ((block_mode == SRP_INIT_NONBLOCK_MODE) ? O_NDELAY : 0));
- if (srp_dev > 0)
- return srp_dev;
- else
- return SRP_ERROR_OPEN_FAIL;
- }
-
- LOGE("%s: Device is already opened", __func__);
- return SRP_ERROR_ALREADY_OPEN;
-}
-
-int SRP_Init()
-{
- int ret = SRP_RETURN_OK;
- unsigned int mmapped_size = 0;
-
- if (srp_dev != -1) {
- ret = ioctl(srp_dev, SRP_INIT);
- if (ret < 0)
- return ret;
-
- /* mmap for OBUF */
- ret = ioctl(srp_dev, SRP_GET_MMAP_SIZE, &mmapped_size);
- if (ret < 0) {
- LOGE("%s: SRP_GET_MMAP_SIZE is failed", __func__);
- return SRP_ERROR_OBUF_MMAP;
- }
- obuf_info.mmapped_addr = mmap(0, mmapped_size,
- PROT_READ | PROT_WRITE, MAP_SHARED, srp_dev, 0);
- if (!obuf_info.mmapped_addr) {
- LOGE("%s: mmap is failed", __func__);
- return SRP_ERROR_OBUF_MMAP;
- }
- obuf_info.mmapped_size = mmapped_size;
-
- ret = SRP_RETURN_OK;
- } else {
- LOGE("%s: Device is not ready", __func__);
- ret = SRP_ERROR_NOT_READY; /* device is not created */
- }
-
- return ret;
-}
-
-int SRP_Decode(void *buff, int size_byte)
-{
- int ret = SRP_RETURN_OK;
-
- if (srp_dev != -1) {
- if (size_byte > 0) {
- LOGV("%s: Send data to RP (%d bytes)", __func__, size_byte);
-
- ret = write(srp_dev, buff, size_byte); /* Write Buffer to RP Driver */
- if (ret < 0) {
- if (ret != SRP_ERROR_IBUF_OVERFLOW)
- LOGE("SRP_Decode returned error code: %d", ret);
- }
- return ret; /* Write Success */
- } else {
- return ret;
- }
- }
-
- LOGE("%s: Device is not ready", __func__);
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_Send_EOS(void)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, SRP_SEND_EOS);
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_SetParams(int id, unsigned long val)
-{
- if (srp_dev != -1)
- return 0; /* not yet */
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_GetParams(int id, unsigned long *pval)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, id, pval);
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_Flush(void)
-{
- if (srp_dev != -1)
- return ioctl(srp_dev, SRP_FLUSH);
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_Get_PCM(void **addr, unsigned int *size)
-{
- int ret = SRP_RETURN_OK;
-
- if (srp_dev != -1) {
- ret = read(srp_dev, &pcm_info, 0);
- if (ret == -1) {
- *size = 0;
- LOGE("%s: PCM read fail", __func__);
- return SRP_ERROR_OBUF_READ;
- }
-
- *addr = pcm_info.addr;
- *size = pcm_info.size;
- } else {
- return SRP_ERROR_NOT_READY;
- }
-
- return ret; /* Read Success */
-}
-
-int SRP_Get_Dec_Info(struct srp_dec_info *dec_info)
-{
- int ret;
-
- if (srp_dev != -1) {
- ret = ioctl(srp_dev, SRP_GET_DEC_INFO, dec_info);
- if (ret < 0) {
- LOGE("%s: Failed to get dec info", __func__);
- return SRP_ERROR_GETINFO_FAIL;
- }
-
- LOGV("numChannels(%d), samplingRate(%d)", dec_info->channels, dec_info->sample_rate);
-
- ret = SRP_RETURN_OK;
- } else {
- ret = SRP_ERROR_NOT_READY;
- }
-
- return ret;
-}
-
-int SRP_Get_Ibuf_Info(void **addr, unsigned int *size, unsigned int *num)
-{
- int ret = SRP_RETURN_OK;
-
- if (srp_dev != -1) {
- ret = ioctl(srp_dev, SRP_GET_IBUF_INFO, &ibuf_info);
- if (ret == -1) {
- LOGE("%s: Failed to get Ibuf info", __func__);
- return SRP_ERROR_IBUF_INFO;
- }
-
- *addr = ibuf_info.addr;
- *size = ibuf_info.size;
- *num = ibuf_info.num;
-
- if (*num == 0) {
- LOGE("%s: IBUF num is 0", __func__);
- return SRP_ERROR_INVALID_SETTING;
- }
-
- ret = SRP_RETURN_OK;
- } else {
- ret = SRP_ERROR_NOT_READY;
- }
-
- return ret;
-}
-
-int SRP_Get_Obuf_Info(void **addr, unsigned int *size, unsigned int *num)
-{
- int ret = SRP_RETURN_OK;
-
- if (srp_dev != -1) {
- if (obuf_info.addr == NULL) {
- ret = ioctl(srp_dev, SRP_GET_OBUF_INFO, &obuf_info);
- if (ret < 0) {
- LOGE("%s: SRP_GET_OBUF_INFO is failed", __func__);
- return SRP_ERROR_OBUF_INFO;
- }
- }
-
- *addr = obuf_info.addr;
- *size = obuf_info.size;
- *num = obuf_info.num;
-
- if (*num == 0) {
- LOGE("%s: OBUF num is 0", __func__);
- return SRP_ERROR_INVALID_SETTING;
- }
-
- ret = SRP_RETURN_OK;
- } else {
- ret = SRP_ERROR_NOT_READY;
- }
-
- return ret;
-}
-
-int SRP_Deinit(void)
-{
- if (srp_dev != -1) {
- munmap(obuf_info.mmapped_addr, obuf_info.mmapped_size);
- return ioctl(srp_dev, SRP_DEINIT);
- }
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_Terminate(void)
-{
- int ret;
-
- if (srp_dev != -1) {
- ret = close(srp_dev);
-
- if (ret == 0) {
- srp_dev = -1; /* device closed */
- return SRP_RETURN_OK;
- }
- }
-
- return SRP_ERROR_NOT_READY;
-}
-
-int SRP_IsOpen(void)
-{
- if (srp_dev == -1) {
- LOGV("%s: Device is not opened", __func__);
- return 0;
- }
-
- LOGV("%s: Device is opened", __func__);
- return 1;
-}
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/Android.mk b/exynos4/multimedia/codecs/sec_codecs/video/Android.mk
deleted file mode 100644
index 3bc3577..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/Android.mk
+++ /dev/null
@@ -1,11 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
-include $(LOCAL_PATH)/exynos4/Android.mk
-endif
-
-ifeq ($(filter-out exynos5,$(TARGET_BOARD_PLATFORM)),)
-include $(LOCAL_PATH)/exynos5/Android.mk
-endif
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/Android.mk b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/Android.mk
deleted file mode 100644
index 1a8c419..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/Android.mk
+++ /dev/null
@@ -1,11 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_VIDEO_PATH :=$(LOCAL_PATH)
-
-ifeq ($(BOARD_USE_V4L2), true)
-include $(LOCAL_VIDEO_PATH)/mfc_v4l2/Android.mk
-else
-include $(LOCAL_VIDEO_PATH)/mfc/Android.mk
-endif
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/Android.mk b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/Android.mk
deleted file mode 100644
index b23f603..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/Android.mk
+++ /dev/null
@@ -1,38 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_COPY_HEADERS_TO := libsecmm
-LOCAL_COPY_HEADERS := \
- include/mfc_errno.h \
- include/mfc_interface.h \
- include/SsbSipMfcApi.h
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- dec/src/SsbSipMfcDecAPI.c \
- enc/src/SsbSipMfcEncAPI.c
-
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/include/
-
-LOCAL_MODULE := libsecmfcapi
-
-LOCAL_PRELINK_MODULE := false
-
-ifeq ($(BOARD_USES_MFC_FPS),true)
-LOCAL_CFLAGS := -DCONFIG_MFC_FPS
-#LOCAL_CFLAGS += -DCONFIG_MFC_PERF_LOG
-endif
-
-ifeq ($(BOARD_USE_S3D_SUPPORT), true)
-LOCAL_CFLAGS += -DS3D_SUPPORT
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES :=
-LOCAL_SHARED_LIBRARIES := liblog
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/dec/src/SsbSipMfcDecAPI.c b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/dec/src/SsbSipMfcDecAPI.c
deleted file mode 100644
index 5cc7c88..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/dec/src/SsbSipMfcDecAPI.c
+++ /dev/null
@@ -1,1165 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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.
- */
-
-#include <stdio.h>
-#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 "mfc_interface.h"
-#include "SsbSipMfcApi.h"
-
-#include <utils/Log.h>
-/*#define LOG_NDEBUG 0*/
-#undef LOG_TAG
-#define LOG_TAG "MFC_DEC_APP"
-
-#ifdef CONFIG_MFC_FPS
-#include <sys/time.h>
-#endif
-
-#define _MFCLIB_MAGIC_NUMBER 0x92241000
-
-#define USR_DATA_START_CODE (0x000001B2)
-#define VOP_START_CODE (0x000001B6)
-#define MP4_START_CODE (0x000001)
-
-#ifdef CONFIG_MFC_FPS
-unsigned int framecount, over30ms;
-struct timeval mDec1, mDec2, mAvg;
-#endif
-
-static char *mfc_dev_name = SAMSUNG_MFC_DEV_NAME;
-
-static void getAByte(char *buff, int *code)
-{
- int byte;
-
- *code = (*code << 8);
- byte = (int)*buff;
- byte &= 0xFF;
- *code |= byte;
-}
-
-static int isPBPacked(_MFCLIB *pCtx, int Frameleng)
-{
- char *strmBuffer = NULL;
- int startCode = 0xFFFFFFFF;
- int leng_idx = 1;
-
- strmBuffer = (char*)pCtx->virStrmBuf;
-
- while (1) {
- while (startCode != USR_DATA_START_CODE) {
- if ((startCode == VOP_START_CODE) || (leng_idx == Frameleng)) {
- LOGI("isPBPacked] VOP START Found !!.....return");
- LOGW("isPBPacked] Non Packed PB");
- return 0;
- }
- getAByte(strmBuffer, &startCode);
- LOGV(">> StartCode = 0x%08x <<\n", startCode);
- strmBuffer++;
- leng_idx++;
- }
- LOGI("isPBPacked] User Data Found !!");
-
- do {
- if (*strmBuffer == 'p') {
- /*LOGI(">> peter strmBuffer = 0x%08x <<\n", *strmBuffer);*/
- LOGW("isPBPacked] Packed PB\n");
- return 1;
- }
- getAByte(strmBuffer, &startCode);
- strmBuffer++; leng_idx++;
- } while ((leng_idx <= Frameleng) && ((startCode >> 8) != MP4_START_CODE));
-
- if (leng_idx > Frameleng)
- break;
- }
-
- LOGW("isPBPacked] Non Packed PB");
-
- return 0;
-}
-
-void SsbSipMfcDecSetMFCName(char *devicename)
-{
- mfc_dev_name = devicename;
-}
-
-void *SsbSipMfcDecOpen(void)
-{
- int hMFCOpen;
- unsigned int mapped_addr;
- _MFCLIB *pCTX = NULL;
- int mapped_size;
- struct mfc_common_args CommonArg;
-
- LOGI("[%s] MFC Library Ver %d.%02d\n",__func__, MFC_LIB_VER_MAJOR, MFC_LIB_VER_MINOR);
-#ifdef CONFIG_MFC_FPS
- framecount = 0;
- over30ms = 0;
- mAvg.tv_sec = 0;
- mAvg.tv_usec = 0;
-#endif
- pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
- if (pCTX == NULL) {
- LOGE("SsbSipMfcDecOpen] malloc failed.\n");
- return NULL;
- }
- memset(pCTX, 0, sizeof(_MFCLIB));
-
- if (access(mfc_dev_name, F_OK) != 0) {
- LOGE("SsbSipMfcDecOpen] MFC device node not exists");
- free(pCTX);
- return NULL;
- }
-
- hMFCOpen = open(mfc_dev_name, O_RDWR | O_NDELAY);
- if (hMFCOpen < 0) {
- LOGE("SsbSipMfcDecOpen] MFC Open failure");
- free(pCTX);
- return NULL;
- }
-
- mapped_size = ioctl(hMFCOpen, IOCTL_MFC_GET_MMAP_SIZE, &CommonArg);
- if ((mapped_size < 0) || (CommonArg.ret_code != MFC_OK)) {
- LOGE("SsbSipMfcDecOpen] IOCTL_MFC_GET_MMAP_SIZE failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- mapped_addr = (unsigned int)mmap(0, mapped_size, PROT_READ | PROT_WRITE, MAP_SHARED, hMFCOpen, 0);
- if (!mapped_addr) {
- LOGE("SsbSipMfcDecOpen] FIMV5.x driver address mapping failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- pCTX->magic = _MFCLIB_MAGIC_NUMBER;
- pCTX->hMFC = hMFCOpen;
- pCTX->mapped_addr = mapped_addr;
- pCTX->mapped_size = mapped_size;
- pCTX->inter_buff_status = MFC_USE_NONE;
-
- return (void *)pCTX;
-}
-
-void *SsbSipMfcDecOpenExt(void *value)
-{
- int hMFCOpen;
- unsigned int mapped_addr;
- _MFCLIB *pCTX = NULL;
- int mapped_size;
- int err;
- struct mfc_common_args CommonArg;
-
- LOGI("[%s] MFC Library Ver %d.%02d\n",__func__, MFC_LIB_VER_MAJOR, MFC_LIB_VER_MINOR);
-
- pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
- if (pCTX == NULL) {
- LOGE("SsbSipMfcDecOpenExt] malloc failed.\n");
- return NULL;
- }
- memset(pCTX, 0, sizeof(_MFCLIB));
-
- if (access(mfc_dev_name, F_OK) != 0) {
- LOGE("SsbSipMfcDecOpen] MFC device node not exists");
- free(pCTX);
- return NULL;
- }
-
- hMFCOpen = open(mfc_dev_name, O_RDWR | O_NDELAY);
- if (hMFCOpen < 0) {
- LOGE("SsbSipMfcDecOpenExt] MFC Open failure");
- free(pCTX);
- return NULL;
- }
-
- CommonArg.args.mem_alloc.buf_cache_type = *(SSBIP_MFC_BUFFER_TYPE *)value;
-
- err = ioctl(hMFCOpen, IOCTL_MFC_SET_BUF_CACHE, &CommonArg);
- if ((err < 0) || (CommonArg.ret_code != MFC_OK)) {
- LOGE("SsbSipMfcDecOpenExt] IOCTL_MFC_SET_BUF_CACHE failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- mapped_size = ioctl(hMFCOpen, IOCTL_MFC_GET_MMAP_SIZE, &CommonArg);
- if ((mapped_size < 0) || (CommonArg.ret_code != MFC_OK)) {
- LOGE("SsbSipMfcDecOpenExt] IOCTL_MFC_GET_MMAP_SIZE failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- mapped_addr = (unsigned int)mmap(0, mapped_size, PROT_READ | PROT_WRITE, MAP_SHARED, hMFCOpen, 0);
- if (!mapped_addr) {
- LOGE("SsbSipMfcDecOpenExt] FIMV5.x driver address mapping failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- pCTX->magic = _MFCLIB_MAGIC_NUMBER;
- pCTX->hMFC = hMFCOpen;
- pCTX->mapped_addr = mapped_addr;
- pCTX->mapped_size = mapped_size;
- 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 r;
- int packedPB = 0;
- struct mfc_common_args DecArg;
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecInit] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *)openHandle;
- memset(&DecArg, 0x00, sizeof(DecArg));
-
- if ((codec_type != MPEG4_DEC) &&
- (codec_type != H264_DEC) &&
- (codec_type != H263_DEC) &&
- (codec_type != MPEG1_DEC) &&
- (codec_type != MPEG2_DEC) &&
- (codec_type != FIMV1_DEC) &&
- (codec_type != FIMV2_DEC) &&
- (codec_type != FIMV3_DEC) &&
- (codec_type != FIMV4_DEC) &&
- (codec_type != XVID_DEC) &&
- (codec_type != VC1RCV_DEC) &&
- (codec_type != VC1_DEC)) {
- LOGE("SsbSipMfcDecInit] Undefined codec type");
- return MFC_RET_INVALID_PARAM;
- }
- pCTX->codecType = codec_type;
-
- if ((pCTX->codecType == MPEG4_DEC) ||
- (pCTX->codecType == XVID_DEC) ||
- (pCTX->codecType == FIMV1_DEC) ||
- (pCTX->codecType == FIMV2_DEC) ||
- (pCTX->codecType == FIMV3_DEC) ||
- (pCTX->codecType == FIMV4_DEC))
- packedPB = isPBPacked(pCTX, Frameleng);
-
- /* init args */
- DecArg.args.dec_init.in_codec_type = pCTX->codecType;
- DecArg.args.dec_init.in_strm_size = Frameleng;
- DecArg.args.dec_init.in_strm_buf = pCTX->phyStrmBuf;
-
- DecArg.args.dec_init.in_numextradpb = pCTX->dec_numextradpb;
- DecArg.args.dec_init.in_slice= pCTX->dec_slice;
- DecArg.args.dec_init.in_crc = pCTX->dec_crc;
- DecArg.args.dec_init.in_pixelcache = pCTX->dec_pixelcache;
-
- DecArg.args.dec_init.in_packed_PB = packedPB;
-
- /* mem alloc args */
- DecArg.args.dec_init.in_mapped_addr = pCTX->mapped_addr;
-
- /* get pyhs addr args */
- /* no needs */
-
- /* sequence start args */
- /* no needs */
-
- r = ioctl(pCTX->hMFC, IOCTL_MFC_DEC_INIT, &DecArg);
- if (DecArg.ret_code != MFC_OK) {
- LOGE("SsbSipMfcDecInit] IOCTL_MFC_DEC_INIT failed");
- return MFC_RET_DEC_INIT_FAIL;
- }
-
- pCTX->decOutInfo.img_width = DecArg.args.dec_init.out_frm_width;
- pCTX->decOutInfo.img_height = DecArg.args.dec_init.out_frm_height;
- pCTX->decOutInfo.buf_width = DecArg.args.dec_init.out_buf_width;
- pCTX->decOutInfo.buf_height = DecArg.args.dec_init.out_buf_height;
-
- 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;
- int Yoffset;
- int Coffset;
- _MFCLIB *pCTX;
- struct mfc_common_args DecArg;
-
-#ifdef CONFIG_MFC_FPS
- long int diffTime, avgTime;
-#endif
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecExe] openHandle is NULL\n");
- return MFC_RET_INVALID_PARAM;
- }
-
- if ((lengthBufFill < 0) || (lengthBufFill > MAX_DECODER_INPUT_BUFFER_SIZE)) {
- LOGE("SsbSipMfcDecExe] lengthBufFill is invalid. (lengthBufFill=%d)", lengthBufFill);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
- memset(&DecArg, 0x00, sizeof(DecArg));
-
- DecArg.args.dec_exe.in_codec_type = pCTX->codecType;
- 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->inframetag;
- DecArg.args.dec_exe.in_immediately_disp = pCTX->immediatelydisp;
-
-#ifdef CONFIG_MFC_FPS
- gettimeofday(&mDec1, NULL);
-
-#ifdef CONFIG_MFC_PERF_LOG
- if (framecount != 0) {
- if (mDec2.tv_sec == mDec1.tv_sec)
- LOGI("SsbSipMfcDecExe] Interval between IOCTL_MFC_DEC_EXE's (end to start) = %8d", (mDec1.tv_usec - mDec2.tv_usec));
- else
- LOGI("SsbSipMfcDecExe] Interval between IOCTL_MFC_DEC_EXE's (end to start) = %8d", (1000000 + (mDec1.tv_usec - mDec2.tv_usec)));
- }
-#endif
-#endif
-
- ret = ioctl(pCTX->hMFC, IOCTL_MFC_DEC_EXE, &DecArg);
-
- if (DecArg.ret_code != MFC_OK) {
- LOGE("SsbSipMfcDecExe] IOCTL_MFC_DEC_EXE failed(ret : %d)", DecArg.ret_code);
- return MFC_RET_DEC_EXE_ERR;
- }
-
-#ifdef CONFIG_MFC_FPS
- gettimeofday(&mDec2, NULL);
- framecount++;
-
- if (mDec1.tv_sec == mDec2.tv_sec) {
- if (mDec2.tv_usec - mDec1.tv_usec > 30000)
- over30ms++;
-#ifdef CONFIG_MFC_PERF_LOG
- LOGI("SsbSipMfcDecExe] Time consumed for IOCTL_MFC_DEC_EXE = %8d", ((mDec2.tv_usec - mDec1.tv_usec)));
-#endif
- } else {
- if (1000000 + mDec2.tv_usec - mDec1.tv_usec > 30000)
- over30ms++;
-#ifdef CONFIG_MFC_PERF_LOG
- LOGI("SsbSipMfcDecExe] Time consumed for IOCTL_MFC_DEC_EXE = %8d", (1000000 + (mDec2.tv_usec - mDec1.tv_usec)));
-#endif
- }
-
- diffTime = ((mDec2.tv_sec * 1000000) + mDec2.tv_usec) - ((mDec1.tv_sec * 1000000) + mDec1.tv_usec);
- avgTime = (mAvg.tv_sec * 1000000) + mAvg.tv_usec;
- avgTime = ((framecount - 1) * avgTime + diffTime) / framecount;
-
- mAvg.tv_sec = avgTime / 1000000;
- mAvg.tv_usec = avgTime % 1000000;
-#endif
-
- /* FIXME: dynamic resolution change */
- if (DecArg.args.dec_exe.out_display_status == 4) {
- LOGI("SsbSipMfcDecExe] Resolution is chagned");
- /*
- pCTX->virFrmBuf.chroma = DecArg.args.dec_exe.out_u_addr.chroma;
- pCTX->virFrmBuf.luma = DecArg.args.dec_exe.out_u_addr.luma;
- pCTX->phyFrmBuf.chroma = DecArg.args.dec_exe.out_p_addr.chroma;
- pCTX->phyFrmBuf.luma = DecArg.args.dec_exe.out_p_addr.luma;
- pCTX->sizeFrmBuf.chroma = DecArg.args.dec_exe.out_frame_buf_size.chroma;
- pCTX->sizeFrmBuf.luma = DecArg.args.dec_exe.out_frame_buf_size.luma;
- */
- pCTX->decOutInfo.img_width = DecArg.args.dec_exe.out_img_width;
- pCTX->decOutInfo.img_height = DecArg.args.dec_exe.out_img_height;
- pCTX->decOutInfo.buf_width = DecArg.args.dec_exe.out_buf_width;
- pCTX->decOutInfo.buf_height = DecArg.args.dec_exe.out_buf_height;
- }
-
- 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);
-
- /* for new driver */
- pCTX->decOutInfo.YVirAddr = (void*)(pCTX->mapped_addr + DecArg.args.dec_exe.out_y_offset);
- pCTX->decOutInfo.CVirAddr = (void*)(pCTX->mapped_addr + DecArg.args.dec_exe.out_c_offset);
-
- pCTX->displayStatus = DecArg.args.dec_exe.out_display_status;
-
- pCTX->decOutInfo.disp_pic_frame_type = DecArg.args.dec_exe.out_disp_pic_frame_type;
-
- /* clear immediately display flag */
- pCTX->immediatelydisp = 0;
- pCTX->outframetagtop = DecArg.args.dec_exe.out_frametag_top;
- pCTX->outframetagbottom = DecArg.args.dec_exe.out_frametag_bottom;
- pCTX->decOutInfo.timestamp_top = DecArg.args.dec_exe.out_pic_time_top;
- pCTX->decOutInfo.timestamp_bottom = DecArg.args.dec_exe.out_pic_time_bottom;
- pCTX->decOutInfo.consumedByte = DecArg.args.dec_exe.out_consumed_byte;
-
- pCTX->decOutInfo.crop_right_offset = DecArg.args.dec_exe.out_crop_right_offset;
- pCTX->decOutInfo.crop_left_offset = DecArg.args.dec_exe.out_crop_left_offset;
- pCTX->decOutInfo.crop_bottom_offset = DecArg.args.dec_exe.out_crop_bottom_offset;
- pCTX->decOutInfo.crop_top_offset = DecArg.args.dec_exe.out_crop_top_offset;
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecClose(void *openHandle)
-{
- int ret;
- _MFCLIB *pCTX;
- struct mfc_common_args free_arg;
-
-#ifdef CONFIG_MFC_FPS
- LOGI(">>> Statistics in MFC API:");
- LOGI(">>> Total number of IOCTL_MFC_DEC_EXE = %d", framecount);
- LOGI(">>> Number of IOCTL_MFC_DEC_EXE taking more than 30ms = %d", over30ms);
- LOGI(">>> Avg IOCTL_MFC_DEC_EXE time = %dsec %.2fmsec", (int)mAvg.tv_sec, (float)(mAvg.tv_usec / 1000.0));
-#endif
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecClose] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- /* FIXME: free buffer? */
-#if 0
- if (pCTX->inter_buff_status & MFC_USE_YUV_BUFF) {
- free_arg.args.mem_free.key = pCTX->virFrmBuf.luma;
- ret = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
- free_arg.args.mem_free.key = pCTX->virFrmBuf.chroma;
- ret = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
- }
-#endif
-
- if (pCTX->inter_buff_status & MFC_USE_STRM_BUFF) {
- free_arg.args.mem_free.key = pCTX->virStrmBuf;
- ret = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
- }
-
- pCTX->inter_buff_status = MFC_USE_NONE;
-
- munmap((void *)pCTX->mapped_addr, pCTX->mapped_size);
- close(pCTX->hMFC);
- free(pCTX);
-
- return MFC_RET_OK;
-}
-
-
-void *SsbSipMfcDecGetInBuf(void *openHandle, void **phyInBuf, int inputBufferSize)
-{
- int ret_code;
- _MFCLIB *pCTX;
- struct mfc_common_args user_addr_arg, phys_addr_arg;
-
- if (inputBufferSize < 0) {
- LOGE("SsbSipMfcDecGetInBuf] inputBufferSize = %d is invalid", inputBufferSize);
- return NULL;
- }
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecGetInBuf] openHandle is NULL\n");
- return NULL;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- /*user_addr_arg.args.mem_alloc.codec_type = pCTX->codec_type; */
- user_addr_arg.args.mem_alloc.type = DECODER;
- user_addr_arg.args.mem_alloc.buff_size = inputBufferSize;
- user_addr_arg.args.mem_alloc.mapped_addr = pCTX->mapped_addr;
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_IN_BUF, &user_addr_arg);
- if (ret_code < 0) {
- LOGE("SsbSipMfcDecGetInBuf] IOCTL_MFC_GET_IN_BUF failed");
- return NULL;
- }
-
- phys_addr_arg.args.real_addr.key = user_addr_arg.args.mem_alloc.offset;
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_REAL_ADDR, &phys_addr_arg);
- if (ret_code < 0) {
- LOGE("SsbSipMfcDecGetInBuf] IOCTL_MFC_GET_PHYS_ADDR failed");
- return NULL;
- }
-
- /*
- pCTX->virStrmBuf = user_addr_arg.args.mem_alloc.offset;
- */
- pCTX->virStrmBuf = pCTX->mapped_addr + user_addr_arg.args.mem_alloc.offset;
- pCTX->phyStrmBuf = phys_addr_arg.args.real_addr.addr;
-
- 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 size)
-{
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecSetInBuf] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- pCTX->phyStrmBuf = (int)phyInBuf;
- pCTX->virStrmBuf = (int)virInBuf;
- pCTX->sizeStrmBuf = size;
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecGetOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info)
-{
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecGetOutBuf] openHandle is NULL");
- 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;
-
- output_info->timestamp_top = pCTX->decOutInfo.timestamp_top;
- output_info->timestamp_bottom = pCTX->decOutInfo.timestamp_bottom;
- output_info->consumedByte = pCTX->decOutInfo.consumedByte;
-
- output_info->crop_right_offset = pCTX->decOutInfo.crop_right_offset;
- output_info->crop_left_offset = pCTX->decOutInfo.crop_left_offset;
- output_info->crop_bottom_offset = pCTX->decOutInfo.crop_bottom_offset;
- output_info->crop_top_offset = pCTX->decOutInfo.crop_top_offset;
-
- output_info->disp_pic_frame_type = pCTX->decOutInfo.disp_pic_frame_type;
-
- if (pCTX->displayStatus == 3)
- 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 if (pCTX->displayStatus == 0)
- return MFC_GETOUTBUF_DECODING_ONLY;
- else if (pCTX->displayStatus == 4)
- return MFC_GETOUTBUF_CHANGE_RESOL;
- else
- return MFC_GETOUTBUF_DISPLAY_END;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetConfig(void *openHandle, SSBSIP_MFC_DEC_CONF conf_type, void *value)
-{
- int ret_code;
- _MFCLIB *pCTX;
- struct mfc_common_args DecArg;
- struct mfc_dec_fimv1_info *fimv1_res;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecSetConfig] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("SsbSipMfcDecSetConfig] value is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *)openHandle;
- memset(&DecArg, 0x00, sizeof(DecArg));
-#ifdef S3D_SUPPORT
- DecArg.args.config.type = conf_type;
-#else
- DecArg.args.set_config.in_config_param = conf_type;
-#endif
- switch (conf_type) {
- case MFC_DEC_SETCONF_EXTRA_BUFFER_NUM:
- pCTX->dec_numextradpb = *((unsigned int *) value);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_SLICE_ENABLE:
- pCTX->dec_slice = *((unsigned int *) value);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_CRC_ENABLE:
- pCTX->dec_crc = *((unsigned int *) value);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_PIXEL_CACHE:
- pCTX->dec_pixelcache = *((unsigned int *) value);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_FRAME_TAG: /* be set before calling SsbSipMfcDecExe */
- pCTX->inframetag = *((unsigned int *) value);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_IMMEDIATELY_DISPLAY: /* be set before calling SsbSipMfcDecExe */
- pCTX->immediatelydisp = *((unsigned int *) value);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_FIMV1_WIDTH_HEIGHT:
- fimv1_res = (struct mfc_dec_fimv1_info *)value;
- LOGI("fimv1->width = %d\n", fimv1_res->width);
- LOGI("fimv1->height = %d\n", fimv1_res->height);
-#ifdef S3D_SUPPORT
- DecArg.args.config.args.basic.values[0] = (int)(fimv1_res->width);
- DecArg.args.config.args.basic.values[1] = (int)(fimv1_res->height);
-#else
- DecArg.args.set_config.in_config_value[0] = (int)(fimv1_res->width);
- DecArg.args.set_config.in_config_value[1] = (int)(fimv1_res->height);
-#endif
- break;
- case MFC_DEC_SETCONF_IS_LAST_FRAME:
- case MFC_DEC_SETCONF_DPB_FLUSH:
-#ifdef S3D_SUPPORT
- case MFC_DEC_SETCONF_SEI_PARSE:
- default:
- DecArg.args.config.args.basic.values[0] = *((int *) value);
- DecArg.args.config.args.basic.values[1] = 0;
-#else
- default:
- DecArg.args.set_config.in_config_value[0] = *((unsigned int *) value);
- DecArg.args.set_config.in_config_value[1] = 0;
-#endif
- break;
- }
-
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_SET_CONFIG, &DecArg);
- if (DecArg.ret_code != MFC_OK) {
- LOGE("SsbSipMfcDecSetConfig] IOCTL_MFC_SET_CONFIG failed(ret : %d, conf_type: 0x%08x)", 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;
- struct mfc_common_args DecArg;
-
- /*
- s3c_mfc_common_args phys_addr_arg;
- SSBSIP_MFC_BUFFER_ADDR *buf_addr;
- */
-
- SSBSIP_MFC_IMG_RESOLUTION *img_resolution;
- SSBSIP_MFC_CRC_DATA *crc_data;
- SSBSIP_MFC_CROP_INFORMATION *crop_information;
-#ifdef S3D_SUPPORT
- SSBSIP_MFC_FRAME_PACKING *frame_packing;
-#endif
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecGetConfig] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("SsbSipMfcDecGetConfig] value is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- switch (conf_type) {
-#if 0
- case MFC_DEC_GETCONF_PHYS_ADDR:
- buf_addr = (SSBSIP_MFC_BUFFER_ADDR *)value;
- phys_addr_arg.args.get_phys_addr.u_addr = buf_addr->u_addr;
- r = ioctl(pCTX->hMFC, IOCTL_MFC_GET_PHYS_ADDR, &phys_addr_arg);
- if (r < 0) {
- LOGE("SsbSipMfcDecGetConfig] IOCTL_MFC_GET_PHYS_ADDR failed");
- return MFC_API_FAIL;
- }
- buf_addr->p_addr = phys_addr_arg.args.get_phys_addr.p_addr;
- break;
-#endif
- case MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT:
- img_resolution = (SSBSIP_MFC_IMG_RESOLUTION *)value;
- img_resolution->width = pCTX->decOutInfo.img_width;
- img_resolution->height = pCTX->decOutInfo.img_height;
- img_resolution->buf_width = pCTX->decOutInfo.buf_width;
- img_resolution->buf_height = pCTX->decOutInfo.buf_height;
- break;
- case MFC_DEC_GETCONF_FRAME_TAG:
- *((unsigned int *)value) = pCTX->outframetagtop;
- break;
- 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:
-#ifdef S3D_SUPPORT
- case MFC_DEC_GETCONF_FRAME_PACKING:
- memset(&DecArg, 0x00, sizeof(DecArg));
- DecArg.args.config.type = conf_type;
-
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_CONFIG, &DecArg);
- if (DecArg.ret_code != MFC_OK) {
- LOGE("SsbSipMfcDecGetConfig] IOCTL_MFC_GET_CONFIG failed(ret : %d, conf_type: 0x%08x)", DecArg.ret_code, conf_type);
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
-
- if (conf_type == MFC_DEC_GETCONF_CRC_DATA) {
- crc_data = (SSBSIP_MFC_CRC_DATA *)value;
-
- crc_data->luma0 = DecArg.args.config.args.basic.values[0];
- crc_data->chroma0 = DecArg.args.config.args.basic.values[1];
- } else {
- frame_packing = (SSBSIP_MFC_FRAME_PACKING *)value;
- memcpy(frame_packing, &DecArg.args.config.args.frame_packing,
- sizeof(SSBSIP_MFC_FRAME_PACKING));
- }
-#else
- crc_data = (SSBSIP_MFC_CRC_DATA *)value;
-
- memset(&DecArg, 0x00, sizeof(DecArg));
- DecArg.args.get_config.in_config_param = conf_type;
-
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_CONFIG, &DecArg);
- if (DecArg.ret_code != MFC_OK) {
- LOGE("SsbSipMfcDecGetConfig] IOCTL_MFC_GET_CONFIG failed(ret : %d, conf_type: 0x%08x)", 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];
-#endif
- break;
- default:
- LOGE("SsbSipMfcDecGetConfig] No such conf_type is supported");
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
-
- return MFC_RET_OK;
-}
-
-void *SsbSipMfcDecAllocInputBuffer(void *openHandle, void **phyInBuf, int inputBufferSize)
-{
- int ret_code;
- _MFCLIB *pCTX;
- struct mfc_common_args user_addr_arg, phys_addr_arg;
-
- if (inputBufferSize < 0) {
- LOGE("SsbSipMfcDecAllocInputBuffer] inputBufferSize = %d is invalid\n", inputBufferSize);
- return NULL;
- }
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecAllocInputBuffer] openHandle is NULL\n");
- return NULL;
- }
-
- pCTX = (_MFCLIB *)openHandle;
-
- user_addr_arg.args.mem_alloc.type = DECODER;
- user_addr_arg.args.mem_alloc.buff_size = inputBufferSize;
- user_addr_arg.args.mem_alloc.mapped_addr = pCTX->mapped_addr;
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_IN_BUF, &user_addr_arg);
- if (ret_code < 0) {
- LOGE("SsbSipMfcDecAllocInputBuffer] IOCTL_MFC_GET_IN_BUF failed");
- return NULL;
- }
-
- phys_addr_arg.args.real_addr.key = user_addr_arg.args.mem_alloc.offset;
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_REAL_ADDR, &phys_addr_arg);
- if (ret_code < 0) {
- LOGE("SsbSipMfcDecGetInBuf] IOCTL_MFC_GET_PHYS_ADDR failed");
- return NULL;
- }
-
- pCTX->virStrmBuf = pCTX->mapped_addr + user_addr_arg.args.mem_alloc.offset;
- pCTX->phyStrmBuf = phys_addr_arg.args.real_addr.addr;
- pCTX->sizeStrmBuf = inputBufferSize;
- pCTX->inter_buff_status |= MFC_USE_STRM_BUFF;
-
- *phyInBuf = (void *)pCTX->phyStrmBuf;
-
- return (void *)pCTX->virStrmBuf;
-}
-
-void SsbSipMfcDecFreeInputBuffer(void *openHandle, void *phyInBuf)
-{
- int ret;
- _MFCLIB *pCTX;
- struct mfc_common_args free_arg;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcDecFreeInputBuffer] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *)openHandle;
-
- if (pCTX->inter_buff_status & MFC_USE_STRM_BUFF) {
- free_arg.args.mem_free.key = pCTX->virStrmBuf;
- ret = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
- }
- pCTX->inter_buff_status = MFC_USE_NONE;
- return MFC_RET_OK;
-}
-
-/* CRESPO */
-#if 1
-int tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos)
-{
- int pixel_x_m1, pixel_y_m1;
- int roundup_x, roundup_y;
- int linear_addr0, linear_addr1, bank_addr ;
- int x_addr;
- int trans_addr;
-
- pixel_x_m1 = x_size -1;
- pixel_y_m1 = y_size -1;
-
- roundup_x = ((pixel_x_m1 >> 7) + 1);
- roundup_y = ((pixel_x_m1 >> 6) + 1);
-
- x_addr = x_pos >> 2;
-
- if ((y_size <= y_pos+32) && ( y_pos < y_size) &&
- (((pixel_y_m1 >> 5) & 0x1) == 0) && (((y_pos >> 5) & 0x1) == 0)) {
- linear_addr0 = (((y_pos & 0x1f) <<4) | (x_addr & 0xf));
- linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 6) & 0x3f));
-
- if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
- bank_addr = ((x_addr >> 4) & 0x1);
- else
- bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
- } else {
- linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
- linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 5) & 0x7f));
-
- if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
- bank_addr = ((x_addr >> 4) & 0x1);
- else
- bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
- }
-
- linear_addr0 = linear_addr0 << 2;
- trans_addr = (linear_addr1 <<13) | (bank_addr << 11) | linear_addr0;
-
- return trans_addr;
-}
-
-void Y_tile_to_linear_4x2(unsigned char *p_linear_addr, unsigned char *p_tiled_addr, unsigned int x_size, unsigned int y_size)
-{
- int trans_addr;
- unsigned int i, j, k, index;
- unsigned char data8[4];
- unsigned int max_index = x_size * y_size;
-
- for (i = 0; i < y_size; i = i + 16) {
- for (j = 0; j < x_size; j = j + 16) {
- trans_addr = tile_4x2_read(x_size, y_size, j, i);
- for (k = 0; k < 16; k++) {
- /* limit check - prohibit segmentation fault */
- index = (i * x_size) + (x_size * k) + j;
- /* remove equal condition to solve thumbnail bug */
- if (index + 16 > max_index) {
- continue;
- }
-
- data8[0] = p_tiled_addr[trans_addr + 64 * k + 0];
- data8[1] = p_tiled_addr[trans_addr + 64 * k + 1];
- data8[2] = p_tiled_addr[trans_addr + 64 * k + 2];
- data8[3] = p_tiled_addr[trans_addr + 64 * k + 3];
-
- p_linear_addr[index] = data8[0];
- p_linear_addr[index + 1] = data8[1];
- p_linear_addr[index + 2] = data8[2];
- p_linear_addr[index + 3] = data8[3];
-
- data8[0] = p_tiled_addr[trans_addr + 64 * k + 4];
- data8[1] = p_tiled_addr[trans_addr + 64 * k + 5];
- data8[2] = p_tiled_addr[trans_addr + 64 * k + 6];
- data8[3] = p_tiled_addr[trans_addr + 64 * k + 7];
-
- p_linear_addr[index + 4] = data8[0];
- p_linear_addr[index + 5] = data8[1];
- p_linear_addr[index + 6] = data8[2];
- p_linear_addr[index + 7] = data8[3];
-
- data8[0] = p_tiled_addr[trans_addr + 64 * k + 8];
- data8[1] = p_tiled_addr[trans_addr + 64 * k + 9];
- data8[2] = p_tiled_addr[trans_addr + 64 * k + 10];
- data8[3] = p_tiled_addr[trans_addr + 64 * k + 11];
-
- p_linear_addr[index + 8] = data8[0];
- p_linear_addr[index + 9] = data8[1];
- p_linear_addr[index + 10] = data8[2];
- p_linear_addr[index + 11] = data8[3];
-
- data8[0] = p_tiled_addr[trans_addr + 64 * k + 12];
- data8[1] = p_tiled_addr[trans_addr + 64 * k + 13];
- data8[2] = p_tiled_addr[trans_addr + 64 * k + 14];
- data8[3] = p_tiled_addr[trans_addr + 64 * k + 15];
-
- p_linear_addr[index + 12] = data8[0];
- p_linear_addr[index + 13] = data8[1];
- p_linear_addr[index + 14] = data8[2];
- p_linear_addr[index + 15] = data8[3];
- }
- }
- }
-}
-
-void CbCr_tile_to_linear_4x2(unsigned char *p_linear_addr, unsigned char *p_tiled_addr, unsigned int x_size, unsigned int y_size)
-{
- int trans_addr;
- unsigned int i, j, k, index;
- unsigned char data8[4];
- unsigned int half_y_size = y_size / 2;
- unsigned int max_index = x_size * half_y_size;
- unsigned char *pUVAddr[2];
-
- pUVAddr[0] = p_linear_addr;
- pUVAddr[1] = p_linear_addr + ((x_size * half_y_size) / 2);
-
- for (i = 0; i < half_y_size; i = i + 16) {
- for (j = 0; j < x_size; j = j + 16) {
- trans_addr = tile_4x2_read(x_size, half_y_size, j, i);
- for (k = 0; k < 16; k++) {
- /* limit check - prohibit segmentation fault */
- index = (i * x_size) + (x_size * k) + j;
- /* remove equal condition to solve thumbnail bug */
- if (index + 16 > max_index) {
- continue;
- }
-
- data8[0] = p_tiled_addr[trans_addr + 64 * k + 0];
- data8[1] = p_tiled_addr[trans_addr + 64 * k + 1];
- data8[2] = p_tiled_addr[trans_addr + 64 * k + 2];
- data8[3] = p_tiled_addr[trans_addr + 64 * k + 3];
-
- pUVAddr[index%2][index/2] = data8[0];
- pUVAddr[(index+1)%2][(index+1)/2] = data8[1];
- pUVAddr[(index+2)%2][(index+2)/2] = data8[2];
- pUVAddr[(index+3)%2][(index+3)/2] = data8[3];
-
- data8[0] = p_tiled_addr[trans_addr + 64 * k + 4];
- data8[1] = p_tiled_addr[trans_addr + 64 * k + 5];
- data8[2] = p_tiled_addr[trans_addr + 64 * k + 6];
- data8[3] = p_tiled_addr[trans_addr + 64 * k + 7];
-
- pUVAddr[(index+4)%2][(index+4)/2] = data8[0];
- pUVAddr[(index+5)%2][(index+5)/2] = data8[1];
- pUVAddr[(index+6)%2][(index+6)/2] = data8[2];
- pUVAddr[(index+7)%2][(index+7)/2] = data8[3];
-
- data8[0] = p_tiled_addr[trans_addr + 64 * k + 8];
- data8[1] = p_tiled_addr[trans_addr + 64 * k + 9];
- data8[2] = p_tiled_addr[trans_addr + 64 * k + 10];
- data8[3] = p_tiled_addr[trans_addr + 64 * k + 11];
-
- pUVAddr[(index+8)%2][(index+8)/2] = data8[0];
- pUVAddr[(index+9)%2][(index+9)/2] = data8[1];
- pUVAddr[(index+10)%2][(index+10)/2] = data8[2];
- pUVAddr[(index+11)%2][(index+11)/2] = data8[3];
-
- data8[0] = p_tiled_addr[trans_addr + 64 * k + 12];
- data8[1] = p_tiled_addr[trans_addr + 64 * k + 13];
- data8[2] = p_tiled_addr[trans_addr + 64 * k + 14];
- data8[3] = p_tiled_addr[trans_addr + 64 * k + 15];
-
- pUVAddr[(index+12)%2][(index+12)/2] = data8[0];
- pUVAddr[(index+13)%2][(index+13)/2] = data8[1];
- pUVAddr[(index+14)%2][(index+14)/2] = data8[2];
- pUVAddr[(index+15)%2][(index+15)/2] = data8[3];
- }
- }
- }
-}
-#else
-int tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos)
-{
- int pixel_x_m1, pixel_y_m1;
- int roundup_x, roundup_y;
- int linear_addr0, linear_addr1, bank_addr;
- int x_addr;
- int trans_addr;
-
- pixel_x_m1 = x_size -1;
- pixel_y_m1 = y_size -1;
-
- roundup_x = ((pixel_x_m1 >> 7) + 1);
- roundup_y = ((pixel_x_m1 >> 6) + 1);
-
- x_addr = x_pos >> 2;
-
- if ((y_size <= y_pos+32) &&
- ( y_pos < y_size) &&
- (((pixel_y_m1 >> 5) & 0x1) == 0) &&
- (((y_pos >> 5) & 0x1) == 0)) {
- linear_addr0 = (((y_pos & 0x1f) <<4) | (x_addr & 0xf));
- linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 6) & 0x3f));
-
- if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
- bank_addr = ((x_addr >> 4) & 0x1);
- else
- bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
- } else {
- linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
- linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 5) & 0x7f));
-
- if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
- bank_addr = ((x_addr >> 4) & 0x1);
- else
- bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
- }
-
- linear_addr0 = linear_addr0 << 2;
- trans_addr = (linear_addr1 <<13) | (bank_addr << 11) | linear_addr0;
-
- return trans_addr;
-}
-
-
-void tile_to_linear_4x2(unsigned char *p_linear_addr, unsigned char *p_tiled_addr, unsigned int x_size, unsigned int y_size)
-{
- int trans_addr;
- unsigned int i, j, k, nn, mm;
- unsigned int ix,iy, nx, ny;
-
- nx = x_size % 16;
- ny = y_size % 16;
-
- if (nx != 0)
- ix = 16;
- else
- ix = 1;
-
- if (ny != 0)
- iy = 16;
- else
- iy = 1;
-
- for (i = 0; i < y_size - iy; i = i + 16) {
- for (j = 0; j < x_size -ix; j = j + 16) {
- trans_addr = tile_4x2_read(x_size, y_size, j, i);
-
- k = 0; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 1; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 2; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 3; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 4; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 5; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 6; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 7; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 8; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 9; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 10; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 11; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 12; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 13; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 14; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
-
- k = 15; nn = trans_addr + (k << 6); mm =x_size*(i+k) + j;
- memcpy(p_linear_addr+mm, p_tiled_addr+nn, 16);
- }
- }
-}
-#endif
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/enc/src/SsbSipMfcEncAPI.c b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/enc/src/SsbSipMfcEncAPI.c
deleted file mode 100644
index 797baad..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/enc/src/SsbSipMfcEncAPI.c
+++ /dev/null
@@ -1,862 +0,0 @@
-/*
- * Copyright (c) 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 <stdio.h>
-#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 <math.h>
-
-#include "mfc_interface.h"
-#include "SsbSipMfcApi.h"
-
-#include <utils/Log.h>
-/* #define LOG_NDEBUG 0 */
-#undef LOG_TAG
-#define LOG_TAG "MFC_ENC_APP"
-
-#define _MFCLIB_MAGIC_NUMBER 0x92241001
-
-static char *mfc_dev_name = SAMSUNG_MFC_DEV_NAME;
-
-void SsbSipMfcEncSetMFCName(char *devicename)
-{
- mfc_dev_name = devicename;
-}
-
-void *SsbSipMfcEncOpen(void)
-{
- int hMFCOpen;
- _MFCLIB *pCTX = NULL;
- unsigned int mapped_addr;
- int mapped_size;
- struct mfc_common_args CommonArg;
-
- LOGI("[%s] MFC Library Ver %d.%02d",__func__, MFC_LIB_VER_MAJOR, MFC_LIB_VER_MINOR);
-
-#if 0
- if ((codecType != MPEG4_ENC) &&
- (codecType != H264_ENC) &&
- (codecType != H263_ENC)) {
- LOGE("SsbSipMfcEncOpen] Undefined codec type");
- return NULL;
- }
-#endif
-
- if (access(mfc_dev_name, F_OK) != 0) {
- LOGE("SsbSipMfcEncOpen] MFC device node not exists");
- return NULL;
- }
-
- hMFCOpen = open(mfc_dev_name, O_RDWR | O_NDELAY);
- if (hMFCOpen < 0) {
- LOGE("SsbSipMfcEncOpen] MFC Open failure");
- return NULL;
- }
-
- pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
- if (pCTX == NULL) {
- LOGE("SsbSipMfcEncOpen] malloc failed.");
- close(hMFCOpen);
- return NULL;
- }
- memset(pCTX, 0, sizeof(_MFCLIB));
-
- mapped_size = ioctl(hMFCOpen, IOCTL_MFC_GET_MMAP_SIZE, &CommonArg);
- if ((mapped_size < 0) || (CommonArg.ret_code != MFC_OK)) {
- LOGE("SsbSipMfcEncOpen] IOCTL_MFC_GET_MMAP_SIZE failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- mapped_addr = (unsigned int)mmap(0, mapped_size, PROT_READ | PROT_WRITE, MAP_SHARED, hMFCOpen, 0);
- if (!mapped_addr) {
- LOGE("SsbSipMfcEncOpen] FIMV5.x driver address mapping failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- pCTX->magic = _MFCLIB_MAGIC_NUMBER;
- pCTX->hMFC = hMFCOpen;
- pCTX->mapped_addr = mapped_addr;
- pCTX->mapped_size = mapped_size;
- pCTX->inter_buff_status = MFC_USE_NONE;
-
- return (void *) pCTX;
-}
-
-
-void *SsbSipMfcEncOpenExt(void *value)
-{
- int hMFCOpen;
- _MFCLIB *pCTX = NULL;
- unsigned int mapped_addr;
- int mapped_size;
- int err;
- struct mfc_common_args CommonArg;
-
- LOGI("[%s] MFC Library Ver %d.%02d",__func__, MFC_LIB_VER_MAJOR, MFC_LIB_VER_MINOR);
-
-#if 0
- if ((codecType != MPEG4_ENC) &&
- (codecType != H264_ENC) &&
- (codecType != H263_ENC)) {
- LOGE("SsbSipMfcEncOpen] Undefined codec type");
- return NULL;
- }
-#endif
-
- if (access(mfc_dev_name, F_OK) != 0) {
- LOGE("SsbSipMfcEncOpenExt] MFC device node not exists");
- return NULL;
- }
-
- hMFCOpen = open(mfc_dev_name, O_RDWR | O_NDELAY);
- if (hMFCOpen < 0) {
- LOGE("SsbSipMfcEncOpenExt] MFC Open failure");
- return NULL;
- }
-
- pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
- if (pCTX == NULL) {
- LOGE("SsbSipMfcEncOpenExt] malloc failed.");
- close(hMFCOpen);
- return NULL;
- }
- memset(pCTX, 0, sizeof(_MFCLIB));
-
- CommonArg.args.mem_alloc.buf_cache_type = *(SSBIP_MFC_BUFFER_TYPE *)value;
-
- err = ioctl(hMFCOpen, IOCTL_MFC_SET_BUF_CACHE, &CommonArg);
- if ((err < 0) || (CommonArg.ret_code != MFC_OK)) {
- LOGE("SsbSipMfcEncOpenExt] IOCTL_MFC_SET_BUF_CACHE failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- mapped_size = ioctl(hMFCOpen, IOCTL_MFC_GET_MMAP_SIZE, &CommonArg);
- if ((mapped_size < 0) || (CommonArg.ret_code != MFC_OK)) {
- LOGE("SsbSipMfcEncOpenExt] IOCTL_MFC_GET_MMAP_SIZE failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- mapped_addr = (unsigned int)mmap(0, mapped_size, PROT_READ | PROT_WRITE, MAP_SHARED, hMFCOpen, 0);
- if (!mapped_addr) {
- LOGE("SsbSipMfcEncOpenExt] FIMV5.x driver address mapping failed");
- free(pCTX);
- close(hMFCOpen);
- return NULL;
- }
-
- pCTX->magic = _MFCLIB_MAGIC_NUMBER;
- pCTX->hMFC = hMFCOpen;
- pCTX->mapped_addr = mapped_addr;
- pCTX->mapped_size = mapped_size;
- pCTX->inter_buff_status = MFC_USE_NONE;
-
- return (void *) pCTX;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncInit(void *openHandle, void *param)
-{
- int ret_code;
-
- _MFCLIB *pCTX;
- struct mfc_common_args EncArg;
- SSBSIP_MFC_ENC_H264_PARAM *h264_arg;
- SSBSIP_MFC_ENC_MPEG4_PARAM *mpeg4_arg;
- SSBSIP_MFC_ENC_H263_PARAM *h263_arg;
-
- pCTX = (_MFCLIB *) openHandle;
- memset(&EncArg, 0, sizeof(struct mfc_common_args));
-
- pCTX->encode_cnt = 0;
-
- mpeg4_arg = (SSBSIP_MFC_ENC_MPEG4_PARAM*)param;
- if (mpeg4_arg->codecType == MPEG4_ENC) {
- pCTX->codecType= MPEG4_ENC;
- } else {
- h263_arg = (SSBSIP_MFC_ENC_H263_PARAM*)param;
- if (h263_arg->codecType == H263_ENC) {
- pCTX->codecType = H263_ENC;
- } else {
- h264_arg = (SSBSIP_MFC_ENC_H264_PARAM*)param;
- if (h264_arg->codecType == H264_ENC) {
- pCTX->codecType = H264_ENC;
- } else {
- LOGE("SsbSipMfcEncInit] Undefined codec type");
- return MFC_RET_INVALID_PARAM;
- }
- }
- }
-
- LOGI("SsbSipMfcEncInit] Encode Init start");
-
- switch (pCTX->codecType) {
- case MPEG4_ENC:
- LOGI("SsbSipMfcEncInit] MPEG4 Encode");
- mpeg4_arg = (SSBSIP_MFC_ENC_MPEG4_PARAM *)param;
-
- pCTX->width = mpeg4_arg->SourceWidth;
- pCTX->height = mpeg4_arg->SourceHeight;
- break;
-
- case H263_ENC:
- LOGI("SsbSipMfcEncInit] H263 Encode");
- h263_arg = (SSBSIP_MFC_ENC_H263_PARAM *)param;
-
- pCTX->width = h263_arg->SourceWidth;
- pCTX->height = h263_arg->SourceHeight;
- break;
-
- case H264_ENC:
- LOGI("SsbSipMfcEncInit] H264 Encode");
- h264_arg = (SSBSIP_MFC_ENC_H264_PARAM *)param;
-
- pCTX->width = h264_arg->SourceWidth;
- pCTX->height = h264_arg->SourceHeight;
- break;
-
- default:
- break;
- }
-
- switch (pCTX->codecType) {
- case MPEG4_ENC:
- mpeg4_arg = (SSBSIP_MFC_ENC_MPEG4_PARAM *)param;
-
- EncArg.args.enc_init.cmn.in_codec_type = pCTX->codecType;
-
- EncArg.args.enc_init.cmn.in_width = mpeg4_arg->SourceWidth;
- EncArg.args.enc_init.cmn.in_height = mpeg4_arg->SourceHeight;
- EncArg.args.enc_init.cmn.in_gop_num = mpeg4_arg->IDRPeriod;
-
- EncArg.args.enc_init.cmn.in_ms_mode = mpeg4_arg->SliceMode;
- EncArg.args.enc_init.cmn.in_ms_arg = mpeg4_arg->SliceArgument;
-
- EncArg.args.enc_init.cmn.in_mb_refresh = mpeg4_arg->RandomIntraMBRefresh;
-
- /* rate control*/
- EncArg.args.enc_init.cmn.in_rc_fr_en = mpeg4_arg->EnableFRMRateControl;
- if ((mpeg4_arg->QSCodeMin > 31) || (mpeg4_arg->QSCodeMax > 31)) {
- LOGE("SsbSipMfcEncInit] No such Min/Max QP is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_rc_qbound_min = mpeg4_arg->QSCodeMin;
- EncArg.args.enc_init.cmn.in_rc_qbound_max = mpeg4_arg->QSCodeMax;
- EncArg.args.enc_init.cmn.in_rc_rpara = mpeg4_arg->CBRPeriodRf;
-
- /* pad control */
- EncArg.args.enc_init.cmn.in_pad_ctrl_on = mpeg4_arg->PadControlOn;
- if ((mpeg4_arg->LumaPadVal > 255) || (mpeg4_arg->CbPadVal > 255) || (mpeg4_arg->CrPadVal > 255)) {
- LOGE("SsbSipMfcEncInit] No such Pad value is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_y_pad_val = mpeg4_arg->LumaPadVal;
- EncArg.args.enc_init.cmn.in_cb_pad_val = mpeg4_arg->CbPadVal;
- EncArg.args.enc_init.cmn.in_cr_pad_val = mpeg4_arg->CrPadVal;
-
- /* Input stream Mode NV12_Linear or NV12_Tile*/
- EncArg.args.enc_init.cmn.in_frame_map = mpeg4_arg->FrameMap;
-
- EncArg.args.enc_init.cmn.in_rc_bitrate = mpeg4_arg->Bitrate;
- if ((mpeg4_arg->FrameQp > 31) || (mpeg4_arg->FrameQp_P > 31)) {
- LOGE("SsbSipMfcEncInit] No such FrameQp is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_vop_quant = mpeg4_arg->FrameQp;
- EncArg.args.enc_init.cmn.in_vop_quant_p = mpeg4_arg->FrameQp_P;
-
- /* MPEG4 only */
- EncArg.args.enc_init.codec.mpeg4.in_profile = mpeg4_arg->ProfileIDC;
- EncArg.args.enc_init.codec.mpeg4.in_level = mpeg4_arg->LevelIDC;
-
- if (mpeg4_arg->FrameQp_B > 31) {
- LOGE("SsbSipMfcEncInit] No such FrameQp is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.codec.mpeg4.in_vop_quant_b = mpeg4_arg->FrameQp_B;
-
- if (mpeg4_arg->NumberBFrames > 2) {
- LOGE("SsbSipMfcEncInit] No such BframeNum is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.codec.mpeg4.in_bframenum = mpeg4_arg->NumberBFrames;
-
- EncArg.args.enc_init.codec.mpeg4.in_quart_pixel = mpeg4_arg->DisableQpelME;
-
- EncArg.args.enc_init.codec.mpeg4.in_TimeIncreamentRes = mpeg4_arg->TimeIncreamentRes;
- EncArg.args.enc_init.codec.mpeg4.in_VopTimeIncreament = mpeg4_arg->VopTimeIncreament;
-
- break;
-
- case H263_ENC:
- h263_arg = (SSBSIP_MFC_ENC_H263_PARAM *)param;
-
- EncArg.args.enc_init.cmn.in_codec_type = pCTX->codecType;
-
- EncArg.args.enc_init.cmn.in_width = h263_arg->SourceWidth;
- EncArg.args.enc_init.cmn.in_height = h263_arg->SourceHeight;
- EncArg.args.enc_init.cmn.in_gop_num = h263_arg->IDRPeriod;
-
- EncArg.args.enc_init.cmn.in_ms_mode = h263_arg->SliceMode;
- EncArg.args.enc_init.cmn.in_ms_arg = 0;
-
- EncArg.args.enc_init.cmn.in_mb_refresh = h263_arg->RandomIntraMBRefresh;
-
- /* rate control*/
- EncArg.args.enc_init.cmn.in_rc_fr_en = h263_arg->EnableFRMRateControl;
- if ((h263_arg->QSCodeMin > 31) || (h263_arg->QSCodeMax > 31)) {
- LOGE("SsbSipMfcEncInit] No such Min/Max QP is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_rc_qbound_min = h263_arg->QSCodeMin;
- EncArg.args.enc_init.cmn.in_rc_qbound_max = h263_arg->QSCodeMax;
- EncArg.args.enc_init.cmn.in_rc_rpara = h263_arg->CBRPeriodRf;
-
- /* pad control */
- EncArg.args.enc_init.cmn.in_pad_ctrl_on = h263_arg->PadControlOn;
- if ((h263_arg->LumaPadVal > 255) || (h263_arg->CbPadVal > 255) || (h263_arg->CrPadVal > 255)) {
- LOGE("SsbSipMfcEncInit] No such Pad value is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_y_pad_val = h263_arg->LumaPadVal;
- EncArg.args.enc_init.cmn.in_cb_pad_val = h263_arg->CbPadVal;
- EncArg.args.enc_init.cmn.in_cr_pad_val = h263_arg->CrPadVal;
-
- /* Input stream Mode NV12_Linear or NV12_Tile*/
- EncArg.args.enc_init.cmn.in_frame_map = h263_arg->FrameMap;
-
- EncArg.args.enc_init.cmn.in_rc_bitrate = h263_arg->Bitrate;
- if ((h263_arg->FrameQp > 31) || (h263_arg->FrameQp_P > 31)) {
- LOGE("SsbSipMfcEncInit] No such FrameQp is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_vop_quant = h263_arg->FrameQp;
- EncArg.args.enc_init.cmn.in_vop_quant_p = h263_arg->FrameQp_P;
-
- /* H.263 only */
- EncArg.args.enc_init.codec.h263.in_rc_framerate = h263_arg->FrameRate;
-
- break;
-
- case H264_ENC:
- h264_arg = (SSBSIP_MFC_ENC_H264_PARAM *)param;
-
- EncArg.args.enc_init.cmn.in_codec_type = H264_ENC;
-
- EncArg.args.enc_init.cmn.in_width = h264_arg->SourceWidth;
- EncArg.args.enc_init.cmn.in_height = h264_arg->SourceHeight;
- EncArg.args.enc_init.cmn.in_gop_num = h264_arg->IDRPeriod;
-
- if ((h264_arg->SliceMode == 0)||(h264_arg->SliceMode == 1)||
- (h264_arg->SliceMode == 2)||(h264_arg->SliceMode == 4)) {
- EncArg.args.enc_init.cmn.in_ms_mode = h264_arg->SliceMode;
- } else {
- LOGE("SsbSipMfcEncInit] No such slice mode is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_ms_arg = h264_arg->SliceArgument;
-
- EncArg.args.enc_init.cmn.in_mb_refresh = h264_arg->RandomIntraMBRefresh;
- /* pad control */
- EncArg.args.enc_init.cmn.in_pad_ctrl_on = h264_arg->PadControlOn;
- if ((h264_arg->LumaPadVal > 255) || (h264_arg->CbPadVal > 255) || (h264_arg->CrPadVal > 255)) {
- LOGE("SsbSipMfcEncInit] No such Pad value is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_y_pad_val = h264_arg->LumaPadVal;
- EncArg.args.enc_init.cmn.in_cb_pad_val = h264_arg->CbPadVal;
- EncArg.args.enc_init.cmn.in_cr_pad_val = h264_arg->CrPadVal;
-
- /* Input stream Mode NV12_Linear or NV12_Tile*/
- EncArg.args.enc_init.cmn.in_frame_map = h264_arg->FrameMap;
-
- /* rate control*/
- EncArg.args.enc_init.cmn.in_rc_fr_en = h264_arg->EnableFRMRateControl;
- EncArg.args.enc_init.cmn.in_rc_bitrate = h264_arg->Bitrate;
- if ((h264_arg->FrameQp > 51) || (h264_arg->FrameQp_P > 51)) {
- LOGE("SsbSipMfcEncInit] No such FrameQp is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_vop_quant = h264_arg->FrameQp;
- EncArg.args.enc_init.cmn.in_vop_quant_p = h264_arg->FrameQp_P;
-
- if ((h264_arg->QSCodeMin > 51) || (h264_arg->QSCodeMax > 51)) {
- LOGE("SsbSipMfcEncInit] No such Min/Max QP is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.cmn.in_rc_qbound_min = h264_arg->QSCodeMin;
- EncArg.args.enc_init.cmn.in_rc_qbound_max = h264_arg->QSCodeMax;
- EncArg.args.enc_init.cmn.in_rc_rpara = h264_arg->CBRPeriodRf;
-
-
- /* H.264 Only */
- EncArg.args.enc_init.codec.h264.in_profile = h264_arg->ProfileIDC;
- EncArg.args.enc_init.codec.h264.in_level = h264_arg->LevelIDC;
-
- if (h264_arg->FrameQp_B > 51) {
- LOGE("SsbSipMfcEncInit] No such FrameQp is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.codec.h264.in_vop_quant_b = h264_arg->FrameQp_B;
-
- if (h264_arg->NumberBFrames > 2) {
- LOGE("SsbSipMfcEncInit] No such BframeNum is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.codec.h264.in_bframenum = h264_arg->NumberBFrames;
-
- EncArg.args.enc_init.codec.h264.in_interlace_mode = h264_arg->PictureInterlace;
-
- if ((h264_arg->NumberRefForPframes > 2)||(h264_arg->NumberReferenceFrames >2)) {
- LOGE("SsbSipMfcEncInit] No such ref Num is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.codec.h264.in_reference_num = h264_arg->NumberReferenceFrames;
- EncArg.args.enc_init.codec.h264.in_ref_num_p = h264_arg->NumberRefForPframes;
-
- EncArg.args.enc_init.codec.h264.in_rc_framerate = h264_arg->FrameRate;
-
- EncArg.args.enc_init.codec.h264.in_rc_mb_en = h264_arg->EnableMBRateControl;
- EncArg.args.enc_init.codec.h264.in_rc_mb_dark_dis = h264_arg->DarkDisable;
- EncArg.args.enc_init.codec.h264.in_rc_mb_smooth_dis = h264_arg->SmoothDisable;
- EncArg.args.enc_init.codec.h264.in_rc_mb_static_dis = h264_arg->StaticDisable;
- EncArg.args.enc_init.codec.h264.in_rc_mb_activity_dis = h264_arg->ActivityDisable;
-
- EncArg.args.enc_init.codec.h264.in_deblock_dis = h264_arg->LoopFilterDisable;
- if ((abs(h264_arg->LoopFilterAlphaC0Offset) > 6) || (abs(h264_arg->LoopFilterBetaOffset) > 6)) {
- LOGE("SsbSipMfcEncInit] No such AlphaC0Offset or BetaOffset is supported");
- return MFC_RET_INVALID_PARAM;
- }
- EncArg.args.enc_init.codec.h264.in_deblock_alpha_c0 = h264_arg->LoopFilterAlphaC0Offset;
- EncArg.args.enc_init.codec.h264.in_deblock_beta = h264_arg->LoopFilterBetaOffset;
-
- EncArg.args.enc_init.codec.h264.in_symbolmode = h264_arg->SymbolMode;
- EncArg.args.enc_init.codec.h264.in_transform8x8_mode = h264_arg->Transform8x8Mode;
-
- /* FIXME: is it removed? */
- EncArg.args.enc_init.codec.h264.in_md_interweight_pps = 300;
- EncArg.args.enc_init.codec.h264.in_md_intraweight_pps = 170;
-
- break;
-
- default:
- LOGE("SsbSipMfcEncInit] No such codec type is supported");
- return MFC_RET_INVALID_PARAM;
- }
-
- EncArg.args.enc_init.cmn.in_mapped_addr = pCTX->mapped_addr;
-
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_ENC_INIT, &EncArg);
- if (EncArg.ret_code != MFC_OK) {
- LOGE("SsbSipMfcEncInit] IOCTL_MFC_ENC_INIT failed");
- return MFC_RET_ENC_INIT_FAIL;
- }
-
- pCTX->virStrmBuf = EncArg.args.enc_init.cmn.out_u_addr.strm_ref_y;
- pCTX->phyStrmBuf = EncArg.args.enc_init.cmn.out_p_addr.strm_ref_y;
-
- pCTX->sizeStrmBuf = MAX_ENCODER_OUTPUT_BUFFER_SIZE;
- pCTX->encodedHeaderSize = EncArg.args.enc_init.cmn.out_header_size;
-
- pCTX->virMvRefYC = EncArg.args.enc_init.cmn.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;
- struct mfc_common_args EncArg;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcEncExe] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *)openHandle;
-
- memset(&EncArg, 0x00, sizeof(struct mfc_common_args));
-
- EncArg.args.enc_exe.in_codec_type = pCTX->codecType;
- EncArg.args.enc_exe.in_Y_addr = (unsigned int)pCTX->phyFrmBuf.luma;
- EncArg.args.enc_exe.in_CbCr_addr = (unsigned int)pCTX->phyFrmBuf.chroma;
-#if 0 /* peter for debug */
- 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;
-#endif
- EncArg.args.enc_exe.in_frametag = pCTX->inframetag;
- 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 + pCTX->sizeStrmBuf + (MAX_ENCODER_OUTPUT_BUFFER_SIZE / 2);
- }
-
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_ENC_EXE, &EncArg);
- if (EncArg.ret_code != MFC_OK) {
- LOGE("SsbSipMfcEncExe] IOCTL_MFC_ENC_EXE failed(ret : %d)", 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->encodedphyFrmBuf.luma = EncArg.args.enc_exe.out_Y_addr;
- pCTX->encodedphyFrmBuf.chroma = EncArg.args.enc_exe.out_CbCr_addr;
- pCTX->outframetagtop = EncArg.args.enc_exe.out_frametag_top;
- pCTX->outframetagbottom = EncArg.args.enc_exe.out_frametag_bottom;
-
- LOGV("SsbSipMfcEncExe] Encode success ==================");
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncClose(void *openHandle)
-{
- int ret_code;
- _MFCLIB *pCTX;
- struct mfc_common_args free_arg;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcEncClose] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *)openHandle;
-
- /* FIXME: free buffer? */
- if (pCTX->inter_buff_status & MFC_USE_YUV_BUFF) {
- free_arg.args.mem_free.key = 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.key = pCTX->virStrmBuf;
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_FREE_BUF, &free_arg);
- free_arg.args.mem_free.key = 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, pCTX->mapped_size);
-
- close(pCTX->hMFC);
-
- free(pCTX);
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
-{
- int ret_code;
- _MFCLIB *pCTX;
- struct mfc_common_args user_addr_arg, real_addr_arg;
- int y_size, c_size;
- int aligned_y_size, aligned_c_size;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcEncGetInBuf] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- /* FIXME: */
- y_size = pCTX->width * pCTX->height;
- c_size = (pCTX->width * pCTX->height) >> 1;
-
- /* lenear: 2KB, tile: 8KB */
- aligned_y_size = Align(y_size, 64 * BUF_L_UNIT);
- aligned_c_size = Align(c_size, 64 * BUF_L_UNIT);
-
- /* Allocate luma & chroma buf */
- user_addr_arg.args.mem_alloc.type = ENCODER;
- user_addr_arg.args.mem_alloc.buff_size = aligned_y_size + aligned_c_size;
- user_addr_arg.args.mem_alloc.mapped_addr = pCTX->mapped_addr;
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_IN_BUF, &user_addr_arg);
- if (ret_code < 0) {
- LOGE("SsbSipMfcEncGetInBuf] IOCTL_MFC_GET_IN_BUF failed");
- return MFC_RET_ENC_GET_INBUF_FAIL;
- }
-
- pCTX->virFrmBuf.luma = pCTX->mapped_addr + user_addr_arg.args.mem_alloc.offset;
- pCTX->virFrmBuf.chroma = pCTX->mapped_addr + user_addr_arg.args.mem_alloc.offset + (unsigned int)aligned_y_size;
-
- real_addr_arg.args.real_addr.key = user_addr_arg.args.mem_alloc.offset;
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_GET_REAL_ADDR, &real_addr_arg);
- if (ret_code < 0) {
- LOGE("SsbSipMfcEncGetInBuf] IOCTL_MFC_GET_REAL_ADDR failed");
- return MFC_RET_ENC_GET_INBUF_FAIL;
- }
- pCTX->phyFrmBuf.luma = real_addr_arg.args.real_addr.addr;
- pCTX->phyFrmBuf.chroma = real_addr_arg.args.real_addr.addr + (unsigned int)aligned_y_size;
-
- pCTX->sizeFrmBuf.luma = (unsigned int)y_size;
- pCTX->sizeFrmBuf.chroma = (unsigned int)c_size;
- pCTX->inter_buff_status |= MFC_USE_YUV_BUFF;
-
- input_info->YPhyAddr = (void*)pCTX->phyFrmBuf.luma;
- input_info->CPhyAddr = (void*)pCTX->phyFrmBuf.chroma;
- input_info->YVirAddr = (void*)pCTX->virFrmBuf.luma;
- input_info->CVirAddr = (void*)pCTX->virFrmBuf.chroma;
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
-{
- _MFCLIB *pCTX;
- int ret_code;
- struct mfc_common_args user_addr_arg, real_addr_arg;
- int y_size, c_size;
- int aligned_y_size, aligned_c_size;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcEncSetInBuf] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- LOGV("SsbSipMfcEncSetInBuf] input_info->YPhyAddr & input_info->CPhyAddr should be 64KB aligned");
-
- pCTX = (_MFCLIB *) openHandle;
-
- /* FIXME: */
- y_size = pCTX->width * pCTX->height;
- c_size = (pCTX->width * pCTX->height) >> 1;
-
- /* lenear: 2KB, tile: 8KB */
- aligned_y_size = Align(y_size, 64 * BUF_L_UNIT);
- aligned_c_size = Align(c_size, 64 * BUF_L_UNIT);
-
- pCTX->phyFrmBuf.luma = (unsigned int)input_info->YPhyAddr;
- pCTX->phyFrmBuf.chroma = (unsigned int)input_info->CPhyAddr;
-
- pCTX->sizeFrmBuf.luma = (unsigned int)input_info->YSize;
- pCTX->sizeFrmBuf.chroma = (unsigned int)input_info->CSize;
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetOutBuf(void *openHandle, SSBSIP_MFC_ENC_OUTPUT_INFO *output_info)
-{
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcEncGetOutBuf] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *)openHandle;
-
- output_info->headerSize = pCTX->encodedHeaderSize;
- output_info->dataSize = pCTX->encodedDataSize;
- output_info->frameType = pCTX->encodedframeType;
-
- if (pCTX->encode_cnt == 0) {
- output_info->StrmPhyAddr = (void *)pCTX->phyStrmBuf;
- output_info->StrmVirAddr = (unsigned char *)pCTX->virStrmBuf + pCTX->mapped_addr;
- } else {
- output_info->StrmPhyAddr = (unsigned char *)pCTX->phyStrmBuf + (MAX_ENCODER_OUTPUT_BUFFER_SIZE / 2);
- output_info->StrmVirAddr = (unsigned char *)pCTX->virStrmBuf + pCTX->mapped_addr + (MAX_ENCODER_OUTPUT_BUFFER_SIZE / 2);
- }
-
- pCTX->encode_cnt ++;
- pCTX->encode_cnt %= 2;
-
- output_info->encodedYPhyAddr = (void*)pCTX->encodedphyFrmBuf.luma;
- output_info->encodedCPhyAddr = (void*)pCTX->encodedphyFrmBuf.chroma;
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetOutBuf(void *openHandle, void *phyOutbuf, void *virOutbuf, int outputBufferSize)
-{
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcEncSetOutBuf] openHandle is NULL");
- 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;
- struct mfc_common_args EncArg;
- struct mfc_enc_vui_info vui_info;
- struct mfc_enc_hier_p_qp hier_p_qp;
-#ifdef S3D_SUPPORT
- struct mfc_enc_set_config set_info;
- struct mfc_frame_packing *frame_packing;
-#endif
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcEncSetConfig] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("SsbSipMfcEncSetConfig] value is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
- memset(&EncArg, 0x00, sizeof(struct mfc_common_args));
-
-#ifdef S3D_SUPPORT
- EncArg.args.config.type = conf_type;
-
- switch (conf_type) {
- case MFC_ENC_SETCONF_FRAME_TAG:
- pCTX->inframetag = *((unsigned int *)value);
- return MFC_RET_OK;
- case MFC_ENC_SETCONF_ALLOW_FRAME_SKIP:
- set_info = *((struct mfc_enc_set_config *) value);
- EncArg.args.config.args.basic.values[0] = set_info.enable;
- if (set_info.enable == 2)
- EncArg.args.config.args.basic.values[1] = set_info.number;
- else
- EncArg.args.config.args.basic.values[1] = 0;
- break;
- case MFC_ENC_SETCONF_VUI_INFO:
- set_info = *((struct mfc_enc_set_config *) value);
- EncArg.args.config.args.basic.values[0] = set_info.enable;
- if (set_info.enable == 255) //Re-check this part of code with Jeongtae Park
- EncArg.args.config.args.basic.values[1] = set_info.number;
- else
- EncArg.args.config.args.basic.values[1] = 0;
-
- EncArg.args.config.args.basic.values[1] = set_info.number;
- break;
- case MFC_ENC_SETCONF_FRAME_PACKING:
- frame_packing = (struct mfc_frame_packing *)value;
- /*
- memcpy(&EncArg.args.config.args.frame_packing, frame_packing,
- sizeof(struct mfc_frame_packing));
- */
- EncArg.args.config.args.basic.values[0] = frame_packing->arrangement_type;
- EncArg.args.config.args.basic.values[1] = frame_packing->current_frame_is_frame0_flag;
- break;
- case MFC_ENC_SETCONF_FRAME_TYPE:
- case MFC_ENC_SETCONF_CHANGE_FRAME_RATE:
- case MFC_ENC_SETCONF_CHANGE_BIT_RATE:
- case MFC_ENC_SETCONF_I_PERIOD:
- case MFC_ENC_SETCONF_HIER_P:
- case MFC_ENC_SETCONF_SEI_GEN:
- EncArg.args.config.args.basic.values[0] = *((int *) value);
- EncArg.args.config.args.basic.values[1] = 0;
- break;
- default:
- LOGE("SsbSipMfcEncSetConfig] not supported type");
- return MFC_RET_ENC_SET_CONF_FAIL;
- }
-#else
- EncArg.args.set_config.in_config_param = conf_type;
- switch (conf_type) {
- case MFC_ENC_SETCONF_FRAME_TAG:
- pCTX->inframetag = *((unsigned int *)value);
- return MFC_RET_OK;
- case MFC_ENC_SETCONF_VUI_INFO:
- vui_info = *((struct mfc_enc_vui_info *) value);
- EncArg.args.set_config.in_config_value[0] = (int)(vui_info.aspect_ratio_idc);
- EncArg.args.set_config.in_config_value[1] = 0;
- break;
- case MFC_ENC_SETCONF_HIER_P:
- hier_p_qp = *((struct mfc_enc_hier_p_qp *) value);
- EncArg.args.set_config.in_config_value[0] = (int)(hier_p_qp.t0_frame_qp);
- EncArg.args.set_config.in_config_value[1] = (int)(hier_p_qp.t2_frame_qp);
- EncArg.args.set_config.in_config_value[2] = (int)(hier_p_qp.t3_frame_qp);
- break;
- default:
- EncArg.args.set_config.in_config_value[0] = *((int *) value);
- EncArg.args.set_config.in_config_value[1] = 0;
- break;
- }
-#endif
-
- ret_code = ioctl(pCTX->hMFC, IOCTL_MFC_SET_CONFIG, &EncArg);
- if (EncArg.ret_code != MFC_OK) {
- LOGE("SsbSipMfcEncSetConfig] IOCTL_MFC_SET_CONFIG failed(ret : %d)", 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)
-{
- _MFCLIB *pCTX;
- /*
- unsigned int *encoded_header_size;
- */
-
- pCTX = (_MFCLIB *)openHandle;
-
- if (openHandle == NULL) {
- LOGE("SsbSipMfcEncGetConfig] openHandle is NULL");
- return MFC_RET_INVALID_PARAM;
- }
- if (value == NULL) {
- LOGE("SsbSipMfcEncGetConfig] value is NULL");
- return MFC_RET_INVALID_PARAM;
- }
-
- switch (conf_type) {
- case MFC_ENC_GETCONF_FRAME_TAG:
- *((unsigned int *)value) = pCTX->outframetagtop;
- break;
-#if 0
- case MFC_ENC_GETCONF_HEADER_SIZE:
- encoded_header_size = (unsigned int *)value;
- *encoded_header_size = pCTX->encodedHeaderSize;
- break;
-#endif
- default:
- LOGE("SsbSipMfcEncGetConfig] No such conf_type is supported.");
- return MFC_RET_INVALID_PARAM;
- }
-
- return MFC_RET_OK;
-}
-
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/SsbSipMfcApi.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/SsbSipMfcApi.h
deleted file mode 100644
index fed3e34..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/SsbSipMfcApi.h
+++ /dev/null
@@ -1,420 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 _SSBSIP_MFC_API_H_
-#define _SSBSIP_MFC_API_H_
-
-/*--------------------------------------------------------------------------------*/
-/* Definition */
-/*--------------------------------------------------------------------------------*/
-#define MAX_DECODER_INPUT_BUFFER_SIZE (1024 * 3072)
-#define MAX_ENCODER_OUTPUT_BUFFER_SIZE (1024 * 3072)
-
-#define SUPPORT_1080P 1
-
-#if SUPPORT_1080P
-#define MMAP_BUFFER_SIZE_MMAP (70*1024*1024) /* only C110 use this value. in C210, memory size is decided in menuconfig*/
-#else
-#define MMAP_BUFFER_SIZE_MMAP (62*1024*1024)
-#endif
-
-#define SAMSUNG_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,
- NV21_LINEAR
-} SSBSIP_MFC_INSTRM_MODE_TYPE;
-
-typedef enum {
- FRAME = 0,
- SLICE,
-} SSBSIP_MFC_OUTSTRM_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,
-
- /* C210 specific feature */
- MFC_DEC_SETCONF_IMMEDIATELY_DISPLAY,
- MFC_DEC_SETCONF_DPB_FLUSH,
- MFC_DEC_SETCONF_PIXEL_CACHE,
-#ifndef S3D_SUPPORT
- MFC_DEC_GETCONF_WIDTH_HEIGHT
-#else
- MFC_DEC_GETCONF_WIDTH_HEIGHT,
- MFC_DEC_SETCONF_SEI_PARSE,
- MFC_DEC_GETCONF_FRAME_PACKING
-#endif
-} 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,
-
- /* C210 specific feature */
- MFC_ENC_SETCONF_VUI_INFO,
- MFC_ENC_SETCONF_I_PERIOD,
-#ifndef S3D_SUPPORT
- MFC_ENC_SETCONF_HIER_P
-#else
- MFC_ENC_SETCONF_HIER_P,
- MFC_ENC_SETCONF_SEI_GEN,
- MFC_ENC_SETCONF_FRAME_PACKING
-#endif
-} 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,
- MFC_GETOUTBUF_CHANGE_RESOL
-} 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 */
- int disp_pic_frame_type; /* [OUT] display picture frame type information */
-
- /* C210 UMP feature */
- unsigned int y_cookie; /* [OUT] cookie for Y address */
- unsigned int c_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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 */
-
- /* C210 UMP feature */
- unsigned int y_cookie; /* [OUT] cookie for Y address */
- unsigned int c_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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 */
-
- /* C210 UMP feature */
- unsigned int strm_cookie; /* [OUT] cooke for stream buffer */
- unsigned int y_encoded_cookie; /* [OUT] cookie for Y address */
- unsigned int c_encoded_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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) */
- SSBSIP_MFC_OUTSTRM_MODE_TYPE OutputMode; /* [IN] Output mode: Frame/Slice */
-
- /* 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) */
- SSBSIP_MFC_OUTSTRM_MODE_TYPE OutputMode; /* [IN] Output mode: Frame/Slice */
-
- /* 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 S3D_SUPPORT
-typedef struct {
- int available;
- unsigned int arrangement_id;
- int arrangement_cancel_flag;
- unsigned char arrangement_type;
- int quincunx_sampling_flag;
- unsigned char content_interpretation_type;
- int spatial_flipping_flag;
- int frame0_flipped_flag;
- int field_views_flag;
- int current_frame_is_frame0_flag;
- unsigned char frame0_grid_pos_x;
- unsigned char frame0_grid_pos_y;
- unsigned char frame1_grid_pos_x;
- unsigned char frame1_grid_pos_y;
-} SSBSIP_MFC_FRAME_PACKING;
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*--------------------------------------------------------------------------------*/
-/* Decoding APIs */
-/*--------------------------------------------------------------------------------*/
-void *SsbSipMfcDecOpen(void);
-void *SsbSipMfcDecOpenExt(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);
-
-
-#if (defined(CONFIG_VIDEO_MFC_VCM_UMP) || defined(USE_UMP))
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, unsigned int secure_id, int size);
-#else
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, void *phyInBuf, void *virInBuf, int size);
-#endif
-
-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);
-
-void *SsbSipMfcDecAllocInputBuffer(void *openHandle, void **phyInBuf, int inputBufferSize);
-void SsbSipMfcDecFreeInputBuffer(void *openHandle, void *phyInBuf);
-
-/*--------------------------------------------------------------------------------*/
-/* Encoding APIs */
-/*--------------------------------------------------------------------------------*/
-void *SsbSipMfcEncOpen(void);
-void *SsbSipMfcEncOpenExt(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 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/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/mfc_errno.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/mfc_errno.h
deleted file mode 100644
index 305a28e..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/mfc_errno.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 __MFC_ERRNO_H
-#define __MFC_ERRNO_H __FILE__
-
-enum mfc_ret_code {
- MFC_OK = 1,
- MFC_FAIL = -1000,
- MFC_OPEN_FAIL = -1001,
- MFC_CLOSE_FAIL = -1002,
-
- MFC_DEC_INIT_FAIL = -2000,
- MFC_DEC_EXE_TIME_OUT = -2001,
- MFC_DEC_EXE_ERR = -2002,
- MFC_DEC_GET_INBUF_FAIL = 2003,
- MFC_DEC_SET_INBUF_FAIL = 2004,
- MFC_DEC_GET_OUTBUF_FAIL = -2005,
- MFC_DEC_GET_CONF_FAIL = -2006,
- MFC_DEC_SET_CONF_FAIL = -2007,
-
- MFC_ENC_INIT_FAIL = -3000,
- MFC_ENC_EXE_TIME_OUT = -3001,
- MFC_ENC_EXE_ERR = -3002,
- MFC_ENC_GET_INBUF_FAIL = -3003,
- MFC_ENC_SET_INBUF_FAIL = -3004,
- MFC_ENC_GET_OUTBUF_FAIL = -3005,
- MFC_ENC_SET_OUTBUF_FAIL = -3006,
- MFC_ENC_GET_CONF_FAIL = -3007,
- MFC_ENC_SET_CONF_FAIL = -3008,
-
- MFC_STATE_INVALID = -4000,
- MFC_DEC_HEADER_FAIL = -4001,
- MFC_DEC_INIT_BUF_FAIL = -4002,
- MFC_ENC_HEADER_FAIL = -5000,
- MFC_ENC_PARAM_FAIL = -5001,
- MFC_FRM_BUF_SIZE_FAIL = -6000,
- MFC_FW_LOAD_FAIL = -6001,
- MFC_FW_INIT_FAIL = -6002,
- MFC_INST_NUM_EXCEEDED_FAIL = -6003,
- MFC_MEM_ALLOC_FAIL = -6004,
- MFC_MEM_INVALID_ADDR_FAIL = -6005,
- MFC_MEM_MAPPING_FAIL = -6006,
- MFC_GET_CONF_FAIL = -6007,
- MFC_SET_CONF_FAIL = -6008,
- MFC_INVALID_PARAM_FAIL = -6009,
- MFC_API_FAIL = -9000,
-
- MFC_CMD_FAIL = -1003,
- MFC_SLEEP_FAIL = -1010,
- MFC_WAKEUP_FAIL = -1020,
-
- MFC_CLK_ON_FAIL = -1030,
- MFC_CLK_OFF_FAIL = -1030,
- MFC_PWR_ON_FAIL = -1040,
- MFC_PWR_OFF_FAIL = -1041,
-} ;
-
-#endif /* __MFC_ERRNO_H */
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/mfc_interface.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/mfc_interface.h
deleted file mode 100644
index 968da44..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/mfc_interface.h
+++ /dev/null
@@ -1,525 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 __MFC_INTERFACE_H
-#define __MFC_INTERFACE_H __FILE__
-
-#include "mfc_errno.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_REAL_ADDR (0x00800012)
-#define IOCTL_MFC_GET_MMAP_SIZE (0x00800014)
-#define IOCTL_MFC_SET_IN_BUF (0x00800018)
-
-#define IOCTL_MFC_SET_CONFIG (0x00800101)
-#define IOCTL_MFC_GET_CONFIG (0x00800102)
-
-#define IOCTL_MFC_SET_BUF_CACHE (0x00800201)
-
-/* MFC H/W support maximum 32 extra DPB. */
-#define MFC_MAX_EXTRA_DPB 5
-#define MFC_MAX_DISP_DELAY 0xF
-
-#define MFC_LIB_VER_MAJOR 1
-#define MFC_LIB_VER_MINOR 00
-
-#define BUF_L_UNIT (1024)
-#define Align(x, alignbyte) (((x)+(alignbyte)-1)/(alignbyte)*(alignbyte))
-
-enum inst_type {
- DECODER = 0x1,
- ENCODER = 0x2,
-};
-
-typedef enum {
- MFC_UNPACKED_PB = 0,
- MFC_PACKED_PB = 1
-} mfc_packed_mode;
-
-
-typedef enum
-{
- MFC_USE_NONE = 0x00,
- MFC_USE_YUV_BUFF = 0x01,
- MFC_USE_STRM_BUFF = 0x10
-} s3c_mfc_interbuff_status;
-
-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) */
-} SSBSIP_MFC_CRC_DATA;
-
-struct mfc_strm_ref_buf_arg {
- unsigned int strm_ref_y;
- unsigned int mv_ref_yc;
-};
-
-struct mfc_frame_buf_arg {
- unsigned int luma;
- unsigned int chroma;
-};
-
-
-struct mfc_enc_init_common_arg {
- 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_gop_num; /* [IN] GOP Number (interval of I-frame) */
- int in_vop_quant; /* [IN] VOP quant */
- int in_vop_quant_p; /* [IN] VOP quant for P frame */
-
- /* [IN] RC enable */
- /* [IN] RC enable (0:disable, 1:frame level RC) */
- int in_rc_fr_en;
- int in_rc_bitrate; /* [IN] RC parameter (bitrate in kbps) */
-
- int in_rc_qbound_min; /* [IN] RC parameter (Q bound Min) */
- int in_rc_qbound_max; /* [IN] RC parameter (Q bound Max) */
- int in_rc_rpara; /* [IN] RC parameter (Reaction Coefficient) */
-
- /* [IN] Multi-slice mode (0:single, 1:multiple) */
- int in_ms_mode;
- /* [IN] Multi-slice size (in num. of mb or byte) */
- int in_ms_arg;
-
- int in_mb_refresh; /* [IN] Macroblock refresh */
-
- /* [IN] Enable (1) / Disable (0) padding with the specified values */
- int in_pad_ctrl_on;
-
- /* [IN] pad value if pad_ctrl_on is Enable */
- int in_y_pad_val;
- int in_cb_pad_val;
- int in_cr_pad_val;
-
- /* linear or tiled */
- int in_frame_map;
-
- unsigned int in_pixelcache;
-
-
- unsigned int in_mapped_addr;
- struct mfc_strm_ref_buf_arg out_u_addr;
- struct mfc_strm_ref_buf_arg out_p_addr;
- struct mfc_strm_ref_buf_arg out_buf_size;
- unsigned int out_header_size;
-};
-
-struct mfc_enc_init_h263_arg {
- int in_rc_framerate; /* [IN] RC parameter (framerate) */
-};
-
-struct mfc_enc_init_mpeg4_arg {
- int in_profile; /* [IN] profile */
- int in_level; /* [IN] level */
-
- int in_vop_quant_b; /* [IN] VOP quant for B frame */
-
- /* [IN] B frame number */
- int in_bframenum;
-
- /* [IN] Quarter-pel MC enable (1:enabled, 0:disabled) */
- int in_quart_pixel;
-
- int in_TimeIncreamentRes; /* [IN] VOP time resolution */
- int in_VopTimeIncreament; /* [IN] Frame delta */
-};
-
-struct mfc_enc_init_h264_arg {
- int in_profile; /* [IN] profile */
- int in_level; /* [IN] level */
-
- int in_vop_quant_b; /* [IN] VOP quant for B frame */
-
- /* [IN] B frame number */
- int in_bframenum;
-
- /* [IN] interlace mode(0:progressive, 1:interlace) */
- int in_interlace_mode;
-
- /* [IN] reference number */
- int in_reference_num;
- /* [IN] reference number of P frame */
- int in_ref_num_p;
-
- int in_rc_framerate; /* [IN] RC parameter (framerate) */
- int in_rc_mb_en; /* [IN] RC enable (0:disable, 1:MB level RC) */
- /* [IN] MB level rate control dark region adaptive feature */
- int in_rc_mb_dark_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control smooth region adaptive feature */
- int in_rc_mb_smooth_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control static region adaptive feature */
- int in_rc_mb_static_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control activity region adaptive feature */
- int in_rc_mb_activity_dis; /* (0:enable, 1:disable) */
-
- /* [IN] disable deblocking filter idc */
- int in_deblock_dis; /* (0: enable,1: disable, 2:Disable at slice boundary) */
- /* [IN] slice alpha c0 offset of deblocking filter */
- int in_deblock_alpha_c0;
- /* [IN] slice beta offset of deblocking filter */
- int in_deblock_beta;
-
- /* [IN] ( 0 : CAVLC, 1 : CABAC ) */
- int in_symbolmode;
- /* [IN] (0: only 4x4 transform, 1: allow using 8x8 transform) */
- int in_transform8x8_mode;
-
- /* [IN] Inter weighted parameter for mode decision */
- int in_md_interweight_pps;
- /* [IN] Intra weighted parameter for mode decision */
- int in_md_intraweight_pps;
-};
-
-struct mfc_enc_init_arg {
- struct mfc_enc_init_common_arg cmn;
- union {
- struct mfc_enc_init_h264_arg h264;
- struct mfc_enc_init_mpeg4_arg mpeg4;
- struct mfc_enc_init_h263_arg h263;
- } codec;
-};
-
-struct mfc_enc_exe_arg {
- 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 */
- unsigned 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_Y_addr; /* [OUT]Out-buffer addr of encoded Y component */
- unsigned int out_CbCr_addr; /* [OUT]Out-buffer addr of encoded CbCr component */
- unsigned int out_frametag_top; /* [OUT] unique frame ID of an output frame or top field */
- unsigned int out_frametag_bottom; /* [OUT] unique frame ID of bottom field */
-
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int out_y_secure_id;
- unsigned int out_c_secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int out_y_cookie;
- unsigned int out_c_cookie;
-#endif
-};
-
-struct mfc_dec_init_arg {
- SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN] codec type */
- int in_strm_buf; /* [IN] address of stream buffer */
- int in_strm_size; /* [IN] filled size in stream buffer */
- int in_packed_PB; /* [IN] Is packed PB frame or not, 1: packedPB 0: unpacked */
-
- unsigned int in_crc; /* [IN] */
- unsigned int in_pixelcache; /* [IN] */
- unsigned int in_slice; /* [IN] */
- unsigned int in_numextradpb; /* [IN] */
-
- unsigned int in_mapped_addr;
-
- int out_frm_width; /* [OUT] width of YUV420 frame */
- int out_frm_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_right_offset; /* [OUT] crop information for h264 */
- int out_crop_left_offset;
- int out_crop_bottom_offset;
- int out_crop_top_offset;
-};
-
-struct mfc_dec_exe_arg {
- SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN] codec type */
- int in_strm_buf; /* [IN] the physical address of STRM_BUF */
- /* [IN] Size of video stream filled in STRM_BUF */
- int in_strm_size;
- /* [IN] the address of dpb FRAME_BUF */
- struct mfc_frame_buf_arg in_frm_buf;
- /* [IN] size of dpb FRAME_BUF */
- struct mfc_frame_buf_arg in_frm_size;
- /* [IN] Unique frame ID eg. application specific timestamp */
- unsigned int in_frametag;
- /* [IN] immdiate Display for seek,thumbnail and one frame */
- int in_immediately_disp;
- /* [OUT] the physical address of display buf */
- int out_display_Y_addr;
- /* [OUT] the physical address of display buf */
- int out_display_C_addr;
- int out_display_status;
- /* [OUT] unique frame ID of an output frame or top field */
- unsigned int out_frametag_top;
- /* [OUT] unique frame ID of bottom field */
- unsigned int out_frametag_bottom;
- int out_pic_time_top;
- int out_pic_time_bottom;
- int out_consumed_byte;
-
- int out_crop_right_offset;
- int out_crop_left_offset;
- int out_crop_bottom_offset;
- int out_crop_top_offset;
-
- /* in new driver, each buffer offset must be return to the user */
- int out_y_offset;
- int out_c_offset;
-
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int out_y_secure_id;
- unsigned int out_c_secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int out_y_cookie;
- unsigned int out_c_cookie;
-#endif
- 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_disp_pic_frame_type; /* [OUT] display picture frame type information */
-};
-
-#ifdef S3D_SUPPORT
-struct mfc_basic_config {
- int values[4];
-};
-
-struct mfc_frame_packing {
- int available;
- unsigned int arrangement_id;
- int arrangement_cancel_flag;
- unsigned char arrangement_type;
- int quincunx_sampling_flag;
- unsigned char content_interpretation_type;
- int spatial_flipping_flag;
- int frame0_flipped_flag;
- int field_views_flag;
- int current_frame_is_frame0_flag;
- unsigned char frame0_grid_pos_x;
- unsigned char frame0_grid_pos_y;
- unsigned char frame1_grid_pos_x;
- unsigned char frame1_grid_pos_y;
-};
-
-union _mfc_config_arg {
- struct mfc_basic_config basic;
- struct mfc_frame_packing frame_packing;
-};
-
-struct mfc_config_arg {
- int type;
- union _mfc_config_arg args;
-};
-#else
-struct mfc_get_config_arg {
- /* [IN] Configurable parameter type */
- int in_config_param;
-
- /* [IN] Values to get for the configurable parameter. */
- /* Maximum four integer values can be obtained; */
- int out_config_value[4];
-};
-
-struct mfc_set_config_arg {
- /* [IN] Configurable parameter type */
- int in_config_param;
-
- /* [IN] Values to be set for the configurable parameter. */
- /* Maximum four integer values can be set. */
- int in_config_value[4];
-};
-#endif
-
-struct mfc_get_real_addr_arg {
- unsigned int key;
- unsigned int addr;
-};
-
-struct mfc_buf_alloc_arg {
- enum inst_type type;
- int size;
- /*
- unsigned int mapped;
- */
- unsigned int align;
-
- unsigned int addr;
- /*
- unsigned int phys;
- */
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- /* FIMXE: invalid secure id == -1 */
- unsigned int secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int cookie;
-#else
- unsigned int offset;
-#endif
-};
-
-struct mfc_buf_free_arg {
- unsigned int addr;
-};
-
-
-/* RMVME */
-struct mfc_mem_alloc_arg {
- enum inst_type type;
- int buff_size;
- SSBIP_MFC_BUFFER_TYPE buf_cache_type;
- unsigned int mapped_addr;
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int cookie;
-#else
- unsigned int offset;
-#endif
-};
-
-struct mfc_mem_free_arg {
- unsigned int key;
-};
-/* RMVME */
-
-union mfc_args {
- /*
- struct mfc_enc_init_arg enc_init;
-
- struct mfc_enc_init_mpeg4_arg enc_init_mpeg4;
- struct mfc_enc_init_mpeg4_arg enc_init_h263;
- struct mfc_enc_init_h264_arg enc_init_h264;
- */
- struct mfc_enc_init_arg enc_init;
- struct mfc_enc_exe_arg enc_exe;
-
- struct mfc_dec_init_arg dec_init;
- struct mfc_dec_exe_arg dec_exe;
-
-#ifdef S3D_SUPPORT
- struct mfc_config_arg config;
-#else
- struct mfc_get_config_arg get_config;
- struct mfc_set_config_arg set_config;
-#endif
-
- struct mfc_buf_alloc_arg buf_alloc;
- struct mfc_buf_free_arg buf_free;
- struct mfc_get_real_addr_arg real_addr;
-
- /* RMVME */
- struct mfc_mem_alloc_arg mem_alloc;
- struct mfc_mem_free_arg mem_free;
- /* RMVME */
-};
-
-struct mfc_common_args {
- enum mfc_ret_code ret_code; /* [OUT] error code */
- union mfc_args args;
-};
-
-struct mfc_enc_vui_info {
- int aspect_ratio_idc;
-};
-
-struct mfc_dec_fimv1_info {
- int width;
- int height;
-};
-
-struct mfc_enc_hier_p_qp {
- int t0_frame_qp;
- int t2_frame_qp;
- int t3_frame_qp;
-};
-
-#ifdef S3D_SUPPORT
-struct mfc_enc_set_config {
- int enable;
- int number;
-};
-#endif
-
-typedef struct
-{
- int magic;
- int hMFC;
- int hVMEM;
- int width;
- int height;
- int sizeStrmBuf;
- struct mfc_frame_buf_arg sizeFrmBuf;
- int displayStatus;
- int inter_buff_status;
- unsigned int virFreeStrmAddr;
- unsigned int phyStrmBuf;
- unsigned int virStrmBuf;
- unsigned int virMvRefYC;
- struct mfc_frame_buf_arg phyFrmBuf;
- struct mfc_frame_buf_arg virFrmBuf;
- unsigned int mapped_addr;
- unsigned int mapped_size;
- struct mfc_common_args MfcArg;
- SSBSIP_MFC_CODEC_TYPE codecType;
- SSBSIP_MFC_DEC_OUTPUT_INFO decOutInfo;
- unsigned int inframetag;
- unsigned int outframetagtop;
- unsigned int outframetagbottom;
- unsigned int immediatelydisp;
- unsigned int encodedHeaderSize;
- int encodedDataSize;
- unsigned int encodedframeType;
- struct mfc_frame_buf_arg encodedphyFrmBuf;
-
- unsigned int dec_crc;
- unsigned int dec_pixelcache;
- unsigned int dec_slice;
- unsigned int dec_numextradpb;
-
- int input_cookie;
- int input_secure_id;
- int input_size;
-
- /* to support non-blocking mode */
- unsigned int encode_cnt;
-} _MFCLIB;
-
-#define ENC_PROFILE_LEVEL(profile, level) ((profile) | ((level) << 8))
-#define ENC_RC_QBOUND(min_qp, max_qp) ((min_qp) | ((max_qp) << 8))
-
-#endif /* __MFC_INTERFACE_H */
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/Android.mk b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/Android.mk
deleted file mode 100644
index f135163..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/Android.mk
+++ /dev/null
@@ -1,34 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_COPY_HEADERS_TO := libsecmm
-LOCAL_COPY_HEADERS := \
- include/mfc_errno.h \
- include/mfc_interface.h \
- include/SsbSipMfcApi.h
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- dec/src/SsbSipMfcDecAPI.c \
- enc/src/SsbSipMfcEncAPI.c
-
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/include \
- $(BOARD_HAL_PATH)/include
-
-LOCAL_MODULE := libsecmfcapi
-
-LOCAL_PRELINK_MODULE := false
-
-ifeq ($(BOARD_USES_MFC_FPS),true)
-LOCAL_CFLAGS := -DCONFIG_MFC_FPS
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES :=
-LOCAL_SHARED_LIBRARIES := liblog
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/dec/src/SsbSipMfcDecAPI.c b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/dec/src/SsbSipMfcDecAPI.c
deleted file mode 100644
index 510a351..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/dec/src/SsbSipMfcDecAPI.c
+++ /dev/null
@@ -1,1352 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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.
- */
-
-#include <stdio.h>
-#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 <sys/poll.h>
-#include "videodev2.h"
-
-#include "mfc_interface.h"
-#include "SsbSipMfcApi.h"
-
-/* #define LOG_NDEBUG 0 */
-#define LOG_TAG "MFC_DEC_APP"
-#include <utils/Log.h>
-
-#ifdef CONFIG_MFC_FPS
-#include <sys/time.h>
-#endif
-
-/*#define CRC_ENABLE
-#define SLICE_MODE_ENABLE */
-#define POLL_DEC_WAIT_TIMEOUT 25
-
-#define USR_DATA_START_CODE (0x000001B2)
-#define VOP_START_CODE (0x000001B6)
-#define MP4_START_CODE (0x000001)
-
-#ifdef CONFIG_MFC_FPS
-unsigned int framecount, over30ms;
-struct timeval mTS1, mTS2, mDec1, mDec2;
-#endif
-
-#define DEFAULT_NUMBER_OF_EXTRA_DPB 5
-
-static char *mfc_dev_name = SAMSUNG_MFC_DEV_NAME;
-static int mfc_dev_node = 6;
-
-static void getAByte(char *buff, int *code)
-{
- int byte;
-
- *code = (*code << 8);
- byte = (int)*buff;
- byte &= 0xFF;
- *code |= byte;
-}
-
-static int isPBPacked(_MFCLIB *pCtx, int Frameleng)
-{
- char *strmBuffer = NULL;
- int startCode = 0xFFFFFFFF;
- int leng_idx = 1;
-
- strmBuffer = (char*)pCtx->virStrmBuf;
-
- while (1) {
- while (startCode != USR_DATA_START_CODE) {
- if ((startCode == VOP_START_CODE) || (leng_idx == Frameleng)) {
- LOGI("[%s] VOP START Found !!.....return",__func__);
- LOGW("[%s] Non Packed PB",__func__);
- return 0;
- }
- getAByte(strmBuffer, &startCode);
- LOGV(">> StartCode = 0x%08x <<\n", startCode);
- strmBuffer++;
- leng_idx++;
- }
- LOGI("[%s] User Data Found !!",__func__);
-
- do {
- if (*strmBuffer == 'p') {
- LOGW("[%s] Packed PB",__func__);
- return 1;
- }
- getAByte(strmBuffer, &startCode);
- strmBuffer++; leng_idx++;
- } while ((leng_idx <= Frameleng) && ((startCode >> 8) != MP4_START_CODE));
-
- if (leng_idx > Frameleng)
- break;
- }
-
- LOGW("[%s] Non Packed PB",__func__);
-
- return 0;
-}
-
-static void getMFCName(char *devicename, int size)
-{
- snprintf(devicename, size, "%s%d", SAMSUNG_MFC_DEV_NAME, mfc_dev_node);
-}
-
-void SsbSipMfcDecSetMFCNode(int devicenode)
-{
- mfc_dev_node = devicenode;
-}
-
-void SsbSipMfcDecSetMFCName(char *devicename)
-{
- mfc_dev_name = devicename;
-}
-
-void *SsbSipMfcDecOpen(void)
-{
- int hMFCOpen;
- _MFCLIB *pCTX;
-
- char mfc_dev_name[64];
-
- int ret;
- unsigned int i, j;
- struct v4l2_capability cap;
- struct v4l2_format fmt;
-
- struct v4l2_requestbuffers reqbuf;
- struct v4l2_buffer buf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
- LOGI("[%s] MFC Library Ver %d.%02d",__func__, MFC_LIB_VER_MAJOR, MFC_LIB_VER_MINOR);
-#ifdef CONFIG_MFC_FPS
- framecount = 0;
- over30ms = 0;
- gettimeofday(&mTS1, NULL);
-#endif
- pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
- if (pCTX == NULL) {
- LOGE("[%s] malloc failed.",__func__);
- return NULL;
- }
-
- memset(pCTX, 0, sizeof(_MFCLIB));
-
- getMFCName(mfc_dev_name, 64);
- LOGI("[%s] dev name is %s",__func__,mfc_dev_name);
-
- if (access(mfc_dev_name, F_OK) != 0) {
- LOGE("[%s] MFC device node not exists",__func__);
- goto error_case1;
- }
-
- hMFCOpen = open(mfc_dev_name, O_RDWR|O_NONBLOCK, 0);
- if (hMFCOpen < 0) {
- LOGE("[%s] Failed to open MFC device",__func__);
- goto error_case1;
- }
-
- pCTX->hMFC = hMFCOpen;
-
- memset(&cap, 0, sizeof(cap));
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYCAP, &cap);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QUERYCAP failed",__func__);
- goto error_case2;
- }
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
- LOGE("[%s] Device does not support capture",__func__);
- goto error_case2;
- }
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
- LOGE("[%s] Device does not support output",__func__);
- goto error_case2;
- }
-
- if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
- LOGE("[%s] Device does not support streaming",__func__);
- goto error_case2;
- }
-
- pCTX->inter_buff_status = MFC_USE_NONE;
- memset(&fmt, 0, sizeof(fmt));
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264; /* Default is set to H264 */
- fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage = MAX_DECODER_INPUT_BUFFER_SIZE;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_FMT, &fmt);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed",__func__);
- goto error_case2;
- }
-
- pCTX->v4l2_dec.mfc_src_bufs_len = MAX_DECODER_INPUT_BUFFER_SIZE;
-
- memset(&(reqbuf), 0, sizeof (reqbuf));
- reqbuf.count = MFC_DEC_NUM_SRC_BUFS;
- reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- reqbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_REQBUFS, &reqbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_REQBUFS failed",__func__);
- goto error_case2;
- }
-
- pCTX->v4l2_dec.mfc_num_src_bufs = reqbuf.count;
-
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_src_bufs; ++i) {
- memset(&(buf), 0, sizeof (buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.index = i;
- buf.m.planes = planes;
- buf.length = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QUERYBUF failed",__func__);
- goto error_case3;
- }
-
- pCTX->v4l2_dec.mfc_src_bufs[i] = mmap(NULL, buf.m.planes[0].length,
- PROT_READ | PROT_WRITE, MAP_SHARED, pCTX->hMFC, buf.m.planes[0].m.mem_offset);
- if (pCTX->v4l2_dec.mfc_src_bufs[i] == MAP_FAILED) {
- LOGE("[%s] mmap failed (%d)",__func__,i);
- goto error_case3;
- }
- }
- pCTX->inter_buff_status |= MFC_USE_STRM_BUFF;
-
- /* set extra DPB size to 5 as default for optimal performce (heuristic method) */
- pCTX->dec_numextradpb = DEFAULT_NUMBER_OF_EXTRA_DPB;
-
- pCTX->v4l2_dec.bBeingFinalized = 0;
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_NOT_RECEIVED;
-
- pCTX->cacheablebuffer = NO_CACHE;
-
- for (i = 0; i<MFC_DEC_NUM_SRC_BUFS; i++)
- pCTX->v4l2_dec.mfc_src_buf_flags[i] = BUF_DEQUEUED;
-
- pCTX->v4l2_dec.beingUsedIndex = 0;
-
- return (void *) pCTX;
-
-error_case3:
- for (j = 0; j < i; j++)
- munmap(pCTX->v4l2_dec.mfc_src_bufs[j], pCTX->v4l2_dec.mfc_src_bufs_len);
-
-error_case2:
- close(pCTX->hMFC);
-
-error_case1:
- free(pCTX);
-
- return NULL;
-}
-
-void *SsbSipMfcDecOpenExt(void *value)
-{
- _MFCLIB *pCTX;
-
- pCTX = SsbSipMfcDecOpen();
-
- if (pCTX == NULL)
- return NULL;
-
- if (NO_CACHE == (*(SSBIP_MFC_BUFFER_TYPE *)value)) {
- pCTX->cacheablebuffer = NO_CACHE;
- LOGI("[%s] non cacheable buffer",__func__);
- } else {
- pCTX->cacheablebuffer = CACHE;
- LOGI("[%s] cacheable buffer",__func__);
- }
-
- return (void *)pCTX;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecClose(void *openHandle)
-{
- int ret, i;
- _MFCLIB *pCTX;
-
- enum v4l2_buf_type type;
-#ifdef CONFIG_MFC_FPS
- LOGI(">>> MFC");
- gettimeofday(&mTS2, NULL);
- LOGI(">>> time=%d", mTS2.tv_sec-mTS1.tv_sec);
- LOGI(">>> framecount=%d", framecount);
- LOGI(">>> 30ms over=%d", over30ms);
-#endif
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (pCTX->inter_buff_status & MFC_USE_DST_STREAMON) {
- type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMOFF, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMOFF failed (destination buffers)",__func__);
- return MFC_RET_CLOSE_FAIL;
- }
- pCTX->inter_buff_status &= ~(MFC_USE_DST_STREAMON);
- }
-
- if (pCTX->inter_buff_status & MFC_USE_SRC_STREAMON) {
- type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMOFF, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMOFF failed (source buffers)",__func__);
- return MFC_RET_CLOSE_FAIL;
- }
- pCTX->inter_buff_status &= ~(MFC_USE_SRC_STREAMON);
- }
-
- if (pCTX->inter_buff_status & MFC_USE_STRM_BUFF) {
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_src_bufs; i++)
- munmap(pCTX->v4l2_dec.mfc_src_bufs[i], pCTX->v4l2_dec.mfc_src_bufs_len);
- pCTX->inter_buff_status &= ~(MFC_USE_STRM_BUFF);
- }
-
- if (pCTX->inter_buff_status & MFC_USE_YUV_BUFF) {
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_dst_bufs; i++) {
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[i][0], pCTX->v4l2_dec.mfc_dst_bufs_len[0]);
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[i][1], pCTX->v4l2_dec.mfc_dst_bufs_len[1]);
- }
- pCTX->inter_buff_status &= ~(MFC_USE_YUV_BUFF);
- }
-
- close(pCTX->hMFC);
- free(pCTX);
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecInit(void *openHandle, SSBSIP_MFC_CODEC_TYPE codec_type, int Frameleng)
-{
- int packedPB = 0;
- _MFCLIB *pCTX;
- int ret;
- unsigned int i, j;
-
- struct v4l2_requestbuffers reqbuf;
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
- struct v4l2_format fmt;
- struct v4l2_pix_format_mplane pix_mp;
- struct v4l2_control ctrl;
- struct v4l2_crop crop;
- enum v4l2_buf_type type;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- pCTX->codecType = codec_type;
-
- if ((pCTX->codecType == MPEG4_DEC) || (pCTX->codecType == XVID_DEC) ||
- (pCTX->codecType == FIMV1_DEC) || (pCTX->codecType == FIMV2_DEC) ||
- (pCTX->codecType == FIMV3_DEC) || (pCTX->codecType == FIMV4_DEC))
- packedPB = isPBPacked(pCTX, Frameleng);
-
- memset(&fmt, 0, sizeof(fmt));
-
- switch (pCTX->codecType) {
- case H264_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
- break;
- case MPEG4_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_MPEG4;
- break;
- case H263_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H263;
- break;
- case XVID_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_XVID;
- break;
- case MPEG2_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_MPEG12;
- break;
- case FIMV1_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_FIMV1;
- fmt.fmt.pix_mp.width = pCTX->fimv1_res.width;
- fmt.fmt.pix_mp.height = pCTX->fimv1_res.height;
- break;
- case FIMV2_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_FIMV2;
- break;
- case FIMV3_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_FIMV3;
- break;
- case FIMV4_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_FIMV4;
- break;
- case VC1_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_VC1;
- break;
- case VC1RCV_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_VC1_RCV;
- break;
- default:
- LOGE("[%s] Does NOT support the standard (%d)",__func__,pCTX->codecType);
- ret = MFC_RET_INVALID_PARAM;
- goto error_case1;
- }
-
- fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage = MAX_DECODER_INPUT_BUFFER_SIZE;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_FMT, &fmt);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- memset(&qbuf, 0, sizeof(qbuf));
-
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = pCTX->v4l2_dec.beingUsedIndex;
- qbuf.m.planes = planes;
- qbuf.length = 1;
- qbuf.m.planes[0].bytesused = Frameleng;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-
- // Processing the header requires running streamon
- // on OUTPUT queue
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMON, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMON failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- pCTX->inter_buff_status |= MFC_USE_SRC_STREAMON;
-
- fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_G_FMT, &fmt);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_FMT failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- pix_mp = fmt.fmt.pix_mp;
- pCTX->decOutInfo.buf_width = pix_mp.plane_fmt[0].bytesperline;
- pCTX->decOutInfo.buf_height =
- pix_mp.plane_fmt[0].sizeimage / pix_mp.plane_fmt[0].bytesperline;
-
- pCTX->decOutInfo.img_width = pix_mp.width;
- pCTX->decOutInfo.img_height = pix_mp.height;
-
- memset(&crop, 0, sizeof(crop));
- crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CROP, &crop);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CROP failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- pCTX->decOutInfo.crop_left_offset = crop.c.left;
- pCTX->decOutInfo.crop_top_offset = crop.c.top;
- pCTX->decOutInfo.crop_right_offset =
- pix_mp.width - crop.c.width - crop.c.left;
- pCTX->decOutInfo.crop_bottom_offset =
- pix_mp.height - crop.c.height - crop.c.top;
-
- memset(&ctrl, 0, sizeof(ctrl));
- ctrl.id = V4L2_CID_CODEC_REQ_NUM_BUFS;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- pCTX->v4l2_dec.mfc_num_dst_bufs = ctrl.value + pCTX->dec_numextradpb;
-
- /* Cacheable buffer */
- ctrl.id = V4L2_CID_CACHEABLE;
- if(pCTX->cacheablebuffer == NO_CACHE)
- ctrl.value = 0;
- else
- ctrl.value = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed, V4L2_CID_CACHEABLE",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- memset(&reqbuf, 0, sizeof(reqbuf));
- reqbuf.count = pCTX->v4l2_dec.mfc_num_dst_bufs;
- reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- reqbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_REQBUFS, &reqbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_REQBUFS failed (destination buffers)",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- pCTX->v4l2_dec.mfc_num_dst_bufs = reqbuf.count;
-
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_dst_bufs; ++i) {
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = i;
- qbuf.m.planes = planes;
- qbuf.length = 2;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QUERYBUF failed (destination buffers)",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- pCTX->v4l2_dec.mfc_dst_bufs_len[0] = qbuf.m.planes[0].length;
- pCTX->v4l2_dec.mfc_dst_bufs_len[1] = qbuf.m.planes[1].length;
-
- pCTX->v4l2_dec.mfc_dst_phys[i][0] = qbuf.m.planes[0].cookie;
- pCTX->v4l2_dec.mfc_dst_phys[i][1] = qbuf.m.planes[1].cookie;
-
- pCTX->v4l2_dec.mfc_dst_bufs[i][0] = mmap(NULL, qbuf.m.planes[0].length,
- PROT_READ | PROT_WRITE, MAP_SHARED, pCTX->hMFC, qbuf.m.planes[0].m.mem_offset);
-
- if (pCTX->v4l2_dec.mfc_dst_bufs[i][0] == MAP_FAILED) {
- LOGE("[%s] mmap failed (destination buffers (Y))",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case2;
- }
-
- pCTX->v4l2_dec.mfc_dst_bufs[i][1] = mmap(NULL, qbuf.m.planes[1].length,
- PROT_READ | PROT_WRITE, MAP_SHARED, pCTX->hMFC, qbuf.m.planes[1].m.mem_offset);
- if (pCTX->v4l2_dec.mfc_dst_bufs[i][1] == MAP_FAILED) {
- LOGE("[%s] mmap failed (destination buffers (UV))",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case2;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case2;
- }
- }
- pCTX->inter_buff_status |= MFC_USE_YUV_BUFF;
-
- type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMON, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMON failed (destination buffers)",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
- pCTX->inter_buff_status |= MFC_USE_DST_STREAMON;
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- if(ret != 0) {
- LOGE("[%s] VIDIOC_DQBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- return MFC_RET_OK;
-
-error_case2:
- for (j = 0; j < i; j++) {
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[j][0], pCTX->v4l2_dec.mfc_dst_bufs_len[0]);
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[j][1], pCTX->v4l2_dec.mfc_dst_bufs_len[1]);
- }
-error_case1:
- SsbSipMfcDecClose(openHandle);
- return ret;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecExe(void *openHandle, int lengthBufFill)
-{
- _MFCLIB *pCTX;
- int ret;
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
- struct pollfd poll_events;
- int poll_state;
-
-#ifdef CONFIG_MFC_FPS
- framecount++;
-#endif
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if ((lengthBufFill < 0) || (lengthBufFill > MAX_DECODER_INPUT_BUFFER_SIZE)) {
- LOGE("[%s] lengthBufFill is invalid. (lengthBufFill=%d)",__func__, lengthBufFill);
- return MFC_RET_INVALID_PARAM;
- }
-
-#ifdef CONFIG_MFC_FPS
- gettimeofday(&mDec1, NULL);
-#endif
- pCTX = (_MFCLIB *) openHandle;
-
- /* note: #define POLLOUT 0x0004 */
- poll_events.fd = pCTX->hMFC;
- poll_events.events = POLLOUT | POLLERR;
- poll_events.revents = 0;
-
- if ((lengthBufFill > 0) && (SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe)) {
- /* Queue the stream frame */
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = pCTX->v4l2_dec.beingUsedIndex;
- qbuf.m.planes = planes;
- qbuf.length = 1;
- qbuf.m.planes[0].bytesused = lengthBufFill;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_DEC_EXE_ERR;
- }
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = 1;
-
- /* wait for decoding */
- do {
- poll_state = poll((struct pollfd*)&poll_events, 1, POLL_DEC_WAIT_TIMEOUT);
- if (0 < poll_state) {
- if (poll_events.revents & POLLOUT) { /* POLLOUT */
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- if (ret == 0) {
- if (qbuf.flags & V4L2_BUF_FLAG_ERROR)
- return MFC_RET_DEC_EXE_ERR;
- break;
- }
- } else if (poll_events.revents & POLLERR) { /* POLLERR */
- LOGE("[%s] POLLERR\n",__func__);
- return MFC_RET_DEC_EXE_ERR;
- } else {
- LOGE("[%s] poll() returns 0x%x\n",__func__, poll_events.revents);
- return MFC_RET_DEC_EXE_ERR;
- }
- } else if (0 > poll_state) {
- return MFC_RET_DEC_EXE_ERR;
- }
- } while (0 == poll_state);
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = MFC_DEC_NUM_PLANES;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
-
- if (ret != 0) {
- pCTX->displayStatus = MFC_GETOUTBUF_DECODING_ONLY;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return MFC_RET_OK;
- } else {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_DECODING;
- }
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][1];
-
- if (SSBSIP_MFC_LAST_FRAME_RECEIVED == pCTX->lastframe)
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_PROCESSED;
-
- } else if(pCTX->v4l2_dec.bBeingFinalized == 0) {
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_PROCESSED;
-
- /* Queue the stream frame */
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = pCTX->v4l2_dec.beingUsedIndex;
- qbuf.m.planes = planes;
- qbuf.length = 1;
- qbuf.m.planes[0].bytesused = 0;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_DEC_EXE_ERR;
- }
-
- pCTX->v4l2_dec.bBeingFinalized = 1; /* true */
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = MFC_DEC_NUM_PLANES;
- /* FIXME
- wait for decoding */
- do {
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- } while (ret != 0);
-
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][1];
- } else {
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = MFC_DEC_NUM_PLANES;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
-
- if (qbuf.m.planes[0].bytesused == 0) {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_END;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return MFC_RET_OK;
- } else {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
- }
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][1];
- }
-
- pCTX->decOutInfo.disp_pic_frame_type = (qbuf.flags & (0x7 << 3));
-
- switch (pCTX->decOutInfo.disp_pic_frame_type) {
- case V4L2_BUF_FLAG_KEYFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 1;
- break;
- case V4L2_BUF_FLAG_PFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 2;
- break;
- case V4L2_BUF_FLAG_BFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 3;
- break;
- default:
- pCTX->decOutInfo.disp_pic_frame_type = 0;
- break;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
-
-#ifdef CONFIG_MFC_FPS
- gettimeofday(&mDec2, NULL);
- if (mDec2.tv_usec-mDec1.tv_usec > 30000) over30ms++;
-#endif
- return MFC_RET_OK;
-}
-
-#if 0
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecExeNb(void *openHandle, int lengthBufFill)
-{
- _MFCLIB *pCTX;
- int ret;
-
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
-#ifdef CONFIG_MFC_FPS
- framecount++;
-#endif
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if ((lengthBufFill < 0) || (lengthBufFill > MAX_DECODER_INPUT_BUFFER_SIZE)) {
- LOGE("[%s] lengthBufFill is invalid. (lengthBufFill=%d)",__func__, lengthBufFill);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if ((lengthBufFill > 0) && (SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe)) {
- /* Queue the stream frame */
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = pCTX->v4l2_dec.beingUsedIndex;
- qbuf.m.planes = planes;
- qbuf.length = 1;
- qbuf.m.planes[0].bytesused = lengthBufFill;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_DEC_EXE_ERR;
- }
- } else if(pCTX->v4l2_dec.bBeingFinalized == 0) {
- /* Queue the stream frame */
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = pCTX->v4l2_dec.beingUsedIndex;
- qbuf.m.planes = planes;
- qbuf.length = 1;
- qbuf.m.planes[0].bytesused = 0;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_DEC_EXE_ERR;
- }
- }
-
- if ((SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe) && (lengthBufFill == 0))
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_RECEIVED;
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecWaitForOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info)
-{
- _MFCLIB *pCTX;
- int ret;
-
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
- struct pollfd poll_events;
- int poll_state;
-
- pCTX = (_MFCLIB *) openHandle;
-
- /* note: #define POLLOUT 0x0004 */
- poll_events.fd = pCTX->hMFC;
- poll_events.events = POLLOUT | POLLERR;
- poll_events.revents = 0;
-
- if (SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe) {
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = 1;
-
- /* wait for decoding */
- do {
- poll_state = poll((struct pollfd*)&poll_events, 1, POLL_DEC_WAIT_TIMEOUT);
- if (0 < poll_state) {
- if (poll_events.revents & POLLOUT) { /* POLLOUT */
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- if (ret == 0) {
- if (qbuf.flags & V4L2_BUF_FLAG_ERROR)
- return MFC_GETOUTBUF_STATUS_NULL;
- break;
- }
- } else if (poll_events.revents & POLLERR) { /* POLLERR */
- LOGE("[%s] POLLERR\n",__func__);
- return MFC_GETOUTBUF_STATUS_NULL;
- } else {
- LOGE("[%s] poll() returns 0x%x\n",__func__, poll_events.revents);
- return MFC_GETOUTBUF_STATUS_NULL;
- }
- } else if (0 > poll_state) {
- return MFC_GETOUTBUF_STATUS_NULL;
- }
- } while (0 == poll_state);
-
- pCTX->v4l2_dec.mfc_src_buf_flags[qbuf.index] = BUF_DEQUEUED;
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = MFC_DEC_NUM_PLANES;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
-
- if (ret != 0) {
- pCTX->displayStatus = MFC_GETOUTBUF_DECODING_ONLY;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return SsbSipMfcDecGetOutBuf(pCTX, output_info);;
- } else {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_DECODING;
- }
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][1];
-
- if (SSBSIP_MFC_LAST_FRAME_RECEIVED == pCTX->lastframe)
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_PROCESSED;
- } else if (pCTX->v4l2_dec.bBeingFinalized == 0) {
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_PROCESSED;
-
- pCTX->v4l2_dec.bBeingFinalized = 1; /* true */
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = MFC_DEC_NUM_PLANES;
-
- /* wait for decoding */
- do {
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- } while (ret != 0);
-
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][1];
- } else {
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = MFC_DEC_NUM_PLANES;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
-
- if (qbuf.m.planes[0].bytesused == 0) {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_END;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return SsbSipMfcDecGetOutBuf(pCTX, output_info);;
- } else {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
- }
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[qbuf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[qbuf.index][1];
- }
-
- pCTX->decOutInfo.disp_pic_frame_type = (qbuf.flags & (0x7 << 3));
-
- switch (pCTX->decOutInfo.disp_pic_frame_type) {
- case V4L2_BUF_FLAG_KEYFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 1;
- break;
- case V4L2_BUF_FLAG_PFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 2;
- break;
- case V4L2_BUF_FLAG_BFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 3;
- break;
- default:
- pCTX->decOutInfo.disp_pic_frame_type = 0;
- break;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
-
- return SsbSipMfcDecGetOutBuf(pCTX, output_info);
-}
-#endif
-
-void *SsbSipMfcDecGetInBuf(void *openHandle, void **phyInBuf, int inputBufferSize)
-{
- _MFCLIB *pCTX;
- int i;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return NULL;
- }
-
- if ((inputBufferSize < 0) || (inputBufferSize > MAX_DECODER_INPUT_BUFFER_SIZE)) {
- LOGE("[%s] inputBufferSize = %d is invalid",__func__, inputBufferSize);
- return NULL;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- for (i = 0; i < MFC_DEC_NUM_SRC_BUFS; i++)
- if (BUF_DEQUEUED == pCTX->v4l2_dec.mfc_src_buf_flags[i])
- break;
-
- if (i == MFC_DEC_NUM_SRC_BUFS) {
- LOGV("[%s] No buffer is available.",__func__);
- return NULL;
- } else {
- pCTX->virStrmBuf = (unsigned int)pCTX->v4l2_dec.mfc_src_bufs[i];
- /* Set the buffer flag as Enqueued for NB_mode_process*/
- /* FIXME: Check this assignment in case of using New API ExeNb() */
- pCTX->v4l2_dec.mfc_src_buf_flags[i] = BUF_ENQUEUED;
- }
-
- return (void *)pCTX->virStrmBuf;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, void *phyInBuf, void *virInBuf, int size)
-{
- _MFCLIB *pCTX;
- int i;
-
- LOGV("[%s] Enter",__func__);
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- for (i = 0; i<MFC_DEC_NUM_SRC_BUFS; i++)
- if (pCTX->v4l2_dec.mfc_src_bufs[i] == virInBuf)
- break;
-
- if (i == MFC_DEC_NUM_SRC_BUFS) {
- LOGE("[%s] Can not use the buffer",__func__);
- return MFC_RET_INVALID_PARAM;
- } else {
- pCTX->virStrmBuf = (unsigned int)virInBuf;
- pCTX->v4l2_dec.beingUsedIndex = i;
- pCTX->v4l2_dec.mfc_src_buf_flags[i] = BUF_ENQUEUED;
- }
- LOGV("[%s] Exit idx %d",__func__,pCTX->v4l2_dec.beingUsedIndex);
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecGetOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info)
-{
- int ret;
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- 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;
-
- output_info->crop_right_offset = pCTX->decOutInfo.crop_right_offset;
- output_info->crop_left_offset = pCTX->decOutInfo.crop_left_offset;
- output_info->crop_bottom_offset = pCTX->decOutInfo.crop_bottom_offset;
- output_info->crop_top_offset = pCTX->decOutInfo.crop_top_offset;
-
- output_info->disp_pic_frame_type = pCTX->decOutInfo.disp_pic_frame_type;
-
- switch (pCTX->displayStatus) {
- case MFC_GETOUTBUF_DISPLAY_ONLY:
- case MFC_GETOUTBUF_DISPLAY_DECODING:
- case MFC_GETOUTBUF_DISPLAY_END:
-#ifdef SSB_UMP
- ret = ump_secure_id_get_from_vaddr(pCTX->decOutInfo.YVirAddr, &output_info->y_cookie);
- if (ret) {
- LOGV("[%s] fail to get secure id(%d) from vaddr(%x)\n",__func__, \
- output_info->y_cookie, pCTX->decOutInfo.YVirAddr);
- }
-
- ret = ump_secure_id_get_from_vaddr(pCTX->decOutInfo.CVirAddr, &output_info->c_cookie);
- if (ret) {
- LOGV("[%s] fail to get secure id(%d) from vaddr(%x)\n",__func__, \
- output_info->c_cookie, pCTX->decOutInfo.CVirAddr);
- }
- break;
-#endif
- case MFC_GETOUTBUF_DECODING_ONLY:
- case MFC_GETOUTBUF_CHANGE_RESOL:
- break;
- default:
- return MFC_GETOUTBUF_DISPLAY_END;
- }
-
- return pCTX->displayStatus;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetConfig(void *openHandle, SSBSIP_MFC_DEC_CONF conf_type, void *value)
-{
- int ret, i;
-
- _MFCLIB *pCTX;
- struct mfc_dec_fimv1_info *fimv1_res;
-
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
- struct v4l2_control ctrl;
-
- enum v4l2_buf_type type;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if ((value == NULL) && (MFC_DEC_SETCONF_IS_LAST_FRAME !=conf_type)) {
- LOGE("[%s] value is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- /* First, process non-ioctl calling settings */
- switch (conf_type) {
- case MFC_DEC_SETCONF_EXTRA_BUFFER_NUM:
- pCTX->dec_numextradpb = *((unsigned int *) value);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_FIMV1_WIDTH_HEIGHT: /* be set before calling SsbSipMfcDecInit */
- fimv1_res = (struct mfc_dec_fimv1_info *)value;
- LOGI("fimv1->width = %d\n", fimv1_res->width);
- LOGI("fimv1->height = %d\n", fimv1_res->height);
- pCTX->fimv1_res.width = (int)(fimv1_res->width);
- pCTX->fimv1_res.height = (int)(fimv1_res->height);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_IS_LAST_FRAME:
- if (SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe) {
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_RECEIVED;
- return MFC_RET_OK;
- } else {
- return MFC_RET_FAIL;
- }
-
- case MFC_DEC_SETCONF_DPB_FLUSH:
- type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMOFF, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMOFF failed (destination buffers)",__func__);
- return MFC_RET_DEC_SET_CONF_FAIL;
- }
- pCTX->inter_buff_status &= ~(MFC_USE_DST_STREAMON);
-
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_dst_bufs; ++i) {
- memset(&qbuf, 0, sizeof(qbuf));
-
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = i;
- qbuf.m.planes = planes;
- qbuf.length = 2;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- return MFC_RET_DEC_SET_CONF_FAIL;
- }
- }
-
- type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMON, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMON failed (destination buffers)",__func__);
- return MFC_RET_DEC_SET_CONF_FAIL;
- }
- pCTX->inter_buff_status |= MFC_USE_DST_STREAMON;
- return MFC_RET_OK;
- default:
- /* Others will be processed next */
- break;
- }
-
- /* Process ioctl calling settings */
- memset(&ctrl, 0, sizeof(ctrl));
- switch (conf_type) {
- case MFC_DEC_SETCONF_DISPLAY_DELAY: /* be set before calling SsbSipMfcDecInit */
- ctrl.id = V4L2_CID_CODEC_DISPLAY_DELAY;
- ctrl.value = *((unsigned int *) value);
- break;
-
- case MFC_DEC_SETCONF_CRC_ENABLE:
- ctrl.id = V4L2_CID_CODEC_CRC_ENABLE;
- ctrl.value = 1;
- break;
-
- case MFC_DEC_SETCONF_SLICE_ENABLE:
- ctrl.id = V4L2_CID_CODEC_SLICE_INTERFACE;
- ctrl.value = 1;
- break;
-
- case MFC_DEC_SETCONF_FRAME_TAG: /*be set before calling SsbSipMfcDecExe */
- ctrl.id = V4L2_CID_CODEC_FRAME_TAG;
- ctrl.value = *((unsigned int*)value);
- break;
-
- case MFC_DEC_SETCONF_POST_ENABLE:
- ctrl.id = V4L2_CID_CODEC_LOOP_FILTER_MPEG4_ENABLE;
- ctrl.value = *((unsigned int*)value);
- break;
-
- default:
- LOGE("[%s] conf_type(%d) is NOT supported",__func__, conf_type);
- return MFC_RET_INVALID_PARAM;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed (conf_type = %d)",__func__, 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)
-{
- _MFCLIB *pCTX;
-
- SSBSIP_MFC_IMG_RESOLUTION *img_resolution;
- int ret;
- SSBSIP_MFC_CRC_DATA *crc_data;
- SSBSIP_MFC_CROP_INFORMATION *crop_information;
- struct v4l2_control ctrl;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("[%s] value is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- switch (conf_type) {
- case MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT:
- img_resolution = (SSBSIP_MFC_IMG_RESOLUTION *)value;
- img_resolution->width = pCTX->decOutInfo.img_width;
- img_resolution->height = pCTX->decOutInfo.img_height;
- img_resolution->buf_width = pCTX->decOutInfo.buf_width;
- img_resolution->buf_height = pCTX->decOutInfo.buf_height;
- break;
-
- case MFC_DEC_GETCONF_CRC_DATA:
- crc_data = (SSBSIP_MFC_CRC_DATA *) value;
-
- ctrl.id = V4L2_CID_CODEC_CRC_DATA_LUMA;
- ctrl.value = 0;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed, V4L2_CID_CODEC_CRC_DATA_LUMA",__func__);
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
- crc_data->luma0 = ctrl.value;
-
- ctrl.id = V4L2_CID_CODEC_CRC_DATA_CHROMA;
- ctrl.value = 0;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed, V4L2_CID_CODEC_CRC_DATA_CHROMA",__func__);
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
- crc_data->chroma0 = ctrl.value;
-
- LOGI("[%s] crc_data->luma0=%d",__func__,ctrl.value);
- LOGI("[%s] crc_data->chroma0=%d",__func__,ctrl.value);
- break;
-
- case MFC_DEC_GETCONF_FRAME_TAG:
- ctrl.id = V4L2_CID_CODEC_FRAME_TAG;
- ctrl.value = 0;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- if (ret != 0) {
- printf("Error to do g_ctrl.\n");
- }
- *((unsigned int *)value) = ctrl.value;
- break;
-
- 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;
-
- default:
- LOGE("[%s] conf_type(%d) is NOT supported",__func__, conf_type);
- return MFC_RET_INVALID_PARAM;
- }
-
- return MFC_RET_OK;
-}
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/enc/src/SsbSipMfcEncAPI.c b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/enc/src/SsbSipMfcEncAPI.c
deleted file mode 100644
index 45888c6..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/enc/src/SsbSipMfcEncAPI.c
+++ /dev/null
@@ -1,1206 +0,0 @@
-/*
- * Copyright (c) 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 <stdio.h>
-#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 <sys/poll.h>
-#include "videodev2.h"
-
-#include "mfc_interface.h"
-#include "SsbSipMfcApi.h"
-
-/* #define LOG_NDEBUG 0 */
-#define LOG_TAG "MFC_ENC_APP"
-#include <utils/Log.h>
-
-#define POLL_ENC_WAIT_TIMEOUT 25
-
-#ifndef true
-#define true (1)
-#endif
-
-#ifndef false
-#define false (0)
-#endif
-
-#define MAX_STREAM_SIZE (2*1024*1024)
-
-static char *mfc_dev_name = SAMSUNG_MFC_DEV_NAME;
-static int mfc_dev_node = 7;
-
-static void getMFCName(char *devicename, int size)
-{
- snprintf(devicename, size, "%s%d", SAMSUNG_MFC_DEV_NAME, mfc_dev_node);
-}
-
-void SsbSipMfcEncSetMFCName(char *devicename)
-{
- mfc_dev_name = devicename;
-}
-
-void *SsbSipMfcEncOpen(void)
-{
- int hMFCOpen;
- _MFCLIB *pCTX;
-
- char mfc_dev_name[64];
-
- int ret;
- struct v4l2_capability cap;
-
- getMFCName(mfc_dev_name, 64);
- LOGI("[%s] dev name is %s\n",__func__,mfc_dev_name);
-
- if (access(mfc_dev_name, F_OK) != 0) {
- LOGE("[%s] MFC device node not exists",__func__);
- return NULL;
- }
-
- hMFCOpen = open(mfc_dev_name, O_RDWR | O_NONBLOCK, 0);
- if (hMFCOpen < 0) {
- LOGE("[%s] Failed to open MFC device",__func__);
- return NULL;
- }
-
- pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
- if (pCTX == NULL) {
- LOGE("[%s] malloc failed.",__func__);
- return NULL;
- }
- memset(pCTX, 0, sizeof(_MFCLIB));
-
- pCTX->hMFC = hMFCOpen;
-
- memset(&cap, 0, sizeof(cap));
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYCAP, &cap);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QUERYCAP failed",__func__);
- close(pCTX->hMFC);
- free(pCTX);
- return NULL;
- }
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
- LOGE("[%s] Device does not support capture",__func__);
- close(pCTX->hMFC);
- free(pCTX);
- return NULL;
- }
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
- LOGE("[%s] Device does not support output",__func__);
- close(pCTX->hMFC);
- free(pCTX);
- return NULL;
- }
-
- if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
- LOGE("[%s] Device does not support streaming",__func__);
- close(pCTX->hMFC);
- free(pCTX);
- return NULL;
- }
-
- pCTX->v4l2_enc.bRunning = 0;
- /* physical address is used for Input source */
- pCTX->v4l2_enc.bInputPhyVir = 1;
-
- pCTX->cacheablebuffer = NO_CACHE;
-
- return (void *)pCTX;
-}
-
-void *SsbSipMfcEncOpenExt(void *value)
-{
- _MFCLIB *pCTX;
-
- pCTX = SsbSipMfcEncOpen();
- if (pCTX == NULL)
- return NULL;
-
- if (NO_CACHE == (*(SSBIP_MFC_BUFFER_TYPE *)value)) {
- pCTX->cacheablebuffer = NO_CACHE;
- /* physical address is used for Input source */
- pCTX->v4l2_enc.bInputPhyVir = 1;
- LOGI("[%s] non cacheable buffer",__func__);
- }
- else {
- pCTX->cacheablebuffer = CACHE;
- /* vitual address is used for Input source */
- pCTX->v4l2_enc.bInputPhyVir = 0;
- LOGI("[%s] cacheable buffer",__func__);
- }
-
- return (void *)pCTX;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncClose(void *openHandle)
-{
- _MFCLIB *pCTX;
- int i;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (!pCTX->v4l2_enc.bInputPhyVir) {
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; i++) {
- munmap(pCTX->v4l2_enc.mfc_src_bufs[i][0], pCTX->v4l2_enc.mfc_src_bufs_len[0]);
- munmap(pCTX->v4l2_enc.mfc_src_bufs[i][1], pCTX->v4l2_enc.mfc_src_bufs_len[1]);
- }
- }
-
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_dst_bufs; i++)
- munmap(pCTX->v4l2_enc.mfc_dst_bufs[i], pCTX->v4l2_enc.mfc_dst_bufs_len);
-
- pCTX->inter_buff_status = MFC_USE_NONE;
-
- close(pCTX->hMFC);
-
- free(pCTX);
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncInit(void *openHandle, void *param)
-{
- int ret, i, j,index;
- _MFCLIB *pCTX;
-
- enum v4l2_buf_type type;
- struct v4l2_format fmt;
- struct v4l2_plane planes[MFC_ENC_NUM_PLANES];
-
- struct v4l2_buffer buf;
- struct v4l2_requestbuffers reqbuf;
-
- struct v4l2_control ctrl;
-
- struct pollfd poll_events;
- int poll_state;
-
- struct v4l2_ext_control ext_ctrl_mpeg4[27];
- struct v4l2_ext_control ext_ctrl_h263[19];
- struct v4l2_ext_control ext_ctrl[44];
- struct v4l2_ext_controls ext_ctrls;
-
- SSBSIP_MFC_ENC_H264_PARAM *h264_arg;
- SSBSIP_MFC_ENC_MPEG4_PARAM *mpeg4_arg;
- SSBSIP_MFC_ENC_H263_PARAM *h263_arg;
-
- if (openHandle == NULL) {
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- mpeg4_arg = (SSBSIP_MFC_ENC_MPEG4_PARAM*)param;
- if (mpeg4_arg->codecType == MPEG4_ENC) {
- pCTX->codecType= MPEG4_ENC;
- pCTX->width = mpeg4_arg->SourceWidth;
- pCTX->height = mpeg4_arg->SourceHeight;
- pCTX->framemap = mpeg4_arg->FrameMap;
- } else {
- h263_arg = (SSBSIP_MFC_ENC_H263_PARAM*)param;
- if (h263_arg->codecType == H263_ENC) {
- pCTX->codecType = H263_ENC;
- pCTX->width = h263_arg->SourceWidth;
- pCTX->height = h263_arg->SourceHeight;
- pCTX->framemap = h263_arg->FrameMap;
- } else {
- h264_arg = (SSBSIP_MFC_ENC_H264_PARAM*)param;
- if (h264_arg->codecType == H264_ENC) {
- pCTX->codecType = H264_ENC;
- pCTX->width = h264_arg->SourceWidth;
- pCTX->height = h264_arg->SourceHeight;
- pCTX->framemap = h264_arg->FrameMap;
- } else {
- LOGE("[%s] Undefined codec type \n",__func__);
- ret = MFC_RET_INVALID_PARAM;
- goto error_case1;
- }
- }
- }
-
- switch (pCTX->codecType) {
- case MPEG4_ENC:
- ext_ctrl_mpeg4[0].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_PROFILE;
- ext_ctrl_mpeg4[0].value = mpeg4_arg->ProfileIDC;
- ext_ctrl_mpeg4[1].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_LEVEL;
- ext_ctrl_mpeg4[1].value = mpeg4_arg->LevelIDC;
- ext_ctrl_mpeg4[2].id = V4L2_CID_CODEC_MFC5X_ENC_GOP_SIZE;
- ext_ctrl_mpeg4[2].value = mpeg4_arg->IDRPeriod;
- ext_ctrl_mpeg4[3].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_QUARTER_PIXEL;
- ext_ctrl_mpeg4[3].value = mpeg4_arg->DisableQpelME;
-
- ext_ctrl_mpeg4[4].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MODE;
- ext_ctrl_mpeg4[4].value = mpeg4_arg->SliceMode; /* 0: one, 1: fixed #mb, 3: fixed #bytes */
- if (mpeg4_arg->SliceMode == 0) {
- ext_ctrl_mpeg4[5].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl_mpeg4[5].value = 1; /* default */
- ext_ctrl_mpeg4[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl_mpeg4[6].value = 1900; /* default */
- } else if (mpeg4_arg->SliceMode == 1) {
- ext_ctrl_mpeg4[5].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl_mpeg4[5].value = mpeg4_arg->SliceArgument;
- ext_ctrl_mpeg4[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl_mpeg4[6].value = 1900; /* default */
- } else if (mpeg4_arg->SliceMode == 3) {
- ext_ctrl_mpeg4[5].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl_mpeg4[5].value = 1; /* default */
- ext_ctrl_mpeg4[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl_mpeg4[6].value = mpeg4_arg->SliceArgument;
- }
- /*
- It should be set using mpeg4_arg->NumberBFrames after being handled by appl.
- */
- ext_ctrl_mpeg4[7].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_B_FRAMES;
- ext_ctrl_mpeg4[7].value = mpeg4_arg->NumberBFrames;
- ext_ctrl_mpeg4[8].id = V4L2_CID_CODEC_MFC5X_ENC_INTRA_REFRESH_MB;
- ext_ctrl_mpeg4[8].value = mpeg4_arg->RandomIntraMBRefresh;
-
- ext_ctrl_mpeg4[9].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CTRL_ENABLE;
- ext_ctrl_mpeg4[9].value = mpeg4_arg->PadControlOn;
- ext_ctrl_mpeg4[10].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_LUMA_VALUE;
- ext_ctrl_mpeg4[10].value = mpeg4_arg->LumaPadVal;
- ext_ctrl_mpeg4[11].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CB_VALUE;
- ext_ctrl_mpeg4[11].value = mpeg4_arg->CbPadVal;
- ext_ctrl_mpeg4[12].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CR_VALUE;
- ext_ctrl_mpeg4[12].value = mpeg4_arg->CrPadVal;
-
- ext_ctrl_mpeg4[13].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FRAME_ENABLE;
- ext_ctrl_mpeg4[13].value = mpeg4_arg->EnableFRMRateControl;
- ext_ctrl_mpeg4[14].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_VOP_TIME_RES;
- ext_ctrl_mpeg4[14].value = mpeg4_arg->TimeIncreamentRes;
- ext_ctrl_mpeg4[15].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_VOP_FRM_DELTA;
- ext_ctrl_mpeg4[15].value = mpeg4_arg->VopTimeIncreament;
- ext_ctrl_mpeg4[16].id = V4L2_CID_CODEC_MFC5X_ENC_RC_BIT_RATE;
- ext_ctrl_mpeg4[16].value = mpeg4_arg->Bitrate;
-
- ext_ctrl_mpeg4[17].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_FRAME_QP;
- ext_ctrl_mpeg4[17].value = mpeg4_arg->FrameQp;
- ext_ctrl_mpeg4[18].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_P_FRAME_QP;
- ext_ctrl_mpeg4[18].value = mpeg4_arg->FrameQp_P;
- ext_ctrl_mpeg4[19].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_B_FRAME_QP;
- ext_ctrl_mpeg4[19].value = mpeg4_arg->FrameQp_B;
-
- ext_ctrl_mpeg4[20].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_MAX_QP;
- ext_ctrl_mpeg4[20].value = mpeg4_arg->QSCodeMax;
- ext_ctrl_mpeg4[21].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_MIN_QP;
- ext_ctrl_mpeg4[21].value = mpeg4_arg->QSCodeMin;
- ext_ctrl_mpeg4[22].id = V4L2_CID_CODEC_MFC5X_ENC_RC_REACTION_COEFF;
- ext_ctrl_mpeg4[22].value = mpeg4_arg->CBRPeriodRf;
-
- if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL == pCTX->enc_frameskip) {
- ext_ctrl_mpeg4[23].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_mpeg4[23].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL;
- } else if(V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE == pCTX->enc_frameskip) {
- ext_ctrl_mpeg4[23].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_mpeg4[23].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE;
- } else { /* ENC_FRAME_SKIP_MODE_DISABLE (default) */
- ext_ctrl_mpeg4[23].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_mpeg4[23].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_DISABLE;
- }
-
- ext_ctrl_mpeg4[24].id = V4L2_CID_CODEC_MFC5X_ENC_VBV_BUF_SIZE;
- ext_ctrl_mpeg4[24].value = 0;
-
- ext_ctrl_mpeg4[25].id = V4L2_CID_CODEC_MFC5X_ENC_SEQ_HDR_MODE;
- ext_ctrl_mpeg4[25].value = 0;
-
- ext_ctrl_mpeg4[26].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FIXED_TARGET_BIT;
- ext_ctrl_mpeg4[26].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
- break;
-
- case H263_ENC:
- ext_ctrl_h263[0].id = V4L2_CID_CODEC_MFC5X_ENC_GOP_SIZE;
- ext_ctrl_h263[0].value = h263_arg->IDRPeriod;
-
- ext_ctrl_h263[1].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MODE;
- ext_ctrl_h263[1].value = h263_arg->SliceMode; /* 0: one, Check is needed if h264 support multi-slice */
-
- ext_ctrl_h263[2].id = V4L2_CID_CODEC_MFC5X_ENC_INTRA_REFRESH_MB;
- ext_ctrl_h263[2].value = h263_arg->RandomIntraMBRefresh;
-
- ext_ctrl_h263[3].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CTRL_ENABLE;
- ext_ctrl_h263[3].value = h263_arg->PadControlOn;
- ext_ctrl_h263[4].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_LUMA_VALUE;
- ext_ctrl_h263[4].value = h263_arg->LumaPadVal;
- ext_ctrl_h263[5].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CB_VALUE;
- ext_ctrl_h263[5].value = h263_arg->CbPadVal;
- ext_ctrl_h263[6].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CR_VALUE;
- ext_ctrl_h263[6].value = h263_arg->CrPadVal;
-
- ext_ctrl_h263[7].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FRAME_ENABLE;
- ext_ctrl_h263[7].value = h263_arg->EnableFRMRateControl;
-
- ext_ctrl_h263[8].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_FRAME_RATE;
- ext_ctrl_h263[8].value = h263_arg->FrameRate;
-
- ext_ctrl_h263[9].id = V4L2_CID_CODEC_MFC5X_ENC_RC_BIT_RATE;
- ext_ctrl_h263[9].value = h263_arg->Bitrate;
-
- ext_ctrl_h263[10].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_FRAME_QP;
- ext_ctrl_h263[10].value = h263_arg->FrameQp;
- ext_ctrl_h263[11].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_P_FRAME_QP;
- ext_ctrl_h263[11].value = h263_arg->FrameQp_P;
-
- ext_ctrl_h263[12].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_MAX_QP;
- ext_ctrl_h263[12].value = h263_arg->QSCodeMax;
- ext_ctrl_h263[13].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_MIN_QP;
- ext_ctrl_h263[13].value = h263_arg->QSCodeMin;
- ext_ctrl_h263[14].id = V4L2_CID_CODEC_MFC5X_ENC_RC_REACTION_COEFF;
- ext_ctrl_h263[14].value = h263_arg->CBRPeriodRf;
-
- if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL == pCTX->enc_frameskip) {
- ext_ctrl_h263[15].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_h263[15].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL;
- } else if(V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE== pCTX->enc_frameskip) {
- ext_ctrl_h263[15].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_h263[15].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE;
- } else { /* ENC_FRAME_SKIP_MODE_DISABLE (default) */
- ext_ctrl_h263[15].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_h263[15].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_DISABLE;
- }
-
- ext_ctrl_h263[16].id = V4L2_CID_CODEC_MFC5X_ENC_VBV_BUF_SIZE;
- ext_ctrl_h263[16].value = 0;
-
- ext_ctrl_h263[17].id = V4L2_CID_CODEC_MFC5X_ENC_SEQ_HDR_MODE;
- ext_ctrl_h263[17].value = 0;
-
- ext_ctrl_h263[18].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FIXED_TARGET_BIT;
- ext_ctrl_h263[18].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
- break;
-
- case H264_ENC:
- ext_ctrl[0].id = V4L2_CID_CODEC_MFC5X_ENC_H264_PROFILE;
- ext_ctrl[0].value = h264_arg->ProfileIDC;
- ext_ctrl[1].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LEVEL;
- ext_ctrl[1].value = h264_arg->LevelIDC;
- ext_ctrl[2].id = V4L2_CID_CODEC_MFC5X_ENC_GOP_SIZE;
- ext_ctrl[2].value = h264_arg->IDRPeriod;
- ext_ctrl[3].id = V4L2_CID_CODEC_MFC5X_ENC_H264_MAX_REF_PIC;
- ext_ctrl[3].value = h264_arg->NumberReferenceFrames;
- ext_ctrl[4].id = V4L2_CID_CODEC_MFC5X_ENC_H264_NUM_REF_PIC_4P;
- ext_ctrl[4].value = h264_arg->NumberRefForPframes;
- ext_ctrl[5].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MODE;
- ext_ctrl[5].value = h264_arg->SliceMode; /* 0: one, 1: fixed #mb, 3: fixed #bytes */
- if (h264_arg->SliceMode == 0) {
- ext_ctrl[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl[6].value = 1; /* default */
- ext_ctrl[7].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl[7].value = 1900; /* default */
- } else if (h264_arg->SliceMode == 1) {
- ext_ctrl[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl[6].value = h264_arg->SliceArgument;
- ext_ctrl[7].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl[7].value = 1900; /* default */
- } else if (h264_arg->SliceMode == 3) {
- ext_ctrl[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl[6].value = 1; /* default */
- ext_ctrl[7].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl[7].value = h264_arg->SliceArgument;
- }
- /*
- It should be set using h264_arg->NumberBFrames after being handled by appl.
- */
- ext_ctrl[8].id = V4L2_CID_CODEC_MFC5X_ENC_H264_B_FRAMES;
- ext_ctrl[8].value = h264_arg->NumberBFrames;
- ext_ctrl[9].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LOOP_FILTER_MODE;
- ext_ctrl[9].value = h264_arg->LoopFilterDisable;
- ext_ctrl[10].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LOOP_FILTER_ALPHA;
- ext_ctrl[10].value = h264_arg->LoopFilterAlphaC0Offset;
- ext_ctrl[11].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LOOP_FILTER_BETA;
- ext_ctrl[11].value = h264_arg->LoopFilterBetaOffset;
- ext_ctrl[12].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ENTROPY_MODE;
- ext_ctrl[12].value = h264_arg->SymbolMode;
- ext_ctrl[13].id = V4L2_CID_CODEC_MFC5X_ENC_H264_INTERLACE;
- ext_ctrl[13].value = h264_arg->PictureInterlace;
- ext_ctrl[14].id = V4L2_CID_CODEC_MFC5X_ENC_H264_8X8_TRANSFORM;
- ext_ctrl[14].value = h264_arg->Transform8x8Mode;
- ext_ctrl[15].id = V4L2_CID_CODEC_MFC5X_ENC_INTRA_REFRESH_MB;
- ext_ctrl[15].value = h264_arg->RandomIntraMBRefresh;
- ext_ctrl[16].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CTRL_ENABLE;
- ext_ctrl[16].value = h264_arg->PadControlOn;
- ext_ctrl[17].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_LUMA_VALUE;
- ext_ctrl[17].value = h264_arg->LumaPadVal;
- ext_ctrl[18].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CB_VALUE;
- ext_ctrl[18].value = h264_arg->CbPadVal;
- ext_ctrl[19].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CR_VALUE;
- ext_ctrl[19].value = h264_arg->CrPadVal;
- ext_ctrl[20].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FRAME_ENABLE;
- ext_ctrl[20].value = h264_arg->EnableFRMRateControl;
- ext_ctrl[21].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_ENABLE;
- ext_ctrl[21].value = h264_arg->EnableMBRateControl;
- ext_ctrl[22].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_FRAME_RATE;
- ext_ctrl[22].value = h264_arg->FrameRate;
- ext_ctrl[23].id = V4L2_CID_CODEC_MFC5X_ENC_RC_BIT_RATE;
- /* FIXME temporary fix */
- if (h264_arg->Bitrate)
- ext_ctrl[23].value = h264_arg->Bitrate;
- else
- ext_ctrl[23].value = 1; /* just for testing Movi studio */
- ext_ctrl[24].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_FRAME_QP;
- ext_ctrl[24].value = h264_arg->FrameQp;
- ext_ctrl[25].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_P_FRAME_QP;
- ext_ctrl[25].value = h264_arg->FrameQp_P;
- ext_ctrl[26].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_B_FRAME_QP;
- ext_ctrl[26].value = h264_arg->FrameQp_B;
- ext_ctrl[27].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MAX_QP;
- ext_ctrl[27].value = h264_arg->QSCodeMax;
- ext_ctrl[28].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MIN_QP;
- ext_ctrl[28].value = h264_arg->QSCodeMin;
- ext_ctrl[29].id = V4L2_CID_CODEC_MFC5X_ENC_RC_REACTION_COEFF;
- ext_ctrl[29].value = h264_arg->CBRPeriodRf;
- ext_ctrl[30].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_DARK;
- ext_ctrl[30].value = h264_arg->DarkDisable;
- ext_ctrl[31].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_SMOOTH;
- ext_ctrl[31].value = h264_arg->SmoothDisable;
- ext_ctrl[32].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_STATIC;
- ext_ctrl[32].value = h264_arg->StaticDisable;
- ext_ctrl[33].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_ACTIVITY;
- ext_ctrl[33].value = h264_arg->ActivityDisable;
-
- /* doesn't have to be set */
- ext_ctrl[34].id = V4L2_CID_CODEC_MFC5X_ENC_H264_OPEN_GOP;
- ext_ctrl[34].value = V4L2_CODEC_MFC5X_ENC_SW_DISABLE;
- ext_ctrl[35].id = V4L2_CID_CODEC_MFC5X_ENC_H264_I_PERIOD;
- ext_ctrl[35].value = 10;
-
- if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL == pCTX->enc_frameskip) {
- ext_ctrl[36].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl[36].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL;
- } else if(V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE== pCTX->enc_frameskip) {
- ext_ctrl[36].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl[36].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE;
- } else { /* ENC_FRAME_SKIP_MODE_DISABLE (default) */
- ext_ctrl[36].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl[36].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_DISABLE;
- }
-
- ext_ctrl[37].id = V4L2_CID_CODEC_MFC5X_ENC_VBV_BUF_SIZE;
- ext_ctrl[37].value = 0;
-
- ext_ctrl[38].id = V4L2_CID_CODEC_MFC5X_ENC_SEQ_HDR_MODE;
- ext_ctrl[38].value = 0; /* 0: seperated header
- 1: header + first frame */
-
- ext_ctrl[39].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FIXED_TARGET_BIT;
- ext_ctrl[39].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
-
- ext_ctrl[40].id = V4L2_CID_CODEC_MFC5X_ENC_H264_AR_VUI_ENABLE;
- ext_ctrl[40].value = V4L2_CODEC_MFC5X_ENC_SW_DISABLE;
- ext_ctrl[41].id = V4L2_CID_CODEC_MFC5X_ENC_H264_AR_VUI_IDC;
- ext_ctrl[41].value = 0;
- ext_ctrl[42].id = V4L2_CID_CODEC_MFC5X_ENC_H264_EXT_SAR_WIDTH;
- ext_ctrl[42].value = 0;
- ext_ctrl[43].id = V4L2_CID_CODEC_MFC5X_ENC_H264_EXT_SAR_HEIGHT;
- ext_ctrl[43].value = 0;
-
- break;
-
- default:
- LOGE("[%s] Undefined codec type",__func__);
- ret = MFC_RET_INVALID_PARAM;
- goto error_case1;
- }
-
- ext_ctrls.ctrl_class = V4L2_CTRL_CLASS_CODEC;
- if (pCTX->codecType == MPEG4_ENC) {
- ext_ctrls.count = 27;
- ext_ctrls.controls = ext_ctrl_mpeg4;
- } else if (pCTX->codecType == H264_ENC) {
- ext_ctrls.count = 44;
- ext_ctrls.controls = ext_ctrl;
- } else if (pCTX->codecType == H263_ENC) {
- ext_ctrls.count = 19;
- ext_ctrls.controls = ext_ctrl_h263;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_EXT_CTRLS, &ext_ctrls);
- if (ret != 0) {
- LOGE("[%s] Failed to set extended controls",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
-
- memset(&fmt, 0, sizeof(fmt));
- fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-
- fmt.fmt.pix_mp.width = pCTX->width;
- fmt.fmt.pix_mp.height = pCTX->height;
- fmt.fmt.pix_mp.num_planes = 2;
- fmt.fmt.pix_mp.plane_fmt[0].bytesperline = Align(fmt.fmt.pix_mp.width, 128);
- fmt.fmt.pix_mp.plane_fmt[1].bytesperline = Align(fmt.fmt.pix_mp.width, 128);
-
- if (NV12_TILE == pCTX->framemap) {
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12MT; /* 4:2:0, 2 Planes, 64x32 Tiles */
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage =
- Align(Align(fmt.fmt.pix_mp.width, 128) * Align(fmt.fmt.pix_mp.height, 32), 8192); /* tiled mode */
- fmt.fmt.pix_mp.plane_fmt[1].sizeimage =
- Align(Align(fmt.fmt.pix_mp.width, 128) * Align(fmt.fmt.pix_mp.height >> 1, 32), 8192); /* tiled mode */
- } else { /* NV12_LINEAR (default) */
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M; /* 4:2:0, 2 Planes, linear */
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage =
- Align((fmt.fmt.pix_mp.width * fmt.fmt.pix_mp.height), 2048); /* linear mode, 2K align */
- fmt.fmt.pix_mp.plane_fmt[1].sizeimage =
- Align((fmt.fmt.pix_mp.width * (fmt.fmt.pix_mp.height >> 1)), 2048); /* linear mode, 2K align */
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_FMT, &fmt);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed on MFC output stream",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
-
- /* capture (dst) */
- memset(&fmt, 0, sizeof(fmt));
-
- switch (pCTX->codecType) {
- case H264_ENC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
- break;
- case MPEG4_ENC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_MPEG4;
- break;
- case H263_ENC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H263;
- break;
- default:
- LOGE("[%s] Codec has not been recognised",__func__);
- return MFC_RET_ENC_INIT_FAIL;
- }
-
- fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage = MAX_STREAM_SIZE;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_FMT, &fmt);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed on MFC output stream",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
-
- /* cacheable buffer */
- ctrl.id = V4L2_CID_CACHEABLE;
- if (pCTX->cacheablebuffer == NO_CACHE)
- ctrl.value = 0;
- else
- ctrl.value = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed, V4L2_CID_CACHEABLE",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
-
- /* Initialize streams for input */
- memset(&reqbuf, 0, sizeof(reqbuf));
- reqbuf.count = MFC_ENC_NUM_SRC_BUFS;
- reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- if (pCTX->v4l2_enc.bInputPhyVir)
- reqbuf.memory = V4L2_MEMORY_USERPTR;
- else
- reqbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_REQBUFS, &reqbuf);
- if (ret != 0) {
- LOGE("[%s] Reqbufs src ioctl failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
- pCTX->v4l2_enc.mfc_num_src_bufs = reqbuf.count;
-
- if (!pCTX->v4l2_enc.bInputPhyVir) {
- /* Then the buffers have to be queried and mmaped */
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; ++i) {
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.index = i;
- buf.m.planes = planes;
- buf.length = 2;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] Querybuf src ioctl failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case2;
- }
-
- pCTX->v4l2_enc.mfc_src_bufs_len[0] = buf.m.planes[0].length;
- pCTX->v4l2_enc.mfc_src_bufs_len[1] = buf.m.planes[1].length;
-
- pCTX->v4l2_enc.mfc_src_phys[i][0] = buf.m.planes[0].cookie;
- pCTX->v4l2_enc.mfc_src_phys[i][1] = buf.m.planes[1].cookie;
-
- pCTX->v4l2_enc.mfc_src_bufs[i][0] =
- mmap(NULL, buf.m.planes[0].length, PROT_READ | PROT_WRITE,
- MAP_SHARED, pCTX->hMFC, buf.m.planes[0].m.mem_offset);
- if (pCTX->v4l2_enc.mfc_src_bufs[i][0] == MAP_FAILED) {
- LOGE("[%s] Mmap on src buffer (0) failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case2;
- }
-
- pCTX->v4l2_enc.mfc_src_bufs[i][1] =
- mmap(NULL, buf.m.planes[1].length, PROT_READ | PROT_WRITE,
- MAP_SHARED, pCTX->hMFC, buf.m.planes[1].m.mem_offset);
- if (pCTX->v4l2_enc.mfc_src_bufs[i][1] == MAP_FAILED) {
- munmap(pCTX->v4l2_enc.mfc_src_bufs[i][0], pCTX->v4l2_enc.mfc_src_bufs_len[0]);
- LOGE("[%s] Mmap on src buffer (1) failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case2;
- }
- }
- } else
- LOGV("[%s] Camera Phys src buf %d",__func__,reqbuf.count);
-
- for (i = 0; i<pCTX->v4l2_enc.mfc_num_src_bufs; i++)
- pCTX->v4l2_enc.mfc_src_buf_flags[i] = BUF_DEQUEUED;
-
- pCTX->v4l2_enc.beingUsedIndex = 0;
-
- pCTX->sizeFrmBuf.luma = (unsigned int)(pCTX->width * pCTX->height);
- pCTX->sizeFrmBuf.chroma = (unsigned int)((pCTX->width * pCTX->height) >> 1);
- pCTX->inter_buff_status |= MFC_USE_YUV_BUFF;
-
- /* Initialize stream for output */
- memset(&reqbuf, 0, sizeof(reqbuf));
- reqbuf.count = MFC_ENC_MAX_DST_BUFS;
- reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- reqbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_REQBUFS, &reqbuf);
- if (ret != 0) {
- LOGE("[%s] Reqbufs dst ioctl failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case2;
- }
-
- pCTX->v4l2_enc.mfc_num_dst_bufs = reqbuf.count;
-
- for (i = 0; i<MFC_ENC_MAX_DST_BUFS; ++i) {
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.index = i;
- buf.m.planes = planes;
- buf.length = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] Querybuf dst ioctl failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
-
- pCTX->v4l2_enc.mfc_dst_bufs_len = buf.m.planes[0].length;
- pCTX->v4l2_enc.mfc_dst_bufs[i] =
- mmap(NULL, buf.m.planes[0].length, PROT_READ | PROT_WRITE,
- MAP_SHARED, pCTX->hMFC, buf.m.planes[0].m.mem_offset);
- if (pCTX->v4l2_enc.mfc_dst_bufs[i] == MAP_FAILED) {
- LOGE("[%s] Mmap on dst buffer failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
- }
-
- pCTX->sizeStrmBuf = MAX_ENCODER_OUTPUT_BUFFER_SIZE;
- pCTX->inter_buff_status |= MFC_USE_STRM_BUFF;
-
- type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMON, &type);
- if (ret != 0) {
- LOGE("[%s] V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, VIDIOC_STREAMON failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
-
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.m.planes = planes;
- buf.length = 1;
-
- /* note: #define POLLOUT 0x0004 */
- poll_events.fd = pCTX->hMFC;
- poll_events.events = POLLIN | POLLERR;
- poll_events.revents = 0;
-
- /* wait for header encoding */
- do {
- poll_state = poll((struct pollfd*)&poll_events, 1, POLL_ENC_WAIT_TIMEOUT);
- if (0 < poll_state) {
- if (poll_events.revents & POLLIN) { /* POLLIN */
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &buf);
- if (ret == 0)
- break;
- } else if(poll_events.revents & POLLERR) { /*POLLERR */
- LOGE("[%s] POLLERR\n",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- } else {
- LOGE("[%s] poll() returns 0x%x\n",__func__, poll_events.revents);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
- } else if(0 > poll_state) {
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
- } while (0 == poll_state);
-
- pCTX->v4l2_enc.mfc_dst_bufs_bytes_used_len = buf.m.planes[0].bytesused;
- pCTX->virStrmBuf = pCTX->v4l2_enc.mfc_dst_bufs[buf.index];
-
- /* stream dequeued index */
- index = buf.index;
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.index = index;
- buf.m.planes = planes;
- buf.length = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
- LOGV("[%s] Strm out idx %d",__func__,index);
-
- return MFC_RET_OK;
-error_case3:
- for (j = 0; j < i; j++)
- munmap(pCTX->v4l2_enc.mfc_dst_bufs[j], pCTX->v4l2_enc.mfc_dst_bufs_len);
-
- i = pCTX->v4l2_enc.mfc_num_src_bufs;
-error_case2:
- if (!pCTX->v4l2_enc.bInputPhyVir) {
- for (j = 0; j < i; j++) {
- munmap(pCTX->v4l2_enc.mfc_src_bufs[j][0], pCTX->v4l2_enc.mfc_src_bufs_len[0]);
- munmap(pCTX->v4l2_enc.mfc_src_bufs[j][1], pCTX->v4l2_enc.mfc_src_bufs_len[1]);
- }
- }
-error_case1:
- return ret;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
-{
- _MFCLIB *pCTX;
- int i;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (pCTX->v4l2_enc.bInputPhyVir) {
- input_info->YPhyAddr = (void*)0;
- input_info->CPhyAddr = (void*)0;
- input_info->YVirAddr = (void*)0;
- input_info->CVirAddr = (void*)0;
-
- if (NV12_TILE == pCTX->framemap) {
- /* 4:2:0, 2 Planes, 64x32 Tiles */
- input_info->YSize = Align(Align(pCTX->width, 128) * Align(pCTX->height, 32), 8192); /* tiled mode */
- input_info->CSize = Align(Align(pCTX->width, 128) * Align(pCTX->height >> 1, 32), 8192); /* tiled mode */
- } else { /* NV12_LINEAR (default) */
- /* 4:2:0, 2 Planes, linear */
- input_info->YSize = Align(Align(pCTX->width, 16) * Align(pCTX->height, 16), 2048); /* width = 16B, height = 16B align */
- input_info->CSize = Align(Align(pCTX->width, 16) * Align(pCTX->height >> 1, 8), 2048); /* width = 16B, height = 8B align */
- }
- } else {
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; i++)
- if (BUF_DEQUEUED == pCTX->v4l2_enc.mfc_src_buf_flags[i])
- break;
-
- if (i == pCTX->v4l2_enc.mfc_num_src_bufs) {
- LOGV("[%s] No buffer is available.",__func__);
- return MFC_RET_ENC_GET_INBUF_FAIL;
- } else {
- /* FIXME check this for correct physical address */
- input_info->YPhyAddr = (void*)pCTX->v4l2_enc.mfc_src_phys[i][0];
- input_info->CPhyAddr = (void*)pCTX->v4l2_enc.mfc_src_phys[i][1];
- input_info->YVirAddr = (void*)pCTX->v4l2_enc.mfc_src_bufs[i][0];
- input_info->CVirAddr = (void*)pCTX->v4l2_enc.mfc_src_bufs[i][1];
- input_info->YSize = (int)pCTX->v4l2_enc.mfc_src_bufs_len[0];
- input_info->CSize = (int)pCTX->v4l2_enc.mfc_src_bufs_len[1];
-
- pCTX->v4l2_enc.mfc_src_buf_flags[i] = BUF_ENQUEUED;
- }
- }
- LOGV("[%s] Input Buffer idx %d",__func__,i);
- return MFC_RET_OK;
-}
-
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
-{
- _MFCLIB *pCTX;
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_ENC_NUM_PLANES];
- int ret,i;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- memset(&qbuf, 0, sizeof(qbuf));
- if (pCTX->v4l2_enc.bInputPhyVir) {
- qbuf.memory = V4L2_MEMORY_USERPTR;
- qbuf.index = pCTX->v4l2_enc.beingUsedIndex;
- planes[0].m.userptr = (unsigned long)input_info->YPhyAddr;
- planes[0].length = input_info->YSize;
- planes[0].bytesused = input_info->YSize;
- planes[1].m.userptr = (unsigned long)input_info->CPhyAddr;
- planes[1].length = input_info->CSize;
- planes[1].bytesused = input_info->CSize;
-
- /* FIXME, this is only for case of not using B frame,
- Camera side should know which buffer is queued() refering to index of
- MFC dqbuf() */
- pCTX->v4l2_enc.beingUsedIndex++;
- pCTX->v4l2_enc.beingUsedIndex %= MFC_ENC_NUM_SRC_BUFS;
- LOGV("[%s] Phy Input Buffer idx Queued %d",__func__,pCTX->v4l2_enc.beingUsedIndex);
- } else {
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; i++)
- if (pCTX->v4l2_enc.mfc_src_bufs[i][0] == input_info->YVirAddr)
- break;
-
- if (i == pCTX->v4l2_enc.mfc_num_src_bufs) {
- LOGE("[%s] Can not use the buffer",__func__);
- return MFC_RET_INVALID_PARAM;
- } else {
- pCTX->v4l2_enc.beingUsedIndex = i;
- //pCTX->v4l2_enc.mfc_src_buf_flags[i] = BUF_ENQUEUED;
- }
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = pCTX->v4l2_enc.beingUsedIndex;
- planes[0].bytesused = pCTX->width * pCTX->height;
- planes[1].bytesused = (pCTX->width * pCTX->height) >> 1;
- LOGV("[%s] Input Buffer idx Queued %d",__func__,pCTX->v4l2_enc.beingUsedIndex);
- }
-
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.m.planes = planes;
- qbuf.length = 2;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_ENC_SET_INBUF_FAIL;
- }
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetOutBuf(void *openHandle, SSBSIP_MFC_ENC_OUTPUT_INFO *output_info)
-{
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (pCTX->v4l2_enc.bRunning == 0) {
- pCTX->encodedHeaderSize = pCTX->v4l2_enc.mfc_dst_bufs_bytes_used_len;
- output_info->dataSize = 0;
- } else {
- output_info->dataSize = pCTX->v4l2_enc.mfc_dst_bufs_bytes_used_len;
- }
-
- output_info->headerSize = pCTX->encodedHeaderSize;
- output_info->frameType = pCTX->encodedframeType;
- output_info->StrmPhyAddr = (void *)0;
- output_info->StrmVirAddr = (void *)pCTX->virStrmBuf;
- output_info->encodedYPhyAddr = (void*)0;
- output_info->encodedCPhyAddr = (void*)0;
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetOutBuf(void *openHandle, void *phyOutbuf, void *virOutbuf, int outputBufferSize)
-{
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- return MFC_RET_ENC_SET_OUTBUF_FAIL;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncExe(void *openHandle)
-{
- int ret;
- int dequeued_index;
- int loopcnt = 0;
- _MFCLIB *pCTX;
-
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_ENC_NUM_PLANES];
- enum v4l2_buf_type type;
-
- struct v4l2_control ctrl;
-
- struct pollfd poll_events;
- int poll_state;
-
- LOGV("[%s] Enter \n",__func__);
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- ctrl.id = V4L2_CID_CODEC_FRAME_TAG;
- ctrl.value = pCTX->inframetag;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed, V4L2_CID_CODEC_FRAME_TAG",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
-
- if (pCTX->v4l2_enc.bRunning == 0) {
- type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMON, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMON failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
-
- pCTX->v4l2_enc.bRunning = 1;
- }
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = 1;
-
- /* note: #define POLLOUT 0x0004 */
- poll_events.fd = pCTX->hMFC;
- poll_events.events = POLLIN | POLLERR;
- poll_events.revents = 0;
-
- /* wait for encoding */
- do {
- poll_state = poll((struct pollfd*)&poll_events, 1, POLL_ENC_WAIT_TIMEOUT);
- if (0 < poll_state) {
- if (poll_events.revents & POLLIN) { /* POLLIN */
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- if (ret == 0)
- break;
- } else if (poll_events.revents & POLLERR) { /* POLLERR */
- LOGE("[%s] POLLERR\n",__func__);
- return MFC_RET_ENC_EXE_ERR;
- } else {
- LOGE("[%s] poll() returns 0x%x\n",__func__, poll_events.revents);
- return MFC_RET_ENC_EXE_ERR;
- }
- } else if (0 > poll_state) {
- LOGE("[%s] poll() Encoder POLL Timeout 0x%x\n",__func__, poll_events.revents);
- return MFC_RET_ENC_EXE_ERR;
- }
- loopcnt++;
- } while ((0 == poll_state) && (loopcnt < 5));
-
- if (pCTX->v4l2_enc.bRunning != 0) {
- pCTX->encodedframeType = (qbuf.flags & 0x18) >> 3; /* encoded frame type */
-
- LOGV("[%s] encoded frame type = %d\n",__func__, pCTX->encodedframeType);
- switch (pCTX->encodedframeType) {
- case 1:
- pCTX->encodedframeType = MFC_FRAME_TYPE_I_FRAME;
- break;
- case 2:
- pCTX->encodedframeType = MFC_FRAME_TYPE_P_FRAME;
- break;
- case 4:
- pCTX->encodedframeType = MFC_FRAME_TYPE_B_FRAME;
- break;
- default:
- LOGE("[%s] VIDIOC_DQBUF failed, encoded frame type is wrong",__func__);
- }
- }
-
- dequeued_index = qbuf.index;
-
- if (qbuf.m.planes[0].bytesused > 0) { /* FIXME later */
- pCTX->v4l2_enc.mfc_dst_bufs_bytes_used_len = qbuf.m.planes[0].bytesused;
- }
-
- ctrl.id = V4L2_CID_CODEC_FRAME_TAG;
- ctrl.value = 0;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed, V4L2_CID_CODEC_FRAME_TAG",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
-
- pCTX->outframetagtop = ctrl.value;
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = dequeued_index;
- qbuf.m.planes = planes;
- qbuf.length = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
-
- if (pCTX->v4l2_enc.bRunning != 0) {
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-
- if (pCTX->v4l2_enc.bInputPhyVir)
- qbuf.memory = V4L2_MEMORY_USERPTR;
- else
- qbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_DQBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
- }
- pCTX->v4l2_enc.mfc_src_buf_flags[qbuf.index] = BUF_DEQUEUED;
-
- /* Update context stream buffer address */
- pCTX->virStrmBuf = pCTX->v4l2_enc.mfc_dst_bufs[dequeued_index];
- LOGV("[%s] Strm out idx %d",__func__,dequeued_index);
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetConfig(void *openHandle, SSBSIP_MFC_ENC_CONF conf_type, void *value)
-{
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("[%s] value is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- switch (conf_type) {
- case MFC_ENC_SETCONF_FRAME_TAG:
- pCTX->inframetag = *((unsigned int *)value);
- return MFC_RET_OK;
-
- case MFC_ENC_SETCONF_ALLOW_FRAME_SKIP:
- pCTX->enc_frameskip = *((int *)value);
- return MFC_RET_OK;
-#if 0
- case MFC_ENC_SETCONF_VUI_INFO:
- vui_info = *((struct mfc_enc_vui_info *) value);
- EncArg.args.set_config.in_config_value[0] = (int)(vui_info.aspect_ratio_idc);
- EncArg.args.set_config.in_config_value[1] = 0;
- break;
-
- case MFC_ENC_SETCONF_HIER_P:
- hier_p_qp = *((struct mfc_enc_hier_p_qp *) value);
- EncArg.args.set_config.in_config_value[0] = (int)(hier_p_qp.t0_frame_qp);
- EncArg.args.set_config.in_config_value[1] = (int)(hier_p_qp.t2_frame_qp);
- EncArg.args.set_config.in_config_value[2] = (int)(hier_p_qp.t3_frame_qp);
- break;
-
- case MFC_ENC_SETCONF_I_PERIOD:
-#endif
- default:
- LOGE("[%s] conf_type(%d) is NOT supported\n",__func__, conf_type);
- return MFC_RET_INVALID_PARAM;
- }
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetConfig(void *openHandle, SSBSIP_MFC_ENC_CONF conf_type, void *value)
-{
- _MFCLIB *pCTX;
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("[%s] value is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- switch (conf_type) {
- case MFC_ENC_GETCONF_FRAME_TAG:
- *((unsigned int *)value) = pCTX->outframetagtop;
- break;
-
- default:
- LOGE("[%s] conf_type(%d) is NOT supported\n",__func__, conf_type);
- return MFC_RET_INVALID_PARAM;
- }
-
- return MFC_RET_OK;
-}
-
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/SsbSipMfcApi.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/SsbSipMfcApi.h
deleted file mode 100644
index b85256b..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/SsbSipMfcApi.h
+++ /dev/null
@@ -1,382 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 _SSBSIP_MFC_API_H_
-#define _SSBSIP_MFC_API_H_
-
-/*--------------------------------------------------------------------------------*/
-/* Definition */
-/*--------------------------------------------------------------------------------*/
-#define MAX_DECODER_INPUT_BUFFER_SIZE (1024 * 3072)
-#define MAX_ENCODER_OUTPUT_BUFFER_SIZE (1024 * 3072)
-
-#define SUPPORT_1080P 1
-
-#if SUPPORT_1080P
-#define MMAP_BUFFER_SIZE_MMAP (70*1024*1024) /* only C110 use this value. in C210, memory size is decided in menuconfig*/
-#else
-#define MMAP_BUFFER_SIZE_MMAP (62*1024*1024)
-#endif
-
-#define SAMSUNG_MFC_DEV_NAME "/dev/video"
-
-#define SSBSIP_MFC_OK (1)
-#define SSBSIP_MFC_FAIL (0)
-
-/*--------------------------------------------------------------------------------*/
-/* 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,
- NV21_LINEAR
-} 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,
-
- /* C210 specific feature */
- MFC_DEC_SETCONF_IMMEDIATELY_DISPLAY,
- MFC_DEC_SETCONF_DPB_FLUSH,
- MFC_DEC_SETCONF_PIXEL_CACHE,
- MFC_DEC_GETCONF_WIDTH_HEIGHT
-} 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,
-
- /* C210 specific feature */
- MFC_ENC_SETCONF_VUI_INFO,
- MFC_ENC_SETCONF_I_PERIOD,
- MFC_ENC_SETCONF_HIER_P
-} 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,
- MFC_GETOUTBUF_CHANGE_RESOL
-} 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 */
- int disp_pic_frame_type; /* [OUT] display picture frame type information */
-
- /* C210 UMP feature */
- unsigned int y_cookie; /* [OUT] cookie for Y address */
- unsigned int c_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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 */
-
- /* C210 UMP feature */
- unsigned int y_cookie; /* [OUT] cookie for Y address */
- unsigned int c_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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 */
-
- /* C210 UMP feature */
- unsigned int strm_cookie; /* [OUT] cooke for stream buffer */
- unsigned int y_encoded_cookie; /* [OUT] cookie for Y address */
- unsigned int c_encoded_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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);
-void *SsbSipMfcDecOpenExt(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 SsbSipMfcDecExeNb(void *openHandle, int lengthBufFill);
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecClose(void *openHandle);
-void *SsbSipMfcDecGetInBuf(void *openHandle, void **phyInBuf, int inputBufferSize);
-//SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecWaitForOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info);
-
-#if (defined(CONFIG_VIDEO_MFC_VCM_UMP) || defined(USE_UMP))
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, unsigned int secure_id, int size);
-#else
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, void *phyInBuf, void *virInBuf, int size);
-#endif
-
-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);
-void *SsbSipMfcEncOpenExt(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 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/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/mfc_errno.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/mfc_errno.h
deleted file mode 100644
index b8e96ab..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/mfc_errno.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 __MFC_ERRNO_H
-#define __MFC_ERRNO_H __FILE__
-
-enum mfc_ret_code {
- MFC_OK = 1,
- MFC_FAIL = -1000,
- MFC_OPEN_FAIL = -1001,
- MFC_CLOSE_FAIL = -1002,
-
- MFC_DEC_INIT_FAIL = -2000,
- MFC_DEC_EXE_TIME_OUT = -2001,
- MFC_DEC_EXE_ERR = -2002,
- MFC_DEC_GET_INBUF_FAIL = 2003,
- MFC_DEC_SET_INBUF_FAIL = 2004,
- MFC_DEC_GET_OUTBUF_FAIL = -2005,
- MFC_DEC_GET_CONF_FAIL = -2006,
- MFC_DEC_SET_CONF_FAIL = -2007,
-
- MFC_ENC_INIT_FAIL = -3000,
- MFC_ENC_EXE_TIME_OUT = -3001,
- MFC_ENC_EXE_ERR = -3002,
- MFC_ENC_GET_INBUF_FAIL = -3003,
- MFC_ENC_SET_INBUF_FAIL = -3004,
- MFC_ENC_GET_OUTBUF_FAIL = -3005,
- MFC_ENC_SET_OUTBUF_FAIL = -3006,
- MFC_ENC_GET_CONF_FAIL = -3007,
- MFC_ENC_SET_CONF_FAIL = -3008,
-
- MFC_STATE_INVALID = -4000,
- MFC_DEC_HEADER_FAIL = -4001,
- MFC_DEC_INIT_BUF_FAIL = -4002,
- MFC_ENC_HEADER_FAIL = -5000,
- MFC_ENC_PARAM_FAIL = -5001,
- MFC_FRM_BUF_SIZE_FAIL = -6000,
- MFC_FW_LOAD_FAIL = -6001,
- MFC_FW_INIT_FAIL = -6002,
- MFC_INST_NUM_EXCEEDED_FAIL = -6003,
- MFC_MEM_ALLOC_FAIL = -6004,
- MFC_MEM_INVALID_ADDR_FAIL = -6005,
- MFC_MEM_MAPPING_FAIL = -6006,
- MFC_GET_CONF_FAIL = -6007,
- MFC_SET_CONF_FAIL = -6008,
- MFC_INVALID_PARAM_FAIL = -6009,
- MFC_API_FAIL = -9000,
-
- MFC_CMD_FAIL = -1003,
- MFC_SLEEP_FAIL = -1010,
- MFC_WAKEUP_FAIL = -1020,
-
- MFC_CLK_ON_FAIL = -1030,
- MFC_CLK_OFF_FAIL = -1030,
- MFC_PWR_ON_FAIL = -1040,
- MFC_PWR_OFF_FAIL = -1041,
-};
-
-#endif /* __MFC_ERRNO_H */
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/mfc_interface.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/mfc_interface.h
deleted file mode 100644
index b7289c4..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/mfc_interface.h
+++ /dev/null
@@ -1,541 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 __MFC_INTERFACE_H
-#define __MFC_INTERFACE_H
-
-#include "mfc_errno.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_REAL_ADDR (0x00800012)
-#define IOCTL_MFC_GET_MMAP_SIZE (0x00800014)
-#define IOCTL_MFC_SET_IN_BUF (0x00800018)
-
-#define IOCTL_MFC_SET_CONFIG (0x00800101)
-#define IOCTL_MFC_GET_CONFIG (0x00800102)
-
-#define IOCTL_MFC_SET_BUF_CACHE (0x00800201)
-
-/* MFC H/W support maximum 32 extra DPB. */
-#define MFC_MAX_EXTRA_DPB 5
-#define MFC_MAX_DISP_DELAY 0xF
-
-#define MFC_LIB_VER_MAJOR 1
-#define MFC_LIB_VER_MINOR 00
-
-#define BUF_L_UNIT (1024)
-#define Align(x, alignbyte) (((x)+(alignbyte)-1)/(alignbyte)*(alignbyte))
-
-#define MFC_ENC_NUM_SRC_BUFS 2 /* Number of source buffers to request */
-#define MFC_ENC_MAX_DST_BUFS 2 /* The maximum number of buffers */
-#define MFC_ENC_NUM_PLANES 2 /* Number of planes used by MFC Input */
-
-#define MFC_DEC_NUM_SRC_BUFS 2 /* Number of source buffers to request */
-#define MFC_DEC_MAX_DST_BUFS 32 /* The maximum number of buffers */
-#define MFC_DEC_NUM_PLANES 2 /* Number of planes used by MFC output */
-
-enum inst_type {
- DECODER = 0x1,
- ENCODER = 0x2,
-};
-
-typedef enum {
- MFC_UNPACKED_PB = 0,
- MFC_PACKED_PB = 1
-} mfc_packed_mode;
-
-typedef enum {
- SSBSIP_MFC_LAST_FRAME_NOT_RECEIVED = 0,
- SSBSIP_MFC_LAST_FRAME_RECEIVED = 1,
- SSBSIP_MFC_LAST_FRAME_PROCESSED = 2
-} SSBSIP_MFC_LAST_FRAME_STATUS;
-
-typedef enum {
- MFC_USE_NONE = 0x0000,
- MFC_USE_YUV_BUFF = 0x0001,
- MFC_USE_STRM_BUFF = 0x0010,
- MFC_USE_SRC_STREAMON = 0x0100,
- MFC_USE_DST_STREAMON = 0x1000,
-} s3c_mfc_interbuff_status;
-
-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) */
-} SSBSIP_MFC_CRC_DATA;
-
-struct mfc_strm_ref_buf_arg {
- unsigned int strm_ref_y;
- unsigned int mv_ref_yc;
-};
-
-struct mfc_frame_buf_arg {
- unsigned int luma;
- unsigned int chroma;
-};
-
-struct mfc_enc_init_common_arg {
- 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_gop_num; /* [IN] GOP Number (interval of I-frame) */
- int in_vop_quant; /* [IN] VOP quant */
- int in_vop_quant_p; /* [IN] VOP quant for P frame */
-
- /* [IN] RC enable */
- /* [IN] RC enable (0:disable, 1:frame level RC) */
- int in_rc_fr_en;
- int in_rc_bitrate; /* [IN] RC parameter (bitrate in kbps) */
-
- int in_rc_qbound_min; /* [IN] RC parameter (Q bound Min) */
- int in_rc_qbound_max; /* [IN] RC parameter (Q bound Max) */
- int in_rc_rpara; /* [IN] RC parameter (Reaction Coefficient) */
-
- /* [IN] Multi-slice mode (0:single, 1:multiple) */
- int in_ms_mode;
- /* [IN] Multi-slice size (in num. of mb or byte) */
- int in_ms_arg;
-
- int in_mb_refresh; /* [IN] Macroblock refresh */
-
- /* [IN] Enable (1) / Disable (0) padding with the specified values */
- int in_pad_ctrl_on;
-
- /* [IN] pad value if pad_ctrl_on is Enable */
- int in_y_pad_val;
- int in_cb_pad_val;
- int in_cr_pad_val;
-
- /* linear or tiled */
- int in_frame_map;
-
- unsigned int in_pixelcache;
-
- unsigned int in_mapped_addr;
- struct mfc_strm_ref_buf_arg out_u_addr;
- struct mfc_strm_ref_buf_arg out_p_addr;
- struct mfc_strm_ref_buf_arg out_buf_size;
- unsigned int out_header_size;
-};
-
-struct mfc_enc_init_h263_arg {
- int in_rc_framerate; /* [IN] RC parameter (framerate) */
-};
-
-struct mfc_enc_init_mpeg4_arg {
- int in_profile; /* [IN] profile */
- int in_level; /* [IN] level */
-
- int in_vop_quant_b; /* [IN] VOP quant for B frame */
-
- /* [IN] B frame number */
- int in_bframenum;
-
- /* [IN] Quarter-pel MC enable (1:enabled, 0:disabled) */
- int in_quart_pixel;
-
- int in_TimeIncreamentRes; /* [IN] VOP time resolution */
- int in_VopTimeIncreament; /* [IN] Frame delta */
-};
-
-struct mfc_enc_init_h264_arg {
- int in_profile; /* [IN] profile */
- int in_level; /* [IN] level */
-
- int in_vop_quant_b; /* [IN] VOP quant for B frame */
-
- /* [IN] B frame number */
- int in_bframenum;
-
- /* [IN] interlace mode(0:progressive, 1:interlace) */
- int in_interlace_mode;
-
- /* [IN] reference number */
- int in_reference_num;
- /* [IN] reference number of P frame */
- int in_ref_num_p;
-
- int in_rc_framerate; /* [IN] RC parameter (framerate) */
- int in_rc_mb_en; /* [IN] RC enable (0:disable, 1:MB level RC) */
- /* [IN] MB level rate control dark region adaptive feature */
- int in_rc_mb_dark_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control smooth region adaptive feature */
- int in_rc_mb_smooth_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control static region adaptive feature */
- int in_rc_mb_static_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control activity region adaptive feature */
- int in_rc_mb_activity_dis; /* (0:enable, 1:disable) */
-
- /* [IN] disable deblocking filter idc */
- int in_deblock_dis; /* (0: enable,1: disable, 2:Disable at slice boundary) */
- /* [IN] slice alpha c0 offset of deblocking filter */
- int in_deblock_alpha_c0;
- /* [IN] slice beta offset of deblocking filter */
- int in_deblock_beta;
-
- /* [IN] ( 0 : CAVLC, 1 : CABAC ) */
- int in_symbolmode;
- /* [IN] (0: only 4x4 transform, 1: allow using 8x8 transform) */
- int in_transform8x8_mode;
-
- /* [IN] Inter weighted parameter for mode decision */
- int in_md_interweight_pps;
- /* [IN] Intra weighted parameter for mode decision */
- int in_md_intraweight_pps;
-};
-
-struct mfc_enc_init_arg {
- struct mfc_enc_init_common_arg cmn;
- union {
- struct mfc_enc_init_h264_arg h264;
- struct mfc_enc_init_mpeg4_arg mpeg4;
- struct mfc_enc_init_h263_arg h263;
- } codec;
-};
-
-struct mfc_enc_exe_arg {
- 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 */
- unsigned 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_Y_addr; /*[OUT]Out-buffer addr of encoded Y component */
- unsigned int out_CbCr_addr; /*[OUT]Out-buffer addr of encoded CbCr component */
- unsigned int out_frametag_top; /* [OUT] unique frame ID of an output frame or top field */
- unsigned int out_frametag_bottom;/* [OUT] unique frame ID of bottom field */
-
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int out_y_secure_id;
- unsigned int out_c_secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int out_y_cookie;
- unsigned int out_c_cookie;
-#endif
-};
-
-struct mfc_dec_init_arg {
- SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN] codec type */
- int in_strm_buf; /* [IN] address of stream buffer */
- int in_strm_size; /* [IN] filled size in stream buffer */
- int in_packed_PB; /* [IN] Is packed PB frame or not, 1: packedPB 0: unpacked */
-
- unsigned int in_crc; /* [IN] */
- unsigned int in_pixelcache; /* [IN] */
- unsigned int in_slice; /* [IN] */
- unsigned int in_numextradpb; /* [IN] */
-
- unsigned int in_mapped_addr;
-
- int out_frm_width; /* [OUT] width of YUV420 frame */
- int out_frm_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_right_offset; /* [OUT] crop information for h264 */
- int out_crop_left_offset;
- int out_crop_bottom_offset;
- int out_crop_top_offset;
-};
-
-struct mfc_dec_exe_arg {
- SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN] codec type */
- int in_strm_buf; /* [IN] the physical address of STRM_BUF */
- /* [IN] Size of video stream filled in STRM_BUF */
- int in_strm_size;
- /* [IN] the address of dpb FRAME_BUF */
- struct mfc_frame_buf_arg in_frm_buf;
- /* [IN] size of dpb FRAME_BUF */
- struct mfc_frame_buf_arg in_frm_size;
- /* [IN] Unique frame ID eg. application specific timestamp */
- unsigned int in_frametag;
- /* [IN] immdiate Display for seek,thumbnail and one frame */
- int in_immediately_disp;
- /* [OUT] the physical address of display buf */
- int out_display_Y_addr;
- /* [OUT] the physical address of display buf */
- int out_display_C_addr;
- int out_display_status;
- /* [OUT] unique frame ID of an output frame or top field */
- unsigned int out_frametag_top;
- /* [OUT] unique frame ID of bottom field */
- unsigned int out_frametag_bottom;
- int out_pic_time_top;
- int out_pic_time_bottom;
- int out_consumed_byte;
-
- int out_crop_right_offset;
- int out_crop_left_offset;
- int out_crop_bottom_offset;
- int out_crop_top_offset;
-
- /* in new driver, each buffer offset must be return to the user */
- int out_y_offset;
- int out_c_offset;
-
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int out_y_secure_id;
- unsigned int out_c_secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int out_y_cookie;
- unsigned int out_c_cookie;
-#endif
- 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_disp_pic_frame_type; /* [OUT] display picture frame type information */
-};
-
-struct mfc_get_config_arg {
- /* [IN] Configurable parameter type */
- int in_config_param;
-
- /* [IN] Values to get for the configurable parameter. */
- /* Maximum four integer values can be obtained; */
- int out_config_value[4];
-};
-
-struct mfc_set_config_arg {
- /* [IN] Configurable parameter type */
- int in_config_param;
-
- /* [IN] Values to be set for the configurable parameter. */
- /* Maximum four integer values can be set. */
- int in_config_value[4];
-};
-
-struct mfc_get_real_addr_arg {
- unsigned int key;
- unsigned int addr;
-};
-
-struct mfc_buf_alloc_arg {
- enum inst_type type;
- int size;
- /*
- unsigned int mapped;
- */
- unsigned int align;
-
- unsigned int addr;
- /*
- unsigned int phys;
- */
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- /* FIMXE: invalid secure id == -1 */
- unsigned int secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int cookie;
-#else
- unsigned int offset;
-#endif
-};
-
-struct mfc_buf_free_arg {
- unsigned int addr;
-};
-
-/* RMVME */
-struct mfc_mem_alloc_arg {
- enum inst_type type;
- int buff_size;
- SSBIP_MFC_BUFFER_TYPE buf_cache_type;
- unsigned int mapped_addr;
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int cookie;
-#else
- unsigned int offset;
-#endif
-};
-
-struct mfc_mem_free_arg {
- unsigned int key;
-};
-/* RMVME */
-
-union mfc_args {
- /*
- struct mfc_enc_init_arg enc_init;
-
- struct mfc_enc_init_mpeg4_arg enc_init_mpeg4;
- struct mfc_enc_init_mpeg4_arg enc_init_h263;
- struct mfc_enc_init_h264_arg enc_init_h264;
- */
- struct mfc_enc_init_arg enc_init;
- struct mfc_enc_exe_arg enc_exe;
-
- struct mfc_dec_init_arg dec_init;
- struct mfc_dec_exe_arg dec_exe;
-
- struct mfc_get_config_arg get_config;
- struct mfc_set_config_arg set_config;
-
- struct mfc_buf_alloc_arg buf_alloc;
- struct mfc_buf_free_arg buf_free;
- struct mfc_get_real_addr_arg real_addr;
-
- /* RMVME */
- struct mfc_mem_alloc_arg mem_alloc;
- struct mfc_mem_free_arg mem_free;
- /* RMVME */
-};
-
-struct mfc_common_args {
- enum mfc_ret_code ret_code; /* [OUT] error code */
- union mfc_args args;
-};
-
-struct mfc_enc_vui_info {
- int aspect_ratio_idc;
-};
-
-struct mfc_dec_fimv1_info {
- int width;
- int height;
-};
-
-struct mfc_enc_hier_p_qp {
- int t0_frame_qp;
- int t2_frame_qp;
- int t3_frame_qp;
-};
-
-enum BUF_STATUS {
- BUF_ENQUEUED,
- BUF_DEQUEUED
-};
-
-struct mfc_dec_v4l2 {
- char *mfc_src_bufs[MFC_DEC_NUM_SRC_BUFS]; /* information of source buffers */
- char *mfc_dst_bufs[MFC_DEC_MAX_DST_BUFS][MFC_DEC_NUM_PLANES]; /* information of destination buffers */
- char *mfc_dst_phys[MFC_DEC_MAX_DST_BUFS][MFC_DEC_NUM_PLANES]; /* cma information of destination buffers */
-
- unsigned int mfc_src_bufs_len; /* needed for munmap */
- unsigned int mfc_dst_bufs_len[MFC_DEC_NUM_PLANES]; /* needed for munmap */
-
- unsigned int mfc_num_src_bufs; /* the number of source buffers */
- unsigned int mfc_num_dst_bufs; /* the number of destination buffers */
-
- char mfc_src_buf_flags[MFC_DEC_NUM_SRC_BUFS];
- int bBeingFinalized;
- int allocIndex;
- int beingUsedIndex;
-};
-
-struct mfc_enc_v4l2 {
- char *mfc_src_bufs[MFC_ENC_NUM_SRC_BUFS][MFC_ENC_NUM_PLANES];
- char *mfc_src_phys[MFC_ENC_NUM_SRC_BUFS][MFC_ENC_NUM_PLANES];
- char *mfc_dst_bufs[MFC_ENC_MAX_DST_BUFS];
-
- unsigned int mfc_src_bufs_len[MFC_ENC_NUM_PLANES];
- unsigned int mfc_dst_bufs_len;
-
- unsigned int mfc_num_src_bufs;
- unsigned int mfc_num_dst_bufs;
-
- unsigned int mfc_dst_bufs_bytes_used_len;
- char mfc_src_buf_flags[MFC_ENC_NUM_SRC_BUFS];
- int bRunning;
- int bInputPhyVir; /* Flag to use MFC src as physical or virtual 0: virtual 1: physical */
- int beingUsedIndex;
-};
-
-typedef struct {
- int magic;
- int hMFC;
- int hVMEM;
- int width;
- int height;
- int sizeStrmBuf;
- struct mfc_frame_buf_arg sizeFrmBuf;
- int displayStatus;
- int inter_buff_status;
- unsigned int virFreeStrmAddr;
- unsigned int phyStrmBuf;
- unsigned int virStrmBuf;
- unsigned int virMvRefYC;
- struct mfc_frame_buf_arg phyFrmBuf;
- struct mfc_frame_buf_arg virFrmBuf;
- unsigned int mapped_addr;
- unsigned int mapped_size;
- struct mfc_common_args MfcArg;
- SSBSIP_MFC_CODEC_TYPE codecType;
- SSBSIP_MFC_DEC_OUTPUT_INFO decOutInfo;
- unsigned int inframetag;
- unsigned int outframetagtop;
- unsigned int outframetagbottom;
- unsigned int immediatelydisp;
- unsigned int encodedHeaderSize;
- int encodedDataSize;
- unsigned int encodedframeType;
- struct mfc_frame_buf_arg encodedphyFrmBuf;
-
- unsigned int dec_crc;
- unsigned int dec_pixelcache;
- unsigned int dec_slice;
- unsigned int dec_numextradpb;
-
- int input_cookie;
- int input_secure_id;
- int input_size;
-
- /* to support non-blocking mode */
- unsigned int encode_cnt;
-
- struct mfc_dec_v4l2 v4l2_dec;
- struct mfc_enc_v4l2 v4l2_enc;
-
- int enc_frameskip;
- int cacheablebuffer;
- struct mfc_dec_fimv1_info fimv1_res;
- SSBSIP_MFC_LAST_FRAME_STATUS lastframe;
- SSBSIP_MFC_INSTRM_MODE_TYPE framemap;
-} _MFCLIB;
-
-#define ENC_PROFILE_LEVEL(profile, level) ((profile) | ((level) << 8))
-#define ENC_RC_QBOUND(min_qp, max_qp) ((min_qp) | ((max_qp) << 8))
-
-#define SSBSIP_MFC_FAIL (0)
-
-#endif /* __MFC_INTERFACE_H */
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/Android.mk b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/Android.mk
deleted file mode 100644
index 949c637..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/Android.mk
+++ /dev/null
@@ -1,7 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_VIDEO_PATH :=$(LOCAL_PATH)
-
-include $(LOCAL_VIDEO_PATH)/mfc_v4l2/Android.mk
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/Android.mk b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/Android.mk
deleted file mode 100644
index 89f3e84..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/Android.mk
+++ /dev/null
@@ -1,39 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_COPY_HEADERS_TO := libsecmm
-LOCAL_COPY_HEADERS := \
- include/mfc_errno.h \
- include/mfc_interface.h \
- include/SsbSipMfcApi.h
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- dec/src/SsbSipMfcDecAPI.c \
- enc/src/SsbSipMfcEncAPI.c
-
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/include \
- $(BOARD_HAL_PATH)/include
-
-LOCAL_MODULE := libsecmfcapi
-
-LOCAL_PRELINK_MODULE := false
-
-ifeq ($(BOARD_USE_S3D_SUPPORT), true)
-LOCAL_CFLAGS += -DS3D_SUPPORT
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES :=
-LOCAL_SHARED_LIBRARIES := liblog
-
-#ifeq ($(BOARD_USE_V4L2_ION),true)
-#LOCAL_CFLAGS += -DUSE_ION
-#LOCAL_SHARED_LIBRARIES += libion
-#endif
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/dec/src/SsbSipMfcDecAPI.c b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/dec/src/SsbSipMfcDecAPI.c
deleted file mode 100644
index fb04587..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/dec/src/SsbSipMfcDecAPI.c
+++ /dev/null
@@ -1,1740 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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.
- */
-
-#include <stdio.h>
-#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 <sys/poll.h>
-#include "videodev2.h"
-
-#include "mfc_interface.h"
-#include "SsbSipMfcApi.h"
-#ifdef USE_ION
-#include "ion.h"
-#endif
-
-/* #define LOG_NDEBUG 0 */
-#define LOG_TAG "MFC_DEC_APP"
-#include <utils/Log.h>
-
-/*#define CRC_ENABLE
-#define SLICE_MODE_ENABLE */
-#define POLL_DEC_WAIT_TIMEOUT 25
-
-#define USR_DATA_START_CODE (0x000001B2)
-#define VOP_START_CODE (0x000001B6)
-#define MP4_START_CODE (0x000001)
-
-#define DEFAULT_NUMBER_OF_EXTRA_DPB 5
-#define CLEAR(x) memset (&(x), 0, sizeof(x))
-#ifdef S3D_SUPPORT
-#define OPERATE_BIT(x, mask, shift) ((x & (mask << shift)) >> shift)
-#define FRAME_PACK_SEI_INFO_NUM 4
-#endif
-
-enum {
- NV12MT_FMT = 0,
- NV12M_FMT,
- NV21M_FMT,
-};
-
-static char *mfc_dev_name = SAMSUNG_MFC_DEV_NAME;
-static int mfc_dev_node = 6;
-
-int read_header_data(void *openHandle);
-int init_mfc_output_stream(void *openHandle);
-int isBreak_loop(void *openHandle);
-
-int v4l2_mfc_querycap(int fd)
-{
- struct v4l2_capability cap;
- int ret;
-
- CLEAR(cap);
-
- ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QUERYCAP failed", __func__);
- return ret;
- }
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
- LOGE("[%s] Device does not support capture", __func__);
- return -1;
- }
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
- LOGE("[%s] Device does not support output", __func__);
- return -1;
- }
-
- if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
- LOGE("[%s] Device does not support streaming", __func__);
- return -1;
- }
-
- return 0;
-}
-
-int v4l2_mfc_s_fmt(int fd, enum v4l2_buf_type type,
- int pixelformat, unsigned int sizeimage, int width, int height)
-{
- int ret;
- struct v4l2_format fmt;
-
- CLEAR(fmt);
-
- fmt.type = type;
-
- if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
- switch (pixelformat) {
- case H264_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
- break;
- case MPEG4_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_MPEG4;
- break;
- case H263_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H263;
- break;
- case XVID_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_XVID;
- break;
- case MPEG2_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_MPEG12;
- break;
- case FIMV1_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_FIMV1;
- fmt.fmt.pix_mp.width = width;
- fmt.fmt.pix_mp.height = height;
- break;
- case FIMV2_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_FIMV2;
- break;
- case FIMV3_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_FIMV3;
- break;
- case FIMV4_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_FIMV4;
- break;
- case VC1_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_VC1;
- break;
- case VC1RCV_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_VC1_RCV;
- break;
-#if defined (MFC6x_VERSION)
- case VP8_DEC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_VP8;
- break;
-#endif
- default:
- LOGE("[%s] Does NOT support the codec type (%d)", __func__, pixelformat);
- return -1;
- }
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage = sizeimage;
- } else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
- switch (pixelformat) {
- case NV12MT_FMT:
-#if defined (MFC6x_VERSION)
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12MT_16X16;
-#else
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12MT;
-#endif
- break;
- case NV12M_FMT:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M;
- break;
- case NV21M_FMT:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV21M;
- break;
- default:
- LOGE("[%s] Does NOT support the pixel format (%d)", __func__, pixelformat);
- return -1;
- }
- } else {
- LOGE("[%s] Wrong buffer type", __func__);
- return -1;
- }
-
- ret = ioctl(fd, VIDIOC_S_FMT, &fmt);
-
- return ret;
-}
-
-int v4l2_mfc_reqbufs(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int *buf_cnt)
-{
- struct v4l2_requestbuffers reqbuf;
- int ret;
-
- CLEAR(reqbuf);
-
- reqbuf.type = type;
- reqbuf.memory = memory;
- reqbuf.count = *buf_cnt;
-
- ret = ioctl(fd, VIDIOC_REQBUFS, &reqbuf);
- *buf_cnt = reqbuf.count;
-
- return ret;
-}
-
-int v4l2_mfc_querybuf(int fd, struct v4l2_buffer *buf, enum v4l2_buf_type type,
- enum v4l2_memory memory, int index, struct v4l2_plane *planes)
-{
- int length = -1, ret;
-
- if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
- length = 1;
- else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
- length = 2;
-
- CLEAR(*buf);
- buf->type = type;
- buf->memory = memory;
- buf->index = index;
- buf->m.planes = planes;
- buf->length = length;
-
- ret = ioctl(fd, VIDIOC_QUERYBUF, buf);
-
- return ret;
-}
-
-int v4l2_mfc_streamon(int fd, enum v4l2_buf_type type)
-{
- int ret;
-
- ret = ioctl(fd, VIDIOC_STREAMON, &type);
-
- return ret;
-}
-
-int v4l2_mfc_streamoff(int fd, enum v4l2_buf_type type)
-{
- int ret;
-
- ret = ioctl(fd, VIDIOC_STREAMOFF, &type);
-
- return ret;
-}
-
-int v4l2_mfc_s_ctrl(int fd, int id, int value)
-{
- struct v4l2_control ctrl;
- int ret;
-
- CLEAR(ctrl);
- ctrl.id = id;
- ctrl.value = value;
-
- ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
-
- return ret;
-}
-
-int v4l2_mfc_g_ctrl(int fd, int id, int *value)
-{
- struct v4l2_control ctrl;
- int ret;
-
- CLEAR(ctrl);
- ctrl.id = id;
-
- ret = ioctl(fd, VIDIOC_G_CTRL, &ctrl);
- *value = ctrl.value;
-
- return ret;
-}
-
-#ifdef S3D_SUPPORT
-int v4l2_mfc_ext_g_ctrl(int fd, SSBSIP_MFC_DEC_CONF conf_type, void *value)
-{
- struct v4l2_ext_control ext_ctrl[FRAME_PACK_SEI_INFO_NUM];
- struct v4l2_ext_controls ext_ctrls;
- struct mfc_frame_pack_sei_info *sei_info;
- int ret, i;
-
- ext_ctrls.ctrl_class = V4L2_CTRL_CLASS_CODEC;
-
- switch (conf_type) {
- case MFC_DEC_GETCONF_FRAME_PACKING:
- sei_info = (struct mfc_frame_pack_sei_info *)value;
- for (i=0; i<FRAME_PACK_SEI_INFO_NUM; i++)
- CLEAR(ext_ctrl[i]);
-
- ext_ctrls.count = FRAME_PACK_SEI_INFO_NUM;
- ext_ctrls.controls = ext_ctrl;
- ext_ctrl[0].id = V4L2_CID_CODEC_FRAME_PACK_SEI_AVAIL;
- ext_ctrl[1].id = V4L2_CID_CODEC_FRAME_PACK_ARRGMENT_ID;
- ext_ctrl[2].id = V4L2_CID_CODEC_FRAME_PACK_SEI_INFO;
- ext_ctrl[3].id = V4L2_CID_CODEC_FRAME_PACK_GRID_POS;
-
- ret = ioctl(fd, VIDIOC_G_EXT_CTRLS, &ext_ctrls);
-
- sei_info->sei_avail = ext_ctrl[0].value;
- sei_info->arrgment_id = ext_ctrl[1].value;
- sei_info->sei_info = ext_ctrl[2].value;
- sei_info->grid_pos = ext_ctrl[3].value;
- break;
- }
-
- return ret;
-}
-#endif
-
-int v4l2_mfc_qbuf(int fd, struct v4l2_buffer *qbuf, enum v4l2_buf_type type,
- enum v4l2_memory memory, int index,
- struct v4l2_plane *planes, int frame_length)
-{
- int ret, length = 0;
-
- if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
- CLEAR(*qbuf);
- length = 1;
- } else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
- length = 2;
- }
-
- qbuf->type = type;
- qbuf->memory = memory;
- qbuf->index = index;
- qbuf->m.planes = planes;
- qbuf->length = length;
- qbuf->m.planes[0].bytesused = frame_length;
-
- ret = ioctl(fd, VIDIOC_QBUF, qbuf);
-
- return ret;
-}
-
-int v4l2_mfc_dqbuf(int fd, struct v4l2_buffer *dqbuf, enum v4l2_buf_type type,
- enum v4l2_memory memory)
-{
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
- int ret, length = 0;
-
- CLEAR(*dqbuf);
- if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
- length = 1;
- else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
- length = 2;
-
- dqbuf->type = type;
- dqbuf->memory = memory;
- dqbuf->m.planes = planes;
- dqbuf->length = length;
-
- ret = ioctl(fd, VIDIOC_DQBUF, dqbuf);
-
- return ret;
-}
-
-int v4l2_mfc_g_fmt(int fd, struct v4l2_format *fmt, enum v4l2_buf_type type)
-{
- int ret;
-
- CLEAR(*fmt);
- fmt->type = type;
- ret = ioctl(fd, VIDIOC_G_FMT, fmt);
-
- return ret;
-}
-
-int v4l2_mfc_g_crop(int fd, struct v4l2_crop *crop, enum v4l2_buf_type type)
-{
- int ret;
-
- CLEAR(*crop);
- crop->type = type;
- ret = ioctl(fd, VIDIOC_G_CROP, crop);
-
- return ret;
-}
-
-int v4l2_mfc_poll(int fd, int *revents, int timeout)
-{
- struct pollfd poll_events;
- int ret;
-
- poll_events.fd = fd;
- poll_events.events = POLLOUT | POLLERR;
- poll_events.revents = 0;
-
- ret = poll((struct pollfd*)&poll_events, 1, timeout);
- *revents = poll_events.revents;
-
- return ret;
-}
-
-static void getAByte(char *buff, int *code)
-{
- int byte;
-
- *code = (*code << 8);
- byte = (int)*buff;
- byte &= 0xFF;
- *code |= byte;
-}
-
-static int isPBPacked(_MFCLIB *pCtx, int Frameleng)
-{
- char *strmBuffer = NULL;
- int startCode = 0xFFFFFFFF;
- int leng_idx = 1;
-
- strmBuffer = (char*)pCtx->virStrmBuf;
-
- while (1) {
- while (startCode != USR_DATA_START_CODE) {
- if ((startCode == VOP_START_CODE) || (leng_idx == Frameleng)) {
- LOGI("[%s] VOP START Found !!.....return",__func__);
- LOGW("[%s] Non Packed PB",__func__);
- return 0;
- }
- getAByte(strmBuffer, &startCode);
- LOGV(">> StartCode = 0x%08x <<\n", startCode);
- strmBuffer++;
- leng_idx++;
- }
- LOGI("[%s] User Data Found !!",__func__);
-
- do {
- if (*strmBuffer == 'p') {
- LOGW("[%s] Packed PB",__func__);
- return 1;
- }
- getAByte(strmBuffer, &startCode);
- strmBuffer++; leng_idx++;
- } while ((leng_idx <= Frameleng) && ((startCode >> 8) != MP4_START_CODE));
-
- if (leng_idx > Frameleng)
- break;
- }
-
- LOGW("[%s] Non Packed PB",__func__);
-
- return 0;
-}
-
-static void getMFCName(char *devicename, int size)
-{
- snprintf(devicename, size, "%s%d", SAMSUNG_MFC_DEV_NAME, mfc_dev_node);
-}
-
-void SsbSipMfcDecSetMFCNode(int devicenode)
-{
- mfc_dev_node = devicenode;
-}
-
-void SsbSipMfcDecSetMFCName(char *devicename)
-{
- mfc_dev_name = devicename;
-}
-
-void *SsbSipMfcDecOpen(void)
-{
- int hMFCOpen;
- _MFCLIB *pCTX;
- char mfc_dev_name[64];
-
- int ret;
- int req_count;
- unsigned int i, j;
-
- struct v4l2_buffer buf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
- LOGI("[%s] MFC Library Ver %d.%02d",__func__, MFC_LIB_VER_MAJOR, MFC_LIB_VER_MINOR);
-
- pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
- if (pCTX == NULL) {
- LOGE("[%s] malloc failed.",__func__);
- return NULL;
- }
-
- memset(pCTX, 0, sizeof(_MFCLIB));
-
- getMFCName(mfc_dev_name, 64);
- LOGI("[%s] dev name is %s",__func__,mfc_dev_name);
-
- if (access(mfc_dev_name, F_OK) != 0) {
- LOGE("[%s] MFC device node not exists",__func__);
- goto error_case1;
- }
-
- hMFCOpen = open(mfc_dev_name, O_RDWR|O_NONBLOCK, 0);
- if (hMFCOpen < 0) {
- LOGE("[%s] Failed to open MFC device",__func__);
- goto error_case1;
- }
-
- pCTX->hMFC = hMFCOpen;
-
- ret = v4l2_mfc_querycap(pCTX->hMFC);
- if (ret != 0) {
- LOGE("[%s] QUERYCAP failed", __func__);
- goto error_case2;
- }
-
- pCTX->inter_buff_status = MFC_USE_NONE;
- ret = v4l2_mfc_s_fmt(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
- H264_DEC, MAX_DECODER_INPUT_BUFFER_SIZE, 0, 0);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed",__func__);
- goto error_case2;
- }
-
- pCTX->v4l2_dec.mfc_src_bufs_len = MAX_DECODER_INPUT_BUFFER_SIZE;
-
- req_count = MFC_DEC_NUM_SRC_BUFS;
- ret = v4l2_mfc_reqbufs(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
- V4L2_MEMORY_MMAP, &req_count);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_REQBUFS failed",__func__);
- goto error_case2;
- }
-
- pCTX->v4l2_dec.mfc_num_src_bufs = req_count;
-
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_src_bufs; ++i) {
- ret = v4l2_mfc_querybuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
- V4L2_MEMORY_MMAP, i, planes);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QUERYBUF failed",__func__);
- goto error_case3;
- }
-
- pCTX->v4l2_dec.mfc_src_bufs[i] = mmap(NULL, buf.m.planes[0].length,
- PROT_READ | PROT_WRITE, MAP_SHARED, pCTX->hMFC, buf.m.planes[0].m.mem_offset);
- if (pCTX->v4l2_dec.mfc_src_bufs[i] == MAP_FAILED) {
- LOGE("[%s] mmap failed (%d)",__func__,i);
- goto error_case3;
- }
- }
- pCTX->inter_buff_status |= MFC_USE_STRM_BUFF;
-
- /* set extra DPB size to 5 as default for optimal performce (heuristic method) */
- pCTX->dec_numextradpb = DEFAULT_NUMBER_OF_EXTRA_DPB;
-
- pCTX->v4l2_dec.bBeingFinalized = 0;
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_NOT_RECEIVED;
-
- pCTX->cacheablebuffer = NO_CACHE;
-
- for (i = 0; i<MFC_DEC_NUM_SRC_BUFS; i++)
- pCTX->v4l2_dec.mfc_src_buf_flags[i] = BUF_DEQUEUED;
-
- pCTX->v4l2_dec.beingUsedIndex = 0;
-
- return (void *) pCTX;
-
-error_case3:
- for (j = 0; j < i; j++)
- munmap(pCTX->v4l2_dec.mfc_src_bufs[j], pCTX->v4l2_dec.mfc_src_bufs_len);
-error_case2:
- close(pCTX->hMFC);
-error_case1:
- free(pCTX);
-
- return NULL;
-}
-
-void *SsbSipMfcDecOpenExt(void *value)
-{
- _MFCLIB *pCTX;
-
- pCTX = SsbSipMfcDecOpen();
-
- if (pCTX == NULL)
- return NULL;
-
- if (NO_CACHE == (*(SSBIP_MFC_BUFFER_TYPE *)value)) {
- pCTX->cacheablebuffer = NO_CACHE;
- LOGI("[%s] non cacheable buffer",__func__);
- } else {
- pCTX->cacheablebuffer = CACHE;
- LOGI("[%s] cacheable buffer",__func__);
- }
-
- return (void *)pCTX;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecClose(void *openHandle)
-{
- int ret, i;
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (pCTX->inter_buff_status & MFC_USE_DST_STREAMON) {
- ret = v4l2_mfc_streamoff(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMOFF failed (destination buffers)",__func__);
- return MFC_RET_CLOSE_FAIL;
- }
- pCTX->inter_buff_status &= ~(MFC_USE_DST_STREAMON);
- }
-
- if (pCTX->inter_buff_status & MFC_USE_SRC_STREAMON) {
- ret = v4l2_mfc_streamoff(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMOFF failed (source buffers)",__func__);
- return MFC_RET_CLOSE_FAIL;
- }
- pCTX->inter_buff_status &= ~(MFC_USE_SRC_STREAMON);
- }
-
- if (pCTX->inter_buff_status & MFC_USE_STRM_BUFF) {
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_src_bufs; i++)
- munmap(pCTX->v4l2_dec.mfc_src_bufs[i], pCTX->v4l2_dec.mfc_src_bufs_len);
- pCTX->inter_buff_status &= ~(MFC_USE_STRM_BUFF);
- }
-
- if (pCTX->inter_buff_status & MFC_USE_YUV_BUFF) {
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_dst_bufs; i++) {
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[i][0], pCTX->v4l2_dec.mfc_dst_bufs_len[0]);
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[i][1], pCTX->v4l2_dec.mfc_dst_bufs_len[1]);
- }
- pCTX->inter_buff_status &= ~(MFC_USE_YUV_BUFF);
- }
-
-#ifdef USE_ION
- ion_client_destroy(pCTX->ion_fd);
-#endif
- close(pCTX->hMFC);
- free(pCTX);
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecInit(void *openHandle, SSBSIP_MFC_CODEC_TYPE codec_type, int Frameleng)
-{
- int packedPB = 0;
- _MFCLIB *pCTX;
- int ret;
-
- int width, height;
- int ctrl_value;
-
- struct v4l2_buffer buf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
- int poll_state, poll_revents;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- pCTX->codecType = codec_type;
-
- if ((pCTX->codecType == MPEG4_DEC) || (pCTX->codecType == XVID_DEC) ||
- (pCTX->codecType == FIMV1_DEC) || (pCTX->codecType == FIMV2_DEC) ||
- (pCTX->codecType == FIMV3_DEC) || (pCTX->codecType == FIMV4_DEC))
- packedPB = isPBPacked(pCTX, Frameleng);
-
- if (pCTX->codecType == FIMV1_DEC) {
- width = pCTX->fimv1_res.width;
- height = pCTX->fimv1_res.height;
- } else {
- width = 0;
- height = 0;
- }
- ret = v4l2_mfc_s_fmt(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, pCTX->codecType,
- MAX_DECODER_INPUT_BUFFER_SIZE, width, height);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed", __func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- /* Set default destination format as NV12MT */
- ret = v4l2_mfc_s_fmt(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, NV12MT_FMT,
- 0, width, height);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- /* PackedPB should be set after VIDIOC_S_FMT */
- if (packedPB) {
- ret = v4l2_mfc_s_ctrl(pCTX->hMFC, V4L2_CID_CODEC_PACKED_PB, 1);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed of PACKED_PB\n", __func__);
- return MFC_RET_DEC_SET_CONF_FAIL;
- }
- }
-
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
- V4L2_MEMORY_MMAP, pCTX->v4l2_dec.beingUsedIndex, planes, Frameleng);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- /* Processing the header requires running streamon
- on OUTPUT queue */
- ret = v4l2_mfc_streamon(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMON failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
- pCTX->inter_buff_status |= MFC_USE_SRC_STREAMON;
-
- ret = read_header_data(pCTX);
- if (ret != 0)
- goto error_case1;
-
- /* cacheable buffer */
- if (pCTX->cacheablebuffer == NO_CACHE)
- ctrl_value = 0;
- else
- ctrl_value = 1;
-
- ret = v4l2_mfc_s_ctrl(pCTX->hMFC, V4L2_CID_CACHEABLE, ctrl_value);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed, V4L2_CID_CACHEABLE", __func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
-#ifdef USE_ION
- pCTX->ion_fd = ion_client_create();
- if (pCTX->ion_fd < 3) {
- LOGE("[%s] Failed to get ion_fd : %d", __func__, pCTX->ion_fd);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-#endif
-
- ret = init_mfc_output_stream(pCTX);
- if (ret != 0)
- goto error_case1;
-
- ret = v4l2_mfc_streamon(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMON failed (destination buffers)", __func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
- pCTX->inter_buff_status |= MFC_USE_DST_STREAMON;
-
- do {
- poll_state = v4l2_mfc_poll(pCTX->hMFC, &poll_revents, POLL_DEC_WAIT_TIMEOUT);
- if (poll_state > 0) {
- if (poll_revents & POLLOUT) {
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_MMAP);
- if (ret == 0)
- break;
- } else if (poll_revents & POLLERR) {
- LOGE("[%s] POLLERR\n", __func__);
- return MFC_GETOUTBUF_STATUS_NULL;
- } else {
- LOGE("[%s] poll() returns 0x%x\n", __func__, poll_revents);
- return MFC_GETOUTBUF_STATUS_NULL;
- }
- } else if (poll_state < 0) {
- return MFC_GETOUTBUF_STATUS_NULL;
- }
- } while (poll_state == 0);
-
- return MFC_RET_OK;
-
-error_case1:
- SsbSipMfcDecClose(openHandle);
- return ret;
-}
-
-int read_header_data(void *openHandle)
-{
- struct v4l2_format fmt;
- struct v4l2_crop crop;
- struct v4l2_pix_format_mplane pix_mp;
- int ctrl_value;
- int ret;
-
- _MFCLIB *pCTX;
- pCTX = (_MFCLIB *) openHandle;
-
- ret = v4l2_mfc_g_fmt(pCTX->hMFC, &fmt, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_FMT failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case;
- }
-
- pix_mp = fmt.fmt.pix_mp;
- pCTX->decOutInfo.buf_width = pix_mp.plane_fmt[0].bytesperline;
- pCTX->decOutInfo.buf_height =
- pix_mp.plane_fmt[0].sizeimage / pix_mp.plane_fmt[0].bytesperline;
-
- pCTX->decOutInfo.img_width = pix_mp.width;
- pCTX->decOutInfo.img_height = pix_mp.height;
-
- ret = v4l2_mfc_g_crop(pCTX->hMFC, &crop, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CROP failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case;
- }
-
- pCTX->decOutInfo.crop_left_offset = crop.c.left;
- pCTX->decOutInfo.crop_top_offset = crop.c.top;
- pCTX->decOutInfo.crop_right_offset =
- pix_mp.width - crop.c.width - crop.c.left;
- pCTX->decOutInfo.crop_bottom_offset =
- pix_mp.height - crop.c.height - crop.c.top;
-
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_REQ_NUM_BUFS, &ctrl_value);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case;
- }
-
- pCTX->v4l2_dec.mfc_num_dst_bufs = ctrl_value + pCTX->dec_numextradpb;
-
- LOGV("[%s] Num of allocated buffers: %d\n",__func__, pCTX->v4l2_dec.mfc_num_dst_bufs);
-
- return 0;
-
-error_case:
- return ret;
- }
-
-/* Initialize output stream of MFC */
-int init_mfc_output_stream(void *openHandle)
-{
- struct v4l2_buffer buf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
- int ret;
- int i, j;
- _MFCLIB *pCTX;
- pCTX = (_MFCLIB *) openHandle;
-
- ret = v4l2_mfc_reqbufs(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
- V4L2_MEMORY_MMAP, (int *)&pCTX->v4l2_dec.mfc_num_dst_bufs);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_REQBUFS failed (destination buffers)",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_dst_bufs; ++i) {
- ret = v4l2_mfc_querybuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
- V4L2_MEMORY_MMAP, i, planes);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QUERYBUF failed (destination buffers)",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case1;
- }
-
- pCTX->v4l2_dec.mfc_dst_bufs_len[0] = buf.m.planes[0].length;
- pCTX->v4l2_dec.mfc_dst_bufs_len[1] = buf.m.planes[1].length;
-
- pCTX->v4l2_dec.mfc_dst_phys[i][0] = buf.m.planes[0].cookie;
- pCTX->v4l2_dec.mfc_dst_phys[i][1] = buf.m.planes[1].cookie;
-
-#ifdef USE_ION
- pCTX->dst_ion_fd[i][0] = (int)buf.m.planes[0].share;
- pCTX->dst_ion_fd[i][1] = (int)buf.m.planes[1].share;
-
- pCTX->v4l2_dec.mfc_dst_bufs[i][0] =
- ion_map(pCTX->dst_ion_fd[i][0],pCTX->v4l2_dec.mfc_dst_bufs_len[0],0);
- pCTX->v4l2_dec.mfc_dst_bufs[i][1] =
- ion_map(pCTX->dst_ion_fd[i][1],pCTX->v4l2_dec.mfc_dst_bufs_len[1],0);
- if (pCTX->v4l2_dec.mfc_dst_bufs[i][0] == MAP_FAILED ||
- pCTX->v4l2_dec.mfc_dst_bufs[i][0] == MAP_FAILED)
- goto error_case2;
-#else
- pCTX->v4l2_dec.mfc_dst_bufs[i][0] = mmap(NULL, buf.m.planes[0].length,
- PROT_READ | PROT_WRITE, MAP_SHARED, pCTX->hMFC, buf.m.planes[0].m.mem_offset);
- if (pCTX->v4l2_dec.mfc_dst_bufs[i][0] == MAP_FAILED) {
- LOGE("[%s] mmap failed (destination buffers (Y))",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case2;
- }
-
- pCTX->v4l2_dec.mfc_dst_bufs[i][1] = mmap(NULL, buf.m.planes[1].length,
- PROT_READ | PROT_WRITE, MAP_SHARED, pCTX->hMFC, buf.m.planes[1].m.mem_offset);
- if (pCTX->v4l2_dec.mfc_dst_bufs[i][1] == MAP_FAILED) {
- LOGE("[%s] mmap failed (destination buffers (UV))",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case2;
- }
-#endif
-
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
- V4L2_MEMORY_MMAP, i, planes, 0);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- ret = MFC_RET_DEC_INIT_FAIL;
- goto error_case2;
- }
- }
- pCTX->inter_buff_status |= MFC_USE_YUV_BUFF;
-
- return 0;
-
-error_case2:
- for (j = 0; j < i; j++) {
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[j][0], pCTX->v4l2_dec.mfc_dst_bufs_len[0]);
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[j][1], pCTX->v4l2_dec.mfc_dst_bufs_len[1]);
- }
-error_case1:
- return ret;
-}
-
-int resolution_change(void *openHandle)
-{
- int i, ret;
- int req_count;
- _MFCLIB *pCTX;
- pCTX = (_MFCLIB *) openHandle;
-
- ret = v4l2_mfc_streamoff(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
- if (ret != 0)
- goto error_case;
-
- pCTX->inter_buff_status &= ~(MFC_USE_DST_STREAMON);
-
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_dst_bufs; i++) {
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[i][0], pCTX->v4l2_dec.mfc_dst_bufs_len[0]);
- munmap(pCTX->v4l2_dec.mfc_dst_bufs[i][1], pCTX->v4l2_dec.mfc_dst_bufs_len[1]);
- }
- pCTX->inter_buff_status &= ~(MFC_USE_YUV_BUFF);
-
- req_count = 0;
- ret = v4l2_mfc_reqbufs(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
- V4L2_MEMORY_MMAP, &req_count);
- if (ret != 0)
- goto error_case;
-
- read_header_data(pCTX);
- init_mfc_output_stream(pCTX);
-
- ret = v4l2_mfc_streamon(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
- if (ret != 0)
- goto error_case;
- pCTX->inter_buff_status |= MFC_USE_DST_STREAMON;
-
- return 0;
-
-error_case:
- return ret;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecExe(void *openHandle, int lengthBufFill)
-{
- _MFCLIB *pCTX;
- int ret;
-
- struct v4l2_buffer buf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
- int loop_count, ctrl_value;
-
- int poll_state;
- int poll_revents;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if ((lengthBufFill < 0) || (lengthBufFill > MAX_DECODER_INPUT_BUFFER_SIZE)) {
- LOGE("[%s] lengthBufFill is invalid. (lengthBufFill=%d)",__func__, lengthBufFill);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if ((lengthBufFill > 0) && (SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe)) {
- if (pCTX->displayStatus != MFC_GETOUTBUF_DISPLAY_ONLY) {
- /* Queue the stream frame */
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
- V4L2_MEMORY_MMAP, pCTX->v4l2_dec.beingUsedIndex, planes, lengthBufFill);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_DEC_EXE_ERR;
- }
-
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.m.planes = planes;
- buf.length = 1;
-
- /* wait for decoding */
- do {
- poll_state = v4l2_mfc_poll(pCTX->hMFC, &poll_revents, POLL_DEC_WAIT_TIMEOUT);
- if (poll_state > 0) {
- if (poll_revents & POLLOUT) {
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_MMAP);
- if (ret == 0) {
- if (buf.flags & V4L2_BUF_FLAG_ERROR)
- return MFC_RET_DEC_EXE_ERR;
- pCTX->v4l2_dec.mfc_src_buf_flags[buf.index] = BUF_DEQUEUED;
- break;
- }
- } else if (poll_revents & POLLERR) {
- LOGE("[%s] POLLERR\n",__func__);
- return MFC_RET_DEC_EXE_ERR;
- } else {
- LOGE("[%s] poll() returns 0x%x\n", __func__, poll_revents);
- return MFC_RET_DEC_EXE_ERR;
- }
- } else if (poll_state < 0) {
- return MFC_RET_DEC_EXE_ERR;
- }
-
- if (isBreak_loop(pCTX))
- break;
-
- } while(0 == poll_state);
- }
-
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP);
- if (ret != 0) {
- pCTX->displayStatus = MFC_GETOUTBUF_DECODING_ONLY;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return MFC_RET_OK;
- } else {
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_DISPLAY_STATUS, &ctrl_value);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed", __func__);
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
-
- switch (ctrl_value) {
- case 0:
- pCTX->displayStatus = MFC_GETOUTBUF_DECODING_ONLY;
- break;
- case 1:
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_DECODING;
- break;
- case 2:
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
- break;
- case 3:
- pCTX->displayStatus = MFC_GETOUTBUF_CHANGE_RESOL;
- break;
- }
- }
-
- if (pCTX->displayStatus == MFC_GETOUTBUF_CHANGE_RESOL) {
- resolution_change(pCTX);
- } else {
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][1];
- }
-
- if (SSBSIP_MFC_LAST_FRAME_RECEIVED == pCTX->lastframe)
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_PROCESSED;
-
- } else if (pCTX->v4l2_dec.bBeingFinalized == 0) {
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_PROCESSED;
- pCTX->v4l2_dec.bBeingFinalized = 1; /* true */
-
- /* Queue the stream frame */
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
- V4L2_MEMORY_MMAP, pCTX->v4l2_dec.beingUsedIndex, planes, 0);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_DEC_EXE_ERR;
- }
-
- /* wait for decoding */
- loop_count = 0;
- do {
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP);
- if (ret != 0)
- usleep(1000);
- loop_count++;
- if (loop_count >= 1000) {
- LOGE("[%s] Error in do-while loop",__func__);
- break;
- }
- } while (ret != 0);
-
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_DISPLAY_STATUS, &ctrl_value);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed", __func__);
- return MFC_RET_DEC_EXE_ERR;
- }
- if (ctrl_value == 3) {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_END;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return MFC_RET_OK;
- }
-
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][1];
- } else {
- loop_count = 0;
- do {
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP);
- if (ret != 0)
- usleep(1000);
- loop_count++;
- if (loop_count >= 1000) {
- LOGE("[%s] Error in do-while loop",__func__);
- break;
- }
- } while (ret != 0);
-
- if (buf.m.planes[0].bytesused == 0) {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_END;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return MFC_RET_OK;
- } else {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
- }
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][1];
- }
-
- pCTX->decOutInfo.disp_pic_frame_type = (buf.flags & (0x7 << 3));
-
- switch (pCTX->decOutInfo.disp_pic_frame_type) {
- case V4L2_BUF_FLAG_KEYFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 1;
- break;
- case V4L2_BUF_FLAG_PFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 2;
- break;
- case V4L2_BUF_FLAG_BFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 3;
- break;
- default:
- pCTX->decOutInfo.disp_pic_frame_type = 0;
- break;
- }
-
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP,
- buf.index, planes, 0);
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecExeNb(void *openHandle, int lengthBufFill)
-{
- _MFCLIB *pCTX;
- int ret;
-
- struct v4l2_buffer buf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if ((lengthBufFill < 0) || (lengthBufFill > MAX_DECODER_INPUT_BUFFER_SIZE)) {
- LOGE("[%s] lengthBufFill is invalid. (lengthBufFill=%d)",__func__, lengthBufFill);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if ((lengthBufFill > 0) && (SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe)
- && (pCTX->displayStatus != MFC_GETOUTBUF_DISPLAY_ONLY)) {
- /* Queue the stream frame */
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
- V4L2_MEMORY_MMAP, pCTX->v4l2_dec.beingUsedIndex, planes, lengthBufFill);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_DEC_EXE_ERR;
- }
- } else if (pCTX->v4l2_dec.bBeingFinalized == 0) {
- /* Queue the stream frame */
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
- V4L2_MEMORY_MMAP, pCTX->v4l2_dec.beingUsedIndex, planes, 0);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_DEC_EXE_ERR;
- }
- }
-
- if ((SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe) && (lengthBufFill == 0))
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_RECEIVED;
-
- return MFC_RET_OK;
-}
-
-int isBreak_loop(void *openHandle)
-{
- _MFCLIB *pCTX;
- pCTX = (_MFCLIB *) openHandle;
- int ctrl_value;
- int ret = 0;
-
- if (pCTX->displayStatus == MFC_GETOUTBUF_DISPLAY_ONLY)
- return 1;
-
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_CHECK_STATE, &ctrl_value);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed", __func__);
- return 0;
- }
-
- if (ctrl_value == MFCSTATE_DEC_RES_DETECT) {
- LOGV("[%s] Resolution Change detect",__func__);
- return 1;
- } else if (ctrl_value == MFCSTATE_DEC_TERMINATING) {
- LOGV("[%s] Decoding Finish!!!",__func__);
- return 1;
- }
-
- return 0;
-}
-
-SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecWaitForOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info)
-{
- _MFCLIB *pCTX;
- int ret;
-
- struct v4l2_buffer buf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
- int loop_count, ctrl_value;
-
- int poll_state;
- int poll_revents;
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe) {
- if (pCTX->displayStatus != MFC_GETOUTBUF_DISPLAY_ONLY) {
- /* wait for decoding */
- do {
- poll_state = v4l2_mfc_poll(pCTX->hMFC, &poll_revents, POLL_DEC_WAIT_TIMEOUT);
- if (poll_state > 0) {
- if (poll_revents & POLLOUT) {
- buf.m.planes = planes;
- buf.length = 1;
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_MMAP);
- if (ret == 0) {
- if (buf.flags & V4L2_BUF_FLAG_ERROR)
- return MFC_GETOUTBUF_STATUS_NULL;
- pCTX->v4l2_dec.mfc_src_buf_flags[buf.index] = BUF_DEQUEUED;
- break;
- }
- } else if (poll_revents & POLLERR) {
- LOGE("[%s] POLLERR\n",__func__);
- return MFC_GETOUTBUF_STATUS_NULL;
- } else {
- LOGE("[%s] poll() returns 0x%x\n", __func__, poll_revents);
- return MFC_GETOUTBUF_STATUS_NULL;
- }
- } else if (poll_state < 0) {
- return MFC_GETOUTBUF_STATUS_NULL;
- }
-
- if (isBreak_loop(pCTX))
- break;
-
- } while (0 == poll_state);
- }
-
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP);
- if (ret != 0) {
- pCTX->displayStatus = MFC_GETOUTBUF_DECODING_ONLY;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return SsbSipMfcDecGetOutBuf(pCTX, output_info);;
- } else {
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_DISPLAY_STATUS, &ctrl_value);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed", __func__);
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
-
- switch (ctrl_value) {
- case 0:
- pCTX->displayStatus = MFC_GETOUTBUF_DECODING_ONLY;
- break;
- case 1:
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_DECODING;
- break;
- case 2:
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
- break;
- case 3:
- pCTX->displayStatus = MFC_GETOUTBUF_CHANGE_RESOL;
- break;
- }
- }
-
- if (pCTX->displayStatus == MFC_GETOUTBUF_CHANGE_RESOL) {
- resolution_change(pCTX);
- } else {
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][1];
- }
-
- if (SSBSIP_MFC_LAST_FRAME_RECEIVED == pCTX->lastframe)
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_PROCESSED;
- } else if (pCTX->v4l2_dec.bBeingFinalized == 0) {
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_PROCESSED;
- pCTX->v4l2_dec.bBeingFinalized = 1; /* true */
-
- /* wait for decoding */
- loop_count = 0;
- do {
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP);
- if (ret != 0)
- usleep(1000);
- loop_count++;
- if (loop_count >= 1000) {
- LOGE("[%s] Error in do-while loop",__func__);
- break;
- }
- } while (ret != 0);
-
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_DISPLAY_STATUS, &ctrl_value);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed", __func__);
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
- if (ctrl_value == 3) {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_END;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return SsbSipMfcDecGetOutBuf(pCTX, output_info);;
- }
-
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][1];
- } else {
- loop_count = 0;
- do {
- ret = v4l2_mfc_dqbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP);
- if (ret != 0)
- usleep(1000);
- loop_count++;
- if (loop_count >= 1000) {
- LOGE("[%s] Error in do-while loop",__func__);
- break;
- }
- } while (ret != 0);
-
- if (buf.m.planes[0].bytesused == 0) {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_END;
- pCTX->decOutInfo.disp_pic_frame_type = -1;
- return SsbSipMfcDecGetOutBuf(pCTX, output_info);;
- } else {
- pCTX->displayStatus = MFC_GETOUTBUF_DISPLAY_ONLY;
- }
-
- pCTX->decOutInfo.YVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][0];
- pCTX->decOutInfo.CVirAddr = pCTX->v4l2_dec.mfc_dst_bufs[buf.index][1];
-
- pCTX->decOutInfo.YPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][0];
- pCTX->decOutInfo.CPhyAddr = (unsigned int)pCTX->v4l2_dec.mfc_dst_phys[buf.index][1];
- }
-
- pCTX->decOutInfo.disp_pic_frame_type = (buf.flags & (0x7 << 3));
-
- switch (pCTX->decOutInfo.disp_pic_frame_type) {
- case V4L2_BUF_FLAG_KEYFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 1;
- break;
- case V4L2_BUF_FLAG_PFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 2;
- break;
- case V4L2_BUF_FLAG_BFRAME:
- pCTX->decOutInfo.disp_pic_frame_type = 3;
- break;
- default:
- pCTX->decOutInfo.disp_pic_frame_type = 0;
- break;
- }
-
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP,
- buf.index, planes, 0);
-
- return SsbSipMfcDecGetOutBuf(pCTX, output_info);
-}
-
-void *SsbSipMfcDecGetInBuf(void *openHandle, void **phyInBuf, int inputBufferSize)
-{
- _MFCLIB *pCTX;
- int i;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return NULL;
- }
-
- if ((inputBufferSize < 0) || (inputBufferSize > MAX_DECODER_INPUT_BUFFER_SIZE)) {
- LOGE("[%s] inputBufferSize = %d is invalid",__func__, inputBufferSize);
- return NULL;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- for (i = 0; i < MFC_DEC_NUM_SRC_BUFS; i++)
- if (BUF_DEQUEUED == pCTX->v4l2_dec.mfc_src_buf_flags[i])
- break;
-
- if (i == MFC_DEC_NUM_SRC_BUFS) {
- LOGV("[%s] No buffer is available.",__func__);
- return NULL;
- } else {
- pCTX->virStrmBuf = (unsigned int)pCTX->v4l2_dec.mfc_src_bufs[i];
- pCTX->v4l2_dec.beingUsedIndex = i;
- /* Set the buffer flag as Enqueued for NB_mode_process*/
- /* FIXME: Check this assignment in case of using New API ExeNb() */
- pCTX->v4l2_dec.mfc_src_buf_flags[i] = BUF_ENQUEUED;
- }
-
- return (void *)pCTX->virStrmBuf;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, void *phyInBuf, void *virInBuf, int size)
-{
- _MFCLIB *pCTX;
- int i;
-
- LOGV("[%s] Enter",__func__);
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- for (i = 0; i < MFC_DEC_NUM_SRC_BUFS; i++) {
- if (pCTX->v4l2_dec.mfc_src_bufs[i] == virInBuf)
- break;
- }
-
- if (i == MFC_DEC_NUM_SRC_BUFS) {
- LOGE("[%s] Can not use the buffer",__func__);
- return MFC_RET_INVALID_PARAM;
- } else {
- pCTX->virStrmBuf = (unsigned int)virInBuf;
- pCTX->v4l2_dec.beingUsedIndex = i;
- pCTX->v4l2_dec.mfc_src_buf_flags[i] = BUF_ENQUEUED;
- }
- LOGV("[%s] Exit idx %d",__func__,pCTX->v4l2_dec.beingUsedIndex);
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecGetOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info)
-{
- _MFCLIB *pCTX;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- 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;
-
- output_info->crop_right_offset = pCTX->decOutInfo.crop_right_offset;
- output_info->crop_left_offset = pCTX->decOutInfo.crop_left_offset;
- output_info->crop_bottom_offset = pCTX->decOutInfo.crop_bottom_offset;
- output_info->crop_top_offset = pCTX->decOutInfo.crop_top_offset;
-
- output_info->disp_pic_frame_type = pCTX->decOutInfo.disp_pic_frame_type;
-
- switch (pCTX->displayStatus) {
- case MFC_GETOUTBUF_DISPLAY_ONLY:
- case MFC_GETOUTBUF_DISPLAY_DECODING:
- case MFC_GETOUTBUF_DISPLAY_END:
- case MFC_GETOUTBUF_DECODING_ONLY:
- case MFC_GETOUTBUF_CHANGE_RESOL:
- break;
- default:
- return MFC_GETOUTBUF_DISPLAY_END;
- }
-
- return pCTX->displayStatus;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetConfig(void *openHandle, SSBSIP_MFC_DEC_CONF conf_type, void *value)
-{
- int ret, i;
-
- _MFCLIB *pCTX;
- struct mfc_dec_fimv1_info *fimv1_res;
-
- struct v4l2_buffer buf;
- struct v4l2_plane planes[MFC_DEC_NUM_PLANES];
-
- int id, ctrl_value;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if ((value == NULL) && (MFC_DEC_SETCONF_IS_LAST_FRAME !=conf_type)) {
- LOGE("[%s] value is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- /* First, process non-ioctl calling settings */
- switch (conf_type) {
- case MFC_DEC_SETCONF_EXTRA_BUFFER_NUM:
- pCTX->dec_numextradpb = *((unsigned int *) value);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_FIMV1_WIDTH_HEIGHT: /* be set before calling SsbSipMfcDecInit */
- fimv1_res = (struct mfc_dec_fimv1_info *)value;
- LOGI("fimv1->width = %d\n", fimv1_res->width);
- LOGI("fimv1->height = %d\n", fimv1_res->height);
- pCTX->fimv1_res.width = (int)(fimv1_res->width);
- pCTX->fimv1_res.height = (int)(fimv1_res->height);
- return MFC_RET_OK;
-
- case MFC_DEC_SETCONF_IS_LAST_FRAME:
- if (SSBSIP_MFC_LAST_FRAME_PROCESSED != pCTX->lastframe) {
- pCTX->lastframe = SSBSIP_MFC_LAST_FRAME_RECEIVED;
- return MFC_RET_OK;
- } else {
- return MFC_RET_FAIL;
- }
-
- case MFC_DEC_SETCONF_DPB_FLUSH:
- ret = v4l2_mfc_streamoff(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMOFF failed (destination buffers)",__func__);
- return MFC_RET_DEC_SET_CONF_FAIL;
- }
- pCTX->inter_buff_status &= ~(MFC_USE_DST_STREAMON);
-
- for (i = 0; i < pCTX->v4l2_dec.mfc_num_dst_bufs; ++i) {
- ret = v4l2_mfc_qbuf(pCTX->hMFC, &buf, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
- V4L2_MEMORY_MMAP, i, planes, 0);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- return MFC_RET_DEC_SET_CONF_FAIL;
- }
- }
-
- ret = v4l2_mfc_streamon(pCTX->hMFC, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMON failed (destination buffers)",__func__);
- return MFC_RET_DEC_SET_CONF_FAIL;
- }
- pCTX->inter_buff_status |= MFC_USE_DST_STREAMON;
- return MFC_RET_OK;
- default:
- /* Others will be processed next */
- break;
- }
-
- /* Process ioctl calling settings */
- switch (conf_type) {
- case MFC_DEC_SETCONF_DISPLAY_DELAY: /* be set before calling SsbSipMfcDecInit */
- id = V4L2_CID_CODEC_DISPLAY_DELAY;
- ctrl_value = *((unsigned int *) value);
- break;
-
- case MFC_DEC_SETCONF_CRC_ENABLE:
- id = V4L2_CID_CODEC_CRC_ENABLE;
- ctrl_value = 1;
- break;
-
- case MFC_DEC_SETCONF_SLICE_ENABLE:
- id = V4L2_CID_CODEC_SLICE_INTERFACE;
- ctrl_value = 1;
- break;
-
- case MFC_DEC_SETCONF_FRAME_TAG: /*be set before calling SsbSipMfcDecExe */
- id = V4L2_CID_CODEC_FRAME_TAG;
- ctrl_value = *((unsigned int*)value);
- break;
-
- case MFC_DEC_SETCONF_POST_ENABLE:
- id = V4L2_CID_CODEC_LOOP_FILTER_MPEG4_ENABLE;
- ctrl_value = *((unsigned int*)value);
- break;
-#ifdef S3D_SUPPORT
- case MFC_DEC_SETCONF_SEI_PARSE:
- id = V4L2_CID_CODEC_FRAME_PACK_SEI_PARSE;
- ctrl_value = 1;
- break;
-#endif
- default:
- LOGE("[%s] conf_type(%d) is NOT supported",__func__, conf_type);
- return MFC_RET_INVALID_PARAM;
- }
-
- ret = v4l2_mfc_s_ctrl(pCTX->hMFC, id, ctrl_value);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed (conf_type = %d)",__func__, 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)
-{
- _MFCLIB *pCTX;
-
- SSBSIP_MFC_IMG_RESOLUTION *img_resolution;
- int ret;
- SSBSIP_MFC_CRC_DATA *crc_data;
-#ifdef S3D_SUPPORT
- SSBSIP_MFC_FRAME_PACKING *frame_packing;
- struct mfc_frame_pack_sei_info sei_info;
-#endif
- SSBSIP_MFC_CROP_INFORMATION *crop_information;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("[%s] value is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- switch (conf_type) {
- case MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT:
- img_resolution = (SSBSIP_MFC_IMG_RESOLUTION *)value;
- img_resolution->width = pCTX->decOutInfo.img_width;
- img_resolution->height = pCTX->decOutInfo.img_height;
- img_resolution->buf_width = pCTX->decOutInfo.buf_width;
- img_resolution->buf_height = pCTX->decOutInfo.buf_height;
- break;
-
- case MFC_DEC_GETCONF_FRAME_TAG:
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_FRAME_TAG, (int*)value);
- if (ret != 0)
- LOGE("[%s] VIDIOC_G_CTRL failed, V4L2_CID_CODEC_FRAME_TAG", __func__);
- break;
-
- case MFC_DEC_GETCONF_CRC_DATA:
- crc_data = (SSBSIP_MFC_CRC_DATA *) value;
-
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_CRC_DATA_LUMA, &crc_data->luma0);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed, V4L2_CID_CODEC_CRC_DATA_LUMA",__func__);
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
-
- ret = v4l2_mfc_g_ctrl(pCTX->hMFC, V4L2_CID_CODEC_CRC_DATA_CHROMA, &crc_data->chroma0);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed, V4L2_CID_CODEC_CRC_DATA_CHROMA",__func__);
- return MFC_RET_DEC_GET_CONF_FAIL;
- }
- LOGI("[%s] crc_data->luma0=0x%x\n", __func__, crc_data->luma0);
- LOGI("[%s] crc_data->chroma0=0x%x\n", __func__, crc_data->chroma0);
- break;
-#ifdef S3D_SUPPORT
- case MFC_DEC_GETCONF_FRAME_PACKING:
- frame_packing = (SSBSIP_MFC_FRAME_PACKING *)value;
-
- ret = v4l2_mfc_ext_g_ctrl(pCTX->hMFC, conf_type, &sei_info);
- if (ret != 0) {
- printf("Error to do ext_g_ctrl.\n");
- }
- frame_packing->available = sei_info.sei_avail;
- frame_packing->arrangement_id = sei_info.arrgment_id;
-
- frame_packing->arrangement_cancel_flag = OPERATE_BIT(sei_info.sei_info, 0x1, 0);
- frame_packing->arrangement_type = OPERATE_BIT(sei_info.sei_info, 0x3f, 1);
- frame_packing->quincunx_sampling_flag = OPERATE_BIT(sei_info.sei_info, 0x1, 8);
- frame_packing->content_interpretation_type = OPERATE_BIT(sei_info.sei_info, 0x3f, 9);
- frame_packing->spatial_flipping_flag = OPERATE_BIT(sei_info.sei_info, 0x1, 15);
- frame_packing->frame0_flipped_flag = OPERATE_BIT(sei_info.sei_info, 0x1, 16);
- frame_packing->field_views_flag = OPERATE_BIT(sei_info.sei_info, 0x1, 17);
- frame_packing->current_frame_is_frame0_flag = OPERATE_BIT(sei_info.sei_info, 0x1, 18);
-
- frame_packing->frame0_grid_pos_x = OPERATE_BIT(sei_info.sei_info, 0xf, 0);
- frame_packing->frame0_grid_pos_y = OPERATE_BIT(sei_info.sei_info, 0xf, 4);
- frame_packing->frame1_grid_pos_x = OPERATE_BIT(sei_info.sei_info, 0xf, 8);
- frame_packing->frame1_grid_pos_y = OPERATE_BIT(sei_info.sei_info, 0xf, 12);
- break;
-#endif
- 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;
-
- default:
- LOGE("[%s] conf_type(%d) is NOT supported",__func__, conf_type);
- return MFC_RET_INVALID_PARAM;
- }
-
- return MFC_RET_OK;
-}
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/enc/src/SsbSipMfcEncAPI.c b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/enc/src/SsbSipMfcEncAPI.c
deleted file mode 100644
index 2333b6c..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/enc/src/SsbSipMfcEncAPI.c
+++ /dev/null
@@ -1,1506 +0,0 @@
-/*
- * Copyright (c) 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 <stdio.h>
-#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 <sys/poll.h>
-#include "videodev2.h"
-
-#include "mfc_interface.h"
-#include "SsbSipMfcApi.h"
-
-/* #define LOG_NDEBUG 0 */
-#define LOG_TAG "MFC_ENC_APP"
-#include <utils/Log.h>
-
-#define POLL_ENC_WAIT_TIMEOUT 25
-
-#ifndef true
-#define true (1)
-#endif
-
-#ifndef false
-#define false (0)
-#endif
-
-#define MAX_STREAM_SIZE (2*1024*1024)
-
-static char *mfc_dev_name = SAMSUNG_MFC_DEV_NAME;
-static int mfc_dev_node = 7;
-
-#if defined (MFC5x_VERSION)
-#define H263_CTRL_NUM 19
-#define MPEG4_CTRL_NUM 27
-#define H264_CTRL_NUM 50
-#elif defined (MFC6x_VERSION)
-#define H263_CTRL_NUM 20
-#define MPEG4_CTRL_NUM 28
-#define H264_CTRL_NUM 67
-#endif
-
-
-static void getMFCName(char *devicename, int size)
-{
- snprintf(devicename, size, "%s%d", SAMSUNG_MFC_DEV_NAME, mfc_dev_node);
-}
-
-void SsbSipMfcEncSetMFCName(char *devicename)
-{
- mfc_dev_name = devicename;
-}
-
-void *SsbSipMfcEncOpen(void)
-{
- int hMFCOpen;
- _MFCLIB *pCTX;
-
- char mfc_dev_name[64];
-
- int ret;
- struct v4l2_capability cap;
-
- LOGI("[%s] MFC Library Ver %d.%02d",__func__, MFC_LIB_VER_MAJOR, MFC_LIB_VER_MINOR);
- getMFCName(mfc_dev_name, 64);
- LOGI("[%s] dev name is %s\n",__func__,mfc_dev_name);
-
- if (access(mfc_dev_name, F_OK) != 0) {
- LOGE("[%s] MFC device node not exists",__func__);
- return NULL;
- }
-
- hMFCOpen = open(mfc_dev_name, O_RDWR | O_NONBLOCK, 0);
- if (hMFCOpen < 0) {
- LOGE("[%s] Failed to open MFC device",__func__);
- return NULL;
- }
-
- pCTX = (_MFCLIB *)malloc(sizeof(_MFCLIB));
- if (pCTX == NULL) {
- LOGE("[%s] malloc failed.",__func__);
- return NULL;
- }
- memset(pCTX, 0, sizeof(_MFCLIB));
-
- pCTX->hMFC = hMFCOpen;
-
- memset(&cap, 0, sizeof(cap));
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYCAP, &cap);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QUERYCAP failed",__func__);
- close(pCTX->hMFC);
- free(pCTX);
- return NULL;
- }
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
- LOGE("[%s] Device does not support capture",__func__);
- close(pCTX->hMFC);
- free(pCTX);
- return NULL;
- }
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
- LOGE("[%s] Device does not support output",__func__);
- close(pCTX->hMFC);
- free(pCTX);
- return NULL;
- }
-
- if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
- LOGE("[%s] Device does not support streaming",__func__);
- close(pCTX->hMFC);
- free(pCTX);
- return NULL;
- }
-
- pCTX->v4l2_enc.bRunning = 0;
- /* physical address is used for Input source */
- pCTX->v4l2_enc.bInputPhyVir = 1;
-
- pCTX->cacheablebuffer = NO_CACHE;
-
- return (void *)pCTX;
-}
-
-void *SsbSipMfcEncOpenExt(void *value)
-{
- _MFCLIB *pCTX;
-
- pCTX = SsbSipMfcEncOpen();
- if (pCTX == NULL)
- return NULL;
-
- if (NO_CACHE == (*(SSBIP_MFC_BUFFER_TYPE *)value)) {
- pCTX->cacheablebuffer = NO_CACHE;
- /* physical address is used for Input source */
- pCTX->v4l2_enc.bInputPhyVir = 1;
- LOGI("[%s] non cacheable buffer",__func__);
- }
- else {
- pCTX->cacheablebuffer = CACHE;
- /* vitual address is used for Input source */
- pCTX->v4l2_enc.bInputPhyVir = 0;
- LOGI("[%s] cacheable buffer",__func__);
- }
-
- return (void *)pCTX;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncClose(void *openHandle)
-{
- _MFCLIB *pCTX;
- int ret, i;
-
- enum v4l2_buf_type type;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (pCTX->inter_buff_status & MFC_USE_DST_STREAMON) {
- type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMOFF, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMOFF failed (destination buffers)",__func__);
- return MFC_RET_CLOSE_FAIL;
- }
- pCTX->inter_buff_status &= ~(MFC_USE_DST_STREAMON);
- }
-
- if (pCTX->inter_buff_status & MFC_USE_SRC_STREAMON) {
- type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMOFF, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMOFF failed (source buffers)",__func__);
- return MFC_RET_CLOSE_FAIL;
- }
- pCTX->inter_buff_status &= ~(MFC_USE_SRC_STREAMON);
- }
-
- if (!pCTX->v4l2_enc.bInputPhyVir) {
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; i++) {
- munmap(pCTX->v4l2_enc.mfc_src_bufs[i][0], pCTX->v4l2_enc.mfc_src_bufs_len[0]);
- munmap(pCTX->v4l2_enc.mfc_src_bufs[i][1], pCTX->v4l2_enc.mfc_src_bufs_len[1]);
- }
- }
-
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_dst_bufs; i++)
- munmap(pCTX->v4l2_enc.mfc_dst_bufs[i], pCTX->v4l2_enc.mfc_dst_bufs_len);
-
- pCTX->inter_buff_status = MFC_USE_NONE;
-
- close(pCTX->hMFC);
-
- free(pCTX);
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncInit(void *openHandle, void *param)
-{
- int ret, i, j,index;
- _MFCLIB *pCTX;
-
- enum v4l2_buf_type type;
- struct v4l2_format fmt;
- struct v4l2_plane planes[MFC_ENC_NUM_PLANES];
-
- struct v4l2_buffer buf;
- struct v4l2_requestbuffers reqbuf;
-
- struct v4l2_control ctrl;
-
- struct pollfd poll_events;
- int poll_state;
-
- struct v4l2_ext_control ext_ctrl_mpeg4[MPEG4_CTRL_NUM];
- struct v4l2_ext_control ext_ctrl_h263[H263_CTRL_NUM];
- struct v4l2_ext_control ext_ctrl[H264_CTRL_NUM];
- struct v4l2_ext_controls ext_ctrls;
-
- SSBSIP_MFC_ENC_H264_PARAM *h264_arg;
- SSBSIP_MFC_ENC_MPEG4_PARAM *mpeg4_arg;
- SSBSIP_MFC_ENC_H263_PARAM *h263_arg;
-
- if (openHandle == NULL)
- return MFC_RET_INVALID_PARAM;
-
- pCTX = (_MFCLIB *) openHandle;
-
- mpeg4_arg = (SSBSIP_MFC_ENC_MPEG4_PARAM*)param;
- if (mpeg4_arg->codecType == MPEG4_ENC) {
- pCTX->codecType= MPEG4_ENC;
- pCTX->width = mpeg4_arg->SourceWidth;
- pCTX->height = mpeg4_arg->SourceHeight;
- pCTX->framemap = mpeg4_arg->FrameMap;
- } else {
- h263_arg = (SSBSIP_MFC_ENC_H263_PARAM*)param;
- if (h263_arg->codecType == H263_ENC) {
- pCTX->codecType = H263_ENC;
- pCTX->width = h263_arg->SourceWidth;
- pCTX->height = h263_arg->SourceHeight;
- pCTX->framemap = h263_arg->FrameMap;
- } else {
- h264_arg = (SSBSIP_MFC_ENC_H264_PARAM*)param;
- if (h264_arg->codecType == H264_ENC) {
- pCTX->codecType = H264_ENC;
- pCTX->width = h264_arg->SourceWidth;
- pCTX->height = h264_arg->SourceHeight;
- pCTX->framemap = h264_arg->FrameMap;
- } else {
- LOGE("[%s] Undefined codec type \n",__func__);
- ret = MFC_RET_INVALID_PARAM;
- goto error_case1;
- }
- }
- }
-
- switch (pCTX->codecType) {
- case MPEG4_ENC:
- ext_ctrl_mpeg4[0].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_PROFILE;
- ext_ctrl_mpeg4[0].value = mpeg4_arg->ProfileIDC;
- ext_ctrl_mpeg4[1].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_LEVEL;
- ext_ctrl_mpeg4[1].value = mpeg4_arg->LevelIDC;
- ext_ctrl_mpeg4[2].id = V4L2_CID_CODEC_MFC5X_ENC_GOP_SIZE;
- ext_ctrl_mpeg4[2].value = mpeg4_arg->IDRPeriod;
- ext_ctrl_mpeg4[3].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_QUARTER_PIXEL;
- ext_ctrl_mpeg4[3].value = mpeg4_arg->DisableQpelME;
-
- ext_ctrl_mpeg4[4].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MODE;
- ext_ctrl_mpeg4[4].value = mpeg4_arg->SliceMode; /* 0: one, 1: fixed #mb, 3: fixed #bytes */
- if (mpeg4_arg->SliceMode == 0) {
- ext_ctrl_mpeg4[5].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl_mpeg4[5].value = 1; /* default */
-#if defined (MFC5x_VERSION)
- ext_ctrl_mpeg4[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl_mpeg4[6].value = 1900; /* default */
-#elif defined (MFC6x_VERSION)
- ext_ctrl_mpeg4[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl_mpeg4[6].value = 2800; /* based on MFC6.x */
-#endif
- } else if (mpeg4_arg->SliceMode == 1) {
- ext_ctrl_mpeg4[5].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl_mpeg4[5].value = mpeg4_arg->SliceArgument;
-#if defined (MFC5x_VERSION)
- ext_ctrl_mpeg4[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl_mpeg4[6].value = 1900; /* default */
-#elif defined (MFC6x_VERSION)
- ext_ctrl_mpeg4[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl_mpeg4[6].value = 2800; /* based on MFC6.x */
-#endif
- } else if (mpeg4_arg->SliceMode == 3) {
- ext_ctrl_mpeg4[5].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl_mpeg4[5].value = 1; /* default */
- ext_ctrl_mpeg4[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl_mpeg4[6].value = mpeg4_arg->SliceArgument;
- }
- /*
- * It should be set using mpeg4_arg->NumberBFrames after being handled by appl.
- */
- ext_ctrl_mpeg4[7].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_B_FRAMES;
- ext_ctrl_mpeg4[7].value = mpeg4_arg->NumberBFrames;
- ext_ctrl_mpeg4[8].id = V4L2_CID_CODEC_MFC5X_ENC_INTRA_REFRESH_MB;
- ext_ctrl_mpeg4[8].value = mpeg4_arg->RandomIntraMBRefresh;
-
- ext_ctrl_mpeg4[9].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CTRL_ENABLE;
- ext_ctrl_mpeg4[9].value = mpeg4_arg->PadControlOn;
- ext_ctrl_mpeg4[10].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_LUMA_VALUE;
- ext_ctrl_mpeg4[10].value = mpeg4_arg->LumaPadVal;
- ext_ctrl_mpeg4[11].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CB_VALUE;
- ext_ctrl_mpeg4[11].value = mpeg4_arg->CbPadVal;
- ext_ctrl_mpeg4[12].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CR_VALUE;
- ext_ctrl_mpeg4[12].value = mpeg4_arg->CrPadVal;
-
- ext_ctrl_mpeg4[13].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FRAME_ENABLE;
- ext_ctrl_mpeg4[13].value = mpeg4_arg->EnableFRMRateControl;
- ext_ctrl_mpeg4[14].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_VOP_TIME_RES;
- ext_ctrl_mpeg4[14].value = mpeg4_arg->TimeIncreamentRes;
- ext_ctrl_mpeg4[15].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_VOP_FRM_DELTA;
- ext_ctrl_mpeg4[15].value = mpeg4_arg->VopTimeIncreament;
- ext_ctrl_mpeg4[16].id = V4L2_CID_CODEC_MFC5X_ENC_RC_BIT_RATE;
- ext_ctrl_mpeg4[16].value = mpeg4_arg->Bitrate;
-
- ext_ctrl_mpeg4[17].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_FRAME_QP;
- ext_ctrl_mpeg4[17].value = mpeg4_arg->FrameQp;
- ext_ctrl_mpeg4[18].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_P_FRAME_QP;
- ext_ctrl_mpeg4[18].value = mpeg4_arg->FrameQp_P;
- ext_ctrl_mpeg4[19].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_B_FRAME_QP;
- ext_ctrl_mpeg4[19].value = mpeg4_arg->FrameQp_B;
-
- ext_ctrl_mpeg4[20].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_MAX_QP;
- ext_ctrl_mpeg4[20].value = mpeg4_arg->QSCodeMax;
- ext_ctrl_mpeg4[21].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_MIN_QP;
- ext_ctrl_mpeg4[21].value = mpeg4_arg->QSCodeMin;
- ext_ctrl_mpeg4[22].id = V4L2_CID_CODEC_MFC5X_ENC_RC_REACTION_COEFF;
- ext_ctrl_mpeg4[22].value = mpeg4_arg->CBRPeriodRf;
-
- if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL == pCTX->enc_frameskip) {
- ext_ctrl_mpeg4[23].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_mpeg4[23].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL;
- } else if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE == pCTX->enc_frameskip) {
- ext_ctrl_mpeg4[23].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_mpeg4[23].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE;
- } else { /* ENC_FRAME_SKIP_MODE_DISABLE (default) */
- ext_ctrl_mpeg4[23].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_mpeg4[23].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_DISABLE;
- }
-
- ext_ctrl_mpeg4[24].id = V4L2_CID_CODEC_MFC5X_ENC_VBV_BUF_SIZE;
- ext_ctrl_mpeg4[24].value = 0;
-
- ext_ctrl_mpeg4[25].id = V4L2_CID_CODEC_MFC5X_ENC_SEQ_HDR_MODE;
- ext_ctrl_mpeg4[25].value = 0;
-
- ext_ctrl_mpeg4[26].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FIXED_TARGET_BIT;
- ext_ctrl_mpeg4[26].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
-
-#if defined (MFC6x_VERSION)
- ext_ctrl_mpeg4[27].id = V4L2_CID_CODEC_MFC5X_ENC_MPEG4_RC_MB_ENABLE; /* MFC 6.x Only */
- ext_ctrl_mpeg4[27].value = mpeg4_arg->EnableMBRateControl;
-#endif
- break;
-
- case H263_ENC:
- ext_ctrl_h263[0].id = V4L2_CID_CODEC_MFC5X_ENC_GOP_SIZE;
- ext_ctrl_h263[0].value = h263_arg->IDRPeriod;
-
- ext_ctrl_h263[1].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MODE;
- ext_ctrl_h263[1].value = h263_arg->SliceMode; /* 0: one, Check is needed if h264 support multi-slice */
-
- ext_ctrl_h263[2].id = V4L2_CID_CODEC_MFC5X_ENC_INTRA_REFRESH_MB;
- ext_ctrl_h263[2].value = h263_arg->RandomIntraMBRefresh;
-
- ext_ctrl_h263[3].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CTRL_ENABLE;
- ext_ctrl_h263[3].value = h263_arg->PadControlOn;
- ext_ctrl_h263[4].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_LUMA_VALUE;
- ext_ctrl_h263[4].value = h263_arg->LumaPadVal;
- ext_ctrl_h263[5].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CB_VALUE;
- ext_ctrl_h263[5].value = h263_arg->CbPadVal;
- ext_ctrl_h263[6].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CR_VALUE;
- ext_ctrl_h263[6].value = h263_arg->CrPadVal;
-
- ext_ctrl_h263[7].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FRAME_ENABLE;
- ext_ctrl_h263[7].value = h263_arg->EnableFRMRateControl;
-
- ext_ctrl_h263[8].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_FRAME_RATE;
- ext_ctrl_h263[8].value = h263_arg->FrameRate;
-
- ext_ctrl_h263[9].id = V4L2_CID_CODEC_MFC5X_ENC_RC_BIT_RATE;
- ext_ctrl_h263[9].value = h263_arg->Bitrate;
-
- ext_ctrl_h263[10].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_FRAME_QP;
- ext_ctrl_h263[10].value = h263_arg->FrameQp;
- ext_ctrl_h263[11].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_P_FRAME_QP;
- ext_ctrl_h263[11].value = h263_arg->FrameQp_P;
-
- ext_ctrl_h263[12].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_MAX_QP;
- ext_ctrl_h263[12].value = h263_arg->QSCodeMax;
- ext_ctrl_h263[13].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_MIN_QP;
- ext_ctrl_h263[13].value = h263_arg->QSCodeMin;
- ext_ctrl_h263[14].id = V4L2_CID_CODEC_MFC5X_ENC_RC_REACTION_COEFF;
- ext_ctrl_h263[14].value = h263_arg->CBRPeriodRf;
-
- if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL == pCTX->enc_frameskip) {
- ext_ctrl_h263[15].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_h263[15].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL;
- } else if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE == pCTX->enc_frameskip) {
- ext_ctrl_h263[15].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_h263[15].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE;
- } else { /* ENC_FRAME_SKIP_MODE_DISABLE (default) */
- ext_ctrl_h263[15].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl_h263[15].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_DISABLE;
- }
-
- ext_ctrl_h263[16].id = V4L2_CID_CODEC_MFC5X_ENC_VBV_BUF_SIZE;
- ext_ctrl_h263[16].value = 0;
-
- ext_ctrl_h263[17].id = V4L2_CID_CODEC_MFC5X_ENC_SEQ_HDR_MODE;
- ext_ctrl_h263[17].value = 0;
-
- ext_ctrl_h263[18].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FIXED_TARGET_BIT;
- ext_ctrl_h263[18].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
-
-#if defined (MFC6x_VERSION)
- ext_ctrl_h263[19].id = V4L2_CID_CODEC_MFC5X_ENC_H263_RC_MB_ENABLE; /* MFC 6.x Only */
- ext_ctrl_h263[19].value = h263_arg->EnableMBRateControl;
-#endif
- break;
-
- case H264_ENC:
- ext_ctrl[0].id = V4L2_CID_CODEC_MFC5X_ENC_H264_PROFILE;
- ext_ctrl[0].value = h264_arg->ProfileIDC;
- ext_ctrl[1].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LEVEL;
- ext_ctrl[1].value = h264_arg->LevelIDC;
- ext_ctrl[2].id = V4L2_CID_CODEC_MFC5X_ENC_GOP_SIZE;
- ext_ctrl[2].value = h264_arg->IDRPeriod;
- ext_ctrl[3].id = V4L2_CID_CODEC_MFC5X_ENC_H264_MAX_REF_PIC;
- ext_ctrl[3].value = h264_arg->NumberReferenceFrames;
- ext_ctrl[4].id = V4L2_CID_CODEC_MFC5X_ENC_H264_NUM_REF_PIC_4P;
- ext_ctrl[4].value = h264_arg->NumberRefForPframes;
- ext_ctrl[5].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MODE;
- ext_ctrl[5].value = h264_arg->SliceMode; /* 0: one, 1: fixed #mb, 3: fixed #bytes */
- if (h264_arg->SliceMode == 0) {
- ext_ctrl[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl[6].value = 1; /* default */
-#if defined (MFC5x_VERSION)
- ext_ctrl[7].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl[7].value = 1900; /* default */
-#elif defined (MFC6x_VERSION)
- ext_ctrl[7].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl[7].value = 2800; /* based on MFC6.x */
-#endif
- } else if (h264_arg->SliceMode == 1) {
- ext_ctrl[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl[6].value = h264_arg->SliceArgument;
-#if defined (MFC5x_VERSION)
- ext_ctrl[7].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl[7].value = 1900; /* default */
-#elif defined (MFC6x_VERSION)
- ext_ctrl[7].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl[7].value = 2800; /* based on MFC6.x */
-#endif
- } else if (h264_arg->SliceMode == 3) {
- ext_ctrl[6].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_MB;
- ext_ctrl[6].value = 1; /* default */
- ext_ctrl[7].id = V4L2_CID_CODEC_MFC5X_ENC_MULTI_SLICE_BIT;
- ext_ctrl[7].value = h264_arg->SliceArgument;
- }
- /*
- * It should be set using h264_arg->NumberBFrames after being handled by appl.
- */
- ext_ctrl[8].id = V4L2_CID_CODEC_MFC5X_ENC_H264_B_FRAMES;
- ext_ctrl[8].value = h264_arg->NumberBFrames;
- ext_ctrl[9].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LOOP_FILTER_MODE;
- ext_ctrl[9].value = h264_arg->LoopFilterDisable;
- ext_ctrl[10].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LOOP_FILTER_ALPHA;
- ext_ctrl[10].value = h264_arg->LoopFilterAlphaC0Offset;
- ext_ctrl[11].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LOOP_FILTER_BETA;
- ext_ctrl[11].value = h264_arg->LoopFilterBetaOffset;
- ext_ctrl[12].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ENTROPY_MODE;
- ext_ctrl[12].value = h264_arg->SymbolMode;
- ext_ctrl[13].id = V4L2_CID_CODEC_MFC5X_ENC_H264_INTERLACE;
- ext_ctrl[13].value = h264_arg->PictureInterlace;
- ext_ctrl[14].id = V4L2_CID_CODEC_MFC5X_ENC_H264_8X8_TRANSFORM;
- ext_ctrl[14].value = h264_arg->Transform8x8Mode;
- ext_ctrl[15].id = V4L2_CID_CODEC_MFC5X_ENC_INTRA_REFRESH_MB;
- ext_ctrl[15].value = h264_arg->RandomIntraMBRefresh;
- ext_ctrl[16].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CTRL_ENABLE;
- ext_ctrl[16].value = h264_arg->PadControlOn;
- ext_ctrl[17].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_LUMA_VALUE;
- ext_ctrl[17].value = h264_arg->LumaPadVal;
- ext_ctrl[18].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CB_VALUE;
- ext_ctrl[18].value = h264_arg->CbPadVal;
- ext_ctrl[19].id = V4L2_CID_CODEC_MFC5X_ENC_PAD_CR_VALUE;
- ext_ctrl[19].value = h264_arg->CrPadVal;
- ext_ctrl[20].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FRAME_ENABLE;
- ext_ctrl[20].value = h264_arg->EnableFRMRateControl;
- ext_ctrl[21].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_ENABLE;
- ext_ctrl[21].value = h264_arg->EnableMBRateControl;
- ext_ctrl[22].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_FRAME_RATE;
- ext_ctrl[22].value = h264_arg->FrameRate;
- ext_ctrl[23].id = V4L2_CID_CODEC_MFC5X_ENC_RC_BIT_RATE;
- /* FIXME temporary fix */
- if (h264_arg->Bitrate)
- ext_ctrl[23].value = h264_arg->Bitrate;
- else
- ext_ctrl[23].value = 1; /* just for testing Movi studio */
- ext_ctrl[24].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_FRAME_QP;
- ext_ctrl[24].value = h264_arg->FrameQp;
- ext_ctrl[25].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_P_FRAME_QP;
- ext_ctrl[25].value = h264_arg->FrameQp_P;
- ext_ctrl[26].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_B_FRAME_QP;
- ext_ctrl[26].value = h264_arg->FrameQp_B;
- ext_ctrl[27].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MAX_QP;
- ext_ctrl[27].value = h264_arg->QSCodeMax;
- ext_ctrl[28].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MIN_QP;
- ext_ctrl[28].value = h264_arg->QSCodeMin;
- ext_ctrl[29].id = V4L2_CID_CODEC_MFC5X_ENC_RC_REACTION_COEFF;
- ext_ctrl[29].value = h264_arg->CBRPeriodRf;
- ext_ctrl[30].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_DARK;
- ext_ctrl[30].value = h264_arg->DarkDisable;
- ext_ctrl[31].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_SMOOTH;
- ext_ctrl[31].value = h264_arg->SmoothDisable;
- ext_ctrl[32].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_STATIC;
- ext_ctrl[32].value = h264_arg->StaticDisable;
- ext_ctrl[33].id = V4L2_CID_CODEC_MFC5X_ENC_H264_RC_MB_ACTIVITY;
- ext_ctrl[33].value = h264_arg->ActivityDisable;
-
- /* doesn't have to be set */
- ext_ctrl[34].id = V4L2_CID_CODEC_MFC5X_ENC_H264_OPEN_GOP;
- ext_ctrl[34].value = V4L2_CODEC_MFC5X_ENC_SW_DISABLE;
- ext_ctrl[35].id = V4L2_CID_CODEC_MFC5X_ENC_H264_I_PERIOD;
- ext_ctrl[35].value = 10;
-
- if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL == pCTX->enc_frameskip) {
- ext_ctrl[36].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl[36].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_LEVEL;
- } else if (V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE == pCTX->enc_frameskip) {
- ext_ctrl[36].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl[36].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_VBV_BUF_SIZE;
- } else { /* ENC_FRAME_SKIP_MODE_DISABLE (default) */
- ext_ctrl[36].id = V4L2_CID_CODEC_MFC5X_ENC_FRAME_SKIP_MODE;
- ext_ctrl[36].value = V4L2_CODEC_MFC5X_ENC_FRAME_SKIP_MODE_DISABLE;
- }
-
- ext_ctrl[37].id = V4L2_CID_CODEC_MFC5X_ENC_VBV_BUF_SIZE;
- ext_ctrl[37].value = 0;
-
- ext_ctrl[38].id = V4L2_CID_CODEC_MFC5X_ENC_SEQ_HDR_MODE;
- ext_ctrl[38].value = 0; /* 0: seperated header, 1: header + first frame */
-
- ext_ctrl[39].id = V4L2_CID_CODEC_MFC5X_ENC_H264_AR_VUI_ENABLE;
- ext_ctrl[39].value = V4L2_CODEC_MFC5X_ENC_SW_DISABLE;
- ext_ctrl[40].id = V4L2_CID_CODEC_MFC5X_ENC_H264_AR_VUI_IDC;
- ext_ctrl[40].value = 0;
- ext_ctrl[41].id = V4L2_CID_CODEC_MFC5X_ENC_H264_EXT_SAR_WIDTH;
- ext_ctrl[41].value = 0;
- ext_ctrl[42].id = V4L2_CID_CODEC_MFC5X_ENC_H264_EXT_SAR_HEIGHT;
- ext_ctrl[42].value = 0;
-
- if (pCTX->hier_p_enable) {
- ext_ctrl[43].id = V4L2_CID_CODEC_MFC5X_ENC_H264_HIER_P_ENABLE;
- ext_ctrl[43].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
- ext_ctrl[44].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LAYER0_QP;
- ext_ctrl[44].value = pCTX->hier_qp_value.t0_frame_qp;
- ext_ctrl[45].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LAYER1_QP;
- ext_ctrl[45].value = pCTX->hier_qp_value.t2_frame_qp;
- ext_ctrl[46].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LAYER2_QP;
- ext_ctrl[46].value = pCTX->hier_qp_value.t3_frame_qp;
- } else {
- ext_ctrl[43].id = V4L2_CID_CODEC_MFC5X_ENC_H264_HIER_P_ENABLE;
- ext_ctrl[43].value = V4L2_CODEC_MFC5X_ENC_SW_DISABLE;
- ext_ctrl[44].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LAYER0_QP;
- ext_ctrl[44].value = 0;
- ext_ctrl[45].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LAYER1_QP;
- ext_ctrl[45].value = 0;
- ext_ctrl[46].id = V4L2_CID_CODEC_MFC5X_ENC_H264_LAYER2_QP;
- ext_ctrl[46].value = 0;
- }
-#ifdef S3D_SUPPORT
- if (pCTX->sei_info.sei_gen_enable) {
- ext_ctrl[47].id = V4L2_CID_CODEC_FRAME_PACK_FRM0_FLAG;
- ext_ctrl[47].value = pCTX->sei_info.curr_frame_frm0_flag;
- ext_ctrl[48].id = V4L2_CID_CODEC_FRAME_PACK_ARRGMENT_TYPE;
- ext_ctrl[48].value = pCTX->sei_info.frame_pack_arrgment_type;
- } else {
- ext_ctrl[47].id = V4L2_CID_CODEC_FRAME_PACK_FRM0_FLAG;
- ext_ctrl[47].value = 0;
- ext_ctrl[48].id = V4L2_CID_CODEC_FRAME_PACK_ARRGMENT_TYPE;
- ext_ctrl[48].value = 3;
- }
-#else
- ext_ctrl[47].id = V4L2_CID_CODEC_FRAME_PACK_FRM0_FLAG;
- ext_ctrl[47].value = 0;
- ext_ctrl[48].id = V4L2_CID_CODEC_FRAME_PACK_ARRGMENT_TYPE;
- ext_ctrl[48].value = 3;
-#endif
-#if defined (MFC5x_VERSION)
- ext_ctrl[49].id = V4L2_CID_CODEC_MFC5X_ENC_RC_FIXED_TARGET_BIT; /* MFC5.x Only */
- ext_ctrl[49].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
-#elif defined (MFC6x_VERSION)
- if (pCTX->fmo_enable) {
- ext_ctrl[49].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_ENABLE;
- ext_ctrl[49].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
- ext_ctrl[50].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_MAP_TYPE;
- ext_ctrl[50].value = pCTX->fmo_value.slice_map_type;
- ext_ctrl[51].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_SLICE_NUM;
- ext_ctrl[51].value = pCTX->fmo_value.slice_num_grp;
- if (pCTX->fmo_value.slice_map_type == 0) {
- ext_ctrl[52].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN1;
- ext_ctrl[53].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN2;
- ext_ctrl[54].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN3;
- ext_ctrl[55].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN4;
- for (i = 0; i < pCTX->fmo_value.slice_num_grp; i++)
- ext_ctrl[52+i].value = pCTX->fmo_value.run_length[i];
- for (i = pCTX->fmo_value.slice_num_grp; i < 4; i++);
- ext_ctrl[52+i].value = 1;
- } else {
- ext_ctrl[52].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN1;
- ext_ctrl[52].value = 1;
- ext_ctrl[53].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN2;
- ext_ctrl[53].value = 1;
- ext_ctrl[54].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN3;
- ext_ctrl[54].value = 1;
- ext_ctrl[55].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN4;
- ext_ctrl[55].value = 1;
- }
- if (pCTX->fmo_value.slice_map_type == 4 || pCTX->fmo_value.slice_map_type == 5) {
- ext_ctrl[56].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_SG_DIR;
- ext_ctrl[56].value = pCTX->fmo_value.sg_dir;
- ext_ctrl[57].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_SG_RATE;
- ext_ctrl[57].value = pCTX->fmo_value.sg_rate;
- } else {
- ext_ctrl[56].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_SG_DIR;
- ext_ctrl[56].value = 0;
- ext_ctrl[57].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_SG_RATE;
- ext_ctrl[57].value = 1;
- }
- } else {
- ext_ctrl[49].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_ENABLE;
- ext_ctrl[49].value = V4L2_CODEC_MFC5X_ENC_SW_DISABLE;
- ext_ctrl[50].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_MAP_TYPE;
- ext_ctrl[50].value = 0;
- ext_ctrl[51].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_SLICE_NUM;
- ext_ctrl[51].value = 1;
- ext_ctrl[52].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN1;
- ext_ctrl[52].value = 1;
- ext_ctrl[53].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN2;
- ext_ctrl[53].value = 1;
- ext_ctrl[54].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN3;
- ext_ctrl[54].value = 1;
- ext_ctrl[55].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_RUN_LEN4;
- ext_ctrl[55].value = 1;
- ext_ctrl[56].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_SG_DIR;
- ext_ctrl[56].value = 0;
- ext_ctrl[57].id = V4L2_CID_CODEC_MFC5X_ENC_H264_FMO_SG_RATE;
- ext_ctrl[57].value = 1;
- }
- if (pCTX->aso_enable) {
- ext_ctrl[58].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_ENABLE;
- ext_ctrl[58].value = V4L2_CODEC_MFC5X_ENC_SW_ENABLE;
- ext_ctrl[59].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_0;
- ext_ctrl[59].value = pCTX->aso_sl_order[0];
- ext_ctrl[60].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_1;
- ext_ctrl[60].value = pCTX->aso_sl_order[1];
- ext_ctrl[61].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_2;
- ext_ctrl[61].value = pCTX->aso_sl_order[2];
- ext_ctrl[62].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_3;
- ext_ctrl[62].value = pCTX->aso_sl_order[3];
- ext_ctrl[63].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_4;
- ext_ctrl[63].value = pCTX->aso_sl_order[4];
- ext_ctrl[64].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_5;
- ext_ctrl[64].value = pCTX->aso_sl_order[5];
- ext_ctrl[65].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_6;
- ext_ctrl[65].value = pCTX->aso_sl_order[6];
- ext_ctrl[66].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_7;
- ext_ctrl[66].value = pCTX->aso_sl_order[7];
- } else {
- ext_ctrl[58].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_ENABLE;
- ext_ctrl[58].value = V4L2_CODEC_MFC5X_ENC_SW_DISABLE;
- ext_ctrl[59].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_0;
- ext_ctrl[59].value = 0;
- ext_ctrl[60].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_1;
- ext_ctrl[60].value = 0;
- ext_ctrl[61].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_2;
- ext_ctrl[61].value = 0;
- ext_ctrl[62].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_3;
- ext_ctrl[62].value = 0;
- ext_ctrl[63].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_4;
- ext_ctrl[63].value = 0;
- ext_ctrl[64].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_5;
- ext_ctrl[64].value = 0;
- ext_ctrl[65].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_6;
- ext_ctrl[65].value = 0;
- ext_ctrl[66].id = V4L2_CID_CODEC_MFC5X_ENC_H264_ASO_SL_ORDER_7;
- ext_ctrl[66].value = 0;
- }
-#endif
- break;
-
- default:
- LOGE("[%s] Undefined codec type",__func__);
- ret = MFC_RET_INVALID_PARAM;
- goto error_case1;
- }
-
- ext_ctrls.ctrl_class = V4L2_CTRL_CLASS_CODEC;
- if (pCTX->codecType == MPEG4_ENC) {
- ext_ctrls.count = MPEG4_CTRL_NUM;
- ext_ctrls.controls = ext_ctrl_mpeg4;
- } else if (pCTX->codecType == H264_ENC) {
- ext_ctrls.count = H264_CTRL_NUM;
- ext_ctrls.controls = ext_ctrl;
- } else if (pCTX->codecType == H263_ENC) {
- ext_ctrls.count = H263_CTRL_NUM;
- ext_ctrls.controls = ext_ctrl_h263;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_EXT_CTRLS, &ext_ctrls);
- if (ret != 0) {
- LOGE("[%s] Failed to set extended controls",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
-
- memset(&fmt, 0, sizeof(fmt));
- fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-
- fmt.fmt.pix_mp.width = pCTX->width;
- fmt.fmt.pix_mp.height = pCTX->height;
- fmt.fmt.pix_mp.num_planes = 2;
-#if 0
- fmt.fmt.pix_mp.plane_fmt[0].bytesperline = Align(fmt.fmt.pix_mp.width, 128);
- fmt.fmt.pix_mp.plane_fmt[1].bytesperline = Align(fmt.fmt.pix_mp.width, 128);
-
- if (NV12_TILE == pCTX->framemap) {
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12MT; /* 4:2:0, 2 Planes, 64x32 Tiles */
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage =
- Align(Align(fmt.fmt.pix_mp.width, 128) * Align(fmt.fmt.pix_mp.height, 32), 8192); /* tiled mode */
- fmt.fmt.pix_mp.plane_fmt[1].sizeimage =
- Align(Align(fmt.fmt.pix_mp.width, 128) * Align(fmt.fmt.pix_mp.height >> 1, 32), 8192); /* tiled mode */
- } else { /* NV12_LINEAR (default) */
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M; /* 4:2:0, 2 Planes, linear */
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage =
- Align((fmt.fmt.pix_mp.width * fmt.fmt.pix_mp.height), 2048); /* linear mode, 2K align */
- fmt.fmt.pix_mp.plane_fmt[1].sizeimage =
- Align((fmt.fmt.pix_mp.width * (fmt.fmt.pix_mp.height >> 1)), 2048); /* linear mode, 2K align */
- }
-#else /* FIXME: */
- if (NV12_TILE == pCTX->framemap) {
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12MT_16X16; /* 4:2:0, 2 Planes, 16x16 Tiles */
- } else { /* NV12_LINEAR (default) */
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M; /* 4:2:0, 2 Planes, linear */
- }
-#endif
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_FMT, &fmt);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed on MFC output stream",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
-
- /* capture (dst) */
- memset(&fmt, 0, sizeof(fmt));
-
- switch (pCTX->codecType) {
- case H264_ENC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
- break;
- case MPEG4_ENC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_MPEG4;
- break;
- case H263_ENC:
- fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H263;
- break;
- default:
- LOGE("[%s] Codec has not been recognised",__func__);
- return MFC_RET_ENC_INIT_FAIL;
- }
-
- fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- fmt.fmt.pix_mp.plane_fmt[0].sizeimage = MAX_STREAM_SIZE;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_FMT, &fmt);
- if (ret != 0) {
- LOGE("[%s] S_FMT failed on MFC output stream",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
-
- /* cacheable buffer */
- ctrl.id = V4L2_CID_CACHEABLE;
- if (pCTX->cacheablebuffer == NO_CACHE)
- ctrl.value = 0;
- else
- ctrl.value = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed, V4L2_CID_CACHEABLE",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
-
- /* Initialize streams for input */
- memset(&reqbuf, 0, sizeof(reqbuf));
- reqbuf.count = MFC_ENC_NUM_SRC_BUFS;
- reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- if (pCTX->v4l2_enc.bInputPhyVir)
- reqbuf.memory = V4L2_MEMORY_USERPTR;
- else
- reqbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_REQBUFS, &reqbuf);
- if (ret != 0) {
- LOGE("[%s] Reqbufs src ioctl failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case1;
- }
- pCTX->v4l2_enc.mfc_num_src_bufs = reqbuf.count;
-
- if (!pCTX->v4l2_enc.bInputPhyVir) {
- /* Then the buffers have to be queried and mmaped */
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; ++i) {
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.index = i;
- buf.m.planes = planes;
- buf.length = 2;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] Querybuf src ioctl failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case2;
- }
-
- pCTX->v4l2_enc.mfc_src_bufs_len[0] = buf.m.planes[0].length;
- pCTX->v4l2_enc.mfc_src_bufs_len[1] = buf.m.planes[1].length;
-
- pCTX->v4l2_enc.mfc_src_phys[i][0] = buf.m.planes[0].cookie;
- pCTX->v4l2_enc.mfc_src_phys[i][1] = buf.m.planes[1].cookie;
-
- pCTX->v4l2_enc.mfc_src_bufs[i][0] =
- mmap(NULL, buf.m.planes[0].length, PROT_READ | PROT_WRITE,
- MAP_SHARED, pCTX->hMFC, buf.m.planes[0].m.mem_offset);
- if (pCTX->v4l2_enc.mfc_src_bufs[i][0] == MAP_FAILED) {
- LOGE("[%s] Mmap on src buffer (0) failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case2;
- }
-
- pCTX->v4l2_enc.mfc_src_bufs[i][1] =
- mmap(NULL, buf.m.planes[1].length, PROT_READ | PROT_WRITE,
- MAP_SHARED, pCTX->hMFC, buf.m.planes[1].m.mem_offset);
- if (pCTX->v4l2_enc.mfc_src_bufs[i][1] == MAP_FAILED) {
- munmap(pCTX->v4l2_enc.mfc_src_bufs[i][0], pCTX->v4l2_enc.mfc_src_bufs_len[0]);
- LOGE("[%s] Mmap on src buffer (1) failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case2;
- }
- }
- } else
- LOGV("[%s] Camera Phys src buf %d",__func__,reqbuf.count);
-
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; i++)
- pCTX->v4l2_enc.mfc_src_buf_flags[i] = BUF_DEQUEUED;
-
- pCTX->v4l2_enc.beingUsedIndex = 0;
-
- pCTX->sizeFrmBuf.luma = (unsigned int)(pCTX->width * pCTX->height);
- pCTX->sizeFrmBuf.chroma = (unsigned int)((pCTX->width * pCTX->height) >> 1);
- pCTX->inter_buff_status |= MFC_USE_YUV_BUFF;
-
- /* Initialize stream for output */
- memset(&reqbuf, 0, sizeof(reqbuf));
- reqbuf.count = MFC_ENC_MAX_DST_BUFS;
- reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- reqbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_REQBUFS, &reqbuf);
- if (ret != 0) {
- LOGE("[%s] Reqbufs dst ioctl failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case2;
- }
-
- pCTX->v4l2_enc.mfc_num_dst_bufs = reqbuf.count;
-
- for (i = 0; i < MFC_ENC_MAX_DST_BUFS; ++i) {
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.index = i;
- buf.m.planes = planes;
- buf.length = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QUERYBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] Querybuf dst ioctl failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
-
- pCTX->v4l2_enc.mfc_dst_bufs_len = buf.m.planes[0].length;
- pCTX->v4l2_enc.mfc_dst_bufs[i] =
- mmap(NULL, buf.m.planes[0].length, PROT_READ | PROT_WRITE,
- MAP_SHARED, pCTX->hMFC, buf.m.planes[0].m.mem_offset);
- if (pCTX->v4l2_enc.mfc_dst_bufs[i] == MAP_FAILED) {
- LOGE("[%s] Mmap on dst buffer failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
- }
-
- pCTX->sizeStrmBuf = MAX_ENCODER_OUTPUT_BUFFER_SIZE;
- pCTX->inter_buff_status |= MFC_USE_STRM_BUFF;
-
- type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMON, &type);
- if (ret != 0) {
- LOGE("[%s] V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, VIDIOC_STREAMON failed",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
-
- pCTX->inter_buff_status |= MFC_USE_DST_STREAMON;
-
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.m.planes = planes;
- buf.length = 1;
-
- /* note: #define POLLOUT 0x0004 */
- poll_events.fd = pCTX->hMFC;
- poll_events.events = POLLIN | POLLERR;
- poll_events.revents = 0;
-
- /* wait for header encoding */
- do {
- poll_state = poll((struct pollfd*)&poll_events, 1, POLL_ENC_WAIT_TIMEOUT);
- if (0 < poll_state) {
- if (poll_events.revents & POLLIN) { /* POLLIN */
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &buf);
- if (ret == 0)
- break;
- } else if (poll_events.revents & POLLERR) { /*POLLERR */
- LOGE("[%s] POLLERR\n",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- } else {
- LOGE("[%s] poll() returns 0x%x\n",__func__, poll_events.revents);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
- } else if (0 > poll_state) {
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
- } while (1 == poll_state);
-
- pCTX->v4l2_enc.mfc_dst_bufs_bytes_used_len = buf.m.planes[0].bytesused;
- pCTX->virStrmBuf = (unsigned int)pCTX->v4l2_enc.mfc_dst_bufs[buf.index];
-
- /* stream dequeued index */
- index = buf.index;
- memset(&buf, 0, sizeof(buf));
- buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- buf.memory = V4L2_MEMORY_MMAP;
- buf.index = index;
- buf.m.planes = planes;
- buf.length = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &buf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- ret = MFC_RET_ENC_INIT_FAIL;
- goto error_case3;
- }
- LOGV("[%s] Strm out idx %d",__func__,index);
-
- return MFC_RET_OK;
-
-error_case3:
- for (j = 0; j < i; j++)
- munmap(pCTX->v4l2_enc.mfc_dst_bufs[j], pCTX->v4l2_enc.mfc_dst_bufs_len);
-
- i = pCTX->v4l2_enc.mfc_num_src_bufs;
-error_case2:
- if (!pCTX->v4l2_enc.bInputPhyVir) {
- for (j = 0; j < i; j++) {
- munmap(pCTX->v4l2_enc.mfc_src_bufs[j][0], pCTX->v4l2_enc.mfc_src_bufs_len[0]);
- munmap(pCTX->v4l2_enc.mfc_src_bufs[j][1], pCTX->v4l2_enc.mfc_src_bufs_len[1]);
- }
- }
-error_case1:
- return ret;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
-{
- _MFCLIB *pCTX;
- int i;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- /* FIXME check this if GetInBuf() is not called for UserPtr */
- if (pCTX->v4l2_enc.bInputPhyVir) {
- input_info->YPhyAddr = (void*)0;
- input_info->CPhyAddr = (void*)0;
- input_info->YVirAddr = (void*)0;
- input_info->CVirAddr = (void*)0;
-
- /* FIXME check whether Y & C sizes should be set or not*/
- if (NV12_TILE == pCTX->framemap) {
- /* 4:2:0, 2 Planes, 64x32 Tiles */
- input_info->YSize = Align(Align(pCTX->width, 128) * Align(pCTX->height, 32), 8192); /* tiled mode */
- input_info->CSize = Align(Align(pCTX->width, 128) * Align(pCTX->height >> 1, 32), 8192); /* tiled mode */
- } else { /* NV12_LINEAR (default) */
- /* 4:2:0, 2 Planes, linear */
- input_info->YSize = Align(Align(pCTX->width, 16) * Align(pCTX->height, 16), 2048); /* width = 16B, height = 16B align */
- input_info->CSize = Align(Align(pCTX->width, 16) * Align(pCTX->height >> 1, 8), 2048); /* width = 16B, height = 8B align */
- }
- } else {
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; i++)
- if (BUF_DEQUEUED == pCTX->v4l2_enc.mfc_src_buf_flags[i])
- break;
-
- if (i == pCTX->v4l2_enc.mfc_num_src_bufs) {
- LOGV("[%s] No buffer is available.",__func__);
- return MFC_RET_ENC_GET_INBUF_FAIL;
- } else {
- input_info->YPhyAddr = (void*)pCTX->v4l2_enc.mfc_src_phys[i][0];
- input_info->CPhyAddr = (void*)pCTX->v4l2_enc.mfc_src_phys[i][1];
- input_info->YVirAddr = (void*)pCTX->v4l2_enc.mfc_src_bufs[i][0];
- input_info->CVirAddr = (void*)pCTX->v4l2_enc.mfc_src_bufs[i][1];
- input_info->YSize = (int)pCTX->v4l2_enc.mfc_src_bufs_len[0];
- input_info->CSize = (int)pCTX->v4l2_enc.mfc_src_bufs_len[1];
-
- pCTX->v4l2_enc.mfc_src_buf_flags[i] = BUF_ENQUEUED;
- }
- }
- LOGV("[%s] Input Buffer idx %d",__func__,i);
- return MFC_RET_OK;
-}
-
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetInBuf(void *openHandle, SSBSIP_MFC_ENC_INPUT_INFO *input_info)
-{
- _MFCLIB *pCTX;
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_ENC_NUM_PLANES];
- int ret,i;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- memset(&qbuf, 0, sizeof(qbuf));
- if (pCTX->v4l2_enc.bInputPhyVir) {
- qbuf.memory = V4L2_MEMORY_USERPTR;
- qbuf.index = pCTX->v4l2_enc.beingUsedIndex;
- planes[0].m.userptr = (unsigned long)input_info->YPhyAddr;
- planes[0].length = input_info->YSize;
- planes[0].bytesused = input_info->YSize;
- planes[1].m.userptr = (unsigned long)input_info->CPhyAddr;
- planes[1].length = input_info->CSize;
- planes[1].bytesused = input_info->CSize;
-
- /* FIXME, this is only for case of not using B frame,
- Camera side should know which buffer is queued() refering to index of
- MFC dqbuf() */
- pCTX->v4l2_enc.beingUsedIndex++;
- pCTX->v4l2_enc.beingUsedIndex %= MFC_ENC_NUM_SRC_BUFS;
- LOGV("[%s] Phy Input Buffer idx Queued %d",__func__,pCTX->v4l2_enc.beingUsedIndex);
- } else {
- for (i = 0; i < pCTX->v4l2_enc.mfc_num_src_bufs; i++)
- if (pCTX->v4l2_enc.mfc_src_bufs[i][0] == input_info->YVirAddr)
- break;
-
- if (i == pCTX->v4l2_enc.mfc_num_src_bufs) {
- LOGE("[%s] Can not use the buffer",__func__);
- return MFC_RET_INVALID_PARAM;
- } else {
- pCTX->v4l2_enc.beingUsedIndex = i;
- //pCTX->v4l2_enc.mfc_src_buf_flags[i] = BUF_ENQUEUED;
- }
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = pCTX->v4l2_enc.beingUsedIndex;
- planes[0].bytesused = pCTX->width * pCTX->height;
- planes[1].bytesused = (pCTX->width * pCTX->height) >> 1;
- LOGV("[%s] Input Buffer idx Queued %d",__func__,pCTX->v4l2_enc.beingUsedIndex);
- }
-
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- qbuf.m.planes = planes;
- qbuf.length = 2;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_ENC_SET_INBUF_FAIL;
- }
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncGetOutBuf(void *openHandle, SSBSIP_MFC_ENC_OUTPUT_INFO *output_info)
-{
- _MFCLIB *pCTX;
- struct v4l2_control ctrl;
- unsigned int encoded_y_addr, encoded_c_addr;
- int ret;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (pCTX->v4l2_enc.bRunning == 0) {
- pCTX->encodedHeaderSize = pCTX->v4l2_enc.mfc_dst_bufs_bytes_used_len;
- output_info->dataSize = 0;
- } else {
- output_info->dataSize = pCTX->v4l2_enc.mfc_dst_bufs_bytes_used_len;
- }
-
- ctrl.id = V4L2_CID_CODEC_ENCODED_LUMA_ADDR;
- ctrl.value = 0;
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- if (ret != 0)
- LOGE("[%s] Error to do g_ctrl",__func__);
- encoded_y_addr = (unsigned int)ctrl.value;
-
- ctrl.id = V4L2_CID_CODEC_ENCODED_CHROMA_ADDR;
- ctrl.value = 0;
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- if (ret != 0)
- LOGE("[%s] Error to do g_ctrl",__func__);
- encoded_c_addr = (unsigned int)ctrl.value;
-
- output_info->headerSize = pCTX->encodedHeaderSize;
- output_info->frameType = pCTX->encodedframeType;
- output_info->StrmPhyAddr = (void *)0;
- output_info->StrmVirAddr = (void *)pCTX->virStrmBuf;
- output_info->encodedYPhyAddr = (void*)encoded_y_addr;
- output_info->encodedCPhyAddr = (void*)encoded_c_addr;
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetOutBuf(void *openHandle, void *phyOutbuf, void *virOutbuf, int outputBufferSize)
-{
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- return MFC_RET_ENC_SET_OUTBUF_FAIL;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncExe(void *openHandle)
-{
- int ret;
- int dequeued_index;
- int loopcnt = 0;
- _MFCLIB *pCTX;
-
- struct v4l2_buffer qbuf;
- struct v4l2_plane planes[MFC_ENC_NUM_PLANES];
- enum v4l2_buf_type type;
-
- struct v4l2_control ctrl;
-
- struct pollfd poll_events;
- int poll_state;
-
- LOGV("[%s] Enter \n",__func__);
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- ctrl.id = V4L2_CID_CODEC_FRAME_TAG;
- ctrl.value = pCTX->inframetag;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed, V4L2_CID_CODEC_FRAME_TAG",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
-
- if (pCTX->v4l2_enc.bRunning == 0) {
- type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- ret = ioctl(pCTX->hMFC, VIDIOC_STREAMON, &type);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_STREAMON failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
-
- pCTX->v4l2_enc.bRunning = 1;
- }
-
- pCTX->inter_buff_status |= MFC_USE_SRC_STREAMON;
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.m.planes = planes;
- qbuf.length = 1;
-
- /* note: #define POLLOUT 0x0004 */
- poll_events.fd = pCTX->hMFC;
- poll_events.events = POLLIN | POLLERR;
- poll_events.revents = 0;
-
- /* wait for encoding */
- do {
- poll_state = poll((struct pollfd*)&poll_events, 1, POLL_ENC_WAIT_TIMEOUT);
- if (0 < poll_state) {
- if (poll_events.revents & POLLIN) { /* POLLIN */
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- if (ret == 0)
- break;
- } else if (poll_events.revents & POLLERR) { /* POLLERR */
- LOGE("[%s] POLLERR\n",__func__);
- return MFC_RET_ENC_EXE_ERR;
- } else {
- LOGE("[%s] poll() returns 0x%x\n",__func__, poll_events.revents);
- return MFC_RET_ENC_EXE_ERR;
- }
- } else if (0 > poll_state) {
- LOGE("[%s] poll() Encoder POLL Timeout 0x%x\n",__func__, poll_events.revents);
- return MFC_RET_ENC_EXE_ERR;
- } else { /* in the case of B frame encoding */
- ctrl.id = V4L2_CID_CODEC_CHECK_STATE;
- ctrl.value = 0;
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- LOGV("[%s] ctx state = %d\n",__func__, ctrl.value);
- if (ctrl.value == MFCSTATE_ENC_NO_OUTPUT)
- return MFC_RET_OK;
- }
- loopcnt++;
- } while ((0 == poll_state) && (loopcnt < 5));
-
- if (pCTX->v4l2_enc.bRunning != 0) {
- pCTX->encodedframeType = (qbuf.flags & 0x38) >> 3; /* encoded frame type */
- LOGV("[%s] encoded frame type = %d\n", __func__, pCTX->encodedframeType);
-
- switch (pCTX->encodedframeType) {
- case 1:
- pCTX->encodedframeType = MFC_FRAME_TYPE_I_FRAME;
- break;
- case 2:
- pCTX->encodedframeType = MFC_FRAME_TYPE_P_FRAME;
- break;
- case 4:
- pCTX->encodedframeType = MFC_FRAME_TYPE_B_FRAME;
- break;
- default:
- LOGE("[%s] VIDIOC_DQBUF failed, encoded frame type is wrong",__func__);
- }
- }
-
- dequeued_index = qbuf.index;
-
- if (qbuf.m.planes[0].bytesused > 0) { /* FIXME later */
- pCTX->v4l2_enc.mfc_dst_bufs_bytes_used_len = qbuf.m.planes[0].bytesused;
- }
-
- ctrl.id = V4L2_CID_CODEC_FRAME_TAG;
- ctrl.value = 0;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_G_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_G_CTRL failed, V4L2_CID_CODEC_FRAME_TAG",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
-
- pCTX->outframetagtop = ctrl.value;
-
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- qbuf.memory = V4L2_MEMORY_MMAP;
- qbuf.index = dequeued_index;
- qbuf.m.planes = planes;
- qbuf.length = 1;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_QBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_QBUF failed, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
-
- if (pCTX->v4l2_enc.bRunning != 0) {
- memset(&qbuf, 0, sizeof(qbuf));
- qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-
- if (pCTX->v4l2_enc.bInputPhyVir)
- qbuf.memory = V4L2_MEMORY_USERPTR;
- else
- qbuf.memory = V4L2_MEMORY_MMAP;
-
- ret = ioctl(pCTX->hMFC, VIDIOC_DQBUF, &qbuf);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_DQBUF failed, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE",__func__);
- return MFC_RET_ENC_EXE_ERR;
- }
- }
- pCTX->v4l2_enc.mfc_src_buf_flags[qbuf.index] = BUF_DEQUEUED;
-
- /* Update context stream buffer address */
- pCTX->virStrmBuf = (unsigned int)pCTX->v4l2_enc.mfc_dst_bufs[dequeued_index];
- LOGV("[%s] Strm out idx %d",__func__,dequeued_index);
-
- return MFC_RET_OK;
-}
-
-SSBSIP_MFC_ERROR_CODE SsbSipMfcEncSetConfig(void *openHandle, SSBSIP_MFC_ENC_CONF conf_type, void *value)
-{
- _MFCLIB *pCTX;
- struct v4l2_control ctrl;
- struct mfc_enc_hier_p_qp hier_p_qp;
-#ifdef S3D_SUPPORT
- SSBSIP_MFC_FRAME_PACKING *frame_packing;
-#endif
- struct mfc_enc_fmo fmo_param;
- int *aso_param;
- int ret, i;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("[%s] value is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- pCTX = (_MFCLIB *) openHandle;
-
- switch (conf_type) {
- case MFC_ENC_SETCONF_FRAME_TAG:
- pCTX->inframetag = *((unsigned int *)value);
- return MFC_RET_OK;
-
- case MFC_ENC_SETCONF_FRAME_TYPE:
- ctrl.id = V4L2_CID_CODEC_FRAME_INSERTION;
- ctrl.value = *((unsigned int*)value);
- break;
-
- case MFC_ENC_SETCONF_I_PERIOD:
- ctrl.id = V4L2_CID_CODEC_ENCODED_I_PERIOD_CH;
- ctrl.value = *((unsigned int*)value);
- break;
-
- case MFC_ENC_SETCONF_CHANGE_FRAME_RATE:
- ctrl.id = V4L2_CID_CODEC_ENCODED_FRAME_RATE_CH;
- ctrl.value = *((unsigned int*)value);
- break;
-
- case MFC_ENC_SETCONF_CHANGE_BIT_RATE:
- ctrl.id = V4L2_CID_CODEC_ENCODED_BIT_RATE_CH;
- ctrl.value = *((unsigned int*)value);
- break;
-#ifdef S3D_SUPPORT
- case MFC_ENC_SETCONF_SEI_GEN:
- ctrl.id = V4L2_CID_CODEC_FRAME_PACK_SEI_GEN;
- ctrl.value = *((unsigned int*)value);
- pCTX->sei_info.sei_gen_enable = 1;
- break;
-#endif
- case MFC_ENC_SETCONF_ALLOW_FRAME_SKIP:
- pCTX->enc_frameskip = *((int *)value);
- return MFC_RET_OK;
-#if 0
- case MFC_ENC_SETCONF_VUI_INFO:
- vui_info = *((struct mfc_enc_vui_info *) value);
- EncArg.args.set_config.in_config_value[0] = (int)(vui_info.aspect_ratio_idc);
- EncArg.args.set_config.in_config_value[1] = 0;
- break;
-#endif
- case MFC_ENC_SETCONF_HIER_P:
- hier_p_qp = *((struct mfc_enc_hier_p_qp *) value);
- pCTX->hier_p_enable = 1;
- pCTX->hier_qp_value.t0_frame_qp = (int)(hier_p_qp.t0_frame_qp);
- pCTX->hier_qp_value.t2_frame_qp = (int)(hier_p_qp.t2_frame_qp);
- pCTX->hier_qp_value.t3_frame_qp = (int)(hier_p_qp.t3_frame_qp);
- return MFC_RET_OK;
-#ifdef S3D_SUPPORT
- case MFC_ENC_SETCONF_FRAME_PACKING:
- frame_packing = (SSBSIP_MFC_FRAME_PACKING *)value;
- pCTX->sei_info.curr_frame_frm0_flag = (int)(frame_packing->current_frame_is_frame0_flag);
- pCTX->sei_info.frame_pack_arrgment_type = (int)(frame_packing->arrangement_type);
- return MFC_RET_OK;
-#endif
- case MFC_ENC_SETCONF_FMO:
- fmo_param = *((struct mfc_enc_fmo *) value);
- pCTX->fmo_enable = 1;
- pCTX->fmo_value.slice_map_type = (int)(fmo_param.slice_map_type);
- pCTX->fmo_value.slice_num_grp = (int)(fmo_param.slice_num_grp);
- pCTX->fmo_value.run_length[0] = (int)(fmo_param.run_length[0]);
- pCTX->fmo_value.run_length[1] = (int)(fmo_param.run_length[1]);
- pCTX->fmo_value.run_length[2] = (int)(fmo_param.run_length[2]);
- pCTX->fmo_value.run_length[3] = (int)(fmo_param.run_length[3]);
- pCTX->fmo_value.sg_dir = (int)(fmo_param.sg_dir);
- pCTX->fmo_value.sg_rate = (int)(fmo_param.sg_rate);
- return MFC_RET_OK;
-
- case MFC_ENC_SETCONF_ASO:
- aso_param = (int *) value;
- pCTX->aso_enable = 1;
- for (i = 0; i < 8; i++)
- pCTX->aso_sl_order[i] = (int)aso_param[i];
- return MFC_RET_OK;
-
- default:
- LOGE("[%s] conf_type(%d) is NOT supported\n",__func__, conf_type);
- return MFC_RET_INVALID_PARAM;
- }
-
- ret = ioctl(pCTX->hMFC, VIDIOC_S_CTRL, &ctrl);
- if (ret != 0) {
- LOGE("[%s] VIDIOC_S_CTRL failed (conf_type = %d)",__func__, conf_type);
- 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)
-{
- _MFCLIB *pCTX;
-
- pCTX = (_MFCLIB *) openHandle;
-
- if (openHandle == NULL) {
- LOGE("[%s] openHandle is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- if (value == NULL) {
- LOGE("[%s] value is NULL\n",__func__);
- return MFC_RET_INVALID_PARAM;
- }
-
- switch (conf_type) {
- case MFC_ENC_GETCONF_FRAME_TAG:
- *((unsigned int *)value) = pCTX->outframetagtop;
- break;
-
- default:
- LOGE("[%s] conf_type(%d) is NOT supported\n",__func__, conf_type);
- return MFC_RET_INVALID_PARAM;
- }
-
- return MFC_RET_OK;
-}
-
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/SsbSipMfcApi.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/SsbSipMfcApi.h
deleted file mode 100644
index b386c72..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/SsbSipMfcApi.h
+++ /dev/null
@@ -1,431 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 _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 MFC6x_VERSION
-
-#define SUPPORT_1080P 1
-
-#if SUPPORT_1080P
-#define MMAP_BUFFER_SIZE_MMAP (70*1024*1024) /* only C110 use this value. in C210, memory size is decided in menuconfig*/
-#else
-#define MMAP_BUFFER_SIZE_MMAP (62*1024*1024)
-#endif
-
-#define SAMSUNG_MFC_DEV_NAME "/dev/video"
-
-#define SSBSIP_MFC_OK (1)
-#define SSBSIP_MFC_FAIL (0)
-
-/*--------------------------------------------------------------------------------*/
-/* 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,
-#if defined (MFC6x_VERSION)
- VP8_DEC,
-#endif
- 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,
- NV21_LINEAR
-} SSBSIP_MFC_INSTRM_MODE_TYPE;
-
-typedef enum {
- FRAME = 0,
- SLICE,
-} SSBSIP_MFC_OUTSTRM_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,
-
- /* C210 specific feature */
- MFC_DEC_SETCONF_IMMEDIATELY_DISPLAY,
- MFC_DEC_SETCONF_DPB_FLUSH,
- MFC_DEC_SETCONF_PIXEL_CACHE,
- MFC_DEC_GETCONF_WIDTH_HEIGHT,
-#ifdef S3D_SUPPORT
- /* S3D specific feature */
- MFC_DEC_SETCONF_SEI_PARSE,
- MFC_DEC_GETCONF_FRAME_PACKING
-#endif
-} 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,
-
- /* C210 specific feature */
- MFC_ENC_SETCONF_VUI_INFO,
- MFC_ENC_SETCONF_I_PERIOD,
- MFC_ENC_SETCONF_HIER_P,
-#ifdef S3D_SUPPORT
- /* S3D Specific feature */
- MFC_ENC_SETCONF_SEI_GEN,
- MFC_ENC_SETCONF_FRAME_PACKING,
-#endif
- MFC_ENC_SETCONF_FMO,
- MFC_ENC_SETCONF_ASO,
-} 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,
- MFC_GETOUTBUF_CHANGE_RESOL
-} 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 */
- int disp_pic_frame_type; /* [OUT] display picture frame type information */
-
- /* C210 UMP feature */
- unsigned int y_cookie; /* [OUT] cookie for Y address */
- unsigned int c_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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 */
-
- /* C210 UMP feature */
- unsigned int y_cookie; /* [OUT] cookie for Y address */
- unsigned int c_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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 */
-
- /* C210 UMP feature */
- unsigned int strm_cookie; /* [OUT] cooke for stream buffer */
- unsigned int y_encoded_cookie; /* [OUT] cookie for Y address */
- unsigned int c_encoded_cookie; /* [OUT] cookie for CbCr address, If it is 0, Y and CbCr is in continous memory */
-} 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) */
- SSBSIP_MFC_OUTSTRM_MODE_TYPE OutputMode; /* [IN] Output mode: Frame/Slice */
-
- /* 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) */
- SSBSIP_MFC_OUTSTRM_MODE_TYPE OutputMode; /* [IN] Output mode: Frame/Slice */
-#if defined (MFC6x_VERSION)
- int EnableMBRateControl; /* [IN] Enable macroblock-level rate control, MFC6.x Only */
-#endif
-
- /* 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) */
-#if defined (MFC6x_VERSION)
- int EnableMBRateControl; /* [IN] Enable macroblock-level rate control, MFC6.x Only */
-#endif
-
- /* 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 S3D_SUPPORT
-typedef struct {
- int available;
- unsigned int arrangement_id;
- int arrangement_cancel_flag;
- unsigned char arrangement_type;
- int quincunx_sampling_flag;
- unsigned char content_interpretation_type;
- int spatial_flipping_flag;
- int frame0_flipped_flag;
- int field_views_flag;
- int current_frame_is_frame0_flag;
- unsigned char frame0_grid_pos_x;
- unsigned char frame0_grid_pos_y;
- unsigned char frame1_grid_pos_x;
- unsigned char frame1_grid_pos_y;
-} SSBSIP_MFC_FRAME_PACKING;
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*--------------------------------------------------------------------------------*/
-/* Decoding APIs */
-/*--------------------------------------------------------------------------------*/
-void *SsbSipMfcDecOpen(void);
-void *SsbSipMfcDecOpenExt(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 SsbSipMfcDecExeNb(void *openHandle, int lengthBufFill);
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecClose(void *openHandle);
-void *SsbSipMfcDecGetInBuf(void *openHandle, void **phyInBuf, int inputBufferSize);
-//SSBSIP_MFC_DEC_OUTBUF_STATUS SsbSipMfcDecWaitForOutBuf(void *openHandle, SSBSIP_MFC_DEC_OUTPUT_INFO *output_info);
-
-#if (defined(CONFIG_VIDEO_MFC_VCM_UMP) || defined(USE_UMP))
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, unsigned int secure_id, int size);
-#else
-SSBSIP_MFC_ERROR_CODE SsbSipMfcDecSetInBuf(void *openHandle, void *phyInBuf, void *virInBuf, int size);
-#endif
-
-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);
-void *SsbSipMfcEncOpenExt(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 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/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/mfc_errno.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/mfc_errno.h
deleted file mode 100644
index b8e96ab..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/mfc_errno.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 __MFC_ERRNO_H
-#define __MFC_ERRNO_H __FILE__
-
-enum mfc_ret_code {
- MFC_OK = 1,
- MFC_FAIL = -1000,
- MFC_OPEN_FAIL = -1001,
- MFC_CLOSE_FAIL = -1002,
-
- MFC_DEC_INIT_FAIL = -2000,
- MFC_DEC_EXE_TIME_OUT = -2001,
- MFC_DEC_EXE_ERR = -2002,
- MFC_DEC_GET_INBUF_FAIL = 2003,
- MFC_DEC_SET_INBUF_FAIL = 2004,
- MFC_DEC_GET_OUTBUF_FAIL = -2005,
- MFC_DEC_GET_CONF_FAIL = -2006,
- MFC_DEC_SET_CONF_FAIL = -2007,
-
- MFC_ENC_INIT_FAIL = -3000,
- MFC_ENC_EXE_TIME_OUT = -3001,
- MFC_ENC_EXE_ERR = -3002,
- MFC_ENC_GET_INBUF_FAIL = -3003,
- MFC_ENC_SET_INBUF_FAIL = -3004,
- MFC_ENC_GET_OUTBUF_FAIL = -3005,
- MFC_ENC_SET_OUTBUF_FAIL = -3006,
- MFC_ENC_GET_CONF_FAIL = -3007,
- MFC_ENC_SET_CONF_FAIL = -3008,
-
- MFC_STATE_INVALID = -4000,
- MFC_DEC_HEADER_FAIL = -4001,
- MFC_DEC_INIT_BUF_FAIL = -4002,
- MFC_ENC_HEADER_FAIL = -5000,
- MFC_ENC_PARAM_FAIL = -5001,
- MFC_FRM_BUF_SIZE_FAIL = -6000,
- MFC_FW_LOAD_FAIL = -6001,
- MFC_FW_INIT_FAIL = -6002,
- MFC_INST_NUM_EXCEEDED_FAIL = -6003,
- MFC_MEM_ALLOC_FAIL = -6004,
- MFC_MEM_INVALID_ADDR_FAIL = -6005,
- MFC_MEM_MAPPING_FAIL = -6006,
- MFC_GET_CONF_FAIL = -6007,
- MFC_SET_CONF_FAIL = -6008,
- MFC_INVALID_PARAM_FAIL = -6009,
- MFC_API_FAIL = -9000,
-
- MFC_CMD_FAIL = -1003,
- MFC_SLEEP_FAIL = -1010,
- MFC_WAKEUP_FAIL = -1020,
-
- MFC_CLK_ON_FAIL = -1030,
- MFC_CLK_OFF_FAIL = -1030,
- MFC_PWR_ON_FAIL = -1040,
- MFC_PWR_OFF_FAIL = -1041,
-};
-
-#endif /* __MFC_ERRNO_H */
diff --git a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/mfc_interface.h b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/mfc_interface.h
deleted file mode 100644
index 9bcee9d..0000000
--- a/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/mfc_interface.h
+++ /dev/null
@@ -1,588 +0,0 @@
-/*
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- * http://www.samsung.com/
- *
- * Global header for Samsung MFC (Multi Function Codec - FIMV) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * 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 __MFC_INTERFACE_H
-#define __MFC_INTERFACE_H
-
-#include "mfc_errno.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_REAL_ADDR (0x00800012)
-#define IOCTL_MFC_GET_MMAP_SIZE (0x00800014)
-#define IOCTL_MFC_SET_IN_BUF (0x00800018)
-
-#define IOCTL_MFC_SET_CONFIG (0x00800101)
-#define IOCTL_MFC_GET_CONFIG (0x00800102)
-
-#define IOCTL_MFC_SET_BUF_CACHE (0x00800201)
-
-/* MFC H/W support maximum 32 extra DPB. */
-#define MFC_MAX_EXTRA_DPB 5
-#define MFC_MAX_DISP_DELAY 0xF
-
-#define MFC_LIB_VER_MAJOR 1
-#define MFC_LIB_VER_MINOR 00
-
-#define BUF_L_UNIT (1024)
-#define Align(x, alignbyte) (((x)+(alignbyte)-1)/(alignbyte)*(alignbyte))
-
-#define MFC_ENC_NUM_SRC_BUFS 2 /* Number of source buffers to request */
-#define MFC_ENC_MAX_DST_BUFS 2 /* The maximum number of buffers */
-#define MFC_ENC_NUM_PLANES 2 /* Number of planes used by MFC Input */
-
-#define MFC_DEC_NUM_SRC_BUFS 2 /* Number of source buffers to request */
-#define MFC_DEC_MAX_DST_BUFS 32 /* The maximum number of buffers */
-#define MFC_DEC_NUM_PLANES 2 /* Number of planes used by MFC output */
-
-enum inst_type {
- DECODER = 0x1,
- ENCODER = 0x2,
-};
-
-enum mfc_check_state {
- MFCSTATE_PROCESSING = 0,
- MFCSTATE_DEC_RES_DETECT,
- MFCSTATE_DEC_TERMINATING,
- MFCSTATE_ENC_NO_OUTPUT,
-};
-
-typedef enum {
- MFC_UNPACKED_PB = 0,
- MFC_PACKED_PB = 1
-} mfc_packed_mode;
-
-typedef enum {
- SSBSIP_MFC_LAST_FRAME_NOT_RECEIVED = 0,
- SSBSIP_MFC_LAST_FRAME_RECEIVED = 1,
- SSBSIP_MFC_LAST_FRAME_PROCESSED = 2
-} SSBSIP_MFC_LAST_FRAME_STATUS;
-
-typedef enum {
- MFC_USE_NONE = 0x0000,
- MFC_USE_YUV_BUFF = 0x0001,
- MFC_USE_STRM_BUFF = 0x0010,
- MFC_USE_SRC_STREAMON = 0x0100,
- MFC_USE_DST_STREAMON = 0x1000,
-} s3c_mfc_interbuff_status;
-
-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) */
-} SSBSIP_MFC_CRC_DATA;
-
-#ifdef S3D_SUPPORT
-struct mfc_frame_pack_sei_info {
- int sei_avail;
- unsigned int arrgment_id;
- int sei_info;
- int grid_pos;
-};
-#endif
-
-struct mfc_strm_ref_buf_arg {
- unsigned int strm_ref_y;
- unsigned int mv_ref_yc;
-};
-
-struct mfc_frame_buf_arg {
- unsigned int luma;
- unsigned int chroma;
-};
-
-struct mfc_enc_init_common_arg {
- 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_gop_num; /* [IN] GOP Number (interval of I-frame) */
- int in_vop_quant; /* [IN] VOP quant */
- int in_vop_quant_p; /* [IN] VOP quant for P frame */
-
- /* [IN] RC enable */
- /* [IN] RC enable (0:disable, 1:frame level RC) */
- int in_rc_fr_en;
- int in_rc_bitrate; /* [IN] RC parameter (bitrate in kbps) */
-
- int in_rc_qbound_min; /* [IN] RC parameter (Q bound Min) */
- int in_rc_qbound_max; /* [IN] RC parameter (Q bound Max) */
- int in_rc_rpara; /* [IN] RC parameter (Reaction Coefficient) */
-
- /* [IN] Multi-slice mode (0:single, 1:multiple) */
- int in_ms_mode;
- /* [IN] Multi-slice size (in num. of mb or byte) */
- int in_ms_arg;
-
- int in_mb_refresh; /* [IN] Macroblock refresh */
-
- /* [IN] Enable (1) / Disable (0) padding with the specified values */
- int in_pad_ctrl_on;
-
- /* [IN] pad value if pad_ctrl_on is Enable */
- int in_y_pad_val;
- int in_cb_pad_val;
- int in_cr_pad_val;
-
- /* linear or tiled */
- int in_frame_map;
-
- unsigned int in_pixelcache;
-
- unsigned int in_mapped_addr;
- struct mfc_strm_ref_buf_arg out_u_addr;
- struct mfc_strm_ref_buf_arg out_p_addr;
- struct mfc_strm_ref_buf_arg out_buf_size;
- unsigned int out_header_size;
-};
-
-struct mfc_enc_init_h263_arg {
- int in_rc_framerate; /* [IN] RC parameter (framerate) */
-};
-
-struct mfc_enc_init_mpeg4_arg {
- int in_profile; /* [IN] profile */
- int in_level; /* [IN] level */
-
- int in_vop_quant_b; /* [IN] VOP quant for B frame */
-
- /* [IN] B frame number */
- int in_bframenum;
-
- /* [IN] Quarter-pel MC enable (1:enabled, 0:disabled) */
- int in_quart_pixel;
-
- int in_TimeIncreamentRes; /* [IN] VOP time resolution */
- int in_VopTimeIncreament; /* [IN] Frame delta */
-};
-
-struct mfc_enc_init_h264_arg {
- int in_profile; /* [IN] profile */
- int in_level; /* [IN] level */
-
- int in_vop_quant_b; /* [IN] VOP quant for B frame */
-
- /* [IN] B frame number */
- int in_bframenum;
-
- /* [IN] interlace mode(0:progressive, 1:interlace) */
- int in_interlace_mode;
-
- /* [IN] reference number */
- int in_reference_num;
- /* [IN] reference number of P frame */
- int in_ref_num_p;
-
- int in_rc_framerate; /* [IN] RC parameter (framerate) */
- int in_rc_mb_en; /* [IN] RC enable (0:disable, 1:MB level RC) */
- /* [IN] MB level rate control dark region adaptive feature */
- int in_rc_mb_dark_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control smooth region adaptive feature */
- int in_rc_mb_smooth_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control static region adaptive feature */
- int in_rc_mb_static_dis; /* (0:enable, 1:disable) */
- /* [IN] MB level rate control activity region adaptive feature */
- int in_rc_mb_activity_dis; /* (0:enable, 1:disable) */
-
- /* [IN] disable deblocking filter idc */
- int in_deblock_dis; /* (0: enable,1: disable, 2:Disable at slice boundary) */
- /* [IN] slice alpha c0 offset of deblocking filter */
- int in_deblock_alpha_c0;
- /* [IN] slice beta offset of deblocking filter */
- int in_deblock_beta;
-
- /* [IN] ( 0 : CAVLC, 1 : CABAC ) */
- int in_symbolmode;
- /* [IN] (0: only 4x4 transform, 1: allow using 8x8 transform) */
- int in_transform8x8_mode;
-
- /* [IN] Inter weighted parameter for mode decision */
- int in_md_interweight_pps;
- /* [IN] Intra weighted parameter for mode decision */
- int in_md_intraweight_pps;
-};
-
-struct mfc_enc_init_arg {
- struct mfc_enc_init_common_arg cmn;
- union {
- struct mfc_enc_init_h264_arg h264;
- struct mfc_enc_init_mpeg4_arg mpeg4;
- struct mfc_enc_init_h263_arg h263;
- } codec;
-};
-
-struct mfc_enc_exe_arg {
- 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 */
- unsigned 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_Y_addr; /*[OUT]Out-buffer addr of encoded Y component */
- unsigned int out_CbCr_addr; /*[OUT]Out-buffer addr of encoded CbCr component */
- unsigned int out_frametag_top; /* [OUT] unique frame ID of an output frame or top field */
- unsigned int out_frametag_bottom;/* [OUT] unique frame ID of bottom field */
-
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int out_y_secure_id;
- unsigned int out_c_secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int out_y_cookie;
- unsigned int out_c_cookie;
-#endif
-};
-
-struct mfc_dec_init_arg {
- SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN] codec type */
- int in_strm_buf; /* [IN] address of stream buffer */
- int in_strm_size; /* [IN] filled size in stream buffer */
- int in_packed_PB; /* [IN] Is packed PB frame or not, 1: packedPB 0: unpacked */
-
- unsigned int in_crc; /* [IN] */
- unsigned int in_pixelcache; /* [IN] */
- unsigned int in_slice; /* [IN] */
- unsigned int in_numextradpb; /* [IN] */
-
- unsigned int in_mapped_addr;
-
- int out_frm_width; /* [OUT] width of YUV420 frame */
- int out_frm_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_right_offset; /* [OUT] crop information for h264 */
- int out_crop_left_offset;
- int out_crop_bottom_offset;
- int out_crop_top_offset;
-};
-
-struct mfc_dec_exe_arg {
- SSBSIP_MFC_CODEC_TYPE in_codec_type; /* [IN] codec type */
- int in_strm_buf; /* [IN] the physical address of STRM_BUF */
- /* [IN] Size of video stream filled in STRM_BUF */
- int in_strm_size;
- /* [IN] the address of dpb FRAME_BUF */
- struct mfc_frame_buf_arg in_frm_buf;
- /* [IN] size of dpb FRAME_BUF */
- struct mfc_frame_buf_arg in_frm_size;
- /* [IN] Unique frame ID eg. application specific timestamp */
- unsigned int in_frametag;
- /* [IN] immdiate Display for seek,thumbnail and one frame */
- int in_immediately_disp;
- /* [OUT] the physical address of display buf */
- int out_display_Y_addr;
- /* [OUT] the physical address of display buf */
- int out_display_C_addr;
- int out_display_status;
- /* [OUT] unique frame ID of an output frame or top field */
- unsigned int out_frametag_top;
- /* [OUT] unique frame ID of bottom field */
- unsigned int out_frametag_bottom;
- int out_pic_time_top;
- int out_pic_time_bottom;
- int out_consumed_byte;
-
- int out_crop_right_offset;
- int out_crop_left_offset;
- int out_crop_bottom_offset;
- int out_crop_top_offset;
-
- /* in new driver, each buffer offset must be return to the user */
- int out_y_offset;
- int out_c_offset;
-
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int out_y_secure_id;
- unsigned int out_c_secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int out_y_cookie;
- unsigned int out_c_cookie;
-#endif
- 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_disp_pic_frame_type; /* [OUT] display picture frame type information */
-};
-
-struct mfc_get_config_arg {
- /* [IN] Configurable parameter type */
- int in_config_param;
-
- /* [IN] Values to get for the configurable parameter. */
- /* Maximum four integer values can be obtained; */
- int out_config_value[4];
-};
-
-struct mfc_set_config_arg {
- /* [IN] Configurable parameter type */
- int in_config_param;
-
- /* [IN] Values to be set for the configurable parameter. */
- /* Maximum four integer values can be set. */
- int in_config_value[4];
-};
-
-struct mfc_get_real_addr_arg {
- unsigned int key;
- unsigned int addr;
-};
-
-struct mfc_buf_alloc_arg {
- enum inst_type type;
- int size;
- /*
- unsigned int mapped;
- */
- unsigned int align;
-
- unsigned int addr;
- /*
- unsigned int phys;
- */
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- /* FIMXE: invalid secure id == -1 */
- unsigned int secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int cookie;
-#else
- unsigned int offset;
-#endif
-};
-
-struct mfc_buf_free_arg {
- unsigned int addr;
-};
-
-/* RMVME */
-struct mfc_mem_alloc_arg {
- enum inst_type type;
- int buff_size;
- SSBIP_MFC_BUFFER_TYPE buf_cache_type;
- unsigned int mapped_addr;
-#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
- unsigned int secure_id;
-#elif defined(CONFIG_S5P_VMEM)
- unsigned int cookie;
-#else
- unsigned int offset;
-#endif
-};
-
-struct mfc_mem_free_arg {
- unsigned int key;
-};
-/* RMVME */
-
-union mfc_args {
- /*
- struct mfc_enc_init_arg enc_init;
-
- struct mfc_enc_init_mpeg4_arg enc_init_mpeg4;
- struct mfc_enc_init_mpeg4_arg enc_init_h263;
- struct mfc_enc_init_h264_arg enc_init_h264;
- */
- struct mfc_enc_init_arg enc_init;
- struct mfc_enc_exe_arg enc_exe;
-
- struct mfc_dec_init_arg dec_init;
- struct mfc_dec_exe_arg dec_exe;
-
- struct mfc_get_config_arg get_config;
- struct mfc_set_config_arg set_config;
-
- struct mfc_buf_alloc_arg buf_alloc;
- struct mfc_buf_free_arg buf_free;
- struct mfc_get_real_addr_arg real_addr;
-
- /* RMVME */
- struct mfc_mem_alloc_arg mem_alloc;
- struct mfc_mem_free_arg mem_free;
- /* RMVME */
-};
-
-struct mfc_common_args {
- enum mfc_ret_code ret_code; /* [OUT] error code */
- union mfc_args args;
-};
-
-struct mfc_enc_vui_info {
- int aspect_ratio_idc;
-};
-
-struct mfc_dec_fimv1_info {
- int width;
- int height;
-};
-
-struct mfc_enc_hier_p_qp {
- int t0_frame_qp;
- int t2_frame_qp;
- int t3_frame_qp;
-};
-
-#ifdef S3D_SUPPORT
-struct mfc_enc_sei_info {
- int sei_gen_enable;
- int curr_frame_frm0_flag;
- int frame_pack_arrgment_type;
-};
-#endif
-
-struct mfc_enc_fmo {
- unsigned int slice_map_type;
- unsigned int slice_num_grp;
- unsigned int run_length[4];
- unsigned int sg_dir;
- unsigned int sg_rate;
-};
-
-enum BUF_STATUS {
- BUF_ENQUEUED,
- BUF_DEQUEUED
-};
-
-struct mfc_dec_v4l2 {
- char *mfc_src_bufs[MFC_DEC_NUM_SRC_BUFS]; /* information of source buffers */
- char *mfc_dst_bufs[MFC_DEC_MAX_DST_BUFS][MFC_DEC_NUM_PLANES]; /* information of destination buffers */
- char *mfc_dst_phys[MFC_DEC_MAX_DST_BUFS][MFC_DEC_NUM_PLANES]; /* cma information of destination buffers */
-
- unsigned int mfc_src_bufs_len; /* needed for munmap */
- unsigned int mfc_dst_bufs_len[MFC_DEC_NUM_PLANES]; /* needed for munmap */
-
- unsigned int mfc_num_src_bufs; /* the number of source buffers */
- unsigned int mfc_num_dst_bufs; /* the number of destination buffers */
-
- char mfc_src_buf_flags[MFC_DEC_NUM_SRC_BUFS];
- int bBeingFinalized;
- int allocIndex;
- int beingUsedIndex;
-};
-
-struct mfc_enc_v4l2 {
- char *mfc_src_bufs[MFC_ENC_NUM_SRC_BUFS][MFC_ENC_NUM_PLANES];
- char *mfc_src_phys[MFC_ENC_NUM_SRC_BUFS][MFC_ENC_NUM_PLANES];
- char *mfc_dst_bufs[MFC_ENC_MAX_DST_BUFS];
-
- unsigned int mfc_src_bufs_len[MFC_ENC_NUM_PLANES];
- unsigned int mfc_dst_bufs_len;
-
- unsigned int mfc_num_src_bufs;
- unsigned int mfc_num_dst_bufs;
-
- unsigned int mfc_dst_bufs_bytes_used_len;
- char mfc_src_buf_flags[MFC_ENC_NUM_SRC_BUFS];
- int bRunning;
- int bInputPhyVir; /* Flag to use MFC src as physical or virtual 0: virtual 1: physical */
- int beingUsedIndex;
-};
-
-typedef struct {
- int magic;
- int hMFC;
- int hVMEM;
- int width;
- int height;
- int sizeStrmBuf;
- struct mfc_frame_buf_arg sizeFrmBuf;
- int displayStatus;
- int inter_buff_status;
- unsigned int virFreeStrmAddr;
- unsigned int phyStrmBuf;
- unsigned int virStrmBuf;
- unsigned int virMvRefYC;
- struct mfc_frame_buf_arg phyFrmBuf;
- struct mfc_frame_buf_arg virFrmBuf;
- unsigned int mapped_addr;
- unsigned int mapped_size;
- struct mfc_common_args MfcArg;
- SSBSIP_MFC_CODEC_TYPE codecType;
- SSBSIP_MFC_DEC_OUTPUT_INFO decOutInfo;
- unsigned int inframetag;
- unsigned int outframetagtop;
- unsigned int outframetagbottom;
- unsigned int immediatelydisp;
- unsigned int encodedHeaderSize;
- int encodedDataSize;
- unsigned int encodedframeType;
- struct mfc_frame_buf_arg encodedphyFrmBuf;
-
- unsigned int dec_crc;
- unsigned int dec_pixelcache;
- unsigned int dec_slice;
- unsigned int dec_numextradpb;
-
- int input_cookie;
- int input_secure_id;
- int input_size;
-
- /* to support non-blocking mode */
- unsigned int encode_cnt;
-
- struct mfc_dec_v4l2 v4l2_dec;
- struct mfc_enc_v4l2 v4l2_enc;
-
- int enc_frameskip;
- int cacheablebuffer;
- struct mfc_dec_fimv1_info fimv1_res;
- SSBSIP_MFC_LAST_FRAME_STATUS lastframe;
- SSBSIP_MFC_INSTRM_MODE_TYPE framemap;
-
- int hier_p_enable;
- struct mfc_enc_hier_p_qp hier_qp_value;
-#ifdef S3D_SUPPORT
- struct mfc_enc_sei_info sei_info;
-#endif
- int fmo_enable;
- struct mfc_enc_fmo fmo_value;
- int aso_enable;
- int aso_sl_order[8];
-
-
- /*ION related*/
- int ion_fd;
- int dst_ion_fd[MFC_DEC_MAX_DST_BUFS][MFC_DEC_NUM_PLANES];
-} _MFCLIB;
-
-#define ENC_PROFILE_LEVEL(profile, level) ((profile) | ((level) << 8))
-#define ENC_RC_QBOUND(min_qp, max_qp) ((min_qp) | ((max_qp) << 8))
-
-#define SSBSIP_MFC_FAIL (0)
-
-#endif /* __MFC_INTERFACE_H */
diff --git a/exynos4/multimedia/libs/Android.mk b/exynos4/multimedia/libs/Android.mk
deleted file mode 100644
index 55ca333..0000000
--- a/exynos4/multimedia/libs/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-include $(all-subdir-makefiles)
\ No newline at end of file
diff --git a/exynos4/multimedia/libs/libcsc/Android.mk b/exynos4/multimedia/libs/libcsc/Android.mk
deleted file mode 100644
index 6f3f753..0000000
--- a/exynos4/multimedia/libs/libcsc/Android.mk
+++ /dev/null
@@ -1,64 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_COPY_HEADERS_TO := libsecmm
-LOCAL_COPY_HEADERS := \
- csc.h
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- csc.c
-
-ifeq ($(BOARD_USE_EXYNOS_OMX), true)
-OMX_NAME := exynos
-else
-OMX_NAME := sec
-endif
-
-LOCAL_C_INCLUDES := \
- $(TOP)/$(BOARD_HMM_PATH)/openmax/$(OMX_NAME)_omx/include/khronos \
- $(TOP)/$(BOARD_HMM_PATH)/openmax/$(OMX_NAME)_omx/include/$(OMX_NAME)
-
-LOCAL_CFLAGS :=
-
-LOCAL_MODULE := libcsc
-
-LOCAL_PRELINK_MODULE := false
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libswconverter
-LOCAL_SHARED_LIBRARIES := liblog
-
-ifeq ($(BOARD_USE_SAMSUNG_COLORFORMAT), true)
-LOCAL_CFLAGS += -DUSE_SAMSUNG_COLORFORMAT
-endif
-
-ifeq ($(TARGET_BOARD_PLATFORM), exynos4)
-LOCAL_SRC_FILES += hwconverter_wrapper.cpp
-LOCAL_C_INCLUDES += $(TOP)/$(BOARD_HMM_PATH)/utils/csc/exynos4 \
- $(TOP)/$(BOARD_HAL_PATH)/include \
- $(TOP)/$(BOARD_HAL_PATH)/libhwconverter
-LOCAL_CFLAGS += -DUSE_FIMC
-LOCAL_SHARED_LIBRARIES += libfimc libhwconverter
-endif
-
-ifeq ($(TARGET_BOARD_PLATFORM), exynos5)
-LOCAL_C_INCLUDES += $(TOP)/$(BOARD_HMM_PATH)/utils/csc/exynos5 \
- $(TOP)/device/samsung/exynos5/include
-LOCAL_CFLAGS += -DUSE_GSCALER
-LOCAL_SHARED_LIBRARIES += libexynosgscaler
-endif
-
-ifeq ($(BOARD_USE_V4L2_ION),true)
-LOCAL_CFLAGS += -DUSE_ION
-LOCAL_SHARED_LIBRARIES += libion
-endif
-
-ifeq ($(BOARD_USE_EXYNOS_OMX), true)
-LOCAL_CFLAGS += -DEXYNOS_OMX
-endif
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/libs/libcsc/csc.c b/exynos4/multimedia/libs/libcsc/csc.c
deleted file mode 100644
index 19bd203..0000000
--- a/exynos4/multimedia/libs/libcsc/csc.c
+++ /dev/null
@@ -1,740 +0,0 @@
-/*
- *
- * Copyright 2012 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.c
- *
- * @brief color space convertion abstract source
- *
- * @author Pyoungjae Jung(pjet.jung@samsung.com)
- *
- * @version 1.0.0
- *
- * @history
- * 2012.1.11 : Create
- */
-#define LOG_TAG "libcsc"
-#include <cutils/log.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <utils/Log.h>
-
-#include "csc.h"
-#include "sec_format.h"
-#include "sec_utils_v4l2.h"
-#include "swconverter.h"
-
-#ifdef EXYNOS_OMX
-#include "Exynos_OMX_Def.h"
-#else
-#include "SEC_OMX_Def.h"
-#endif
-
-#ifdef USE_FIMC
-#include "hwconverter_wrapper.h"
-#endif
-
-#ifdef USE_GSCALER
-#include "exynos_gscaler.h"
-#endif
-
-#define GSCALER_IMG_ALIGN 16
-#define CSC_MAX_PLANES 3
-#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
-
-typedef enum _CSC_PLANE {
- CSC_Y_PLANE = 0,
- CSC_RGB_PLANE = 0,
- CSC_U_PLANE = 1,
- CSC_UV_PLANE = 1,
- CSC_V_PLANE = 2
-} CSC_PLANE;
-
-typedef enum _CSC_HW_TYPE {
- CSC_HW_TYPE_FIMC = 0,
- CSC_HW_TYPE_GSCALER
-} CSC_HW_TYPE;
-
-typedef struct _CSC_FORMAT {
- unsigned int width;
- unsigned int height;
- unsigned int crop_left;
- unsigned int crop_top;
- unsigned int crop_width;
- unsigned int crop_height;
- unsigned int color_format;
- unsigned int cacheable;
-} CSC_FORMAT;
-
-typedef struct _CSC_BUFFER {
- unsigned char *planes[CSC_MAX_PLANES];
- int ion_fd;
-} CSC_BUFFER;
-
-typedef struct _CSC_HANDLE {
- CSC_FORMAT dst_format;
- CSC_FORMAT src_format;
- CSC_BUFFER dst_buffer;
- CSC_BUFFER src_buffer;
- CSC_METHOD csc_method;
- CSC_HW_TYPE csc_hw_type;
- void *csc_hw_handle;
-} CSC_HANDLE;
-
-OMX_COLOR_FORMATTYPE hal_2_omx_pixel_format(
- unsigned int hal_format)
-{
- OMX_COLOR_FORMATTYPE omx_format;
- switch (hal_format) {
- case HAL_PIXEL_FORMAT_YCbCr_420_P:
- omx_format = OMX_COLOR_FormatYUV420Planar;
- break;
- case HAL_PIXEL_FORMAT_YCbCr_420_SP:
- omx_format = OMX_COLOR_FormatYUV420SemiPlanar;
- break;
- case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
- omx_format = OMX_SEC_COLOR_FormatNV12Tiled;
- break;
- case HAL_PIXEL_FORMAT_ARGB888:
- omx_format = OMX_COLOR_Format32bitARGB8888;
- break;
- default:
- omx_format = OMX_COLOR_FormatYUV420Planar;
- break;
- }
- return omx_format;
-}
-
-unsigned int omx_2_hal_pixel_format(
- OMX_COLOR_FORMATTYPE omx_format)
-{
- unsigned int hal_format;
- switch (omx_format) {
- case OMX_COLOR_FormatYUV420Planar:
- hal_format = HAL_PIXEL_FORMAT_YCbCr_420_P;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- hal_format = HAL_PIXEL_FORMAT_YCbCr_420_SP;
- break;
- case OMX_SEC_COLOR_FormatNV12Tiled:
- hal_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED;
- break;
- case OMX_COLOR_Format32bitARGB8888:
- hal_format = HAL_PIXEL_FORMAT_ARGB888;
- break;
- default:
- hal_format = HAL_PIXEL_FORMAT_YCbCr_420_P;
- break;
- }
- return hal_format;
-}
-
-/* source is RGB888 */
-static CSC_ERRORCODE conv_sw_src_argb888(
- CSC_HANDLE *handle)
-{
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- switch (handle->dst_format.color_format) {
- case HAL_PIXEL_FORMAT_YCbCr_420_P:
- csc_ARGB8888_to_YUV420P(
- (unsigned char *)handle->dst_buffer.planes[CSC_Y_PLANE],
- (unsigned char *)handle->dst_buffer.planes[CSC_U_PLANE],
- (unsigned char *)handle->dst_buffer.planes[CSC_V_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_RGB_PLANE],
- handle->src_format.width,
- handle->src_format.height);
- ret = CSC_ErrorNone;
- break;
- case HAL_PIXEL_FORMAT_YCbCr_420_SP:
- csc_ARGB8888_to_YUV420SP(
- (unsigned char *)handle->dst_buffer.planes[CSC_Y_PLANE],
- (unsigned char *)handle->dst_buffer.planes[CSC_UV_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_RGB_PLANE],
- handle->src_format.width,
- handle->src_format.height);
- ret = CSC_ErrorNone;
- break;
- default:
- ret = CSC_ErrorUnsupportFormat;
- break;
- }
-
- return ret;
-}
-
-/* source is NV12T */
-static CSC_ERRORCODE conv_sw_src_nv12t(
- CSC_HANDLE *handle)
-{
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- switch (handle->dst_format.color_format) {
- case HAL_PIXEL_FORMAT_YCbCr_420_P:
- csc_tiled_to_linear_y_neon(
- (unsigned char *)handle->dst_buffer.planes[CSC_Y_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_Y_PLANE],
- handle->src_format.width,
- handle->src_format.height);
- csc_tiled_to_linear_uv_deinterleave_neon(
- (unsigned char *)handle->dst_buffer.planes[CSC_U_PLANE],
- (unsigned char *)handle->dst_buffer.planes[CSC_V_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_UV_PLANE],
- handle->src_format.width,
- handle->src_format.height / 2);
- ret = CSC_ErrorNone;
- break;
- case HAL_PIXEL_FORMAT_YCbCr_420_SP:
- csc_tiled_to_linear_y_neon(
- (unsigned char *)handle->dst_buffer.planes[CSC_Y_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_Y_PLANE],
- handle->src_format.width,
- handle->src_format.height);
- csc_tiled_to_linear_uv_neon(
- (unsigned char *)handle->dst_buffer.planes[CSC_UV_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_UV_PLANE],
- handle->src_format.width,
- handle->src_format.height / 2);
- ret = CSC_ErrorNone;
- break;
- default:
- ret = CSC_ErrorUnsupportFormat;
- break;
- }
-
- return ret;
-}
-
-/* source is YUV420P */
-static CSC_ERRORCODE conv_sw_src_yuv420p(
- CSC_HANDLE *handle)
-{
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- switch (handle->dst_format.color_format) {
- case HAL_PIXEL_FORMAT_YCbCr_420_P: /* bypass */
- memcpy((unsigned char *)handle->dst_buffer.planes[CSC_Y_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_Y_PLANE],
- handle->src_format.width * handle->src_format.height);
- memcpy((unsigned char *)handle->dst_buffer.planes[CSC_U_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_U_PLANE],
- (handle->src_format.width * handle->src_format.height) >> 2);
- memcpy((unsigned char *)handle->dst_buffer.planes[CSC_V_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_V_PLANE],
- (handle->src_format.width * handle->src_format.height) >> 2);
- ret = CSC_ErrorNone;
- break;
- case HAL_PIXEL_FORMAT_YCbCr_420_SP:
- memcpy((unsigned char *)handle->dst_buffer.planes[CSC_Y_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_Y_PLANE],
- handle->src_format.width * handle->src_format.height);
- csc_interleave_memcpy_neon(
- (unsigned char *)handle->dst_buffer.planes[CSC_UV_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_U_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_V_PLANE],
- (handle->src_format.width * handle->src_format.height) >> 2);
- ret = CSC_ErrorNone;
- break;
- default:
- ret = CSC_ErrorUnsupportFormat;
- break;
- }
-
- return ret;
-}
-
-/* source is YUV420SP */
-static CSC_ERRORCODE conv_sw_src_yuv420sp(
- CSC_HANDLE *handle)
-{
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- switch (handle->dst_format.color_format) {
- case HAL_PIXEL_FORMAT_YCbCr_420_P:
- memcpy((unsigned char *)handle->dst_buffer.planes[CSC_Y_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_Y_PLANE],
- handle->src_format.width * handle->src_format.height);
- csc_deinterleave_memcpy(
- (unsigned char *)handle->dst_buffer.planes[CSC_U_PLANE],
- (unsigned char *)handle->dst_buffer.planes[CSC_V_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_UV_PLANE],
- handle->src_format.width * handle->src_format.height >> 1);
- ret = CSC_ErrorNone;
- break;
- case HAL_PIXEL_FORMAT_YCbCr_420_SP: /* bypass */
- memcpy((unsigned char *)handle->dst_buffer.planes[CSC_Y_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_Y_PLANE],
- handle->src_format.width * handle->src_format.height);
- memcpy((unsigned char *)handle->dst_buffer.planes[CSC_UV_PLANE],
- (unsigned char *)handle->src_buffer.planes[CSC_UV_PLANE],
- handle->src_format.width * handle->src_format.height >> 1);
- ret = CSC_ErrorNone;
- break;
- default:
- ret = CSC_ErrorUnsupportFormat;
- break;
- }
-
- return ret;
-}
-
-static CSC_ERRORCODE conv_sw(
- CSC_HANDLE *handle)
-{
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- switch (handle->src_format.color_format) {
- case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
- ret = conv_sw_src_nv12t(handle);
- break;
- case HAL_PIXEL_FORMAT_YCbCr_420_P:
- ret = conv_sw_src_yuv420p(handle);
- break;
- case HAL_PIXEL_FORMAT_YCbCr_420_SP:
- ret = conv_sw_src_yuv420sp(handle);
- break;
- case HAL_PIXEL_FORMAT_ARGB888:
- ret = conv_sw_src_argb888(handle);
- break;
- default:
- ret = CSC_ErrorUnsupportFormat;
- break;
- }
-
- return ret;
-}
-
-static CSC_ERRORCODE conv_hw(
- CSC_HANDLE *handle)
-{
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- switch (handle->csc_hw_type) {
-#ifdef USE_FIMC
- case CSC_HW_TYPE_FIMC:
- {
- void *src_addr[3];
- void *dst_addr[3];
- OMX_COLOR_FORMATTYPE omx_format;
- src_addr[0] = handle->src_buffer.planes[CSC_Y_PLANE];
- src_addr[1] = handle->src_buffer.planes[CSC_UV_PLANE];
- dst_addr[0] = handle->dst_buffer.planes[CSC_Y_PLANE];
- dst_addr[1] = handle->dst_buffer.planes[CSC_U_PLANE];
- dst_addr[2] = handle->dst_buffer.planes[CSC_V_PLANE];
- omx_format = hal_2_omx_pixel_format(handle->dst_format.color_format);
- csc_hwconverter_convert_nv12t(
- handle->csc_hw_handle,
- dst_addr,
- src_addr,
- handle->dst_format.width,
- handle->dst_format.height,
- omx_format);
- break;
- }
-#endif
-#ifdef USE_GSCALER
- case CSC_HW_TYPE_GSCALER:
- exynos_gsc_convert(handle->csc_hw_handle);
- break;
-#endif
- default:
- LOGE("%s:: unsupported csc_hw_type", __func__);
- break;
- }
-
- return CSC_ErrorNotImplemented;
-}
-
-void *csc_init(
- CSC_METHOD *method)
-{
- CSC_HANDLE *csc_handle;
- csc_handle = (CSC_HANDLE *)malloc(sizeof(CSC_HANDLE));
- if (csc_handle == NULL)
- return NULL;
-
- memset(csc_handle, 0, sizeof(CSC_HANDLE));
-
- csc_handle->csc_method = *method;
-
- if (csc_handle->csc_method == CSC_METHOD_HW ||
- csc_handle->csc_method == CSC_METHOD_PREFER_HW) {
-#ifdef USE_FIMC
- csc_handle->csc_hw_type = CSC_HW_TYPE_FIMC;
-#endif
-#ifdef USE_GSCALER
- csc_handle->csc_hw_type = CSC_HW_TYPE_GSCALER;
-#endif
- switch (csc_handle->csc_hw_type) {
-#ifdef USE_FIMC
- case CSC_HW_TYPE_FIMC:
- csc_handle->csc_hw_handle = csc_hwconverter_open();
- LOGD("%s:: CSC_HW_TYPE_FIMC", __func__);
- break;
-#endif
-#ifdef USE_GSCALER
- case CSC_HW_TYPE_GSCALER:
- csc_handle->csc_hw_handle = exynos_gsc_create();
- LOGD("%s:: CSC_HW_TYPE_GSCALER", __func__);
- break;
-#endif
- default:
- LOGE("%s:: unsupported csc_hw_type, csc use sw", __func__);
- csc_handle->csc_hw_handle == NULL;
- break;
- }
- }
-
- if (csc_handle->csc_method == CSC_METHOD_PREFER_HW) {
- if (csc_handle->csc_hw_handle == NULL) {
- csc_handle->csc_method = CSC_METHOD_SW;
- *method = CSC_METHOD_SW;
- } else {
- csc_handle->csc_method = CSC_METHOD_HW;
- *method = CSC_METHOD_HW;
- }
- }
-
- if (csc_handle->csc_method == CSC_METHOD_HW) {
- if (csc_handle->csc_hw_handle == NULL) {
- LOGE("%s:: CSC_METHOD_HW can't open HW", __func__);
- free(csc_handle);
- csc_handle = NULL;
- }
- }
-
- LOGD("%s:: CSC_METHOD=%d", __func__, csc_handle->csc_method);
-
- return (void *)csc_handle;
-}
-
-CSC_ERRORCODE csc_deinit(
- void *handle)
-{
- CSC_ERRORCODE ret = CSC_ErrorNone;
- CSC_HANDLE *csc_handle;
-
- csc_handle = (CSC_HANDLE *)handle;
- if (csc_handle->csc_method == CSC_METHOD_HW) {
- switch (csc_handle->csc_hw_type) {
-#ifdef USE_FIMC
- case CSC_HW_TYPE_FIMC:
- csc_hwconverter_close(csc_handle->csc_hw_handle);
- break;
-#endif
-#ifdef USE_GSCALER
- case CSC_HW_TYPE_GSCALER:
- exynos_gsc_destroy(csc_handle->csc_hw_handle);
- break;
-#endif
- default:
- LOGE("%s:: unsupported csc_hw_type", __func__);
- break;
- }
- }
-
- if (csc_handle != NULL) {
- free(csc_handle);
- ret = CSC_ErrorNone;
- }
-
- return ret;
-}
-
-CSC_ERRORCODE csc_get_method(
- void *handle,
- CSC_METHOD *method)
-{
- CSC_HANDLE *csc_handle;
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- if (handle == NULL)
- return CSC_ErrorNotInit;
-
- csc_handle = (CSC_HANDLE *)handle;
- *method = csc_handle->csc_method;
-
- return ret;
-}
-
-CSC_ERRORCODE csc_get_src_format(
- void *handle,
- unsigned int *width,
- unsigned int *height,
- unsigned int *crop_left,
- unsigned int *crop_top,
- unsigned int *crop_width,
- unsigned int *crop_height,
- unsigned int *color_format,
- unsigned int *cacheable)
-{
- CSC_HANDLE *csc_handle;
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- if (handle == NULL)
- return CSC_ErrorNotInit;
-
- csc_handle = (CSC_HANDLE *)handle;
- *width = csc_handle->src_format.width;
- *height = csc_handle->src_format.height;
- *crop_left = csc_handle->src_format.crop_left;
- *crop_top = csc_handle->src_format.crop_top;
- *crop_width = csc_handle->src_format.crop_width;
- *crop_height = csc_handle->src_format.crop_height;
- *color_format = csc_handle->src_format.color_format;
- *cacheable = csc_handle->src_format.cacheable;
-
- return ret;
-}
-
-CSC_ERRORCODE csc_set_src_format(
- void *handle,
- unsigned int width,
- unsigned int height,
- unsigned int crop_left,
- unsigned int crop_top,
- unsigned int crop_width,
- unsigned int crop_height,
- unsigned int color_format,
- unsigned int cacheable)
-{
- CSC_HANDLE *csc_handle;
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- if (handle == NULL)
- return CSC_ErrorNotInit;
-
- csc_handle = (CSC_HANDLE *)handle;
- csc_handle->src_format.width = width;
- csc_handle->src_format.height = height;
- csc_handle->src_format.crop_left = crop_left;
- csc_handle->src_format.crop_top = crop_top;
- csc_handle->src_format.crop_width = crop_width;
- csc_handle->src_format.crop_height = crop_height;
- csc_handle->src_format.color_format = color_format;
- csc_handle->src_format.cacheable = cacheable;
-
- if (csc_handle->csc_method == CSC_METHOD_HW) {
- switch (csc_handle->csc_hw_type) {
- case CSC_HW_TYPE_FIMC:
- break;
-#ifdef USE_GSCALER
- case CSC_HW_TYPE_GSCALER:
- exynos_gsc_set_src_format(
- csc_handle->csc_hw_handle,
- ALIGN(csc_handle->src_format.width, GSCALER_IMG_ALIGN),
- ALIGN(csc_handle->src_format.height, GSCALER_IMG_ALIGN),
- csc_handle->src_format.crop_left,
- csc_handle->src_format.crop_top,
- ALIGN(csc_handle->src_format.crop_width, GSCALER_IMG_ALIGN),
- ALIGN(csc_handle->src_format.crop_height, GSCALER_IMG_ALIGN),
- HAL_PIXEL_FORMAT_2_V4L2_PIX(csc_handle->src_format.color_format),
- csc_handle->src_format.cacheable);
- break;
-#endif
- default:
- LOGE("%s:: unsupported csc_hw_type", __func__);
- break;
- }
- }
-
- return ret;
-}
-
-CSC_ERRORCODE csc_get_dst_format(
- void *handle,
- unsigned int *width,
- unsigned int *height,
- unsigned int *crop_left,
- unsigned int *crop_top,
- unsigned int *crop_width,
- unsigned int *crop_height,
- unsigned int *color_format,
- unsigned int *cacheable)
-{
- CSC_HANDLE *csc_handle;
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- if (handle == NULL)
- return CSC_ErrorNotInit;
-
- csc_handle = (CSC_HANDLE *)handle;
- *width = csc_handle->dst_format.width;
- *height = csc_handle->dst_format.height;
- *crop_left = csc_handle->dst_format.crop_left;
- *crop_top = csc_handle->dst_format.crop_top;
- *crop_width = csc_handle->dst_format.crop_width;
- *crop_height = csc_handle->dst_format.crop_height;
- *color_format = csc_handle->dst_format.color_format;
- *cacheable = csc_handle->dst_format.cacheable;
-
- return ret;
-}
-
-CSC_ERRORCODE csc_set_dst_format(
- void *handle,
- unsigned int width,
- unsigned int height,
- unsigned int crop_left,
- unsigned int crop_top,
- unsigned int crop_width,
- unsigned int crop_height,
- unsigned int color_format,
- unsigned int cacheable)
-{
- CSC_HANDLE *csc_handle;
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- if (handle == NULL)
- return CSC_ErrorNotInit;
-
- csc_handle = (CSC_HANDLE *)handle;
- csc_handle->dst_format.width = width;
- csc_handle->dst_format.height = height;
- csc_handle->dst_format.crop_left = crop_left;
- csc_handle->dst_format.crop_top = crop_top;
- csc_handle->dst_format.crop_width = crop_width;
- csc_handle->dst_format.crop_height = crop_height;
- csc_handle->dst_format.color_format = color_format;
- csc_handle->dst_format.cacheable = cacheable;
-
- if (csc_handle->csc_method == CSC_METHOD_HW) {
- switch (csc_handle->csc_hw_type) {
- case CSC_HW_TYPE_FIMC:
- break;
-#ifdef USE_GSCALER
- case CSC_HW_TYPE_GSCALER:
- exynos_gsc_set_dst_format(
- csc_handle->csc_hw_handle,
- ALIGN(csc_handle->dst_format.width, GSCALER_IMG_ALIGN),
- ALIGN(csc_handle->dst_format.height, GSCALER_IMG_ALIGN),
- csc_handle->dst_format.crop_left,
- csc_handle->dst_format.crop_top,
- ALIGN(csc_handle->dst_format.crop_width, GSCALER_IMG_ALIGN),
- ALIGN(csc_handle->dst_format.crop_height, GSCALER_IMG_ALIGN),
- HAL_PIXEL_FORMAT_2_V4L2_PIX(csc_handle->dst_format.color_format),
- csc_handle->dst_format.cacheable);
- break;
-#endif
- default:
- LOGE("%s:: unsupported csc_hw_type", __func__);
- break;
- }
- }
-
- return ret;
-}
-
-CSC_ERRORCODE csc_set_src_buffer(
- void *handle,
- unsigned char *y,
- unsigned char *u,
- unsigned char *v,
- int ion_fd)
-{
- CSC_HANDLE *csc_handle;
- CSC_ERRORCODE ret = CSC_ErrorNone;
- void *addr[3] = {NULL, };
-
- if (handle == NULL)
- return CSC_ErrorNotInit;
-
- csc_handle = (CSC_HANDLE *)handle;
- csc_handle->src_buffer.planes[CSC_Y_PLANE] = y;
- csc_handle->src_buffer.planes[CSC_U_PLANE] = u;
- csc_handle->src_buffer.planes[CSC_V_PLANE] = v;
-
- if (csc_handle->csc_method == CSC_METHOD_HW) {
- addr[0] = csc_handle->src_buffer.planes[CSC_Y_PLANE];
- addr[1] = csc_handle->src_buffer.planes[CSC_U_PLANE];
- addr[2] = csc_handle->src_buffer.planes[CSC_V_PLANE];
-
- switch (csc_handle->csc_hw_type) {
- case CSC_HW_TYPE_FIMC:
- break;
-#ifdef USE_GSCALER
- case CSC_HW_TYPE_GSCALER:
- exynos_gsc_set_src_addr(csc_handle->csc_hw_handle, addr);
- break;
-#endif
- default:
- LOGE("%s:: unsupported csc_hw_type", __func__);
- break;
- }
- }
-
- return ret;
-}
-
-CSC_ERRORCODE csc_set_dst_buffer(
- void *handle,
- unsigned char *y,
- unsigned char *u,
- unsigned char *v,
- int ion_fd)
-{
- CSC_HANDLE *csc_handle;
- CSC_ERRORCODE ret = CSC_ErrorNone;
- void *addr[3] = {NULL, };
-
- if (handle == NULL)
- return CSC_ErrorNotInit;
-
- csc_handle = (CSC_HANDLE *)handle;
- csc_handle->dst_buffer.planes[CSC_Y_PLANE] = y;
- csc_handle->dst_buffer.planes[CSC_U_PLANE] = u;
- csc_handle->dst_buffer.planes[CSC_V_PLANE] = v;
-
- if (csc_handle->csc_method == CSC_METHOD_HW) {
- addr[0] = csc_handle->dst_buffer.planes[CSC_Y_PLANE];
- addr[1] = csc_handle->dst_buffer.planes[CSC_U_PLANE];
- addr[2] = csc_handle->dst_buffer.planes[CSC_V_PLANE];
-
- switch (csc_handle->csc_hw_type) {
- case CSC_HW_TYPE_FIMC:
- break;
-#ifdef USE_GSCALER
- case CSC_HW_TYPE_GSCALER:
- exynos_gsc_set_dst_addr(csc_handle->csc_hw_handle, addr);
- break;
-#endif
- default:
- LOGE("%s:: unsupported csc_hw_type", __func__);
- break;
- }
- }
-
- return ret;
-}
-
-CSC_ERRORCODE csc_convert(
- void *handle)
-{
- CSC_HANDLE *csc_handle = (CSC_HANDLE *)handle;
- CSC_ERRORCODE ret = CSC_ErrorNone;
-
- if (csc_handle == NULL)
- return CSC_ErrorNotInit;
-
- if (csc_handle->csc_method == CSC_METHOD_HW)
- ret = conv_hw(csc_handle);
- else
- ret = conv_sw(csc_handle);
-
- return ret;
-}
diff --git a/exynos4/multimedia/libs/libcsc/csc.h b/exynos4/multimedia/libs/libcsc/csc.h
deleted file mode 100644
index 9069392..0000000
--- a/exynos4/multimedia/libs/libcsc/csc.h
+++ /dev/null
@@ -1,355 +0,0 @@
-/*
- * 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.
- */
-
-/*
- * @file csc.h
- *
- * @brief color space convertion abstract header
- *
- * @author Pyoungjae Jung (pjet.jung@samsung.com)
- *
- * @version 1.0
- *
- * @history
- * 2011.12.27 : Create
- */
-
-#ifndef CSC_H
-#define CSC_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum _CSC_ERRORCODE {
- CSC_ErrorNone = 0,
- CSC_Error,
- CSC_ErrorNotInit,
- CSC_ErrorInvalidAddress,
- CSC_ErrorUnsupportFormat,
- CSC_ErrorNotImplemented
-} CSC_ERRORCODE;
-
-typedef enum _CSC_METHOD {
- CSC_METHOD_SW = 0,
- CSC_METHOD_HW,
- CSC_METHOD_PREFER_HW
-} CSC_METHOD;
-
-/*
- * change hal pixel format to omx pixel format
- *
- * @param hal_format
- * hal pixel format[in]
- *
- * @return
- * omx pixel format
- */
-unsigned int hal_2_omx_pixel_format(
- unsigned int hal_format);
-
-/*
- * change omx pixel format to hal pixel format
- *
- * @param hal_format
- * omx pixel format[in]
- *
- * @return
- * hal pixel format
- */
-unsigned int omx_2_hal_pixel_format(
- unsigned int omx_format);
-
-/*
- * Init CSC handle
- *
- * @return
- * csc handle
- */
-void *csc_init(
- CSC_METHOD *method);
-
-/*
- * Deinit CSC handle
- *
- * @param handle
- * CSC handle[in]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_deinit(
- void *handle);
-
-/*
- * get color space converter method
- *
- * @param handle
- * CSC handle[in]
- *
- * @param method
- * CSC method[out]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_get_method(
- void *handle,
- CSC_METHOD *method);
-
-/*
- * Get source format.
- *
- * @param handle
- * CSC handle[in]
- *
- * @param width
- * address of image width[out]
- *
- * @param height
- * address of image height[out]
- *
- * @param crop_left
- * address of image left crop size[out]
- *
- * @param crop_top
- * address of image top crop size[out]
- *
- * @param crop_width
- * address of cropped image width[out]
- *
- * @param crop_height
- * address of cropped image height[out]
- *
- * @param color_format
- * address of source color format(HAL format)[out]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_get_src_format(
- void *handle,
- unsigned int *width,
- unsigned int *height,
- unsigned int *crop_left,
- unsigned int *crop_top,
- unsigned int *crop_width,
- unsigned int *crop_height,
- unsigned int *color_format,
- unsigned int *cacheable);
-
-/*
- * Set source format.
- * Don't call each converting time.
- * Pls call this function as below.
- * 1. first converting time
- * 2. format is changed
- *
- * @param handle
- * CSC handle[in]
- *
- * @param width
- * image width[in]
- *
- * @param height
- * image height[in]
- *
- * @param crop_left
- * image left crop size[in]
- *
- * @param crop_top
- * image top crop size[in]
- *
- * @param crop_width
- * cropped image width[in]
- *
- * @param crop_height
- * cropped image height[in]
- *
- * @param color_format
- * source color format(HAL format)[in]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_set_src_format(
- void *handle,
- unsigned int width,
- unsigned int height,
- unsigned int crop_left,
- unsigned int crop_top,
- unsigned int crop_width,
- unsigned int crop_height,
- unsigned int color_format,
- unsigned int cacheable);
-
-/*
- * Get destination format.
- *
- * @param handle
- * CSC handle[in]
- *
- * @param width
- * address of image width[out]
- *
- * @param height
- * address of image height[out]
- *
- * @param crop_left
- * address of image left crop size[out]
- *
- * @param crop_top
- * address of image top crop size[out]
- *
- * @param crop_width
- * address of cropped image width[out]
- *
- * @param crop_height
- * address of cropped image height[out]
- *
- * @param color_format
- * address of color format(HAL format)[out]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_get_dst_format(
- void *handle,
- unsigned int *width,
- unsigned int *height,
- unsigned int *crop_left,
- unsigned int *crop_top,
- unsigned int *crop_width,
- unsigned int *crop_height,
- unsigned int *color_format,
- unsigned int *cacheable);
-
-/*
- * Set destination format
- * Don't call each converting time.
- * Pls call this function as below.
- * 1. first converting time
- * 2. format is changed
- *
- * @param handle
- * CSC handle[in]
- *
- * @param width
- * image width[in]
- *
- * @param height
- * image height[in]
- *
- * @param crop_left
- * image left crop size[in]
- *
- * @param crop_top
- * image top crop size[in]
- *
- * @param crop_width
- * cropped image width[in]
- *
- * @param crop_height
- * cropped image height[in]
- *
- * @param color_format
- * destination color format(HAL format)[in]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_set_dst_format(
- void *handle,
- unsigned int width,
- unsigned int height,
- unsigned int crop_left,
- unsigned int crop_top,
- unsigned int crop_width,
- unsigned int crop_height,
- unsigned int color_format,
- unsigned int cacheable);
-
-/*
- * Setup source buffer
- * set_format func should be called before this this func.
- *
- * @param handle
- * CSC handle[in]
- *
- * @param src_buffer
- * source buffer pointer array[in]
- *
- * @param y
- * y or RGB destination pointer[in]
- *
- * @param u
- * u or uv destination pointer[in]
- *
- * @param v
- * v or none destination pointer[in]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_set_src_buffer(
- void *handle,
- unsigned char *y,
- unsigned char *u,
- unsigned char *v,
- int ion_fd);
-
-/*
- * Setup destination buffer
- *
- * @param handle
- * CSC handle[in]
- *
- * @param y
- * y or RGB destination pointer[in]
- *
- * @param u
- * u or uv destination pointer[in]
- *
- * @param v
- * v or none destination pointer[in]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_set_dst_buffer(
- void *handle,
- unsigned char *y,
- unsigned char *u,
- unsigned char *v,
- int ion_fd);
-
-/*
- * Convert color space with presetup color format
- *
- * @param handle
- * CSC handle[in]
- *
- * @return
- * error code
- */
-CSC_ERRORCODE csc_convert(
- void *handle);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/exynos4/multimedia/libs/libcsc/hwconverter_wrapper.cpp b/exynos4/multimedia/libs/libcsc/hwconverter_wrapper.cpp
deleted file mode 100644
index 9f6cd07..0000000
--- a/exynos4/multimedia/libs/libcsc/hwconverter_wrapper.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * 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.
- */
-
-/*
- * @file hwconverter_wrapper.cpp
- *
- * @brief hwconverter_wrapper abstract libhwconverter and support c functions
- *
- * @author ShinWon Lee (shinwon.lee@samsung.com)
- *
- * @version 1.0
- *
- * @history
- * 2012.02.01 : Create
- */
-
-#include <utils/Log.h>
-#include <dlfcn.h>
-
-#include "SEC_OMX_Def.h"
-#include "hwconverter_wrapper.h"
-#include "HardwareConverter.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * create hwconverter handle
- *
- * @return
- * fimc handle
- */
-void *csc_hwconverter_open()
-{
- HardwareConverter *hw_converter = NULL;
-
- hw_converter = new HardwareConverter;
- if (hw_converter->bHWconvert_flag == 0) {
- delete hw_converter;
- hw_converter = NULL;
- LOGE("%s LINE = %d HardwareConverter failed", __func__, __LINE__);
- }
-
- return (void *)hw_converter;
-}
-
-/*
- * destroy hwconverter handle
- *
- * @param handle
- * fimc handle[in]
- *
- * @return
- * pass or fail
- */
-HWCONVERTER_ERROR_CODE csc_hwconverter_close(
- void *handle)
-{
- HardwareConverter *hw_converter = (HardwareConverter *)handle;
-
- if (hw_converter != NULL)
- delete hw_converter;
-
- return HWCONVERTER_RET_OK;
-}
-
-/*
- * convert color space nv12t to omxformat
- *
- * @param handle
- * hwconverter handle[in]
- *
- * @param dst_addr
- * y,u,v address of dst_addr[out]
- *
- * @param src_addr
- * y,uv address of src_addr.Format is nv12t[in]
- *
- * @param width
- * width of dst image[in]
- *
- * @param height
- * height of dst image[in]
- *
- * @param omxformat
- * omxformat of dst image[in]
- *
- * @return
- * pass or fail
- */
-HWCONVERTER_ERROR_CODE csc_hwconverter_convert_nv12t(
- void *handle,
- void **dst_addr,
- void **src_addr,
- unsigned int width,
- unsigned int height,
- OMX_COLOR_FORMATTYPE omxformat)
-{
- HWCONVERTER_ERROR_CODE ret = HWCONVERTER_RET_OK;
- HardwareConverter *hw_converter = (HardwareConverter *)handle;
-
- if (hw_converter == NULL) {
- ret = HWCONVERTER_RET_FAIL;
- goto EXIT;
- }
-
- hw_converter->convert(
- (void *)src_addr, (void *)dst_addr,
- (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatNV12TPhysicalAddress,
- width, height, omxformat);
-
- ret = HWCONVERTER_RET_OK;
-
-EXIT:
-
- return ret;
-}
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/exynos4/multimedia/libs/libcsc/hwconverter_wrapper.h b/exynos4/multimedia/libs/libcsc/hwconverter_wrapper.h
deleted file mode 100644
index 292a680..0000000
--- a/exynos4/multimedia/libs/libcsc/hwconverter_wrapper.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * 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.
- */
-
-/*
- * @file hwconverter_wrapper.h
- *
- * @brief hwconverter_wrapper abstract libhwconverter and support c functions
- *
- * @author ShinWon Lee (shinwon.lee@samsung.com)
- *
- * @version 1.0
- *
- * @history
- * 2012.02.01 : Create
- */
-
-#ifndef HWCONVERTER_WRAPPER_H
-
-#define HWCONVERTER_WRAPPER_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <OMX_Video.h>
-
-/*--------------------------------------------------------------------------------*/
-/* Structure and Type */
-/*--------------------------------------------------------------------------------*/
-typedef enum {
- HWCONVERTER_RET_OK = 0,
- HWCONVERTER_RET_FAIL = -1
-} HWCONVERTER_ERROR_CODE;
-
-/*--------------------------------------------------------------------------------*/
-/* CSC FIMC APIs */
-/*--------------------------------------------------------------------------------*/
-/*
- * create hwconverter handle
- *
- * @return
- * hwconverter handle
- */
-void *csc_fimc_open();
-
-/*
- * destroy hwconverter handle
- *
- * @param handle
- * hwconverter handle[in]
- *
- * @return
- * error code
- */
-HWCONVERTER_ERROR_CODE csc_fimc_close(
- void *handle);
-
-/*
- * convert color space nv12t to omxformat
- *
- * @param handle
- * hwconverter handle[in]
- *
- * @param dst_addr
- * y,u,v address of dst_addr[out]
- *
- * @param src_addr
- * y,uv address of src_addr.Format is nv12t[in]
- *
- * @param width
- * width of dst image[in]
- *
- * @param height
- * height of dst image[in]
- *
- * @param omxformat
- * omxformat of dst image[in]
- *
- * @return
- * error code
- */
-HWCONVERTER_ERROR_CODE csc_fimc_convert_nv12t(
- void *handle,
- void **dst_addr,
- void **src_addr,
- unsigned int width,
- unsigned int height,
- OMX_COLOR_FORMATTYPE omxformat);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/exynos4/multimedia/libstagefrighthw/Android.mk b/exynos4/multimedia/libstagefrighthw/Android.mk
deleted file mode 100644
index ce7a5e7..0000000
--- a/exynos4/multimedia/libstagefrighthw/Android.mk
+++ /dev/null
@@ -1,23 +0,0 @@
-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/base/include/media/stagefright/openmax \
-
-LOCAL_SHARED_LIBRARIES := \
- libbinder \
- libutils \
- libcutils \
- libui \
- libdl \
- libsurfaceflinger_client
-
-LOCAL_MODULE := libstagefrighthw
-
-LOCAL_MODULE_TAGS := optional
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/libstagefrighthw/SEC_OMX_Plugin.cpp b/exynos4/multimedia/libstagefrighthw/SEC_OMX_Plugin.cpp
deleted file mode 100644
index efc8691..0000000
--- a/exynos4/multimedia/libstagefrighthw/SEC_OMX_Plugin.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * 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 <media/stagefright/HardwareAPI.h>
-#include <media/stagefright/MediaDebug.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);
-
- CHECK_EQ(err, OMX_ErrorNone);
- CHECK_EQ(numRoles, numRoles2);
-
- for (OMX_U32 i = 0; i < numRoles; ++i) {
- String8 s((const char *)array[i]);
- roles->push(s);
-
- delete[] array[i];
- array[i] = NULL;
- }
-
- delete[] array;
- array = NULL;
- }
-
- return OMX_ErrorNone;
-}
-
-} // namespace android
-
diff --git a/exynos4/multimedia/libstagefrighthw/SEC_OMX_Plugin.h b/exynos4/multimedia/libstagefrighthw/SEC_OMX_Plugin.h
deleted file mode 100644
index 6df2d31..0000000
--- a/exynos4/multimedia/libstagefrighthw/SEC_OMX_Plugin.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * 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 <media/stagefright/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/exynos4/multimedia/openmax/Android.mk b/exynos4/multimedia/openmax/Android.mk
deleted file mode 100644
index 6571161..0000000
--- a/exynos4/multimedia/openmax/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-include $(all-subdir-makefiles)
diff --git a/exynos4/multimedia/openmax/sec_omx/Android.mk b/exynos4/multimedia/openmax/sec_omx/Android.mk
deleted file mode 100644
index a15f70d..0000000
--- a/exynos4/multimedia/openmax/sec_omx/Android.mk
+++ /dev/null
@@ -1,32 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-BOARD_USE_ANB := true
-
-include $(CLEAR_VARS)
-
-SEC_OMX_TOP := $(LOCAL_PATH)
-
-SEC_COPY_HEADERS_TO := libsecmm
-
-SEC_OMX_INC := $(SEC_OMX_TOP)/include/
-SEC_OMX_COMPONENT := $(SEC_OMX_TOP)/component
-
-include $(SEC_OMX_TOP)/osal/Android.mk
-include $(SEC_OMX_TOP)/core/Android.mk
-
-include $(SEC_OMX_COMPONENT)/common/Android.mk
-include $(SEC_OMX_COMPONENT)/video/dec/Android.mk
-include $(SEC_OMX_COMPONENT)/video/dec/h264/Android.mk
-include $(SEC_OMX_COMPONENT)/video/dec/mpeg4/Android.mk
-include $(SEC_OMX_COMPONENT)/video/dec/vc1/Android.mk
-include $(SEC_OMX_COMPONENT)/video/enc/Android.mk
-include $(SEC_OMX_COMPONENT)/video/enc/h264/Android.mk
-include $(SEC_OMX_COMPONENT)/video/enc/mpeg4/Android.mk
-
-ifeq ($(filter-out exynos5,$(TARGET_BOARD_PLATFORM)),)
-include $(SEC_OMX_COMPONENT)/video/dec/vp8/Android.mk
-endif
-
-ifeq ($(BOARD_USE_ALP_AUDIO), true)
-include $(SEC_OMX_COMPONENT)/audio/dec/Android.mk
-include $(SEC_OMX_COMPONENT)/audio/dec/mp3/Android.mk
-endif
diff --git a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/audio/dec/Android.mk
deleted file mode 100644
index 303737b..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/Android.mk
+++ /dev/null
@@ -1,19 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
- SEC_OMX_Adec.c
-
-LOCAL_MODULE := libSEC_OMX_Adec
-LOCAL_ARM_MODE := arm
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/audio/dec \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO)
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/SEC_OMX_Adec.c b/exynos4/multimedia/openmax/sec_omx/component/audio/dec/SEC_OMX_Adec.c
deleted file mode 100644
index dab7247..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/SEC_OMX_Adec.c
+++ /dev/null
@@ -1,1376 +0,0 @@
-/*
- *
- * 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_Adec.c
- * @brief
- * @author Yunji Kim (yunji.kim@samsung.com)
- *
- * @version 1.1.0
- * @history
- * 2011.10.18 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "SEC_OMX_Macros.h"
-#include "SEC_OSAL_Event.h"
-#include "SEC_OMX_Adec.h"
-#include "SEC_OMX_Basecomponent.h"
-#include "SEC_OSAL_Thread.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Mutex.h"
-#include "SEC_OSAL_ETC.h"
-#include "srp_api.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_AUDIO_DEC"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-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;
- 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;
-
- 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;
- 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;
-
- 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;
- 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;
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- /* 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_BASEPORT *secInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- 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;
- }
-
- /* Audio extractor should parse into frame units. */
- flagEOF = OMX_TRUE;
- checkedSize = checkInputStreamLen;
- copySize = checkedSize;
-
- 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));
- }
- }
- } else {
- /*????????????????????????????????? Error ?????????????????????????????????*/
- SEC_DataReset(pOMXComponent, INPUT_PORT_INDEX);
- flagEOF = OMX_FALSE;
- }
-
- if ((inputUseBuffer->remainDataLen == 0) ||
- (CHECK_PORT_BEING_FLUSHED(secInputPort)))
- SEC_InputBufferReturn(pOMXComponent);
- else
- inputUseBuffer->dataValid = OMX_TRUE;
- }
-
- if (flagEOF == OMX_TRUE) {
- if (pSECComponent->checkTimeStamp.needSetStartTimeStamp == OMX_TRUE) {
- /* Flush SRP buffers */
- SRP_Flush();
-
- pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_TRUE;
- pSECComponent->checkTimeStamp.startTimeStamp = inputData->timeStamp;
- pSECComponent->checkTimeStamp.nStartFlags = inputData->nFlags;
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
- SEC_OSAL_Log(SEC_LOG_TRACE, "first frame timestamp after seeking %lld us (%.2f secs)",
- inputData->timeStamp, inputData->timeStamp / 1E6);
- }
-
- 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_BASEPORT *secOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- 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.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) ||
- (CHECK_PORT_BEING_FLUSHED(secOutputPort)))
- SEC_OutputBufferReturn(pOMXComponent);
- } else {
- SEC_OSAL_Log(SEC_LOG_ERROR, "output buffer is smaller than decoded data size Out Length");
-
- ret = OMX_FALSE;
-
- /* reset outputData */
- SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
- }
- } 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_AUDIODEC_COMPONENT *pVideoDec = (SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle;
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- 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_AudioDecodeGetParameter(
- 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_ErrorInvalidState;
- goto EXIT;
- }
-
- if (ComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- switch (nParamIndex) {
- case OMX_IndexParamAudioInit:
- {
- 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_IndexParamAudioPortFormat:
- {
- OMX_AUDIO_PARAM_PORTFORMATTYPE *portFormat = (OMX_AUDIO_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_AUDIO_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->eEncoding = portDefinition->format.audio.eEncoding;
- } 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->eEncoding = portDefinition->format.audio.eEncoding;
- }
- ret = OMX_ErrorNone;
- }
- break;
- default:
- {
- ret = SEC_OMX_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
- }
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-OMX_ERRORTYPE SEC_OMX_AudioDecodeSetParameter(
- 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_ErrorInvalidState;
- goto EXIT;
- }
-
- if (ComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- switch (nIndex) {
- case OMX_IndexParamAudioPortFormat:
- {
- OMX_AUDIO_PARAM_PORTFORMATTYPE *portFormat = (OMX_AUDIO_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_AUDIO_PARAM_PORTFORMATTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if ((portIndex >= pSECComponent->portParam.nPorts)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[portIndex];
- portDefinition = &pSECPort->portDefinition;
-
- portDefinition->format.audio.eEncoding = portFormat->eEncoding;
- ret = OMX_ErrorNone;
- }
- break;
- default:
- {
- ret = SEC_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
- }
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_AudioDecodeGetConfig(
- 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_OMX_AudioDecodeSetConfig(
- 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_IndexConfigAudioMute:
- {
- SEC_OSAL_Log(SEC_LOG_TRACE, "OMX_IndexConfigAudioMute");
- ret = OMX_ErrorUnsupportedIndex;
- }
- break;
- case OMX_IndexConfigAudioVolume:
- {
- SEC_OSAL_Log(SEC_LOG_TRACE, "OMX_IndexConfigAudioVolume");
- ret = OMX_ErrorUnsupportedIndex;
- }
- break;
- default:
- ret = SEC_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_AudioDecodeGetExtensionIndex(
- 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 = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_AudioDecodeComponentInit(OMX_IN OMX_HANDLETYPE hComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- SEC_OMX_AUDIODEC_COMPONENT *pAudioDec = 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;
-
- pAudioDec = SEC_OSAL_Malloc(sizeof(SEC_OMX_AUDIODEC_COMPONENT));
- if (pAudioDec == NULL) {
- SEC_OMX_BaseComponent_Destructor(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
-
- SEC_OSAL_Memset(pAudioDec, 0, sizeof(SEC_OMX_AUDIODEC_COMPONENT));
- pSECComponent->hComponentHandle = (OMX_HANDLETYPE)pAudioDec;
- pSECComponent->bSaveFlagEOS = OMX_FALSE;
-
- /* Input port */
- pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- pSECPort->portDefinition.nBufferCountActual = MAX_AUDIO_INPUTBUFFER_NUM;
- pSECPort->portDefinition.nBufferCountMin = MAX_AUDIO_INPUTBUFFER_NUM;
- pSECPort->portDefinition.nBufferSize = DEFAULT_AUDIO_INPUT_BUFFER_SIZE;
- pSECPort->portDefinition.eDomain = OMX_PortDomainAudio;
-
- pSECPort->portDefinition.format.audio.cMIMEType = SEC_OSAL_Malloc(MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.audio.cMIMEType, "audio/raw");
- pSECPort->portDefinition.format.audio.pNativeRender = 0;
- pSECPort->portDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingUnused;
-
- /* Output port */
- pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECPort->portDefinition.nBufferCountActual = MAX_AUDIO_OUTPUTBUFFER_NUM;
- pSECPort->portDefinition.nBufferCountMin = MAX_AUDIO_OUTPUTBUFFER_NUM;
- pSECPort->portDefinition.nBufferSize = DEFAULT_AUDIO_OUTPUT_BUFFER_SIZE;
- pSECPort->portDefinition.eDomain = OMX_PortDomainAudio;
-
- pSECPort->portDefinition.format.audio.cMIMEType = SEC_OSAL_Malloc(MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.audio.cMIMEType, "audio/raw");
- pSECPort->portDefinition.format.audio.pNativeRender = 0;
- pSECPort->portDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingUnused;
-
-
- 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_AudioDecodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- SEC_OMX_AUDIODEC_COMPONENT *pAudioDec = 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;
-
- pAudioDec = (SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OSAL_Free(pAudioDec);
- pSECComponent->hComponentHandle = pAudioDec = NULL;
-
- for(i = 0; i < ALL_PORT_NUM; i++) {
- pSECPort = &pSECComponent->pSECPort[i];
- SEC_OSAL_Free(pSECPort->portDefinition.format.audio.cMIMEType);
- pSECPort->portDefinition.format.audio.cMIMEType = NULL;
- }
-
- ret = SEC_OMX_Port_Destructor(pOMXComponent);
-
- ret = SEC_OMX_BaseComponent_Destructor(hComponent);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/SEC_OMX_Adec.h b/exynos4/multimedia/openmax/sec_omx/component/audio/dec/SEC_OMX_Adec.h
deleted file mode 100644
index 8ff20ab..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/SEC_OMX_Adec.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- *
- * 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_Adec.h
- * @brief
- * @author Yunji Kim (yunji.kim@samsung.com)
- *
- * @version 1.1.0
- * @history
- * 2011.10.18 : Create
- */
-
-#ifndef SEC_OMX_AUDIO_DECODE
-#define SEC_OMX_AUDIO_DECODE
-
-#include "OMX_Component.h"
-#include "SEC_OMX_Def.h"
-#include "SEC_OSAL_Queue.h"
-#include "SEC_OMX_Baseport.h"
-#include "SEC_OMX_Basecomponent.h"
-
-#define MAX_AUDIO_INPUTBUFFER_NUM 2
-#define MAX_AUDIO_OUTPUTBUFFER_NUM 2
-
-#define DEFAULT_AUDIO_INPUT_BUFFER_SIZE (16 * 1024)
-#define DEFAULT_AUDIO_OUTPUT_BUFFER_SIZE (32 * 1024)
-
-#define DEFAULT_AUDIO_SAMPLING_FREQ 44100
-#define DEFAULT_AUDIO_CHANNELS_NUM 2
-#define DEFAULT_AUDIO_BIT_PER_SAMPLE 16
-
-#define INPUT_PORT_SUPPORTFORMAT_NUM_MAX 1
-#define OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX 1
-
-typedef struct _SRP_DEC_INPUT_BUFFER
-{
- void *PhyAddr; // physical address
- void *VirAddr; // virtual address
- int bufferSize; // input buffer alloc size
- int dataSize; // Data length
-} SRP_DEC_INPUT_BUFFER;
-
-typedef struct _SEC_OMX_AUDIODEC_COMPONENT
-{
- OMX_HANDLETYPE hCodecHandle;
-
- OMX_BOOL bFirstFrame;
- OMX_PTR pInputBuffer;
- SRP_DEC_INPUT_BUFFER SRPDecInputBuffer[MAX_AUDIO_INPUTBUFFER_NUM];
- OMX_U32 indexInputBuffer;
-} SEC_OMX_AUDIODEC_COMPONENT;
-
-
-#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_AudioDecodeGetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nParamIndex,
- OMX_INOUT OMX_PTR ComponentParameterStructure);
-OMX_ERRORTYPE SEC_OMX_AudioDecodeSetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR ComponentParameterStructure);
-OMX_ERRORTYPE SEC_OMX_AudioDecodeGetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure);
-OMX_ERRORTYPE SEC_OMX_AudioDecodeSetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure);
-OMX_ERRORTYPE SEC_OMX_AudioDecodeGetExtensionIndex(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_STRING cParameterName,
- OMX_OUT OMX_INDEXTYPE *pIndexType);
-OMX_ERRORTYPE SEC_OMX_AudioDecodeComponentInit(OMX_IN OMX_HANDLETYPE hComponent);
-OMX_ERRORTYPE SEC_OMX_AudioDecodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent);
-OMX_BOOL SEC_Check_BufferProcess_State(SEC_OMX_BASECOMPONENT *pSECComponent);
-inline void SEC_UpdateFrameSize(OMX_COMPONENTTYPE *pOMXComponent);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SEC_OMX_AUDIO_DECODE */
diff --git a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/Android.mk
deleted file mode 100644
index 43af655..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/Android.mk
+++ /dev/null
@@ -1,31 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_Mp3dec.c \
- library_register.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libOMX.SEC.MP3.Decoder
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/omx
-
-LOCAL_CFLAGS :=
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libSEC_OMX_Adec libsecosal libsecbasecomponent \
- libsrpapi
-LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui \
- libSEC_OMX_Resourcemanager
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/audio/dec \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO)
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/SEC_OMX_Mp3dec.c b/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/SEC_OMX_Mp3dec.c
deleted file mode 100644
index a8c77f6..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/SEC_OMX_Mp3dec.c
+++ /dev/null
@@ -1,918 +0,0 @@
-/*
- *
- * 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_Mp3dec.c
- * @brief
- * @author Yunji Kim (yunji.kim@samsung.com)
- * @version 1.1.0
- * @history
- * 2011.10.18 : 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_Adec.h"
-#include "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Thread.h"
-#include "library_register.h"
-#include "SEC_OMX_Mp3dec.h"
-#include "srp_api.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_MP3_DEC"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-//#define SRP_DUMP_TO_FILE
-#ifdef SRP_DUMP_TO_FILE
-#include "stdio.h"
-
-FILE *inFile;
-FILE *outFile;
-#endif
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_GetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nParamIndex,
- OMX_INOUT OMX_PTR pComponentParameterStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nParamIndex) {
- case OMX_IndexParamAudioMp3:
- {
- OMX_AUDIO_PARAM_MP3TYPE *pDstMp3Param = (OMX_AUDIO_PARAM_MP3TYPE *)pComponentParameterStructure;
- OMX_AUDIO_PARAM_MP3TYPE *pSrcMp3Param = NULL;
- SEC_MP3_HANDLE *pMp3Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pDstMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pDstMp3Param->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pMp3Dec = (SEC_MP3_HANDLE *)((SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSrcMp3Param = &pMp3Dec->mp3Param;
-
- SEC_OSAL_Memcpy(pDstMp3Param, pSrcMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
- }
- break;
- case OMX_IndexParamAudioPcm:
- {
- OMX_AUDIO_PARAM_PCMMODETYPE *pDstPcmParam = (OMX_AUDIO_PARAM_PCMMODETYPE *)pComponentParameterStructure;
- OMX_AUDIO_PARAM_PCMMODETYPE *pSrcPcmParam = NULL;
- SEC_MP3_HANDLE *pMp3Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pDstPcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pDstPcmParam->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pMp3Dec = (SEC_MP3_HANDLE *)((SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSrcPcmParam = &pMp3Dec->pcmParam;
-
- SEC_OSAL_Memcpy(pDstPcmParam, pSrcPcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
- }
- 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;
- }
-
- SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPONENT_MP3_DEC_ROLE);
- }
- break;
- default:
- ret = SEC_OMX_AudioDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
- break;
- }
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_SetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR pComponentParameterStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- case OMX_IndexParamAudioMp3:
- {
- OMX_AUDIO_PARAM_MP3TYPE *pDstMp3Param = NULL;
- OMX_AUDIO_PARAM_MP3TYPE *pSrcMp3Param = (OMX_AUDIO_PARAM_MP3TYPE *)pComponentParameterStructure;
- SEC_MP3_HANDLE *pMp3Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pSrcMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pSrcMp3Param->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pMp3Dec = (SEC_MP3_HANDLE *)((SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pDstMp3Param = &pMp3Dec->mp3Param;
-
- SEC_OSAL_Memcpy(pDstMp3Param, pSrcMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
- }
- break;
- case OMX_IndexParamAudioPcm:
- {
- OMX_AUDIO_PARAM_PCMMODETYPE *pDstPcmParam = NULL;
- OMX_AUDIO_PARAM_PCMMODETYPE *pSrcPcmParam = (OMX_AUDIO_PARAM_PCMMODETYPE *)pComponentParameterStructure;
- SEC_MP3_HANDLE *pMp3Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pSrcPcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pSrcPcmParam->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pMp3Dec = (SEC_MP3_HANDLE *)((SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pDstPcmParam = &pMp3Dec->pcmParam;
-
- SEC_OSAL_Memcpy(pDstPcmParam, pSrcPcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
- }
- 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_MP3_DEC_ROLE)) {
- pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
- } else {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- }
- break;
- default:
- ret = SEC_OMX_AudioDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
- break;
- }
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_GetConfig(
- 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_AudioDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_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_AudioDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_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 = SEC_OMX_AudioDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_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_ErrorInvalidState;
- goto EXIT;
- }
-
- SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPONENT_MP3_DEC_ROLE);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_AUDIODEC_COMPONENT *pAudioDec = (SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_MP3_HANDLE *pMp3Dec = (SEC_MP3_HANDLE *)pAudioDec->hCodecHandle;
-
- FunctionIn();
-
- SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
- SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
- pSECComponent->bUseFlagEOF = OMX_TRUE; /* Mp3 extractor should parse into frame unit. */
- pSECComponent->bSaveFlagEOS = OMX_FALSE;
- pMp3Dec->hSRPMp3Handle.bConfiguredSRP = OMX_FALSE;
- pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_FALSE;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
-
-#ifdef SRP_DUMP_TO_FILE
- inFile = fopen("/data/InFile.mp3", "w+");
- outFile = fopen("/data/OutFile.pcm", "w+");
-#endif
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- FunctionIn();
-
-#ifdef SRP_DUMP_TO_FILE
- fclose(inFile);
- fclose(outFile);
-#endif
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3_Decode_Block(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_AUDIODEC_COMPONENT *pAudioDec = (SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_MP3_HANDLE *pMp3Dec = (SEC_MP3_HANDLE *)pAudioDec->hCodecHandle;
- struct srp_dec_info codecDecInfo;
- OMX_S32 returnCodec = 0;
- unsigned long isSRPStopped = 0;
- OMX_PTR dataBuffer = NULL;
- unsigned int dataLen = 0;
- OMX_BOOL isSRPIbufOverflow = OMX_FALSE;
-
- FunctionIn();
-
-#ifdef SRP_DUMP_TO_FILE
- if (pSECComponent->reInputData == OMX_FALSE) {
- fwrite(pInputData->dataBuffer, pInputData->dataLen, 1, inFile);
- }
-#endif
-
- /* Save timestamp and flags of input data */
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags & (~OMX_BUFFERFLAG_EOS);
-
- /* Decoding mp3 frames by SRP */
- if (pSECComponent->getAllDelayBuffer == OMX_FALSE) {
- returnCodec = SRP_Decode(pInputData->dataBuffer, pInputData->dataLen);
-
- if (returnCodec >= 0) {
- if (pInputData->nFlags & OMX_BUFFERFLAG_EOS) {
- SRP_Send_EOS();
- pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_TRUE;
- }
- } else if (returnCodec == SRP_ERROR_IBUF_OVERFLOW) {
- isSRPIbufOverflow = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- }
- }
-
- if (pMp3Dec->hSRPMp3Handle.bConfiguredSRP == OMX_FALSE) {
- returnCodec = SRP_Get_Dec_Info(&codecDecInfo);
- if (returnCodec < 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SRP_Get_Dec_Info failed: %d", returnCodec);
- ret = OMX_ErrorHardware;
- goto EXIT;
- }
-
- if (!codecDecInfo.sample_rate || !codecDecInfo.channels) {
- if (pMp3Dec->hSRPMp3Handle.bSRPSendEOS == OMX_TRUE) {
- pOutputData->dataLen = 0;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- if (isSRPIbufOverflow)
- ret = OMX_ErrorInputDataDecodeYet;
- else
- ret = OMX_ErrorNone;
- }
- goto EXIT;
- }
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "numChannels(%d), samplingRate(%d)",
- codecDecInfo.channels, codecDecInfo.sample_rate);
-
- if (pMp3Dec->pcmParam.nChannels != codecDecInfo.channels ||
- pMp3Dec->pcmParam.nSamplingRate != codecDecInfo.sample_rate) {
- /* Change channel count and sampling rate information */
- pMp3Dec->pcmParam.nChannels = codecDecInfo.channels;
- pMp3Dec->pcmParam.nSamplingRate = codecDecInfo.sample_rate;
-
- /* 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);
- }
-
- pMp3Dec->hSRPMp3Handle.bConfiguredSRP = OMX_TRUE;
-
- if (pMp3Dec->hSRPMp3Handle.bSRPSendEOS == OMX_TRUE) {
- pOutputData->dataLen = 0;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- if (isSRPIbufOverflow)
- ret = OMX_ErrorInputDataDecodeYet;
- else
- ret = OMX_ErrorNone;
- }
- goto EXIT;
- }
-
- /* Get decoded data from SRP */
- returnCodec = SRP_Get_PCM(&dataBuffer, &dataLen);
- if (dataLen > 0) {
- pOutputData->dataLen = dataLen;
- SEC_OSAL_Memcpy(pOutputData->dataBuffer, dataBuffer, dataLen);
- } else {
- pOutputData->dataLen = 0;
- }
-
-#ifdef SRP_DUMP_TO_FILE
- if (pOutputData->dataLen > 0)
- fwrite(pOutputData->dataBuffer, pOutputData->dataLen, 1, outFile);
-#endif
-
- /* Delay EOS signal until all the PCM is returned from the SRP driver. */
- if (pMp3Dec->hSRPMp3Handle.bSRPSendEOS == OMX_TRUE) {
- if (pInputData->nFlags & OMX_BUFFERFLAG_EOS) {
- returnCodec = SRP_GetParams(SRP_STOP_EOS_STATE, &isSRPStopped);
- if (returnCodec != 0)
- SEC_OSAL_Log(SEC_LOG_ERROR, "Fail SRP_STOP_EOS_STATE");
- if (isSRPStopped == 1) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_FALSE; /* for repeating one song */
- ret = OMX_ErrorNone;
- } else {
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- }
- } else { /* Flush after EOS */
- pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_FALSE;
- }
- }
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_SRP_Mp3Dec_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))) {
- if (pInputData->nFlags & OMX_BUFFERFLAG_EOS)
- ret = OMX_ErrorInputDataDecodeYet;
- else
- ret = OMX_ErrorNone;
-
- goto EXIT;
- }
- if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
- if (pInputData->nFlags & OMX_BUFFERFLAG_EOS)
- ret = OMX_ErrorInputDataDecodeYet;
- else
- ret = OMX_ErrorNone;
-
- goto EXIT;
- }
-
- ret = SEC_SRP_Mp3_Decode_Block(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_OMX_AUDIODEC_COMPONENT *pAudioDec = NULL;
- SEC_MP3_HANDLE *pMp3Dec = NULL;
- OMX_PTR pInputBuffer = NULL;
- OMX_PTR pOutputBuffer = NULL;
- unsigned int inputBufferSize = 0;
- unsigned int inputBufferNum = 0;
- unsigned int outputBufferSize = 0;
- unsigned int outputBufferNum = 0;
- OMX_S32 returnCodec;
- int i = 0;
-
- FunctionIn();
-
- if ((hComponent == NULL) || (componentName == NULL)) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: parameters are null, ret: %X", __FUNCTION__, ret);
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_MP3_DEC, componentName) != 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: componentName(%s) error, ret: %X", __FUNCTION__, componentName, ret);
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_AudioDecodeComponentInit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_OMX_AudioDecodeComponentInit error, ret: %X", __FUNCTION__, ret);
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- pSECComponent->codecType = HW_AUDIO_DEC_CODEC;
-
- pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
- if (pSECComponent->componentName == NULL) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: componentName alloc error, ret: %X", __FUNCTION__, ret);
- ret = OMX_ErrorInsufficientResources;
- goto EXIT_ERROR_1;
- }
- SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
- SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_MP3_DEC);
-
- pMp3Dec = SEC_OSAL_Malloc(sizeof(SEC_MP3_HANDLE));
- if (pMp3Dec == NULL) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_MP3_HANDLE alloc error, ret: %X", __FUNCTION__, ret);
- ret = OMX_ErrorInsufficientResources;
- goto EXIT_ERROR_2;
- }
- SEC_OSAL_Memset(pMp3Dec, 0, sizeof(SEC_MP3_HANDLE));
- pAudioDec = (SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle;
- pAudioDec->hCodecHandle = (OMX_HANDLETYPE)pMp3Dec;
-
- /* Create and Init SRP */
- pMp3Dec->hSRPMp3Handle.bSRPLoaded = OMX_FALSE;
- returnCodec = SRP_Create(SRP_INIT_BLOCK_MODE);
- if (returnCodec < 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SRP_Create failed: %d", returnCodec);
- ret = OMX_ErrorHardware;
- goto EXIT_ERROR_3;
- }
- pMp3Dec->hSRPMp3Handle.hSRPHandle = (OMX_HANDLETYPE)returnCodec; /* SRP's fd */
- returnCodec = SRP_Init();
- if (returnCodec < 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SRP_Init failed: %d", returnCodec);
- ret = OMX_ErrorHardware;
- goto EXIT_ERROR_4;
- }
- pMp3Dec->hSRPMp3Handle.bSRPLoaded = OMX_TRUE;
-
- /* Get input buffer info from SRP */
- returnCodec = SRP_Get_Ibuf_Info(&pInputBuffer, &inputBufferSize, &inputBufferNum);
- if (returnCodec < 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SRP_Get_Ibuf_Info failed: %d", returnCodec);
- ret = OMX_ErrorHardware;
- goto EXIT_ERROR_5;
- }
-
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = inputBufferSize;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = SEC_OSAL_Malloc(inputBufferSize);
- if (pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer == NULL) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "Input data buffer alloc failed");
- ret = OMX_ErrorInsufficientResources;
- goto EXIT_ERROR_5;
- }
-
- /* Get output buffer info from SRP */
- returnCodec = SRP_Get_Obuf_Info(&pOutputBuffer, &outputBufferSize, &outputBufferNum);
- if (returnCodec < 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SRP_Get_Obuf_Info failed: %d", returnCodec);
- ret = OMX_ErrorHardware;
- goto EXIT_ERROR_6;
- }
-
- /* 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;
-
- /* Input port */
- pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- pSECPort->portDefinition.nBufferCountActual = inputBufferNum;
- pSECPort->portDefinition.nBufferCountMin = inputBufferNum;
- pSECPort->portDefinition.nBufferSize = inputBufferSize;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
- SEC_OSAL_Memset(pSECPort->portDefinition.format.audio.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.audio.cMIMEType, "audio/mpeg");
- pSECPort->portDefinition.format.audio.pNativeRender = 0;
- pSECPort->portDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
-
- /* Output port */
- pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECPort->portDefinition.nBufferCountActual = outputBufferNum;
- pSECPort->portDefinition.nBufferCountMin = outputBufferNum;
- pSECPort->portDefinition.nBufferSize = outputBufferSize;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
- SEC_OSAL_Memset(pSECPort->portDefinition.format.audio.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.audio.cMIMEType, "audio/raw");
- pSECPort->portDefinition.format.audio.pNativeRender = 0;
- pSECPort->portDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
-
- /* Default values for Mp3 audio param */
- INIT_SET_SIZE_VERSION(&pMp3Dec->mp3Param, OMX_AUDIO_PARAM_MP3TYPE);
- pMp3Dec->mp3Param.nPortIndex = INPUT_PORT_INDEX;
- pMp3Dec->mp3Param.nChannels = DEFAULT_AUDIO_CHANNELS_NUM;
- pMp3Dec->mp3Param.nBitRate = 0;
- pMp3Dec->mp3Param.nSampleRate = DEFAULT_AUDIO_SAMPLING_FREQ;
- pMp3Dec->mp3Param.nAudioBandWidth = 0;
- pMp3Dec->mp3Param.eChannelMode = OMX_AUDIO_ChannelModeStereo;
- pMp3Dec->mp3Param.eFormat = OMX_AUDIO_MP3StreamFormatMP1Layer3;
-
- /* Default values for PCM audio param */
- INIT_SET_SIZE_VERSION(&pMp3Dec->pcmParam, OMX_AUDIO_PARAM_PCMMODETYPE);
- pMp3Dec->pcmParam.nPortIndex = OUTPUT_PORT_INDEX;
- pMp3Dec->pcmParam.nChannels = DEFAULT_AUDIO_CHANNELS_NUM;
- pMp3Dec->pcmParam.eNumData = OMX_NumericalDataSigned;
- pMp3Dec->pcmParam.eEndian = OMX_EndianLittle;
- pMp3Dec->pcmParam.bInterleaved = OMX_TRUE;
- pMp3Dec->pcmParam.nBitPerSample = DEFAULT_AUDIO_BIT_PER_SAMPLE;
- pMp3Dec->pcmParam.nSamplingRate = DEFAULT_AUDIO_SAMPLING_FREQ;
- pMp3Dec->pcmParam.ePCMMode = OMX_AUDIO_PCMModeLinear;
- pMp3Dec->pcmParam.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
- pMp3Dec->pcmParam.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
-
- pOMXComponent->GetParameter = &SEC_SRP_Mp3Dec_GetParameter;
- pOMXComponent->SetParameter = &SEC_SRP_Mp3Dec_SetParameter;
- pOMXComponent->GetConfig = &SEC_SRP_Mp3Dec_GetConfig;
- pOMXComponent->SetConfig = &SEC_SRP_Mp3Dec_SetConfig;
- pOMXComponent->GetExtensionIndex = &SEC_SRP_Mp3Dec_GetExtensionIndex;
- pOMXComponent->ComponentRoleEnum = &SEC_SRP_Mp3Dec_ComponentRoleEnum;
- pOMXComponent->ComponentDeInit = &SEC_OMX_ComponentDeinit;
-
- /* ToDo: Change the function name associated with a specific codec */
- pSECComponent->sec_mfc_componentInit = &SEC_SRP_Mp3Dec_Init;
- pSECComponent->sec_mfc_componentTerminate = &SEC_SRP_Mp3Dec_Terminate;
- pSECComponent->sec_mfc_bufferProcess = &SEC_SRP_Mp3Dec_bufferProcess;
- pSECComponent->sec_checkInputFrame = NULL;
-
- pSECComponent->currentState = OMX_StateLoaded;
-
- ret = OMX_ErrorNone;
- goto EXIT; /* This function is performed successfully. */
-
-EXIT_ERROR_6:
- SEC_OSAL_Free(pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer);
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = NULL;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = 0;
-EXIT_ERROR_5:
- SRP_Deinit();
-EXIT_ERROR_4:
- SRP_Terminate();
-EXIT_ERROR_3:
- SEC_OSAL_Free(pMp3Dec);
- pAudioDec->hCodecHandle = NULL;
-EXIT_ERROR_2:
- SEC_OSAL_Free(pSECComponent->componentName);
- pSECComponent->componentName = NULL;
-EXIT_ERROR_1:
- SEC_OMX_AudioDecodeComponentDeinit(pOMXComponent);
-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_MP3_HANDLE *pMp3Dec = 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;
- if (pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer) {
- SEC_OSAL_Free(pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer);
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = NULL;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = 0;
- }
-
- pMp3Dec = (SEC_MP3_HANDLE *)((SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pMp3Dec != NULL) {
- if (pMp3Dec->hSRPMp3Handle.bSRPLoaded == OMX_TRUE) {
- SRP_Deinit();
- SRP_Terminate();
- }
- SEC_OSAL_Free(pMp3Dec);
- ((SEC_OMX_AUDIODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle = NULL;
- }
-
- ret = SEC_OMX_AudioDecodeComponentDeinit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- ret = OMX_ErrorNone;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/SEC_OMX_Mp3dec.h b/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/SEC_OMX_Mp3dec.h
deleted file mode 100644
index a8b80f5..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/SEC_OMX_Mp3dec.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *
- * 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_Mp3dec.h
- * @brief
- * @author Yunji Kim (yunji.kim@samsung.com)
- * @version 1.1.0
- * @history
- * 2011.10.18 : Create
- */
-
-#ifndef SEC_OMX_MP3_DEC_COMPONENT
-#define SEC_OMX_MP3_DEC_COMPONENT
-
-#include "SEC_OMX_Def.h"
-#include "OMX_Component.h"
-
-typedef struct _SEC_SRP_MP3_HANDLE
-{
- OMX_HANDLETYPE hSRPHandle;
- OMX_BOOL bConfiguredSRP;
- OMX_BOOL bSRPLoaded;
- OMX_BOOL bSRPSendEOS;
- OMX_S32 returnCodec;
-} SEC_SRP_MP3_HANDLE;
-
-typedef struct _SEC_MP3_HANDLE
-{
- /* OMX Codec specific */
- OMX_AUDIO_PARAM_MP3TYPE mp3Param;
- OMX_AUDIO_PARAM_PCMMODETYPE pcmParam;
-
- /* SEC SRP Codec specific */
- SEC_SRP_MP3_HANDLE hSRPMp3Handle;
-} SEC_MP3_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 /* SEC_OMX_MP3_DEC_COMPONENT */
diff --git a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/library_register.c b/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/library_register.c
deleted file mode 100644
index c94377a..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/library_register.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- *
- * 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.1.0
- * @history
- * 2011.10.18 : 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_MP3_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 - audio decoder MP3 */
- SEC_OSAL_Strcpy(ppSECComponent[0]->componentName, SEC_OMX_COMPONENT_MP3_DEC);
- SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPONENT_MP3_DEC_ROLE);
- ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
-
-EXIT:
- FunctionOut();
- return MAX_COMPONENT_NUM;
-}
-
diff --git a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/library_register.h b/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/library_register.h
deleted file mode 100644
index 90ae8c2..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/audio/dec/mp3/library_register.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- *
- * 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.1.0
- * @history
- * 2011.10.18 : Create
- */
-
-#ifndef SEC_OMX_MP3_DEC_REG
-#define SEC_OMX_MP3_DEC_REG
-
-#include "SEC_OMX_Def.h"
-#include "OMX_Component.h"
-#include "SEC_OMX_Component_Register.h"
-
-
-#define OSCL_EXPORT_REF __attribute__((visibility("default")))
-#define MAX_COMPONENT_NUM 1
-#define MAX_COMPONENT_ROLE_NUM 1
-
-/* MP3 */
-#define SEC_OMX_COMPONENT_MP3_DEC "OMX.SEC.MP3.Decoder"
-#define SEC_OMX_COMPONENT_MP3_DEC_ROLE "audio_decoder.mp3"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif /* SEC_OMX_MP3_DEC_REG */
-
diff --git a/exynos4/multimedia/openmax/sec_omx/component/common/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/common/Android.mk
deleted file mode 100644
index a6f84bf..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/common/Android.mk
+++ /dev/null
@@ -1,43 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_Basecomponent.c \
- SEC_OMX_Baseport.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)/osal
-
-include $(BUILD_STATIC_LIBRARY)
-
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_Resourcemanager.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libSEC_OMX_Resourcemanager
-
-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)/osal
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Basecomponent.c b/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Basecomponent.c
deleted file mode 100644
index e615d18..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Basecomponent.c
+++ /dev/null
@@ -1,1535 +0,0 @@
-/*
- *
- * 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.1.0
- * @history
- * 2010.7.15 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "SEC_OSAL_Event.h"
-#include "SEC_OSAL_Thread.h"
-#include "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Mutex.h"
-#include "SEC_OMX_Baseport.h"
-#include "SEC_OMX_Basecomponent.h"
-#include "SEC_OMX_Resourcemanager.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;
- unsigned int i = 0, j = 0;
- int k = 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_StateWaitForResources:
- SEC_OMX_Out_WaitForResource(pOMXComponent);
- case OMX_StateIdle:
- case OMX_StateExecuting:
- case OMX_StatePause:
- case OMX_StateLoaded:
- 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);
-
- ret = OMX_ErrorInvalidState;
- break;
- default:
- ret = OMX_ErrorInvalidState;
- break;
- }
- 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(pSECPort, 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++) {
- ret = SEC_OSAL_SemaphoreCreate(&pSECComponent->pSECPort[i].bufferSemID);
- if (ret != OMX_ErrorNone) {
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
- }
- for (i = 0; i < ALL_PORT_NUM; i++) {
- ret = SEC_OSAL_MutexCreate(&pSECComponent->secDataBuffer[i].bufferMutex);
- if (ret != OMX_ErrorNone) {
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
- }
- 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;
- default:
- ret = OMX_ErrorIncorrectStateTransition;
- 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_S32 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 (k = 0; k < cnt; k++) {
- SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID);
- }
- }
- }
- }
-
- pSECComponent->currentState = OMX_StateExecuting;
- SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
- break;
- case OMX_StateWaitForResources:
- ret = OMX_ErrorIncorrectStateTransition;
- break;
- default:
- 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;
- default:
- 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;
- default:
- ret = OMX_ErrorIncorrectStateTransition;
- break;
- }
- break;
- default:
- ret = OMX_ErrorIncorrectStateTransition;
- 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_FALSE) {
- 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_S32 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_S32 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_S32 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 = NULL;
-
-
- 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 ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
- if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
- ret = OMX_ErrorIncorrectStateOperation;
- 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;
- }
-
- switch (nIndex) {
- default:
- ret = OMX_ErrorUnsupportedIndex;
- break;
- }
-
-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;
- }
-
- switch (nIndex) {
- default:
- ret = OMX_ErrorUnsupportedIndex;
- break;
- }
-
-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->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_S32 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/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Basecomponent.h b/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Basecomponent.h
deleted file mode 100644
index 47c6771..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Basecomponent.h
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- *
- * 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.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_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_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 hComponentHandle;
-
- /* 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);
-
- OMX_ERRORTYPE (*sec_allocSecureInputBuffer)(OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_U32 nBufferSize,
- OMX_INOUT OMX_PTR *pInputBuffer_physicalAddress);
- OMX_ERRORTYPE (*sec_freeSecureInputBuffer)(OMX_IN OMX_HANDLETYPE hComponent,
- OMX_INOUT OMX_PTR pInputBuffer_physicalAddress);
-
- int (*sec_checkInputFrame)(OMX_U8 *pInputStream, OMX_U32 buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame);
-} SEC_OMX_BASECOMPONENT;
-
-OMX_ERRORTYPE SEC_OMX_GetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nParamIndex,
- OMX_INOUT OMX_PTR ComponentParameterStructure);
-
-OMX_ERRORTYPE SEC_OMX_SetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR ComponentParameterStructure);
-
-OMX_ERRORTYPE SEC_OMX_GetConfig(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_INOUT OMX_PTR pComponentConfigStructure);
-
-OMX_ERRORTYPE SEC_OMX_SetConfig(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR pComponentConfigStructure);
-
-OMX_ERRORTYPE SEC_OMX_GetExtensionIndex(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_STRING cParameterName,
- OMX_OUT OMX_INDEXTYPE *pIndexType);
-
-OMX_ERRORTYPE SEC_OMX_BaseComponent_Constructor(OMX_IN OMX_HANDLETYPE hComponent);
-OMX_ERRORTYPE SEC_OMX_BaseComponent_Destructor(OMX_IN OMX_HANDLETYPE hComponent);
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
- OMX_ERRORTYPE SEC_OMX_Check_SizeVersion(OMX_PTR header, OMX_U32 size);
-
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Baseport.c b/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Baseport.c
deleted file mode 100644
index 3bd37f5..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Baseport.c
+++ /dev/null
@@ -1,1014 +0,0 @@
-/*
- *
- * 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.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) < (int)pSECPort->assignedBufferNum) {
- SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[portIndex].bufferSemID);
- }
- if (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) != (int)pSECPort->assignedBufferNum)
- SEC_OSAL_SetElemNum(&pSECPort->bufferQ, pSECPort->assignedBufferNum);
- } else {
- while(1) {
- OMX_S32 cnt = 0;
- 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) && (pOMXComponent != NULL) && (pSECComponent != NULL)) {
- 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;
- } else if (portIndex == OUTPUT_PORT_INDEX) {
- pSECComponent->remainOutputData = OMX_FALSE;
- }
- }
-
-EXIT:
- if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pSECComponent != NULL)) {
- 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) && (pOMXComponent != NULL) && (pSECComponent != NULL)) {
- 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) && (pOMXComponent != NULL) && (pSECComponent != NULL)) {
- 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;
-
- ret = SEC_OSAL_Queue(&pSECPort->bufferQ, (void *)message);
- if (ret != 0) {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
- ret = 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;
-
- ret = SEC_OSAL_Queue(&pSECPort->bufferQ, (void *)message);
- if (ret != 0) {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
- ret = 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;
- ret = SEC_OSAL_SemaphoreCreate(&pSECInputPort->loadedResource);
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
- pSECInputPort->bufferStateAllocate = NULL;
- SEC_OSAL_Free(pSECInputPort->bufferHeader);
- pSECInputPort->bufferHeader = NULL;
- SEC_OSAL_Free(pSECPort);
- pSECPort = NULL;
- goto EXIT;
- }
- ret = SEC_OSAL_SemaphoreCreate(&pSECInputPort->unloadedResource);
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource);
- pSECInputPort->loadedResource = NULL;
- SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
- pSECInputPort->bufferStateAllocate = NULL;
- SEC_OSAL_Free(pSECInputPort->bufferHeader);
- pSECInputPort->bufferHeader = NULL;
- SEC_OSAL_Free(pSECPort);
- pSECPort = NULL;
- goto EXIT;
- }
-
- INIT_SET_SIZE_VERSION(&pSECInputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
- pSECInputPort->portDefinition.nPortIndex = INPUT_PORT_INDEX;
- pSECInputPort->portDefinition.eDir = OMX_DirInput;
- pSECInputPort->portDefinition.nBufferCountActual = 0;
- pSECInputPort->portDefinition.nBufferCountMin = 0;
- pSECInputPort->portDefinition.nBufferSize = 0;
- pSECInputPort->portDefinition.bEnabled = OMX_FALSE;
- pSECInputPort->portDefinition.bPopulated = OMX_FALSE;
- pSECInputPort->portDefinition.eDomain = OMX_PortDomainMax;
- pSECInputPort->portDefinition.bBuffersContiguous = OMX_FALSE;
- pSECInputPort->portDefinition.nBufferAlignment = 0;
- pSECInputPort->markType.hMarkTargetComponent = NULL;
- pSECInputPort->markType.pMarkData = NULL;
-
- /* Output Port */
- pSECOutputPort = &pSECPort[OUTPUT_PORT_INDEX];
-
- SEC_OSAL_QueueCreate(&pSECOutputPort->bufferQ);
-
- pSECOutputPort->bufferHeader = SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM);
- if (pSECOutputPort->bufferHeader == NULL) {
- SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource);
- pSECInputPort->unloadedResource = NULL;
- SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource);
- pSECInputPort->loadedResource = NULL;
- SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
- pSECInputPort->bufferStateAllocate = NULL;
- SEC_OSAL_Free(pSECInputPort->bufferHeader);
- pSECInputPort->bufferHeader = NULL;
- SEC_OSAL_Free(pSECPort);
- pSECPort = NULL;
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- SEC_OSAL_Memset(pSECOutputPort->bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM);
-
- pSECOutputPort->bufferStateAllocate = SEC_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM);
- if (pSECOutputPort->bufferStateAllocate == NULL) {
- SEC_OSAL_Free(pSECOutputPort->bufferHeader);
- pSECOutputPort->bufferHeader = NULL;
-
- SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource);
- pSECInputPort->unloadedResource = NULL;
- SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource);
- pSECInputPort->loadedResource = NULL;
- SEC_OSAL_Free(pSECInputPort->bufferStateAllocate);
- pSECInputPort->bufferStateAllocate = NULL;
- SEC_OSAL_Free(pSECInputPort->bufferHeader);
- pSECInputPort->bufferHeader = NULL;
- SEC_OSAL_Free(pSECPort);
- pSECPort = NULL;
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- SEC_OSAL_Memset(pSECOutputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM);
-
- pSECOutputPort->bufferSemID = NULL;
- pSECOutputPort->assignedBufferNum = 0;
- pSECOutputPort->portState = OMX_StateMax;
- pSECOutputPort->bIsPortFlushed = OMX_FALSE;
- pSECOutputPort->bIsPortDisabled = OMX_FALSE;
- pSECOutputPort->tunneledComponent = NULL;
- pSECOutputPort->tunneledPort = 0;
- pSECOutputPort->tunnelBufferNum = 0;
- pSECOutputPort->bufferSupplier = OMX_BufferSupplyUnspecified;
- pSECOutputPort->tunnelFlags = 0;
- 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;
-
- 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/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Baseport.h b/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Baseport.h
deleted file mode 100644
index a69a443..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Baseport.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- *
- * 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.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_BOOL bIsANBEnabled;
- OMX_BOOL bStoreMetaData;
-} 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);
-OMX_ERRORTYPE SEC_OMX_Port_Constructor(OMX_HANDLETYPE hComponent);
-OMX_ERRORTYPE SEC_OMX_Port_Destructor(OMX_HANDLETYPE hComponent);
-
-#ifdef __cplusplus
-};
-#endif
-
-
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Resourcemanager.c b/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Resourcemanager.c
deleted file mode 100644
index 6a2c979..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Resourcemanager.c
+++ /dev/null
@@ -1,478 +0,0 @@
-/*
- *
- * 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.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"
-#include "SEC_OSAL_Memory.h"
-#include "SEC_OSAL_Mutex.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_RM"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-
-#define MAX_RESOURCE_VIDEO_DEC 3 /* for Android */
-#define MAX_RESOURCE_VIDEO_ENC 1 /* for Android */
-
-/* Max allowable video scheduler component instance */
-static SEC_OMX_RM_COMPONENT_LIST *gpVideoDecRMComponentList = NULL;
-static SEC_OMX_RM_COMPONENT_LIST *gpVideoDecRMWaitingList = NULL;
-static SEC_OMX_RM_COMPONENT_LIST *gpVideoEncRMComponentList = NULL;
-static SEC_OMX_RM_COMPONENT_LIST *gpVideoEncRMWaitingList = 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 {
- if (pPrevComp != NULL)
- 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, OMX_U32 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()
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
-
- FunctionIn();
- ret = SEC_OSAL_MutexCreate(&ghVideoRMComponentListMutex);
- FunctionOut();
-
- return ret;
-}
-
-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 (gpVideoDecRMComponentList) {
- pCurrComponent = gpVideoDecRMComponentList;
- while (pCurrComponent != NULL) {
- pNextComponent = pCurrComponent->pNext;
- SEC_OSAL_Free(pCurrComponent);
- pCurrComponent = pNextComponent;
- }
- gpVideoDecRMComponentList = NULL;
- }
- if (gpVideoDecRMWaitingList) {
- pCurrComponent = gpVideoDecRMWaitingList;
- while (pCurrComponent != NULL) {
- pNextComponent = pCurrComponent->pNext;
- SEC_OSAL_Free(pCurrComponent);
- pCurrComponent = pNextComponent;
- }
- gpVideoDecRMWaitingList = NULL;
- }
-
- if (gpVideoEncRMComponentList) {
- pCurrComponent = gpVideoEncRMComponentList;
- while (pCurrComponent != NULL) {
- pNextComponent = pCurrComponent->pNext;
- SEC_OSAL_Free(pCurrComponent);
- pCurrComponent = pNextComponent;
- }
- gpVideoEncRMComponentList = NULL;
- }
- if (gpVideoEncRMWaitingList) {
- pCurrComponent = gpVideoEncRMWaitingList;
- while (pCurrComponent != NULL) {
- pNextComponent = pCurrComponent->pNext;
- SEC_OSAL_Free(pCurrComponent);
- pCurrComponent = pNextComponent;
- }
- gpVideoEncRMWaitingList = 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;
-
- if (pSECComponent->codecType == HW_VIDEO_DEC_CODEC) {
- pComponentTemp = gpVideoDecRMComponentList;
- if (pComponentTemp != NULL) {
- while (pComponentTemp) {
- numElem++;
- pComponentTemp = pComponentTemp->pNext;
- }
- } else {
- numElem = 0;
- }
- if (numElem >= MAX_RESOURCE_VIDEO_DEC) {
- lowCompDetect = searchLowPriority(gpVideoDecRMComponentList, 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(&gpVideoDecRMComponentList, pComponentCandidate->pOMXStandComp);
- ret = addElementList(&gpVideoDecRMComponentList, pOMXComponent);
- if (ret != OMX_ErrorNone) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- }
- }
- } else {
- ret = addElementList(&gpVideoDecRMComponentList, pOMXComponent);
- if (ret != OMX_ErrorNone) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- }
- } else if (pSECComponent->codecType == HW_VIDEO_ENC_CODEC) {
- pComponentTemp = gpVideoEncRMComponentList;
- if (pComponentTemp != NULL) {
- while (pComponentTemp) {
- numElem++;
- pComponentTemp = pComponentTemp->pNext;
- }
- } else {
- numElem = 0;
- }
- if (numElem >= MAX_RESOURCE_VIDEO_ENC) {
- lowCompDetect = searchLowPriority(gpVideoEncRMComponentList, 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(&gpVideoEncRMComponentList, pComponentCandidate->pOMXStandComp);
- ret = addElementList(&gpVideoEncRMComponentList, pOMXComponent);
- if (ret != OMX_ErrorNone) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- }
- }
- } else {
- ret = addElementList(&gpVideoEncRMComponentList, 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;
-
- if (pSECComponent->codecType == HW_VIDEO_DEC_CODEC) {
- pComponentTemp = gpVideoDecRMWaitingList;
- if (gpVideoDecRMComponentList == NULL) {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
- ret = removeElementList(&gpVideoDecRMComponentList, pOMXComponent);
- if (ret != OMX_ErrorNone) {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
- while (pComponentTemp) {
- numElem++;
- pComponentTemp = pComponentTemp->pNext;
- }
- if (numElem > 0) {
- pOMXWaitComponent = gpVideoDecRMWaitingList->pOMXStandComp;
- removeElementList(&gpVideoDecRMWaitingList, pOMXWaitComponent);
- ret = OMX_SendCommand(pOMXWaitComponent, OMX_CommandStateSet, OMX_StateIdle, NULL);
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- }
- } else if (pSECComponent->codecType == HW_VIDEO_ENC_CODEC) {
- pComponentTemp = gpVideoEncRMWaitingList;
- if (gpVideoEncRMComponentList == NULL) {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
- ret = removeElementList(&gpVideoEncRMComponentList, pOMXComponent);
- if (ret != OMX_ErrorNone) {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
- while (pComponentTemp) {
- numElem++;
- pComponentTemp = pComponentTemp->pNext;
- }
- if (numElem > 0) {
- pOMXWaitComponent = gpVideoEncRMWaitingList->pOMXStandComp;
- removeElementList(&gpVideoEncRMWaitingList, 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_DEC_CODEC)
- ret = addElementList(&gpVideoDecRMWaitingList, pOMXComponent);
- else if (pSECComponent->codecType == HW_VIDEO_ENC_CODEC)
- ret = addElementList(&gpVideoEncRMWaitingList, 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_DEC_CODEC)
- ret = removeElementList(&gpVideoDecRMWaitingList, pOMXComponent);
- else if (pSECComponent->codecType == HW_VIDEO_ENC_CODEC)
- ret = removeElementList(&gpVideoEncRMWaitingList, pOMXComponent);
-
- SEC_OSAL_MutexUnlock(ghVideoRMComponentListMutex);
-
- FunctionOut();
-
- return ret;
-}
-
diff --git a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Resourcemanager.h b/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Resourcemanager.h
deleted file mode 100644
index e78b378..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/common/SEC_OMX_Resourcemanager.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/component/video/dec/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/video/dec/Android.mk
deleted file mode 100644
index 349be6f..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/Android.mk
+++ /dev/null
@@ -1,23 +0,0 @@
-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)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/dec
-
-ifeq ($(BOARD_USE_ANB), true)
-LOCAL_STATIC_LIBRARIES := libsecosal
-LOCAL_CFLAGS += -DUSE_ANB
-endif
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/SEC_OMX_Vdec.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/SEC_OMX_Vdec.c
deleted file mode 100644
index 042dd25..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/SEC_OMX_Vdec.c
+++ /dev/null
@@ -1,1544 +0,0 @@
-/*
- *
- * 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.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 "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Mutex.h"
-#include "SEC_OSAL_ETC.h"
-
-#ifdef USE_ANB
-#include "SEC_OSAL_Android.h"
-#endif
-
-#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_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- if (width && height)
- secOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
- break;
- case OMX_SEC_COLOR_FormatNV12Tiled:
- width = secOutputPort->portDefinition.format.video.nFrameWidth;
- height = secOutputPort->portDefinition.format.video.nFrameHeight;
- if (width && height) {
- secOutputPort->portDefinition.nBufferSize =
- ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)) \
- + ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height/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;
- 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;
-
- 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_VIDEODEC_COMPONENT *pVideoDec = NULL;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- OMX_BUFFERHEADERTYPE *temp_bufferHeader = NULL;
- OMX_U8 *temp_buffer = NULL;
- 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;
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
-
- 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;
- }
-
- if ((pVideoDec->bDRMPlayerMode == OMX_TRUE) && (nPortIndex == INPUT_PORT_INDEX)) {
- ret = pSECComponent->sec_allocSecureInputBuffer(hComponent, sizeof(OMX_U8) * nSizeBytes, &temp_buffer);
- if (ret != OMX_ErrorNone)
- goto EXIT;
- } else {
- 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) {
- if ((pVideoDec->bDRMPlayerMode == OMX_TRUE) && (nPortIndex == INPUT_PORT_INDEX))
- pSECComponent->sec_freeSecureInputBuffer(hComponent, temp_buffer);
- else
- 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);
- if ((pVideoDec->bDRMPlayerMode == OMX_TRUE) && (nPortIndex == INPUT_PORT_INDEX))
- pSECComponent->sec_freeSecureInputBuffer(hComponent, temp_buffer);
- else
- 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_VIDEODEC_COMPONENT *pVideoDec = NULL;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- OMX_BUFFERHEADERTYPE *temp_bufferHeader = NULL;
- OMX_U8 *temp_buffer = NULL;
- 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;
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- 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) {
- if ((pVideoDec->bDRMPlayerMode == OMX_TRUE) && (nPortIndex == INPUT_PORT_INDEX))
- pSECComponent->sec_freeSecureInputBuffer(hComponent, pSECPort->bufferHeader[i]->pBuffer);
- else
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- /* 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_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- 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 (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
- flagEOF = OMX_TRUE;
- checkedSize = checkInputStreamLen;
- } else 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) || (pVideoDec->bDRMPlayerMode == OMX_TRUE)) {
- if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
- inputData->dataBuffer = checkInputStream;
- } else {
- 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) {
- if (pVideoDec->bDRMPlayerMode != OMX_TRUE)
- 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;
- SEC_OSAL_Log(SEC_LOG_TRACE, "first frame timestamp after seeking %lld us (%.2f secs)",
- inputData->timeStamp, inputData->timeStamp / 1E6);
- }
-
- 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_BASEPORT *secOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- 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");
-
- ret = OMX_FALSE;
-
- /* reset outputData */
- SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
- }
- } 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_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- 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 (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
- if ((inputUseBuffer->remainDataLen == 0) &&
- (ret != OMX_ErrorInputDataDecodeYet))
- SEC_InputBufferReturn(pOMXComponent);
- else
- inputUseBuffer->dataValid = OMX_TRUE;
- }
- 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_ErrorInvalidState;
- 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;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_1:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
- 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;
- case supportFormat_3:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- }
- }
- ret = OMX_ErrorNone;
- }
- break;
-#ifdef USE_ANB
- case OMX_IndexParamGetAndroidNativeBuffer:
- {
- ret = SEC_OSAL_GetANBParameter(hComponent, nParamIndex, 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_ErrorInvalidState;
- 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;
-#ifdef USE_ANB
- case OMX_IndexParamEnableAndroidBuffers:
- case OMX_IndexParamUseAndroidNativeBuffer:
- {
- ret = SEC_OSAL_SetANBParameter(hComponent, nIndex, ComponentParameterStructure);
- }
- break;
-#endif
- default:
- {
- ret = SEC_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
- }
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_VideoDecodeGetConfig(
- 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_OMX_VideoDecodeSetConfig(
- 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_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- pVideoDec->bThumbnailMode = *((OMX_BOOL *)pComponentConfigStructure);
-
- ret = OMX_ErrorNone;
- }
- break;
- default:
- ret = SEC_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_VideoDecodeGetExtensionIndex(
- 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_ANB
- if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_ENABLE_ANB) == 0)
- *pIndexType = (OMX_INDEXTYPE) OMX_IndexParamEnableAndroidBuffers;
- else if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_GET_ANB) == 0)
- *pIndexType = (OMX_INDEXTYPE) OMX_IndexParamGetAndroidNativeBuffer;
- else if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_USE_ANB) == 0)
- *pIndexType = (OMX_INDEXTYPE) OMX_IndexParamUseAndroidNativeBuffer;
- else
- ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
-#else
- ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
-#endif
-
-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;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = 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;
-
- pVideoDec = SEC_OSAL_Malloc(sizeof(SEC_OMX_VIDEODEC_COMPONENT));
- if (pVideoDec == NULL) {
- SEC_OMX_BaseComponent_Destructor(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
-
- SEC_OSAL_Memset(pVideoDec, 0, sizeof(SEC_OMX_VIDEODEC_COMPONENT));
- pSECComponent->hComponentHandle = (OMX_HANDLETYPE)pVideoDec;
-
- 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;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = 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;
-
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OSAL_Free(pVideoDec);
- pSECComponent->hComponentHandle = pVideoDec = NULL;
-
- 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/exynos4/multimedia/openmax/sec_omx/component/video/dec/SEC_OMX_Vdec.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/SEC_OMX_Vdec.h
deleted file mode 100644
index d3bbdf4..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/SEC_OMX_Vdec.h
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- *
- * 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.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"
-#include "SEC_OMX_Basecomponent.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 1024 * 1024 * MFC_INPUT_BUFFER_NUM_MAX /*DEFAULT_VIDEO_INPUT_BUFFER_SIZE*/
-
-#define INPUT_PORT_SUPPORTFORMAT_NUM_MAX 1
-#define OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX 4
-
-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;
-
-typedef struct _SEC_OMX_VIDEODEC_COMPONENT
-{
- OMX_HANDLETYPE hCodecHandle;
- SEC_MFC_NBDEC_THREAD NBDecThread;
-
- OMX_BOOL bThumbnailMode;
- OMX_BOOL bFirstFrame;
- MFC_DEC_INPUT_BUFFER MFCDecInputBuffer[MFC_INPUT_BUFFER_NUM_MAX];
- OMX_U32 indexInputBuffer;
-
- /* CSC handle */
- OMX_PTR csc_handle;
- OMX_U32 csc_set_format;
-
- /* For DRM Play */
- OMX_BOOL bDRMPlayerMode;
-} SEC_OMX_VIDEODEC_COMPONENT;
-
-
-#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_VideoDecodeGetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure);
-OMX_ERRORTYPE SEC_OMX_VideoDecodeSetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure);
-OMX_ERRORTYPE SEC_OMX_VideoDecodeGetExtensionIndex(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_STRING cParameterName,
- OMX_OUT OMX_INDEXTYPE *pIndexType);
-OMX_ERRORTYPE SEC_OMX_VideoDecodeComponentInit(OMX_IN OMX_HANDLETYPE hComponent);
-OMX_ERRORTYPE SEC_OMX_VideoDecodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent);
-OMX_BOOL SEC_Check_BufferProcess_State(SEC_OMX_BASECOMPONENT *pSECComponent);
-inline void SEC_UpdateFrameSize(OMX_COMPONENTTYPE *pOMXComponent);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/Android.mk
deleted file mode 100644
index da5880e..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/Android.mk
+++ /dev/null
@@ -1,84 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_H264dec.c \
- library_register.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libOMX.SEC.AVC.Decoder
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/omx
-
-LOCAL_CFLAGS :=
-
-ifeq ($(BOARD_NONBLOCK_MODE_PROCESS), true)
-LOCAL_CFLAGS += -DNONBLOCK_MODE_PROCESS
-endif
-
-ifeq ($(BOARD_USE_DRM), true)
-LOCAL_CFLAGS += -DUSE_DRM
-endif
-
-ifeq ($(BOARD_USE_ANB), true)
-LOCAL_CFLAGS += -DUSE_ANB
-ifeq ($(BOARD_USE_CSC_FIMC), true)
-ifeq ($(BOARD_USE_V4L2_ION), false)
-LOCAL_CFLAGS += -DUSE_CSC_FIMC
-endif
-endif
-
-ifeq ($(BOARD_USE_CSC_GSCALER), true)
-LOCAL_CFLAGS += -DUSE_CSC_GSCALER
-endif
-endif
-
-
-ifeq ($(TARGET_BOARD_PLATFORM), exynos4)
-ifeq ($(BOARD_USE_V4L2_ION),false)
-ifeq ($(BOARD_USE_S3D_SUPPORT), true)
-LOCAL_CFLAGS += -DS3D_SUPPORT
-endif
-endif
-endif
-
-ifeq ($(TARGET_BOARD_PLATFORM), exynos5)
-ifeq ($(BOARD_USE_S3D_SUPPORT), true)
-LOCAL_CFLAGS += -DS3D_SUPPORT
-endif
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libSEC_OMX_Vdec libsecosal libsecbasecomponent \
- libswconverter libsecmfcapi
-LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui \
- libSEC_OMX_Resourcemanager libcsc
-
-ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
-LOCAL_SHARED_LIBRARIES += libfimc libhwconverter
-endif
-
-ifeq ($(filter-out exynos5,$(TARGET_BOARD_PLATFORM)),)
-LOCAL_SHARED_LIBRARIES += libexynosgscaler
-endif
-
-#ifeq ($(BOARD_USE_V4L2_ION),true)
-#LOCAL_SHARED_LIBRARIES += libion
-#endif
-
-ifeq ($(BOARD_USES_MFC_FPS),true)
-LOCAL_CFLAGS += -DCONFIG_MFC_FPS
-endif
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/dec \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO) \
- $(BOARD_HAL_PATH)/include
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/SEC_OMX_H264dec.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/SEC_OMX_H264dec.c
deleted file mode 100644
index 2ad34d8..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/SEC_OMX_H264dec.c
+++ /dev/null
@@ -1,2611 +0,0 @@
-/*
- *
- * Copyright 2010 Samsung Electronics S.LSI Co. LTD
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * @file SEC_OMX_H264dec.c
- * @brief
- * @author SeungBeom Kim (sbcrux.kim@samsung.com)
- * @version 1.1.0
- * @history
- * 2010.7.15 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "SEC_OMX_Macros.h"
-#include "SEC_OMX_Basecomponent.h"
-#include "SEC_OMX_Baseport.h"
-#include "SEC_OMX_Vdec.h"
-#include "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Thread.h"
-#include "library_register.h"
-#include "SEC_OMX_H264dec.h"
-#include "SsbSipMfcApi.h"
-
-#ifdef USE_ANB
-#include "SEC_OSAL_Android.h"
-#endif
-
-/* To use CSC_METHOD_PREFER_HW or CSC_METHOD_HW in SEC OMX, gralloc should allocate physical memory using FIMC */
-/* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
-#include "csc.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_H264_DEC"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-#define H264_DEC_NUM_OF_EXTRA_BUFFERS 7
-
-#ifdef S3D_SUPPORT
-#define ADD_SPS_PPS_I_FRAME
-#else
-//#define ADD_SPS_PPS_I_FRAME
-#endif
-//#define FULL_FRAME_SEARCH
-
-/* H.264 Decoder Supported Levels & profiles */
-SEC_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels[] ={
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel32},
- {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel4},
-
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1b},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel11},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel12},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel13},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel2},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel21},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel22},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel3},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel31},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel32},
- {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel4},
-
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1b},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel11},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel12},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel13},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel2},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel21},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel22},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel3},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel31},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel32},
- {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel4}};
-
-
-static int Check_H264_Frame(OMX_U8 *pInputStream, OMX_U32 buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame)
-{
- OMX_U32 preFourByte = (OMX_U32)-1;
- int accessUnitSize = 0;
- int frameTypeBoundary = 0;
- int nextNaluSize = 0;
- int naluStart = 0;
-
- if (bPreviousFrameEOF == OMX_TRUE)
- naluStart = 0;
- else
- naluStart = 1;
-
- while (1) {
- int inputOneByte = 0;
-
- if (accessUnitSize == (int)buffSize)
- goto EXIT;
-
- inputOneByte = *(pInputStream++);
- accessUnitSize += 1;
-
- if (preFourByte == 0x00000001 || (preFourByte << 8) == 0x00000100) {
- int naluType = inputOneByte & 0x1F;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "NaluType : %d", naluType);
- if (naluStart == 0) {
-#ifdef ADD_SPS_PPS_I_FRAME
- if (naluType == 1 || naluType == 5)
-#else
- if (naluType == 1 || naluType == 5 || naluType == 7 || naluType == 8)
-#endif
- naluStart = 1;
- } else {
-#ifdef OLD_DETECT
- frameTypeBoundary = (8 - naluType) & (naluType - 10); //AUD(9)
-#else
- if (naluType == 9)
- frameTypeBoundary = -2;
-#endif
- if (naluType == 1 || naluType == 5) {
- if (accessUnitSize == (int)buffSize) {
- accessUnitSize--;
- goto EXIT;
- }
- inputOneByte = *pInputStream++;
- accessUnitSize += 1;
-
- if (inputOneByte >= 0x80)
- frameTypeBoundary = -1;
- }
- if (frameTypeBoundary < 0) {
- break;
- }
- }
-
- }
- preFourByte = (preFourByte << 8) + inputOneByte;
- }
-
- *pbEndOfFrame = OMX_TRUE;
- nextNaluSize = -5;
- if (frameTypeBoundary == -1)
- nextNaluSize = -6;
- if (preFourByte != 0x00000001)
- nextNaluSize++;
- return (accessUnitSize + nextNaluSize);
-
-EXIT:
- *pbEndOfFrame = OMX_FALSE;
-
- return accessUnitSize;
-}
-
-OMX_BOOL Check_H264_StartCode(OMX_U8 *pInputStream, OMX_U32 streamSize)
-{
- if (streamSize < 4) {
- return OMX_FALSE;
- } else if ((pInputStream[0] == 0x00) &&
- (pInputStream[1] == 0x00) &&
- (pInputStream[2] == 0x00) &&
- (pInputStream[3] != 0x00) &&
- ((pInputStream[3] >> 3) == 0x00)) {
- return OMX_TRUE;
- } else if ((pInputStream[0] == 0x00) &&
- (pInputStream[1] == 0x00) &&
- (pInputStream[2] != 0x00) &&
- ((pInputStream[2] >> 3) == 0x00)) {
- return OMX_TRUE;
- } else {
- return OMX_FALSE;
- }
-}
-
-OMX_ERRORTYPE SEC_MFC_H264Dec_Alloc_SecureInputBuffer(OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_U32 nBufferSize,
- OMX_INOUT OMX_PTR *pInputBuffer_physicalAddress)
-{
- FunctionIn();
-
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
- OMX_PTR pStreamBuffer = NULL;
- OMX_PTR pStreamPhyBuffer = NULL;
-
-#ifdef USE_DRM
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pH264Dec == NULL) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- pStreamBuffer = SsbSipMfcDecAllocInputBuffer(pH264Dec->hMFCH264Handle.hMFCHandle, &pStreamPhyBuffer, nBufferSize);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorIncorrectStateOperation;
- goto EXIT;
- }
-
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pStreamPhyBuffer;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = nBufferSize;
-
- *pInputBuffer_physicalAddress = pStreamPhyBuffer;
-#endif
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264Dec_Free_SecureInputBuffer(OMX_IN OMX_HANDLETYPE hComponent,
- OMX_INOUT OMX_PTR pInputBuffer_physicalAddress)
-{
- FunctionIn();
-
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
- OMX_PTR pStreamPhyBuffer = NULL;
-
-#ifdef USE_DRM
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pH264Dec == NULL) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- pStreamPhyBuffer = pInputBuffer_physicalAddress;
- SsbSipMfcDecFreeInputBuffer(pH264Dec->hMFCH264Handle.hMFCHandle, pStreamPhyBuffer);
-#endif
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264Dec_GetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nParamIndex,
- OMX_INOUT OMX_PTR pComponentParameterStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nParamIndex) {
- case OMX_IndexParamVideoAvc:
- {
- OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSrcAVCComponent = &pH264Dec->AVCComponent[pDstAVCComponent->nPortIndex];
-
- SEC_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
- }
- break;
- case OMX_IndexParamStandardComponentRole:
- {
- OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
- ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPONENT_H264_DEC_ROLE);
- }
- break;
- case OMX_IndexParamVideoProfileLevelQuerySupported:
- {
- OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
- SEC_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
- OMX_U32 maxProfileLevelNum = 0;
-
- ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pProfileLevel = supportedAVCProfileLevels;
- maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
-
- if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
- ret = OMX_ErrorNoMore;
- goto EXIT;
- }
-
- pProfileLevel += pDstProfileLevel->nProfileIndex;
- pDstProfileLevel->eProfile = pProfileLevel->profile;
- pDstProfileLevel->eLevel = pProfileLevel->level;
- }
- break;
- case OMX_IndexParamVideoProfileLevelCurrent:
- {
- OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
- OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSrcAVCComponent = &pH264Dec->AVCComponent[pDstProfileLevel->nPortIndex];
-
- pDstProfileLevel->eProfile = pSrcAVCComponent->eProfile;
- pDstProfileLevel->eLevel = pSrcAVCComponent->eLevel;
- }
- break;
- case OMX_IndexParamVideoErrorCorrection:
- {
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSrcErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
-
- pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
- pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
- pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
- pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
- pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
- }
- break;
- default:
- ret = SEC_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
- break;
- }
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264Dec_SetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR pComponentParameterStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- case OMX_IndexParamVideoAvc:
- {
- OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
- OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pDstAVCComponent = &pH264Dec->AVCComponent[pSrcAVCComponent->nPortIndex];
-
- SEC_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
- }
- break;
- case OMX_IndexParamStandardComponentRole:
- {
- OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
-
- ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
- ret = OMX_ErrorIncorrectStateOperation;
- goto EXIT;
- }
-
- if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPONENT_H264_DEC_ROLE)) {
- pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
- } else {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- }
- break;
- case OMX_IndexParamPortDefinition:
- {
- OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
- OMX_U32 portIndex = pPortDefinition->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort;
- OMX_U32 width, height, size;
- OMX_U32 realWidth, realHeight;
-
- if (portIndex >= pSECComponent->portParam.nPorts) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
- ret = SEC_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[portIndex];
-
- if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
- if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
- ret = OMX_ErrorIncorrectStateOperation;
- goto EXIT;
- }
- }
- if (pPortDefinition->nBufferCountActual < pSECPort->portDefinition.nBufferCountMin) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- SEC_OSAL_Memcpy(&pSECPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
-
- realWidth = pSECPort->portDefinition.format.video.nFrameWidth;
- realHeight = pSECPort->portDefinition.format.video.nFrameHeight;
- width = ((realWidth + 15) & (~15));
- height = ((realHeight + 15) & (~15));
- size = (width * height * 3) / 2;
- pSECPort->portDefinition.format.video.nStride = width;
- pSECPort->portDefinition.format.video.nSliceHeight = height;
- pSECPort->portDefinition.nBufferSize = (size > pSECPort->portDefinition.nBufferSize) ? size : pSECPort->portDefinition.nBufferSize;
-
- if (portIndex == INPUT_PORT_INDEX) {
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECOutputPort->portDefinition.format.video.nFrameWidth = pSECPort->portDefinition.format.video.nFrameWidth;
- pSECOutputPort->portDefinition.format.video.nFrameHeight = pSECPort->portDefinition.format.video.nFrameHeight;
- pSECOutputPort->portDefinition.format.video.nStride = width;
- pSECOutputPort->portDefinition.format.video.nSliceHeight = height;
-
- switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
- case OMX_COLOR_FormatYUV420Planar:
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
- break;
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pSECOutputPort->portDefinition.nBufferSize =
- ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight)) \
- + ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight/2));
- break;
- default:
- SEC_OSAL_Log(SEC_LOG_ERROR, "Color format is not support!! use default YUV size!!");
- ret = OMX_ErrorUnsupportedSetting;
- break;
- }
- }
- }
- break;
- case OMX_IndexParamVideoProfileLevelCurrent:
- {
- OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
- if (ret != OMX_ErrorNone)
- goto EXIT;
-
- if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- pDstAVCComponent = &pH264Dec->AVCComponent[pSrcProfileLevel->nPortIndex];
- pDstAVCComponent->eProfile = pSrcProfileLevel->eProfile;
- pDstAVCComponent->eLevel = pSrcProfileLevel->eLevel;
- }
- break;
- case OMX_IndexParamVideoErrorCorrection:
- {
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pDstErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
-
- pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
- pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
- pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
- pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
- pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
- }
- break;
- default:
- ret = SEC_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
- break;
- }
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264Dec_GetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- if (pComponentConfigStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (pSECComponent->currentState == OMX_StateInvalid) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- case OMX_IndexConfigCommonOutputCrop:
- {
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
- OMX_CONFIG_RECTTYPE *pSrcRectType = NULL;
- OMX_CONFIG_RECTTYPE *pDstRectType = NULL;
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
- ret = OMX_ErrorNotReady;
- break;
- }
-
- pDstRectType = (OMX_CONFIG_RECTTYPE *)pComponentConfigStructure;
-
- if ((pDstRectType->nPortIndex != INPUT_PORT_INDEX) &&
- (pDstRectType->nPortIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- SEC_OMX_BASEPORT *pSECPort = &pSECComponent->pSECPort[pDstRectType->nPortIndex];
-
- pSrcRectType = &(pSECPort->cropRectangle);
-
- pDstRectType->nTop = pSrcRectType->nTop;
- pDstRectType->nLeft = pSrcRectType->nLeft;
- pDstRectType->nHeight = pSrcRectType->nHeight;
- pDstRectType->nWidth = pSrcRectType->nWidth;
- }
- break;
- default:
- ret = SEC_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264Dec_SetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- if (pComponentConfigStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (pSECComponent->currentState == OMX_StateInvalid) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- default:
- ret = SEC_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264Dec_GetExtensionIndex(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_STRING cParameterName,
- OMX_OUT OMX_INDEXTYPE *pIndexType)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- if ((cParameterName == NULL) || (pIndexType == NULL)) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (pSECComponent->currentState == OMX_StateInvalid) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
- SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- *pIndexType = OMX_IndexVendorThumbnailMode;
-
- ret = OMX_ErrorNone;
- } else {
- ret = SEC_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264Dec_ComponentRoleEnum(OMX_HANDLETYPE hComponent, OMX_U8 *cRole, OMX_U32 nIndex)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if ((hComponent == NULL) || (cRole == NULL)) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
- SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPONENT_H264_DEC_ROLE);
- ret = OMX_ErrorNone;
- } else {
- ret = OMX_ErrorNoMore;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_DecodeThread(OMX_HANDLETYPE hComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- while (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
- SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameStart);
-
- if (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_DEC);
-#endif
- pH264Dec->hMFCH264Handle.returnCodec = SsbSipMfcDecExe(pH264Dec->hMFCH264Handle.hMFCHandle, pVideoDec->NBDecThread.oneFrameSize);
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_DEC);
-#endif
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameEnd);
- }
- }
-
-EXIT:
- SEC_OSAL_ThreadExit(NULL);
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Init */
-OMX_ERRORTYPE SEC_MFC_H264Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
- OMX_PTR pStreamBuffer = NULL;
- OMX_PTR pStreamPhyBuffer = NULL;
- OMX_PTR hMFCHandle;
-
-#ifdef S3D_SUPPORT
- OMX_S32 setConfVal = 0;
-#endif
- CSC_METHOD csc_method = CSC_METHOD_SW;
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfInit(PERF_ID_DEC);
- SEC_OSAL_PerfInit(PERF_ID_CSC);
-#endif
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_FALSE;
- pSECComponent->bUseFlagEOF = OMX_FALSE;
- pSECComponent->bSaveFlagEOS = OMX_FALSE;
-
- /* MFC(Multi Function Codec) decoder and CMM(Codec Memory Management) driver open */
- if (pVideoDec->bDRMPlayerMode == OMX_FALSE) {
- hMFCHandle = NULL;
-
- if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress) {
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen();
- } else {
- SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpenExt(&buf_type);
- }
-
- if (hMFCHandle == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pH264Dec->hMFCH264Handle.hMFCHandle = hMFCHandle;
- } else {
- hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
- pSECComponent->bUseFlagEOF = OMX_TRUE;
- }
-
-#ifdef S3D_SUPPORT
- /*Enable SEI parsing for checking frame_packing S3D*/
- setConfVal = 1;
- SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_SEI_PARSE, &setConfVal);
-#endif
-
- /* Allocate decoder's input buffer */
- /* Get first input buffer */
- if (pVideoDec->bDRMPlayerMode == OMX_FALSE) {
- pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoDec->MFCDecInputBuffer[0].VirAddr = pStreamBuffer;
- pVideoDec->MFCDecInputBuffer[0].PhyAddr = pStreamPhyBuffer;
- pVideoDec->MFCDecInputBuffer[0].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2;
- pVideoDec->MFCDecInputBuffer[0].dataSize = 0;
-
-#ifdef NONBLOCK_MODE_PROCESS
- /* Get second input buffer */
- pStreamBuffer = NULL;
- pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoDec->MFCDecInputBuffer[1].VirAddr = pStreamBuffer;
- pVideoDec->MFCDecInputBuffer[1].PhyAddr = pStreamPhyBuffer;
- pVideoDec->MFCDecInputBuffer[1].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2;
- pVideoDec->MFCDecInputBuffer[1].dataSize = 0;
- pVideoDec->indexInputBuffer = 0;
-
- pVideoDec->bFirstFrame = OMX_TRUE;
-
- pVideoDec->NBDecThread.bExitDecodeThread = OMX_FALSE;
- pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE;
- pVideoDec->NBDecThread.oneFrameSize = 0;
- SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameStart));
- SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameEnd));
- if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pVideoDec->NBDecThread.hNBDecodeThread,
- SEC_MFC_DecodeThread,
- pOMXComponent)) {
- pH264Dec->hMFCH264Handle.returnCodec = MFC_RET_OK;
- }
-#endif
-
- pH264Dec->hMFCH264Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr;
- pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[0].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[0].bufferSize;
- }
-
- SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
- SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
- pH264Dec->hMFCH264Handle.indexTimestamp = 0;
- pH264Dec->hMFCH264Handle.outputIndexTimestamp = 0;
-
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
-
-#ifdef USE_ANB
-#if defined(USE_CSC_FIMC) || defined(USE_CSC_GSCALER)
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE)
- csc_method = CSC_METHOD_PREFER_HW;
-#endif
- if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
- csc_method = CSC_METHOD_HW;
- }
-#endif
- pVideoDec->csc_handle = csc_init(&csc_method);
- pVideoDec->csc_set_format = OMX_FALSE;
-
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s::csc_method=%d", __func__, csc_method);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Terminate */
-OMX_ERRORTYPE SEC_MFC_H264Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
- OMX_PTR hMFCHandle = NULL;
-
- FunctionIn();
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfPrint("[DEC]", PERF_ID_DEC);
- SEC_OSAL_PerfPrint("[CSC]", PERF_ID_CSC);
-#endif
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
-
- pH264Dec->hMFCH264Handle.pMFCStreamBuffer = NULL;
- pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = NULL;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = NULL;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = 0;
-
- if (pVideoDec->bDRMPlayerMode == OMX_FALSE) {
-#ifdef NONBLOCK_MODE_PROCESS
- if (pVideoDec->NBDecThread.hNBDecodeThread != NULL) {
- pVideoDec->NBDecThread.bExitDecodeThread = OMX_TRUE;
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
- SEC_OSAL_ThreadTerminate(pVideoDec->NBDecThread.hNBDecodeThread);
- pVideoDec->NBDecThread.hNBDecodeThread = NULL;
- }
-
- if(pVideoDec->NBDecThread.hDecFrameEnd != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameEnd);
- pVideoDec->NBDecThread.hDecFrameEnd = NULL;
- }
-
- if(pVideoDec->NBDecThread.hDecFrameStart != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameStart);
- pVideoDec->NBDecThread.hDecFrameStart = NULL;
- }
-#endif
- }
-
- if (pVideoDec->bDRMPlayerMode == OMX_FALSE) {
- if (hMFCHandle != NULL) {
- SsbSipMfcDecClose(hMFCHandle);
- hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle = NULL;
- }
- }
-
- if (pVideoDec->csc_handle != NULL) {
- csc_deinit(pVideoDec->csc_handle);
- pVideoDec->csc_handle = NULL;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264_Decode_Nonblock(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 setConfVal = 0;
- int bufWidth = 0;
- int bufHeight = 0;
- OMX_U32 FrameBufferYSize = 0;
- OMX_U32 FrameBufferUVSize = 0;
- OMX_BOOL outputDataValid = OMX_FALSE;
-#ifdef S3D_SUPPORT
- SSBSIP_MFC_FRAME_PACKING frame_packing;
-#endif
-
- FunctionIn();
-
- if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
- SSBSIP_MFC_CODEC_TYPE eCodecType = H264_DEC;
-
- if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
- /* Default number in the driver is optimized */
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- setConfVal = 0;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- } else {
- setConfVal = H264_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &setConfVal);
-
- setConfVal = 8;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- }
-
- SsbSipMfcDecSetInBuf(pH264Dec->hMFCH264Handle.hMFCHandle,
- pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer,
- pH264Dec->hMFCH264Handle.pMFCStreamBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- pH264Dec->hMFCH264Handle.returnCodec = SsbSipMfcDecInit(pH264Dec->hMFCH264Handle.hMFCHandle, eCodecType, oneFrameSize);
- if (pH264Dec->hMFCH264Handle.returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
- SSBSIP_MFC_CROP_INFORMATION cropInfo;
-
- SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol);
- SEC_OSAL_Log(SEC_LOG_TRACE, "set width height information : %d, %d",
- pSECInputPort->portDefinition.format.video.nFrameWidth,
- pSECInputPort->portDefinition.format.video.nFrameHeight);
- SEC_OSAL_Log(SEC_LOG_TRACE, "mfc width height information : %d, %d",
- imgResol.width, imgResol.height);
-
- SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_CROP_INFO, &cropInfo);
- SEC_OSAL_Log(SEC_LOG_TRACE, "mfc crop_top crop_bottom crop_left crop_right : %d, %d, %d, %d",
- cropInfo.crop_top_offset , cropInfo.crop_bottom_offset ,
- cropInfo.crop_left_offset , cropInfo.crop_right_offset);
-
- pSECOutputPort->cropRectangle.nTop = cropInfo.crop_top_offset;
- pSECOutputPort->cropRectangle.nLeft = cropInfo.crop_left_offset;
- pSECOutputPort->cropRectangle.nWidth = imgResol.width - cropInfo.crop_left_offset - cropInfo.crop_right_offset;
- pSECOutputPort->cropRectangle.nHeight = imgResol.height - cropInfo.crop_top_offset - cropInfo.crop_bottom_offset;
-
- pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_TRUE;
-
- /** Update Frame Size **/
- if ((cropInfo.crop_left_offset != 0) || (cropInfo.crop_right_offset != 0) ||
- (cropInfo.crop_top_offset != 0) || (cropInfo.crop_bottom_offset != 0)) {
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /** Send crop info call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- OMX_IndexConfigCommonOutputCrop,
- NULL);
- }
- if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
- SEC_OSAL_Log(SEC_LOG_TRACE, "change width height information : OMX_EventPortSettingsChanged");
-
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /** Send Port Settings changed call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- 0,
- NULL);
- }
-
-#ifdef ADD_SPS_PPS_I_FRAME
- ret = OMX_ErrorInputDataDecodeYet;
-#else
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- ret = OMX_ErrorNone;
-#endif
- goto EXIT;
- } else {
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
- }
-
-#ifndef FULL_FRAME_SEARCH
- if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
- (pSECComponent->bUseFlagEOF == OMX_FALSE))
- pSECComponent->bUseFlagEOF = OMX_TRUE;
-#endif
-
- pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->nFlags;
-
- if ((pH264Dec->hMFCH264Handle.returnCodec == MFC_RET_OK) &&
- (pVideoDec->bFirstFrame == OMX_FALSE)) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- /* wait for mfc decode done */
- if (pVideoDec->NBDecThread.bDecoderRun == OMX_TRUE) {
- SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameEnd);
- pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE;
- }
-
- SEC_OSAL_SleepMillisec(0);
- status = SsbSipMfcDecGetOutBuf(pH264Dec->hMFCH264Handle.hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
-#ifdef S3D_SUPPORT
- /* Check Whether frame packing information is available */
- SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_PACKING, &frame_packing);
-
- if (pVideoDec->bThumbnailMode == OMX_FALSE &&
- frame_packing.available &&
- pH264Dec->hMFCH264Handle.bS3DMode == OMX_FALSE) {
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "arrangement ID: 0x%08x", frame_packing.arrangement_id);
- SEC_OSAL_Log(SEC_LOG_TRACE, "arrangement_type: %d", frame_packing.arrangement_type);
- SEC_OSAL_Log(SEC_LOG_TRACE, "content_interpretation_type: %d", frame_packing.content_interpretation_type);
- SEC_OSAL_Log(SEC_LOG_TRACE, "current_frame_is_frame0_flag: %d", frame_packing.current_frame_is_frame0_flag);
- SEC_OSAL_Log(SEC_LOG_TRACE, "spatial_flipping_flag: %d", frame_packing.spatial_flipping_flag);
- SEC_OSAL_Log(SEC_LOG_TRACE, "fr0X:%d fr0Y:%d fr0X:%d fr0Y:%d", frame_packing.frame0_grid_pos_x,
- frame_packing.frame0_grid_pos_y, frame_packing.frame1_grid_pos_x, frame_packing.frame1_grid_pos_y);
-
- /* Change Outport eColorFormat based on Framepacking information*/
- if (frame_packing.arrangement_type == 3) {
- if (frame_packing.content_interpretation_type == 1) {
- switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled_SBS_LR;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_LR;
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420Planar_SBS_LR;
- break;
- }
- } else if (frame_packing.content_interpretation_type == 2) {
- switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled_SBS_RL;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_RL;
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420Planar_SBS_RL;
- break;
- }
- }
- } else if (frame_packing.arrangement_type == 4) {
- if (frame_packing.content_interpretation_type == 1) {
- switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled_TB_LR;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_LR;
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420Planar_TB_LR;
- break;
- }
- } else if (frame_packing.content_interpretation_type == 2) {
- switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled_TB_RL;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_RL;
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- pSECOutputPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatYUV420Planar_TB_RL;
- break;
- }
- }
- }
-
- /** Send Port Settings changed call back - output color format change */
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- 0,
- NULL);
-
- if ((pSECOutputPort->cropRectangle.nTop != 0) || (pSECOutputPort->cropRectangle.nLeft != 0)) {
- /** Send crop info call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- OMX_IndexConfigCommonOutputCrop,
- NULL);
- }
- pH264Dec->hMFCH264Handle.bS3DMode = OMX_TRUE;
- SEC_OSAL_SleepMillisec(0);
- ret = OMX_ErrorInputDataDecodeYet;
- goto EXIT;
- }
-#endif
-
- if ((SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
- (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if ((outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) ||
- (pH264Dec->hMFCH264Handle.bFlashPlayerMode == OMX_TRUE)) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pH264Dec->hMFCH264Handle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6);
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- outputDataValid = OMX_TRUE;
- pH264Dec->hMFCH264Handle.outputIndexTimestamp++;
- pH264Dec->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- outputDataValid = OMX_FALSE;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE))
- ret = OMX_ErrorInputDataDecodeYet;
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- outputDataValid = OMX_FALSE;
- }
-
-#ifdef FULL_FRAME_SEARCH
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else
-#endif
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
-
- if ((pVideoDec->bFirstFrame == OMX_TRUE) &&
- ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) &&
- ((pInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) != OMX_BUFFERFLAG_CODECCONFIG)) {
- pOutputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- }
-
- outputDataValid = OMX_FALSE;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- }
-
- if (ret == OMX_ErrorInputDataDecodeYet) {
- pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
- pVideoDec->indexInputBuffer++;
- pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- pH264Dec->hMFCH264Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize;
- oneFrameSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize;
- //pInputData->dataLen = oneFrameSize;
- //pInputData->remainDataLen = oneFrameSize;
- }
-
- if ((Check_H264_StartCode(pInputData->dataBuffer, oneFrameSize) == OMX_TRUE) &&
- ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
- if ((ret != OMX_ErrorInputDataDecodeYet) || (pSECComponent->getAllDelayBuffer == OMX_TRUE)) {
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pH264Dec->hMFCH264Handle.indexTimestamp));
- pH264Dec->hMFCH264Handle.indexTimestamp++;
- pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
- }
-
- SsbSipMfcDecSetInBuf(pH264Dec->hMFCH264Handle.hMFCHandle,
- pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer,
- pH264Dec->hMFCH264Handle.pMFCStreamBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
- pVideoDec->NBDecThread.oneFrameSize = oneFrameSize;
-
- /* mfc decode start */
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
- pVideoDec->NBDecThread.bDecoderRun = OMX_TRUE;
- pH264Dec->hMFCH264Handle.returnCodec = MFC_RET_OK;
-
- SEC_OSAL_SleepMillisec(0);
-
- pVideoDec->indexInputBuffer++;
- pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- pH264Dec->hMFCH264Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pH264Dec->hMFCH264Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize;
-
- if ((pVideoDec->bFirstFrame == OMX_TRUE) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE) &&
- (outputDataValid == OMX_FALSE)) {
- ret = OMX_ErrorInputDataDecodeYet;
- }
-
- pVideoDec->bFirstFrame = OMX_FALSE;
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
- }
-
- /** Fill Output Buffer **/
- if (outputDataValid == OMX_TRUE) {
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int actualWidth = outputInfo.img_width;
- int actualHeight = outputInfo.img_height;
- int actualImageSize = actualWidth * actualHeight;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + actualImageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + actualImageSize + actualImageSize / 4;
- pOutputData->dataLen = (actualImageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- OMX_U32 stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, actualWidth, actualHeight, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- actualWidth = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
-
- if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
- (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
- /* if use Post copy address structure */
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (actualWidth * actualHeight * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420p out for ThumbnailMode/Flash player mode");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
-#ifdef S3D_SUPPORT
- case OMX_SEC_COLOR_FormatNV12Tiled_SBS_LR:
- case OMX_SEC_COLOR_FormatNV12Tiled_SBS_RL:
- case OMX_SEC_COLOR_FormatNV12Tiled_TB_LR:
- case OMX_SEC_COLOR_FormatNV12Tiled_TB_RL:
-#endif
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
-#ifdef S3D_SUPPORT
- case OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_LR:
- case OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_RL:
- case OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_LR:
- case OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_RL:
-#endif
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
-#ifdef S3D_SUPPORT
- case OMX_SEC_COLOR_FormatYUV420Planar_SBS_LR:
- case OMX_SEC_COLOR_FormatYUV420Planar_SBS_RL:
- case OMX_SEC_COLOR_FormatYUV420Planar_TB_LR:
- case OMX_SEC_COLOR_FormatYUV420Planar_TB_RL:
-#endif
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- actualWidth, /* width */
- actualHeight, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- actualWidth, /* crop_width */
- actualHeight, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- actualWidth, /* width */
- actualHeight, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- actualWidth, /* crop_width */
- actualHeight, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle, /* handle */
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
- }
-#endif
- } else {
- pOutputData->dataLen = 0;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264_Decode_Block(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 setConfVal = 0;
- OMX_S32 returnCodec = 0;
- int bufWidth = 0;
- int bufHeight = 0;
- OMX_U32 FrameBufferYSize;
- OMX_U32 FrameBufferUVSize;
-
- FunctionIn();
-
- if (pH264Dec->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
- SSBSIP_MFC_CODEC_TYPE eCodecType = H264_DEC;
-
- if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
- /* Default number in the driver is optimized */
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- setConfVal = 0;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- } else {
- setConfVal = H264_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &setConfVal);
-
- setConfVal = 8;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- }
-
- returnCodec = SsbSipMfcDecInit(pH264Dec->hMFCH264Handle.hMFCHandle, eCodecType, oneFrameSize);
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
- SSBSIP_MFC_CROP_INFORMATION cropInfo;
-
- SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol);
- SEC_OSAL_Log(SEC_LOG_TRACE, "set width height information : %d, %d",
- pSECInputPort->portDefinition.format.video.nFrameWidth,
- pSECInputPort->portDefinition.format.video.nFrameHeight);
- SEC_OSAL_Log(SEC_LOG_TRACE, "mfc width height information : %d, %d",
- imgResol.width, imgResol.height);
-
- SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_CROP_INFO, &cropInfo);
- SEC_OSAL_Log(SEC_LOG_TRACE, "mfc crop_top crop_bottom crop_left crop_right : %d, %d, %d, %d",
- cropInfo.crop_top_offset , cropInfo.crop_bottom_offset ,
- cropInfo.crop_left_offset , cropInfo.crop_right_offset);
-
- pSECOutputPort->cropRectangle.nTop = cropInfo.crop_top_offset;
- pSECOutputPort->cropRectangle.nLeft = cropInfo.crop_left_offset;
- pSECOutputPort->cropRectangle.nWidth = imgResol.width - cropInfo.crop_left_offset - cropInfo.crop_right_offset;
- pSECOutputPort->cropRectangle.nHeight = imgResol.height - cropInfo.crop_top_offset - cropInfo.crop_bottom_offset;
-
- pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_TRUE;
-
- /** Update Frame Size **/
- if ((cropInfo.crop_left_offset != 0) || (cropInfo.crop_right_offset != 0) ||
- (cropInfo.crop_top_offset != 0) || (cropInfo.crop_bottom_offset != 0)) {
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /** Send crop info call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- OMX_IndexConfigCommonOutputCrop,
- NULL);
- }
- if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
- SEC_OSAL_Log(SEC_LOG_TRACE, "change width height information : OMX_EventPortSettingsChanged");
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /** Send Port Settings changed call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- 0,
- NULL);
- }
-
-#ifdef ADD_SPS_PPS_I_FRAME
- ret = OMX_ErrorInputDataDecodeYet;
-#else
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- ret = OMX_ErrorNone;
-#endif
- goto EXIT;
- } else {
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
- }
-
-#ifndef FULL_FRAME_SEARCH
- if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
- (pSECComponent->bUseFlagEOF == OMX_FALSE))
- pSECComponent->bUseFlagEOF = OMX_TRUE;
-#endif
-
- if (Check_H264_StartCode(pInputData->dataBuffer, pInputData->dataLen) == OMX_TRUE) {
- pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->nFlags;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pH264Dec->hMFCH264Handle.indexTimestamp));
-
- returnCodec = SsbSipMfcDecExe(pH264Dec->hMFCH264Handle.hMFCHandle, oneFrameSize);
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
-
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- returnCodec = MFC_RET_OK;
- goto EXIT;
- }
-
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- status = SsbSipMfcDecGetOutBuf(pH264Dec->hMFCH264Handle.hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
- if (status != MFC_GETOUTBUF_DISPLAY_ONLY) {
- pH264Dec->hMFCH264Handle.indexTimestamp++;
- pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
- }
-
- if ((SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
- (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if ((outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) ||
- (pH264Dec->hMFCH264Handle.bFlashPlayerMode != OMX_FALSE)) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pH264Dec->hMFCH264Handle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6);
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- /** Fill Output Buffer **/
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int actualWidth = outputInfo.img_width;
- int actualHeight = outputInfo.img_height;
- int actualImageSize = actualWidth * actualHeight;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + actualImageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + actualImageSize + actualImageSize / 4;
- pOutputData->dataLen = (actualImageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- OMX_U32 stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, actualWidth, actualHeight, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- actualWidth = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
- if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
- (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
- /* if use Post copy address structure */
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (actualWidth * actualHeight * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420p out for ThumbnailMode/Flash player mode");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- actualWidth, /* width */
- actualHeight, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- actualWidth, /* crop_width */
- actualHeight, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- actualWidth, /* width */
- actualHeight, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- actualWidth, /* crop_width */
- actualHeight, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle, /* handle */
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
- }
-#endif
- pH264Dec->hMFCH264Handle.outputIndexTimestamp++;
- pH264Dec->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- pOutputData->dataLen = 0;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE))
- ret = OMX_ErrorInputDataDecodeYet;
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- goto EXIT;
- }
-
-#ifdef FULL_FRAME_SEARCH
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else
-#endif
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
- pOutputData->dataLen = 0;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264_Decode_DRM(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 setConfVal = 0;
- OMX_S32 returnCodec = 0;
- int bufWidth = 0;
- int bufHeight = 0;
- OMX_U32 FrameBufferYSize;
- OMX_U32 FrameBufferUVSize;
- // DRM
- OMX_PTR pInputPhysBuffer;
- OMX_PTR pInputVirtBuffer;
-
- 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;
- }
-
- /* Set the number of extra buffer to prevent tearing */
- /* DRM Play mode is returned only PhysicalAddress */
- setConfVal = H264_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &setConfVal);
-
- /* Default number in the driver is optimized */
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- setConfVal = 0;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- } else {
- setConfVal = 8;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- }
-
- pInputPhysBuffer = pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer;
- pInputVirtBuffer = NULL; /* ??????????? */
-
- SEC_OSAL_Log(SEC_LOG_ERROR, "pInputPhysBuffer = 0x%x, allocSize = 0x%0x", pInputPhysBuffer, pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- SsbSipMfcDecSetInBuf(pH264Dec->hMFCH264Handle.hMFCHandle,
- pInputPhysBuffer, pInputVirtBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- returnCodec = SsbSipMfcDecInit(pH264Dec->hMFCH264Handle.hMFCHandle, eCodecType, oneFrameSize);
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
- SSBSIP_MFC_CROP_INFORMATION cropInfo;
-
- SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol);
- SEC_OSAL_Log(SEC_LOG_TRACE, "set width height information : %d, %d",
- pSECInputPort->portDefinition.format.video.nFrameWidth,
- pSECInputPort->portDefinition.format.video.nFrameHeight);
- SEC_OSAL_Log(SEC_LOG_TRACE, "mfc width height information : %d, %d",
- imgResol.width, imgResol.height);
-
- SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_CROP_INFO, &cropInfo);
- SEC_OSAL_Log(SEC_LOG_TRACE, "mfc crop_top crop_bottom crop_left crop_right : %d, %d, %d, %d",
- cropInfo.crop_top_offset , cropInfo.crop_bottom_offset ,
- cropInfo.crop_left_offset , cropInfo.crop_right_offset);
-
- pSECOutputPort->cropRectangle.nTop = cropInfo.crop_top_offset;
- pSECOutputPort->cropRectangle.nLeft = cropInfo.crop_left_offset;
- pSECOutputPort->cropRectangle.nWidth = imgResol.width - cropInfo.crop_left_offset - cropInfo.crop_right_offset;
- pSECOutputPort->cropRectangle.nHeight = imgResol.height - cropInfo.crop_top_offset - cropInfo.crop_bottom_offset;
-
- pH264Dec->hMFCH264Handle.bConfiguredMFC = OMX_TRUE;
-
- /** Update Frame Size **/
- if ((cropInfo.crop_left_offset != 0) || (cropInfo.crop_right_offset != 0) ||
- (cropInfo.crop_top_offset != 0) || (cropInfo.crop_bottom_offset != 0)) {
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /** Send crop info call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- OMX_IndexConfigCommonOutputCrop,
- NULL);
- }
- if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
- SEC_OSAL_Log(SEC_LOG_TRACE, "change width height information : OMX_EventPortSettingsChanged");
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /** Send Port Settings changed call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- 0,
- NULL);
- }
-
-#ifdef ADD_SPS_PPS_I_FRAME
- ret = OMX_ErrorInputDataDecodeYet;
-#else
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- ret = OMX_ErrorNone;
-#endif
- goto EXIT;
- } else {
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
- }
-
- if ((pInputData->dataBuffer != NULL) && (pInputData->dataLen != 0)) {
- pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pInputData->nFlags;
- SsbSipMfcDecSetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pH264Dec->hMFCH264Handle.indexTimestamp));
- if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
- pInputPhysBuffer = pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer;
- pInputVirtBuffer = NULL; /* ??????????? */
-
- SsbSipMfcDecSetInBuf(pH264Dec->hMFCH264Handle.hMFCHandle,
- pInputPhysBuffer, pInputVirtBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
- }
- returnCodec = SsbSipMfcDecExe(pH264Dec->hMFCH264Handle.hMFCHandle, oneFrameSize);
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
-
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- returnCodec = MFC_RET_OK;
- goto EXIT;
- }
-
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- status = SsbSipMfcDecGetOutBuf(pH264Dec->hMFCH264Handle.hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
- if (status != MFC_GETOUTBUF_DISPLAY_ONLY) {
- pH264Dec->hMFCH264Handle.indexTimestamp++;
- pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
- }
-
- if ((SsbSipMfcDecGetConfig(pH264Dec->hMFCH264Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
- (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if ((outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) ||
- (pH264Dec->hMFCH264Handle.bFlashPlayerMode != OMX_FALSE)) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pH264Dec->hMFCH264Handle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6);
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- /** Fill Output Buffer **/
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int actualWidth = outputInfo.img_width;
- int actualHeight = outputInfo.img_height;
- int actualImageSize = actualWidth * actualHeight;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + actualImageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + actualImageSize + actualImageSize / 4;
- pOutputData->dataLen = (actualImageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- OMX_U32 stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, actualWidth, actualHeight, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- actualWidth = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
- if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress) {
- /* if use Post copy address structure */
- SEC_OSAL_Log(SEC_LOG_TRACE, "DRM] physical address data mode");
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (actualWidth * actualHeight * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "DRM] Real data method");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- actualWidth, /* width */
- actualHeight, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- actualWidth, /* crop_width */
- actualHeight, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- actualWidth, /* width */
- actualHeight, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- actualWidth, /* crop_width */
- actualHeight, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle, /* handle */
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE)
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
-#endif
- pH264Dec->hMFCH264Handle.outputIndexTimestamp++;
- pH264Dec->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- pOutputData->dataLen = 0;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE))
- ret = OMX_ErrorInputDataDecodeYet;
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- goto EXIT;
- }
-
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
- pOutputData->dataLen = 0;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Decode */
-OMX_ERRORTYPE SEC_MFC_H264Dec_bufferProcess(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_H264DEC_HANDLE *pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- OMX_BOOL endOfFrame = OMX_FALSE;
-
- FunctionIn();
-
- if ((!CHECK_PORT_ENABLED(pSECInputPort)) || (!CHECK_PORT_ENABLED(pSECOutputPort)) ||
- (!CHECK_PORT_POPULATED(pSECInputPort)) || (!CHECK_PORT_POPULATED(pSECOutputPort))) {
- ret = OMX_ErrorNone;
- goto EXIT;
- }
- if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
- if (pVideoDec->bDRMPlayerMode == OMX_FALSE) {
-#ifdef NONBLOCK_MODE_PROCESS
- ret = SEC_MFC_H264_Decode_Nonblock(pOMXComponent, pInputData, pOutputData);
-#else
- ret = SEC_MFC_H264_Decode_Block(pOMXComponent, pInputData, pOutputData);
-#endif
- } else {
- ret = SEC_MFC_H264_Decode_DRM(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_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
- SEC_H264DEC_HANDLE *pH264Dec = NULL;
- OMX_BOOL bDRMPlayerMode = OMX_FALSE;
- OMX_BOOL bFlashPlayerMode = OMX_FALSE;
- int i = 0;
-
- FunctionIn();
-
- if ((hComponent == NULL) || (componentName == NULL)) {
- ret = OMX_ErrorBadParameter;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
- goto EXIT;
- }
- if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_H264_DEC, componentName) == 0) {
- bDRMPlayerMode = OMX_FALSE;
- bFlashPlayerMode = OMX_FALSE;
- } else if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_H264_DRM_DEC, componentName) == 0) {
- bDRMPlayerMode = OMX_TRUE;
- bFlashPlayerMode = OMX_FALSE;
- } else if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_H264_FP_DEC, componentName) == 0) {
- bDRMPlayerMode = OMX_FALSE;
- bFlashPlayerMode = OMX_TRUE;
- } else {
- ret = OMX_ErrorBadParameter;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
- goto EXIT;
- }
-
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_VideoDecodeComponentInit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- pSECComponent->codecType = HW_VIDEO_DEC_CODEC;
-
- pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
- if (pSECComponent->componentName == NULL) {
- SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
- SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
-
- pH264Dec = SEC_OSAL_Malloc(sizeof(SEC_H264DEC_HANDLE));
- if (pH264Dec == NULL) {
- SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
- SEC_OSAL_Memset(pH264Dec, 0, sizeof(SEC_H264DEC_HANDLE));
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pH264Dec;
-
- if (bDRMPlayerMode == OMX_TRUE)
- SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_H264_DRM_DEC);
- else if (bFlashPlayerMode == OMX_TRUE)
- SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_H264_FP_DEC);
- else
- SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_H264_DEC);
-
- pVideoDec->bDRMPlayerMode = bDRMPlayerMode;
- pH264Dec->hMFCH264Handle.bFlashPlayerMode = bFlashPlayerMode;
-#ifdef S3D_SUPPORT
- pH264Dec->hMFCH264Handle.bS3DMode = OMX_FALSE;
-#endif
-
- /* Set componentVersion */
- pSECComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
- pSECComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
- pSECComponent->componentVersion.s.nRevision = REVISION_NUMBER;
- pSECComponent->componentVersion.s.nStep = STEP_NUMBER;
- /* Set specVersion */
- pSECComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
- pSECComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
- pSECComponent->specVersion.s.nRevision = REVISION_NUMBER;
- pSECComponent->specVersion.s.nStep = STEP_NUMBER;
-
- /* Android CapabilityFlags */
- pSECComponent->capabilityFlags.iIsOMXComponentMultiThreaded = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentSupportsExternalInputBufferAlloc = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentSupportsExternalOutputBufferAlloc = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentSupportsMovableInputBuffers = OMX_FALSE;
- pSECComponent->capabilityFlags.iOMXComponentSupportsPartialFrames = OMX_FALSE;
- pSECComponent->capabilityFlags.iOMXComponentUsesNALStartCodes = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentCanHandleIncompleteFrames = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentUsesFullAVCFrames = OMX_TRUE;
-
- /* Input port */
- pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
- pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
- pSECPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
- pSECPort->portDefinition.format.video.nSliceHeight = 0;
- pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
- pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
- SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/avc");
- pSECPort->portDefinition.format.video.pNativeRender = 0;
- pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
- if (bFlashPlayerMode != OMX_FALSE) {
- pSECPort->portDefinition.nBufferCountActual = MAX_H264_FP_VIDEO_INPUTBUFFER_NUM;
- pSECPort->portDefinition.nBufferCountMin = MAX_H264_FP_VIDEO_INPUTBUFFER_NUM;
- }
-
- /* Output port */
- pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
- pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
- pSECPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
- pSECPort->portDefinition.format.video.nSliceHeight = 0;
- pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
- pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
- SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "raw/video");
- pSECPort->portDefinition.format.video.pNativeRender = 0;
- pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
- if (bFlashPlayerMode != OMX_FALSE) {
- pSECPort->portDefinition.nBufferCountActual = MAX_H264_FP_VIDEO_OUTPUTBUFFER_NUM;
- pSECPort->portDefinition.nBufferCountMin = MAX_H264_FP_VIDEO_OUTPUTBUFFER_NUM;
- }
-
- for(i = 0; i < ALL_PORT_NUM; i++) {
- INIT_SET_SIZE_VERSION(&pH264Dec->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE);
- pH264Dec->AVCComponent[i].nPortIndex = i;
- pH264Dec->AVCComponent[i].eProfile = OMX_VIDEO_AVCProfileBaseline;
- pH264Dec->AVCComponent[i].eLevel = OMX_VIDEO_AVCLevel4;
- }
-
- pOMXComponent->GetParameter = &SEC_MFC_H264Dec_GetParameter;
- pOMXComponent->SetParameter = &SEC_MFC_H264Dec_SetParameter;
- pOMXComponent->GetConfig = &SEC_MFC_H264Dec_GetConfig;
- pOMXComponent->SetConfig = &SEC_MFC_H264Dec_SetConfig;
- pOMXComponent->GetExtensionIndex = &SEC_MFC_H264Dec_GetExtensionIndex;
- pOMXComponent->ComponentRoleEnum = &SEC_MFC_H264Dec_ComponentRoleEnum;
- pOMXComponent->ComponentDeInit = &SEC_OMX_ComponentDeinit;
-
- pSECComponent->sec_mfc_componentInit = &SEC_MFC_H264Dec_Init;
- pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_H264Dec_Terminate;
- pSECComponent->sec_mfc_bufferProcess = &SEC_MFC_H264Dec_bufferProcess;
- pSECComponent->sec_checkInputFrame = &Check_H264_Frame;
-
- pSECComponent->sec_allocSecureInputBuffer = &SEC_MFC_H264Dec_Alloc_SecureInputBuffer;
- pSECComponent->sec_freeSecureInputBuffer = &SEC_MFC_H264Dec_Free_SecureInputBuffer;
-
- if (bDRMPlayerMode == OMX_TRUE) {
- OMX_PTR hMFCHandle = NULL;
- SEC_OSAL_Log(SEC_LOG_ERROR, "DRM--SsbSipMfcDecOpen, Line:%d", __LINE__);
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen();
- if (hMFCHandle == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pH264Dec->hMFCH264Handle.hMFCHandle = hMFCHandle;
- }
-
- 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_OMX_VIDEODEC_COMPONENT *pVideoDec = 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;
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
-
- SEC_OSAL_Free(pSECComponent->componentName);
- pSECComponent->componentName = NULL;
-
- pH264Dec = (SEC_H264DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pH264Dec != NULL) {
- OMX_PTR hMFCHandle = NULL;
- hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
- if ((hMFCHandle != NULL) && (pVideoDec->bDRMPlayerMode == OMX_TRUE)) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "DRM--SsbSipMfcDecClose, Line:%d", __LINE__);
- SsbSipMfcDecClose(hMFCHandle);
- hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle = NULL;
- }
- SEC_OSAL_Free(pH264Dec);
- pH264Dec = ((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle = NULL;
- }
-
- ret = SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- ret = OMX_ErrorNone;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/SEC_OMX_H264dec.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/SEC_OMX_H264dec.h
deleted file mode 100644
index 370a15f..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/SEC_OMX_H264dec.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *
- * 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.1.0
- * @history
- * 2010.7.15 : Create
- */
-
-#ifndef SEC_OMX_H264_DEC_COMPONENT
-#define SEC_OMX_H264_DEC_COMPONENT
-
-#include "SEC_OMX_Def.h"
-#include "OMX_Component.h"
-#include "OMX_Video.h"
-
-
-#define MAX_H264_FP_VIDEO_INPUTBUFFER_NUM 4
-#define MAX_H264_FP_VIDEO_OUTPUTBUFFER_NUM 4
-
-typedef struct _SEC_MFC_H264DEC_HANDLE
-{
- OMX_HANDLETYPE hMFCHandle;
- OMX_PTR pMFCStreamBuffer;
- OMX_PTR pMFCStreamPhyBuffer;
- OMX_U32 indexTimestamp;
- OMX_U32 outputIndexTimestamp;
- OMX_BOOL bConfiguredMFC;
- OMX_BOOL bFlashPlayerMode;
-#ifdef S3D_SUPPORT
- OMX_BOOL bS3DMode;
-#endif
- 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;
-} 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/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/library_register.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/library_register.c
deleted file mode 100644
index aa63c6c..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/library_register.c
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- *
- * 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.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;
-
- /* component 2 - video decoder H.264 for flash player */
- SEC_OSAL_Strcpy(secComponents[1]->componentName, SEC_OMX_COMPONENT_H264_FP_DEC);
- SEC_OSAL_Strcpy(secComponents[1]->roles[0], SEC_OMX_COMPONENT_H264_DEC_ROLE);
- secComponents[1]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
-
- /* component 3 - video decoder H.264 for DRM */
- SEC_OSAL_Strcpy(secComponents[2]->componentName, SEC_OMX_COMPONENT_H264_DRM_DEC);
- SEC_OSAL_Strcpy(secComponents[2]->roles[0], SEC_OMX_COMPONENT_H264_DEC_ROLE);
- secComponents[2]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
-
-EXIT:
- FunctionOut();
-
- return MAX_COMPONENT_NUM;
-}
-
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/library_register.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/library_register.h
deleted file mode 100644
index 8c03cbe..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/h264/library_register.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- *
- * 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.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 3
-#define MAX_COMPONENT_ROLE_NUM 1
-
-/* H.264 */
-#define SEC_OMX_COMPONENT_H264_DEC "OMX.SEC.AVC.Decoder"
-#define SEC_OMX_COMPONENT_H264_FP_DEC "OMX.SEC.FP.AVC.Decoder"
-#define SEC_OMX_COMPONENT_H264_DRM_DEC "OMX.SEC.AVC.Decoder.secure"
-#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/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/Android.mk
deleted file mode 100644
index d353180..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/Android.mk
+++ /dev/null
@@ -1,65 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_Mpeg4dec.c \
- library_register.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libOMX.SEC.M4V.Decoder
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/omx
-
-LOCAL_CFLAGS :=
-
-ifeq ($(BOARD_NONBLOCK_MODE_PROCESS), true)
-LOCAL_CFLAGS += -DNONBLOCK_MODE_PROCESS
-endif
-
-ifeq ($(BOARD_USE_ANB), true)
-LOCAL_CFLAGS += -DUSE_ANB
-ifeq ($(BOARD_USE_CSC_FIMC), true)
-ifeq ($(BOARD_USE_V4L2_ION), false)
-LOCAL_CFLAGS += -DUSE_CSC_FIMC
-endif
-endif
-
-ifeq ($(BOARD_USE_CSC_GSCALER), true)
-LOCAL_CFLAGS += -DUSE_CSC_GSCALER
-endif
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libSEC_OMX_Vdec libsecosal libsecbasecomponent \
- libswconverter libsecmfcapi
-LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui \
- libSEC_OMX_Resourcemanager libcsc
-
-ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
-LOCAL_SHARED_LIBRARIES += libfimc libhwconverter
-endif
-
-ifeq ($(filter-out exynos5,$(TARGET_BOARD_PLATFORM)),)
-LOCAL_SHARED_LIBRARIES += libexynosgscaler
-endif
-
-#ifeq ($(BOARD_USE_V4L2_ION),true)
-#LOCAL_SHARED_LIBRARIES += libion
-#endif
-
-ifeq ($(BOARD_USES_MFC_FPS),true)
-LOCAL_CFLAGS += -DCONFIG_MFC_FPS
-endif
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/dec \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO) \
- $(BOARD_HAL_PATH)/include
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/SEC_OMX_Mpeg4dec.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/SEC_OMX_Mpeg4dec.c
deleted file mode 100644
index e820503..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/SEC_OMX_Mpeg4dec.c
+++ /dev/null
@@ -1,2103 +0,0 @@
-/*
- *
- * 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.1.0
- * @history
- * 2010.7.15 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "SEC_OMX_Macros.h"
-#include "SEC_OMX_Basecomponent.h"
-#include "SEC_OMX_Baseport.h"
-#include "SEC_OMX_Vdec.h"
-#include "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Thread.h"
-#include "library_register.h"
-#include "SEC_OMX_Mpeg4dec.h"
-#include "SsbSipMfcApi.h"
-
-#ifdef USE_ANB
-#include "SEC_OSAL_Android.h"
-#endif
-
-/* To use CSC_METHOD_PREFER_HW or CSC_METHOD_HW in SEC OMX, gralloc should allocate physical memory using FIMC */
-/* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
-#include "csc.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_MPEG4_DEC"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-#define MPEG4_DEC_NUM_OF_EXTRA_BUFFERS 7
-
-//#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)
-{
- OMX_U32 len;
- int 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)
-{
- OMX_U32 len;
- int 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_ErrorInvalidState;
- 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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)(((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)(((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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_ErrorInvalidState;
- 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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)(((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)(((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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;
- OMX_U32 realWidth, realHeight;
-
- if (portIndex >= pSECComponent->portParam.nPorts) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
- ret = SEC_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[portIndex];
-
- if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
- if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
- ret = OMX_ErrorIncorrectStateOperation;
- goto EXIT;
- }
- }
- if (pPortDefinition->nBufferCountActual < pSECPort->portDefinition.nBufferCountMin) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- SEC_OSAL_Memcpy(&pSECPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
-
- realWidth = pSECPort->portDefinition.format.video.nFrameWidth;
- realHeight = pSECPort->portDefinition.format.video.nFrameHeight;
- width = ((realWidth + 15) & (~15));
- height = ((realHeight + 15) & (~15));
- size = (width * height * 3) / 2;
- pSECPort->portDefinition.format.video.nStride = width;
- pSECPort->portDefinition.format.video.nSliceHeight = height;
- pSECPort->portDefinition.nBufferSize = (size > pSECPort->portDefinition.nBufferSize) ? size : pSECPort->portDefinition.nBufferSize;
-
- if (portIndex == INPUT_PORT_INDEX) {
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECOutputPort->portDefinition.format.video.nFrameWidth = pSECPort->portDefinition.format.video.nFrameWidth;
- pSECOutputPort->portDefinition.format.video.nFrameHeight = pSECPort->portDefinition.format.video.nFrameHeight;
- pSECOutputPort->portDefinition.format.video.nStride = width;
- pSECOutputPort->portDefinition.format.video.nSliceHeight = height;
-
- switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
- case OMX_COLOR_FormatYUV420Planar:
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
- break;
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pSECOutputPort->portDefinition.nBufferSize =
- ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight)) \
- + ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight/2));
- break;
- default:
- SEC_OSAL_Log(SEC_LOG_ERROR, "Color format is not support!! use default YUV size!!");
- ret = OMX_ErrorUnsupportedSetting;
- break;
- }
- }
- }
- break;
- case OMX_IndexParamVideoProfileLevelCurrent:
- {
- OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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_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_VideoDecodeGetConfig(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) {
- default:
- ret = SEC_OMX_VideoDecodeSetConfig(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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- *pIndexType = OMX_IndexVendorThumbnailMode;
-
- ret = OMX_ErrorNone;
- } else {
- ret = SEC_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_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_ErrorInvalidState;
- goto EXIT;
- }
-
- codecType = ((SEC_MPEG4_HANDLE *)(((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_MPEG4_HANDLE *pMpeg4Dec = (SEC_MPEG4_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- while (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
- SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameStart);
-
- if (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_DEC);
-#endif
- pMpeg4Dec->hMFCMpeg4Handle.returnCodec = SsbSipMfcDecExe(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle, pVideoDec->NBDecThread.oneFrameSize);
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_DEC);
-#endif
- SEC_OSAL_SemaphorePost(pVideoDec->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_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_MPEG4_HANDLE *pMpeg4Dec = NULL;
- OMX_HANDLETYPE hMFCHandle = NULL;
- OMX_PTR pStreamBuffer = NULL;
- OMX_PTR pStreamPhyBuffer = NULL;
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfInit(PERF_ID_DEC);
- SEC_OSAL_PerfInit(PERF_ID_CSC);
-#endif
- CSC_METHOD csc_method = CSC_METHOD_SW;
-
- FunctionIn();
-
- pMpeg4Dec = (SEC_MPEG4_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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 */
- if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress) {
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen();
- } else {
- SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpenExt(&buf_type);
- }
-
- if (hMFCHandle == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- ghMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = hMFCHandle;
-
- /* Allocate decoder's input buffer */
- /* Get first input buffer */
- pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoDec->MFCDecInputBuffer[0].VirAddr = pStreamBuffer;
- pVideoDec->MFCDecInputBuffer[0].PhyAddr = pStreamPhyBuffer;
- pVideoDec->MFCDecInputBuffer[0].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2;
- pVideoDec->MFCDecInputBuffer[0].dataSize = 0;
-
-#ifdef NONBLOCK_MODE_PROCESS
- /* Get second input buffer */
- pStreamBuffer = NULL;
- pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoDec->MFCDecInputBuffer[1].VirAddr = pStreamBuffer;
- pVideoDec->MFCDecInputBuffer[1].PhyAddr = pStreamPhyBuffer;
- pVideoDec->MFCDecInputBuffer[1].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2;
- pVideoDec->MFCDecInputBuffer[1].dataSize = 0;
- pVideoDec->indexInputBuffer = 0;
-
- pVideoDec->bFirstFrame = OMX_TRUE;
-
- pVideoDec->NBDecThread.bExitDecodeThread = OMX_FALSE;
- pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE;
- pVideoDec->NBDecThread.oneFrameSize = 0;
- SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameStart));
- SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameEnd));
- if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pVideoDec->NBDecThread.hNBDecodeThread,
- SEC_MFC_DecodeThread,
- pOMXComponent)) {
- pMpeg4Dec->hMFCMpeg4Handle.returnCodec = MFC_RET_OK;
- }
-#endif
-
- pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr;
- pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[0].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[0].bufferSize;
-
- SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
- SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
- pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp = 0;
- pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = 0;
-
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
-
-#ifdef USE_ANB
-#if defined(USE_CSC_FIMC) || defined(USE_CSC_GSCALER)
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- csc_method = CSC_METHOD_PREFER_HW;
- }
-#endif
-#endif
- pVideoDec->csc_handle = csc_init(&csc_method);
- pVideoDec->csc_set_format = 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_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_MPEG4_HANDLE *pMpeg4Dec = NULL;
- OMX_HANDLETYPE hMFCHandle = NULL;
-
- FunctionIn();
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfPrint("[DEC]", PERF_ID_DEC);
- SEC_OSAL_PerfPrint("[CSC]", PERF_ID_CSC);
-#endif
-
- pMpeg4Dec = (SEC_MPEG4_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->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;
-
-#ifdef NONBLOCK_MODE_PROCESS
- if (pVideoDec->NBDecThread.hNBDecodeThread != NULL) {
- pVideoDec->NBDecThread.bExitDecodeThread = OMX_TRUE;
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
- SEC_OSAL_ThreadTerminate(pVideoDec->NBDecThread.hNBDecodeThread);
- pVideoDec->NBDecThread.hNBDecodeThread = NULL;
- }
-
- if(pVideoDec->NBDecThread.hDecFrameEnd != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameEnd);
- pVideoDec->NBDecThread.hDecFrameEnd = NULL;
- }
-
- if(pVideoDec->NBDecThread.hDecFrameStart != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameStart);
- pVideoDec->NBDecThread.hDecFrameStart = NULL;
- }
-#endif
-
- if (hMFCHandle != NULL) {
- SsbSipMfcDecClose(hMFCHandle);
- ghMFCHandle = hMFCHandle = NULL;
- pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = NULL;
- }
-
- if (pVideoDec->csc_handle != NULL) {
- csc_deinit(pVideoDec->csc_handle);
- pVideoDec->csc_handle = NULL;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_Mpeg4_Decode_Nonblock(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_MPEG4_HANDLE *pMpeg4Dec = (SEC_MPEG4_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_HANDLETYPE hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 configValue;
- int bufWidth;
- int bufHeight;
- OMX_U32 FrameBufferYSize = 0;
- OMX_U32 FrameBufferUVSize = 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 mpeg4 deblocking filter enable */
- configValue = 1;
- SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_POST_ENABLE, &configValue);
-
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- configValue = 0; // the number that you want to delay
- SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &configValue);
- } else {
- configValue = MPEG4_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &configValue);
- }
-
- SsbSipMfcDecSetInBuf(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle,
- pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer,
- pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- pMpeg4Dec->hMFCMpeg4Handle.returnCodec = SsbSipMfcDecInit(hMFCHandle, MFCCodecType, oneFrameSize);
- if (pMpeg4Dec->hMFCMpeg4Handle.returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
-
- 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 ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_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)",
- pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
- pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->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) &&
- (pVideoDec->bFirstFrame == OMX_FALSE)) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- /* wait for mfc decode done */
- if (pVideoDec->NBDecThread.bDecoderRun == OMX_TRUE) {
- SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameEnd);
- pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE;
- }
-
- SEC_OSAL_SleepMillisec(0);
- status = SsbSipMfcDecGetOutBuf(hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
- if ((SsbSipMfcDecGetConfig(hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
- (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if (outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- outputDataValid = OMX_TRUE;
- pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp++;
- pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- outputDataValid = OMX_FALSE;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE))
- ret = OMX_ErrorInputDataDecodeYet;
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- outputDataValid = OMX_FALSE;
- }
-
-#ifdef FULL_FRAME_SEARCH
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else
-#endif
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
-
- if ((pVideoDec->bFirstFrame == OMX_TRUE) &&
- ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) &&
- ((pInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) != OMX_BUFFERFLAG_CODECCONFIG)) {
- pOutputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- }
-
- outputDataValid = OMX_FALSE;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- }
-
- if (ret == OMX_ErrorInputDataDecodeYet) {
- pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
- pVideoDec->indexInputBuffer++;
- pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize;
- oneFrameSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize;
- //pInputData->dataLen = oneFrameSize;
- //pInputData->remainDataLen = oneFrameSize;
- }
-
- if ((Check_Stream_PrefixCode(pInputData->dataBuffer, oneFrameSize, pMpeg4Dec->hMFCMpeg4Handle.codecType) == OMX_TRUE) &&
- ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
- if ((ret != OMX_ErrorInputDataDecodeYet) || (pSECComponent->getAllDelayBuffer == OMX_TRUE)) {
- SsbSipMfcDecSetConfig(pMpeg4Dec->hMFCMpeg4Handle.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);
-
- pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
- pVideoDec->NBDecThread.oneFrameSize = oneFrameSize;
-
- /* mfc decode start */
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
- pVideoDec->NBDecThread.bDecoderRun = OMX_TRUE;
- pMpeg4Dec->hMFCMpeg4Handle.returnCodec = MFC_RET_OK;
-
- SEC_OSAL_SleepMillisec(0);
-
- pVideoDec->indexInputBuffer++;
- pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pMpeg4Dec->hMFCMpeg4Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize;
-
- if ((pVideoDec->bFirstFrame == OMX_TRUE) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE) &&
- (outputDataValid == OMX_FALSE)) {
- ret = OMX_ErrorInputDataDecodeYet;
- }
-
- pVideoDec->bFirstFrame = OMX_FALSE;
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
- }
-
- /** Fill Output Buffer **/
- if (outputDataValid == OMX_TRUE) {
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int width = outputInfo.img_width;
- int height = outputInfo.img_height;
- int imageSize = outputInfo.img_width * outputInfo.img_height;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + imageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + imageSize + imageSize / 4;
- pOutputData->dataLen = (imageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- OMX_U32 stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, width, height, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- width = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
- if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
- (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
- /* if use Post copy address structure */
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (outputInfo.img_width * outputInfo.img_height * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 out for ThumbnailMode");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
-
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle, /* handle */
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
- }
-#endif
- } else {
- pOutputData->dataLen = 0;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_Mpeg4_Decode_Block(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_MPEG4_HANDLE *pMpeg4Dec = (SEC_MPEG4_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_HANDLETYPE hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 configValue;
- OMX_S32 returnCodec;
- int bufWidth;
- int bufHeight;
- OMX_U32 FrameBufferYSize;
- OMX_U32 FrameBufferUVSize;
-
- 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 mpeg4 deblocking filter enable */
- configValue = 1;
- SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_POST_ENABLE, &configValue);
-
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- configValue = 0; // the number that you want to delay
- SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &configValue);
- } else {
- configValue = MPEG4_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &configValue);
- }
-
- returnCodec = SsbSipMfcDecInit(hMFCHandle, MFCCodecType, oneFrameSize);
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
-
- 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 ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_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)",
- pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
- pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->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
-
- if (Check_Stream_PrefixCode(pInputData->dataBuffer, pInputData->dataLen, pMpeg4Dec->hMFCMpeg4Handle.codecType) == OMX_TRUE) {
- pSECComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pInputData->nFlags;
- SsbSipMfcDecSetConfig(hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp));
-
- returnCodec = SsbSipMfcDecExe(hMFCHandle, oneFrameSize);
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
-
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- returnCodec = MFC_RET_OK;
- goto EXIT;
- }
-
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- status = SsbSipMfcDecGetOutBuf(hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
- if (status != MFC_GETOUTBUF_DISPLAY_ONLY) {
- pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp++;
- pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
- }
-
- 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;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if (outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- /** Fill Output Buffer **/
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int width = outputInfo.img_width;
- int height = outputInfo.img_height;
- int imageSize = outputInfo.img_width * outputInfo.img_height;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + imageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + imageSize + imageSize / 4;
- pOutputData->dataLen = (imageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- OMX_U32 stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, width, height, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- width = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
- if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
- (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
- /* if use Post copy address structure */
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (outputInfo.img_width * outputInfo.img_height * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 out for ThumbnailMode");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
-
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle, /* handle */
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
- }
-#endif
- pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp++;
- pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- pOutputData->dataLen = 0;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE)) {
- ret = OMX_ErrorInputDataDecodeYet;
- }
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- goto EXIT;
- }
-
-#ifdef FULL_FRAME_SEARCH
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else
-#endif
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
- pOutputData->dataLen = 0;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Decode */
-OMX_ERRORTYPE SEC_MFC_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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- OMX_BOOL bCheckPrefix = OMX_FALSE;
-
- FunctionIn();
-
- if ((!CHECK_PORT_ENABLED(pSECInputPort)) || (!CHECK_PORT_ENABLED(pSECOutputPort)) ||
- (!CHECK_PORT_POPULATED(pSECInputPort)) || (!CHECK_PORT_POPULATED(pSECOutputPort))) {
- ret = OMX_ErrorNone;
- goto EXIT;
- }
- if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
-#ifdef NONBLOCK_MODE_PROCESS
- ret = SEC_MFC_Mpeg4_Decode_Nonblock(pOMXComponent, pInputData, pOutputData);
-#else
- ret = SEC_MFC_Mpeg4_Decode_Block(pOMXComponent, pInputData, pOutputData);
-#endif
- if (ret != OMX_ErrorNone) {
- if (ret == OMX_ErrorInputDataDecodeYet) {
- pOutputData->usedDataLen = 0;
- pOutputData->remainDataLen = pOutputData->dataLen;
- } else {
- pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventError, ret, 0, NULL);
- }
- } else {
- pInputData->previousDataLen = pInputData->dataLen;
- pInputData->usedDataLen += pInputData->dataLen;
- pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen;
- pInputData->dataLen -= pInputData->usedDataLen;
- pInputData->usedDataLen = 0;
-
- pOutputData->usedDataLen = 0;
- pOutputData->remainDataLen = pOutputData->dataLen;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OSCL_EXPORT_REF OMX_ERRORTYPE SEC_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
- SEC_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_DEC_CODEC;
-
- pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
- if (pSECComponent->componentName == NULL) {
- SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "%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));
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- pVideoDec->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_FormatYUV420Planar;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
-
- if (codecType == CODEC_TYPE_MPEG4) {
- for(i = 0; i < ALL_PORT_NUM; i++) {
- INIT_SET_SIZE_VERSION(&pMpeg4Dec->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
- pMpeg4Dec->mpeg4Component[i].nPortIndex = i;
- pMpeg4Dec->mpeg4Component[i].eProfile = OMX_VIDEO_MPEG4ProfileSimple;
- pMpeg4Dec->mpeg4Component[i].eLevel = OMX_VIDEO_MPEG4Level3;
- }
- } else {
- for(i = 0; i < ALL_PORT_NUM; i++) {
- INIT_SET_SIZE_VERSION(&pMpeg4Dec->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
- pMpeg4Dec->h263Component[i].nPortIndex = i;
- pMpeg4Dec->h263Component[i].eProfile = OMX_VIDEO_H263ProfileBaseline | OMX_VIDEO_H263ProfileISWV2;
- pMpeg4Dec->h263Component[i].eLevel = OMX_VIDEO_H263Level45;
- }
- }
-
- pOMXComponent->GetParameter = &SEC_MFC_Mpeg4Dec_GetParameter;
- pOMXComponent->SetParameter = &SEC_MFC_Mpeg4Dec_SetParameter;
- pOMXComponent->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 *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pMpeg4Dec != NULL) {
- SEC_OSAL_Free(pMpeg4Dec);
- ((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle = NULL;
- }
-
- ret = SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- ret = OMX_ErrorNone;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/SEC_OMX_Mpeg4dec.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/SEC_OMX_Mpeg4dec.h
deleted file mode 100644
index 256cb66..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/SEC_OMX_Mpeg4dec.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- *
- * 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.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_U32 outputIndexTimestamp;
- OMX_BOOL bConfiguredMFC;
- 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;
-} 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/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/library_register.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/library_register.c
deleted file mode 100644
index 2ae1b0d..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/library_register.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/library_register.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/library_register.h
deleted file mode 100644
index 40aec73..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/mpeg4/library_register.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/Android.mk
deleted file mode 100644
index 8be63e1..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/Android.mk
+++ /dev/null
@@ -1,65 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_Wmvdec.c \
- library_register.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libOMX.SEC.WMV.Decoder
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/omx
-
-LOCAL_CFLAGS :=
-
-ifeq ($(BOARD_NONBLOCK_MODE_PROCESS), true)
-LOCAL_CFLAGS += -DNONBLOCK_MODE_PROCESS
-endif
-
-ifeq ($(BOARD_USE_ANB), true)
-LOCAL_CFLAGS += -DUSE_ANB
-ifeq ($(BOARD_USE_CSC_FIMC), true)
-ifeq ($(BOARD_USE_V4L2_ION), false)
-LOCAL_CFLAGS += -DUSE_CSC_FIMC
-endif
-endif
-
-ifeq ($(BOARD_USE_CSC_GSCALER), true)
-LOCAL_CFLAGS += -DUSE_CSC_GSCALER
-endif
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libSEC_OMX_Vdec libsecosal libsecbasecomponent \
- libswconverter libsecmfcapi
-LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui \
- libSEC_OMX_Resourcemanager libcsc
-
-ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
-LOCAL_SHARED_LIBRARIES += libfimc libhwconverter
-endif
-
-ifeq ($(filter-out exynos5,$(TARGET_BOARD_PLATFORM)),)
-LOCAL_SHARED_LIBRARIES += libexynosgscaler
-endif
-
-#ifeq ($(BOARD_USE_V4L2_ION),true)
-#LOCAL_SHARED_LIBRARIES += libion
-#endif
-
-ifeq ($(BOARD_USES_MFC_FPS),true)
-LOCAL_CFLAGS += -DCONFIG_MFC_FPS
-endif
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/dec \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO) \
- $(BOARD_HAL_PATH)/include
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/SEC_OMX_Wmvdec.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/SEC_OMX_Wmvdec.c
deleted file mode 100644
index 7e9194b..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/SEC_OMX_Wmvdec.c
+++ /dev/null
@@ -1,2014 +0,0 @@
-/*
- *
- * Copyright 2010 Samsung Electronics S.LSI Co. LTD
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * @file SEC_OMX_Wmvdec.c
- * @brief
- * @author HyeYeon Chung (hyeon.chung@samsung.com)
- * @version 1.1.0
- * @history
- * 2010.8.16 : Create
- * 2010.8.20 : Support WMV3 (Vc-1 Simple/Main Profile)
- * 2010.8.21 : Support WMvC1 (Vc-1 Advanced Profile)
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "SEC_OMX_Macros.h"
-#include "SEC_OMX_Basecomponent.h"
-#include "SEC_OMX_Baseport.h"
-#include "SEC_OMX_Vdec.h"
-#include "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Thread.h"
-#include "SEC_OSAL_Memory.h"
-#include "library_register.h"
-#include "SEC_OMX_Wmvdec.h"
-#include "SsbSipMfcApi.h"
-#include "SEC_OSAL_Event.h"
-
-#ifdef USE_ANB
-#include "SEC_OSAL_Android.h"
-#endif
-
-/* To use CSC_METHOD_PREFER_HW or CSC_METHOD_HW in SEC OMX, gralloc should allocate physical memory using FIMC */
-/* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
-#include "csc.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_WMV_DEC"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-#define WMV_DEC_NUM_OF_EXTRA_BUFFERS 7
-
-//#define FULL_FRAME_SEARCH
-
-/* ASF parser does not send start code on OpenCORE */
-#define WO_START_CODE
-
-static OMX_HANDLETYPE ghMFCHandle = NULL;
-static WMV_FORMAT gWvmFormat = WMV_FORMAT_UNKNOWN;
-
-const OMX_U32 wmv3 = 0x33564d57;
-const OMX_U32 wvc1 = 0x31435657;
-const OMX_U32 wmva = 0x41564d57;
-
-static int Check_Wmv_Frame(OMX_U8 *pInputStream, OMX_U32 buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame)
-{
- OMX_U32 compressionID;
- OMX_BOOL bFrameStart;
- OMX_U32 len, readStream;
- OMX_U32 startCode;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "buffSize = %d", buffSize);
-
- len = 0;
- bFrameStart = OMX_FALSE;
-
- if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
- BitmapInfoHhr *pBitmapInfoHeader;
- pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
-
- compressionID = pBitmapInfoHeader->BiCompression;
- if (compressionID == wmv3) {
- SEC_OSAL_Log(SEC_LOG_TRACE, "WMV_FORMAT_WMV3");
- gWvmFormat = WMV_FORMAT_WMV3;
-
- *pbEndOfFrame = OMX_TRUE;
- return buffSize;
- }
- else if ((compressionID == wvc1) || (compressionID == wmva)) {
- SEC_OSAL_Log(SEC_LOG_TRACE, "WMV_FORMAT_VC1");
- gWvmFormat = WMV_FORMAT_VC1;
-
-#ifdef WO_START_CODE
-/* ASF parser does not send start code on OpenCORE */
- *pbEndOfFrame = OMX_TRUE;
- return buffSize;
-#endif
- }
- }
-
- if (gWvmFormat == WMV_FORMAT_WMV3) {
- *pbEndOfFrame = OMX_TRUE;
- return buffSize;
- }
-
-#ifdef WO_START_CODE
-/* ASF parser does not send start code on OpenCORE */
- if (gWvmFormat == WMV_FORMAT_VC1) {
- *pbEndOfFrame = OMX_TRUE;
- return buffSize;
- }
-#else
- /* TODO : for comformanc test based on common buffer scheme w/o parser */
-
- if (bPreviousFrameEOF == OMX_FALSE)
- bFrameStart = OMX_TRUE;
-
- startCode = 0xFFFFFFFF;
- if (bFrameStart == OMX_FALSE) {
- /* find Frame start code */
- while(startCode != 0x10D) {
- readStream = *(pInputStream + len);
- startCode = (startCode << 8) | readStream;
- len++;
- if (len > buffSize)
- goto EXIT;
- }
- }
-
- /* find next Frame start code */
- startCode = 0xFFFFFFFF;
- while ((startCode != 0x10D)) {
- readStream = *(pInputStream + len);
- startCode = (startCode << 8) | readStream;
- len++;
- if (len > buffSize)
- goto EXIT;
- }
-
- *pbEndOfFrame = OMX_TRUE;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "1. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
-
- return len - 4;
-#endif
-
-EXIT :
- *pbEndOfFrame = OMX_FALSE;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "2. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 1, buffSize);
-
- return --len;
-}
-
-OMX_BOOL Check_Stream_PrefixCode(OMX_U8 *pInputStream, OMX_U32 streamSize, WMV_FORMAT wmvFormat)
-{
- switch (wmvFormat) {
- case WMV_FORMAT_WMV3:
- if (streamSize > 0)
- return OMX_TRUE;
- else
- return OMX_FALSE;
- break;
- case WMV_FORMAT_VC1:
-
-#ifdef WO_START_CODE
- /* ASF parser does not send start code on OpenCORE */
- if (streamSize > 3)
- return OMX_TRUE;
- else
- return OMX_FALSE;
- break;
-#else
- /* TODO : for comformanc test based on common buffer scheme w/o parser */
- if (streamSize < 3) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: streamSize is too small (%d)", __FUNCTION__, streamSize);
- return OMX_FALSE;
- } else if ((pInputStream[0] == 0x00) &&
- (pInputStream[1] == 0x00) &&
- (pInputStream[2] == 0x01)) {
- return OMX_TRUE;
- } else {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: Cannot find prefix", __FUNCTION__);
- return OMX_FALSE;
- }
-#endif
- break;
-
- default:
- SEC_OSAL_Log(SEC_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
- return OMX_FALSE;
- break;
- }
-}
-
-OMX_BOOL Make_Stream_MetaData(OMX_U8 *pInputStream, OMX_U32 *pStreamSize, WMV_FORMAT wmvFormat)
-{
- OMX_U32 width, height;
- OMX_U8 *pCurrBuf = pInputStream;
- OMX_U32 currPos = 0;
-
- FunctionIn();
-
- /* Sequence Layer Data Structure */
- OMX_U8 const_C5[4] = {0x00, 0x00, 0x00, 0xc5};
- OMX_U8 const_04[4] = {0x04, 0x00, 0x00, 0x00};
- OMX_U8 const_0C[4] = {0x0C, 0x00, 0x00, 0x00};
- OMX_U8 struct_B_1[4] = {0xB3, 0x19, 0x00, 0x00};
- OMX_U8 struct_B_2[4] = {0x44, 0x62, 0x05, 0x00};
- OMX_U8 struct_B_3[4] = {0x0F, 0x00, 0x00, 0x00};
- OMX_U8 struct_C[4] = {0x30, 0x00, 0x00, 0x00};
-
- switch (wmvFormat) {
- case WMV_FORMAT_WMV3:
- if (*pStreamSize >= BITMAPINFOHEADER_SIZE) {
- BitmapInfoHhr *pBitmapInfoHeader;
- pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
-
- width = pBitmapInfoHeader->BiWidth;
- height = pBitmapInfoHeader->BiHeight;
- if (*pStreamSize > BITMAPINFOHEADER_SIZE)
- SEC_OSAL_Memcpy(struct_C, pInputStream+BITMAPINFOHEADER_SIZE, 4);
-
- SEC_OSAL_Memcpy(pCurrBuf + currPos, const_C5, 4);
- currPos +=4;
-
- SEC_OSAL_Memcpy(pCurrBuf + currPos, const_04, 4);
- currPos +=4;
-
- SEC_OSAL_Memcpy(pCurrBuf + currPos, struct_C, 4);
- currPos +=4;
-
- /* struct_A : VERT_SIZE */
- pCurrBuf[currPos] = height & 0xFF;
- pCurrBuf[currPos+1] = (height>>8) & 0xFF;
- pCurrBuf[currPos+2] = (height>>16) & 0xFF;
- pCurrBuf[currPos+3] = (height>>24) & 0xFF;
- currPos +=4;
-
- /* struct_A : HORIZ_SIZE */
- pCurrBuf[currPos] = width & 0xFF;
- pCurrBuf[currPos+1] = (width>>8) & 0xFF;
- pCurrBuf[currPos+2] = (width>>16) & 0xFF;
- pCurrBuf[currPos+3] = (width>>24) & 0xFF;
- currPos +=4;
-
- SEC_OSAL_Memcpy(pCurrBuf + currPos,const_0C, 4);
- currPos +=4;
-
- SEC_OSAL_Memcpy(pCurrBuf + currPos, struct_B_1, 4);
- currPos +=4;
-
- SEC_OSAL_Memcpy(pCurrBuf + currPos, struct_B_2, 4);
- currPos +=4;
-
- SEC_OSAL_Memcpy(pCurrBuf + currPos, struct_B_3, 4);
- currPos +=4;
-
- *pStreamSize = currPos;
- return OMX_TRUE;
- } else {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
- return OMX_FALSE;
- }
- break;
- case WMV_FORMAT_VC1:
- if (*pStreamSize >= BITMAPINFOHEADER_ASFBINDING_SIZE) {
- SEC_OSAL_Memcpy(pCurrBuf, pInputStream + BITMAPINFOHEADER_ASFBINDING_SIZE, *pStreamSize - BITMAPINFOHEADER_ASFBINDING_SIZE);
- *pStreamSize -= BITMAPINFOHEADER_ASFBINDING_SIZE;
- return OMX_TRUE;
- } else {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
- return OMX_FALSE;
- }
- break;
- default:
- SEC_OSAL_Log(SEC_LOG_WARNING, "%s: It is not necessary to make bitstream metadata for wmvFormat (%d)", __FUNCTION__, wmvFormat);
- return OMX_FALSE;
- break;
- }
-}
-
-#ifdef WO_START_CODE
-OMX_BOOL Make_Stream_StartCode(OMX_U8 *pInputStream, OMX_U32 streamSize, WMV_FORMAT wmvFormat)
-{
- OMX_U8 frameStartCode[4] = {0x00, 0x00, 0x01, 0x0d};
- OMX_U32 i;
-
- switch (wmvFormat) {
- case WMV_FORMAT_WMV3:
- return OMX_TRUE;
- break;
-
- case WMV_FORMAT_VC1:
- /* Should find better way to shift data */
- SEC_OSAL_Memmove(pInputStream+4, pInputStream, streamSize);
- SEC_OSAL_Memcpy(pInputStream, frameStartCode, 4);
-
- return OMX_TRUE;
- break;
-
- default:
- SEC_OSAL_Log(SEC_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
- return OMX_FALSE;
- break;
- }
-}
-#endif
-
-OMX_ERRORTYPE SEC_MFC_WmvDec_GetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nParamIndex,
- OMX_INOUT OMX_PTR pComponentParameterStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nParamIndex) {
- case OMX_IndexParamVideoWmv:
- {
- OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = NULL;
- SEC_WMV_HANDLE *pWmvDec = NULL;
- ret = SEC_OMX_Check_SizeVersion(pDstWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pDstWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
- ret = OMX_ErrorBadPortIndex;
- }
-
- pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSrcWmvParam = &pWmvDec->WmvComponent[pDstWmvParam->nPortIndex];
-
- SEC_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
- }
- break;
- case OMX_IndexParamStandardComponentRole:
- {
- OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
- ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPONENT_WMV_DEC_ROLE);
- }
- break;
- case OMX_IndexParamVideoErrorCorrection:
- {
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
- SEC_WMV_HANDLE *pWmvDec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSrcErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
-
- pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
- pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
- pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
- pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
- pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
- }
- break;
- default:
- ret = SEC_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
- break;
- }
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_WmvDec_SetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR pComponentParameterStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- case OMX_IndexParamVideoWmv:
- {
- OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = NULL;
- OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
- SEC_WMV_HANDLE *pWmvDec = NULL;
- ret = SEC_OMX_Check_SizeVersion(pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pSrcWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pDstWmvParam = &pWmvDec->WmvComponent[pSrcWmvParam->nPortIndex];
-
- SEC_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
- }
- break;
- case OMX_IndexParamStandardComponentRole:
- {
- OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
-
- ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
- ret = OMX_ErrorIncorrectStateOperation;
- goto EXIT;
- }
-
- if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPONENT_WMV_DEC_ROLE)) {
- pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
- } else {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- }
- break;
- case OMX_IndexParamPortDefinition:
- {
- OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
- OMX_U32 portIndex = pPortDefinition->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort;
- OMX_U32 width, height, size;
- OMX_U32 realWidth, realHeight;
-
- if (portIndex >= pSECComponent->portParam.nPorts) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
- ret = SEC_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[portIndex];
-
- if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
- if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
- ret = OMX_ErrorIncorrectStateOperation;
- goto EXIT;
- }
- }
- if (pPortDefinition->nBufferCountActual < pSECPort->portDefinition.nBufferCountMin) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- SEC_OSAL_Memcpy(&pSECPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
-
- realWidth = pSECPort->portDefinition.format.video.nFrameWidth;
- realHeight = pSECPort->portDefinition.format.video.nFrameHeight;
- width = ((realWidth + 15) & (~15));
- height = ((realHeight + 15) & (~15));
- size = (width * height * 3) / 2;
- pSECPort->portDefinition.format.video.nStride = width;
- pSECPort->portDefinition.format.video.nSliceHeight = height;
- pSECPort->portDefinition.nBufferSize = (size > pSECPort->portDefinition.nBufferSize) ? size : pSECPort->portDefinition.nBufferSize;
-
- if (portIndex == INPUT_PORT_INDEX) {
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECOutputPort->portDefinition.format.video.nFrameWidth = pSECPort->portDefinition.format.video.nFrameWidth;
- pSECOutputPort->portDefinition.format.video.nFrameHeight = pSECPort->portDefinition.format.video.nFrameHeight;
- pSECOutputPort->portDefinition.format.video.nStride = width;
- pSECOutputPort->portDefinition.format.video.nSliceHeight = height;
-
- switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
- case OMX_COLOR_FormatYUV420Planar:
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
- break;
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pSECOutputPort->portDefinition.nBufferSize =
- ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight)) \
- + ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight/2));
- break;
- default:
- SEC_OSAL_Log(SEC_LOG_ERROR, "Color format is not support!! use default YUV size!!");
- ret = OMX_ErrorUnsupportedSetting;
- break;
- }
- }
- }
- break;
- case OMX_IndexParamVideoErrorCorrection:
- {
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
- SEC_WMV_HANDLE *pWmvDec = NULL;
-
- ret = SEC_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pDstErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
-
- pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
- pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
- pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
- pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
- pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
- }
- break;
- default:
- ret = SEC_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
- break;
- }
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_WmvDec_GetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- if (pComponentConfigStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (pSECComponent->currentState == OMX_StateInvalid) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- default:
- ret = SEC_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_WmvDec_SetConfig(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR pComponentConfigStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentConfigStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- default:
- ret = SEC_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_WmvDec_GetExtensionIndex(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_STRING cParameterName,
- OMX_OUT OMX_INDEXTYPE *pIndexType)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- if ((cParameterName == NULL) || (pIndexType == NULL)) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (pSECComponent->currentState == OMX_StateInvalid) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
- SEC_WMV_HANDLE *pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- *pIndexType = OMX_IndexVendorThumbnailMode;
-
- ret = OMX_ErrorNone;
- } else {
- ret = SEC_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_WmvDec_ComponentRoleEnum(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_OUT OMX_U8 *cRole,
- OMX_IN OMX_U32 nIndex)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if ((hComponent == NULL) || (cRole == NULL)) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
- SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPONENT_WMV_DEC_ROLE);
- ret = OMX_ErrorNone;
- } else {
- ret = OMX_ErrorUnsupportedIndex;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_DecodeThread(OMX_HANDLETYPE hComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_WMV_HANDLE *pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- while (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
- SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameStart);
-
- if (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_DEC);
-#endif
- pWmvDec->hMFCWmvHandle.returnCodec = SsbSipMfcDecExe(pWmvDec->hMFCWmvHandle.hMFCHandle, pVideoDec->NBDecThread.oneFrameSize);
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_DEC);
-#endif
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameEnd);
- }
- }
-
-EXIT:
- SEC_OSAL_ThreadExit(NULL);
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Init */
-OMX_ERRORTYPE SEC_MFC_WmvDec_Init(OMX_COMPONENTTYPE *pOMXComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_WMV_HANDLE *pWmvDec = NULL;
- OMX_HANDLETYPE hMFCHandle = NULL;
- OMX_PTR pStreamBuffer = NULL;
- OMX_PTR pStreamPhyBuffer = NULL;
- CSC_METHOD csc_method = CSC_METHOD_SW;
-
- FunctionIn();
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfInit(PERF_ID_DEC);
- SEC_OSAL_PerfInit(PERF_ID_CSC);
-#endif
-
- pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pWmvDec->hMFCWmvHandle.bConfiguredMFC = OMX_FALSE;
- pSECComponent->bUseFlagEOF = OMX_FALSE;
- pSECComponent->bSaveFlagEOS = OMX_FALSE;
-
- /* MFC(Multi Format Codec) decoder and CMM(Codec Memory Management) driver open */
- if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress) {
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen();
- } else {
- SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpenExt(&buf_type);
- }
-
- if (hMFCHandle == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- ghMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle = hMFCHandle;
-
- /* Allocate decoder's input buffer */
- /* Get first input buffer */
- pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoDec->MFCDecInputBuffer[0].VirAddr = pStreamBuffer;
- pVideoDec->MFCDecInputBuffer[0].PhyAddr = pStreamPhyBuffer;
- pVideoDec->MFCDecInputBuffer[0].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2;
- pVideoDec->MFCDecInputBuffer[0].dataSize = 0;
-
-#ifdef NONBLOCK_MODE_PROCESS
- /* Get second input buffer */
- pStreamBuffer = NULL;
- pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoDec->MFCDecInputBuffer[1].VirAddr = pStreamBuffer;
- pVideoDec->MFCDecInputBuffer[1].PhyAddr = pStreamPhyBuffer;
- pVideoDec->MFCDecInputBuffer[1].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2;
- pVideoDec->MFCDecInputBuffer[1].dataSize = 0;
- pVideoDec->indexInputBuffer = 0;
-
- pVideoDec->bFirstFrame = OMX_TRUE;
-
- pVideoDec->NBDecThread.bExitDecodeThread = OMX_FALSE;
- pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE;
- pVideoDec->NBDecThread.oneFrameSize = 0;
- SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameStart));
- SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameEnd));
- if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pVideoDec->NBDecThread.hNBDecodeThread,
- SEC_MFC_DecodeThread,
- pOMXComponent)) {
- pWmvDec->hMFCWmvHandle.returnCodec = MFC_RET_OK;
- }
-#endif
-
- pWmvDec->hMFCWmvHandle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr;
- pWmvDec->hMFCWmvHandle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[0].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[0].bufferSize;
-
- SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
- SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
- pWmvDec->hMFCWmvHandle.indexTimestamp = 0;
- pWmvDec->hMFCWmvHandle.outputIndexTimestamp = 0;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
-
-#ifdef USE_ANB
-#if defined(USE_CSC_FIMC) || defined(USE_CSC_GSCALER)
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- csc_method = CSC_METHOD_PREFER_HW;
- }
-#endif
-#endif
- pVideoDec->csc_handle = csc_init(&csc_method);
- pVideoDec->csc_set_format = OMX_FALSE;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Terminate */
-OMX_ERRORTYPE SEC_MFC_WmvDec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_WMV_HANDLE *pWmvDec = NULL;
- OMX_HANDLETYPE hMFCHandle = NULL;
-
- FunctionIn();
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfPrint("[DEC]", PERF_ID_DEC);
- SEC_OSAL_PerfPrint("[CSC]", PERF_ID_CSC);
-#endif
-
- pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
-
- pWmvDec->hMFCWmvHandle.pMFCStreamBuffer = NULL;
- pWmvDec->hMFCWmvHandle.pMFCStreamPhyBuffer = NULL;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = NULL;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = 0;
-
-#ifdef NONBLOCK_MODE_PROCESS
- if (pVideoDec->NBDecThread.hNBDecodeThread != NULL) {
- pVideoDec->NBDecThread.bExitDecodeThread = OMX_TRUE;
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
- SEC_OSAL_ThreadTerminate(pVideoDec->NBDecThread.hNBDecodeThread);
- pVideoDec->NBDecThread.hNBDecodeThread = NULL;
- }
-
- if(pVideoDec->NBDecThread.hDecFrameEnd != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameEnd);
- pVideoDec->NBDecThread.hDecFrameEnd = NULL;
- }
-
- if(pVideoDec->NBDecThread.hDecFrameStart != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameStart);
- pVideoDec->NBDecThread.hDecFrameStart = NULL;
- }
-#endif
-
- if (hMFCHandle != NULL) {
- SsbSipMfcDecClose(hMFCHandle);
- pWmvDec->hMFCWmvHandle.hMFCHandle = NULL;
- }
-
- if (pVideoDec->csc_handle != NULL) {
- csc_deinit(pVideoDec->csc_handle);
- pVideoDec->csc_handle = NULL;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_Wmv_Decode_Nonblock(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_WMV_HANDLE *pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 configValue = 0;
- OMX_BOOL bMetaData = OMX_FALSE;
- OMX_BOOL bStartCode = OMX_FALSE;
- int bufWidth = 0;
- int bufHeight = 0;
- OMX_U32 FrameBufferYSize = 0;
- OMX_U32 FrameBufferUVSize = 0;
- OMX_BOOL outputDataValid = OMX_FALSE;
-
- FunctionIn();
-
- if (pWmvDec->hMFCWmvHandle.bConfiguredMFC == OMX_FALSE) {
- SSBSIP_MFC_CODEC_TYPE MFCCodecType;
-
- if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
- if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3)
- MFCCodecType = VC1RCV_DEC;
- else if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_VC1)
- MFCCodecType = VC1_DEC;
- else
- MFCCodecType = UNKNOWN_TYPE;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "codec type = %d", MFCCodecType);
-
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- configValue = 0; // the number that you want to delay
- SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &configValue);
- } else {
- configValue = WMV_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &configValue);
- }
-
- bMetaData = Make_Stream_MetaData(pInputData->dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
- if (bMetaData == OMX_FALSE) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "Fail to Make Stream MetaData");
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
-
- SsbSipMfcDecSetInBuf(pWmvDec->hMFCWmvHandle.hMFCHandle,
- pWmvDec->hMFCWmvHandle.pMFCStreamPhyBuffer,
- pWmvDec->hMFCWmvHandle.pMFCStreamBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- pWmvDec->hMFCWmvHandle.returnCodec = SsbSipMfcDecInit(pWmvDec->hMFCWmvHandle.hMFCHandle, MFCCodecType, oneFrameSize);
- if (pWmvDec->hMFCWmvHandle.returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
-
- if (SsbSipMfcDecGetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol) != MFC_RET_OK) {
- ret = OMX_ErrorMFCInit;
- SEC_OSAL_Log(SEC_LOG_ERROR, "SsbSipMfcDecGetConfig failed");
- goto EXIT;
- }
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "## nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
- pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
- pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->portDefinition.format.video.nSliceHeight);
-
- /** Update Frame Size **/
- if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
- pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
- pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->portDefinition.format.video.nSliceHeight);
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /* Send Port Settings changed call back */
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, // The command was completed
- OMX_DirOutput, // This is the port index
- 0,
- NULL);
- }
-
- pWmvDec->hMFCWmvHandle.bConfiguredMFC = OMX_TRUE;
-
- if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
- } else {
-
-#ifdef WO_START_CODE
-/* ASF parser does not send start code on OpenCORE */
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
-#else
-/* TODO : for comformanc test based on common buffer scheme w/o parser */
- pOutputData->dataLen = 0;
- ret = OMX_ErrorInputDataDecodeYet;
-#endif
- }
- goto EXIT;
- } else {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SsbSipMfcDecInit failed");
- ret = OMX_ErrorMFCInit; /* OMX_ErrorUndefined */
- goto EXIT;
- }
- }
-
-#ifndef FULL_FRAME_SEARCH
- if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
- (pSECComponent->bUseFlagEOF == OMX_FALSE))
- pSECComponent->bUseFlagEOF = OMX_TRUE;
-#endif
-
- pSECComponent->timeStamp[pWmvDec->hMFCWmvHandle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pWmvDec->hMFCWmvHandle.indexTimestamp] = pInputData->nFlags;
-
- if ((pWmvDec->hMFCWmvHandle.returnCodec == MFC_RET_OK) && (pVideoDec->bFirstFrame == OMX_FALSE)) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- /* wait for mfc decode done */
- if (pVideoDec->NBDecThread.bDecoderRun == OMX_TRUE) {
- SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameEnd);
- pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE;
- }
-
- SEC_OSAL_SleepMillisec(0);
- status = SsbSipMfcDecGetOutBuf(pWmvDec->hMFCWmvHandle.hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
- if ((SsbSipMfcDecGetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
- (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if (outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pWmvDec->hMFCWmvHandle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- outputDataValid = OMX_TRUE;
- pWmvDec->hMFCWmvHandle.outputIndexTimestamp++;
- pWmvDec->hMFCWmvHandle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- outputDataValid = OMX_FALSE;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE))
- ret = OMX_ErrorInputDataDecodeYet;
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- outputDataValid = OMX_FALSE;
- }
-
-#ifdef FULL_FRAME_SEARCH
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else
-#endif
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
-
- if ((pVideoDec->bFirstFrame == OMX_TRUE) &&
- ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) &&
- ((pInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) != OMX_BUFFERFLAG_CODECCONFIG)) {
- pOutputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- }
-
- outputDataValid = OMX_FALSE;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- }
-
-#ifdef WO_START_CODE
- if (pInputData->allocSize < oneFrameSize+4) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "Can't attach startcode due to lack of buffer space");
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
-
- bStartCode = Make_Stream_StartCode(pInputData->dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
- if (bStartCode == OMX_FALSE) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "Fail to Make Stream Start Code");
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
-#endif
-
- if (ret == OMX_ErrorInputDataDecodeYet) {
- pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
- pVideoDec->indexInputBuffer++;
- pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- pWmvDec->hMFCWmvHandle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pWmvDec->hMFCWmvHandle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize;
- oneFrameSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize;
- //pInputData->dataLen = oneFrameSize;
- //pInputData->remainDataLen = oneFrameSize;
- }
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "SsbSipMfcDecExe oneFrameSize = %d", oneFrameSize);
-
- if ((Check_Stream_PrefixCode(pInputData->dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat) == OMX_TRUE) &&
- ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
- if ((ret != OMX_ErrorInputDataDecodeYet) || (pSECComponent->getAllDelayBuffer == OMX_TRUE)) {
- SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pWmvDec->hMFCWmvHandle.indexTimestamp));
- pWmvDec->hMFCWmvHandle.indexTimestamp++;
- pWmvDec->hMFCWmvHandle.indexTimestamp %= MAX_TIMESTAMP;
- }
-
- SsbSipMfcDecSetInBuf(pWmvDec->hMFCWmvHandle.hMFCHandle,
- pWmvDec->hMFCWmvHandle.pMFCStreamPhyBuffer,
- pWmvDec->hMFCWmvHandle.pMFCStreamBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
-#ifdef WO_START_CODE
- pVideoDec->NBDecThread.oneFrameSize = oneFrameSize + 4; /* Frame Start Code */
-#else
- pVideoDec->NBDecThread.oneFrameSize = oneFrameSize;
-#endif
- /* mfc decode start */
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
- pVideoDec->NBDecThread.bDecoderRun = OMX_TRUE;
- pWmvDec->hMFCWmvHandle.returnCodec = MFC_RET_OK;
-
- SEC_OSAL_SleepMillisec(0);
-
- pVideoDec->indexInputBuffer++;
- pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- pWmvDec->hMFCWmvHandle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pWmvDec->hMFCWmvHandle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize;
-
- if ((pVideoDec->bFirstFrame == OMX_TRUE) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE) &&
- (outputDataValid == OMX_FALSE)) {
- ret = OMX_ErrorInputDataDecodeYet;
- }
-
- pVideoDec->bFirstFrame = OMX_FALSE;
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
- }
-
- /** Fill Output Buffer **/
- if (outputDataValid == OMX_TRUE) {
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int width = outputInfo.img_width;
- int height = outputInfo.img_height;
- int imageSize = outputInfo.img_width * outputInfo.img_height;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + imageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + imageSize + imageSize / 4;
- pOutputData->dataLen = (imageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- OMX_U32 stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, width, height, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- width = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
- if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
- (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
- /* if use Post copy address structure */
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (outputInfo.img_width * outputInfo.img_height * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 out for ThumbnailMode");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle,
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
- }
-#endif
- } else {
- pOutputData->dataLen = 0;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_Wmv_Decode_Block(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_WMV_HANDLE *pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 configValue = 0;
- OMX_S32 returnCodec = 0;
- OMX_BOOL bMetaData = OMX_FALSE;
- OMX_BOOL bStartCode = OMX_FALSE;
- int bufWidth = 0;
- int bufHeight = 0;
- OMX_U32 FrameBufferYSize;
- OMX_U32 FrameBufferUVSize;
-
- FunctionIn();
-
- if (pWmvDec->hMFCWmvHandle.bConfiguredMFC == OMX_FALSE) {
- SSBSIP_MFC_CODEC_TYPE MFCCodecType;
-
- if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
- if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3)
- MFCCodecType = VC1RCV_DEC;
- else if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_VC1)
- MFCCodecType = VC1_DEC;
- else
- MFCCodecType = UNKNOWN_TYPE;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "codec type = %d", MFCCodecType);
-
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- configValue = 0; // the number that you want to delay
- SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &configValue);
- } else {
- configValue = WMV_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &configValue);
- }
-
- bMetaData = Make_Stream_MetaData(pInputData->dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
- if (bMetaData == OMX_FALSE) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "Fail to Make Stream MetaData");
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
-
- returnCodec = SsbSipMfcDecInit(pWmvDec->hMFCWmvHandle.hMFCHandle, MFCCodecType, oneFrameSize);
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
-
- if (SsbSipMfcDecGetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol) != MFC_RET_OK) {
- ret = OMX_ErrorMFCInit;
- SEC_OSAL_Log(SEC_LOG_ERROR, "SsbSipMfcDecGetConfig failed");
- goto EXIT;
- }
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "## nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
- pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
- pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->portDefinition.format.video.nSliceHeight);
-
- /** Update Frame Size **/
- if ((pSECInputPort->portDefinition.format.video.nFrameWidth != (unsigned int)imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != (unsigned int)imgResol.height)) {
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "nFrameWidth(%d) nFrameHeight(%d), nStride(%d), nSliceHeight(%d)",
- pSECInputPort->portDefinition.format.video.nFrameWidth, pSECInputPort->portDefinition.format.video.nFrameHeight,
- pSECInputPort->portDefinition.format.video.nStride, pSECInputPort->portDefinition.format.video.nSliceHeight);
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /* Send Port Settings changed call back */
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, // The command was completed
- OMX_DirOutput, // This is the port index
- 0,
- NULL);
- }
-
- pWmvDec->hMFCWmvHandle.bConfiguredMFC = OMX_TRUE;
-
- if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
- } else {
-
-#ifdef WO_START_CODE
-/* ASF parser does not send start code on OpenCORE */
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
-#else
-/* TODO : for comformanc test based on common buffer scheme w/o parser */
- pOutputData->dataLen = 0;
- ret = OMX_ErrorInputDataDecodeYet;
-#endif
- }
- goto EXIT;
- } else {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SsbSipMfcDecInit failed");
- ret = OMX_ErrorMFCInit; /* OMX_ErrorUndefined */
- goto EXIT;
- }
- }
-
-#ifndef FULL_FRAME_SEARCH
- if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
- (pSECComponent->bUseFlagEOF == OMX_FALSE))
- pSECComponent->bUseFlagEOF = OMX_TRUE;
-#endif
-
-#ifdef WO_START_CODE
- if (pInputData->allocSize < oneFrameSize+4) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "Can't attach startcode due to lack of buffer space");
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
-
- bStartCode = Make_Stream_StartCode(pInputData->dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
- if (bStartCode == OMX_FALSE) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "Fail to Make Stream Start Code");
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
-#endif
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "SsbSipMfcDecExe oneFrameSize = %d", oneFrameSize);
-
- if (Check_Stream_PrefixCode(pInputData->dataBuffer, pInputData->dataLen, pWmvDec->hMFCWmvHandle.wmvFormat) == OMX_TRUE) {
- pSECComponent->timeStamp[pWmvDec->hMFCWmvHandle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pWmvDec->hMFCWmvHandle.indexTimestamp] = pInputData->nFlags;
- SsbSipMfcDecSetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pWmvDec->hMFCWmvHandle.indexTimestamp));
-
-#ifdef WO_START_CODE
- returnCodec = SsbSipMfcDecExe(pWmvDec->hMFCWmvHandle.hMFCHandle, oneFrameSize+4); /* Frame Start Code */
-#else
- returnCodec = SsbSipMfcDecExe(pWmvDec->hMFCWmvHandle.hMFCHandle, oneFrameSize);
-#endif
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
-
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- returnCodec = MFC_RET_OK;
- goto EXIT;
- }
-
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- status = SsbSipMfcDecGetOutBuf(pWmvDec->hMFCWmvHandle.hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
- if (status != MFC_GETOUTBUF_DISPLAY_ONLY) {
- pWmvDec->hMFCWmvHandle.indexTimestamp++;
- pWmvDec->hMFCWmvHandle.indexTimestamp %= MAX_TIMESTAMP;
- }
-
- if (SsbSipMfcDecGetConfig(pWmvDec->hMFCWmvHandle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK ||
- (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if (outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pWmvDec->hMFCWmvHandle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- /** Fill Output Buffer **/
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int width = outputInfo.img_width;
- int height = outputInfo.img_height;
- int imageSize = outputInfo.img_width * outputInfo.img_height;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + imageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + imageSize + imageSize / 4;
- pOutputData->dataLen = (imageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- OMX_U32 stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, width, height, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- width = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
- if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
- (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (outputInfo.img_width * outputInfo.img_height * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 out for ThumbnailMode");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle,
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
- }
-#endif
- pWmvDec->hMFCWmvHandle.outputIndexTimestamp++;
- pWmvDec->hMFCWmvHandle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- pOutputData->dataLen = 0;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE))
- ret = OMX_ErrorInputDataDecodeYet;
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- goto EXIT;
- }
-
-#ifdef FULL_FRAME_SEARCH
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else
-#endif
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
- pOutputData->dataLen = 0;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Decode */
-OMX_ERRORTYPE SEC_MFC_WmvDec_bufferProcess(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_WMV_HANDLE *pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- OMX_BOOL bCheckPrefix = OMX_FALSE;
-
- FunctionIn();
-
- if ((!CHECK_PORT_ENABLED(pSECInputPort)) || (!CHECK_PORT_ENABLED(pSECOutputPort)) ||
- (!CHECK_PORT_POPULATED(pSECInputPort)) || (!CHECK_PORT_POPULATED(pSECOutputPort))) {
- goto EXIT;
- }
- if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
- goto EXIT;
- }
-
- pWmvDec->hMFCWmvHandle.wmvFormat = gWvmFormat;
-
-#ifdef NONBLOCK_MODE_PROCESS
- ret = SEC_MFC_Wmv_Decode_Nonblock(pOMXComponent, pInputData, pOutputData);
-#else
- ret = SEC_MFC_Wmv_Decode_Block(pOMXComponent, pInputData, pOutputData);
-#endif
- if (ret != OMX_ErrorNone) {
- if (ret == OMX_ErrorInputDataDecodeYet) {
- pOutputData->usedDataLen = 0;
- pOutputData->remainDataLen = pOutputData->dataLen;
- } else {
- pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventError, ret, 0, NULL);
- }
- } else {
- pInputData->previousDataLen = pInputData->dataLen;
- pInputData->usedDataLen += pInputData->dataLen;
- pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen;
- pInputData->dataLen -= pInputData->usedDataLen;
- pInputData->usedDataLen = 0;
-
- pOutputData->usedDataLen = 0;
- pOutputData->remainDataLen = pOutputData->dataLen;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OSCL_EXPORT_REF OMX_ERRORTYPE SEC_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
- SEC_WMV_HANDLE *pWmvDec = NULL;
- OMX_S32 wmvFormat = WMV_FORMAT_UNKNOWN;
- int i = 0;
-
- FunctionIn();
-
- if ((hComponent == NULL) || (componentName == NULL)) {
- ret = OMX_ErrorBadParameter;
- SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_ComponentInit: parameters are null, ret:%X", ret);
- goto EXIT;
- }
- if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_WMV_DEC, componentName) != 0) {
- ret = OMX_ErrorBadParameter;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
- goto EXIT;
- }
-
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_VideoDecodeComponentInit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_ComponentInit: SEC_OMX_VideoDecodeComponentInit error, ret: %X", ret);
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- pSECComponent->codecType = HW_VIDEO_DEC_CODEC;
-
- pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
- if (pSECComponent->componentName == NULL) {
- SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_ComponentInit: componentName alloc error, ret: %X", ret);
- goto EXIT;
- }
- SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
-
- pWmvDec = SEC_OSAL_Malloc(sizeof(SEC_WMV_HANDLE));
- if (pWmvDec == NULL) {
- SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_ComponentInit: SEC_WMV_HANDLE alloc error, ret: %X", ret);
- goto EXIT;
- }
- SEC_OSAL_Memset(pWmvDec, 0, sizeof(SEC_WMV_HANDLE));
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pWmvDec;
- pWmvDec->hMFCWmvHandle.wmvFormat = wmvFormat;
-
- SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_WMV_DEC);
-
- /* Set componentVersion */
- pSECComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
- pSECComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
- pSECComponent->componentVersion.s.nRevision = REVISION_NUMBER;
- pSECComponent->componentVersion.s.nStep = STEP_NUMBER;
- /* Set specVersion */
- pSECComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
- pSECComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
- pSECComponent->specVersion.s.nRevision = REVISION_NUMBER;
- pSECComponent->specVersion.s.nStep = STEP_NUMBER;
-
- /* Android CapabilityFlags */
- pSECComponent->capabilityFlags.iIsOMXComponentMultiThreaded = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentSupportsExternalInputBufferAlloc = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentSupportsExternalOutputBufferAlloc = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentSupportsMovableInputBuffers = OMX_FALSE;
- pSECComponent->capabilityFlags.iOMXComponentSupportsPartialFrames = OMX_FALSE;
- pSECComponent->capabilityFlags.iOMXComponentUsesNALStartCodes = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentCanHandleIncompleteFrames = OMX_TRUE;
- pSECComponent->capabilityFlags.iOMXComponentUsesFullAVCFrames = OMX_TRUE;
-
- /* Input port */
- pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
- pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
- pSECPort->portDefinition.format.video.nStride = 0;
- pSECPort->portDefinition.format.video.nSliceHeight = 0;
- pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
-
- pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
- SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/wmv");
-
- pSECPort->portDefinition.format.video.pNativeRender = 0;
- pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
-
- /* Output port */
- pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
- pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
- pSECPort->portDefinition.format.video.nStride = 0;
- pSECPort->portDefinition.format.video.nSliceHeight = 0;
- pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
- pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
- SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "raw/video");
- pSECPort->portDefinition.format.video.pNativeRender = 0;
- pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
-
- for(i = 0; i < ALL_PORT_NUM; i++) {
- INIT_SET_SIZE_VERSION(&pWmvDec->WmvComponent[i], OMX_VIDEO_PARAM_WMVTYPE);
- pWmvDec->WmvComponent[i].nPortIndex = i;
- pWmvDec->WmvComponent[i].eFormat = OMX_VIDEO_WMVFormat9;
- }
-
- pOMXComponent->GetParameter = &SEC_MFC_WmvDec_GetParameter;
- pOMXComponent->SetParameter = &SEC_MFC_WmvDec_SetParameter;
- pOMXComponent->GetConfig = &SEC_MFC_WmvDec_GetConfig;
- pOMXComponent->SetConfig = &SEC_MFC_WmvDec_SetConfig;
- pOMXComponent->GetExtensionIndex = &SEC_MFC_WmvDec_GetExtensionIndex;
- pOMXComponent->ComponentRoleEnum = &SEC_MFC_WmvDec_ComponentRoleEnum;
- pOMXComponent->ComponentDeInit = &SEC_OMX_ComponentDeinit;
-
- pSECComponent->sec_mfc_componentInit = &SEC_MFC_WmvDec_Init;
- pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_WmvDec_Terminate;
- pSECComponent->sec_mfc_bufferProcess = &SEC_MFC_WmvDec_bufferProcess;
- pSECComponent->sec_checkInputFrame = &Check_Wmv_Frame;
-
- pSECComponent->currentState = OMX_StateLoaded;
-
- ret = OMX_ErrorNone;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
- SEC_WMV_HANDLE *pWmvDec = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- SEC_OSAL_Free(pSECComponent->componentName);
- pSECComponent->componentName = NULL;
-
- pWmvDec = (SEC_WMV_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pWmvDec != NULL) {
- SEC_OSAL_Free(pWmvDec);
- pWmvDec = ((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle = NULL;
- }
-
- ret = SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- ret = OMX_ErrorNone;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/SEC_OMX_Wmvdec.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/SEC_OMX_Wmvdec.h
deleted file mode 100644
index 0634465..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/SEC_OMX_Wmvdec.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- *
- * Copyright 2010 Samsung Electronics S.LSI Co. LTD
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * @file SEC_OMX_Wmvdec.h
- * @brief
- * @author HyeYeon Chung (hyeon.chung@samsung.com)
- * @version 1.1.0
- * @history
- * 2010.8.20 : Create
- */
-
-#ifndef SEC_OMX_WMV_DEC_COMPONENT
-#define SEC_OMX_WMV_DEC_COMPONENT
-
-#include "SEC_OMX_Def.h"
-#include "OMX_Component.h"
-
-#define BITMAPINFOHEADER_SIZE 40
-#define BITMAPINFOHEADER_ASFBINDING_SIZE 41
-#define COMPRESSION_POS 16
-
-typedef enum WMV_FORMAT {
- WMV_FORMAT_VC1,
- WMV_FORMAT_WMV3,
- WMV_FORMAT_UNKNOWN
-} WMV_FORMAT;
-
-/*
- * This structure is the same as BitmapInfoHhr struct in pv_avifile_typedefs.h file
- */
-typedef struct _BitmapInfoHhr
-{
- OMX_U32 BiSize;
- OMX_U32 BiWidth;
- OMX_U32 BiHeight;
- OMX_U16 BiPlanes;
- OMX_U16 BiBitCount;
- OMX_U32 BiCompression;
- OMX_U32 BiSizeImage;
- OMX_U32 BiXPelsPerMeter;
- OMX_U32 BiYPelsPerMeter;
- OMX_U32 BiClrUsed;
- OMX_U32 BiClrImportant;
-} BitmapInfoHhr;
-
-typedef struct _SEC_MFC_WMV_HANDLE
-{
- OMX_HANDLETYPE hMFCHandle;
- OMX_PTR pMFCStreamBuffer;
- OMX_PTR pMFCStreamPhyBuffer;
- OMX_U32 indexTimestamp;
- OMX_U32 outputIndexTimestamp;
- OMX_BOOL bConfiguredMFC;
- WMV_FORMAT wmvFormat;
- OMX_S32 returnCodec;
-} SEC_MFC_WMV_HANDLE;
-
-typedef struct _SEC_WMV_HANDLE
-{
- /* OMX Codec specific */
- OMX_VIDEO_PARAM_WMVTYPE WmvComponent[ALL_PORT_NUM];
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType[ALL_PORT_NUM];
-
- /* SEC MFC Codec specific */
- SEC_MFC_WMV_HANDLE hMFCWmvHandle;
-} SEC_WMV_HANDLE;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-OSCL_EXPORT_REF OMX_ERRORTYPE SEC_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName);
- OMX_ERRORTYPE SEC_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/library_register.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/library_register.c
deleted file mode 100644
index ce04f18..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/library_register.c
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- *
- * Copyright 2010 Samsung Electronics S.LSI Co. LTD
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * @file library_register.c
- * @brief
- * @author HyeYeon Chung (hyeon.chung@samsung.com)
- * @version 1.1.0
- * @history
- * 2010.8.20 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <dlfcn.h>
-
-#include "SEC_OSAL_Memory.h"
-#include "SEC_OSAL_ETC.h"
-#include "library_register.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_WMV_DEC"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent)
-{
- FunctionIn();
-
- if (ppSECComponent == NULL) {
- goto EXIT;
- }
-
- /* component 1 - video decoder WMV */
- SEC_OSAL_Strcpy(ppSECComponent[0]->componentName, SEC_OMX_COMPONENT_WMV_DEC);
- SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPONENT_WMV_DEC_ROLE);
- ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
-
-EXIT:
- FunctionOut();
- return MAX_COMPONENT_NUM;
-}
\ No newline at end of file
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/library_register.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/library_register.h
deleted file mode 100644
index adac586..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vc1/library_register.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- *
- * Copyright 2010 Samsung Electronics S.LSI Co. LTD
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * @file library_register.h
- * @brief
- * @author HyeYeon Chung (hyeon.chung.chung@samsung.com)
- * @version 1.1.0
- * @history
- * 2010.7.15 : Create
- */
-
-#ifndef SEC_OMX_WMV_DEC_REG
-#define SEC_OMX_WMV_DEC_REG
-
-#include "SEC_OMX_Def.h"
-#include "OMX_Component.h"
-#include "SEC_OMX_Component_Register.h"
-
-#define OSCL_EXPORT_REF __attribute__((visibility("default")))
-#define MAX_COMPONENT_NUM 1
-#define MAX_COMPONENT_ROLE_NUM 1
-
-/* WMV */
-#define SEC_OMX_COMPONENT_WMV_DEC "OMX.SEC.WMV.Decoder"
-#define SEC_OMX_COMPONENT_WMV_DEC_ROLE "video_decoder.wmv"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif
\ No newline at end of file
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/Android.mk
deleted file mode 100644
index 1ced382..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/Android.mk
+++ /dev/null
@@ -1,65 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_Vp8dec.c \
- library_register.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libOMX.SEC.VP8.Decoder
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/omx
-
-LOCAL_CFLAGS :=
-
-ifeq ($(BOARD_NONBLOCK_MODE_PROCESS), true)
-LOCAL_CFLAGS += -DNONBLOCK_MODE_PROCESS
-endif
-
-ifeq ($(BOARD_USE_ANB), true)
-LOCAL_CFLAGS += -DUSE_ANB
-ifeq ($(BOARD_USE_CSC_FIMC), true)
-ifeq ($(BOARD_USE_V4L2_ION), false)
-LOCAL_CFLAGS += -DUSE_CSC_FIMC
-endif
-endif
-
-ifeq ($(BOARD_USE_CSC_GSCALER), true)
-LOCAL_CFLAGS += -DUSE_CSC_GSCALER
-endif
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libSEC_OMX_Vdec libsecosal libsecbasecomponent \
- libswconverter libsecmfcapi
-LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui \
- libSEC_OMX_Resourcemanager libcsc
-
-ifeq ($(filter-out exynos4,$(TARGET_BOARD_PLATFORM)),)
-LOCAL_SHARED_LIBRARIES += libfimc libhwconverter
-endif
-
-ifeq ($(filter-out exynos5,$(TARGET_BOARD_PLATFORM)),)
-LOCAL_SHARED_LIBRARIES += libexynosgscaler
-endif
-
-#ifeq ($(BOARD_USE_V4L2_ION),true)
-#LOCAL_SHARED_LIBRARIES += libion
-#endif
-
-ifeq ($(BOARD_USES_MFC_FPS),true)
-LOCAL_CFLAGS += -DCONFIG_MFC_FPS
-endif
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/dec \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO) \
- $(BOARD_HAL_PATH)/include
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/SEC_OMX_Vp8dec.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/SEC_OMX_Vp8dec.c
deleted file mode 100644
index 5ac91d5..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/SEC_OMX_Vp8dec.c
+++ /dev/null
@@ -1,1665 +0,0 @@
-/*
- *
- * 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 SEC_OMX_Vp8dec.c
- * @brief
- * @author Satish Kumar Reddy (palli.satish@samsung.com)
- * @version 1.1.0
- * @history
- * 2011.11.15 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "SEC_OMX_Macros.h"
-#include "SEC_OMX_Basecomponent.h"
-#include "SEC_OMX_Baseport.h"
-#include "SEC_OMX_Vdec.h"
-#include "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Thread.h"
-#include "library_register.h"
-#include "SEC_OMX_Vp8dec.h"
-#include "SsbSipMfcApi.h"
-
-#ifdef USE_ANB
-#include "SEC_OSAL_Android.h"
-#endif
-
-/* To use CSC_METHOD_PREFER_HW or CSC_METHOD_HW in SEC OMX, gralloc should allocate physical memory using FIMC */
-/* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
-#include "csc.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_VP8_DEC"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-#define VP8_DEC_NUM_OF_EXTRA_BUFFERS 7
-
-//#define FULL_FRAME_SEARCH /* Full frame search not support*/
-
-static int Check_VP8_Frame(OMX_U8 *pInputStream, int buffSize, OMX_U32 flag, OMX_BOOL bPreviousFrameEOF, OMX_BOOL *pbEndOfFrame)
-{
- /* Uncompressed data Chunk comprises a common
- (for key frames and interframes) 3-byte frame tag that
- contains four fields
- - 1-bit frame type (0 - key frame, 1 - inter frame)
- - 3-bit version number (0 - 3 are defined as four different
- profiles with different decoding complexity)
- - 1-bit show_frame flag ( 0 - current frame not for display,
- 1 - current frame is for dispaly)
- - 19-bit field - size of the first data partition in bytes
-
- Key Frames : frame tag followed by 7 bytes of uncompressed
- data
- 3-bytes : Start code (byte 0: 0x9d,byte 1: 0x01,byte 2: 0x2a)
- Next 4-bytes: Width & height, Horizontal and vertical scale information
- 16 bits : (2 bits Horizontal Scale << 14) | Width (14 bits)
- 16 bits : (2 bits Vertical Scale << 14) | Height (14 bits)
- */
- int width, height;
- int horizSscale, vertScale;
-
- FunctionIn();
-
- *pbEndOfFrame = OMX_TRUE;
-
- /*Check for Key frame*/
- if (!(pInputStream[0] & 0x01)){
- /* Key Frame Start code*/
- if (pInputStream[3] != 0x9d || pInputStream[4] != 0x01 || pInputStream[5]!=0x2a) {
- SEC_OSAL_Log(SEC_LOG_ERROR, " VP8 Key Frame Start Code not Found");
- *pbEndOfFrame = OMX_FALSE;
- }
- SEC_OSAL_Log(SEC_LOG_TRACE, " VP8 Found Key Frame Start Code");
- width = (pInputStream[6] | (pInputStream[7] << 8)) & 0x3fff;
- horizSscale = pInputStream[7] >> 6;
- height = (pInputStream[8] | (pInputStream[9] << 8)) & 0x3fff;
- vertScale = pInputStream[9] >> 6;
- SEC_OSAL_Log(SEC_LOG_TRACE, "width = %d, height = %d, horizSscale = %d, vertScale = %d", width, height, horizSscale, vertScale);
- }
-
- FunctionOut();
- return buffSize;
-}
-
-OMX_BOOL Check_VP8_StartCode(OMX_U8 *pInputStream, OMX_U32 streamSize)
-{
- SEC_OSAL_Log(SEC_LOG_TRACE, "streamSize: %d",streamSize);
- if (streamSize < 3) {
- return OMX_FALSE;
- }
-
- if (!(pInputStream[0] & 0x01)){
- /* Key Frame Start code*/
- if (pInputStream[3] != 0x9d || pInputStream[4] != 0x01 || pInputStream[5]!=0x2a) {
- SEC_OSAL_Log(SEC_LOG_ERROR, " VP8 Key Frame Start Code not Found");
- return OMX_FALSE;
- }
- SEC_OSAL_Log(SEC_LOG_TRACE, " VP8 Found Key Frame Start Code");
- }
-
- return OMX_TRUE;
-}
-
-OMX_ERRORTYPE SEC_MFC_VP8Dec_GetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nParamIndex,
- OMX_INOUT OMX_PTR pComponentParameterStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nParamIndex) {
- case OMX_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_VP8_DEC_ROLE);
- }
- break;
- case OMX_IndexParamVideoErrorCorrection:
- {
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
- SEC_VP8DEC_HANDLE *pVp8Dec = 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;
- }
-
- pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSrcErrorCorrectionType = &pVp8Dec->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_VP8Dec_SetParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR pComponentParameterStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL || pComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- if (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- case OMX_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_VP8_DEC_ROLE)) {
- pSECComponent->pSECPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingVPX;
- } else {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- }
- break;
- case OMX_IndexParamPortDefinition:
- {
- OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
- OMX_U32 portIndex = pPortDefinition->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort;
- OMX_U32 width, height, size;
- OMX_U32 realWidth, realHeight;
-
- if (portIndex >= pSECComponent->portParam.nPorts) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
- ret = SEC_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[portIndex];
-
- if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
- if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
- ret = OMX_ErrorIncorrectStateOperation;
- goto EXIT;
- }
- }
- if (pPortDefinition->nBufferCountActual < pSECPort->portDefinition.nBufferCountMin) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- SEC_OSAL_Memcpy(&pSECPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
-
- realWidth = pSECPort->portDefinition.format.video.nFrameWidth;
- realHeight = pSECPort->portDefinition.format.video.nFrameHeight;
- width = ((realWidth + 15) & (~15));
- height = ((realHeight + 15) & (~15));
- size = (width * height * 3) / 2;
- pSECPort->portDefinition.format.video.nStride = width;
- pSECPort->portDefinition.format.video.nSliceHeight = height;
- pSECPort->portDefinition.nBufferSize = (size > pSECPort->portDefinition.nBufferSize) ? size : pSECPort->portDefinition.nBufferSize;
-
- if (portIndex == INPUT_PORT_INDEX) {
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECOutputPort->portDefinition.format.video.nFrameWidth = pSECPort->portDefinition.format.video.nFrameWidth;
- pSECOutputPort->portDefinition.format.video.nFrameHeight = pSECPort->portDefinition.format.video.nFrameHeight;
- pSECOutputPort->portDefinition.format.video.nStride = width;
- pSECOutputPort->portDefinition.format.video.nSliceHeight = height;
-
- switch (pSECOutputPort->portDefinition.format.video.eColorFormat) {
- case OMX_COLOR_FormatYUV420Planar:
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- pSECOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
- break;
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pSECOutputPort->portDefinition.nBufferSize =
- ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight)) \
- + ALIGN_TO_8KB(ALIGN_TO_128B(realWidth) * ALIGN_TO_32B(realHeight/2));
- break;
- default:
- SEC_OSAL_Log(SEC_LOG_ERROR, "Color format is not support!! use default YUV size!!");
- ret = OMX_ErrorUnsupportedSetting;
- break;
- }
- }
- }
- break;
- case OMX_IndexParamVideoErrorCorrection:
- {
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
- SEC_VP8DEC_HANDLE *pVp8Dec = 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;
- }
-
- pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pDstErrorCorrectionType = &pVp8Dec->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_VP8Dec_GetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- if (pComponentConfigStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (pSECComponent->currentState == OMX_StateInvalid) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- default:
- ret = SEC_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_VP8Dec_SetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- if (pOMXComponent->pComponentPrivate == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
-
- if (pComponentConfigStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- if (pSECComponent->currentState == OMX_StateInvalid) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- default:
- ret = SEC_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_VP8Dec_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_VP8DEC_HANDLE *pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- *pIndexType = OMX_IndexVendorThumbnailMode;
-
- ret = OMX_ErrorNone;
- } else {
- ret = SEC_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_VP8Dec_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_VP8_DEC_ROLE);
- ret = OMX_ErrorNone;
- } else {
- ret = OMX_ErrorNoMore;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_DecodeThread(OMX_HANDLETYPE hComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_VP8DEC_HANDLE *pVp8Dec = (SEC_VP8DEC_HANDLE *)pVideoDec->hCodecHandle;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- while (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
- SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameStart);
-
- if (pVideoDec->NBDecThread.bExitDecodeThread == OMX_FALSE) {
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_DEC);
-#endif
- pVp8Dec->hMFCVp8Handle.returnCodec = SsbSipMfcDecExe(pVp8Dec->hMFCVp8Handle.hMFCHandle, pVideoDec->NBDecThread.oneFrameSize);
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_DEC);
-#endif
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameEnd);
- }
- }
-
-EXIT:
- SEC_OSAL_ThreadExit(NULL);
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Init */
-OMX_ERRORTYPE SEC_MFC_VP8Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_VP8DEC_HANDLE *pVp8Dec = NULL;
- OMX_PTR hMFCHandle = NULL;
- OMX_PTR pStreamBuffer = NULL;
- OMX_PTR pStreamPhyBuffer = NULL;
- CSC_METHOD csc_method = CSC_METHOD_SW;
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfInit(PERF_ID_DEC);
- SEC_OSAL_PerfInit(PERF_ID_CSC);
-#endif
-
- pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pVp8Dec->hMFCVp8Handle.bConfiguredMFC = OMX_FALSE;
- pSECComponent->bUseFlagEOF = OMX_FALSE;
- pSECComponent->bSaveFlagEOS = OMX_FALSE;
-
- /* MFC(Multi Function Codec) decoder and CMM(Codec Memory Management) driver open */
- if (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress) {
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpen();
- } else {
- SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
- hMFCHandle = (OMX_PTR)SsbSipMfcDecOpenExt(&buf_type);
- }
-
- if (hMFCHandle == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVp8Dec->hMFCVp8Handle.hMFCHandle = hMFCHandle;
-
- /* Allocate decoder's input buffer */
- /* Get first input buffer */
- pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoDec->MFCDecInputBuffer[0].VirAddr = pStreamBuffer;
- pVideoDec->MFCDecInputBuffer[0].PhyAddr = pStreamPhyBuffer;
- pVideoDec->MFCDecInputBuffer[0].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2;
- pVideoDec->MFCDecInputBuffer[0].dataSize = 0;
-
-#ifdef NONBLOCK_MODE_PROCESS
- /* Get second input buffer */
- pStreamBuffer = NULL;
- pStreamBuffer = SsbSipMfcDecGetInBuf(hMFCHandle, &pStreamPhyBuffer, DEFAULT_MFC_INPUT_BUFFER_SIZE / 2);
- if (pStreamBuffer == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoDec->MFCDecInputBuffer[1].VirAddr = pStreamBuffer;
- pVideoDec->MFCDecInputBuffer[1].PhyAddr = pStreamPhyBuffer;
- pVideoDec->MFCDecInputBuffer[1].bufferSize = DEFAULT_MFC_INPUT_BUFFER_SIZE / 2;
- pVideoDec->MFCDecInputBuffer[1].dataSize = 0;
- pVideoDec->indexInputBuffer = 0;
-
- pVideoDec->bFirstFrame = OMX_TRUE;
-
- pVideoDec->NBDecThread.bExitDecodeThread = OMX_FALSE;
- pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE;
- pVideoDec->NBDecThread.oneFrameSize = 0;
- SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameStart));
- SEC_OSAL_SemaphoreCreate(&(pVideoDec->NBDecThread.hDecFrameEnd));
- if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pVideoDec->NBDecThread.hNBDecodeThread,
- SEC_MFC_DecodeThread,
- pOMXComponent)) {
- pVp8Dec->hMFCVp8Handle.returnCodec = MFC_RET_OK;
- }
-#endif
-
- pVp8Dec->hMFCVp8Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr;
- pVp8Dec->hMFCVp8Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[0].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[0].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[0].bufferSize;
-
- SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
- SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
- pVp8Dec->hMFCVp8Handle.indexTimestamp = 0;
- pVp8Dec->hMFCVp8Handle.outputIndexTimestamp = 0;
-
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
-
-#ifdef USE_ANB
-#if defined(USE_CSC_FIMC) || defined(USE_CSC_GSCALER)
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- csc_method = CSC_METHOD_PREFER_HW;
- }
-#endif
-#endif
- pVideoDec->csc_handle = csc_init(&csc_method);
- pVideoDec->csc_set_format = OMX_FALSE;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Terminate */
-OMX_ERRORTYPE SEC_MFC_VP8Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_VP8DEC_HANDLE *pVp8Dec = NULL;
- OMX_PTR hMFCHandle = NULL;
-
- FunctionIn();
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfPrint("[DEC]", PERF_ID_DEC);
- SEC_OSAL_PerfPrint("[CSC]", PERF_ID_CSC);
-#endif
-
- pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- hMFCHandle = pVp8Dec->hMFCVp8Handle.hMFCHandle;
-
- pVp8Dec->hMFCVp8Handle.pMFCStreamBuffer = NULL;
- pVp8Dec->hMFCVp8Handle.pMFCStreamPhyBuffer = NULL;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = NULL;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = 0;
-
-#ifdef NONBLOCK_MODE_PROCESS
- if (pVideoDec->NBDecThread.hNBDecodeThread != NULL) {
- pVideoDec->NBDecThread.bExitDecodeThread = OMX_TRUE;
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
- SEC_OSAL_ThreadTerminate(pVideoDec->NBDecThread.hNBDecodeThread);
- pVideoDec->NBDecThread.hNBDecodeThread = NULL;
- }
-
- if(pVideoDec->NBDecThread.hDecFrameEnd != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameEnd);
- pVideoDec->NBDecThread.hDecFrameEnd = NULL;
- }
-
- if(pVideoDec->NBDecThread.hDecFrameStart != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoDec->NBDecThread.hDecFrameStart);
- pVideoDec->NBDecThread.hDecFrameStart = NULL;
- }
-#endif
-
- if (hMFCHandle != NULL) {
- SsbSipMfcDecClose(hMFCHandle);
- hMFCHandle = pVp8Dec->hMFCVp8Handle.hMFCHandle = NULL;
- }
-
- if (pVideoDec->csc_handle != NULL) {
- csc_deinit(pVideoDec->csc_handle);
- pVideoDec->csc_handle = NULL;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_VP8_Decode_Nonblock(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_VP8DEC_HANDLE *pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 setConfVal = 0;
- int bufWidth = 0;
- int bufHeight = 0;
- OMX_U32 FrameBufferYSize = 0;
- OMX_U32 FrameBufferUVSize = 0;
- OMX_BOOL outputDataValid = OMX_FALSE;
-
- FunctionIn();
-
- if (pVp8Dec->hMFCVp8Handle.bConfiguredMFC == OMX_FALSE) {
- SSBSIP_MFC_CODEC_TYPE eCodecType = VP8_DEC;
-
- if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
- /* Default number in the driver is optimized */
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- setConfVal = 0;
- SsbSipMfcDecSetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- } else {
- setConfVal = VP8_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &setConfVal);
-
- setConfVal = 8;
- SsbSipMfcDecSetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- }
-
- SsbSipMfcDecSetInBuf(pVp8Dec->hMFCVp8Handle.hMFCHandle,
- pVp8Dec->hMFCVp8Handle.pMFCStreamPhyBuffer,
- pVp8Dec->hMFCVp8Handle.pMFCStreamBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- pVp8Dec->hMFCVp8Handle.returnCodec = SsbSipMfcDecInit(pVp8Dec->hMFCVp8Handle.hMFCHandle, eCodecType, oneFrameSize);
- if (pVp8Dec->hMFCVp8Handle.returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
-
- SsbSipMfcDecGetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol);
- SEC_OSAL_Log(SEC_LOG_ERROR, "set width height information : %d, %d",
- pSECInputPort->portDefinition.format.video.nFrameWidth,
- pSECInputPort->portDefinition.format.video.nFrameHeight);
- SEC_OSAL_Log(SEC_LOG_ERROR, "mfc width height information : %d, %d",
- imgResol.width, imgResol.height);
-
- if ((pSECInputPort->portDefinition.format.video.nFrameWidth != imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != imgResol.height)) {
- SEC_OSAL_Log(SEC_LOG_TRACE, "change width height information : OMX_EventPortSettingsChanged");
-
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /** Send Port Settings changed call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- 0,
- NULL);
- }
-
- pVp8Dec->hMFCVp8Handle.bConfiguredMFC = OMX_TRUE;
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- ret = OMX_ErrorInputDataDecodeYet;
- 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[pVp8Dec->hMFCVp8Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pVp8Dec->hMFCVp8Handle.indexTimestamp] = pInputData->nFlags;
-
- if ((pVp8Dec->hMFCVp8Handle.returnCodec == MFC_RET_OK) &&
- (pVideoDec->bFirstFrame == OMX_FALSE)) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- /* wait for mfc decode done */
- if (pVideoDec->NBDecThread.bDecoderRun == OMX_TRUE) {
- SEC_OSAL_SemaphoreWait(pVideoDec->NBDecThread.hDecFrameEnd);
- pVideoDec->NBDecThread.bDecoderRun = OMX_FALSE;
- }
-
- SEC_OSAL_SleepMillisec(0);
- status = SsbSipMfcDecGetOutBuf(pVp8Dec->hMFCVp8Handle.hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
- if ((SsbSipMfcDecGetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
- (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if (outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pVp8Dec->hMFCVp8Handle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pVp8Dec->hMFCVp8Handle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pVp8Dec->hMFCVp8Handle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6);
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- outputDataValid = OMX_TRUE;
- pVp8Dec->hMFCVp8Handle.outputIndexTimestamp++;
- pVp8Dec->hMFCVp8Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- outputDataValid = OMX_FALSE;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE))
- ret = OMX_ErrorInputDataDecodeYet;
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- outputDataValid = OMX_FALSE;
- }
-
-#ifdef FULL_FRAME_SEARCH
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else
-#endif
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
-
- if ((pVideoDec->bFirstFrame == OMX_TRUE) &&
- ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) &&
- ((pInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) != OMX_BUFFERFLAG_CODECCONFIG)) {
- pOutputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- }
-
- outputDataValid = OMX_FALSE;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- }
-
- if (ret == OMX_ErrorInputDataDecodeYet) {
- pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
- pVideoDec->indexInputBuffer++;
- pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- pVp8Dec->hMFCVp8Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pVp8Dec->hMFCVp8Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize;
- oneFrameSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize;
- //pInputData->dataLen = oneFrameSize;
- //pInputData->remainDataLen = oneFrameSize;
- }
-
- if ((Check_VP8_StartCode(pInputData->dataBuffer, oneFrameSize) == OMX_TRUE) &&
- ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
- if ((ret != OMX_ErrorInputDataDecodeYet) || (pSECComponent->getAllDelayBuffer == OMX_TRUE)) {
- SsbSipMfcDecSetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pVp8Dec->hMFCVp8Handle.indexTimestamp));
- pVp8Dec->hMFCVp8Handle.indexTimestamp++;
- pVp8Dec->hMFCVp8Handle.indexTimestamp %= MAX_TIMESTAMP;
- }
-
- SsbSipMfcDecSetInBuf(pVp8Dec->hMFCVp8Handle.hMFCHandle,
- pVp8Dec->hMFCVp8Handle.pMFCStreamPhyBuffer,
- pVp8Dec->hMFCVp8Handle.pMFCStreamBuffer,
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize);
-
- pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].dataSize = oneFrameSize;
- pVideoDec->NBDecThread.oneFrameSize = oneFrameSize;
-
- /* mfc decode start */
- SEC_OSAL_SemaphorePost(pVideoDec->NBDecThread.hDecFrameStart);
- pVideoDec->NBDecThread.bDecoderRun = OMX_TRUE;
- pVp8Dec->hMFCVp8Handle.returnCodec = MFC_RET_OK;
-
- SEC_OSAL_SleepMillisec(0);
-
- pVideoDec->indexInputBuffer++;
- pVideoDec->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- pVp8Dec->hMFCVp8Handle.pMFCStreamBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pVp8Dec->hMFCVp8Handle.pMFCStreamPhyBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].PhyAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].dataBuffer = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].VirAddr;
- pSECComponent->processData[INPUT_PORT_INDEX].allocSize = pVideoDec->MFCDecInputBuffer[pVideoDec->indexInputBuffer].bufferSize;
-
- if ((pVideoDec->bFirstFrame == OMX_TRUE) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE) &&
- (outputDataValid == OMX_FALSE)) {
- ret = OMX_ErrorInputDataDecodeYet;
- }
-
- pVideoDec->bFirstFrame = OMX_FALSE;
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
- }
-
- /** Fill Output Buffer **/
- if (outputDataValid == OMX_TRUE) {
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int width = outputInfo.img_width;
- int height = outputInfo.img_height;
- int imageSize = outputInfo.img_width * outputInfo.img_height;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + imageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + imageSize + imageSize / 4;
- pOutputData->dataLen = (imageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- unsigned int stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, width, height, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- width = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
- if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
- (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
- /* if use Post copy address structure */
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (width * height * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 SP/P Output mode");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle,
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
- }
-#endif
- } else {
- pOutputData->dataLen = 0;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_VP8_Decode_Block(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_VP8DEC_HANDLE *pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- SSBSIP_MFC_DEC_OUTPUT_INFO outputInfo;
- OMX_S32 setConfVal = 0;
- OMX_S32 returnCodec = 0;
- int bufWidth = 0;
- int bufHeight = 0;
- OMX_U32 FrameBufferYSize;
- OMX_U32 FrameBufferUVSize;
-
- FunctionIn();
-
- if (pVp8Dec->hMFCVp8Handle.bConfiguredMFC == OMX_FALSE) {
- SSBSIP_MFC_CODEC_TYPE eCodecType = VP8_DEC;
-
- if ((oneFrameSize <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
- /* Default number in the driver is optimized */
- if (pVideoDec->bThumbnailMode == OMX_TRUE) {
- setConfVal = 0;
- SsbSipMfcDecSetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_SETCONF_DISPLAY_DELAY, &setConfVal);
- } else {
- setConfVal = VP8_DEC_NUM_OF_EXTRA_BUFFERS;
- SsbSipMfcDecSetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_SETCONF_EXTRA_BUFFER_NUM, &setConfVal);
- }
-
- returnCodec = SsbSipMfcDecInit(pVp8Dec->hMFCVp8Handle.hMFCHandle, eCodecType, oneFrameSize);
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_IMG_RESOLUTION imgResol;
-
- SsbSipMfcDecGetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_GETCONF_BUF_WIDTH_HEIGHT, &imgResol);
- SEC_OSAL_Log(SEC_LOG_TRACE, "set width height information : %d, %d",
- pSECInputPort->portDefinition.format.video.nFrameWidth,
- pSECInputPort->portDefinition.format.video.nFrameHeight);
- SEC_OSAL_Log(SEC_LOG_TRACE, "mfc width height information : %d, %d",
- imgResol.width, imgResol.height);
-
- /** Update Frame Size **/
- if ((pSECInputPort->portDefinition.format.video.nFrameWidth != imgResol.width) ||
- (pSECInputPort->portDefinition.format.video.nFrameHeight != imgResol.height)) {
- SEC_OSAL_Log(SEC_LOG_TRACE, "change width height information : OMX_EventPortSettingsChanged");
- /* change width and height information */
- pSECInputPort->portDefinition.format.video.nFrameWidth = imgResol.width;
- pSECInputPort->portDefinition.format.video.nFrameHeight = imgResol.height;
- pSECInputPort->portDefinition.format.video.nStride = ((imgResol.width + 15) & (~15));
- pSECInputPort->portDefinition.format.video.nSliceHeight = ((imgResol.height + 15) & (~15));
-
- SEC_UpdateFrameSize(pOMXComponent);
-
- /** Send Port Settings changed call back **/
- (*(pSECComponent->pCallbacks->EventHandler))
- (pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventPortSettingsChanged, /* The command was completed */
- OMX_DirOutput, /* This is the port index */
- 0,
- NULL);
- }
-
- pVp8Dec->hMFCVp8Handle.bConfiguredMFC = OMX_TRUE;
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- ret = OMX_ErrorInputDataDecodeYet;
- goto EXIT;
- } else {
- ret = OMX_ErrorMFCInit;
- goto EXIT;
- }
- }
-
-#ifndef FULL_FRAME_SEARCH
- if ((pInputData->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) &&
- (pSECComponent->bUseFlagEOF == OMX_FALSE))
- pSECComponent->bUseFlagEOF = OMX_TRUE;
-#endif
-
- if (Check_VP8_StartCode(pInputData->dataBuffer, pInputData->dataLen) == OMX_TRUE) {
- pSECComponent->timeStamp[pVp8Dec->hMFCVp8Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pVp8Dec->hMFCVp8Handle.indexTimestamp] = pInputData->nFlags;
- SsbSipMfcDecSetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_SETCONF_FRAME_TAG, &(pVp8Dec->hMFCVp8Handle.indexTimestamp));
-
- returnCodec = SsbSipMfcDecExe(pVp8Dec->hMFCVp8Handle.hMFCHandle, oneFrameSize);
- } else {
- if (pSECComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE)
- pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
-
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- returnCodec = MFC_RET_OK;
- goto EXIT;
- }
-
- if (returnCodec == MFC_RET_OK) {
- SSBSIP_MFC_DEC_OUTBUF_STATUS status;
- OMX_S32 indexTimestamp = 0;
-
- status = SsbSipMfcDecGetOutBuf(pVp8Dec->hMFCVp8Handle.hMFCHandle, &outputInfo);
- bufWidth = (outputInfo.img_width + 15) & (~15);
- bufHeight = (outputInfo.img_height + 15) & (~15);
- FrameBufferYSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height));
- FrameBufferUVSize = ALIGN_TO_8KB(ALIGN_TO_128B(outputInfo.img_width) * ALIGN_TO_32B(outputInfo.img_height/2));
-
- if (status != MFC_GETOUTBUF_DISPLAY_ONLY) {
- pVp8Dec->hMFCVp8Handle.indexTimestamp++;
- pVp8Dec->hMFCVp8Handle.indexTimestamp %= MAX_TIMESTAMP;
- }
-
- if ((SsbSipMfcDecGetConfig(pVp8Dec->hMFCVp8Handle.hMFCHandle, MFC_DEC_GETCONF_FRAME_TAG, &indexTimestamp) != MFC_RET_OK) ||
- (((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)))) {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
- } else {
- /* For timestamp correction. if mfc support frametype detect */
- SEC_OSAL_Log(SEC_LOG_TRACE, "disp_pic_frame_type: %d", outputInfo.disp_pic_frame_type);
-#ifdef NEED_TIMESTAMP_REORDER
- if (outputInfo.disp_pic_frame_type == MFC_FRAME_TYPE_I_FRAME) {
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
- pVp8Dec->hMFCVp8Handle.outputIndexTimestamp = indexTimestamp;
- } else {
- pOutputData->timeStamp = pSECComponent->timeStamp[pVp8Dec->hMFCVp8Handle.outputIndexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[pVp8Dec->hMFCVp8Handle.outputIndexTimestamp];
- }
-#else
- pOutputData->timeStamp = pSECComponent->timeStamp[indexTimestamp];
- pOutputData->nFlags = pSECComponent->nFlags[indexTimestamp];
-#endif
- SEC_OSAL_Log(SEC_LOG_TRACE, "timestamp %lld us (%.2f secs)", pOutputData->timeStamp, pOutputData->timeStamp / 1E6);
- }
-
- if ((status == MFC_GETOUTBUF_DISPLAY_DECODING) ||
- (status == MFC_GETOUTBUF_DISPLAY_ONLY)) {
- /** Fill Output Buffer **/
- void *pOutputBuf = (void *)pOutputData->dataBuffer;
- void *pSrcBuf[3] = {NULL, };
- void *pYUVBuf[3] = {NULL, };
- unsigned int csc_src_color_format, csc_dst_color_format;
- CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
-
- int frameSize = bufWidth * bufHeight;
- int width = outputInfo.img_width;
- int height = outputInfo.img_height;
- int imageSize = outputInfo.img_width * outputInfo.img_height;
-
- pSrcBuf[0] = outputInfo.YVirAddr;
- pSrcBuf[1] = outputInfo.CVirAddr;
-
- pYUVBuf[0] = (unsigned char *)pOutputBuf;
- pYUVBuf[1] = (unsigned char *)pOutputBuf + imageSize;
- pYUVBuf[2] = (unsigned char *)pOutputBuf + imageSize + imageSize / 4;
- pOutputData->dataLen = (imageSize * 3) / 2;
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- unsigned int stride;
- SEC_OSAL_LockANB(pOutputData->dataBuffer, width, height, pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat, &stride, pYUVBuf);
- width = stride;
- pOutputData->dataLen = sizeof(void *);
- }
-#endif
- if ((pVideoDec->bThumbnailMode == OMX_FALSE) &&
- (pSECOutputPort->portDefinition.format.video.eColorFormat == OMX_SEC_COLOR_FormatNV12TPhysicalAddress)) {
- /* if use Post copy address structure */
- SEC_OSAL_Memcpy(pYUVBuf[0], &(outputInfo.YPhyAddr), sizeof(outputInfo.YPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 1), &(outputInfo.CPhyAddr), sizeof(outputInfo.CPhyAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 2), &(outputInfo.YVirAddr), sizeof(outputInfo.YVirAddr));
- SEC_OSAL_Memcpy((unsigned char *)pYUVBuf[0] + (sizeof(void *) * 3), &(outputInfo.CVirAddr), sizeof(outputInfo.CVirAddr));
- pOutputData->dataLen = (width * height * 3) / 2;
- } else {
- SEC_OSAL_Log(SEC_LOG_TRACE, "YUV420 SP/P Output mode");
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStart(PERF_ID_CSC);
-#endif
- switch (pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12Tiled:
- SEC_OSAL_Memcpy(pOutputBuf, outputInfo.YVirAddr, FrameBufferYSize);
- SEC_OSAL_Memcpy((unsigned char *)pOutputBuf + FrameBufferYSize, outputInfo.CVirAddr, FrameBufferUVSize);
- pOutputData->dataLen = FrameBufferYSize + FrameBufferUVSize;
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420Planar:
- default:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_SEC_COLOR_FormatNV12Tiled);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- break;
- }
-
- csc_get_method(pVideoDec->csc_handle, &csc_method);
-#ifdef USE_CSC_FIMC
- if ((pSECOutputPort->bIsANBEnabled == OMX_TRUE) && (csc_method == CSC_METHOD_HW)) {
- SEC_OSAL_GetPhysANB(pOutputData->dataBuffer, pYUVBuf);
- pSrcBuf[0] = outputInfo.YPhyAddr;
- pSrcBuf[1] = outputInfo.CPhyAddr;
- }
-#endif
- if (pVideoDec->csc_set_format == OMX_FALSE) {
- csc_set_src_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoDec->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- pVideoDec->csc_set_format = OMX_TRUE;
- }
- csc_set_src_buffer(
- pVideoDec->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoDec->csc_handle,
- pYUVBuf[0], /* y addr */
- pYUVBuf[1], /* u addr or uv addr */
- pYUVBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoDec->csc_handle);
-
-#ifdef CONFIG_MFC_FPS
- SEC_OSAL_PerfStop(PERF_ID_CSC);
-#endif
- }
-
-#ifdef USE_ANB
- if (pSECOutputPort->bIsANBEnabled == OMX_TRUE) {
- SEC_OSAL_UnlockANB(pOutputData->dataBuffer);
- }
-#endif
- pVp8Dec->hMFCVp8Handle.outputIndexTimestamp++;
- pVp8Dec->hMFCVp8Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
- }
- if (pOutputData->nFlags & OMX_BUFFERFLAG_EOS)
- pOutputData->dataLen = 0;
-
- if ((status == MFC_GETOUTBUF_DISPLAY_ONLY) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE))
- ret = OMX_ErrorInputDataDecodeYet;
-
- if (status == MFC_GETOUTBUF_DECODING_ONLY) {
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- ((pSECComponent->bSaveFlagEOS == OMX_TRUE) || (pSECComponent->getAllDelayBuffer == OMX_TRUE))) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else {
- ret = OMX_ErrorNone;
- }
- goto EXIT;
- }
-
-#ifdef FULL_FRAME_SEARCH
- if (((pInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS) &&
- (pSECComponent->bSaveFlagEOS == OMX_TRUE)) {
- pInputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else
-#endif
- if ((pInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pInputData->nFlags = (pOutputData->nFlags & (~OMX_BUFFERFLAG_EOS));
- pSECComponent->getAllDelayBuffer = OMX_TRUE;
- ret = OMX_ErrorInputDataDecodeYet;
- } else if ((pOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- ret = OMX_ErrorNone;
- }
- } else {
- pOutputData->timeStamp = pInputData->timeStamp;
- pOutputData->nFlags = pInputData->nFlags;
-
- if ((pSECComponent->bSaveFlagEOS == OMX_TRUE) ||
- (pSECComponent->getAllDelayBuffer == OMX_TRUE) ||
- (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
- pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
- pSECComponent->getAllDelayBuffer = OMX_FALSE;
- }
- pOutputData->dataLen = 0;
-
- /* ret = OMX_ErrorUndefined; */
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Decode */
-OMX_ERRORTYPE SEC_MFC_VP8Dec_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_VP8DEC_HANDLE *pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- OMX_BOOL endOfFrame = OMX_FALSE;
-
- FunctionIn();
-
- if ((!CHECK_PORT_ENABLED(pSECInputPort)) || (!CHECK_PORT_ENABLED(pSECOutputPort)) ||
- (!CHECK_PORT_POPULATED(pSECInputPort)) || (!CHECK_PORT_POPULATED(pSECOutputPort))) {
- ret = OMX_ErrorNone;
- goto EXIT;
- }
- if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
- ret = OMX_ErrorNone;
- goto EXIT;
- }
-
-#ifdef NONBLOCK_MODE_PROCESS
- ret = SEC_MFC_VP8_Decode_Nonblock(pOMXComponent, pInputData, pOutputData);
-#else
- ret = SEC_MFC_VP8_Decode_Block(pOMXComponent, pInputData, pOutputData);
-#endif
- if (ret != OMX_ErrorNone) {
- if (ret == OMX_ErrorInputDataDecodeYet) {
- pOutputData->usedDataLen = 0;
- pOutputData->remainDataLen = pOutputData->dataLen;
- } else {
- pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
- pSECComponent->callbackData,
- OMX_EventError, ret, 0, NULL);
- }
- } else {
- pInputData->previousDataLen = pInputData->dataLen;
- pInputData->usedDataLen += pInputData->dataLen;
- pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen;
- pInputData->dataLen -= pInputData->usedDataLen;
- pInputData->usedDataLen = 0;
-
- pOutputData->usedDataLen = 0;
- pOutputData->remainDataLen = pOutputData->dataLen;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OSCL_EXPORT_REF OMX_ERRORTYPE SEC_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_COMPONENTTYPE *pOMXComponent = NULL;
- SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- SEC_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
- SEC_VP8DEC_HANDLE *pVp8Dec = NULL;
- //OMX_BOOL bFlashPlayerMode = OMX_FALSE;
- int i = 0;
-
- FunctionIn();
-
- if ((hComponent == NULL) || (componentName == NULL)) {
- ret = OMX_ErrorBadParameter;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
- goto EXIT;
- }
- if (SEC_OSAL_Strcmp(SEC_OMX_COMPONENT_VP8_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_DEC_CODEC;
-
- pSECComponent->componentName = (OMX_STRING)SEC_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
- if (pSECComponent->componentName == NULL) {
- SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
- SEC_OSAL_Memset(pSECComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
-
- pVp8Dec = SEC_OSAL_Malloc(sizeof(SEC_VP8DEC_HANDLE));
- if (pVp8Dec == NULL) {
- SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
- SEC_OSAL_Memset(pVp8Dec, 0, sizeof(SEC_VP8DEC_HANDLE));
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
- pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pVp8Dec;
-
- SEC_OSAL_Strcpy(pSECComponent->componentName, SEC_OMX_COMPONENT_VP8_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_CodingVPX;
- SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "video/x-vnd.on2.vp8");
- pSECPort->portDefinition.format.video.pNativeRender = 0;
- pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
-
- /* Output port */
- pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- pSECPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
- pSECPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
- pSECPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
- pSECPort->portDefinition.format.video.nSliceHeight = 0;
- pSECPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
- pSECPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
- SEC_OSAL_Memset(pSECPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
- SEC_OSAL_Strcpy(pSECPort->portDefinition.format.video.cMIMEType, "raw/video");
- pSECPort->portDefinition.format.video.pNativeRender = 0;
- pSECPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
- pSECPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
- pSECPort->portDefinition.bEnabled = OMX_TRUE;
-
- /*for(i = 0; i < ALL_PORT_NUM; i++) {
- INIT_SET_SIZE_VERSION(&pH264Dec->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE);
- pH264Dec->AVCComponent[i].nPortIndex = i;
- pH264Dec->AVCComponent[i].eProfile = OMX_VIDEO_AVCProfileBaseline;
- pH264Dec->AVCComponent[i].eLevel = OMX_VIDEO_AVCLevel4;
- }*/
-
- pOMXComponent->GetParameter = &SEC_MFC_VP8Dec_GetParameter;
- pOMXComponent->SetParameter = &SEC_MFC_VP8Dec_SetParameter;
- pOMXComponent->GetConfig = &SEC_MFC_VP8Dec_GetConfig;
- pOMXComponent->SetConfig = &SEC_MFC_VP8Dec_SetConfig;
- pOMXComponent->GetExtensionIndex = &SEC_MFC_VP8Dec_GetExtensionIndex;
- pOMXComponent->ComponentRoleEnum = &SEC_MFC_VP8Dec_ComponentRoleEnum;
- pOMXComponent->ComponentDeInit = &SEC_OMX_ComponentDeinit;
-
- pSECComponent->sec_mfc_componentInit = &SEC_MFC_VP8Dec_Init;
- pSECComponent->sec_mfc_componentTerminate = &SEC_MFC_VP8Dec_Terminate;
- pSECComponent->sec_mfc_bufferProcess = &SEC_MFC_VP8Dec_bufferProcess;
- pSECComponent->sec_checkInputFrame = &Check_VP8_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_VP8DEC_HANDLE *pVp8Dec = 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;
-
- pVp8Dec = (SEC_VP8DEC_HANDLE *)((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pVp8Dec != NULL) {
- SEC_OSAL_Free(pVp8Dec);
- pVp8Dec = ((SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle = NULL;
- }
-
- ret = SEC_OMX_VideoDecodeComponentDeinit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- ret = OMX_ErrorNone;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/SEC_OMX_Vp8dec.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/SEC_OMX_Vp8dec.h
deleted file mode 100644
index 40ce20c..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/SEC_OMX_Vp8dec.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- *
- * 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 SEC_OMX_Vp8dec.h
- * @brief
- * @author Satish Kumar Reddy (palli.satish@samsung.com)
- * @version 1.1.0
- * @history
- * 2011.10.10 : Create
- */
-
-#ifndef SEC_OMX_VP8_DEC_COMPONENT
-#define SEC_OMX_VP8_DEC_COMPONENT
-
-#include "SEC_OMX_Def.h"
-#include "OMX_Component.h"
-#include "OMX_Video.h"
-
-
-typedef struct _SEC_MFC_VP8DEC_HANDLE
-{
- OMX_HANDLETYPE hMFCHandle;
- OMX_PTR pMFCStreamBuffer;
- OMX_PTR pMFCStreamPhyBuffer;
- OMX_U32 indexTimestamp;
- OMX_U32 outputIndexTimestamp;
- OMX_BOOL bConfiguredMFC;
- OMX_S32 returnCodec;
-} SEC_MFC_VP8DEC_HANDLE;
-
-typedef struct _SEC_VP8DEC_HANDLE
-{
- /* OMX Codec specific */
- OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType[ALL_PORT_NUM];
-
- /* SEC MFC Codec specific */
- SEC_MFC_VP8DEC_HANDLE hMFCVp8Handle;
-} SEC_VP8DEC_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/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/library_register.c b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/library_register.c
deleted file mode 100644
index 13f7f4a..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/library_register.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- *
- * 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 library_register.c
- * @brief
- * @author Satish Kumar Reddy (palli.satish@samsung.com)
- * @version 1.1.0
- * @history
- * 2011.11.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_VP8_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 VP8 */
- SEC_OSAL_Strcpy(ppSECComponent[0]->componentName, SEC_OMX_COMPONENT_VP8_DEC);
- SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPONENT_VP8_DEC_ROLE);
- ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM;
-
-EXIT:
- FunctionOut();
- return MAX_COMPONENT_NUM;
-}
-
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/library_register.h b/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/library_register.h
deleted file mode 100644
index 5e17150..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/dec/vp8/library_register.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- *
- * 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 library_register.h
- * @brief
- * @author Satish Kumar Reddy (palli.satish@samsung.com)
- * @version 1.1.0
- * @history
- * 2011.11.15 : Create
- */
-
-#ifndef SEC_OMX_VP8_DEC_REG
-#define SEC_OMX_VP8_DEC_REG
-
-#include "SEC_OMX_Def.h"
-#include "OMX_Component.h"
-#include "SEC_OMX_Component_Register.h"
-
-
-#define OSCL_EXPORT_REF __attribute__((visibility("default")))
-#define MAX_COMPONENT_NUM 1
-#define MAX_COMPONENT_ROLE_NUM 1
-
-/* VP8 */
-#define SEC_OMX_COMPONENT_VP8_DEC "OMX.SEC.VP8.Decoder"
-#define SEC_OMX_COMPONENT_VP8_DEC_ROLE "video_decoder.vpx"
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/enc/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/video/enc/Android.mk
deleted file mode 100644
index 1c842f2..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/Android.mk
+++ /dev/null
@@ -1,37 +0,0 @@
-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)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/dec \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO)
-
-ifeq ($(BOARD_USE_METADATABUFFERTYPE), true)
-LOCAL_CFLAGS += -DUSE_METADATABUFFERTYPE
-endif
-
-ifeq ($(BOARD_USE_STOREMETADATA), true)
-LOCAL_CFLAGS += -DUSE_STOREMETADATA
-endif
-
-ifeq ($(BOARD_USE_V4L2), true)
-ifeq ($(TARGET_SOC), exynos5250)
-LOCAL_CFLAGS += -DUSE_SLICE_OUTPUT_MODE
-endif
-else
-LOCAL_CFLAGS += -DUSE_SLICE_OUTPUT_MODE
-endif
-
-LOCAL_SHARED_LIBRARIES := libcsc
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/enc/SEC_OMX_Venc.c b/exynos4/multimedia/openmax/sec_omx/component/video/enc/SEC_OMX_Venc.c
deleted file mode 100644
index e4b6cc2..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/SEC_OMX_Venc.c
+++ /dev/null
@@ -1,1856 +0,0 @@
-/*
- *
- * 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.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 "SEC_OSAL_Mutex.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_ETC.h"
-#include "csc.h"
-
-#ifdef USE_STOREMETADATA
-#include "SEC_OSAL_Android.h"
-#endif
-
-#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;
-
- if (width && height)
- secOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
- }
-
- 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;
- 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;
-
- 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;
- 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;
-
- 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;
- 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;
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- /* 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_VIDEOENC_COMPONENT *pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- 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;
- unsigned int oneFrameSize = 0;
-
- switch (pSECPort->portDefinition.format.video.eColorFormat) {
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_COLOR_FormatYUV420Planar:
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12Tiled:
- case OMX_SEC_COLOR_FormatNV21Linear:
- oneFrameSize = (width * height * 3) / 2;
- break;
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- oneFrameSize = ALIGN((ALIGN(width, 16) * ALIGN(height, 16)), 2048) + ALIGN((ALIGN(width, 16) * ALIGN(height >> 1, 8)), 2048);
- break;
- default:
- SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_Preprocessor_InputData: eColorFormat is wrong");
- break;
- }
-
- 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->portDefinition.format.video.eColorFormat != OMX_SEC_COLOR_FormatNV12LPhysicalAddress) &&
- (pSECPort->portDefinition.format.video.eColorFormat != OMX_SEC_COLOR_FormatNV12LVirtualAddress) &&
- (pSECPort->portDefinition.format.video.eColorFormat != OMX_SEC_COLOR_FormatNV21LPhysicalAddress)) {
- if (flagEOF == OMX_TRUE) {
- OMX_U32 width, height;
- unsigned int csc_src_color_format, csc_dst_color_format;
- unsigned int cacheable = 1;
- unsigned char *pSrcBuf[3] = {NULL, };
- unsigned char *pDstBuf[3] = {NULL, };
- OMX_PTR ppBuf[3];
-
- width = pSECPort->portDefinition.format.video.nFrameWidth;
- height = pSECPort->portDefinition.format.video.nFrameHeight;
-
- pDstBuf[0] = (unsigned char *)pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YVirAddr;
- pDstBuf[1] = (unsigned char *)pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CVirAddr;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "pVideoEnc->MFCEncInputBuffer[%d].YVirAddr : 0x%x", pVideoEnc->indexInputBuffer, pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YVirAddr);
- SEC_OSAL_Log(SEC_LOG_TRACE, "pVideoEnc->MFCEncInputBuffer[%d].CVirAddr : 0x%x", pVideoEnc->indexInputBuffer, pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].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)));
-
- if (pSECPort->bStoreMetaData == OMX_FALSE) {
- pSrcBuf[0] = checkInputStream;
- pSrcBuf[1] = checkInputStream + (width * height);
- pSrcBuf[2] = checkInputStream + (((width * height) * 5) / 4);
-
- switch (pSECPort->portDefinition.format.video.eColorFormat) {
- case OMX_COLOR_FormatYUV420Planar:
- /* YUV420Planar case it needed changed interleave UV plane (MFC spec.)*/
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420Planar);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_SEC_COLOR_FormatNV12Tiled:
- case OMX_SEC_COLOR_FormatNV21Linear:
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
- break;
- default:
- break;
- }
- }
-#ifdef USE_METADATABUFFERTYPE
- else {
- if (pSECPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatAndroidOpaque) {
- OMX_PTR pOutBuffer;
- csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_Format32bitARGB8888);
- csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
-
- SEC_OSAL_GetInfoFromMetaData(inputData, ppBuf);
- SEC_OSAL_LockANBHandle((OMX_U32)ppBuf[0], width, height, OMX_COLOR_FormatAndroidOpaque, &pOutBuffer);
- pSrcBuf[0] = (unsigned char *)pOutBuffer;
- pSrcBuf[1] = NULL;
- pSrcBuf[2] = NULL;
- }
- }
-#endif
-
- csc_set_src_format(
- pVideoEnc->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_dst_format(
- pVideoEnc->csc_handle, /* handle */
- width, /* width */
- height, /* height */
- 0, /* crop_left */
- 0, /* crop_right */
- width, /* crop_width */
- height, /* crop_height */
- csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
- csc_set_src_buffer(
- pVideoEnc->csc_handle, /* handle */
- pSrcBuf[0], /* y addr */
- pSrcBuf[1], /* u addr or uv addr */
- pSrcBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_set_dst_buffer(
- pVideoEnc->csc_handle, /* handle */
- pDstBuf[0], /* y addr */
- pDstBuf[1], /* u addr or uv addr */
- pDstBuf[2], /* v addr or none */
- 0); /* ion fd */
- csc_convert(pVideoEnc->csc_handle);
-
-#ifdef USE_METADATABUFFERTYPE
- if (pSECPort->bStoreMetaData == OMX_TRUE) {
- SEC_OSAL_UnlockANBHandle((OMX_U32)ppBuf[0]);
- }
-#endif
- }
- }
-
- inputUseBuffer->dataLen -= copySize; /* ???????????? do not need ?????????????? */
- 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");
-
- ret = OMX_FALSE;
-
- /* reset outputData */
- SEC_DataReset(pOMXComponent, OUTPUT_PORT_INDEX);
- }
- } 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_VIDEOENC_COMPONENT *pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- 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_SignalWait(pSECComponent->pauseEvent, DEF_MAX_WAIT_TIME);
- SEC_OSAL_SignalReset(pSECComponent->pauseEvent);
- }
-
- 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_ErrorInvalidState;
- 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_FormatYUV420Planar;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_1:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12TPhysicalAddress;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_2:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12LPhysicalAddress;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_3:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_4:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_5:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12LVirtualAddress;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_6:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_SEC_COLOR_FormatNV21LPhysicalAddress;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_7:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_SEC_COLOR_FormatNV21Linear;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- case supportFormat_8:
- portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
- portFormat->eColorFormat = OMX_COLOR_FormatAndroidOpaque;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- break;
- }
- } else if (portIndex == OUTPUT_PORT_INDEX) {
- supportFormatNum = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
- if (index > supportFormatNum) {
- ret = OMX_ErrorNoMore;
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- portDefinition = &pSECPort->portDefinition;
-
- portFormat->eCompressionFormat = portDefinition->format.video.eCompressionFormat;
- portFormat->eColorFormat = portDefinition->format.video.eColorFormat;
- portFormat->xFramerate = portDefinition->format.video.xFramerate;
- }
- ret = OMX_ErrorNone;
- }
- break;
- case OMX_IndexParamVideoBitrate:
- {
- OMX_VIDEO_PARAM_BITRATETYPE *videoRateControl = (OMX_VIDEO_PARAM_BITRATETYPE *)ComponentParameterStructure;
- OMX_U32 portIndex = videoRateControl->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pSECPort = &pSECComponent->pSECPort[portIndex];
- portDefinition = &pSECPort->portDefinition;
-
- videoRateControl->eControlRate = pVideoEnc->eControlRate[portIndex];
- videoRateControl->nTargetBitrate = portDefinition->format.video.nBitrate;
- }
- ret = OMX_ErrorNone;
- }
- break;
- case OMX_IndexParamVideoQuantization:
- {
- OMX_VIDEO_PARAM_QUANTIZATIONTYPE *videoQuantizationControl = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)ComponentParameterStructure;
- OMX_U32 portIndex = videoQuantizationControl->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pSECPort = &pSECComponent->pSECPort[portIndex];
- portDefinition = &pSECPort->portDefinition;
-
- videoQuantizationControl->nQpI = pVideoEnc->quantization.nQpI;
- videoQuantizationControl->nQpP = pVideoEnc->quantization.nQpP;
- videoQuantizationControl->nQpB = pVideoEnc->quantization.nQpB;
- }
- 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_STOREMETADATA
- if ((portIndex == 0) &&
- (pSECPort->bStoreMetaData == OMX_TRUE) &&
- (pSECPort->portDefinition.format.video.eColorFormat != OMX_SEC_COLOR_FormatNV12LVirtualAddress)) {
- 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_ErrorInvalidState;
- 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;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pSECPort = &pSECComponent->pSECPort[portIndex];
- portDefinition = &pSECPort->portDefinition;
-
- pVideoEnc->eControlRate[portIndex] = videoRateControl->eControlRate;
- portDefinition->format.video.nBitrate = videoRateControl->nTargetBitrate;
- }
- ret = OMX_ErrorNone;
- }
- break;
- case OMX_IndexParamVideoQuantization:
- {
- OMX_VIDEO_PARAM_QUANTIZATIONTYPE *videoQuantizationControl = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)ComponentParameterStructure;
- OMX_U32 portIndex = videoQuantizationControl->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pSECPort = &pSECComponent->pSECPort[portIndex];
- portDefinition = &pSECPort->portDefinition;
-
- pVideoEnc->quantization.nQpI = videoQuantizationControl->nQpI;
- pVideoEnc->quantization.nQpP = videoQuantizationControl->nQpP;
- pVideoEnc->quantization.nQpB = videoQuantizationControl->nQpB;
- }
- ret = OMX_ErrorNone;
- }
- break;
- case OMX_IndexParamPortDefinition:
- {
- OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
- 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);
- if (portIndex == INPUT_PORT_INDEX) {
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- SEC_UpdateFrameSize(pOMXComponent);
- SEC_OSAL_Log(SEC_LOG_TRACE, "pSECOutputPort->portDefinition.nBufferSize: %d",
- pSECOutputPort->portDefinition.nBufferSize);
- }
- ret = OMX_ErrorNone;
- }
- break;
-#ifdef USE_STOREMETADATA
- case OMX_IndexParamStoreMetaDataBuffer:
- {
- ret = SEC_OSAL_SetANBParameter(hComponent, nIndex, ComponentParameterStructure);
- }
- break;
-#endif
- default:
- {
- ret = SEC_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
- }
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_VideoEncodeGetConfig(
- 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) {
- case OMX_IndexConfigVideoBitrate:
- {
- OMX_VIDEO_CONFIG_BITRATETYPE *pEncodeBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
- OMX_U32 portIndex = pEncodeBitrate->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pSECPort = &pSECComponent->pSECPort[portIndex];
- pEncodeBitrate->nEncodeBitrate = pSECPort->portDefinition.format.video.nBitrate;
- }
- }
- break;
- case OMX_IndexConfigVideoFramerate:
- {
- OMX_CONFIG_FRAMERATETYPE *pFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
- OMX_U32 portIndex = pFramerate->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pSECPort = &pSECComponent->pSECPort[portIndex];
- pFramerate->xEncodeFramerate = pSECPort->portDefinition.format.video.xFramerate;
- }
- }
- break;
- default:
- ret = SEC_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_VideoEncodeSetConfig(
- 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) {
- case OMX_IndexConfigVideoBitrate:
- {
- OMX_VIDEO_CONFIG_BITRATETYPE *pEncodeBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
- OMX_U32 portIndex = pEncodeBitrate->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pSECPort = &pSECComponent->pSECPort[portIndex];
- pSECPort->portDefinition.format.video.nBitrate = pEncodeBitrate->nEncodeBitrate;
- }
- }
- break;
- case OMX_IndexConfigVideoFramerate:
- {
- OMX_CONFIG_FRAMERATETYPE *pFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
- OMX_U32 portIndex = pFramerate->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pSECPort = &pSECComponent->pSECPort[portIndex];
- pSECPort->portDefinition.format.video.xFramerate = pFramerate->xEncodeFramerate;
- }
- }
- break;
- case OMX_IndexConfigVideoIntraVOPRefresh:
- {
- OMX_CONFIG_INTRAREFRESHVOPTYPE *pIntraRefreshVOP = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pComponentConfigStructure;
- SEC_OMX_VIDEOENC_COMPONENT *pVEncBase = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- OMX_U32 portIndex = pIntraRefreshVOP->nPortIndex;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pVEncBase->IntraRefreshVOP = pIntraRefreshVOP->IntraRefreshVOP;
- }
- }
- break;
- default:
- ret = SEC_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OMX_VideoEncodeGetExtensionIndex(
- 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_STOREMETADATA
- if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
- *pIndexType = (OMX_INDEXTYPE) OMX_IndexParamStoreMetaDataBuffer;
- } else {
- ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
- }
-#else
- ret = SEC_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
-#endif
-
-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;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = 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;
-
- pVideoEnc = SEC_OSAL_Malloc(sizeof(SEC_OMX_VIDEOENC_COMPONENT));
- if (pVideoEnc == NULL) {
- SEC_OMX_BaseComponent_Destructor(pOMXComponent);
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
- goto EXIT;
- }
-
- SEC_OSAL_Memset(pVideoEnc, 0, sizeof(SEC_OMX_VIDEOENC_COMPONENT));
- pSECComponent->hComponentHandle = (OMX_HANDLETYPE)pVideoEnc;
-
- pSECComponent->bSaveFlagEOS = OMX_FALSE;
-
- pVideoEnc->configChange = OMX_FALSE;
- pVideoEnc->quantization.nQpI = 20;
- pVideoEnc->quantization.nQpP = 20;
- pVideoEnc->quantization.nQpB = 20;
-
- /* 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;
- pVideoEnc->eControlRate[INPUT_PORT_INDEX] = OMX_Video_ControlRateDisable;
-
- pSECPort->bStoreMetaData = OMX_FALSE;
-
- /* 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;
- pVideoEnc->eControlRate[OUTPUT_PORT_INDEX] = OMX_Video_ControlRateDisable;
-
- 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;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = 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;
-
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OSAL_Free(pVideoEnc);
- pSECComponent->hComponentHandle = pVideoEnc = NULL;
-
- 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/exynos4/multimedia/openmax/sec_omx/component/video/enc/SEC_OMX_Venc.h b/exynos4/multimedia/openmax/sec_omx/component/video/enc/SEC_OMX_Venc.h
deleted file mode 100644
index 6225fd3..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/SEC_OMX_Venc.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- *
- * 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.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"
-#include "SEC_OMX_Basecomponent.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
-
-#define INPUT_PORT_SUPPORTFORMAT_NUM_MAX 9
-#define OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX 1
-
-#ifdef USE_STOREMETADATA
-// 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;
-
-typedef struct _SEC_OMX_VIDEOENC_COMPONENT
-{
- OMX_HANDLETYPE hCodecHandle;
- SEC_MFC_NBENC_THREAD NBEncThread;
-
- OMX_BOOL configChange;
- OMX_BOOL IntraRefreshVOP;
- OMX_VIDEO_CONTROLRATETYPE eControlRate[ALL_PORT_NUM];
- OMX_VIDEO_PARAM_QUANTIZATIONTYPE quantization;
- OMX_BOOL bFirstFrame;
- MFC_ENC_INPUT_BUFFER MFCEncInputBuffer[MFC_INPUT_BUFFER_NUM_MAX];
- OMX_U32 indexInputBuffer;
-
- /* CSC handle */
- OMX_PTR csc_handle;
-} SEC_OMX_VIDEOENC_COMPONENT;
-
-#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_VideoEncodeGetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure);
-OMX_ERRORTYPE SEC_OMX_VideoEncodeSetConfig(
- OMX_HANDLETYPE hComponent,
- OMX_INDEXTYPE nIndex,
- OMX_PTR pComponentConfigStructure);
-OMX_ERRORTYPE SEC_OMX_VideoEncodeGetExtensionIndex(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_STRING cParameterName,
- OMX_OUT OMX_INDEXTYPE *pIndexType);
-OMX_ERRORTYPE SEC_OMX_VideoEncodeComponentInit(OMX_IN OMX_HANDLETYPE hComponent);
-OMX_ERRORTYPE SEC_OMX_VideoEncodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent);
-OMX_BOOL SEC_Check_BufferProcess_State(SEC_OMX_BASECOMPONENT *pSECComponent);
-inline void SEC_UpdateFrameSize(OMX_COMPONENTTYPE *pOMXComponent);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/Android.mk
deleted file mode 100644
index d8c7b06..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/Android.mk
+++ /dev/null
@@ -1,39 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_H264enc.c \
- library_register.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libOMX.SEC.AVC.Encoder
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/omx
-
-LOCAL_CFLAGS :=
-
-ifeq ($(BOARD_NONBLOCK_MODE_PROCESS), true)
-LOCAL_CFLAGS += -DNONBLOCK_MODE_PROCESS
-endif
-
-ifeq ($(BOARD_USE_METADATABUFFERTYPE), true)
-LOCAL_CFLAGS += -DUSE_METADATABUFFERTYPE
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libSEC_OMX_Venc libsecosal libsecbasecomponent \
- libswconverter libsecmfcapi
-LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui \
- libSEC_OMX_Resourcemanager libcsc
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/enc \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO)
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/SEC_OMX_H264enc.c b/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/SEC_OMX_H264enc.c
deleted file mode 100644
index df4241b..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/SEC_OMX_H264enc.c
+++ /dev/null
@@ -1,1605 +0,0 @@
-/*
- *
- * 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.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 "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Thread.h"
-#include "SEC_OSAL_Android.h"
-#include "library_register.h"
-#include "SEC_OMX_H264enc.h"
-#include "SsbSipMfcApi.h"
-#include "csc.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)
-{
- OMX_U32 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);
-#ifdef USE_SLICE_OUTPUT_MODE
- SEC_OSAL_Log(SEC_LOG_TRACE, "OutputMode : %d\n", h264Arg->OutputMode);
-#endif
- 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);
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameMap : %d\n", h264Arg->FrameMap);
-}
-
-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_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- SEC_H264ENC_HANDLE *pH264Enc = NULL;
-
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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;
-#ifdef USE_SLICE_OUTPUT_MODE
- pH264Arg->OutputMode = FRAME;
-#endif
- pH264Arg->RandomIntraMBRefresh = 0;
- pH264Arg->Bitrate = pSECOutputPort->portDefinition.format.video.nBitrate;
- pH264Arg->QSCodeMax = 51;
- pH264Arg->QSCodeMin = 10;
- 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->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 = 1; // 0: CAVLC, 1: CABAC
- pH264Arg->PictureInterlace = 0;
- pH264Arg->Transform8x8Mode = 1; // 0: 4x4, 1: allow 8x8
- pH264Arg->DarkDisable = 1;
- pH264Arg->SmoothDisable = 1;
- pH264Arg->StaticDisable = 1;
- pH264Arg->ActivityDisable = 1;
-
- pH264Arg->FrameQp = pVideoEnc->quantization.nQpI;
- pH264Arg->FrameQp_P = pVideoEnc->quantization.nQpP;
- pH264Arg->FrameQp_B = pVideoEnc->quantization.nQpB;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]);
- switch (pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]) {
- 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;
- }
-
- switch ((SEC_OMX_COLOR_FORMATTYPE)pSECInputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_COLOR_FormatYUV420Planar:
-#ifdef USE_METADATABUFFERTYPE
- case OMX_COLOR_FormatAndroidOpaque:
-#endif
- pH264Arg->FrameMap = NV12_LINEAR;
- break;
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pH264Arg->FrameMap = NV12_TILE;
- break;
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV21Linear:
- pH264Arg->FrameMap = NV21_LINEAR;
- break;
- default:
- pH264Arg->FrameMap = NV12_TILE;
- break;
- }
-
- H264PrintParams(pH264Arg);
-}
-
-void Change_H264Enc_Param(SSBSIP_MFC_ENC_H264_PARAM *pH264Arg, SEC_OMX_BASECOMPONENT *pSECComponent)
-{
- SEC_OMX_BASEPORT *pSECInputPort = NULL;
- SEC_OMX_BASEPORT *pSECOutputPort = NULL;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- SEC_H264ENC_HANDLE *pH264Enc = NULL;
-
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
-
- if (pVideoEnc->IntraRefreshVOP == OMX_TRUE) {
- int set_conf_IntraRefreshVOP = 1;
- SsbSipMfcEncSetConfig(pH264Enc->hMFCH264Handle.hMFCHandle,
- MFC_ENC_SETCONF_FRAME_TYPE,
- &set_conf_IntraRefreshVOP);
- pVideoEnc->IntraRefreshVOP = OMX_FALSE;
- }
- if (pH264Arg->IDRPeriod != (int)pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1) {
- int set_conf_IDRPeriod = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1;
- SsbSipMfcEncSetConfig(pH264Enc->hMFCH264Handle.hMFCHandle,
- MFC_ENC_SETCONF_I_PERIOD,
- &set_conf_IDRPeriod);
- }
- if (pH264Arg->Bitrate != (int)pSECOutputPort->portDefinition.format.video.nBitrate) {
- int set_conf_bitrate = pSECOutputPort->portDefinition.format.video.nBitrate;
- SsbSipMfcEncSetConfig(pH264Enc->hMFCH264Handle.hMFCHandle,
- MFC_ENC_SETCONF_CHANGE_BIT_RATE,
- &set_conf_bitrate);
- }
- if (pH264Arg->FrameRate != (int)((pSECOutputPort->portDefinition.format.video.xFramerate) >> 16)) {
- int set_conf_framerate = (pSECInputPort->portDefinition.format.video.xFramerate) >> 16;
- SsbSipMfcEncSetConfig(pH264Enc->hMFCH264Handle.hMFCHandle,
- MFC_ENC_SETCONF_CHANGE_FRAME_RATE,
- &set_conf_framerate);
- }
-
- Set_H264Enc_Param(pH264Arg, pSECComponent);
- 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_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nParamIndex) {
- case OMX_IndexParamVideoAvc:
- {
- OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
- OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
- SEC_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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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_ErrorInvalidState;
- goto EXIT;
- }
-
- switch (nIndex) {
- case OMX_IndexParamVideoAvc:
- {
- OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
- OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
- SEC_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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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;
- SEC_H264ENC_HANDLE *pH264Enc = 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;
- }
- pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- switch (nIndex) {
- case OMX_IndexConfigVideoAVCIntraPeriod:
- {
- OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pAVCIntraPeriod = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD *)pComponentConfigStructure;
- OMX_U32 portIndex = pAVCIntraPeriod->nPortIndex;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- pAVCIntraPeriod->nIDRPeriod = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1;
- pAVCIntraPeriod->nPFrames = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames;
- }
- }
- break;
- default:
- ret = SEC_OMX_VideoEncodeGetConfig(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;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- SEC_H264ENC_HANDLE *pH264Enc = 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;
- }
-
- pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- switch (nIndex) {
- case OMX_IndexConfigVideoIntraPeriod:
- {
- SEC_OMX_VIDEOENC_COMPONENT *pVEncBase = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- OMX_U32 nPFrames = (*((OMX_U32 *)pComponentConfigStructure)) - 1;
-
- pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
-
- ret = OMX_ErrorNone;
- }
- break;
- case OMX_IndexConfigVideoAVCIntraPeriod:
- {
- OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pAVCIntraPeriod = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD *)pComponentConfigStructure;
- OMX_U32 portIndex = pAVCIntraPeriod->nPortIndex;
-
- if ((portIndex != OUTPUT_PORT_INDEX)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- } else {
- if (pAVCIntraPeriod->nIDRPeriod == (pAVCIntraPeriod->nPFrames + 1))
- pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames = pAVCIntraPeriod->nPFrames;
- else {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- }
- }
- break;
- default:
- ret = SEC_OMX_VideoEncodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- if (ret == OMX_ErrorNone)
- pVideoEnc->configChange = OMX_TRUE;
-
- 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;
- }
- if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_CONFIG_VIDEO_INTRAPERIOD) == 0) {
- *pIndexType = OMX_IndexConfigVideoIntraPeriod;
- ret = OMX_ErrorNone;
- } else {
- ret = SEC_OMX_VideoEncodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
- }
-
-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 = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_H264ENC_HANDLE *pH264Enc = (SEC_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- while (pVideoEnc->NBEncThread.bExitEncodeThread == OMX_FALSE) {
- SEC_OSAL_SemaphoreWait(pVideoEnc->NBEncThread.hEncFrameStart);
-
- if (pVideoEnc->NBEncThread.bExitEncodeThread == OMX_FALSE) {
- pH264Enc->hMFCH264Handle.returnCodec = SsbSipMfcEncExe(pH264Enc->hMFCH264Handle.hMFCHandle);
- SEC_OSAL_SemaphorePost(pVideoEnc->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_VIDEOENC_COMPONENT *pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_H264ENC_HANDLE *pH264Enc = NULL;
- OMX_PTR hMFCHandle = NULL;
- OMX_S32 returnCodec = 0;
- CSC_METHOD csc_method = CSC_METHOD_SW;
-
- FunctionIn();
-
- pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 */
- switch (pSECInputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress:
- hMFCHandle = (OMX_PTR)SsbSipMfcEncOpen();
- break;
- default: {
- SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
- hMFCHandle = (OMX_PTR)SsbSipMfcEncOpenExt(&buf_type);
- break;
- }
- }
-
- if (hMFCHandle == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pH264Enc->hMFCH264Handle.hMFCHandle = hMFCHandle;
-
- Set_H264Enc_Param(&(pH264Enc->hMFCH264Handle.mfcVideoAvc), pSECComponent);
-
- returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pH264Enc->hMFCH264Handle.mfcVideoAvc));
- if (returnCodec != MFC_RET_OK) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
-
- /* Allocate encoder's input buffer */
- returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pH264Enc->hMFCH264Handle.inputInfo));
- if (returnCodec != MFC_RET_OK) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoEnc->MFCEncInputBuffer[0].YPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.YPhyAddr;
- pVideoEnc->MFCEncInputBuffer[0].CPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.CPhyAddr;
- pVideoEnc->MFCEncInputBuffer[0].YVirAddr = pH264Enc->hMFCH264Handle.inputInfo.YVirAddr;
- pVideoEnc->MFCEncInputBuffer[0].CVirAddr = pH264Enc->hMFCH264Handle.inputInfo.CVirAddr;
- pVideoEnc->MFCEncInputBuffer[0].YBufferSize = pH264Enc->hMFCH264Handle.inputInfo.YSize;
- pVideoEnc->MFCEncInputBuffer[0].CBufferSize = pH264Enc->hMFCH264Handle.inputInfo.CSize;
- pVideoEnc->MFCEncInputBuffer[0].YDataSize = 0;
- pVideoEnc->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;
- }
- pVideoEnc->MFCEncInputBuffer[1].YPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.YPhyAddr;
- pVideoEnc->MFCEncInputBuffer[1].CPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.CPhyAddr;
- pVideoEnc->MFCEncInputBuffer[1].YVirAddr = pH264Enc->hMFCH264Handle.inputInfo.YVirAddr;
- pVideoEnc->MFCEncInputBuffer[1].CVirAddr = pH264Enc->hMFCH264Handle.inputInfo.CVirAddr;
- pVideoEnc->MFCEncInputBuffer[1].YBufferSize = pH264Enc->hMFCH264Handle.inputInfo.YSize;
- pVideoEnc->MFCEncInputBuffer[1].CBufferSize = pH264Enc->hMFCH264Handle.inputInfo.CSize;
- pVideoEnc->MFCEncInputBuffer[1].YDataSize = 0;
- pVideoEnc->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);
-
- pVideoEnc->indexInputBuffer = 0;
-
- pVideoEnc->bFirstFrame = OMX_TRUE;
-
-#ifdef NONBLOCK_MODE_PROCESS
- pVideoEnc->NBEncThread.bExitEncodeThread = OMX_FALSE;
- pVideoEnc->NBEncThread.bEncoderRun = OMX_FALSE;
- SEC_OSAL_SemaphoreCreate(&(pVideoEnc->NBEncThread.hEncFrameStart));
- SEC_OSAL_SemaphoreCreate(&(pVideoEnc->NBEncThread.hEncFrameEnd));
- if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pVideoEnc->NBEncThread.hNBEncodeThread,
- SEC_MFC_EncodeThread,
- pOMXComponent)) {
- pH264Enc->hMFCH264Handle.returnCodec = MFC_RET_OK;
- }
-#endif
- 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;
-
- pVideoEnc->csc_handle = csc_init(&csc_method);
-
-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_OMX_VIDEOENC_COMPONENT *pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- SEC_H264ENC_HANDLE *pH264Enc = NULL;
- OMX_PTR hMFCHandle = NULL;
-
- FunctionIn();
-
- pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-#ifdef NONBLOCK_MODE_PROCESS
- if (pVideoEnc->NBEncThread.hNBEncodeThread != NULL) {
- pVideoEnc->NBEncThread.bExitEncodeThread = OMX_TRUE;
- SEC_OSAL_SemaphorePost(pVideoEnc->NBEncThread.hEncFrameStart);
- SEC_OSAL_ThreadTerminate(pVideoEnc->NBEncThread.hNBEncodeThread);
- pVideoEnc->NBEncThread.hNBEncodeThread = NULL;
- }
-
- if(pVideoEnc->NBEncThread.hEncFrameEnd != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoEnc->NBEncThread.hEncFrameEnd);
- pVideoEnc->NBEncThread.hEncFrameEnd = NULL;
- }
-
- if(pVideoEnc->NBEncThread.hEncFrameStart != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoEnc->NBEncThread.hEncFrameStart);
- pVideoEnc->NBEncThread.hEncFrameStart = NULL;
- }
-#endif
-
- hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
- if (hMFCHandle != NULL) {
- SsbSipMfcEncClose(hMFCHandle);
- hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle = NULL;
- }
-
- if (pVideoEnc->csc_handle != NULL) {
- csc_deinit(pVideoEnc->csc_handle);
- pVideoEnc->csc_handle = NULL;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264_Encode_Nonblock(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- SEC_H264ENC_HANDLE *pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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) {
- 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 {
- OMX_U8 *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 = (OMX_U8 *)outputInfo.StrmVirAddr + iSpsSize;
- pH264Enc->hMFCH264Handle.headerData.PPSLen = iPpsSize;
- }
-
- 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 = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YPhyAddr;
- pInputInfo->CPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CPhyAddr;
- pInputInfo->YVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YVirAddr;
- pInputInfo->CVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CVirAddr;
- } else {
- switch (pSECPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress: {
-#ifndef USE_METADATABUFFERTYPE
- /* USE_FIMC_FRAME_BUFFER */
- SEC_OSAL_Memcpy(&addrInfo.pAddrY, pInputData->dataBuffer, sizeof(addrInfo.pAddrY));
- SEC_OSAL_Memcpy(&addrInfo.pAddrC, pInputData->dataBuffer + sizeof(addrInfo.pAddrY), sizeof(addrInfo.pAddrC));
-#else
- OMX_PTR ppBuf[3];
- SEC_OSAL_GetInfoFromMetaData(pInputData, ppBuf);
-
- SEC_OSAL_Memcpy(&addrInfo.pAddrY, ppBuf[0], sizeof(addrInfo.pAddrY));
- SEC_OSAL_Memcpy(&addrInfo.pAddrC, ppBuf[1], sizeof(addrInfo.pAddrC));
-#endif
- pInputInfo->YPhyAddr = addrInfo.pAddrY;
- pInputInfo->CPhyAddr = addrInfo.pAddrC;
- break;
- }
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- addrInfo.pAddrY = *((void **)pInputData->dataBuffer);
- addrInfo.pAddrC = (void *)((char *)addrInfo.pAddrY + pInputInfo->YSize);
-
- pInputInfo->YPhyAddr = addrInfo.pAddrY;
- pInputInfo->CPhyAddr = addrInfo.pAddrC;
- break;
- default:
- pInputInfo->YPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YPhyAddr;
- pInputInfo->CPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CPhyAddr;
- pInputInfo->YVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YVirAddr;
- pInputInfo->CVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CVirAddr;
- break;
- }
- }
-
- pSECComponent->timeStamp[pH264Enc->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pH264Enc->hMFCH264Handle.indexTimestamp] = pInputData->nFlags;
-
- if ((pH264Enc->hMFCH264Handle.returnCodec == MFC_RET_OK) &&
- (pVideoEnc->bFirstFrame == OMX_FALSE)) {
- OMX_S32 indexTimestamp = 0;
-
- /* wait for mfc encode done */
- if (pVideoEnc->NBEncThread.bEncoderRun != OMX_FALSE) {
- SEC_OSAL_SemaphoreWait(pVideoEnc->NBEncThread.hEncFrameEnd);
- pVideoEnc->NBEncThread.bEncoderRun = OMX_FALSE;
- }
-
- SEC_OSAL_SleepMillisec(0);
- 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;
- goto EXIT;
- }
-
- 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 {
- pVideoEnc->indexInputBuffer++;
- pVideoEnc->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- }
-
- if (pVideoEnc->configChange == OMX_TRUE) {
- Change_H264Enc_Param(&(pH264Enc->hMFCH264Handle.mfcVideoAvc), pSECComponent);
- pVideoEnc->configChange = OMX_FALSE;
- }
-
- SsbSipMfcEncSetConfig(pH264Enc->hMFCH264Handle.hMFCHandle, MFC_ENC_SETCONF_FRAME_TAG, &(pH264Enc->hMFCH264Handle.indexTimestamp));
-
- /* mfc encode start */
- SEC_OSAL_SemaphorePost(pVideoEnc->NBEncThread.hEncFrameStart);
- pVideoEnc->NBEncThread.bEncoderRun = OMX_TRUE;
- pH264Enc->hMFCH264Handle.indexTimestamp++;
- pH264Enc->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
- pVideoEnc->bFirstFrame = OMX_FALSE;
- SEC_OSAL_SleepMillisec(0);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_H264_Encode_Block(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- SEC_H264ENC_HANDLE *pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- SSBSIP_MFC_ENC_INPUT_INFO *pInputInfo = &pH264Enc->hMFCH264Handle.inputInfo;
- SSBSIP_MFC_ENC_OUTPUT_INFO outputInfo;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- MFC_ENC_ADDR_INFO addrInfo;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- OMX_S32 returnCodec = 0;
-
- FunctionIn();
-
- if (pH264Enc->hMFCH264Handle.bConfiguredMFC == OMX_FALSE) {
- returnCodec = SsbSipMfcEncGetOutBuf(pH264Enc->hMFCH264Handle.hMFCHandle, &outputInfo);
- if (returnCodec != MFC_RET_OK)
- {
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s - SsbSipMfcEncGetOutBuf Failed\n", __func__);
- ret = OMX_ErrorUndefined;
- goto EXIT;
- } else {
- OMX_U8 *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 = (OMX_U8 *)outputInfo.StrmVirAddr + iSpsSize;
- pH264Enc->hMFCH264Handle.headerData.PPSLen = iPpsSize;
- }
-
- 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];
- switch (pSECPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress: {
-#ifndef USE_METADATABUFFERTYPE
- /* USE_FIMC_FRAME_BUFFER */
- SEC_OSAL_Memcpy(&addrInfo.pAddrY, pInputData->dataBuffer, sizeof(addrInfo.pAddrY));
- SEC_OSAL_Memcpy(&addrInfo.pAddrC, pInputData->dataBuffer + sizeof(addrInfo.pAddrY), sizeof(addrInfo.pAddrC));
-#else
- OMX_PTR ppBuf[3];
- SEC_OSAL_GetInfoFromMetaData(pInputData, ppBuf);
-
- SEC_OSAL_Memcpy(&addrInfo.pAddrY, ppBuf[0], sizeof(addrInfo.pAddrY));
- SEC_OSAL_Memcpy(&addrInfo.pAddrC, ppBuf[1], sizeof(addrInfo.pAddrC));
-#endif
- pInputInfo->YPhyAddr = addrInfo.pAddrY;
- pInputInfo->CPhyAddr = addrInfo.pAddrC;
- break;
- }
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- addrInfo.pAddrY = *((void **)pInputData->dataBuffer);
- addrInfo.pAddrC = (void *)((char *)addrInfo.pAddrY + pInputInfo->YSize);
-
- pInputInfo->YPhyAddr = addrInfo.pAddrY;
- pInputInfo->CPhyAddr = addrInfo.pAddrC;
- break;
- default:
- pInputInfo->YPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YPhyAddr;
- pInputInfo->CPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CPhyAddr;
- pInputInfo->YVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YVirAddr;
- pInputInfo->CVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CVirAddr;
- break;
- }
-
- returnCodec = SsbSipMfcEncSetInBuf(pH264Enc->hMFCH264Handle.hMFCHandle, pInputInfo);
- if (returnCodec != MFC_RET_OK) {
- SEC_OSAL_Log(SEC_LOG_TRACE, "Error : SsbSipMfcEncSetInBuf() \n");
- ret = OMX_ErrorUndefined;
- goto EXIT;
- } else {
- pVideoEnc->indexInputBuffer++;
- pVideoEnc->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- }
-
- if (pVideoEnc->configChange == OMX_TRUE) {
- Change_H264Enc_Param(&(pH264Enc->hMFCH264Handle.mfcVideoAvc), pSECComponent);
- pVideoEnc->configChange = OMX_FALSE;
- }
-
- pSECComponent->timeStamp[pH264Enc->hMFCH264Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pH264Enc->hMFCH264Handle.indexTimestamp] = pInputData->nFlags;
- SsbSipMfcEncSetConfig(pH264Enc->hMFCH264Handle.hMFCHandle, MFC_ENC_SETCONF_FRAME_TAG, &(pH264Enc->hMFCH264Handle.indexTimestamp));
-
- returnCodec = SsbSipMfcEncExe(pH264Enc->hMFCH264Handle.hMFCHandle);
- if (returnCodec == MFC_RET_OK) {
- OMX_S32 indexTimestamp = 0;
-
- pH264Enc->hMFCH264Handle.indexTimestamp++;
- pH264Enc->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
-
- 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 (returnCodec == MFC_RET_OK) {
- /** Fill Output Buffer **/
- pOutputData->dataBuffer = outputInfo.StrmVirAddr;
- pOutputData->allocSize = outputInfo.dataSize;
- pOutputData->dataLen = outputInfo.dataSize;
- pOutputData->usedDataLen = 0;
-
- pOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
- if (outputInfo.frameType == MFC_FRAME_TYPE_I_FRAME)
- pOutputData->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "MFC Encode OK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
-
- ret = OMX_ErrorNone;
- }
- }
-
- if (returnCodec != MFC_RET_OK) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "In %s : SsbSipMfcEncExe OR SsbSipMfcEncGetOutBuf Failed!!!\n", __func__);
- ret = OMX_ErrorUndefined;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Encode */
-OMX_ERRORTYPE SEC_MFC_H264Enc_bufferProcess(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_H264ENC_HANDLE *pH264Enc = (SEC_H264ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
- OMX_BOOL endOfFrame = OMX_FALSE;
- 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;
- }
-
-#ifdef NONBLOCK_MODE_PROCESS
- ret = SEC_MFC_H264_Encode_Nonblock(pOMXComponent, pInputData, pOutputData);
-#else
- ret = SEC_MFC_H264_Encode_Block(pOMXComponent, pInputData, pOutputData);
-#endif
- 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_OMX_VIDEOENC_COMPONENT *pVideoEnc = 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_ENC_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));
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pVideoEnc->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_AVCProfileHigh;
- pH264Enc->AVCComponent[i].eLevel = OMX_VIDEO_AVCLevel4;
-
- pH264Enc->AVCComponent[i].nPFrames = 20;
- }
-
- 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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pH264Enc != NULL) {
- SEC_OSAL_Free(pH264Enc);
- pH264Enc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle = NULL;
- }
-
- ret = SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- ret = OMX_ErrorNone;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/SEC_OMX_H264enc.h b/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/SEC_OMX_H264enc.h
deleted file mode 100644
index cc0a94f..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/SEC_OMX_H264enc.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- *
- * 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.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;
-} 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/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/library_register.c b/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/library_register.c
deleted file mode 100644
index e24e126..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/library_register.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/library_register.h b/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/library_register.h
deleted file mode 100644
index 9511e3c..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/h264/library_register.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/Android.mk b/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/Android.mk
deleted file mode 100644
index 441f5fb..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/Android.mk
+++ /dev/null
@@ -1,39 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OMX_Mpeg4enc.c \
- library_register.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libOMX.SEC.M4V.Encoder
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/omx
-
-LOCAL_CFLAGS :=
-
-ifeq ($(BOARD_NONBLOCK_MODE_PROCESS), true)
-LOCAL_CFLAGS += -DNONBLOCK_MODE_PROCESS
-endif
-
-ifeq ($(BOARD_USE_METADATABUFFERTYPE), true)
-LOCAL_CFLAGS += -DUSE_METADATABUFFERTYPE
-endif
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libSEC_OMX_Venc libsecosal libsecbasecomponent \
- libswconverter libsecmfcapi
-LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils libui \
- libSEC_OMX_Resourcemanager libcsc
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/core \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/enc \
- $(TARGET_OUT_HEADERS)/$(SEC_COPY_HEADERS_TO)
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/SEC_OMX_Mpeg4enc.c b/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/SEC_OMX_Mpeg4enc.c
deleted file mode 100644
index 1fcc90e..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/SEC_OMX_Mpeg4enc.c
+++ /dev/null
@@ -1,1803 +0,0 @@
-/*
- *
- * 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.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 "SEC_OSAL_Semaphore.h"
-#include "SEC_OSAL_Thread.h"
-#include "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Android.h"
-#include "library_register.h"
-#include "SEC_OMX_Mpeg4enc.h"
-#include "SsbSipMfcApi.h"
-#include "csc.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 *pMpeg4Param)
-{
- SEC_OSAL_Log(SEC_LOG_TRACE, "SourceWidth : %d\n", pMpeg4Param->SourceWidth);
- SEC_OSAL_Log(SEC_LOG_TRACE, "SourceHeight : %d\n", pMpeg4Param->SourceHeight);
- SEC_OSAL_Log(SEC_LOG_TRACE, "IDRPeriod : %d\n", pMpeg4Param->IDRPeriod);
- SEC_OSAL_Log(SEC_LOG_TRACE, "SliceMode : %d\n", pMpeg4Param->SliceMode);
-#ifdef USE_SLICE_OUTPUT_MODE
- SEC_OSAL_Log(SEC_LOG_TRACE, "OutputMode : %d\n", pMpeg4Param->OutputMode);
-#endif
- SEC_OSAL_Log(SEC_LOG_TRACE, "RandomIntraMBRefresh : %d\n", pMpeg4Param->RandomIntraMBRefresh);
- SEC_OSAL_Log(SEC_LOG_TRACE, "EnableFRMRateControl : %d\n", pMpeg4Param->EnableFRMRateControl);
- SEC_OSAL_Log(SEC_LOG_TRACE, "Bitrate : %d\n", pMpeg4Param->Bitrate);
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp : %d\n", pMpeg4Param->FrameQp);
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp_P : %d\n", pMpeg4Param->FrameQp_P);
- SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMax : %d\n", pMpeg4Param->QSCodeMax);
- SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMin : %d\n", pMpeg4Param->QSCodeMin);
- SEC_OSAL_Log(SEC_LOG_TRACE, "CBRPeriodRf : %d\n", pMpeg4Param->CBRPeriodRf);
- SEC_OSAL_Log(SEC_LOG_TRACE, "PadControlOn : %d\n", pMpeg4Param->PadControlOn);
- SEC_OSAL_Log(SEC_LOG_TRACE, "LumaPadVal : %d\n", pMpeg4Param->LumaPadVal);
- SEC_OSAL_Log(SEC_LOG_TRACE, "CbPadVal : %d\n", pMpeg4Param->CbPadVal);
- SEC_OSAL_Log(SEC_LOG_TRACE, "CrPadVal : %d\n", pMpeg4Param->CrPadVal);
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameMap : %d\n", pMpeg4Param->FrameMap);
-
- /* MPEG4 specific parameters */
- SEC_OSAL_Log(SEC_LOG_TRACE, "ProfileIDC : %d\n", pMpeg4Param->ProfileIDC);
- SEC_OSAL_Log(SEC_LOG_TRACE, "LevelIDC : %d\n", pMpeg4Param->LevelIDC);
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp_B : %d\n", pMpeg4Param->FrameQp_B);
- SEC_OSAL_Log(SEC_LOG_TRACE, "TimeIncreamentRes : %d\n", pMpeg4Param->TimeIncreamentRes);
- SEC_OSAL_Log(SEC_LOG_TRACE, "VopTimeIncreament : %d\n", pMpeg4Param->VopTimeIncreament);
- SEC_OSAL_Log(SEC_LOG_TRACE, "SliceArgument : %d\n", pMpeg4Param->SliceArgument);
- SEC_OSAL_Log(SEC_LOG_TRACE, "NumberBFrames : %d\n", pMpeg4Param->NumberBFrames);
- SEC_OSAL_Log(SEC_LOG_TRACE, "DisableQpelME : %d\n", pMpeg4Param->DisableQpelME);
-}
-
-void H263PrintParams(SSBSIP_MFC_ENC_H263_PARAM *pH263Param)
-{
- SEC_OSAL_Log(SEC_LOG_TRACE, "SourceWidth : %d\n", pH263Param->SourceWidth);
- SEC_OSAL_Log(SEC_LOG_TRACE, "SourceHeight : %d\n", pH263Param->SourceHeight);
- SEC_OSAL_Log(SEC_LOG_TRACE, "IDRPeriod : %d\n", pH263Param->IDRPeriod);
- SEC_OSAL_Log(SEC_LOG_TRACE, "SliceMode : %d\n", pH263Param->SliceMode);
- SEC_OSAL_Log(SEC_LOG_TRACE, "RandomIntraMBRefresh : %d\n", pH263Param->RandomIntraMBRefresh);
- SEC_OSAL_Log(SEC_LOG_TRACE, "EnableFRMRateControl : %d\n", pH263Param->EnableFRMRateControl);
- SEC_OSAL_Log(SEC_LOG_TRACE, "Bitrate : %d\n", pH263Param->Bitrate);
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp : %d\n", pH263Param->FrameQp);
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameQp_P : %d\n", pH263Param->FrameQp_P);
- SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMax : %d\n", pH263Param->QSCodeMax);
- SEC_OSAL_Log(SEC_LOG_TRACE, "QSCodeMin : %d\n", pH263Param->QSCodeMin);
- SEC_OSAL_Log(SEC_LOG_TRACE, "CBRPeriodRf : %d\n", pH263Param->CBRPeriodRf);
- SEC_OSAL_Log(SEC_LOG_TRACE, "PadControlOn : %d\n", pH263Param->PadControlOn);
- SEC_OSAL_Log(SEC_LOG_TRACE, "LumaPadVal : %d\n", pH263Param->LumaPadVal);
- SEC_OSAL_Log(SEC_LOG_TRACE, "CbPadVal : %d\n", pH263Param->CbPadVal);
- SEC_OSAL_Log(SEC_LOG_TRACE, "CrPadVal : %d\n", pH263Param->CrPadVal);
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameMap : %d\n", pH263Param->FrameMap);
-
- /* H.263 specific parameters */
- SEC_OSAL_Log(SEC_LOG_TRACE, "FrameRate : %d\n", pH263Param->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_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
-
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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;
-#ifdef USE_SLICE_OUTPUT_MODE
- pMpeg4Param->OutputMode = FRAME;
-#endif
- pMpeg4Param->RandomIntraMBRefresh = 0;
- pMpeg4Param->Bitrate = pSECOutputPort->portDefinition.format.video.nBitrate;
- pMpeg4Param->QSCodeMax = 30;
- pMpeg4Param->QSCodeMin = 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->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;
-
- pMpeg4Param->FrameQp = pVideoEnc->quantization.nQpI;
- pMpeg4Param->FrameQp_P = pVideoEnc->quantization.nQpP;
- pMpeg4Param->FrameQp_B = pVideoEnc->quantization.nQpB;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]);
- switch (pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]) {
- case OMX_Video_ControlRateVariable:
- SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
- pMpeg4Param->EnableFRMRateControl = 0; // 0: Disable, 1: Frame level RC
- pMpeg4Param->CBRPeriodRf = 100;
- break;
- case OMX_Video_ControlRateConstant:
- SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode CBR");
- pMpeg4Param->EnableFRMRateControl = 1; // 0: Disable, 1: Frame level RC
- pMpeg4Param->CBRPeriodRf = 10;
- break;
- case OMX_Video_ControlRateDisable:
- default: //Android default
- SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
- pMpeg4Param->EnableFRMRateControl = 0;
- pMpeg4Param->CBRPeriodRf = 100;
- break;
- }
-
- switch ((SEC_OMX_COLOR_FORMATTYPE)pSECInputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_COLOR_FormatYUV420Planar:
-#ifdef METADATABUFFERTYPE
- case OMX_COLOR_FormatAndroidOpaque:
-#endif
- pMpeg4Param->FrameMap = NV12_LINEAR;
- break;
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pMpeg4Param->FrameMap = NV12_TILE;
- break;
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV21Linear:
- pMpeg4Param->FrameMap = NV21_LINEAR;
- break;
- default:
- pMpeg4Param->FrameMap = NV12_TILE;
- break;
- }
-
- Mpeg4PrintParams(pMpeg4Param);
-}
-
-void Change_Mpeg4Enc_Param(SSBSIP_MFC_ENC_MPEG4_PARAM *pMpeg4Param, SEC_OMX_BASECOMPONENT *pSECComponent)
-{
- SEC_OMX_BASEPORT *pSECInputPort = NULL;
- SEC_OMX_BASEPORT *pSECOutputPort = NULL;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
-
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
-
- if (pVideoEnc->IntraRefreshVOP == OMX_TRUE) {
- int set_conf_IntraRefreshVOP = 1;
- SsbSipMfcEncSetConfig(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
- MFC_ENC_SETCONF_FRAME_TYPE,
- &set_conf_IntraRefreshVOP);
- pVideoEnc->IntraRefreshVOP = OMX_FALSE;
- }
-
- if (pMpeg4Param->IDRPeriod != (int)pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1) {
- int set_conf_IDRPeriod = pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1;
- SsbSipMfcEncSetConfig(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
- MFC_ENC_SETCONF_I_PERIOD,
- &set_conf_IDRPeriod);
- }
- if (pMpeg4Param->Bitrate != (int)pSECOutputPort->portDefinition.format.video.nBitrate) {
- int set_conf_bitrate = pSECOutputPort->portDefinition.format.video.nBitrate;
- SsbSipMfcEncSetConfig(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
- MFC_ENC_SETCONF_CHANGE_BIT_RATE,
- &set_conf_bitrate);
- }
- if (pMpeg4Param->TimeIncreamentRes != (int)((pSECOutputPort->portDefinition.format.video.xFramerate) >> 16)) {
- int set_conf_framerate = (pSECInputPort->portDefinition.format.video.xFramerate) >> 16;
- SsbSipMfcEncSetConfig(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
- MFC_ENC_SETCONF_CHANGE_FRAME_RATE,
- &set_conf_framerate);
- }
-
- Set_Mpeg4Enc_Param(pMpeg4Param, pSECComponent);
- 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_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
-
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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->Bitrate = pSECOutputPort->portDefinition.format.video.nBitrate;
- pH263Param->QSCodeMax = 30;
- pH263Param->QSCodeMin = 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;
-
- pH263Param->FrameQp = pVideoEnc->quantization.nQpI;
- pH263Param->FrameQp_P = pVideoEnc->quantization.nQpP;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]);
- switch (pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]) {
- case OMX_Video_ControlRateVariable:
- SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
- pH263Param->EnableFRMRateControl = 0; // 0: Disable, 1: Frame level RC
- pH263Param->CBRPeriodRf = 100;
- break;
- case OMX_Video_ControlRateConstant:
- SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode CBR");
- pH263Param->EnableFRMRateControl = 1; // 0: Disable, 1: Frame level RC
- pH263Param->CBRPeriodRf = 10;
- break;
- case OMX_Video_ControlRateDisable:
- default: //Android default
- SEC_OSAL_Log(SEC_LOG_TRACE, "Video Encode VBR");
- pH263Param->EnableFRMRateControl = 0;
- pH263Param->CBRPeriodRf = 100;
- break;
- }
-
- switch ((SEC_OMX_COLOR_FORMATTYPE)pSECInputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- case OMX_COLOR_FormatYUV420SemiPlanar:
- pH263Param->FrameMap = NV12_LINEAR;
- break;
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12Tiled:
- pH263Param->FrameMap = NV12_TILE;
- break;
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV21Linear:
- pH263Param->FrameMap = NV21_LINEAR;
- break;
- default:
- pH263Param->FrameMap = NV12_TILE;
- break;
- }
-
- H263PrintParams(pH263Param);
-}
-
-void Change_H263Enc_Param(SSBSIP_MFC_ENC_H263_PARAM *pH263Param, SEC_OMX_BASECOMPONENT *pSECComponent)
-{
- SEC_OMX_BASEPORT *pSECInputPort = NULL;
- SEC_OMX_BASEPORT *pSECOutputPort = NULL;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
-
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- pSECOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
-
- if (pVideoEnc->IntraRefreshVOP == OMX_TRUE) {
- int set_conf_IntraRefreshVOP = 1;
- SsbSipMfcEncSetConfig(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
- MFC_ENC_SETCONF_FRAME_TYPE,
- &set_conf_IntraRefreshVOP);
- pVideoEnc->IntraRefreshVOP = OMX_FALSE;
- }
- if (pH263Param->IDRPeriod != (int)pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1) {
- int set_conf_IDRPeriod = pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1;
- SsbSipMfcEncSetConfig(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
- MFC_ENC_SETCONF_I_PERIOD,
- &set_conf_IDRPeriod);
- }
- if (pH263Param->Bitrate != (int)pSECOutputPort->portDefinition.format.video.nBitrate) {
- int set_conf_bitrate = pSECOutputPort->portDefinition.format.video.nBitrate;
- SsbSipMfcEncSetConfig(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
- MFC_ENC_SETCONF_CHANGE_BIT_RATE,
- &set_conf_bitrate);
- }
- if (pH263Param->FrameRate != (int)((pSECOutputPort->portDefinition.format.video.xFramerate) >> 16)) {
- int set_conf_framerate = (pSECInputPort->portDefinition.format.video.xFramerate) >> 16;
- SsbSipMfcEncSetConfig(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
- MFC_ENC_SETCONF_CHANGE_FRAME_RATE,
- &set_conf_framerate);
- }
-
- Set_H263Enc_Param(pH263Param, pSECComponent);
- 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_ErrorInvalidState;
- 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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)(((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)(((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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_ErrorInvalidState;
- 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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)(((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)(((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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_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_VideoEncodeGetConfig(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;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = 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;
- }
-
- pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
-
- switch (nIndex) {
- case OMX_IndexConfigVideoIntraPeriod:
- {
- SEC_OMX_VIDEOENC_COMPONENT *pVEncBase = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_U32 nPFrames = (*((OMX_U32 *)pComponentConfigStructure)) - 1;
-
- if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
- pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
- else
- pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
-
- ret = OMX_ErrorNone;
- }
- break;
- default:
- ret = SEC_OMX_VideoEncodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
- break;
- }
-
-EXIT:
- if (ret == OMX_ErrorNone)
- pVideoEnc->configChange = OMX_TRUE;
-
- 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;
- }
- if (SEC_OSAL_Strcmp(cParameterName, SEC_INDEX_CONFIG_VIDEO_INTRAPERIOD) == 0) {
- *pIndexType = OMX_IndexConfigVideoIntraPeriod;
- ret = OMX_ErrorNone;
- } else {
- ret = SEC_OMX_VideoEncodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
- }
-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_ErrorInvalidState;
- goto EXIT;
- }
-
- codecType = ((SEC_MPEG4ENC_HANDLE *)(((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-
- FunctionIn();
-
- if (hComponent == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- while (pVideoEnc->NBEncThread.bExitEncodeThread == OMX_FALSE) {
- SEC_OSAL_SemaphoreWait(pVideoEnc->NBEncThread.hEncFrameStart);
-
- if (pVideoEnc->NBEncThread.bExitEncodeThread == OMX_FALSE) {
- pMpeg4Enc->hMFCMpeg4Handle.returnCodec = SsbSipMfcEncExe(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle);
- SEC_OSAL_SemaphorePost(pVideoEnc->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_VIDEOENC_COMPONENT *pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- SEC_OMX_BASEPORT *pSECInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
- OMX_HANDLETYPE hMFCHandle = NULL;
- OMX_S32 returnCodec = 0;
- CSC_METHOD csc_method = CSC_METHOD_SW;
-
- FunctionIn();
-
- pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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 */
- switch (pSECInputPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress:
- hMFCHandle = (OMX_PTR)SsbSipMfcEncOpen();
- break;
- default: {
- SSBIP_MFC_BUFFER_TYPE buf_type = CACHE;
- hMFCHandle = (OMX_PTR)SsbSipMfcEncOpenExt(&buf_type);
- break;
- }
- }
-
- if (hMFCHandle == NULL) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = hMFCHandle;
-
- /* set MFC ENC VIDEO PARAM and initialize MFC encoder instance */
- if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4) {
- Set_Mpeg4Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam), pSECComponent);
- returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam));
- } else {
- Set_H263Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam), pSECComponent);
- returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam));
- }
- if (returnCodec != MFC_RET_OK) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
-
- /* Allocate encoder's input buffer */
- returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.inputInfo));
- if (returnCodec != MFC_RET_OK) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoEnc->MFCEncInputBuffer[0].YPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YPhyAddr;
- pVideoEnc->MFCEncInputBuffer[0].CPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CPhyAddr;
- pVideoEnc->MFCEncInputBuffer[0].YVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr;
- pVideoEnc->MFCEncInputBuffer[0].CVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr;
- pVideoEnc->MFCEncInputBuffer[0].YBufferSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YSize;
- pVideoEnc->MFCEncInputBuffer[0].CBufferSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CSize;
- pVideoEnc->MFCEncInputBuffer[0].YDataSize = 0;
- pVideoEnc->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);
-
- returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.inputInfo));
- if (returnCodec != MFC_RET_OK) {
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
- pVideoEnc->MFCEncInputBuffer[1].YPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YPhyAddr;
- pVideoEnc->MFCEncInputBuffer[1].CPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CPhyAddr;
- pVideoEnc->MFCEncInputBuffer[1].YVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr;
- pVideoEnc->MFCEncInputBuffer[1].CVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr;
- pVideoEnc->MFCEncInputBuffer[1].YBufferSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YSize;
- pVideoEnc->MFCEncInputBuffer[1].CBufferSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CSize;
- pVideoEnc->MFCEncInputBuffer[1].YDataSize = 0;
- pVideoEnc->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);
-
- pVideoEnc->indexInputBuffer = 0;
-
- pVideoEnc->bFirstFrame = OMX_TRUE;
-
-#ifdef NONBLOCK_MODE_PROCESS
- pVideoEnc->NBEncThread.bExitEncodeThread = OMX_FALSE;
- pVideoEnc->NBEncThread.bEncoderRun = OMX_FALSE;
- SEC_OSAL_SemaphoreCreate(&(pVideoEnc->NBEncThread.hEncFrameStart));
- SEC_OSAL_SemaphoreCreate(&(pVideoEnc->NBEncThread.hEncFrameEnd));
- if (OMX_ErrorNone == SEC_OSAL_ThreadCreate(&pVideoEnc->NBEncThread.hNBEncodeThread,
- SEC_MFC_EncodeThread,
- pOMXComponent)) {
- pMpeg4Enc->hMFCMpeg4Handle.returnCodec = MFC_RET_OK;
- }
-#endif
- 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;
-
- pVideoEnc->csc_handle = csc_init(&csc_method);
-
-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_OMX_VIDEOENC_COMPONENT *pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
- OMX_HANDLETYPE hMFCHandle = NULL;
-
- FunctionIn();
-
- pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
-#ifdef NONBLOCK_MODE_PROCESS
- if (pVideoEnc->NBEncThread.hNBEncodeThread != NULL) {
- pVideoEnc->NBEncThread.bExitEncodeThread = OMX_TRUE;
- SEC_OSAL_SemaphorePost(pVideoEnc->NBEncThread.hEncFrameStart);
- SEC_OSAL_ThreadTerminate(pVideoEnc->NBEncThread.hNBEncodeThread);
- pVideoEnc->NBEncThread.hNBEncodeThread = NULL;
- }
-
- if(pVideoEnc->NBEncThread.hEncFrameEnd != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoEnc->NBEncThread.hEncFrameEnd);
- pVideoEnc->NBEncThread.hEncFrameEnd = NULL;
- }
-
- if(pVideoEnc->NBEncThread.hEncFrameStart != NULL) {
- SEC_OSAL_SemaphoreTerminate(pVideoEnc->NBEncThread.hEncFrameStart);
- pVideoEnc->NBEncThread.hEncFrameStart = NULL;
- }
-#endif
-
- hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
- if (hMFCHandle != NULL) {
- SsbSipMfcEncClose(hMFCHandle);
- hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = NULL;
- }
-
- if (pVideoEnc->csc_handle != NULL) {
- csc_deinit(pVideoEnc->csc_handle);
- pVideoEnc->csc_handle = NULL;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_Mpeg4_Encode_Nonblock(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->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) {
- 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 = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YPhyAddr;
- pInputInfo->CPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CPhyAddr;
- pInputInfo->YVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YVirAddr;
- pInputInfo->CVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CVirAddr;
- } else {
- switch (pSECPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress: {
-#ifndef USE_METADATABUFFERTYPE
- /* USE_FIMC_FRAME_BUFFER */
- SEC_OSAL_Memcpy(&addrInfo.pAddrY, pInputData->dataBuffer, sizeof(addrInfo.pAddrY));
- SEC_OSAL_Memcpy(&addrInfo.pAddrC, pInputData->dataBuffer + sizeof(addrInfo.pAddrY), sizeof(addrInfo.pAddrC));
-#else
- OMX_PTR ppBuf[3];
- SEC_OSAL_GetInfoFromMetaData(pInputData, ppBuf);
-
- SEC_OSAL_Memcpy(&addrInfo.pAddrY, ppBuf[0], sizeof(addrInfo.pAddrY));
- SEC_OSAL_Memcpy(&addrInfo.pAddrC, ppBuf[1], sizeof(addrInfo.pAddrC));
-#endif
- pInputInfo->YPhyAddr = addrInfo.pAddrY;
- pInputInfo->CPhyAddr = addrInfo.pAddrC;
- break;
- }
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- addrInfo.pAddrY = *((void **)pInputData->dataBuffer);
- addrInfo.pAddrC = (void *)((char *)addrInfo.pAddrY + pInputInfo->YSize);
-
- pInputInfo->YPhyAddr = addrInfo.pAddrY;
- pInputInfo->CPhyAddr = addrInfo.pAddrC;
- break;
- default:
- pInputInfo->YPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YPhyAddr;
- pInputInfo->CPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CPhyAddr;
- pInputInfo->YVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YVirAddr;
- pInputInfo->CVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CVirAddr;
- break;
- }
- }
-
- pSECComponent->timeStamp[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pInputData->nFlags;
-
- if ((pMpeg4Enc->hMFCMpeg4Handle.returnCodec == MFC_RET_OK) &&
- (pVideoEnc->bFirstFrame == OMX_FALSE)) {
- OMX_S32 indexTimestamp = 0;
-
- /* wait for mfc encode done */
- if (pVideoEnc->NBEncThread.bEncoderRun != OMX_FALSE) {
- SEC_OSAL_SemaphoreWait(pVideoEnc->NBEncThread.hEncFrameEnd);
- pVideoEnc->NBEncThread.bEncoderRun = OMX_FALSE;
- }
-
- SEC_OSAL_SleepMillisec(0);
- pMpeg4Enc->hMFCMpeg4Handle.returnCodec = SsbSipMfcEncGetOutBuf(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, &outputInfo);
- if ((SsbSipMfcEncGetConfig(pMpeg4Enc->hMFCMpeg4Handle.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;
-
- 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__, 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, "In %s : SsbSipMfcEncExe Failed!!!\n", __func__);
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
- 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 {
- pVideoEnc->indexInputBuffer++;
- pVideoEnc->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- }
-
- if (pVideoEnc->configChange == OMX_TRUE) {
- if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
- Change_Mpeg4Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam), pSECComponent);
- else
- Change_H263Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam), pSECComponent);
- pVideoEnc->configChange = OMX_FALSE;
- }
-
- SsbSipMfcEncSetConfig(hMFCHandle, MFC_ENC_SETCONF_FRAME_TAG, &(pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp));
-
- /* mfc encode start */
- SEC_OSAL_SemaphorePost(pVideoEnc->NBEncThread.hEncFrameStart);
- pVideoEnc->NBEncThread.bEncoderRun = OMX_TRUE;
- pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp++;
- pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
- pVideoEnc->bFirstFrame = OMX_FALSE;
- SEC_OSAL_SleepMillisec(0);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_MFC_Mpeg4_Encode_Block(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_VIDEOENC_COMPONENT *pVideoEnc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle);
- SEC_MPEG4ENC_HANDLE *pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- OMX_HANDLETYPE hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
- SSBSIP_MFC_ENC_INPUT_INFO *pInputInfo = &(pMpeg4Enc->hMFCMpeg4Handle.inputInfo);
- SSBSIP_MFC_ENC_OUTPUT_INFO outputInfo;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- MFC_ENC_ADDR_INFO addrInfo;
- OMX_U32 oneFrameSize = pInputData->dataLen;
- OMX_S32 returnCodec = 0;
-
- FunctionIn();
-
- if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFC == OMX_FALSE) {
- returnCodec = SsbSipMfcEncGetOutBuf(hMFCHandle, &outputInfo);
- if (returnCodec != MFC_RET_OK)
- {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncGetOutBuf failed, ret:%d", __FUNCTION__, returnCodec);
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
- pOutputData->dataBuffer = outputInfo.StrmVirAddr;
- pOutputData->allocSize = outputInfo.headerSize;
- pOutputData->dataLen = outputInfo.headerSize;
- pOutputData->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];
- switch (pSECPort->portDefinition.format.video.eColorFormat) {
- case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV12LPhysicalAddress:
- case OMX_SEC_COLOR_FormatNV21LPhysicalAddress: {
-#ifndef USE_METADATABUFFERTYPE
- /* USE_FIMC_FRAME_BUFFER */
- SEC_OSAL_Memcpy(&addrInfo.pAddrY, pInputData->dataBuffer, sizeof(addrInfo.pAddrY));
- SEC_OSAL_Memcpy(&addrInfo.pAddrC, pInputData->dataBuffer + sizeof(addrInfo.pAddrY), sizeof(addrInfo.pAddrC));
-#else
- OMX_PTR ppBuf[3];
- SEC_OSAL_GetInfoFromMetaData(pInputData,ppBuf);
-
- SEC_OSAL_Memcpy(&addrInfo.pAddrY, ppBuf[0], sizeof(addrInfo.pAddrY));
- SEC_OSAL_Memcpy(&addrInfo.pAddrC, ppBuf[1], sizeof(addrInfo.pAddrC));
-#endif
- pInputInfo->YPhyAddr = addrInfo.pAddrY;
- pInputInfo->CPhyAddr = addrInfo.pAddrC;
- break;
- }
- case OMX_SEC_COLOR_FormatNV12LVirtualAddress:
- addrInfo.pAddrY = *((void **)pInputData->dataBuffer);
- addrInfo.pAddrC = (void *)((char *)addrInfo.pAddrY + pInputInfo->YSize);
-
- pInputInfo->YPhyAddr = addrInfo.pAddrY;
- pInputInfo->CPhyAddr = addrInfo.pAddrC;
- break;
- default:
- pInputInfo->YPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YPhyAddr;
- pInputInfo->CPhyAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CPhyAddr;
- pInputInfo->YVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].YVirAddr;
- pInputInfo->CVirAddr = pVideoEnc->MFCEncInputBuffer[pVideoEnc->indexInputBuffer].CVirAddr;
- break;
- }
-
- returnCodec = SsbSipMfcEncSetInBuf(hMFCHandle, pInputInfo);
- if (returnCodec != MFC_RET_OK) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncSetInBuf failed, ret:%d", __FUNCTION__, returnCodec);
- ret = OMX_ErrorUndefined;
- goto EXIT;
- } else {
- pVideoEnc->indexInputBuffer++;
- pVideoEnc->indexInputBuffer %= MFC_INPUT_BUFFER_NUM_MAX;
- }
-
- if (pVideoEnc->configChange == OMX_TRUE) {
- if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
- Change_Mpeg4Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam), pSECComponent);
- else
- Change_H263Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam), pSECComponent);
- pVideoEnc->configChange = OMX_FALSE;
- }
-
- pSECComponent->timeStamp[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pInputData->timeStamp;
- pSECComponent->nFlags[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pInputData->nFlags;
- SsbSipMfcEncSetConfig(hMFCHandle, MFC_ENC_SETCONF_FRAME_TAG, &(pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp));
-
- returnCodec = SsbSipMfcEncExe(hMFCHandle);
- if (returnCodec == MFC_RET_OK) {
- OMX_S32 indexTimestamp = 0;
-
- pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp++;
- pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
-
- 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 (returnCodec == MFC_RET_OK) {
- /** Fill Output Buffer **/
- pOutputData->dataBuffer = outputInfo.StrmVirAddr;
- pOutputData->allocSize = outputInfo.dataSize;
- pOutputData->dataLen = outputInfo.dataSize;
- pOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
- if (outputInfo.frameType == MFC_FRAME_TYPE_I_FRAME)
- pOutputData->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
-
- ret = OMX_ErrorNone;
- } else {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncGetOutBuf failed, ret:%d", __FUNCTION__, returnCodec);
- ret = OMX_ErrorUndefined;
- }
- } else {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SsbSipMfcEncExe failed, ret:%d", __FUNCTION__, returnCodec);
- ret = OMX_ErrorUndefined;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-/* MFC Encode */
-OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_bufferProcess(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
- SEC_OMX_BASEPORT *pInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
- SEC_OMX_BASEPORT *pOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
-
- FunctionIn();
-
- if ((!CHECK_PORT_ENABLED(pInputPort)) || (!CHECK_PORT_ENABLED(pOutputPort)) ||
- (!CHECK_PORT_POPULATED(pInputPort)) || (!CHECK_PORT_POPULATED(pOutputPort))) {
- goto EXIT;
- }
- if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
- goto EXIT;
- }
-
-#ifdef NONBLOCK_MODE_PROCESS
- ret = SEC_MFC_Mpeg4_Encode_Nonblock(pOMXComponent, pInputData, pOutputData);
-#else
- ret = SEC_MFC_Mpeg4_Encode_Block(pOMXComponent, pInputData, pOutputData);
-#endif
- 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_OMX_VIDEOENC_COMPONENT *pVideoEnc = 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_ENC_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));
- pVideoEnc = (SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle;
- pVideoEnc->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 *)((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle;
- if (pMpeg4Enc != NULL) {
- SEC_OSAL_Free(pMpeg4Enc);
- pMpeg4Enc = ((SEC_OMX_VIDEOENC_COMPONENT *)pSECComponent->hComponentHandle)->hCodecHandle = NULL;
- }
-
- ret = SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent);
- if (ret != OMX_ErrorNone) {
- goto EXIT;
- }
-
- ret = OMX_ErrorNone;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/SEC_OMX_Mpeg4enc.h b/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/SEC_OMX_Mpeg4enc.h
deleted file mode 100644
index aa32c42..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/SEC_OMX_Mpeg4enc.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- *
- * 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.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;
-} 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/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/library_register.c b/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/library_register.c
deleted file mode 100644
index d43b2d7..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/library_register.c
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/library_register.h b/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/library_register.h
deleted file mode 100644
index 42a168b..0000000
--- a/exynos4/multimedia/openmax/sec_omx/component/video/enc/mpeg4/library_register.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/core/Android.mk b/exynos4/multimedia/openmax/sec_omx/core/Android.mk
deleted file mode 100644
index 8922e4b..0000000
--- a/exynos4/multimedia/openmax/sec_omx/core/Android.mk
+++ /dev/null
@@ -1,26 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := SEC_OMX_Component_Register.c \
- SEC_OMX_Core.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libSEC_OMX_Core
-
-LOCAL_CFLAGS :=
-
-LOCAL_ARM_MODE := arm
-
-LOCAL_STATIC_LIBRARIES := libsecosal libsecbasecomponent
-LOCAL_SHARED_LIBRARIES := libc libdl libcutils libutils \
- libSEC_OMX_Resourcemanager
-
-LOCAL_C_INCLUDES := $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_TOP)/component/common
-
-include $(BUILD_SHARED_LIBRARY)
-
diff --git a/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Component_Register.c b/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Component_Register.c
deleted file mode 100644
index 27a8805..0000000
--- a/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Component_Register.c
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- *
- * 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.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 <dirent.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"
-
-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 *libName;
- size_t len;
- const char *errorMsg;
- DIR *dir;
- struct dirent *d;
-
- int (*SEC_OMX_COMPONENT_Library_Register)(SECRegisterComponentType **secComponents);
- SECRegisterComponentType **secComponentsTemp;
- SEC_OMX_COMPONENT_REGLIST *componentList;
-
- FunctionIn();
-
- dir = opendir(SEC_OMX_INSTALL_PATH);
- if (dir == NULL) {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
- 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 ((d = readdir(dir)) != NULL) {
- OMX_HANDLETYPE soHandle;
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s", d->d_name);
-
- if (SEC_OSAL_Strncmp(d->d_name, "libOMX.SEC.", SEC_OSAL_Strlen("libOMX.SEC.")) == 0) {
- SEC_OSAL_Memset(libName, 0, MAX_OMX_COMPONENT_LIBNAME_SIZE);
- SEC_OSAL_Strcpy(libName, SEC_OMX_INSTALL_PATH);
- SEC_OSAL_Strcat(libName, d->d_name);
- SEC_OSAL_Log(SEC_LOG_ERROR, "Path & 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;
- unsigned int 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);
-
- closedir(dir);
-
- *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((OMX_STRING)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, (OMX_STRING)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) {
- if (NULL != pOMXComponent->ComponentDeInit)
- pOMXComponent->ComponentDeInit(pOMXComponent);
- SEC_OSAL_Free(pOMXComponent);
- SEC_OSAL_dlclose(libHandle);
- 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/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Component_Register.h b/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Component_Register.h
deleted file mode 100644
index 75b8ac5..0000000
--- a/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Component_Register.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Core.c b/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Core.c
deleted file mode 100644
index fa7477b..0000000
--- a/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Core.c
+++ /dev/null
@@ -1,364 +0,0 @@
-/*
- *
- * 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.1.0
- * @history
- * 2010.7.15 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "SEC_OMX_Core.h"
-#include "SEC_OMX_Component_Register.h"
-#include "SEC_OSAL_Memory.h"
-#include "SEC_OSAL_Mutex.h"
-#include "SEC_OSAL_ETC.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 OMX_HANDLETYPE ghLoadComponentListMutex = NULL;
-
-
-OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_Init(void)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
-
- FunctionIn();
-
- if (gInitialized == 0) {
- if (SEC_OMX_Component_Register(&gComponentList, &gComponentNum)) {
- ret = OMX_ErrorInsufficientResources;
- SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_Init : %s", "OMX_ErrorInsufficientResources");
- goto EXIT;
- }
-
- ret = SEC_OMX_ResourceManager_Init();
- if (OMX_ErrorNone != ret) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_Init : SEC_OMX_ResourceManager_Init failed");
- goto EXIT;
- }
-
- ret = SEC_OSAL_MutexCreate(&ghLoadComponentListMutex);
- if (OMX_ErrorNone != ret) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "SEC_OMX_Init : SEC_OSAL_MutexCreate(&ghLoadComponentListMutex) failed");
- goto EXIT;
- }
-
- gInitialized = 1;
- SEC_OSAL_Log(SEC_LOG_TRACE, "SEC_OMX_Init : %s", "OMX_ErrorNone");
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_Deinit(void)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
-
- FunctionIn();
-
- SEC_OSAL_MutexTerminate(ghLoadComponentListMutex);
- ghLoadComponentListMutex = NULL;
-
- SEC_OMX_ResourceManager_Deinit();
-
- if (OMX_ErrorNone != SEC_OMX_Component_Unregister(gComponentList)) {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
- gComponentList = NULL;
- gComponentNum = 0;
- gInitialized = 0;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_ComponentNameEnum(
- OMX_OUT OMX_STRING cComponentName,
- OMX_IN OMX_U32 nNameLength,
- OMX_IN OMX_U32 nIndex)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
-
- FunctionIn();
-
- if (nIndex >= gComponentNum) {
- ret = OMX_ErrorNoMore;
- goto EXIT;
- }
-
- snprintf(cComponentName, nNameLength, "%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;
- unsigned int i = 0;
-
- FunctionIn();
-
- if (gInitialized != 1) {
- ret = OMX_ErrorNotReady;
- goto EXIT;
- }
-
- if ((pHandle == NULL) || (cComponentName == NULL) || (pCallBacks == NULL)) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
- SEC_OSAL_Log(SEC_LOG_TRACE, "ComponentName : %s", cComponentName);
-
- for (i = 0; i < gComponentNum; i++) {
- if (SEC_OSAL_Strcmp(cComponentName, gComponentList[i].component.componentName) == 0) {
- loadComponent = SEC_OSAL_Malloc(sizeof(SEC_OMX_COMPONENT));
- SEC_OSAL_Memset(loadComponent, 0, sizeof(SEC_OMX_COMPONENT));
-
- SEC_OSAL_Strcpy(loadComponent->libName, gComponentList[i].libName);
- SEC_OSAL_Strcpy(loadComponent->componentName, gComponentList[i].component.componentName);
- ret = SEC_OMX_ComponentLoad(loadComponent);
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Free(loadComponent);
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
- goto EXIT;
- }
-
- ret = loadComponent->pOMXComponent->SetCallbacks(loadComponent->pOMXComponent, pCallBacks, pAppData);
- if (ret != OMX_ErrorNone) {
- SEC_OMX_ComponentUnload(loadComponent);
- SEC_OSAL_Free(loadComponent);
- SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
- goto EXIT;
- }
-
- SEC_OSAL_MutexLock(ghLoadComponentListMutex);
- if (gLoadComponentList == NULL) {
- gLoadComponentList = loadComponent;
- } else {
- currentComponent = gLoadComponentList;
- while (currentComponent->nextOMXComp != NULL) {
- currentComponent = currentComponent->nextOMXComp;
- }
- currentComponent->nextOMXComp = loadComponent;
- }
- SEC_OSAL_MutexUnlock(ghLoadComponentListMutex);
-
- *pHandle = loadComponent->pOMXComponent;
- ret = OMX_ErrorNone;
- SEC_OSAL_Log(SEC_LOG_TRACE, "SEC_OMX_GetHandle : %s", "OMX_ErrorNone");
- goto EXIT;
- }
- }
-
- ret = OMX_ErrorComponentNotFound;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_FreeHandle(OMX_IN OMX_HANDLETYPE hComponent)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- SEC_OMX_COMPONENT *currentComponent;
- SEC_OMX_COMPONENT *deleteComponent;
-
- FunctionIn();
-
- if (gInitialized != 1) {
- ret = OMX_ErrorNotReady;
- goto EXIT;
- }
-
- if (!hComponent) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- SEC_OSAL_MutexLock(ghLoadComponentListMutex);
- currentComponent = gLoadComponentList;
- if (gLoadComponentList->pOMXComponent == hComponent) {
- deleteComponent = gLoadComponentList;
- gLoadComponentList = gLoadComponentList->nextOMXComp;
- } else {
- while ((currentComponent != NULL) && (((SEC_OMX_COMPONENT *)(currentComponent->nextOMXComp))->pOMXComponent != hComponent))
- currentComponent = currentComponent->nextOMXComp;
-
- if (((SEC_OMX_COMPONENT *)(currentComponent->nextOMXComp))->pOMXComponent == hComponent) {
- deleteComponent = currentComponent->nextOMXComp;
- currentComponent->nextOMXComp = deleteComponent->nextOMXComp;
- } else if (currentComponent == NULL) {
- ret = OMX_ErrorComponentNotFound;
- SEC_OSAL_MutexUnlock(ghLoadComponentListMutex);
- goto EXIT;
- }
- }
- SEC_OSAL_MutexUnlock(ghLoadComponentListMutex);
-
- SEC_OMX_ComponentUnload(deleteComponent);
- SEC_OSAL_Free(deleteComponent);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_API OMX_ERRORTYPE OMX_APIENTRY SEC_OMX_SetupTunnel(
- OMX_IN OMX_HANDLETYPE hOutput,
- OMX_IN OMX_U32 nPortOutput,
- OMX_IN OMX_HANDLETYPE hInput,
- OMX_IN OMX_U32 nPortInput)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNotImplemented;
-
-EXIT:
- return ret;
-}
-
-OMX_API OMX_ERRORTYPE SEC_OMX_GetContentPipe(
- OMX_OUT OMX_HANDLETYPE *hPipe,
- OMX_IN OMX_STRING szURI)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNotImplemented;
-
-EXIT:
- return ret;
-}
-
-OMX_API OMX_ERRORTYPE SEC_OMX_GetComponentsOfRole (
- OMX_IN OMX_STRING role,
- OMX_INOUT OMX_U32 *pNumComps,
- OMX_INOUT OMX_U8 **compNames)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- int max_role_num = 0;
- OMX_STRING RoleString[MAX_OMX_COMPONENT_ROLE_SIZE];
- int i = 0, j = 0;
-
- FunctionIn();
-
- if (gInitialized != 1) {
- ret = OMX_ErrorNotReady;
- goto EXIT;
- }
-
- *pNumComps = 0;
-
- for (i = 0; i < MAX_OMX_COMPONENT_NUM; i++) {
- max_role_num = gComponentList[i].component.totalRoleNum;
-
- for (j = 0; j < max_role_num; j++) {
- if (SEC_OSAL_Strcmp(gComponentList[i].component.roles[j], role) == 0) {
- if (compNames != NULL) {
- SEC_OSAL_Strcpy((OMX_STRING)compNames[*pNumComps], gComponentList[i].component.componentName);
- }
- *pNumComps = (*pNumComps + 1);
- }
- }
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_API OMX_ERRORTYPE SEC_OMX_GetRolesOfComponent (
- OMX_IN OMX_STRING compName,
- OMX_INOUT OMX_U32 *pNumRoles,
- OMX_OUT OMX_U8 **roles)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_BOOL detectComp = OMX_FALSE;
- int compNum = 0, totalRoleNum = 0;
- int i = 0;
-
- FunctionIn();
-
- if (gInitialized != 1) {
- ret = OMX_ErrorNotReady;
- goto EXIT;
- }
-
- for (i = 0; i < MAX_OMX_COMPONENT_NUM; i++) {
- if (gComponentList != NULL) {
- if (SEC_OSAL_Strcmp(gComponentList[i].component.componentName, compName) == 0) {
- *pNumRoles = totalRoleNum = gComponentList[i].component.totalRoleNum;
- compNum = i;
- detectComp = OMX_TRUE;
- break;
- }
- } else {
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
- }
-
- if (detectComp == OMX_FALSE) {
- *pNumRoles = 0;
- ret = OMX_ErrorComponentNotFound;
- goto EXIT;
- }
-
- if (roles != NULL) {
- for (i = 0; i < totalRoleNum; i++) {
- SEC_OSAL_Strcpy(roles[i], gComponentList[compNum].component.roles[i]);
- }
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Core.h b/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Core.h
deleted file mode 100644
index c60cd52..0000000
--- a/exynos4/multimedia/openmax/sec_omx/core/SEC_OMX_Core.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Audio.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Audio.h
deleted file mode 100644
index 04f1a99..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Audio.h
+++ /dev/null
@@ -1,1311 +0,0 @@
-/*
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Component.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Component.h
deleted file mode 100644
index d595640..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Component.h
+++ /dev/null
@@ -1,579 +0,0 @@
-/*
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_ContentPipe.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_ContentPipe.h
deleted file mode 100644
index 5f6310c..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_ContentPipe.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Core.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Core.h
deleted file mode 100644
index a076f2f..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Core.h
+++ /dev/null
@@ -1,1431 +0,0 @@
-/*
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_IVCommon.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_IVCommon.h
deleted file mode 100644
index 4c4995c..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_IVCommon.h
+++ /dev/null
@@ -1,920 +0,0 @@
-/**
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Image.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Image.h
deleted file mode 100644
index a6d4666..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Image.h
+++ /dev/null
@@ -1,328 +0,0 @@
-/**
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Index.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Index.h
deleted file mode 100644
index 44d4ea7..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Index.h
+++ /dev/null
@@ -1,258 +0,0 @@
-/*
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Other.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Other.h
deleted file mode 100644
index caf7f38..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Other.h
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Types.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Types.h
deleted file mode 100644
index 31be916..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Types.h
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
- * 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/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Video.h b/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Video.h
deleted file mode 100644
index 163e450..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/khronos/OMX_Video.h
+++ /dev/null
@@ -1,1060 +0,0 @@
-/**
- * Copyright (c) 2008 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject
- * to the following conditions:
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-/**
- * @file OMX_Video.h - OpenMax IL version 1.1.2
- * The structures is needed by Video components to exchange parameters
- * and configuration data with OMX components.
- */
-#ifndef OMX_Video_h
-#define OMX_Video_h
-
-/** @defgroup video OpenMAX IL Video Domain
- * @ingroup iv
- * Structures for OpenMAX IL Video domain
- * @{
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-
-/**
- * Each OMX header must include all required header files to allow the
- * header to compile without errors. The includes below are required
- * for this header file to compile successfully
- */
-
-#include <OMX_IVCommon.h>
-
-
-/**
- * Enumeration used to define the possible video compression codings.
- * NOTE: This essentially refers to file extensions. If the coding is
- * being used to specify the ENCODE type, then additional work
- * must be done to configure the exact flavor of the compression
- * to be used. For decode cases where the user application can
- * not differentiate between MPEG-4 and H.264 bit streams, it is
- * up to the codec to handle this.
- */
-typedef enum OMX_VIDEO_CODINGTYPE {
- OMX_VIDEO_CodingUnused, /**< Value when coding is N/A */
- OMX_VIDEO_CodingAutoDetect, /**< Autodetection of coding type */
- OMX_VIDEO_CodingMPEG2, /**< AKA: H.262 */
- OMX_VIDEO_CodingH263, /**< H.263 */
- OMX_VIDEO_CodingMPEG4, /**< MPEG-4 */
- OMX_VIDEO_CodingWMV, /**< all versions of Windows Media Video */
- OMX_VIDEO_CodingRV, /**< all versions of Real Video */
- OMX_VIDEO_CodingAVC, /**< H.264/AVC */
- OMX_VIDEO_CodingMJPEG, /**< Motion JPEG */
- OMX_VIDEO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_CodingMax = 0x7FFFFFFF
-} OMX_VIDEO_CODINGTYPE;
-
-
-/**
- * Data structure used to define a video path. The number of Video paths for
- * input and output will vary by type of the Video component.
- *
- * Input (aka Source) : zero Inputs, one Output,
- * Splitter : one Input, 2 or more Outputs,
- * Processing Element : one Input, one output,
- * Mixer : 2 or more inputs, one output,
- * Output (aka Sink) : one Input, zero outputs.
- *
- * The PortDefinition structure is used to define all of the parameters
- * necessary for the compliant component to setup an input or an output video
- * path. If additional vendor specific data is required, it should be
- * transmitted to the component using the CustomCommand function. Compliant
- * components will prepopulate this structure with optimal values during the
- * GetDefaultInitParams command.
- *
- * STRUCT MEMBERS:
- * cMIMEType : MIME type of data for the port
- * pNativeRender : Platform specific reference for a display if a
- * sync, otherwise this field is 0
- * nFrameWidth : Width of frame to be used on channel if
- * uncompressed format is used. Use 0 for unknown,
- * don't care or variable
- * nFrameHeight : Height of frame to be used on channel if
- * uncompressed format is used. Use 0 for unknown,
- * don't care or variable
- * nStride : Number of bytes per span of an image
- * (i.e. indicates the number of bytes to get
- * from span N to span N+1, where negative stride
- * indicates the image is bottom up
- * nSliceHeight : Height used when encoding in slices
- * nBitrate : Bit rate of frame to be used on channel if
- * compressed format is used. Use 0 for unknown,
- * don't care or variable
- * xFramerate : Frame rate to be used on channel if uncompressed
- * format is used. Use 0 for unknown, don't care or
- * variable. Units are Q16 frames per second.
- * bFlagErrorConcealment : Turns on error concealment if it is supported by
- * the OMX component
- * eCompressionFormat : Compression format used in this instance of the
- * component. When OMX_VIDEO_CodingUnused is
- * specified, eColorFormat is used
- * eColorFormat : Decompressed format used by this component
- * pNativeWindow : Platform specific reference for a window object if a
- * display sink , otherwise this field is 0x0.
- */
-typedef struct OMX_VIDEO_PORTDEFINITIONTYPE {
- OMX_STRING cMIMEType;
- OMX_NATIVE_DEVICETYPE pNativeRender;
- OMX_U32 nFrameWidth;
- OMX_U32 nFrameHeight;
- OMX_S32 nStride;
- OMX_U32 nSliceHeight;
- OMX_U32 nBitrate;
- OMX_U32 xFramerate;
- OMX_BOOL bFlagErrorConcealment;
- OMX_VIDEO_CODINGTYPE eCompressionFormat;
- OMX_COLOR_FORMATTYPE eColorFormat;
- OMX_NATIVE_WINDOWTYPE pNativeWindow;
-} OMX_VIDEO_PORTDEFINITIONTYPE;
-
-/**
- * Port format parameter. This structure is used to enumerate the various
- * data input/output format supported by the port.
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Indicates which port to set
- * nIndex : Indicates the enumeration index for the format from
- * 0x0 to N-1
- * eCompressionFormat : Compression format used in this instance of the
- * component. When OMX_VIDEO_CodingUnused is specified,
- * eColorFormat is used
- * eColorFormat : Decompressed format used by this component
- * xFrameRate : Indicates the video frame rate in Q16 format
- */
-typedef struct OMX_VIDEO_PARAM_PORTFORMATTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nIndex;
- OMX_VIDEO_CODINGTYPE eCompressionFormat;
- OMX_COLOR_FORMATTYPE eColorFormat;
- OMX_U32 xFramerate;
-} OMX_VIDEO_PARAM_PORTFORMATTYPE;
-
-
-/**
- * This is a structure for configuring video compression quantization
- * parameter values. Codecs may support different QP values for different
- * frame types.
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version info
- * nPortIndex : Port that this structure applies to
- * nQpI : QP value to use for index frames
- * nQpP : QP value to use for P frames
- * nQpB : QP values to use for bidirectional frames
- */
-typedef struct OMX_VIDEO_PARAM_QUANTIZATIONTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nQpI;
- OMX_U32 nQpP;
- OMX_U32 nQpB;
-} OMX_VIDEO_PARAM_QUANTIZATIONTYPE;
-
-
-/**
- * Structure for configuration of video fast update parameters.
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version info
- * nPortIndex : Port that this structure applies to
- * bEnableVFU : Enable/Disable video fast update
- * nFirstGOB : Specifies the number of the first macroblock row
- * nFirstMB : specifies the first MB relative to the specified first GOB
- * nNumMBs : Specifies the number of MBs to be refreshed from nFirstGOB
- * and nFirstMB
- */
-typedef struct OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_BOOL bEnableVFU;
- OMX_U32 nFirstGOB;
- OMX_U32 nFirstMB;
- OMX_U32 nNumMBs;
-} OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE;
-
-
-/**
- * Enumeration of possible bitrate control types
- */
-typedef enum OMX_VIDEO_CONTROLRATETYPE {
- OMX_Video_ControlRateDisable,
- OMX_Video_ControlRateVariable,
- OMX_Video_ControlRateConstant,
- OMX_Video_ControlRateVariableSkipFrames,
- OMX_Video_ControlRateConstantSkipFrames,
- OMX_Video_ControlRateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_Video_ControlRateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_Video_ControlRateMax = 0x7FFFFFFF
-} OMX_VIDEO_CONTROLRATETYPE;
-
-
-/**
- * Structure for configuring bitrate mode of a codec.
- *
- * STRUCT MEMBERS:
- * nSize : Size of the struct in bytes
- * nVersion : OMX spec version info
- * nPortIndex : Port that this struct applies to
- * eControlRate : Control rate type enum
- * nTargetBitrate : Target bitrate to encode with
- */
-typedef struct OMX_VIDEO_PARAM_BITRATETYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_VIDEO_CONTROLRATETYPE eControlRate;
- OMX_U32 nTargetBitrate;
-} OMX_VIDEO_PARAM_BITRATETYPE;
-
-
-/**
- * Enumeration of possible motion vector (MV) types
- */
-typedef enum OMX_VIDEO_MOTIONVECTORTYPE {
- OMX_Video_MotionVectorPixel,
- OMX_Video_MotionVectorHalfPel,
- OMX_Video_MotionVectorQuarterPel,
- OMX_Video_MotionVectorEighthPel,
- OMX_Video_MotionVectorKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_Video_MotionVectorVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_Video_MotionVectorMax = 0x7FFFFFFF
-} OMX_VIDEO_MOTIONVECTORTYPE;
-
-
-/**
- * Structure for configuring the number of motion vectors used as well
- * as their accuracy.
- *
- * STRUCT MEMBERS:
- * nSize : Size of the struct in bytes
- * nVersion : OMX spec version info
- * nPortIndex : port that this structure applies to
- * eAccuracy : Enumerated MV accuracy
- * bUnrestrictedMVs : Allow unrestricted MVs
- * bFourMV : Allow use of 4 MVs
- * sXSearchRange : Search range in horizontal direction for MVs
- * sYSearchRange : Search range in vertical direction for MVs
- */
-typedef struct OMX_VIDEO_PARAM_MOTIONVECTORTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_VIDEO_MOTIONVECTORTYPE eAccuracy;
- OMX_BOOL bUnrestrictedMVs;
- OMX_BOOL bFourMV;
- OMX_S32 sXSearchRange;
- OMX_S32 sYSearchRange;
-} OMX_VIDEO_PARAM_MOTIONVECTORTYPE;
-
-
-/**
- * Enumeration of possible methods to use for Intra Refresh
- */
-typedef enum OMX_VIDEO_INTRAREFRESHTYPE {
- OMX_VIDEO_IntraRefreshCyclic,
- OMX_VIDEO_IntraRefreshAdaptive,
- OMX_VIDEO_IntraRefreshBoth,
- OMX_VIDEO_IntraRefreshKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_IntraRefreshVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_IntraRefreshMax = 0x7FFFFFFF
-} OMX_VIDEO_INTRAREFRESHTYPE;
-
-
-/**
- * Structure for configuring intra refresh mode
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * eRefreshMode : Cyclic, Adaptive, or Both
- * nAirMBs : Number of intra macroblocks to refresh in a frame when
- * AIR is enabled
- * nAirRef : Number of times a motion marked macroblock has to be
- * intra coded
- * nCirMBs : Number of consecutive macroblocks to be coded as "intra"
- * when CIR is enabled
- */
-typedef struct OMX_VIDEO_PARAM_INTRAREFRESHTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_VIDEO_INTRAREFRESHTYPE eRefreshMode;
- OMX_U32 nAirMBs;
- OMX_U32 nAirRef;
- OMX_U32 nCirMBs;
-} OMX_VIDEO_PARAM_INTRAREFRESHTYPE;
-
-
-/**
- * Structure for enabling various error correction methods for video
- * compression.
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * bEnableHEC : Enable/disable header extension codes (HEC)
- * bEnableResync : Enable/disable resynchronization markers
- * nResynchMarkerSpacing : Resynch markers interval (in bits) to be
- * applied in the stream
- * bEnableDataPartitioning : Enable/disable data partitioning
- * bEnableRVLC : Enable/disable reversible variable length
- * coding
- */
-typedef struct OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_BOOL bEnableHEC;
- OMX_BOOL bEnableResync;
- OMX_U32 nResynchMarkerSpacing;
- OMX_BOOL bEnableDataPartitioning;
- OMX_BOOL bEnableRVLC;
-} OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE;
-
-
-/**
- * Configuration of variable block-size motion compensation (VBSMC)
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * b16x16 : Enable inter block search 16x16
- * b16x8 : Enable inter block search 16x8
- * b8x16 : Enable inter block search 8x16
- * b8x8 : Enable inter block search 8x8
- * b8x4 : Enable inter block search 8x4
- * b4x8 : Enable inter block search 4x8
- * b4x4 : Enable inter block search 4x4
- */
-typedef struct OMX_VIDEO_PARAM_VBSMCTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_BOOL b16x16;
- OMX_BOOL b16x8;
- OMX_BOOL b8x16;
- OMX_BOOL b8x8;
- OMX_BOOL b8x4;
- OMX_BOOL b4x8;
- OMX_BOOL b4x4;
-} OMX_VIDEO_PARAM_VBSMCTYPE;
-
-
-/**
- * H.263 profile types, each profile indicates support for various
- * performance bounds and different annexes.
- *
- * ENUMS:
- * Baseline : Baseline Profile: H.263 (V1), no optional modes
- * H320 Coding : H.320 Coding Efficiency Backward Compatibility
- * Profile: H.263+ (V2), includes annexes I, J, L.4
- * and T
- * BackwardCompatible : Backward Compatibility Profile: H.263 (V1),
- * includes annex F
- * ISWV2 : Interactive Streaming Wireless Profile: H.263+
- * (V2), includes annexes I, J, K and T
- * ISWV3 : Interactive Streaming Wireless Profile: H.263++
- * (V3), includes profile 3 and annexes V and W.6.3.8
- * HighCompression : Conversational High Compression Profile: H.263++
- * (V3), includes profiles 1 & 2 and annexes D and U
- * Internet : Conversational Internet Profile: H.263++ (V3),
- * includes profile 5 and annex K
- * Interlace : Conversational Interlace Profile: H.263++ (V3),
- * includes profile 5 and annex W.6.3.11
- * HighLatency : High Latency Profile: H.263++ (V3), includes
- * profile 6 and annexes O.1 and P.5
- */
-typedef enum OMX_VIDEO_H263PROFILETYPE {
- OMX_VIDEO_H263ProfileBaseline = 0x01,
- OMX_VIDEO_H263ProfileH320Coding = 0x02,
- OMX_VIDEO_H263ProfileBackwardCompatible = 0x04,
- OMX_VIDEO_H263ProfileISWV2 = 0x08,
- OMX_VIDEO_H263ProfileISWV3 = 0x10,
- OMX_VIDEO_H263ProfileHighCompression = 0x20,
- OMX_VIDEO_H263ProfileInternet = 0x40,
- OMX_VIDEO_H263ProfileInterlace = 0x80,
- OMX_VIDEO_H263ProfileHighLatency = 0x100,
- OMX_VIDEO_H263ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_H263ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_H263ProfileMax = 0x7FFFFFFF
-} OMX_VIDEO_H263PROFILETYPE;
-
-
-/**
- * H.263 level types, each level indicates support for various frame sizes,
- * bit rates, decoder frame rates.
- */
-typedef enum OMX_VIDEO_H263LEVELTYPE {
- OMX_VIDEO_H263Level10 = 0x01,
- OMX_VIDEO_H263Level20 = 0x02,
- OMX_VIDEO_H263Level30 = 0x04,
- OMX_VIDEO_H263Level40 = 0x08,
- OMX_VIDEO_H263Level45 = 0x10,
- OMX_VIDEO_H263Level50 = 0x20,
- OMX_VIDEO_H263Level60 = 0x40,
- OMX_VIDEO_H263Level70 = 0x80,
- OMX_VIDEO_H263LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_H263LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_H263LevelMax = 0x7FFFFFFF
-} OMX_VIDEO_H263LEVELTYPE;
-
-
-/**
- * Specifies the picture type. These values should be OR'd to signal all
- * pictures types which are allowed.
- *
- * ENUMS:
- * Generic Picture Types: I, P and B
- * H.263 Specific Picture Types: SI and SP
- * H.264 Specific Picture Types: EI and EP
- * MPEG-4 Specific Picture Types: S
- */
-typedef enum OMX_VIDEO_PICTURETYPE {
- OMX_VIDEO_PictureTypeI = 0x01,
- OMX_VIDEO_PictureTypeP = 0x02,
- OMX_VIDEO_PictureTypeB = 0x04,
- OMX_VIDEO_PictureTypeSI = 0x08,
- OMX_VIDEO_PictureTypeSP = 0x10,
- OMX_VIDEO_PictureTypeEI = 0x11,
- OMX_VIDEO_PictureTypeEP = 0x12,
- OMX_VIDEO_PictureTypeS = 0x14,
- OMX_VIDEO_PictureTypeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_PictureTypeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_PictureTypeMax = 0x7FFFFFFF
-} OMX_VIDEO_PICTURETYPE;
-
-
-/**
- * H.263 Params
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * nPFrames : Number of P frames between each I frame
- * nBFrames : Number of B frames between each I frame
- * eProfile : H.263 profile(s) to use
- * eLevel : H.263 level(s) to use
- * bPLUSPTYPEAllowed : Indicating that it is allowed to use PLUSPTYPE
- * (specified in the 1998 version of H.263) to
- * indicate custom picture sizes or clock
- * frequencies
- * nAllowedPictureTypes : Specifies the picture types allowed in the
- * bitstream
- * bForceRoundingTypeToZero : value of the RTYPE bit (bit 6 of MPPTYPE) is
- * not constrained. It is recommended to change
- * the value of the RTYPE bit for each reference
- * picture in error-free communication
- * nPictureHeaderRepetition : Specifies the frequency of picture header
- * repetition
- * nGOBHeaderInterval : Specifies the interval of non-empty GOB
- * headers in units of GOBs
- */
-typedef struct OMX_VIDEO_PARAM_H263TYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nPFrames;
- OMX_U32 nBFrames;
- OMX_VIDEO_H263PROFILETYPE eProfile;
- OMX_VIDEO_H263LEVELTYPE eLevel;
- OMX_BOOL bPLUSPTYPEAllowed;
- OMX_U32 nAllowedPictureTypes;
- OMX_BOOL bForceRoundingTypeToZero;
- OMX_U32 nPictureHeaderRepetition;
- OMX_U32 nGOBHeaderInterval;
-} OMX_VIDEO_PARAM_H263TYPE;
-
-
-/**
- * MPEG-2 profile types, each profile indicates support for various
- * performance bounds and different annexes.
- */
-typedef enum OMX_VIDEO_MPEG2PROFILETYPE {
- OMX_VIDEO_MPEG2ProfileSimple = 0, /**< Simple Profile */
- OMX_VIDEO_MPEG2ProfileMain, /**< Main Profile */
- OMX_VIDEO_MPEG2Profile422, /**< 4:2:2 Profile */
- OMX_VIDEO_MPEG2ProfileSNR, /**< SNR Profile */
- OMX_VIDEO_MPEG2ProfileSpatial, /**< Spatial Profile */
- OMX_VIDEO_MPEG2ProfileHigh, /**< High Profile */
- OMX_VIDEO_MPEG2ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_MPEG2ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_MPEG2ProfileMax = 0x7FFFFFFF
-} OMX_VIDEO_MPEG2PROFILETYPE;
-
-
-/**
- * MPEG-2 level types, each level indicates support for various frame
- * sizes, bit rates, decoder frame rates. No need
- */
-typedef enum OMX_VIDEO_MPEG2LEVELTYPE {
- OMX_VIDEO_MPEG2LevelLL = 0, /**< Low Level */
- OMX_VIDEO_MPEG2LevelML, /**< Main Level */
- OMX_VIDEO_MPEG2LevelH14, /**< High 1440 */
- OMX_VIDEO_MPEG2LevelHL, /**< High Level */
- OMX_VIDEO_MPEG2LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_MPEG2LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_MPEG2LevelMax = 0x7FFFFFFF
-} OMX_VIDEO_MPEG2LEVELTYPE;
-
-
-/**
- * MPEG-2 params
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * nPFrames : Number of P frames between each I frame
- * nBFrames : Number of B frames between each I frame
- * eProfile : MPEG-2 profile(s) to use
- * eLevel : MPEG-2 levels(s) to use
- */
-typedef struct OMX_VIDEO_PARAM_MPEG2TYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nPFrames;
- OMX_U32 nBFrames;
- OMX_VIDEO_MPEG2PROFILETYPE eProfile;
- OMX_VIDEO_MPEG2LEVELTYPE eLevel;
-} OMX_VIDEO_PARAM_MPEG2TYPE;
-
-
-/**
- * MPEG-4 profile types, each profile indicates support for various
- * performance bounds and different annexes.
- *
- * ENUMS:
- * - Simple Profile, Levels 1-3
- * - Simple Scalable Profile, Levels 1-2
- * - Core Profile, Levels 1-2
- * - Main Profile, Levels 2-4
- * - N-bit Profile, Level 2
- * - Scalable Texture Profile, Level 1
- * - Simple Face Animation Profile, Levels 1-2
- * - Simple Face and Body Animation (FBA) Profile, Levels 1-2
- * - Basic Animated Texture Profile, Levels 1-2
- * - Hybrid Profile, Levels 1-2
- * - Advanced Real Time Simple Profiles, Levels 1-4
- * - Core Scalable Profile, Levels 1-3
- * - Advanced Coding Efficiency Profile, Levels 1-4
- * - Advanced Core Profile, Levels 1-2
- * - Advanced Scalable Texture, Levels 2-3
- */
-typedef enum OMX_VIDEO_MPEG4PROFILETYPE {
- OMX_VIDEO_MPEG4ProfileSimple = 0x01,
- OMX_VIDEO_MPEG4ProfileSimpleScalable = 0x02,
- OMX_VIDEO_MPEG4ProfileCore = 0x04,
- OMX_VIDEO_MPEG4ProfileMain = 0x08,
- OMX_VIDEO_MPEG4ProfileNbit = 0x10,
- OMX_VIDEO_MPEG4ProfileScalableTexture = 0x20,
- OMX_VIDEO_MPEG4ProfileSimpleFace = 0x40,
- OMX_VIDEO_MPEG4ProfileSimpleFBA = 0x80,
- OMX_VIDEO_MPEG4ProfileBasicAnimated = 0x100,
- OMX_VIDEO_MPEG4ProfileHybrid = 0x200,
- OMX_VIDEO_MPEG4ProfileAdvancedRealTime = 0x400,
- OMX_VIDEO_MPEG4ProfileCoreScalable = 0x800,
- OMX_VIDEO_MPEG4ProfileAdvancedCoding = 0x1000,
- OMX_VIDEO_MPEG4ProfileAdvancedCore = 0x2000,
- OMX_VIDEO_MPEG4ProfileAdvancedScalable = 0x4000,
- OMX_VIDEO_MPEG4ProfileAdvancedSimple = 0x8000,
- OMX_VIDEO_MPEG4ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_MPEG4ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_MPEG4ProfileMax = 0x7FFFFFFF
-} OMX_VIDEO_MPEG4PROFILETYPE;
-
-
-/**
- * MPEG-4 level types, each level indicates support for various frame
- * sizes, bit rates, decoder frame rates. No need
- */
-typedef enum OMX_VIDEO_MPEG4LEVELTYPE {
- OMX_VIDEO_MPEG4Level0 = 0x01, /**< Level 0 */
- OMX_VIDEO_MPEG4Level0b = 0x02, /**< Level 0b */
- OMX_VIDEO_MPEG4Level1 = 0x04, /**< Level 1 */
- OMX_VIDEO_MPEG4Level2 = 0x08, /**< Level 2 */
- OMX_VIDEO_MPEG4Level3 = 0x10, /**< Level 3 */
- OMX_VIDEO_MPEG4Level4 = 0x20, /**< Level 4 */
- OMX_VIDEO_MPEG4Level4a = 0x40, /**< Level 4a */
- OMX_VIDEO_MPEG4Level5 = 0x80, /**< Level 5 */
- OMX_VIDEO_MPEG4LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_MPEG4LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_MPEG4LevelMax = 0x7FFFFFFF
-} OMX_VIDEO_MPEG4LEVELTYPE;
-
-
-/**
- * MPEG-4 configuration. This structure handles configuration options
- * which are specific to MPEG4 algorithms
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * nSliceHeaderSpacing : Number of macroblocks between slice header (H263+
- * Annex K). Put zero if not used
- * bSVH : Enable Short Video Header mode
- * bGov : Flag to enable GOV
- * nPFrames : Number of P frames between each I frame (also called
- * GOV period)
- * nBFrames : Number of B frames between each I frame
- * nIDCVLCThreshold : Value of intra DC VLC threshold
- * bACPred : Flag to use ac prediction
- * nMaxPacketSize : Maximum size of packet in bytes.
- * nTimeIncRes : Used to pass VOP time increment resolution for MPEG4.
- * Interpreted as described in MPEG4 standard.
- * eProfile : MPEG-4 profile(s) to use.
- * eLevel : MPEG-4 level(s) to use.
- * nAllowedPictureTypes : Specifies the picture types allowed in the bitstream
- * nHeaderExtension : Specifies the number of consecutive video packet
- * headers within a VOP
- * bReversibleVLC : Specifies whether reversible variable length coding
- * is in use
- */
-typedef struct OMX_VIDEO_PARAM_MPEG4TYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nSliceHeaderSpacing;
- OMX_BOOL bSVH;
- OMX_BOOL bGov;
- OMX_U32 nPFrames;
- OMX_U32 nBFrames;
- OMX_U32 nIDCVLCThreshold;
- OMX_BOOL bACPred;
- OMX_U32 nMaxPacketSize;
- OMX_U32 nTimeIncRes;
- OMX_VIDEO_MPEG4PROFILETYPE eProfile;
- OMX_VIDEO_MPEG4LEVELTYPE eLevel;
- OMX_U32 nAllowedPictureTypes;
- OMX_U32 nHeaderExtension;
- OMX_BOOL bReversibleVLC;
-} OMX_VIDEO_PARAM_MPEG4TYPE;
-
-
-/**
- * WMV Versions
- */
-typedef enum OMX_VIDEO_WMVFORMATTYPE {
- OMX_VIDEO_WMVFormatUnused = 0x01, /**< Format unused or unknown */
- OMX_VIDEO_WMVFormat7 = 0x02, /**< Windows Media Video format 7 */
- OMX_VIDEO_WMVFormat8 = 0x04, /**< Windows Media Video format 8 */
- OMX_VIDEO_WMVFormat9 = 0x08, /**< Windows Media Video format 9 */
- OMX_VIDEO_WMFFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_WMFFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_WMVFormatMax = 0x7FFFFFFF
-} OMX_VIDEO_WMVFORMATTYPE;
-
-
-/**
- * WMV Params
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * eFormat : Version of WMV stream / data
- */
-typedef struct OMX_VIDEO_PARAM_WMVTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_VIDEO_WMVFORMATTYPE eFormat;
-} OMX_VIDEO_PARAM_WMVTYPE;
-
-
-/**
- * Real Video Version
- */
-typedef enum OMX_VIDEO_RVFORMATTYPE {
- OMX_VIDEO_RVFormatUnused = 0, /**< Format unused or unknown */
- OMX_VIDEO_RVFormat8, /**< Real Video format 8 */
- OMX_VIDEO_RVFormat9, /**< Real Video format 9 */
- OMX_VIDEO_RVFormatG2, /**< Real Video Format G2 */
- OMX_VIDEO_RVFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_RVFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_RVFormatMax = 0x7FFFFFFF
-} OMX_VIDEO_RVFORMATTYPE;
-
-
-/**
- * Real Video Params
- *
- * STUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * eFormat : Version of RV stream / data
- * nBitsPerPixel : Bits per pixel coded in the frame
- * nPaddedWidth : Padded width in pixel of a video frame
- * nPaddedHeight : Padded Height in pixels of a video frame
- * nFrameRate : Rate of video in frames per second
- * nBitstreamFlags : Flags which internal information about the bitstream
- * nBitstreamVersion : Bitstream version
- * nMaxEncodeFrameSize: Max encoded frame size
- * bEnablePostFilter : Turn on/off post filter
- * bEnableTemporalInterpolation : Turn on/off temporal interpolation
- * bEnableLatencyMode : When enabled, the decoder does not display a decoded
- * frame until it has detected that no enhancement layer
- * frames or dependent B frames will be coming. This
- * detection usually occurs when a subsequent non-B
- * frame is encountered
- */
-typedef struct OMX_VIDEO_PARAM_RVTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_VIDEO_RVFORMATTYPE eFormat;
- OMX_U16 nBitsPerPixel;
- OMX_U16 nPaddedWidth;
- OMX_U16 nPaddedHeight;
- OMX_U32 nFrameRate;
- OMX_U32 nBitstreamFlags;
- OMX_U32 nBitstreamVersion;
- OMX_U32 nMaxEncodeFrameSize;
- OMX_BOOL bEnablePostFilter;
- OMX_BOOL bEnableTemporalInterpolation;
- OMX_BOOL bEnableLatencyMode;
-} OMX_VIDEO_PARAM_RVTYPE;
-
-
-/**
- * AVC profile types, each profile indicates support for various
- * performance bounds and different annexes.
- */
-typedef enum OMX_VIDEO_AVCPROFILETYPE {
- OMX_VIDEO_AVCProfileBaseline = 0x01, /**< Baseline profile */
- OMX_VIDEO_AVCProfileMain = 0x02, /**< Main profile */
- OMX_VIDEO_AVCProfileExtended = 0x04, /**< Extended profile */
- OMX_VIDEO_AVCProfileHigh = 0x08, /**< High profile */
- OMX_VIDEO_AVCProfileHigh10 = 0x10, /**< High 10 profile */
- OMX_VIDEO_AVCProfileHigh422 = 0x20, /**< High 4:2:2 profile */
- OMX_VIDEO_AVCProfileHigh444 = 0x40, /**< High 4:4:4 profile */
- OMX_VIDEO_AVCProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_AVCProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_AVCProfileMax = 0x7FFFFFFF
-} OMX_VIDEO_AVCPROFILETYPE;
-
-
-/**
- * AVC level types, each level indicates support for various frame sizes,
- * bit rates, decoder frame rates. No need
- */
-typedef enum OMX_VIDEO_AVCLEVELTYPE {
- OMX_VIDEO_AVCLevel1 = 0x01, /**< Level 1 */
- OMX_VIDEO_AVCLevel1b = 0x02, /**< Level 1b */
- OMX_VIDEO_AVCLevel11 = 0x04, /**< Level 1.1 */
- OMX_VIDEO_AVCLevel12 = 0x08, /**< Level 1.2 */
- OMX_VIDEO_AVCLevel13 = 0x10, /**< Level 1.3 */
- OMX_VIDEO_AVCLevel2 = 0x20, /**< Level 2 */
- OMX_VIDEO_AVCLevel21 = 0x40, /**< Level 2.1 */
- OMX_VIDEO_AVCLevel22 = 0x80, /**< Level 2.2 */
- OMX_VIDEO_AVCLevel3 = 0x100, /**< Level 3 */
- OMX_VIDEO_AVCLevel31 = 0x200, /**< Level 3.1 */
- OMX_VIDEO_AVCLevel32 = 0x400, /**< Level 3.2 */
- OMX_VIDEO_AVCLevel4 = 0x800, /**< Level 4 */
- OMX_VIDEO_AVCLevel41 = 0x1000, /**< Level 4.1 */
- OMX_VIDEO_AVCLevel42 = 0x2000, /**< Level 4.2 */
- OMX_VIDEO_AVCLevel5 = 0x4000, /**< Level 5 */
- OMX_VIDEO_AVCLevel51 = 0x8000, /**< Level 5.1 */
- OMX_VIDEO_AVCLevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_AVCLevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_AVCLevelMax = 0x7FFFFFFF
-} OMX_VIDEO_AVCLEVELTYPE;
-
-
-/**
- * AVC loop filter modes
- *
- * OMX_VIDEO_AVCLoopFilterEnable : Enable
- * OMX_VIDEO_AVCLoopFilterDisable : Disable
- * OMX_VIDEO_AVCLoopFilterDisableSliceBoundary : Disabled on slice boundaries
- */
-typedef enum OMX_VIDEO_AVCLOOPFILTERTYPE {
- OMX_VIDEO_AVCLoopFilterEnable = 0,
- OMX_VIDEO_AVCLoopFilterDisable,
- OMX_VIDEO_AVCLoopFilterDisableSliceBoundary,
- OMX_VIDEO_AVCLoopFilterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_AVCLoopFilterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_AVCLoopFilterMax = 0x7FFFFFFF
-} OMX_VIDEO_AVCLOOPFILTERTYPE;
-
-
-/**
- * AVC params
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * nSliceHeaderSpacing : Number of macroblocks between slice header, put
- * zero if not used
- * nPFrames : Number of P frames between each I frame
- * nBFrames : Number of B frames between each I frame
- * bUseHadamard : Enable/disable Hadamard transform
- * nRefFrames : Max number of reference frames to use for inter
- * motion search (1-16)
- * nRefIdxTrailing : Pic param set ref frame index (index into ref
- * frame buffer of trailing frames list), B frame
- * support
- * nRefIdxForward : Pic param set ref frame index (index into ref
- * frame buffer of forward frames list), B frame
- * support
- * bEnableUEP : Enable/disable unequal error protection. This
- * is only valid of data partitioning is enabled.
- * bEnableFMO : Enable/disable flexible macroblock ordering
- * bEnableASO : Enable/disable arbitrary slice ordering
- * bEnableRS : Enable/disable sending of redundant slices
- * eProfile : AVC profile(s) to use
- * eLevel : AVC level(s) to use
- * nAllowedPictureTypes : Specifies the picture types allowed in the
- * bitstream
- * bFrameMBsOnly : specifies that every coded picture of the
- * coded video sequence is a coded frame
- * containing only frame macroblocks
- * bMBAFF : Enable/disable switching between frame and
- * field macroblocks within a picture
- * bEntropyCodingCABAC : Entropy decoding method to be applied for the
- * syntax elements for which two descriptors appear
- * in the syntax tables
- * bWeightedPPrediction : Enable/disable weighted prediction shall not
- * be applied to P and SP slices
- * nWeightedBipredicitonMode : Default weighted prediction is applied to B
- * slices
- * bconstIpred : Enable/disable intra prediction
- * bDirect8x8Inference : Specifies the method used in the derivation
- * process for luma motion vectors for B_Skip,
- * B_Direct_16x16 and B_Direct_8x8 as specified
- * in subclause 8.4.1.2 of the AVC spec
- * bDirectSpatialTemporal : Flag indicating spatial or temporal direct
- * mode used in B slice coding (related to
- * bDirect8x8Inference) . Spatial direct mode is
- * more common and should be the default.
- * nCabacInitIdx : Index used to init CABAC contexts
- * eLoopFilterMode : Enable/disable loop filter
- */
-typedef struct OMX_VIDEO_PARAM_AVCTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nSliceHeaderSpacing;
- OMX_U32 nPFrames;
- OMX_U32 nBFrames;
- OMX_BOOL bUseHadamard;
- OMX_U32 nRefFrames;
- OMX_U32 nRefIdx10ActiveMinus1;
- OMX_U32 nRefIdx11ActiveMinus1;
- OMX_BOOL bEnableUEP;
- OMX_BOOL bEnableFMO;
- OMX_BOOL bEnableASO;
- OMX_BOOL bEnableRS;
- OMX_VIDEO_AVCPROFILETYPE eProfile;
- OMX_VIDEO_AVCLEVELTYPE eLevel;
- OMX_U32 nAllowedPictureTypes;
- OMX_BOOL bFrameMBsOnly;
- OMX_BOOL bMBAFF;
- OMX_BOOL bEntropyCodingCABAC;
- OMX_BOOL bWeightedPPrediction;
- OMX_U32 nWeightedBipredicitonMode;
- OMX_BOOL bconstIpred ;
- OMX_BOOL bDirect8x8Inference;
- OMX_BOOL bDirectSpatialTemporal;
- OMX_U32 nCabacInitIdc;
- OMX_VIDEO_AVCLOOPFILTERTYPE eLoopFilterMode;
-} OMX_VIDEO_PARAM_AVCTYPE;
-
-typedef struct OMX_VIDEO_PARAM_PROFILELEVELTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 eProfile; /**< type is OMX_VIDEO_AVCPROFILETYPE, OMX_VIDEO_H263PROFILETYPE,
- or OMX_VIDEO_MPEG4PROFILETYPE depending on context */
- OMX_U32 eLevel; /**< type is OMX_VIDEO_AVCLEVELTYPE, OMX_VIDEO_H263LEVELTYPE,
- or OMX_VIDEO_MPEG4PROFILETYPE depending on context */
- OMX_U32 nProfileIndex; /**< Used to query for individual profile support information,
- This parameter is valid only for
- OMX_IndexParamVideoProfileLevelQuerySupported index,
- For all other indices this parameter is to be ignored. */
-} OMX_VIDEO_PARAM_PROFILELEVELTYPE;
-
-/**
- * Structure for dynamically configuring bitrate mode of a codec.
- *
- * STRUCT MEMBERS:
- * nSize : Size of the struct in bytes
- * nVersion : OMX spec version info
- * nPortIndex : Port that this struct applies to
- * nEncodeBitrate : Target average bitrate to be generated in bps
- */
-typedef struct OMX_VIDEO_CONFIG_BITRATETYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nEncodeBitrate;
-} OMX_VIDEO_CONFIG_BITRATETYPE;
-
-/**
- * Defines Encoder Frame Rate setting
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * xEncodeFramerate : Encoding framerate represented in Q16 format
- */
-typedef struct OMX_CONFIG_FRAMERATETYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 xEncodeFramerate; /* Q16 format */
-} OMX_CONFIG_FRAMERATETYPE;
-
-typedef struct OMX_CONFIG_INTRAREFRESHVOPTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_BOOL IntraRefreshVOP;
-} OMX_CONFIG_INTRAREFRESHVOPTYPE;
-
-typedef struct OMX_CONFIG_MACROBLOCKERRORMAPTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nErrMapSize; /* Size of the Error Map in bytes */
- OMX_U8 ErrMap[1]; /* Error map hint */
-} OMX_CONFIG_MACROBLOCKERRORMAPTYPE;
-
-typedef struct OMX_CONFIG_MBERRORREPORTINGTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_BOOL bEnabled;
-} OMX_CONFIG_MBERRORREPORTINGTYPE;
-
-typedef struct OMX_PARAM_MACROBLOCKSTYPE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nMacroblocks;
-} OMX_PARAM_MACROBLOCKSTYPE;
-
-/**
- * AVC Slice Mode modes
- *
- * OMX_VIDEO_SLICEMODE_AVCDefault : Normal frame encoding, one slice per frame
- * OMX_VIDEO_SLICEMODE_AVCMBSlice : NAL mode, number of MBs per frame
- * OMX_VIDEO_SLICEMODE_AVCByteSlice : NAL mode, number of bytes per frame
- */
-typedef enum OMX_VIDEO_AVCSLICEMODETYPE {
- OMX_VIDEO_SLICEMODE_AVCDefault = 0,
- OMX_VIDEO_SLICEMODE_AVCMBSlice,
- OMX_VIDEO_SLICEMODE_AVCByteSlice,
- OMX_VIDEO_SLICEMODE_AVCKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
- OMX_VIDEO_SLICEMODE_AVCVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
- OMX_VIDEO_SLICEMODE_AVCLevelMax = 0x7FFFFFFF
-} OMX_VIDEO_AVCSLICEMODETYPE;
-
-/**
- * AVC FMO Slice Mode Params
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * nNumSliceGroups : Specifies the number of slice groups
- * nSliceGroupMapType : Specifies the type of slice groups
- * eSliceMode : Specifies the type of slice
- */
-typedef struct OMX_VIDEO_PARAM_AVCSLICEFMO {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U8 nNumSliceGroups;
- OMX_U8 nSliceGroupMapType;
- OMX_VIDEO_AVCSLICEMODETYPE eSliceMode;
-} OMX_VIDEO_PARAM_AVCSLICEFMO;
-
-/**
- * AVC IDR Period Configs
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * nIDRPeriod : Specifies periodicity of IDR frames
- * nPFrames : Specifies internal of coding Intra frames
- */
-typedef struct OMX_VIDEO_CONFIG_AVCINTRAPERIOD {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nIDRPeriod;
- OMX_U32 nPFrames;
-} OMX_VIDEO_CONFIG_AVCINTRAPERIOD;
-
-/**
- * AVC NAL Size Configs
- *
- * STRUCT MEMBERS:
- * nSize : Size of the structure in bytes
- * nVersion : OMX specification version information
- * nPortIndex : Port that this structure applies to
- * nNaluBytes : Specifies the NAL unit size
- */
-typedef struct OMX_VIDEO_CONFIG_NALSIZE {
- OMX_U32 nSize;
- OMX_VERSIONTYPE nVersion;
- OMX_U32 nPortIndex;
- OMX_U32 nNaluBytes;
-} OMX_VIDEO_CONFIG_NALSIZE;
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif
-/* File EOF */
-
diff --git a/exynos4/multimedia/openmax/sec_omx/include/sec/SEC_OMX_Def.h b/exynos4/multimedia/openmax/sec_omx/include/sec/SEC_OMX_Def.h
deleted file mode 100644
index 2b4df69..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/sec/SEC_OMX_Def.h
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- *
- * 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.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 SEC_OMX_INSTALL_PATH "/system/lib/omx/"
-
-typedef enum _SEC_CODEC_TYPE
-{
- SW_CODEC,
- HW_VIDEO_DEC_CODEC,
- HW_VIDEO_ENC_CODEC,
- HW_AUDIO_DEC_CODEC,
- HW_AUDIO_ENC_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,
-#define SEC_INDEX_CONFIG_VIDEO_INTRAPERIOD "OMX.SEC.index.VideoIntraPeriod"
- OMX_IndexConfigVideoIntraPeriod = 0x7F000002,
-
- /* 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 = (OMX_S32) 0x90000001,
- OMX_ErrorInputDataDecodeYet = (OMX_S32) 0x90000002,
- OMX_ErrorInputDataEncodeYet = (OMX_S32) 0x90000003,
- OMX_ErrorMFCInit = (OMX_S32) 0x90000004
-} 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 */
- OMX_SEC_COLOR_FormatNV12LPhysicalAddress = 0x7F000002,
- OMX_SEC_COLOR_FormatNV12LVirtualAddress = 0x7F000003,
- OMX_SEC_COLOR_FormatNV12Tiled = 0x7FC00002, /* 0x7FC00002 */
-#ifdef S3D_SUPPORT
- OMX_SEC_COLOR_FormatNV12Tiled_SBS_LR = 0x7FC00003, /* 0x7FC00003 */
- OMX_SEC_COLOR_FormatNV12Tiled_SBS_RL = 0x7FC00004, /* 0x7FC00004 */
- OMX_SEC_COLOR_FormatNV12Tiled_TB_LR = 0x7FC00005, /* 0x7FC00005 */
- OMX_SEC_COLOR_FormatNV12Tiled_TB_RL = 0x7FC00006, /* 0x7FC00006 */
- OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_LR = 0x7FC00007, /* 0x7FC00007 */
- OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_RL = 0x7FC00008, /* 0x7FC00008 */
- OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_LR = 0x7FC00009, /* 0x7FC00009 */
- OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_RL = 0x7FC0000A, /* 0x7FC0000A */
- OMX_SEC_COLOR_FormatYUV420Planar_SBS_LR = 0x7FC0000B, /* 0x7FC0000B */
- OMX_SEC_COLOR_FormatYUV420Planar_SBS_RL = 0x7FC0000C, /* 0x7FC0000C */
- OMX_SEC_COLOR_FormatYUV420Planar_TB_LR = 0x7FC0000D, /* 0x7FC0000D */
- OMX_SEC_COLOR_FormatYUV420Planar_TB_RL = 0x7FC0000E, /* 0x7FC0000E */
-#endif
- OMX_SEC_COLOR_FormatNV21LPhysicalAddress = 0x7F000010,
- OMX_SEC_COLOR_FormatNV21Linear = 0x7F000011,
-
- /* for Android Native Window */
- OMX_SEC_COLOR_FormatANBYUV420SemiPlanar = 0x100,
- /* for Android SurfaceMediaSource*/
- OMX_COLOR_FormatAndroidOpaque = 0x7F000789
-}SEC_OMX_COLOR_FORMATTYPE;
-
-typedef enum _SEC_OMX_SUPPORTFORMAT_TYPE
-{
- supportFormat_0 = 0x00,
- supportFormat_1,
- supportFormat_2,
- supportFormat_3,
- supportFormat_4,
- supportFormat_5,
- supportFormat_6,
- supportFormat_7,
- supportFormat_8
-} SEC_OMX_SUPPORTFORMAT_TYPE;
-
-/* for Android PV OpenCore*/
-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;
-
-#define OMX_VIDEO_CodingVPX 0x09 /**< Google VPX, formerly known as On2 VP8 */
-
-#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/exynos4/multimedia/openmax/sec_omx/include/sec/SEC_OMX_Macros.h b/exynos4/multimedia/openmax/sec_omx/include/sec/SEC_OMX_Macros.h
deleted file mode 100644
index 853d0ac..0000000
--- a/exynos4/multimedia/openmax/sec_omx/include/sec/SEC_OMX_Macros.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- *
- * 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.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(x, a) (((x) + (a) - 1) & ~((a) - 1))
-#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_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/exynos4/multimedia/openmax/sec_omx/osal/Android.mk b/exynos4/multimedia/openmax/sec_omx/osal/Android.mk
deleted file mode 100644
index 5dcbeee..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/Android.mk
+++ /dev/null
@@ -1,45 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := \
- SEC_OSAL_Android.cpp \
- SEC_OSAL_Event.c \
- SEC_OSAL_Queue.c \
- SEC_OSAL_ETC.c \
- SEC_OSAL_Mutex.c \
- SEC_OSAL_Thread.c \
- SEC_OSAL_Memory.c \
- SEC_OSAL_Semaphore.c \
- SEC_OSAL_Library.c \
- SEC_OSAL_Log.c
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE := libsecosal
-
-LOCAL_CFLAGS :=
-
-ifeq ($(BOARD_USE_S3D_SUPPORT), true)
-LOCAL_CFLAGS += -DS3D_SUPPORT
-endif
-
-LOCAL_STATIC_LIBRARIES :=
-LOCAL_SHARED_LIBRARIES := libcutils libutils \
- libui \
- libhardware \
- libandroid_runtime \
- libsurfaceflinger_client \
- libbinder \
- libmedia
-
-LOCAL_C_INCLUDES := \
- $(SEC_OMX_INC)/khronos \
- $(SEC_OMX_INC)/sec \
- $(SEC_OMX_TOP)/osal \
- $(SEC_OMX_COMPONENT)/common \
- $(SEC_OMX_COMPONENT)/video/dec \
- $(BOARD_HAL_PATH)/include \
- $(BOARD_HAL_PATH)/libump/include
-
-include $(BUILD_STATIC_LIBRARY)
diff --git a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Android.cpp b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Android.cpp
deleted file mode 100644
index 2a51de9..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Android.cpp
+++ /dev/null
@@ -1,581 +0,0 @@
-/*
- * 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 SEC_OSAL_Android.cpp
- * @brief
- * @author Seungbeom Kim (sbcrux.kim@samsung.com)
- * @author Hyeyeon Chung (hyeon.chung@samsung.com)
- * @author Yunji Kim (yunji.kim@samsung.com)
- * @author Jinsung Yang (jsgood.yang@samsung.com)
- * @version 1.1.0
- * @history
- * 2011.7.15 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <ui/android_native_buffer.h>
-#include <ui/GraphicBuffer.h>
-#include <ui/GraphicBufferMapper.h>
-#include <ui/Rect.h>
-#include <media/stagefright/HardwareAPI.h>
-#include <hardware/hardware.h>
-#include <media/stagefright/MetadataBufferType.h>
-
-#include "gralloc_priv.h"
-
-#include "SEC_OSAL_Semaphore.h"
-#include "SEC_OMX_Baseport.h"
-#include "SEC_OMX_Basecomponent.h"
-#include "SEC_OMX_Macros.h"
-#include "SEC_OMX_Vdec.h"
-
-#undef SEC_LOG_TAG
-#define SEC_LOG_TAG "SEC_OSAL_Android"
-#define SEC_LOG_OFF
-#include "SEC_OSAL_Log.h"
-
-using namespace android;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-OMX_ERRORTYPE useAndroidNativeBuffer(
- SEC_OMX_BASEPORT *pSECPort,
- OMX_BUFFERHEADERTYPE **ppBufferHdr,
- OMX_U32 nPortIndex,
- OMX_PTR pAppPrivate,
- OMX_U32 nSizeBytes,
- OMX_U8 *pBuffer)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- OMX_BUFFERHEADERTYPE *temp_bufferHeader = NULL;
- unsigned int i = 0;
-
- FunctionIn();
-
- if (pSECPort == NULL) {
- ret = OMX_ErrorBadParameter;
- 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;
- goto EXIT;
- }
- }
-
- SEC_OSAL_Free(temp_bufferHeader);
- ret = OMX_ErrorInsufficientResources;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_LockANBHandle(
- OMX_IN OMX_U32 handle,
- OMX_IN OMX_U32 width,
- OMX_IN OMX_U32 height,
- OMX_IN OMX_COLOR_FORMATTYPE format,
- OMX_OUT OMX_PTR *vaddr)
-{
- FunctionIn();
-
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- GraphicBufferMapper &mapper = GraphicBufferMapper::get();
- buffer_handle_t bufferHandle = (buffer_handle_t) handle;
- Rect bounds(width, height);
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: handle: 0x%x", __func__, handle);
-
- int usage = 0;
-
- switch (format) {
- case OMX_COLOR_FormatYUV420Planar:
- case OMX_COLOR_FormatYUV420SemiPlanar:
-#ifdef S3D_SUPPORT
- case OMX_SEC_COLOR_FormatNV12Tiled_SBS_LR:
- case OMX_SEC_COLOR_FormatNV12Tiled_SBS_RL:
- case OMX_SEC_COLOR_FormatNV12Tiled_TB_LR:
- case OMX_SEC_COLOR_FormatNV12Tiled_TB_RL:
- case OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_LR:
- case OMX_SEC_COLOR_FormatYUV420SemiPlanar_SBS_RL:
- case OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_LR:
- case OMX_SEC_COLOR_FormatYUV420SemiPlanar_TB_RL:
- case OMX_SEC_COLOR_FormatYUV420Planar_SBS_LR:
- case OMX_SEC_COLOR_FormatYUV420Planar_SBS_RL:
- case OMX_SEC_COLOR_FormatYUV420Planar_TB_LR:
- case OMX_SEC_COLOR_FormatYUV420Planar_TB_RL:
-#endif
- case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
- usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_YUV_ADDR;
- break;
- default:
- usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN;
- break;
- }
-
- if (mapper.lock(bufferHandle, usage, bounds, vaddr) != 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: mapper.lock() fail", __func__);
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: buffer locked: 0x%x", __func__, *vaddr);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_UnlockANBHandle(OMX_IN OMX_U32 handle)
-{
- FunctionIn();
-
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- GraphicBufferMapper &mapper = GraphicBufferMapper::get();
- buffer_handle_t bufferHandle = (buffer_handle_t) handle;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: handle: 0x%x", __func__, handle);
-
- if (mapper.unlock(bufferHandle) != 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: mapper.unlock() fail", __func__);
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: buffer unlocked: 0x%x", __func__, handle);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_GetPhysANBHandle(
- OMX_IN OMX_U32 handle,
- OMX_OUT OMX_PTR *paddr)
-{
- FunctionIn();
-
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- GraphicBufferMapper &mapper = GraphicBufferMapper::get();
- buffer_handle_t bufferHandle = (buffer_handle_t) handle;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: handle: 0x%x", __func__, handle);
-
- if (mapper.getphys(bufferHandle, paddr) != 0) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: mapper.getphys() fail", __func__);
- ret = OMX_ErrorUndefined;
- goto EXIT;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_LockANB(
- OMX_IN OMX_PTR pBuffer,
- OMX_IN OMX_U32 width,
- OMX_IN OMX_U32 height,
- OMX_IN OMX_COLOR_FORMATTYPE format,
- OMX_OUT OMX_U32 *pStride,
- OMX_OUT OMX_PTR *vaddr)
-{
- FunctionIn();
-
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- android_native_buffer_t *pANB = (android_native_buffer_t *) pBuffer;
-
- ret = SEC_OSAL_LockANBHandle((OMX_U32)pANB->handle, width, height, format, vaddr);
- *pStride = pANB->stride;
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_UnlockANB(OMX_IN OMX_PTR pBuffer)
-{
- FunctionIn();
-
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- android_native_buffer_t *pANB = (android_native_buffer_t *) pBuffer;
-
- ret = SEC_OSAL_UnlockANBHandle((OMX_U32)pANB->handle);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_GetPhysANB(
- OMX_IN OMX_PTR pBuffer,
- OMX_OUT OMX_PTR *paddr)
-{
- FunctionIn();
-
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- android_native_buffer_t *pANB = (android_native_buffer_t *) pBuffer;
-
- ret = SEC_OSAL_GetPhysANBHandle((OMX_U32)pANB->handle, paddr);
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_GetANBParameter(
- OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- 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 (pSECComponent->currentState == OMX_StateInvalid ) {
- ret = OMX_ErrorInvalidState;
- goto EXIT;
- }
-
- if (ComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- switch (nIndex) {
- case OMX_IndexParamGetAndroidNativeBuffer:
- {
- GetAndroidNativeBufferUsageParams *pANBParams = (GetAndroidNativeBufferUsageParams *) ComponentParameterStructure;
- OMX_U32 portIndex = pANBParams->nPortIndex;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: OMX_IndexParamGetAndroidNativeBuffer", __func__);
-
- ret = SEC_OMX_Check_SizeVersion(pANBParams, sizeof(GetAndroidNativeBufferUsageParams));
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_OMX_Check_SizeVersion(GetAndroidNativeBufferUsageParams) is failed", __func__);
- goto EXIT;
- }
-
- if (portIndex >= pSECComponent->portParam.nPorts) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- /* NOTE: OMX_IndexParamGetAndroidNativeBuffer returns original 'nUsage' without any
- * modifications since currently not defined what the 'nUsage' is for.
- */
- pANBParams->nUsage |= 0;
- }
- break;
-
- default:
- {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: Unsupported index (%d)", __func__, nIndex);
- ret = OMX_ErrorUnsupportedIndex;
- goto EXIT;
- }
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_SetANBParameter(
- 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_VIDEODEC_COMPONENT *pVideoDec = 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;
- }
-
- if (ComponentParameterStructure == NULL) {
- ret = OMX_ErrorBadParameter;
- goto EXIT;
- }
-
- pVideoDec = (SEC_OMX_VIDEODEC_COMPONENT *)pSECComponent->hComponentHandle;
-
- switch (nIndex) {
- case OMX_IndexParamEnableAndroidBuffers:
- {
- EnableAndroidNativeBuffersParams *pANBParams = (EnableAndroidNativeBuffersParams *) ComponentParameterStructure;
- OMX_U32 portIndex = pANBParams->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: OMX_IndexParamEnableAndroidNativeBuffers", __func__);
-
- ret = SEC_OMX_Check_SizeVersion(pANBParams, sizeof(EnableAndroidNativeBuffersParams));
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_OMX_Check_SizeVersion(EnableAndroidNativeBuffersParams) is failed", __func__);
- goto EXIT;
- }
-
- if (portIndex >= pSECComponent->portParam.nPorts) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[portIndex];
- if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pSECPort->bIsANBEnabled = pANBParams->enable;
- }
- break;
-
- case OMX_IndexParamUseAndroidNativeBuffer:
- {
- UseAndroidNativeBufferParams *pANBParams = (UseAndroidNativeBufferParams *) ComponentParameterStructure;
- OMX_U32 portIndex = pANBParams->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
- android_native_buffer_t *pANB;
- OMX_U32 nSizeBytes;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: OMX_IndexParamUseAndroidNativeBuffer, portIndex: %d", __func__, portIndex);
-
- ret = SEC_OMX_Check_SizeVersion(pANBParams, sizeof(UseAndroidNativeBufferParams));
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_OMX_Check_SizeVersion(UseAndroidNativeBufferParams) is failed", __func__);
- goto EXIT;
- }
-
- if (portIndex >= pSECComponent->portParam.nPorts) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[portIndex];
- if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- if (pSECPort->portState != OMX_StateIdle) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: Port state should be IDLE", __func__);
- ret = OMX_ErrorIncorrectStateOperation;
- goto EXIT;
- }
-
- pANB = pANBParams->nativeBuffer.get();
-
- /* MALI alignment restriction */
- nSizeBytes = ALIGN(pANB->width, 16) * ALIGN(pANB->height, 16);
- nSizeBytes += ALIGN(pANB->width / 2, 16) * ALIGN(pANB->height / 2, 16) * 2;
-
- ret = useAndroidNativeBuffer(pSECPort,
- pANBParams->bufferHeader,
- pANBParams->nPortIndex,
- pANBParams->pAppPrivate,
- nSizeBytes,
- (OMX_U8 *) pANB);
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: useAndroidNativeBuffer is failed", __func__);
- goto EXIT;
- }
- }
- break;
-
- case OMX_IndexParamStoreMetaDataBuffer:
- {
- StoreMetaDataInBuffersParams *pANBParams = (StoreMetaDataInBuffersParams *) ComponentParameterStructure;
- OMX_U32 portIndex = pANBParams->nPortIndex;
- SEC_OMX_BASEPORT *pSECPort = NULL;
-
- SEC_OSAL_Log(SEC_LOG_TRACE, "%s: OMX_IndexParamStoreMetaDataBuffer", __func__);
-
- ret = SEC_OMX_Check_SizeVersion(pANBParams, sizeof(StoreMetaDataInBuffersParams));
- if (ret != OMX_ErrorNone) {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: SEC_OMX_Check_SizeVersion(StoreMetaDataInBuffersParams) is failed", __func__);
- goto EXIT;
- }
-
- if (portIndex >= pSECComponent->portParam.nPorts) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pSECPort = &pSECComponent->pSECPort[portIndex];
- if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
- ret = OMX_ErrorBadPortIndex;
- goto EXIT;
- }
-
- pSECPort->bStoreMetaData = pANBParams->bStoreMetaData;
- }
- break;
-
- default:
- {
- SEC_OSAL_Log(SEC_LOG_ERROR, "%s: Unsupported index (%d)", __func__, nIndex);
- ret = OMX_ErrorUnsupportedIndex;
- goto EXIT;
- }
- break;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-OMX_ERRORTYPE SEC_OSAL_GetInfoFromMetaData(OMX_IN SEC_OMX_DATA *pBuffer,
- OMX_OUT OMX_PTR *ppBuf)
-{
- OMX_ERRORTYPE ret = OMX_ErrorNone;
- MetadataBufferType type;
- buffer_handle_t pBufHandle;
-
- FunctionIn();
-
-/*
- * meta data contains the following data format.
- * payload depends on the MetadataBufferType
- * --------------------------------------------------------------
- * | MetadataBufferType | payload |
- * --------------------------------------------------------------
- *
- * If MetadataBufferType is kMetadataBufferTypeCameraSource, then
- * --------------------------------------------------------------
- * | kMetadataBufferTypeCameraSource | physical addr. of Y |physical addr. of CbCr |
- * --------------------------------------------------------------
- *
- * If MetadataBufferType is kMetadataBufferTypeGrallocSource, then
- * --------------------------------------------------------------
- * | kMetadataBufferTypeGrallocSource | buffer_handle_t |
- * --------------------------------------------------------------
- */
-
- /* MetadataBufferType */
- memcpy(&type, (MetadataBufferType *)(pBuffer->dataBuffer), sizeof(type));
-
- if (type == kMetadataBufferTypeCameraSource) {
- /* physical addr. of Y */
- ppBuf[0] = (OMX_PTR)(pBuffer->dataBuffer + sizeof(type));
- /* physical addr. of CbCr */
- ppBuf[1] = (OMX_PTR)(pBuffer->dataBuffer + sizeof(type) + sizeof(pBuffer->dataBuffer));
- } else if (type == kMetadataBufferTypeGrallocSource) {
- /* buffer_handle_t */
- memcpy(&pBufHandle, pBuffer->dataBuffer + sizeof(type), sizeof(buffer_handle_t));
- ppBuf[0] = (OMX_PTR)pBufHandle;
- }
-
-EXIT:
- FunctionOut();
-
- return ret;
-}
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Android.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Android.h
deleted file mode 100644
index 67029f5..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Android.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * 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 SEC_OSAL_Android.h
- * @brief
- * @author Seungbeom Kim (sbcrux.kim@samsung.com)
- * @author Hyeyeon Chung (hyeon.chung@samsung.com)
- * @author Yunji Kim (yunji.kim@samsung.com)
- * @author Jinsung Yang (jsgood.yang@samsung.com)
- * @version 1.1.0
- * @history
- * 2011.7.15 : Create
- */
-
-#ifndef SEC_OSAL_ANDROID
-#define SEC_OSAL_ANDROID
-
-#include "OMX_Types.h"
-#include "OMX_Core.h"
-#include "OMX_Index.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-OMX_ERRORTYPE SEC_OSAL_GetANBParameter(OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_INOUT OMX_PTR ComponentParameterStructure);
-
-OMX_ERRORTYPE SEC_OSAL_SetANBParameter(OMX_IN OMX_HANDLETYPE hComponent,
- OMX_IN OMX_INDEXTYPE nIndex,
- OMX_IN OMX_PTR ComponentParameterStructure);
-
-OMX_ERRORTYPE SEC_OSAL_LockANB(OMX_IN OMX_PTR pBuffer,
- OMX_IN OMX_U32 width,
- OMX_IN OMX_U32 height,
- OMX_IN OMX_COLOR_FORMATTYPE format,
- OMX_OUT OMX_U32 *pStride,
- OMX_OUT OMX_PTR *vaddr);
-
-OMX_ERRORTYPE SEC_OSAL_GetPhysANB(OMX_IN OMX_PTR pBuffer,
- OMX_OUT OMX_PTR *paddr);
-
-OMX_ERRORTYPE SEC_OSAL_UnlockANB(OMX_IN OMX_PTR pBuffer);
-
-OMX_ERRORTYPE SEC_OSAL_LockANBHandle(OMX_IN OMX_U32 pBuffer,
- OMX_IN OMX_U32 width,
- OMX_IN OMX_U32 height,
- OMX_IN OMX_COLOR_FORMATTYPE format,
- OMX_OUT OMX_PTR *vaddr);
-
-OMX_ERRORTYPE SEC_OSAL_UnlockANBHandle(OMX_IN OMX_U32 pBuffer);
-
-OMX_ERRORTYPE SEC_OSAL_GetPhysANBHandle(OMX_IN OMX_U32 pBuffer,
- OMX_OUT OMX_PTR *paddr);
-
-OMX_ERRORTYPE SEC_OSAL_GetInfoFromMetaData(OMX_IN SEC_OMX_DATA *pBuffer,
- OMX_OUT OMX_PTR *pOutBuffer);
-
-OMX_ERRORTYPE SEC_OSAL_CheckANB(OMX_IN SEC_OMX_DATA *pBuffer,
- OMX_OUT OMX_BOOL *bIsANBEnabled);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_ETC.c b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_ETC.c
deleted file mode 100644
index 2082368..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_ETC.c
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- *
- * 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.1.0
- * @history
- * 2010.7.15 : Create
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-
-#include "SEC_OSAL_Memory.h"
-#include "SEC_OSAL_ETC.h"
-#include "SEC_OSAL_Log.h"
-
-static struct timeval perfStart[PERF_ID_MAX+1], perfStop[PERF_ID_MAX+1];
-static unsigned long perfTime[PERF_ID_MAX+1], totalPerfTime[PERF_ID_MAX+1];
-static unsigned int perfFrameCount[PERF_ID_MAX+1], perfOver30ms[PERF_ID_MAX+1];
-
-#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_S32 SEC_OSAL_Strncmp(OMX_PTR str1, OMX_PTR str2, size_t num)
-{
- return strncmp(str1, str2, num);
-}
-
-OMX_PTR SEC_OSAL_Strcat(OMX_PTR dest, OMX_PTR src)
-{
- return strcat(dest, src);
-}
-
-OMX_PTR SEC_OSAL_Strncat(OMX_PTR dest, OMX_PTR src, size_t num)
-{
- return strncat(dest, src, num);
-}
-
-size_t SEC_OSAL_Strlen(const char *str)
-{
- return strlen(str);
-}
-
-static OMX_U32 MeasureTime(struct timeval *start, struct timeval *stop)
-{
- unsigned long sec, usec, time;
-
- sec = stop->tv_sec - start->tv_sec;
- if (stop->tv_usec >= start->tv_usec) {
- usec = stop->tv_usec - start->tv_usec;
- } else {
- usec = stop->tv_usec + 1000000 - start->tv_usec;
- sec--;
- }
-
- time = sec * 1000000 + (usec);
-
- return time;
-}
-
-void SEC_OSAL_PerfInit(PERF_ID_TYPE id)
-{
- memset(&perfStart[id], 0, sizeof(perfStart[id]));
- memset(&perfStop[id], 0, sizeof(perfStop[id]));
- perfTime[id] = 0;
- totalPerfTime[id] = 0;
- perfFrameCount[id] = 0;
- perfOver30ms[id] = 0;
-}
-
-void SEC_OSAL_PerfStart(PERF_ID_TYPE id)
-{
- gettimeofday(&perfStart[id], NULL);
-}
-
-void SEC_OSAL_PerfStop(PERF_ID_TYPE id)
-{
- gettimeofday(&perfStop[id], NULL);
-
- perfTime[id] = MeasureTime(&perfStart[id], &perfStop[id]);
- totalPerfTime[id] += perfTime[id];
- perfFrameCount[id]++;
-
- if (perfTime[id] > 30000)
- perfOver30ms[id]++;
-}
-
-OMX_U32 SEC_OSAL_PerfFrame(PERF_ID_TYPE id)
-{
- return perfTime[id];
-}
-
-OMX_U32 SEC_OSAL_PerfTotal(PERF_ID_TYPE id)
-{
- return totalPerfTime[id];
-}
-
-OMX_U32 SEC_OSAL_PerfFrameCount(PERF_ID_TYPE id)
-{
- return perfFrameCount[id];
-}
-
-int SEC_OSAL_PerfOver30ms(PERF_ID_TYPE id)
-{
- return perfOver30ms[id];
-}
-
-void SEC_OSAL_PerfPrint(OMX_STRING prefix, PERF_ID_TYPE id)
-{
- OMX_U32 perfTotal;
- int frameCount;
-
- frameCount = SEC_OSAL_PerfFrameCount(id);
- perfTotal = SEC_OSAL_PerfTotal(id);
-
- SEC_OSAL_Log(SEC_LOG_INFO, "%s Frame Count: %d", prefix, frameCount);
- SEC_OSAL_Log(SEC_LOG_INFO, "%s Avg Time: %.2f ms, Over 30ms: %d",
- prefix, (float)perfTotal / (float)(frameCount * 1000),
- SEC_OSAL_PerfOver30ms(id));
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_ETC.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_ETC.h
deleted file mode 100644
index 2275abb..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_ETC.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- *
- * 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.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_S32 SEC_OSAL_Strncmp(OMX_PTR str1, OMX_PTR str2, 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);
-
-/* perf */
-typedef enum _PERF_ID_TYPE {
- PERF_ID_CSC = 0,
- PERF_ID_DEC,
- PERF_ID_ENC,
- PERF_ID_USER,
- PERF_ID_MAX,
-} PERF_ID_TYPE;
-
-void SEC_OSAL_PerfInit(PERF_ID_TYPE id);
-void SEC_OSAL_PerfStart(PERF_ID_TYPE id);
-void SEC_OSAL_PerfStop(PERF_ID_TYPE id);
-OMX_U32 SEC_OSAL_PerfFrame(PERF_ID_TYPE id);
-OMX_U32 SEC_OSAL_PerfTotal(PERF_ID_TYPE id);
-OMX_U32 SEC_OSAL_PerfFrameCount(PERF_ID_TYPE id);
-int SEC_OSAL_PerfOver30ms(PERF_ID_TYPE id);
-void SEC_OSAL_PerfPrint(OMX_STRING prefix, PERF_ID_TYPE id);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Event.c b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Event.c
deleted file mode 100644
index 383b62c..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Event.c
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Event.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Event.h
deleted file mode 100644
index 8ae2eb5..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Event.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Library.c b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Library.c
deleted file mode 100644
index f400794..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Library.c
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Library.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Library.h
deleted file mode 100644
index 27ac42e..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Library.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Log.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Log.h
deleted file mode 100644
index d4f2617..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Log.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- *
- * 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.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_INFO,
- 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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Memory.c b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Memory.c
deleted file mode 100644
index bf5224d..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Memory.c
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Memory.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Memory.h
deleted file mode 100644
index fed5cac..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Memory.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- *
- * 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.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);
-OMX_PTR SEC_OSAL_Memmove(OMX_PTR dest, OMX_PTR src, OMX_S32 n);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
diff --git a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Mutex.c b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Mutex.c
deleted file mode 100644
index b8f7b79..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Mutex.c
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- *
- * 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.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) {
- SEC_OSAL_Free(mutex);
- 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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Mutex.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Mutex.h
deleted file mode 100644
index 2dd63bc..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Mutex.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Queue.c b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Queue.c
deleted file mode 100644
index 4ecd8dc..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Queue.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Queue.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Queue.h
deleted file mode 100644
index d1dee11..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Queue.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Semaphore.c b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Semaphore.c
deleted file mode 100644
index be9b9cb..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Semaphore.c
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- *
- * 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.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) {
- SEC_OSAL_Free(sema);
- 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;
- int semaVal = 0;
-
- if (sema == NULL)
- return OMX_ErrorBadParameter;
-
- if (sem_getvalue(sema, &semaVal) != 0)
- return OMX_ErrorUndefined;
-
- *val = (OMX_S32)semaVal;
-
- return OMX_ErrorNone;
-}
diff --git a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Semaphore.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Semaphore.h
deleted file mode 100644
index 431cba4..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Semaphore.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- *
- * 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.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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Thread.c b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Thread.c
deleted file mode 100644
index 730b4a9..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Thread.c
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- *
- * 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.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 <time.h>
-#include <unistd.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) {
- SEC_OSAL_Free(thread);
- *threadHandle = NULL;
- 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:
- SEC_OSAL_Free(thread);
- *threadHandle = NULL;
- ret = OMX_ErrorInsufficientResources;
- break;
- default:
- SEC_OSAL_Free(thread);
- *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/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Thread.h b/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Thread.h
deleted file mode 100644
index ce1262d..0000000
--- a/exynos4/multimedia/openmax/sec_omx/osal/SEC_OSAL_Thread.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- *
- * 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.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