diff options
Diffstat (limited to 'exynos4/multimedia/codecs/sec_codecs')
43 files changed, 12837 insertions, 0 deletions
diff --git a/exynos4/multimedia/codecs/sec_codecs/Android.mk b/exynos4/multimedia/codecs/sec_codecs/Android.mk new file mode 100644 index 0000000..6571161 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/Android.mk @@ -0,0 +1 @@ +include $(all-subdir-makefiles) diff --git a/exynos4/multimedia/codecs/sec_codecs/audio/Android.mk b/exynos4/multimedia/codecs/sec_codecs/audio/Android.mk new file mode 100644 index 0000000..3bc3577 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/Android.mk @@ -0,0 +1,11 @@ +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 new file mode 100644 index 0000000..df938be --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/Android.mk @@ -0,0 +1,14 @@ +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 new file mode 100644 index 0000000..7393f68 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/Android.mk @@ -0,0 +1,26 @@ +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 new file mode 100644 index 0000000..ad65b90 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_api.h @@ -0,0 +1,52 @@ +#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 new file mode 100644 index 0000000..7f79452 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_error.h @@ -0,0 +1,22 @@ +#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 new file mode 100644 index 0000000..21d55df --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/include/srp_ioctl.h @@ -0,0 +1,23 @@ +#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 new file mode 100644 index 0000000..56125fb --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/alp/src/srp_api.c @@ -0,0 +1,265 @@ +#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 new file mode 100644 index 0000000..8450845 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/libsa_jni/Android.mk @@ -0,0 +1,13 @@ +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 new file mode 100644 index 0000000..6b99dc3 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/libsa_jni/SACtrl.c @@ -0,0 +1,33 @@ +#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 new file mode 100644 index 0000000..5b1d397 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/Android.mk @@ -0,0 +1,23 @@ +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 new file mode 100644 index 0000000..74598e5 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_api.h @@ -0,0 +1,55 @@ +#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 new file mode 100644 index 0000000..3b17acf --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_api_ctrl.h @@ -0,0 +1,25 @@ +#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 new file mode 100644 index 0000000..a20b1ac --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/include/srp_ioctl.h @@ -0,0 +1,66 @@ +#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 new file mode 100644 index 0000000..b0c0e5e --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/src/srp_api.c @@ -0,0 +1,381 @@ +#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 new file mode 100644 index 0000000..bdc2310 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos4/srp/ulp/src/srp_api_ctrl.c @@ -0,0 +1,331 @@ +#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 new file mode 100644 index 0000000..4b113e7 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/Android.mk @@ -0,0 +1,9 @@ +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 new file mode 100644 index 0000000..7393f68 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/Android.mk @@ -0,0 +1,26 @@ +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 new file mode 100644 index 0000000..ad65b90 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_api.h @@ -0,0 +1,52 @@ +#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 new file mode 100644 index 0000000..7f79452 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_error.h @@ -0,0 +1,22 @@ +#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 new file mode 100644 index 0000000..21d55df --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/include/srp_ioctl.h @@ -0,0 +1,23 @@ +#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 new file mode 100644 index 0000000..56125fb --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/audio/exynos5/srp/alp/src/srp_api.c @@ -0,0 +1,265 @@ +#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 new file mode 100644 index 0000000..3bc3577 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/Android.mk @@ -0,0 +1,11 @@ +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 new file mode 100644 index 0000000..1a8c419 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/Android.mk @@ -0,0 +1,11 @@ +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 new file mode 100644 index 0000000..b23f603 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/Android.mk @@ -0,0 +1,38 @@ +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 new file mode 100644 index 0000000..5cc7c88 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/dec/src/SsbSipMfcDecAPI.c @@ -0,0 +1,1165 @@ +/* + * 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 new file mode 100644 index 0000000..4b9df6c --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/enc/src/SsbSipMfcEncAPI.c @@ -0,0 +1,865 @@ +/* + * 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_output_mode = mpeg4_arg->OutputMode; + + 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_output_mode = FRAME; /* not support to slice output mode */ + + 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_output_mode = h264_arg->OutputMode; + + 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 new file mode 100644 index 0000000..fed3e34 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/SsbSipMfcApi.h @@ -0,0 +1,420 @@ +/* + * 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 new file mode 100644 index 0000000..305a28e --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/mfc_errno.h @@ -0,0 +1,79 @@ +/* + * 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 new file mode 100644 index 0000000..5212dc1 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc/include/mfc_interface.h @@ -0,0 +1,526 @@ +/* + * 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; + + SSBSIP_MFC_OUTSTRM_MODE_TYPE in_output_mode; + + 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 new file mode 100644 index 0000000..f135163 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/Android.mk @@ -0,0 +1,34 @@ +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 new file mode 100644 index 0000000..510a351 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/dec/src/SsbSipMfcDecAPI.c @@ -0,0 +1,1352 @@ +/* + * 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 new file mode 100644 index 0000000..45888c6 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/enc/src/SsbSipMfcEncAPI.c @@ -0,0 +1,1206 @@ +/* + * 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 new file mode 100644 index 0000000..b85256b --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/SsbSipMfcApi.h @@ -0,0 +1,382 @@ +/* + * 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 new file mode 100644 index 0000000..b8e96ab --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/mfc_errno.h @@ -0,0 +1,79 @@ +/* + * 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 new file mode 100644 index 0000000..b7289c4 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos4/mfc_v4l2/include/mfc_interface.h @@ -0,0 +1,541 @@ +/* + * 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 new file mode 100644 index 0000000..949c637 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/Android.mk @@ -0,0 +1,7 @@ +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 new file mode 100644 index 0000000..89f3e84 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/Android.mk @@ -0,0 +1,39 @@ +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 new file mode 100644 index 0000000..fb04587 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/dec/src/SsbSipMfcDecAPI.c @@ -0,0 +1,1740 @@ +/* + * 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 new file mode 100644 index 0000000..2333b6c --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/enc/src/SsbSipMfcEncAPI.c @@ -0,0 +1,1506 @@ +/* + * 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 new file mode 100644 index 0000000..b386c72 --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/SsbSipMfcApi.h @@ -0,0 +1,431 @@ +/* + * 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 new file mode 100644 index 0000000..b8e96ab --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/mfc_errno.h @@ -0,0 +1,79 @@ +/* + * 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 new file mode 100644 index 0000000..9bcee9d --- /dev/null +++ b/exynos4/multimedia/codecs/sec_codecs/video/exynos5/mfc_v4l2/include/mfc_interface.h @@ -0,0 +1,588 @@ +/* + * 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 */ |