From 3f48b15e4805cbf23549b0ca7af151bb16b4cfdc Mon Sep 17 00:00:00 2001 From: Showbo Zhang Date: Wed, 26 Aug 2015 04:36:00 +0000 Subject: init tv Change-Id: I485f1dc279c1583466ae73d4c84d251d216a44f1 --- diff --git a/Android.mk b/Android.mk index ef5af43..4e60584 100644 --- a/Android.mk +++ b/Android.mk @@ -6,10 +6,36 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) +DVB_PATH := $(wildcard vendor/amlogic/dvb) +TVAPI_PATH := $(LOCAL_PATH)/tvapi +LIB_SQLITE_PATH := $(wildcard external/sqlite) +AM_LIBPLAYER_PATH := $(wildcard vendor/amlogic/frameworks/av/LibPlayer) LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_SHARED_LIBRARIES := libcutils liblog LOCAL_SRC_FILES := tv_input.cpp LOCAL_MODULE := tv_input.amlogic LOCAL_MODULE_TAGS := optional +LOCAL_C_INCLUDES += \ + $(TVAPI_PATH)/libtv \ + $(TVAPI_PATH)/android \ + $(DVB_PATH)/android/ndk/include \ + $(DVB_PATH)/include/am_adp \ + $(DVB_PATH)/include/am_mw \ + $(DVB_PATH)/include/am_ver \ + $(DVB_PATH)/android/ndk/include \ + $(LIB_SQLITE_PATH)/dist \ + $(TVAPI_PATH)/libtv/tvdb \ + $(TVAPI_PATH)/libtv/tv \ + $(TVAPI_PATH)/libtv/include \ + $(AM_LIBPLAYER_PATH)/amadec/include \ + $(AM_LIBPLAYER_PATH)/amcodec/include \ + $(AM_LIBPLAYER_PATH)/amffmpeg \ + $(AM_LIBPLAYER_PATH)/amplayer \ + system/media/audio_effects/include \ + + +LOCAL_SHARED_LIBRARIES += \ + libtv \ + libtvserver include $(BUILD_SHARED_LIBRARY) diff --git a/tv_input.cpp b/tv_input.cpp index ea709de..822c7c8 100644 --- a/tv_input.cpp +++ b/tv_input.cpp @@ -22,7 +22,8 @@ #include #include - +#include +#include /*****************************************************************************/ #define ATV_DEV_ID 1 @@ -32,19 +33,20 @@ #define HDMI2_DEV_ID 5 #define HDMI3_DEV_ID 6 -typedef struct tv_input_private -{ +typedef struct tv_input_private { tv_input_device_t device; // Callback related data - const tv_input_callback_ops_t* callback; - void* callback_data; + const tv_input_callback_ops_t *callback; + void *callback_data; + //TvService* pTvService; + CTv *pTv; } tv_input_private_t; -static int notify_ATV_device_available(tv_input_private_t* priv) +static int notify_ATV_device_available(tv_input_private_t *priv) { - tv_input_event_t event; - event.device_info.device_id =ATV_DEV_ID; + tv_input_event_t event; + event.device_info.device_id = ATV_DEV_ID; event.device_info.type = TV_INPUT_TYPE_TUNER; event.type = TV_INPUT_EVENT_DEVICE_AVAILABLE; event.device_info.audio_type = AUDIO_DEVICE_NONE; @@ -52,10 +54,10 @@ static int notify_ATV_device_available(tv_input_private_t* priv) return 0; } -static int notify_DTV_device_available(tv_input_private_t* priv) +static int notify_DTV_device_available(tv_input_private_t *priv) { - tv_input_event_t event; - event.device_info.device_id =DTV_DEV_ID; + tv_input_event_t event; + event.device_info.device_id = DTV_DEV_ID; event.device_info.type = TV_INPUT_TYPE_TUNER; event.type = TV_INPUT_EVENT_DEVICE_AVAILABLE; event.device_info.audio_type = AUDIO_DEVICE_NONE; @@ -63,10 +65,10 @@ static int notify_DTV_device_available(tv_input_private_t* priv) return 0; } -static int notify_AV_device_available(tv_input_private_t* priv) +static int notify_AV_device_available(tv_input_private_t *priv) { - tv_input_event_t event; - event.device_info.device_id =AV_DEV_ID; + tv_input_event_t event; + event.device_info.device_id = AV_DEV_ID; event.device_info.type = TV_INPUT_TYPE_COMPONENT; event.type = TV_INPUT_EVENT_DEVICE_AVAILABLE; event.device_info.audio_type = AUDIO_DEVICE_NONE; @@ -74,10 +76,10 @@ static int notify_AV_device_available(tv_input_private_t* priv) return 0; } -static int notify_hdmi_device_available(tv_input_private_t* priv, int dev_id, uint32_t port_id) +static int notify_hdmi_device_available(tv_input_private_t *priv, int dev_id, uint32_t port_id) { - tv_input_event_t event; - event.device_info.device_id =dev_id; + tv_input_event_t event; + event.device_info.device_id = dev_id; event.device_info.type = TV_INPUT_TYPE_HDMI; event.type = TV_INPUT_EVENT_DEVICE_AVAILABLE; event.device_info.hdmi.port_id = port_id; @@ -86,144 +88,151 @@ static int notify_hdmi_device_available(tv_input_private_t* priv, int dev_id, ui return 0; } -static int get_stream_configs(int dev_id, int* num_configurations, const tv_stream_config_t** configs) +static int get_stream_configs(int dev_id, int *num_configurations, const tv_stream_config_t **configs) { - tv_stream_config_t* mconfig = (tv_stream_config_t*)malloc(sizeof(mconfig)); - if (!mconfig) { - return -1; - } - switch (dev_id) { - case ATV_DEV_ID: - mconfig->stream_id=ATV_DEV_ID; - mconfig->type =TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; - mconfig->max_video_width = 1920; - mconfig->max_video_height = 1080; - *num_configurations = 1; - *configs = mconfig; - break; - case DTV_DEV_ID: - mconfig->stream_id=DTV_DEV_ID; - mconfig->type =TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; - mconfig->max_video_width = 1920; - mconfig->max_video_height = 1080; - *num_configurations = 1; - *configs = mconfig; - break; - case AV_DEV_ID: - mconfig->stream_id=AV_DEV_ID; - mconfig->type =TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; - mconfig->max_video_width = 1920; - mconfig->max_video_height = 1080; - *num_configurations = 1; - *configs = mconfig; - break; - case HDMI1_DEV_ID: - mconfig->stream_id=HDMI1_DEV_ID; - mconfig->type =TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; - mconfig->max_video_width = 1920; - mconfig->max_video_height = 1080; - *num_configurations = 1; - *configs = mconfig; - break; - case HDMI2_DEV_ID: - mconfig->stream_id=HDMI2_DEV_ID; - mconfig->type =TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; - mconfig->max_video_width = 1920; - mconfig->max_video_height = 1080; - *num_configurations = 1; - *configs = mconfig; - break; - case HDMI3_DEV_ID: - mconfig->stream_id=HDMI3_DEV_ID; - mconfig->type =TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; - mconfig->max_video_width = 1920; - mconfig->max_video_height = 1080; - *num_configurations = 1; - *configs = mconfig; - break; - default: - break; - } - return 0; + tv_stream_config_t *mconfig = (tv_stream_config_t *)malloc(sizeof(mconfig)); + if (!mconfig) { + return -1; + } + switch (dev_id) { + case ATV_DEV_ID: + mconfig->stream_id = ATV_DEV_ID; + mconfig->type = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; + mconfig->max_video_width = 1920; + mconfig->max_video_height = 1080; + *num_configurations = 1; + *configs = mconfig; + break; + case DTV_DEV_ID: + mconfig->stream_id = DTV_DEV_ID; + mconfig->type = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; + mconfig->max_video_width = 1920; + mconfig->max_video_height = 1080; + *num_configurations = 1; + *configs = mconfig; + break; + case AV_DEV_ID: + mconfig->stream_id = AV_DEV_ID; + mconfig->type = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; + mconfig->max_video_width = 1920; + mconfig->max_video_height = 1080; + *num_configurations = 1; + *configs = mconfig; + break; + case HDMI1_DEV_ID: + mconfig->stream_id = HDMI1_DEV_ID; + mconfig->type = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; + mconfig->max_video_width = 1920; + mconfig->max_video_height = 1080; + *num_configurations = 1; + *configs = mconfig; + break; + case HDMI2_DEV_ID: + mconfig->stream_id = HDMI2_DEV_ID; + mconfig->type = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; + mconfig->max_video_width = 1920; + mconfig->max_video_height = 1080; + *num_configurations = 1; + *configs = mconfig; + break; + case HDMI3_DEV_ID: + mconfig->stream_id = HDMI3_DEV_ID; + mconfig->type = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE ; + mconfig->max_video_width = 1920; + mconfig->max_video_height = 1080; + *num_configurations = 1; + *configs = mconfig; + break; + default: + break; + } + return 0; } -static int tv_input_device_open(const struct hw_module_t* module, - const char* name, struct hw_device_t** device); +static int tv_input_device_open(const struct hw_module_t *module, + const char *name, struct hw_device_t **device); static struct hw_module_methods_t tv_input_module_methods = { - open: tv_input_device_open +open: + tv_input_device_open }; tv_input_module_t HAL_MODULE_INFO_SYM = { - common: { - tag: HARDWARE_MODULE_TAG, +common: + { +tag: + HARDWARE_MODULE_TAG, version_major: 0, version_minor: 1, - id: TV_INPUT_HARDWARE_MODULE_ID, - name: "TVInput module", - author: "Amlogic", - methods: &tv_input_module_methods, +id: + TV_INPUT_HARDWARE_MODULE_ID, +name: "TVInput module" + , +author: "Amlogic" + , +methods: + &tv_input_module_methods, } }; /*****************************************************************************/ -static int tv_input_initialize(struct tv_input_device* dev, - const tv_input_callback_ops_t* callback, void* data) +static int tv_input_initialize(struct tv_input_device *dev, + const tv_input_callback_ops_t *callback, void *data) { if (dev == NULL || callback == NULL) { return -EINVAL; } - tv_input_private_t* priv = (tv_input_private_t*)dev; + tv_input_private_t *priv = (tv_input_private_t *)dev; if (priv->callback != NULL) { return -EEXIST; } priv->callback = callback; priv->callback_data = data; -/* ATV_DEVICE_AVAILABLE */ - notify_ATV_device_available(priv); -/* DTV_DEVICE_AVAILABLE */ - notify_DTV_device_available(priv); -/* AV_DEVICE_AVAILABLE */ - notify_AV_device_available(priv); -/* HDMI1_DEVICE_AVAILABLE */ - notify_hdmi_device_available(priv, HDMI1_DEV_ID, 1); -/* HDMI2_DEVICE_AVAILABLE */ - notify_hdmi_device_available(priv, HDMI2_DEV_ID, 2); -/* HDMI3_DEVICE_AVAILABLE */ - notify_hdmi_device_available(priv, HDMI3_DEV_ID, 3); + /* ATV_DEVICE_AVAILABLE */ + notify_ATV_device_available(priv); + /* DTV_DEVICE_AVAILABLE */ + notify_DTV_device_available(priv); + /* AV_DEVICE_AVAILABLE */ + notify_AV_device_available(priv); + /* HDMI1_DEVICE_AVAILABLE */ + notify_hdmi_device_available(priv, HDMI1_DEV_ID, 1); + /* HDMI2_DEVICE_AVAILABLE */ + notify_hdmi_device_available(priv, HDMI2_DEV_ID, 2); + /* HDMI3_DEVICE_AVAILABLE */ + notify_hdmi_device_available(priv, HDMI3_DEV_ID, 3); return 0; } -static int tv_input_get_stream_configurations(const struct tv_input_device* dev, - int device_id, int* num_configurations, - const tv_stream_config_t** configs) +static int tv_input_get_stream_configurations(const struct tv_input_device *dev, + int device_id, int *num_configurations, + const tv_stream_config_t **configs) { - if (get_stream_configs(device_id, num_configurations, configs) == 0) { - return 0; - } + if (get_stream_configs(device_id, num_configurations, configs) == 0) { + return 0; + } return -EINVAL; } -static int tv_input_open_stream(struct tv_input_device*, int, tv_stream_t*) +static int tv_input_open_stream(struct tv_input_device *, int, tv_stream_t *) { return -EINVAL; } -static int tv_input_close_stream(struct tv_input_device*, int, int) +static int tv_input_close_stream(struct tv_input_device *, int, int) { return -EINVAL; } static int tv_input_request_capture( - struct tv_input_device*, int, int, buffer_handle_t, uint32_t) + struct tv_input_device *, int, int, buffer_handle_t, uint32_t) { return -EINVAL; } -static int tv_input_cancel_capture(struct tv_input_device*, int, int, uint32_t) +static int tv_input_cancel_capture(struct tv_input_device *, int, int, uint32_t) { return -EINVAL; } @@ -232,7 +241,10 @@ static int tv_input_cancel_capture(struct tv_input_device*, int, int, uint32_t) static int tv_input_device_close(struct hw_device_t *dev) { - tv_input_private_t* priv = (tv_input_private_t*)dev; + tv_input_private_t *priv = (tv_input_private_t *)dev; + if (priv->pTv != NULL) { + delete priv->pTv; + } if (priv) { free(priv); } @@ -241,25 +253,27 @@ static int tv_input_device_close(struct hw_device_t *dev) /*****************************************************************************/ -static int tv_input_device_open(const struct hw_module_t* module, - const char* name, struct hw_device_t** device) +static int tv_input_device_open(const struct hw_module_t *module, + const char *name, struct hw_device_t **device) { int status = -EINVAL; if (!strcmp(name, TV_INPUT_DEFAULT_DEVICE)) { - tv_input_private_t* dev = (tv_input_private_t*)malloc(sizeof(*dev)); + tv_input_private_t *dev = (tv_input_private_t *)malloc(sizeof(*dev)); /* initialize our state here */ memset(dev, 0, sizeof(*dev)); - + /*intialize tv*/ + dev->pTv = new CTv(); + TvService::instantiate(dev->pTv); /* initialize the procs */ dev->device.common.tag = HARDWARE_DEVICE_TAG; dev->device.common.version = TV_INPUT_DEVICE_API_VERSION_0_1; - dev->device.common.module = const_cast(module); + dev->device.common.module = const_cast(module); dev->device.common.close = tv_input_device_close; dev->device.initialize = tv_input_initialize; dev->device.get_stream_configurations = - tv_input_get_stream_configurations; + tv_input_get_stream_configurations; dev->device.open_stream = tv_input_open_stream; dev->device.close_stream = tv_input_close_stream; dev->device.request_capture = tv_input_request_capture; diff --git a/tvapi/Android.mk b/tvapi/Android.mk new file mode 100644 index 0000000..5053e7d --- a/dev/null +++ b/tvapi/Android.mk @@ -0,0 +1 @@ +include $(call all-subdir-makefiles) diff --git a/tvapi/android/Android.mk b/tvapi/android/Android.mk new file mode 100644 index 0000000..5053e7d --- a/dev/null +++ b/tvapi/android/Android.mk @@ -0,0 +1 @@ +include $(call all-subdir-makefiles) diff --git a/tvapi/android/include/ITv.h b/tvapi/android/include/ITv.h new file mode 100644 index 0000000..2fd6f6d --- a/dev/null +++ b/tvapi/android/include/ITv.h @@ -0,0 +1,51 @@ +#ifndef ANDROID_AMLOGIC_ITV_H +#define ANDROID_AMLOGIC_ITV_H + +#include +#include +#include +#include +#include +#include + +using namespace android; + +class ITvClient; + +class ITv: public IInterface +{ +public: + DECLARE_META_INTERFACE(Tv); + + virtual void disconnect() = 0; + + // connect new client with existing tv remote + virtual status_t connect(const sp &client) = 0; + + // prevent other processes from using this ITv interface + virtual status_t lock() = 0; + + // allow other processes to use this ITv interface + virtual status_t unlock() = 0; + + virtual status_t processCmd(const Parcel &p, Parcel *r) = 0; + + //share mem for subtitle bmp + virtual status_t createSubtitle(const sp &share_mem) = 0; + //share mem for video/hdmi bmp + virtual status_t createVideoFrame(const sp &share_mem) = 0; + +}; + +// ---------------------------------------------------------------------------- + +class BnTv: public BnInterface +{ +public: + virtual status_t onTransact( uint32_t code, + const Parcel &data, + Parcel *reply, + uint32_t flags = 0); +}; + +#endif diff --git a/tvapi/android/include/ITvClient.h b/tvapi/android/include/ITvClient.h new file mode 100644 index 0000000..fcebd6c --- a/dev/null +++ b/tvapi/android/include/ITvClient.h @@ -0,0 +1,30 @@ +#ifndef ANDROID_AMLOGIC_ITV_CLIENT_H +#define ANDROID_AMLOGIC_ITV_CLIENT_H + +#include +#include +#include +#include +#include + +using namespace android; + +class ITvClient: public IInterface +{ +public: + DECLARE_META_INTERFACE(TvClient); + + virtual void notifyCallback(int32_t msgType, const Parcel &p) = 0; +}; + + +class BnTvClient: public BnInterface +{ +public: + virtual status_t onTransact(uint32_t code, + const Parcel &data, + Parcel *reply, + uint32_t flags = 0); +}; + +#endif diff --git a/tvapi/android/include/ITvService.h b/tvapi/android/include/ITvService.h new file mode 100644 index 0000000..cd0d366 --- a/dev/null +++ b/tvapi/android/include/ITvService.h @@ -0,0 +1,35 @@ +#ifndef ANDROID_AMLOGIC_ITVSERVICE_H +#define ANDROID_AMLOGIC_ITVSERVICE_H + +#include +#include +#include +#include +#include + +using namespace android; + + +class ITvService : public IInterface +{ +public: + enum { + CONNECT = IBinder::FIRST_CALL_TRANSACTION, + }; + +public: + DECLARE_META_INTERFACE(TvService); + + virtual sp connect(const sp &tvClient) = 0; +}; + +class BnTvService: public BnInterface +{ +public: + virtual status_t onTransact(uint32_t code, + const Parcel &data, + Parcel *reply, + uint32_t flags = 0); +}; + +#endif diff --git a/tvapi/android/include/Tv.h b/tvapi/android/include/Tv.h new file mode 100644 index 0000000..ed6b324 --- a/dev/null +++ b/tvapi/android/include/Tv.h @@ -0,0 +1,82 @@ +#ifndef ANDROID_AMLOGIC_TV_H +#define ANDROID_AMLOGIC_TV_H + +#include +#include +#include +#include +#include + +using namespace android; + +class ITvService; +class ITv; + +// ref-counted object for callbacks +class TvListener: virtual public RefBase +{ +public: + virtual void notify(int32_t msgType, const Parcel &ext) = 0; +}; + +class Tv : public BnTvClient, public IBinder::DeathRecipient +{ +public: + // construct a tv client from an existing remote + static sp create(const sp &tv); + static sp connect(); + ~Tv(); + void init(); + status_t reconnect(); + void disconnect(); + status_t lock(); + status_t unlock(); + + status_t getStatus() + { + return mStatus; + } + status_t processCmd(const Parcel &p, Parcel *r); + status_t createSubtitle(const sp &share_mem); + status_t createVideoFrame(const sp &share_mem); + void setListener(const sp &listener); + + // ITvClient interface + virtual void notifyCallback(int32_t msgType, const Parcel &p); + + sp remote(); + +private: + Tv(); + Tv(const Tv &); + Tv &operator = (const Tv); + virtual void binderDied(const wp &who); + + class DeathNotifier: public IBinder::DeathRecipient + { + public: + DeathNotifier() {} + virtual void binderDied(const wp &who); + }; + + static sp mDeathNotifier; + + // helper function to obtain tv service handle + static const sp &getTvService(); + + sp mTv; + status_t mStatus; + + sp mListener; + + friend class DeathNotifier; + + static Mutex mLock; + static sp mTvService; + + sp mBmpMemHeap; + sp mBmpMemBase; +}; + + +#endif diff --git a/tvapi/android/include/tvcmd.h b/tvapi/android/include/tvcmd.h new file mode 100644 index 0000000..a105926 --- a/dev/null +++ b/tvapi/android/include/tvcmd.h @@ -0,0 +1,594 @@ +#ifndef ANDROID_AMLOGIC_TVCMD_H +#define ANDROID_AMLOGIC_TVCMD_H + +enum tvcmd_e { + // Tv function + OPEN_TV = 1, + CLOSE_TV = 2, + START_TV = 3, + STOP_TV = 4, + GET_TV_STATUS = 5, + GET_LAST_SOURCE_INPUT = 6, + GET_CURRENT_SOURCE_INPUT = 7, + GET_CURRENT_SOURCE_INPUT_TYPE = 8, + GET_CURRENT_SIGNAL_INFO = 9, + IS_SOURCE_SWTICH_DONE = 10, + SET_SOURCE_INPUT = 11, + RUN_ADC_AUTO_CALIBRATION = 12, + IS_DVI_SIGNAL = 13, + IS_VGA_TIMEING_IN_HDMI = 14, + GET_VIDEO_PATH_STATUS = 15, + GET_VIDEO_STREAM_STATUS = 16, + GET_FIRST_START_SWITCH_TYPE = 17, + SET_PREVIEW_WINDOW = 18, + GET_SOURCE_CONNECT_STATUS = 19, + //Tv function END + + // VGA + RUN_VGA_AUTO_ADJUST = 20, + GET_VGA_AUTO_ADJUST_STATUS = 21, + IS_VGA_AUTO_ADJUST_DONE = 22, + SET_VGA_HPOS = 23, + GET_VGA_HPOS = 24, + SET_VGA_VPOS = 25, + GET_VGA_VPOS = 26, + SET_VGA_CLOCK = 27, + GET_VGA_CLOCK = 28, + SET_VGA_PHASE = 29, + GET_VGA_PHASE = 30, + SET_VGA_AJUST_PARA = 31, + GET_VGA_AJUST_PARA = 32, + SET_VGAPARAM_DEFAULT = 33, + + // 3D + SET_3D_MODE = 61, + GET_3D_MODE = 62, + SET_3D_LR_SWITH = 63, + GET_3D_LR_SWITH = 64, + SET_3D_TO_2D_MODE = 65, + GET_3D_TO_2D_MODE = 66, + SET_3D_DEPTH = 67, + GET_3D_DEPTH = 68, + GET_3D_AUTO_DETECT = 69, + SET_3D_AUTO_DETECT = 70, + // 3D END + + //Screen related + SET_VIDEO_DISABLE = 80, + + // PQ + SET_SCENEMODE = 192, + GET_SCENEMODE = 193, + SET_BRIGHTNESS = 194, + GET_BRIGHTNESS = 195, + SAVE_BRIGHTNESS = 196, + SET_CONTRAST = 197, + GET_CONTRAST = 198, + SAVE_CONTRAST = 199, + SET_SATUATION = 200, + GET_SATUATION = 201, + SAVE_SATUATION = 202, + SET_HUE = 203, + GET_HUE = 204, + SAVE_HUE = 205, + SET_PQMODE = 206, + GET_PQMODE = 207, + SAVE_PQMODE = 208, + SET_SHARPNESS = 209, + GET_SHARPNESS = 210, + SAVE_SHARPNESS = 211, + SET_BACKLIGHT = 212, + GET_BACKLIGHT = 213, + SAVE_BACKLIGHT = 214, + SET_COLOR_MODE = 215, + GET_COLOR_MODE = 216, + SAVE_COLOR_MODE = 217, + SET_COLOR_TEMPERATURE = 218, + GET_COLOR_TEMPERATURE = 219, + SAVE_COLOR_TEMPERATURE = 220, + SET_DISPLAY_MODE = 221, + GET_DISPLAY_MODE = 222, + SAVE_DISPLAY_MODE = 223, + SET_NOISE_REDUCTION_MODE = 224, + GET_NOISE_REDUCTION_MODE = 225, + SAVE_NOISE_REDUCTION_MODE = 226, + SETRGBOGO_POSTOFFSET = 227, + //SETRGBOGO_POSTOFFSET_G = 228, + //SETRGBOGO_POSTOFFSET_B = 229, + SETRGBOGO_GAIN = 230, + //SETRGBOGO_GAIN_G = 231, + //SETRGBOGO_GAIN_B = 232, + GETRGBOGO_POSTOFFSET = 233, + //GETRGBOGO_POSTOFFSET_G = 234, + //GETRGBOGO_POSTOFFSET_B = 235, + GETRGBOGO_GAIN = 236, + //GETRGBOGO_GAIN_G = 237, + //GETRGBOGO_GAIN_B = 238, + + // FACTORY + FACTORY_SETPQMODE_BRIGHTNESS = 240, + FACTORY_GETPQMODE_BRIGHTNESS = 241, + FACTORY_SETPQMODE_CONTRAST = 242, + FACTORY_GETPQMODE_CONTRAST = 243, + FACTORY_SETPQMODE_SATURATION = 244, + FACTORY_GETPQMODE_SATURATION = 245, + FACTORY_SETPQMODE_HUE = 246, + FACTORY_GETPQMODE_HUE = 247, + FACTORY_SETPQMODE_SHARPNESS = 248, + FACTORY_GETPQMODE_SHARPNESS = 249, + FACTORY_SETCOLORTEMP_RGAIN = 250, + FACTORY_SAVECOLORTEMP_RGAIN = 251, + FACTORY_GETCOLORTEMP_RGAIN = 252, + FACTORY_SETCOLORTEMP_GGAIN = 253, + FACTORY_SAVECOLORTEMP_GGAIN = 254, + FACTORY_GETCOLORTEMP_GGAIN = 255, + FACTORY_SETCOLORTEMP_BGAIN = 256, + FACTORY_SAVECOLORTEMP_BGAIN = 257, + FACTORY_GETCOLORTEMP_BGAIN = 258, + FACTORY_SETCOLORTEMP_ROFFSET = 259, + FACTORY_SAVECOLORTEMP_ROFFSET = 260, + FACTORY_GETCOLORTEMP_ROFFSET = 261, + FACTORY_SETCOLORTEMP_GOFFSET = 262, + FACTORY_SAVECOLORTEMP_GOFFSET = 263, + FACTORY_GETCOLORTEMP_GOFFSET = 264, + FACTORY_SETCOLORTEMP_BOFFSET = 265, + FACTORY_SAVECOLORTEMP_BOFFSET = 266, + FACTORY_GETCOLORTEMP_BOFFSET = 267, + FACTORY_SETTESTPATTERN = 268, + FACTORY_GETTESTPATTERN = 269, + FACTORY_RESETPQMODE = 270, + FACTORY_RESETCOLORTEMP = 271, + FACTORY_RESETPAMAMSDEFAULT = 272, + FACTORY_SETDDRSSC = 273, + FACTORY_GETDDRSSC = 274, + FACTORY_SETLVDSSSC = 275, + FACTORY_GETLVDSSSC = 276, + FACTORY_SETNOLINEPARAMS = 277, + FACTORY_GETNOLINEPARAMS = 278, + FACTORY_SETOVERSCAN = 279, + FACTORY_GETOVERSCAN = 280, + FACTORY_SET_OUT_DEFAULT = 281, + FACTORY_GETGLOBALOGO_RGAIN = 282, + FACTORY_GETGLOBALOGO_GGAIN = 283, + FACTORY_GETGLOBALOGO_BGAIN = 284, + FACTORY_GETGLOBALOGO_ROFFSET = 285, + FACTORY_GETGLOBALOGO_GOFFSET = 286, + FACTORY_GETGLOBALOGO_BOFFSET = 287, + FACTORY_SETGLOBALOGO_RGAIN = 288, + FACTORY_SETGLOBALOGO_GGAIN = 289, + FACTORY_SETGLOBALOGO_BGAIN = 290, + FACTORY_SETGLOBALOGO_ROFFSET = 291, + FACTORY_SETGLOBALOGO_GOFFSET = 292, + FACTORY_SETGLOBALOGO_BOFFSET = 293, + FACTORY_CLEAN_ALL_TABLE_FOR_PROGRAM = 294, + + + // FACTORY END + + // AUDIO + // AUDIO MUTE + SET_AUDIO_MUTEKEY_STATUS = 301, + GET_AUDIO_MUTEKEY_STATUS = 302, + SET_AUDIO_FORCE_MUTE_STATUS = 303, + GET_AUDIO_FORCE_MUTE_STATUS = 304, + SET_AUDIO_AVOUT_MUTE_STATUS = 305, + GET_AUDIO_AVOUT_MUTE_STATUS = 306, + SET_AUDIO_SPDIF_MUTE_STATUS = 307, + GET_AUDIO_SPDIF_MUTE_STATUS = 308, + // AUDIO MASTER VOLUME + SET_AUDIO_MASTER_VOLUME = 309, + GET_AUDIO_MASTER_VOLUME = 310, + SAVE_CUR_AUDIO_MASTER_VOLUME = 311, + GET_CUR_AUDIO_MASTER_VOLUME = 312, + // AUDIO BALANCE + SET_AUDIO_BALANCE = 313, + GET_AUDIO_BALANCE = 314, + SAVE_CUR_AUDIO_BALANCE = 315, + GET_CUR_AUDIO_BALANCE = 316, + // AUDIO SUPPERBASS VOLUME + SET_AUDIO_SUPPER_BASS_VOLUME = 317, + GET_AUDIO_SUPPER_BASS_VOLUME = 318, + SAVE_CUR_AUDIO_SUPPER_BASS_VOLUME = 319, + GET_CUR_AUDIO_SUPPER_BASS_VOLUME = 320, + // AUDIO SUPPERBASS SWITCH + SET_AUDIO_SUPPER_BASS_SWITCH = 321, + GET_AUDIO_SUPPER_BASS_SWITCH = 322, + SAVE_CUR_AUDIO_SUPPER_BASS_SWITCH = 323, + GET_CUR_AUDIO_SUPPER_BASS_SWITCH = 324, + // AUDIO SRS SURROUND SWITCH + SET_AUDIO_SRS_SURROUND = 325, + GET_AUDIO_SRS_SURROUND = 326, + SAVE_CUR_AUDIO_SRS_SURROUND = 327, + GET_CUR_AUDIO_SRS_SURROUND = 328, + // AUDIO SRS DIALOG CLARITY + SET_AUDIO_SRS_DIALOG_CLARITY = 329, + GET_AUDIO_SRS_DIALOG_CLARITY = 330, + SAVE_CUR_AUDIO_SRS_DIALOG_CLARITY = 331, + GET_CUR_AUDIO_SRS_DIALOG_CLARITY = 332, + // AUDIO SRS TRUBASS + SET_AUDIO_SRS_TRU_BASS = 333, + GET_AUDIO_SRS_TRU_BASS = 334, + SAVE_CUR_AUDIO_SRS_TRU_BASS = 335, + GET_CUR_AUDIO_SRS_TRU_BASS = 336, + // AUDIO BASS + SET_AUDIO_BASS_VOLUME = 337, + GET_AUDIO_BASS_VOLUME = 338, + SAVE_CUR_AUDIO_BASS_VOLUME = 339, + GET_CUR_AUDIO_BASS_VOLUME = 340, + // AUDIO TREBLE + SET_AUDIO_TREBLE_VOLUME = 341, + GET_AUDIO_TREBLE_VOLUME = 342, + SAVE_CUR_AUDIO_TREBLE_VOLUME = 343, + GET_CUR_AUDIO_TREBLE_VOLUME = 344, + // AUDIO SOUND MODE + SET_AUDIO_SOUND_MODE = 345, + GET_AUDIO_SOUND_MODE = 346, + SAVE_CUR_AUDIO_SOUND_MODE = 347, + GET_CUR_AUDIO_SOUND_MODE = 348, + // AUDIO WALL EFFECT + SET_AUDIO_WALL_EFFECT = 349, + GET_AUDIO_WALL_EFFECT = 350, + SAVE_CUR_AUDIO_WALL_EFFECT = 351, + GET_CUR_AUDIO_WALL_EFFECT = 352, + // AUDIO EQ MODE + SET_AUDIO_EQ_MODE = 353, + GET_AUDIO_EQ_MODE = 354, + SAVE_CUR_AUDIO_EQ_MODE = 355, + GET_CUR_AUDIO_EQ_MODE = 356, + // AUDIO EQ GAIN + GET_AUDIO_EQ_RANGE = 357, + GET_AUDIO_EQ_BAND_COUNT = 358, + SET_AUDIO_EQ_GAIN = 359, + GET_AUDIO_EQ_GAIN = 360, + GET_CUR_EQ_GAIN = 361, + SAVE_CUR_AUDIO_EQ_GAIN = 362, + SET_AUDIO_EQ_SWITCH = 363, + // AUDIO SPDIF SWITCH + SET_AUDIO_SPDIF_SWITCH = 364, + GET_AUDIO_SPDIF_SWITCH = 365, + SAVE_CUR_AUDIO_SPDIF_SWITCH = 366, + GET_CUR_AUDIO_SPDIF_SWITCH = 367, + // AUDIO SPDIF MODE + SET_AUDIO_SPDIF_MODE = 368, + GET_AUDIO_SPDIF_MODE = 369, + SAVE_CUR_AUDIO_SPDIF_MODE = 370, + GET_CUR_AUDIO_SPDIF_MODE = 371, + // amAudio + OPEN_AMAUDIO = 372, + CLOSE_AMAUDIO = 373, + SET_AMAUDIO_INPUT_SR = 374, + SET_AMAUDIO_OUTPUT_MODE = 375, + SET_AMAUDIO_MUSIC_GAIN = 376, + SET_AMAUDIO_LEFT_GAIN = 377, + SET_AMAUDIO_RIGHT_GAIN = 378, + SET_AMAUDIO_REV1 = 379, + SET_AMAUDIO_REV2 = 380, + SET_AMAUDIO_REV3 = 381, + SET_AMAUDIO_REV4 = 382, + SET_AMAUDIO_REV5 = 383, + //AUDIO INPUT LEVEL SWITCH + SELECT_LINE_IN_CHANNEL = 384, + SET_LINE_IN_CAPTURE_VOL = 385, + HANDLE_AUDIO_HEADSET_PLUG_IN = 386, + HANDLE_AUDIO_HEADSET_PULL_OUT = 387, + SET_AUDIO_VOL_COMP = 388, + GET_AUDIO_VOL_COMP = 389, + SET_NOISE_GATE_THRESHOLD = 390, + SAVE_AUDIO_VOL_COMP = 391, + SET_KALAOK_IO_LEVEL = 392, + AUDIO_SET_DOUBLE_OUTPUT_ENABLE = 393, + USB_AUDIO_OUPUT_MODULE_ENABLE = 394, + GET_USB_AUDIO_DOUBLE_OUPUT_MODULE_ENABLE = 395, + GET_USB_AUDIO_OUPUT_MODULE_ENABLE = 396, + SET_AUDIO_SOURCE_FOR_KARAOKE = 397, + //AUDIO END + + // CALLBACK + SEARCH_CALLBACK = 501, + SIGLE_DETECT_CALLBACK = 502, + VGA_CALLBACK = 503, + DREAM_PANEL_CALLBACK = 504, + ADC_CALIBRATION_CALLBACK = 505, + SOURCE_SWITCH_CALLBACK = 506, + CHANNEL_SELECT_CALLBACK = 507, + STATUS_3D_CALLBACK = 508, + DTV_AV_PLAYBACK_CALLBACK = 509, + SOURCE_CONNECT_CALLBACK = 510, + HDMIRX_CEC_CALLBACK = 511, + SERIAL_COMMUNICATION_CALLBACK = 512, + CLOSE_CAPTION_CALLBACK = 514, + VCHIP_CALLBACK = 515, + UPGRADE_FBC_CALLBACK = 516, + HEADSET_STATUS_CALLBACK = 517, + + RELEASE_RESOURCE_CALLBACK = 530, + RESOURCES_STATE_CHANGED_CALLBACK = 531, + RESOURCE_STATE_CHANGED_LISTEN_NOFIFY_CALLBACK = 532, + + SUBTITLE_UPDATE_CALLBACK = 540, + SCAN_EVENT_CALLBACK = 541, + EPG_EVENT_CALLBACK = 542, + VFRAME_BMP_EVENT_CALLBACK = 543, + // CALLBACK END + + // SSM + SSM_INIT_DEVICE = 600, + SSM_SAVE_ONE_BYTE = 601, + SSM_READ_ONE_BYTE = 602, + SSM_SAVE_N_BYTES = 603, + SSM_READ_N_BYTES = 604, + SSM_SAVE_POWER_ON_OFF_CHANNEL = 605, + SSM_READ_POWER_ON_OFF_CHANNEL = 606, + SSM_SAVE_SOURCE_INPUT = 607, + SSM_READ_SOURCE_INPUT = 608, + SSM_SAVE_LAST_SOURCE_INPUT = 609, + SSM_READ_LAST_SOURCE_INPUT = 610, + SSM_SAVE_SYS_LANGUAGE = 611, + SSM_READ_SYS_LANGUAGE = 612, + SSM_SAVE_AGING_MODE = 613, + SSM_READ_AGING_MODE = 614, + SSM_SAVE_PANEL_TYPE = 615, + SSM_READ_PANEL_TYPE = 616, + SSM_SAVE_MAC_ADDR = 617, + SSM_READ_MAC_ADDR = 618, + SSM_SAVE_BAR_CODE = 619, + SSM_READ_BAR_CODE = 620, + SSM_SAVE_POWER_ON_MUSIC_SWITCH = 623, + SSM_READ_POWER_ON_MUSIC_SWITCH = 624, + SSM_SAVE_POWER_ON_MUSIC_VOL = 625, + SSM_READ_POWER_ON_MUSIC_VOL = 626, + SSM_SAVE_SYS_SLEEP_TIMER = 627, + SSM_READ_SYS_SLEEP_TIMER = 628, + SSM_SET_BUS_STATUS = 629, + SSM_GET_BUS_STATUS = 630, + SSM_SAVE_INPUT_SRC_PARENTAL_CTL = 631, + SSM_READ_INPUT_SRC_PARENTAL_CTL = 632, + SSM_SAVE_PARENTAL_CTL_SWITCH = 633, + SSM_READ_PARENTAL_CTL_SWITCH = 634, + SSM_SAVE_PARENTAL_CTL_PASS_WORD = 635, + SSM_READ_PARENTAL_CTL_PASS_WORD = 636, + SSM_SAVE_USING_DEF_HDCP_KEY_FLAG = 637, + SSM_READ_USING_DEF_HDCP_KEY_FLAG = 638, + SSM_GET_CUSTOMER_DATA_START = 639, + SSM_GET_CUSTOMER_DATA_LEN = 640, + SSM_SAVE_STANDBY_MODE = 641, + SSM_READ_STANDBY_MODE = 642, + SSM_SAVE_LOGO_ON_OFF_FLAG = 643, + SSM_READ_LOGO_ON_OFF_FLAG = 644, + SSM_SAVE_HDMIEQ_MODE = 645, + SSM_READ_HDMIEQ_MODE = 646, + SSM_SAVE_HDMIINTERNAL_MODE = 647, + SSM_READ_HDMIINTERNAL_MODE = 648, + SSM_SAVE_DISABLE_3D = 649, + SSM_READ_DISABLE_3D = 650, + SSM_SAVE_GLOBAL_OGOENABLE = 651, + SSM_READ_GLOBAL_OGOENABLE = 652, + SSM_SAVE_LOCAL_DIMING_STATUS = 653, + SSM_READ_LOCAL_DIMING_STATUS = 654, + SSM_SAVE_NON_STANDARD_STATUS = 655, + SSM_READ_NON_STANDARD_STATUS = 656, + SSM_SAVE_ADB_SWITCH_STATUS = 657, + SSM_READ_ADB_SWITCH_STATUS = 658, + SSM_SAVE_SERIAL_CMD_SWITCH_STATUS = 659, + SSM_READ_SERIAL_CMD_SWITCH_STATUS = 660, + SSM_SET_HDCP_KEY = 661, + SSM_SAVE_CHROMA_STATUS = 662, + SSM_SAVE_CA_BUFFER_SIZE = 663, + SSM_READ_CA_BUFFER_SIZE = 664, + SSM_GET_ATV_DATA_START = 665, + SSM_GET_ATV_DATA_LEN = 666, + SSM_GET_VPP_DATA_START = 667, + SSM_GET_VPP_DATA_LEN = 668, + SSM_SAVE_NOISE_GATE_THRESHOLD_STATUS = 669, + SSM_READ_NOISE_GATE_THRESHOLD_STATUS = 670, + SSM_SAVE_PROJECT_ID = 673, + SSM_READ_PROJECT_ID = 674, + SSM_SAVE_HDCPKEY = 675, + SSM_READ_HDCPKEY = 676, + SSM_READ_BLACKOUT_ENABLE = 677, + SSM_REFRESH_HDCPKEY = 678, + + // Misc + MISC_PROP_SET = 701, + MISC_PROP_GET = 702, + MISC_CFG_SET = 703, + MISC_CFG_GET = 704, + MISC_READ_ADC_VAL = 707, + MISC_SET_WDT_USER_PET = 708, + MISC_SET_WDT_USER_COUNTER = 709, + MISC_SET_WDT_USER_PET_RESET_ENABLE = 710, + MISC_GET_TV_API_VERSION = 713, + MISC_GET_DVB_API_VERSION = 714, + MISC_SERIAL_SWITCH = 715, + MISC_SERIAL_SEND_DATA = 716, + MISC_CHANNEL_EXPORT = 721, + MISC_CHANNEL_IMPORT = 722, + MISC_GET_PROJECT_INFO = 723, + MISC_GET_PLATFORM_TYPE = 724, + + //Extra + FORMAT_PARTITION = 801, + DELETE_DIR_FILES = 802, + REQUEST_RESOURCES = 803, + RELEASED_RESOURCES = 804, + SET_LISTEN_TO_RESOURCE = 805, + QUERY_RESOURCE_STATE = 806, + GET_DISPLAY_RESOLUTION_CONFIG = 808, + GET_DISPLAY_RESOLUTION_INFO = 809, + HDMIRX_CEC_SEND_CUSTOM_MESSAGE = 810, + HDMIRX_CEC_SEND_CUSTOM_WAIT_REPLY_MESSAGE = 811, + HDMIRX_CEC_SEND_BROADCAST_STANDBY_MESSAGE = 812, + HDMIRX_CEC_SEND_GIVE_CEC_VERSION_MESSAGE = 813, + HDMIRX_CEC_SEND_GIVE_DEV_VENDOR_ID_MESSAGE = 814, + HDMIRX_CEC_SEND_GIVE_OSD_NAME_MESSAGE = 815, + GET_HDMI_KSV_INFO = 816, + + //Fac_FBC + FACTORY_FBC_UPGRADE = 900, + FACTORY_FBC_SET_BRIGHTNESS = 901, + FACTORY_FBC_GET_BRIGHTNESS = 902, + FACTORY_FBC_SET_CONTRAST = 903, + FACTORY_FBC_GET_CONTRAST = 904, + FACTORY_FBC_SET_SATURATION = 905, + FACTORY_FBC_GET_SATURATION = 906, + FACTORY_FBC_SET_HUE = 907, + FACTORY_FBC_GET_HUE = 908, + FACTORY_FBC_SET_BACKLIGHT = 909, + FACTORY_FBC_GET_BACKLIGHT = 910, + FACTORY_FBC_SET_PIC_MODE = 911, + FACTORY_FBC_GET_PIC_MODE = 912, + FACTORY_FBC_SET_GAIN_RED = 913, + FACTORY_FBC_GET_GAIN_RED = 914, + FACTORY_FBC_SET_GAIN_GREEN = 915, + FACTORY_FBC_GET_GAIN_GREEN = 916, + FACTORY_FBC_SET_GAIN_BLUE = 917, + FACTORY_FBC_GET_GAIN_BLUE = 918, + FACTORY_FBC_SET_OFFSET_RED = 919, + FACTORY_FBC_GET_OFFSET_RED = 920, + FACTORY_FBC_SET_OFFSET_GREEN = 921, + FACTORY_FBC_GET_OFFSET_GREEN = 922, + FACTORY_FBC_SET_OFFSET_BLUE = 923, + FACTORY_FBC_GET_OFFSET_BLUE = 924, + FACTORY_FBC_SET_COLORTEMP_MODE = 925, + FACTORY_FBC_GET_COLORTEMP_MODE = 926, + FACTORY_FBC_SET_WB_INIT = 927, + FACTORY_FBC_GET_WB_INIT = 928, + FACTORY_FBC_SET_TEST_PATTERN = 929, + FACTORY_FBC_GET_TEST_PATTERN = 930, + FACTORY_FBC_SET_BACKLIGHT_EN = 931, + FACTORY_FBC_GET_BACKLIGHT_EN = 932, + FACTORY_FBC_SET_LVDS_SSG = 933, + FACTORY_FBC_SET_ELEC_MODE = 934, + FACTORY_FBC_GET_MAINCODE_VERSION = 935, + FACTORY_FBC_PANEL_POWER_SWITCH = 936, + FACTORY_FBC_PANEL_GET_INFO = 937, + FACTORY_FBC_PANEL_SUSPEND = 938, + FACTORY_FBC_SEND_KEY_TO_FBC = 939, + FACTORY_FBC_POWER_REBOOT = 940, + FACTORY_FBC_GET_ELEC_MODE = 941, + FACTORY_FBC_PANEL_USER_SETTING_DEFAULT = 942, + FACTORY_FBC_SET_BACKLIGHT_N360 = 943, + FACTORY_FBC_GET_BACKLIGHT_N360 = 944, + FACTORY_FBC_SET_COLORTEMP_MODE_N360 = 945, + FACTORY_FBC_GET_COLORTEMP_MODE_N360 = 946, + + //T868 for cvt + FACTORY_SETBACKLIGHT_PWM_FREQUENCY = 1000, + FACTORY_GETBACKLIGHT_PWM_FREQUENCY = 1001, + FACTORY_SETBACKLIGHT_SWITCH_STATUS = 1002, + FACTORY_GETBACKLIGHT_SWITCH_STATUS = 1003, + FACTORY_SETBACKLIGHT_PWM_DUTY = 1004, + FACTORY_GETBACKLIGHT_PWM_DUTY = 1005, + FACTORY_SETLVDS_COLOR_DEPTH = 1006, + FACTORY_GETLVDS_COLOR_DEPTH = 1007, + FACTORY_SETLVDS_DITHER_STATUS = 1008, + FACTORY_GETLVDS_DITHER_STATUS = 1009, + FACTORY_SETLVDS_MAPPING_STATUS = 1010, + FACTORY_GETLVDS_MAPPING_STATUS = 1011, + FACTORY_SETLVDS_PORT_SWAP_STATUS = 1012, + FACTORY_GETLVDS_PORT_SWAP_STATUS = 1013, + FACTORY_SET_SN = 1014, + FACTORY_GET_SN = 1015, + + //Uniform White Balance + FACTORY_WHITE_BALANCE_SET_GAIN_RED = 1100, + FACTORY_WHITE_BALANCE_GET_GAIN_RED = 1101, + FACTORY_WHITE_BALANCE_SET_GAIN_GREEN = 1102, + FACTORY_WHITE_BALANCE_GET_GAIN_GREEN = 1103, + FACTORY_WHITE_BALANCE_SET_GAIN_BLUE = 1104, + FACTORY_WHITE_BALANCE_GET_GAIN_BLUE = 1105, + FACTORY_WHITE_BALANCE_SET_OFFSET_RED = 1106, + FACTORY_WHITE_BALANCE_GET_OFFSET_RED = 1107, + FACTORY_WHITE_BALANCE_SET_OFFSET_GREEN = 1108, + FACTORY_WHITE_BALANCE_GET_OFFSET_GREEN = 1109, + FACTORY_WHITE_BALANCE_SET_OFFSET_BLUE = 1110, + FACTORY_WHITE_BALANCE_GET_OFFSET_BLUE = 1111, + FACTORY_WHITE_BALANCE_GET_COLOR_TMP = 1112, + FACTORY_WHITE_BALANCE_SET_COLOR_TMP = 1113, + FACTORY_WHITE_BALANCE_SAVE_PRAMAS = 1114, + FACTORY_WHITE_BALANCE_SET_WB_INIT = 1115, + FACTORY_WHITE_BALANCE_GET_WB_INIT = 1116, + FACTORY_WHITE_BALANCE_SET_GRAY_PATTERN = 1117, + FACTORY_WHITE_BALANCE_GET_GRAY_PATTERN = 1118, + FACTORY_WHITE_BALANCE_OPEN_GRAY_PATTERN = 1119, + FACTORY_WHITE_BALANCE_CLOSE_GRAY_PATTERN = 1120, + FACTORY_WHITE_BALANCE_GET_ALL_PRAMAS = 1121, + + //dtv + ATV_GET_CURRENT_PROGRAM_ID = 1389, + DTV_GET_CURRENT_PROGRAM_ID = 1390, + ATV_SAVE_PROGRAM_ID = 1391, + DTV_SCAN_MANUAL_BETWEEN_FREQ = 1392, + ATV_GET_MIN_MAX_FREQ = 1393, + DTV_GET_SCAN_FREQUENCY_LIST = 1394, + DTV_GET_CHANNEL_INFO = 1395, + ATV_GET_CHANNEL_INFO = 1396, + ATV_SCAN_MANUAL = 1397, + ATV_SCAN_MANUAL_BY_NUMBER = 1387, + ATV_SCAN_AUTO = 1398, + DTV_SCAN_MANUAL = 1399, + DTV_SCAN_AUTO = 1400, + TV_SUBTITLE_DRAW_END = 1401, + PLAY_PROGRAM = 1402, + STOP_PROGRAM_PLAY = 1403, + GET_PROGRAM_LIST = 1404, + STOP_SCAN = 1405, + DTV_GET_SNR = 1406, + DTV_GET_BER = 1407, + DTV_GET_STRENGTH = 1408, + DTV_GET_AUDIO_TRACK_NUM = 1409, + DTV_GET_AUDIO_TRACK_INFO = 1410, + DTV_SWITCH_AUDIO_TRACK = 1411, + DTV_GET_EPG_UTC_TIME = 1412, + DTV_GET_CUR_FREQ = 1413, + DTV_GET_EPG_INFO_POINT_IN_TIME = 1414, + DTV_GET_EPG_INFO_DURATION = 1415, + SET_FRONTEND_PARA = 1416, + DTV_SET_PROGRAM_NAME = 1417, + DTV_SET_PROGRAM_SKIPPED = 1418, + DTV_SET_PROGRAM_FAVORITE = 1419, + DTV_DETELE_PROGRAM = 1420, + DTV_SWAP_PROGRAM = 1421, + DTV_SET_PROGRAM_LOCKED = 1422, + DTV_SET_BOOKING_FLAG = 1423, + DTV_GET_BOOKED_EVENT = 1424, + DTV_GET_CURR_AUDIO_TRACK_INDEX = 1425, + DTV_SET_AUDIO_CHANNEL_MOD = 1426, + DTV_GET_AUDIO_CHANNEL_MOD = 1427, + DTV_GET_FREQ_BY_PROG_ID = 1428, + DTV_GET_VIDEO_FMT_INFO = 1429, + DTV_START_RECORD = 1430, + DTV_STOP_RECORD = 1431, + DTV_SET_RECORD_ALL_TS = 1432, + DTV_SCAN_AUTO_ATSC = 1433, + DTV_TEST_1 = 1451, + DTV_TEST_2 = 1452, + DTV_TEST_3 = 1453, + TV_CLEAR_ALL_PROGRAM = 1454, + SET_BLACKOUT_ENABLE = 1455, + START_AUTO_BACKLIGHT = 1456, + STOP_AUTO_BACKLIGHT = 1457, + IS_AUTO_BACKLIGHTING = 1458, + TV_PRINT_DEBUG_INFO = 2000, + + //customer interface + FACTROY_FBC_SET_LIGHT_SENSOR_STATUS_N310 = 3000, + FACTROY_FBC_GET_LIGHT_SENSOR_STATUS_N310 = 3001, + FACTROY_FBC_SET_DREAM_PANEL_STATUS_N310 = 3002, + FACTROY_FBC_GET_DREAM_PANEL_STATUS_N310 = 3003, + SSM_EEPROM_SAVE_ONE_BYTE_N310_N311 = 3004, + SSM_EEPROM_READ_ONE_BYTE_N310_N311 = 3005, + SSM_EEPROM_SAVE_N_BYTES_N310_N311 = 3006, + SSM_EEPROM_READ_N_BYTES_N310_N311 = 3007, + SSM_FLASH_SAVE_ONE_BYTE_N310_N311 = 3008, + SSM_FLASH_READ_ONE_BYTE_N310_N311 = 3009, + SSM_FLASH_SAVE_N_BYTES_N310_N311 = 3010, + SSM_FLASH_READ_N_BYTES_N310_N311 = 3011, + FACTROY_FBC_SET_MULT_PQ_STATUS_N310 = 3012, + FACTROY_FBC_GET_MULT_PQ_STATUS_N310 = 3013, + FACTROY_FBC_SET_MEMC_STATUS_N310 = 3014, + FACTROY_FBC_GET_MEMC_STATUS_N310 = 3015, + +}; + +#endif //ANDROID_AMLOGIC_TVCMD_H diff --git a/tvapi/android/jni/Android.mk b/tvapi/android/jni/Android.mk new file mode 100644 index 0000000..b1e2e3e --- a/dev/null +++ b/tvapi/android/jni/Android.mk @@ -0,0 +1,66 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES:= \ + android_amlogic_tv.cpp +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libutils \ + libbinder \ + libtvbinder \ + libnativehelper \ + libandroid_runtime \ + liblog \ + libskia + +LOCAL_C_INCLUDES += \ + frameworks/base/core/jni \ + $(LOCAL_PATH)/../ \ + external/skia/include \ + +LOCAL_MODULE:= libtv_jni +LOCAL_PRELINK_MODULE := false +include $(BUILD_SHARED_LIBRARY) + + + + +#cfbc communication jni lib +include $(CLEAR_VARS) +LOCAL_MODULE_TAGS := optional + +LOCAL_C_INCLUDES += \ + frameworks/base/core/jni \ + $(LOCAL_PATH)/../../libtv \ + $(LOCAL_PATH)/../../libtv/tv \ + bionic/libc/include \ + bionic/libc/private \ + system/extras/ext4_utils \ + bionic/libc/include + +LOCAL_SRC_FILES := \ + ../../libtv/tv/CTvLog.cpp \ + ../../libtv/tvutils/CFile.cpp \ + ../../libtv/tvutils/CThread.cpp \ + ../../libtv/tvutils/CMsgQueue.cpp \ + ../../libtv/tvutils/zepoll.cpp \ + ../../libtv/tv/CFbcCommunication.cpp \ + ../../libtv/tvutils/serial_base.cpp \ + ../../libtv/tvutils/CSerialPort.cpp \ + ../../libtv/tvutils/CHdmiCecCmd.cpp \ + cfbc_jni.cpp \ + cfbc_test.cpp + +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libutils \ + libandroid_runtime \ + liblog \ + libdl + +LOCAL_MODULE:= libcfbc_jni +LOCAL_PRELINK_MODULE := false +#include $(BUILD_EXECUTABLE) +#include $(BUILD_SHARED_LIBRARY) diff --git a/tvapi/android/jni/android_amlogic_tv.cpp b/tvapi/android/jni/android_amlogic_tv.cpp new file mode 100644 index 0000000..ec531ef --- a/dev/null +++ b/tvapi/android/jni/android_amlogic_tv.cpp @@ -0,0 +1,456 @@ +#define LOG_TAG "Tv-JNI" +#include + +#include "jni.h" +#include "JNIHelp.h" +#include "android_runtime/AndroidRuntime.h" +#include +#include +#include +#include +#include +#include +#include +#include "android_util_Binder.h" +#include "android_os_Parcel.h" +using namespace android; + +struct fields_t { + jfieldID context; + jmethodID post_event; +}; + +#ifdef LOG_TAG +#undef LOG_TAG +#define LOG_TAG "TvJNI" +#endif + +static fields_t fields; +static Mutex sLock; +class JNITvContext: public TvListener +{ +public: + JNITvContext(JNIEnv *env, jobject weak_this, jclass clazz, const sp &tv); + ~JNITvContext() + { + release(); + } + virtual void notify(int32_t msgType, const Parcel &p); + void addCallbackBuffer(JNIEnv *env, jbyteArray cbb); + sp getTv() + { + Mutex::Autolock _l(mLock); + return mTv; + } + void release(); + Parcel *mExtParcel; +private: + jobject mTvJObjectWeak; // weak reference to java object + jclass mTvJClass; // strong reference to java class + sp mTv; // strong reference to native object + Mutex mLock; + + Vector mCallbackBuffers; // Global reference application managed byte[] + bool mManualBufferMode; // Whether to use application managed buffers. + bool mManualTvCallbackSet; // Whether the callback has been set, used to reduce unnecessary calls to set the callback. +}; + +sp get_native_tv(JNIEnv *env, jobject thiz, JNITvContext **pContext) +{ + sp tv; + Mutex::Autolock _l(sLock); + JNITvContext *context = reinterpret_cast(env->GetIntField(thiz, fields.context)); + if (context != NULL) { + tv = context->getTv(); + } + if (tv == 0) { + jniThrowException(env, "java/lang/RuntimeException", "Method called after release()"); + } + + if (pContext != NULL) *pContext = context; + return tv; +} + +JNITvContext::JNITvContext(JNIEnv *env, jobject weak_this, jclass clazz, const sp &tv) +{ + mTvJObjectWeak = env->NewGlobalRef(weak_this); + mTvJClass = (jclass)env->NewGlobalRef(clazz); + mTv = tv; + ALOGD("tvjni----------------------JNITvContext::JNITvContext("); + mManualBufferMode = false; + mManualTvCallbackSet = false; + //mExtParcel = parcelForJavaObject(env, ext_parcel); +} + +void JNITvContext::release() +{ + ALOGD("release"); + Mutex::Autolock _l(mLock); + JNIEnv *env = AndroidRuntime::getJNIEnv(); + + if (mTvJObjectWeak != NULL) { + env->DeleteGlobalRef(mTvJObjectWeak); + mTvJObjectWeak = NULL; + } + if (mTvJClass != NULL) { + env->DeleteGlobalRef(mTvJClass); + mTvJClass = NULL; + } + mTv.clear(); +} + +// connect to tv service +static void android_amlogic_Tv_native_setup(JNIEnv *env, jobject thiz, jobject weak_this) +{ + sp tv = Tv::connect(); + + ALOGD("android_amlogic_Tv_native_setup."); + + if (tv == NULL) { + jniThrowException(env, "java/lang/RuntimeException", "Fail to connect to tv service"); + return; + } + + // make sure tv amlogic is alive + if (tv->getStatus() != NO_ERROR) { + jniThrowException(env, "java/lang/RuntimeException", "Tv initialization failed!"); + return; + } + + jclass clazz = env->GetObjectClass(thiz); + if (clazz == NULL) { + jniThrowException(env, "java/lang/RuntimeException", "Can't find android/amlogic/Tv!"); + return; + } + + sp context = new JNITvContext(env, weak_this, clazz, tv); + context->incStrong(thiz); + tv->setListener(context); + + env->SetIntField(thiz, fields.context, (int)context.get()); +} + + +static void android_amlogic_Tv_release(JNIEnv *env, jobject thiz) +{ + // TODO: Change to LOGE + JNITvContext *context = NULL; + sp tv; + { + Mutex::Autolock _l(sLock); + context = reinterpret_cast(env->GetIntField(thiz, fields.context)); + + // Make sure we do not attempt to callback on a deleted Java object. + env->SetIntField(thiz, fields.context, 0); + } + + ALOGD("release tv"); + + // clean up if release has not been called before + if (context != NULL) { + tv = context->getTv(); + context->release(); + ALOGD("native_release: context=%p tv=%p", context, tv.get()); + + // clear callbacks + if (tv != NULL) { + //tv->setPreviewCallbackFlags(FRAME_CALLBACK_FLAG_NOOP); + tv->disconnect(); + } + + // remove context to prevent further Java access + context->decStrong(thiz); + } +} + +void JNITvContext::notify(int32_t msgType, const Parcel &p) +{ + // VM pointer will be NULL if object is released + Mutex::Autolock _l(mLock); + if (mTvJObjectWeak == NULL) { + ALOGW("callback on dead tv object"); + return; + } + + JNIEnv *env = AndroidRuntime::getJNIEnv(); + + jobject jParcel = createJavaParcelObject(env); + if (jParcel != NULL) { + Parcel *nativeParcel = parcelForJavaObject(env, jParcel); + nativeParcel->write(p.data(), p.dataSize()); + env->CallStaticVoidMethod(mTvJClass, fields.post_event, mTvJObjectWeak, msgType, jParcel); + env->DeleteLocalRef(jParcel); + } +} + + +void JNITvContext::addCallbackBuffer(JNIEnv *env, jbyteArray cbb) +{ + if (cbb != NULL) { + Mutex::Autolock _l(mLock); + jbyteArray callbackBuffer = (jbyteArray)env->NewGlobalRef(cbb); + mCallbackBuffers.push(cbb); + ALOGD("Adding callback buffer to queue, %d total", mCallbackBuffers.size()); + } else { + ALOGE("Null byte array!"); + } +} + +static jint android_amlogic_Tv_processCmd(JNIEnv *env, jobject thiz, jobject pObj, jobject rObj) +{ + sp tv = get_native_tv(env, thiz, NULL); + if (tv == 0) return -1; + + Parcel *p = parcelForJavaObject(env, pObj); + //jclass clazz; + //clazz = env->FindClass("android/os/Parcel"); + //LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Parcel"); + + + //jmethodID mConstructor = env->GetMethodID(clazz, "", "(I)V"); + //jobject replayobj = env->NewObject(clazz, mConstructor, 0); + Parcel *r = parcelForJavaObject(env, rObj); + + + return tv->processCmd(*p, r); + //if ( != NO_ERROR) { + // jniThrowException(env, "java/lang/RuntimeException", "StartTv failed"); + // return -1; + // } + //return 0; +} + +static void android_amlogic_Tv_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes) +{ + JNITvContext *context = reinterpret_cast(env->GetIntField(thiz, fields.context)); + + ALOGD("addCallbackBuffer"); + if (context != NULL) { + context->addCallbackBuffer(env, bytes); + } +} + +static void android_amlogic_Tv_reconnect(JNIEnv *env, jobject thiz) +{ + sp tv = get_native_tv(env, thiz, NULL); + if (tv == 0) return; + + if (tv->reconnect() != NO_ERROR) { + jniThrowException(env, "java/io/IOException", "reconnect failed"); + return; + } +} + +static void android_amlogic_Tv_lock(JNIEnv *env, jobject thiz) +{ + sp tv = get_native_tv(env, thiz, NULL); + if (tv == 0) return; + + ALOGD("lock"); + + if (tv->lock() != NO_ERROR) { + jniThrowException(env, "java/lang/RuntimeException", "lock failed"); + } +} + +static void android_amlogic_Tv_unlock(JNIEnv *env, jobject thiz) +{ + sp tv = get_native_tv(env, thiz, NULL); + if (tv == 0) return; + + ALOGD("unlock"); + + if (tv->unlock() != NO_ERROR) { + jniThrowException(env, "java/lang/RuntimeException", "unlock failed"); + } +} + +static void android_amlogic_Tv_create_subtitle_bitmap(JNIEnv *env, jobject thiz, jobject bmpobj) +{ + ALOGD("create subtitle bmp"); + sp tv = get_native_tv(env, thiz, NULL); + if (tv == 0) return; + + //get skbitmap + jclass bmp_clazz; + jfieldID skbmp_fid; + jint hbmp; + bmp_clazz = env->FindClass("android/graphics/Bitmap"); + skbmp_fid = env->GetFieldID(bmp_clazz, "mNativeBitmap", "I"); + hbmp = env->GetIntField(bmpobj, skbmp_fid); + SkBitmap *pSkBmp = reinterpret_cast(hbmp); + ALOGD("pSkBmp = %d", hbmp); + ALOGD("bmp width = %d height = %d", pSkBmp->width(), pSkBmp->height()); + env->DeleteLocalRef(bmp_clazz); + + //alloc share mem + sp MemHeap = new MemoryHeapBase(1920 * 1080 * 4, 0, "subtitle bmp"); + ALOGD("heap id = %d", MemHeap->getHeapID()); + if (MemHeap->getHeapID() < 0) { + return; + } + sp MemBase = new MemoryBase(MemHeap, 0, 1920 * 1080 * 4); + pSkBmp->setPixels(MemBase->pointer()); + + + //send share mem to server + tv->createSubtitle(MemBase); + return; +} + +static void android_amlogic_Tv_create_video_frame_bitmap(JNIEnv *env, jobject thiz, jobject bmpobj ) +{ + ALOGD("create video frame bmp"); + sp tv = get_native_tv(env, thiz, NULL); + if (tv == 0) return; + + //get skbitmap + jclass bmp_clazz; + jfieldID skbmp_fid; + jint hbmp; + bmp_clazz = env->FindClass("android/graphics/Bitmap"); + skbmp_fid = env->GetFieldID(bmp_clazz, "mNativeBitmap", "I"); + hbmp = env->GetIntField(bmpobj, skbmp_fid); + SkBitmap *pSkBmp = reinterpret_cast(hbmp); + ALOGD("pSkBmp = %d", hbmp); + ALOGD("bmp width = %d height = %d", pSkBmp->width(), pSkBmp->height()); + env->DeleteLocalRef(bmp_clazz); + + //alloc share mem + sp MemHeap = new MemoryHeapBase(1280 * 720 * 4 + 1, 0, "video frame bmp"); + ALOGD("heap id = %d", MemHeap->getHeapID()); + if (MemHeap->getHeapID() < 0) { + return; + } + sp MemBase = new MemoryBase(MemHeap, 0, 1280 * 720 * 4 + 1); + pSkBmp->setPixels(MemBase->pointer()); + + + //send share mem to server + tv->createVideoFrame(MemBase); + return; +} + +//------------------------------------------------- + +static JNINativeMethod camMethods[] = { + { + "native_setup", + "(Ljava/lang/Object;)V", + (void *)android_amlogic_Tv_native_setup + }, + { + "native_release", + "()V", + (void *)android_amlogic_Tv_release + }, + { + "processCmd", + "(Landroid/os/Parcel;Landroid/os/Parcel;)I", + (void *)android_amlogic_Tv_processCmd + }, + { + "addCallbackBuffer", + "([B)V", + (void *)android_amlogic_Tv_addCallbackBuffer + }, + { + "reconnect", + "()V", + (void *)android_amlogic_Tv_reconnect + }, + { + "lock", + "()V", + (void *)android_amlogic_Tv_lock + }, + { + "unlock", + "()V", + (void *)android_amlogic_Tv_unlock + }, + { + "native_create_subtitle_bitmap", + "(Ljava/lang/Object;)V", + (void *)android_amlogic_Tv_create_subtitle_bitmap + }, + { + "native_create_video_frame_bitmap", + "(Ljava/lang/Object;)V", + (void *)android_amlogic_Tv_create_video_frame_bitmap + }, + +}; + +struct field { + const char *class_name; + const char *field_name; + const char *field_type; + jfieldID *jfield; +}; + +static int find_fields(JNIEnv *env, field *fields, int count) +{ + for (int i = 0; i < count; i++) { + field *f = &fields[i]; + jclass clazz = env->FindClass(f->class_name); + if (clazz == NULL) { + ALOGE("Can't find %s", f->class_name); + return -1; + } + + jfieldID field = env->GetFieldID(clazz, f->field_name, f->field_type); + if (field == NULL) { + ALOGE("Can't find %s.%s", f->class_name, f->field_name); + return -1; + } + + *(f->jfield) = field; + } + + return 0; +} + +// Get all the required offsets in java class and register native functions +int register_android_amlogic_Tv(JNIEnv *env) +{ + field fields_to_find[] = { + { "android/amlogic/Tv", "mNativeContext", "I", &fields.context } + }; + + ALOGD("register_android_amlogic_Tv."); + + if (find_fields(env, fields_to_find, NELEM(fields_to_find)) < 0) + return -1; + + jclass clazz = env->FindClass("android/amlogic/Tv"); + fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative", "(Ljava/lang/Object;ILandroid/os/Parcel;)V"); + if (fields.post_event == NULL) { + ALOGE("Can't find android/amlogic/Tv.postEventFromNative"); + return -1; + } + + // Register native functions + return AndroidRuntime::registerNativeMethods(env, "android/amlogic/Tv", camMethods, NELEM(camMethods)); +} + + +jint JNI_OnLoad(JavaVM *vm, void *reserved) +{ + JNIEnv *env = NULL; + jint result = -1; + + if (vm->GetEnv((void **) &env, JNI_VERSION_1_4) != JNI_OK) { + ALOGE("ERROR: GetEnv failed\n"); + goto bail; + } + assert(env != NULL); + + register_android_amlogic_Tv(env); + + /* success -- return valid version number */ + result = JNI_VERSION_1_4; +bail: + return result; +} + diff --git a/tvapi/android/jni/cfbc_jni.cpp b/tvapi/android/jni/cfbc_jni.cpp new file mode 100644 index 0000000..7ec7d86 --- a/dev/null +++ b/tvapi/android/jni/cfbc_jni.cpp @@ -0,0 +1,167 @@ +#include +#include +#include +#include +#include +#include +#include +#include "jni.h" +#include "JNIHelp.h" +#include "android_runtime/AndroidRuntime.h" +#include "tv/CFbcCommunication.h" + +#define TAG "joey_jni" +#define JNI_DBG(a...) __android_log_print(ANDROID_LOG_INFO, TAG, a) +#define MAX_CNT 128 + +static JNIEnv *jni_local_env = NULL; +static jclass jni_local_clz = NULL; +static jobject jni_local_obj = NULL; +static jmethodID jni_local_mid = NULL; +static JavaVM *m_vm = NULL; +static CFbcCommunication *g_cfbc_handle = NULL; + +JNIEnv *getJNIEnv(bool *needsDetach) +{ + JNIEnv *env = NULL; + jint result = -1; + if (m_vm->GetEnv((void **) &env, JNI_VERSION_1_4) != JNI_OK) { + __android_log_print(ANDROID_LOG_INFO, TAG, "ERROR: GetEnv failed\n"); + + int status = m_vm->AttachCurrentThread(&env, NULL); + if (status < 0) { + __android_log_print(ANDROID_LOG_INFO, TAG, "callback_handler: failed to attach current thread"); + return NULL; + } + + *needsDetach = true; + } + + __android_log_print(ANDROID_LOG_INFO, TAG, "GetEnv Success"); + return env; +} + +void detachJNI() +{ + int result = m_vm->DetachCurrentThread(); + if (result != JNI_OK) { + __android_log_print(ANDROID_LOG_INFO, TAG, "thread detach failed: %#x", result); + } +} + +//this data buf is same as cmd buf +void java_jni_callback(char *str, int cnt, int data_buf[]) +{ + char temp_str[MAX_CNT]; + int idx = 0; + if (str != NULL && cnt > 0) { + memset(temp_str, 0, sizeof(temp_str)); + JNI_DBG("java jni string is:\n%s, cnt:%d.", str, cnt); + //strcpy(temp_str, "Call From C/C++!"); + memcpy(temp_str, str, strlen(str) % MAX_CNT); + + if (NULL != jni_local_obj) { + bool needsDetach = false; + jint j_cnt = data_buf[1]; + jint j_data_buf[MAX_CNT]; + for (idx = 0; idx < j_cnt; idx++) { + idx %= MAX_CNT; + j_data_buf[idx] = data_buf[idx]; + JNI_DBG("java_jni_callback the %d data is:0x%x, %d.", idx, j_data_buf[idx], data_buf[idx]); + } + + //jobject obj; + jni_local_env = getJNIEnv(&needsDetach); + //obj = (*jni_local_env)->NewGlobalRef(jni_local_env,jni_local_obj); + jni_local_clz = jni_local_env->GetObjectClass(jni_local_obj); + //this func name and parameters should be same as the callback defined in java code + jni_local_mid = jni_local_env->GetMethodID(jni_local_clz, "android_java_callback", "(Ljava/lang/String;[I)I"); + + jstring str1 = jni_local_env->NewStringUTF(temp_str); + + jintArray cc_data_arr = jni_local_env->NewIntArray(j_cnt); + jni_local_env->SetIntArrayRegion(cc_data_arr, 0, cnt, j_data_buf); + //jint *temp_data = jni_local_env->GetIntArrayElements(cc_data_arr, NULL); + + jint cnt = jni_local_env->CallIntMethod(jni_local_obj, jni_local_mid, str1, cc_data_arr); + + //jni_local_env->ReleaseIntArrayElements(cc_data_arr, temp_data, 0); + //jni_local_env->ReleaseIntArrayElements(cc_cmd_arr, temp_cmd, 0); + JNI_DBG("%s %d be called.", __FUNCTION__, __LINE__); + + if (needsDetach) { + detachJNI(); + } + } + } +} + +//here we needn't to match the java package name +static jint jni_java_exec_cmd(JNIEnv *env, jobject obj, jintArray cmdArray) +{ + jint *arry = env->GetIntArrayElements(cmdArray, NULL); + jint length = env->GetArrayLength(cmdArray); + + int cmd_cnt = arry[1], idx = 0; + int cmd_array[MAX_CNT]; + memset(cmd_array, 0, sizeof(cmd_array)); + for (idx = 0; idx < cmd_cnt; idx++) + cmd_array[idx] = arry[idx]; + + JNI_DBG("%s %s %d be called.", __FILE__, __FUNCTION__, __LINE__); + + if (g_cfbc_handle == NULL) { + g_cfbc_handle = new CFbcCommunication(); + g_cfbc_handle->run("cfbc_thread", 0, 0); + } + + //g_cfbc_handle->handleCmd(COMM_DEV_CEC, cmd_array); + //c_exec_cmd(cmd_array); + + if (NULL == jni_local_obj) { + jni_local_obj = env->NewGlobalRef(obj); + } + +#if 0 + /* this is used to terminate the jni call if needed + ** and we should handle the pthread we create in c layer + */ + if (cmd_array[0] == 0x1002) { + if (NULL != jni_local_obj) + env->DeleteGlobalRef(jni_local_obj); + } +#endif + return 0; +} + +//the name of 'exec_cmd' should be same as the native func in java code +static JNINativeMethod gMethods[] = { + {"exec_cmd", "([I)I", (void *)jni_java_exec_cmd}, +}; + +static int register_android_MyFunc(JNIEnv *env) +{ + JNI_DBG("%s %s %d be called.", __FILE__, __FUNCTION__, __LINE__); + //the name below should be same as the class name in which native method declared in Java layer + return android::AndroidRuntime::registerNativeMethods(env, "com/fbc/MyFunc", gMethods, NELEM(gMethods)); +} + +jint JNI_OnLoad(JavaVM *vm, void *reserved) +{ + JNIEnv *env = NULL; + JNI_DBG("%s %s %d be called.", __FILE__, __FUNCTION__, __LINE__); + //c_set_callback(&java_jni_callback); + if (vm->GetEnv((void **)&env, JNI_VERSION_1_4) != JNI_OK) { + JNI_DBG("Error GetEnv\n"); + return -1; + } + + assert(env != NULL); + if (register_android_MyFunc(env) < 0) { + JNI_DBG("register_android_test_hdi error.\n"); + return -1; + } + + m_vm = vm; + return JNI_VERSION_1_4; +} diff --git a/tvapi/android/jni/cfbc_test.cpp b/tvapi/android/jni/cfbc_test.cpp new file mode 100644 index 0000000..ecba2e6 --- a/dev/null +++ b/tvapi/android/jni/cfbc_test.cpp @@ -0,0 +1,43 @@ +#include "stdlib.h" +#include "stdio.h" +#include "tv/CFbcCommunication.h" + +int main(int argc, char **argv) +{ + int idx = 0, send_buf[128], recv_buf[128], cmd_value = 1, run_flag = 0, run_cnt = 0, cmd_type = 0, read_flag = 0; + printf("run begin.......\n"); + if (argc < 4) { + printf("usage:./libcfbc_jni cmd_type cmd_value run_cnt(all hex mode)\n"); + return 0; + } + + cmd_type = strtol(argv[1], NULL, 16); + cmd_value = strtol(argv[2], NULL, 16); + run_cnt = strtol(argv[3], NULL, 16); + + CFbcCommunication *cfbcHandle = new CFbcCommunication(); + printf("to test.......\n"); + cfbcHandle->run(); + sleep(0.2); + + switch (cmd_type) { + default: + for (idx = 0; idx < run_cnt; idx++) { + memset(send_buf, 0, sizeof(send_buf)); + memset(recv_buf, 0, sizeof(recv_buf)); + send_buf[0] = cmd_type; + send_buf[1] = 3; + send_buf[2] = cmd_value; + printf("\n\n======%d to set value is:0x%02x\n", idx, cmd_value); + cfbcHandle->handleCmd(COMM_DEV_SERIAL, send_buf, recv_buf); + sleep(1); + } + break; + } + + printf("wait to exit......\n"); + cfbcHandle->requestExitAndWait(); + delete cfbcHandle; + printf("program exited\n"); + return 0; +} diff --git a/tvapi/android/libtvbinder/Android.mk b/tvapi/android/libtvbinder/Android.mk new file mode 100644 index 0000000..e7820a3 --- a/dev/null +++ b/tvapi/android/libtvbinder/Android.mk @@ -0,0 +1,24 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES:= \ + Tv.cpp \ + ITv.cpp \ + ITvClient.cpp \ + ITvService.cpp + +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libutils \ + libbinder \ + libui + +LOCAL_MODULE:= libtvbinder + +LOCAL_C_INCLUDES += \ + $(LOCAL_PATH)/../ + +LOCAL_PRELINK_MODULE := false +include $(BUILD_SHARED_LIBRARY) diff --git a/tvapi/android/libtvbinder/ITv.cpp b/tvapi/android/libtvbinder/ITv.cpp new file mode 100644 index 0000000..aa81345 --- a/dev/null +++ b/tvapi/android/libtvbinder/ITv.cpp @@ -0,0 +1,145 @@ +//#define LOG_NDEBUG 0 +#define LOG_TAG "ITv" +#include +#include +#include +#include +#include + +enum { + DISCONNECT = IBinder::FIRST_CALL_TRANSACTION, + START_PREVIEW, + SEND_COMMAND, + CONNECT, + LOCK, + UNLOCK, + TV_CMD, + TV_CREATE_SUBTITLE, + TV_CREATE_VIDEO_FRAME, +}; + +class BpTv: public BpInterface +{ +public: + BpTv(const sp &impl) + : BpInterface(impl) + { + } + + // disconnect from tv service + void disconnect() + { + Parcel data, reply; + data.writeInterfaceToken(ITv::getInterfaceDescriptor()); + remote()->transact(DISCONNECT, data, &reply); + } + + status_t processCmd(const Parcel &p, Parcel *r) + { + Parcel data, reply; + data.writeInterfaceToken(ITv::getInterfaceDescriptor()); + data.write(p.data(), p.dataSize()); + remote()->transact(TV_CMD, data, &reply); + r->write(reply.data(), reply.dataSize()); + r->setDataPosition(0); + return 0; + } + + virtual status_t createVideoFrame(const sp &share_mem) + { + Parcel data, reply; + data.writeInterfaceToken(ITv::getInterfaceDescriptor()); + data.writeStrongBinder(share_mem->asBinder()); + remote()->transact(TV_CREATE_VIDEO_FRAME, data, &reply); + return reply.readInt32(); + } + + virtual status_t createSubtitle(const sp &share_mem) + { + Parcel data, reply; + data.writeInterfaceToken(ITv::getInterfaceDescriptor()); + data.writeStrongBinder(share_mem->asBinder()); + remote()->transact(TV_CREATE_SUBTITLE, data, &reply); + return reply.readInt32(); + } + virtual status_t connect(const sp &tvClient) + { + Parcel data, reply; + data.writeInterfaceToken(ITv::getInterfaceDescriptor()); + data.writeStrongBinder(tvClient->asBinder()); + remote()->transact(CONNECT, data, &reply); + return reply.readInt32(); + } + virtual status_t lock() + { + Parcel data, reply; + data.writeInterfaceToken(ITv::getInterfaceDescriptor()); + remote()->transact(LOCK, data, &reply); + return reply.readInt32(); + } + virtual status_t unlock() + { + Parcel data, reply; + data.writeInterfaceToken(ITv::getInterfaceDescriptor()); + remote()->transact(UNLOCK, data, &reply); + return reply.readInt32(); + } +}; + +IMPLEMENT_META_INTERFACE(Tv, "android.amlogic.ITv"); + +status_t BnTv::onTransact( + uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) +{ + switch (code) { + case DISCONNECT: { + CHECK_INTERFACE(ITv, data, reply); + disconnect(); + return NO_ERROR; + } + break; + case CONNECT: { + CHECK_INTERFACE(ITv, data, reply); + sp tvClient = interface_cast(data.readStrongBinder()); + reply->writeInt32(connect(tvClient)); + return NO_ERROR; + } + break; + case LOCK: { + CHECK_INTERFACE(ITv, data, reply); + reply->writeInt32(lock()); + return NO_ERROR; + } + break; + case UNLOCK: { + CHECK_INTERFACE(ITv, data, reply); + reply->writeInt32(unlock()); + return NO_ERROR; + } + break; + case TV_CMD: { + CHECK_INTERFACE(ITv, data, reply); + processCmd(data, reply); + //reply->write(tmp.data(), tmp.dataSize()); + return NO_ERROR; + } + case TV_CREATE_SUBTITLE: { + CHECK_INTERFACE(ITv, data, reply); + sp buffer = interface_cast(data.readStrongBinder()); + createSubtitle(buffer); + //reply->write(tmp.data(), tmp.dataSize()); + return NO_ERROR; + } + case TV_CREATE_VIDEO_FRAME: { + CHECK_INTERFACE(ITv, data, reply); + sp buffer = interface_cast(data.readStrongBinder()); + createVideoFrame(buffer); + //reply->write(tmp.data(), tmp.dataSize()); + return NO_ERROR; + } + break; + default: + return BBinder::onTransact(code, data, reply, flags); + } +} + diff --git a/tvapi/android/libtvbinder/ITvClient.cpp b/tvapi/android/libtvbinder/ITvClient.cpp new file mode 100644 index 0000000..fc6d9bb --- a/dev/null +++ b/tvapi/android/libtvbinder/ITvClient.cpp @@ -0,0 +1,59 @@ +#define LOG_TAG "ITvClient" +#include +#include +#include +#include +#include "../include/tvcmd.h" +enum { + NOTIFY_CALLBACK = IBinder::FIRST_CALL_TRANSACTION, +}; + +class BpTvClient: public BpInterface +{ +public: + BpTvClient(const sp &impl) : + BpInterface (impl) + { + } + + // generic callback from tv service to app + void notifyCallback(int32_t msgType, const Parcel &p) + { + ALOGV("BpTvClient notifyCallback datasize = %d pos = %d", p.dataSize(), p.dataPosition()); + Parcel data, reply; + data.writeInterfaceToken(ITvClient::getInterfaceDescriptor()); + data.writeInt32(msgType); + data.write(p.data(), p.dataSize()); + remote()->transact(NOTIFY_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY); + } +}; + +IMPLEMENT_META_INTERFACE(TvClient, "android.amlogic.ITvClient"); + +// ---------------------------------------------------------------------- +status_t BnTvClient::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) +{ + int i = 0, loop_count = 0; + + switch (code) { + case NOTIFY_CALLBACK: { + CHECK_INTERFACE(ITvClient, data, reply); + Parcel ext; + int32_t msgType = data.readInt32(); + + ext.appendFrom(const_cast(&data), data.dataPosition(), data.dataAvail()); + + + switch (msgType) { + default: + ALOGE("BnTvClient::onTransact NOTIFY_CALLBACK msg type ----= %d", msgType); + break; + } + notifyCallback(msgType, ext); + return NO_ERROR; + } + break; + default: + return BBinder::onTransact(code, data, reply, flags); + } +} diff --git a/tvapi/android/libtvbinder/ITvService.cpp b/tvapi/android/libtvbinder/ITvService.cpp new file mode 100644 index 0000000..d68c60d --- a/dev/null +++ b/tvapi/android/libtvbinder/ITvService.cpp @@ -0,0 +1,51 @@ + +#include +#include +#include +#include +#include +#include + +#include + +class BpTvService: public BpInterface +{ +public: + BpTvService(const sp &impl) + : BpInterface(impl) + { + } + + // connect to tv service + virtual sp connect(const sp &tvClient) + { + Parcel data, reply; + data.writeInterfaceToken(ITvService::getInterfaceDescriptor()); + data.writeStrongBinder(tvClient->asBinder()); + remote()->transact(BnTvService::CONNECT, data, &reply); + return interface_cast(reply.readStrongBinder()); + } +}; + +IMPLEMENT_META_INTERFACE(TvService, "android.amlogic.ITvService"); + +// ---------------------------------------------------------------------- + +status_t BnTvService::onTransact( + uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) +{ + switch (code) { + case CONNECT: { + CHECK_INTERFACE(ITvService, data, reply); + sp tvClient = interface_cast(data.readStrongBinder()); + sp tv = connect(tvClient); + ALOGD("BnTvService::onTransact(　sp tv = connect(tvClient);"); + reply->writeStrongBinder(tv->asBinder()); + return NO_ERROR; + } + break; + default: + return BBinder::onTransact(code, data, reply, flags); + } +} + diff --git a/tvapi/android/libtvbinder/Tv.cpp b/tvapi/android/libtvbinder/Tv.cpp new file mode 100644 index 0000000..29935d1 --- a/dev/null +++ b/tvapi/android/libtvbinder/Tv.cpp @@ -0,0 +1,189 @@ +#define LOG_TAG "Tv" +#include +#include +#include +#include +#include + +#include +#include + +// client singleton for tv service binder interface +Mutex Tv::mLock; +sp Tv::mTvService; +sp Tv::mDeathNotifier; + +// establish binder interface to tv service +const sp &Tv::getTvService() +{ + Mutex::Autolock _l(mLock); + if (mTvService.get() == 0) { + sp sm = defaultServiceManager(); + sp binder; + do { + binder = sm->getService(String16("aml.tvserver")); + if (binder != 0) + break; + ALOGW("TvService not published, waiting..."); + usleep(500000); // 0.5 s + } while (true); + if (mDeathNotifier == NULL) { + mDeathNotifier = new DeathNotifier(); + } + binder->linkToDeath(mDeathNotifier); + mTvService = interface_cast(binder); + } + ALOGE_IF(mTvService == 0, "no TvService!?"); + return mTvService; +} + +Tv::Tv() +{ + init(); +} + +// construct a tv client from an existing tv remote +sp Tv::create(const sp &tv) +{ + ALOGD("create"); + if (tv == 0) { + ALOGE("tv remote is a NULL pointer"); + return 0; + } + + sp c = new Tv(); + if (tv->connect(c) == NO_ERROR) { + c->mStatus = NO_ERROR; + c->mTv = tv; + tv->asBinder()->linkToDeath(c); + } + return c; +} + +void Tv::init() +{ + mStatus = UNKNOWN_ERROR; +} + +Tv::~Tv() +{ + disconnect(); +} + +sp Tv::connect() +{ + ALOGD("Tv::connect------------------------------------------"); + sp c = new Tv(); + const sp &cs = getTvService(); + if (cs != 0) { + c->mTv = cs->connect(c); + } + if (c->mTv != 0) { + c->mTv->asBinder()->linkToDeath(c); + c->mStatus = NO_ERROR; + } else { + c.clear(); + } + return c; +} + +void Tv::disconnect() +{ + ALOGD("disconnect"); + if (mTv != 0) { + mTv->disconnect(); + mTv->asBinder()->unlinkToDeath(this); + mTv = 0; + } +} + +status_t Tv::reconnect() +{ + ALOGD("reconnect"); + sp c = mTv; + if (c == 0) return NO_INIT; + return c->connect(this); +} + +sp Tv::remote() +{ + return mTv; +} + +status_t Tv::lock() +{ + sp c = mTv; + if (c == 0) return NO_INIT; + return c->lock(); +} + +status_t Tv::unlock() +{ + sp c = mTv; + if (c == 0) return NO_INIT; + return c->unlock(); +} + +status_t Tv::processCmd(const Parcel &p, Parcel *r) +{ + sp c = mTv; + if (c == 0) return NO_INIT; + return c->processCmd(p, r); +} + +// +status_t Tv::createSubtitle(const sp &share_mem) +{ + sp c = mTv; + if (c == 0) return NO_INIT; + return c->createSubtitle(share_mem); +} + +status_t Tv::createVideoFrame(const sp &share_mem) +{ + sp c = mTv; + if (c == 0) return NO_INIT; + return c->createVideoFrame(share_mem); +} + + +void Tv::setListener(const sp &listener) +{ + ALOGD("tv------------Tv::setListener"); + Mutex::Autolock _l(mLock); + mListener = listener; +} + + +// callback from tv service +void Tv::notifyCallback(int32_t msgType, const Parcel &p) +{ + int size = p.dataSize(); + int pos = p.dataPosition(); + p.setDataPosition(0); + sp listener; + { + Mutex::Autolock _l(mLock); + listener = mListener; + } + if (listener != NULL) { + listener->notify(msgType, p); + } +} + +void Tv::binderDied(const wp &who) +{ + ALOGW("ITv died"); + //notifyCallback(1, 2, 0); +} + +void Tv::DeathNotifier::binderDied(const wp &who) +{ + ALOGW("-----------------binderDied"); + Mutex::Autolock _l(Tv::mLock); + Tv::mTvService.clear(); + ALOGW("kill myself"); + kill(getpid(), SIGKILL); + ALOGW("----------------Tv server died!"); +} + diff --git a/tvapi/android/tvserver/Android.mk b/tvapi/android/tvserver/Android.mk new file mode 100644 index 0000000..34c9eed --- a/dev/null +++ b/tvapi/android/tvserver/Android.mk @@ -0,0 +1,85 @@ +LOCAL_PATH:= $(call my-dir) + + +DVB_PATH := $(wildcard external/dvb) + +ifeq ($(DVB_PATH), ) + DVB_PATH := $(wildcard vendor/amlogic/dvb) +endif + +AM_LIBPLAYER_PATH := $(wildcard vendor/amlogic/frameworks/av/LibPlayer) +LIB_ZVBI_PATH := $(wildcard external/libzvbi) +LIB_SQLITE_PATH := $(wildcard external/sqlite) + + +#tvserver +include $(CLEAR_VARS) + + + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES:= \ + TvService.cpp + +LOCAL_SHARED_LIBRARIES := \ + libtv + +LOCAL_SHARED_LIBRARIES += \ + libui \ + libutils \ + libbinder \ + libcutils \ + libsqlite \ + libmedia \ + libtvbinder \ + libhardware_legacy \ + libdl \ + libskia \ + libtinyxml + +LOCAL_SHARED_LIBRARIES += \ + libzvbi \ + libntsc_decode \ + libam_mw \ + libam_adp \ + libam_ver + +LOCAL_STATIC_LIBRARIES := \ + lib$(strip $(TVAPI_TARGET_BOARD_VERSION)) +LOCAL_C_INCLUDES := \ + $(LOCAL_PATH)/../../libtv \ + $(LOCAL_PATH)/../ \ + $(LOCAL_PATH)/../../libtv/tvdb \ + $(LOCAL_PATH)/../../libtv/tv \ + $(LOCAL_PATH)/../../libtv/include \ + $(LOCAL_PATH)/../../build/include \ + $(LOCAL_PATH)/../../libtv/projects + +LOCAL_C_INCLUDES += \ + bionic/libc/include \ + bionic/libc/private \ + system/extras/ext4_utils \ + $(LOCAL_PATH)/../ \ + $(LIB_SQLITE_PATH)/dist \ + system/media/audio_effects/include + + +LOCAL_C_INCLUDES += \ + $(LIB_ZVBI_PATH)/ntsc_decode/include \ + $(LIB_ZVBI_PATH)/ntsc_decode/include/ntsc_dmx \ + $(LIB_ZVBI_PATH)/src \ + $(DVB_PATH)/include/am_adp \ + $(DVB_PATH)/include/am_mw \ + $(DVB_PATH)/include/am_ver \ + $(DVB_PATH)/android/ndk/include \ + $(AM_LIBPLAYER_PATH)/amadec/include \ + $(AM_LIBPLAYER_PATH)/amcodec/include \ + $(AM_LIBPLAYER_PATH)/amffmpeg \ + $(AM_LIBPLAYER_PATH)/amplayer + +LOCAL_CFLAGS += -DTARGET_BOARD_$(strip $(TVAPI_TARGET_BOARD_VERSION)) + +LOCAL_MODULE:= libtvserver + +include $(BUILD_SHARED_LIBRARY) diff --git a/tvapi/android/tvserver/TvService.cpp b/tvapi/android/tvserver/TvService.cpp new file mode 100644 index 0000000..72406df --- a/dev/null +++ b/tvapi/android/tvserver/TvService.cpp @@ -0,0 +1,4375 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "TvService.h" +#include +#include +#include +#include +#include +#include