550 lines
20 KiB
C++
550 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2021 Rockchip Electronics Co., Ltd
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <malloc.h>
|
|
|
|
#include <cutils/native_handle.h>
|
|
#include <log/log.h>
|
|
#include <cutils/log.h>
|
|
#include <ui/GraphicBufferMapper.h>
|
|
#include <ui/GraphicBuffer.h>
|
|
//#include <gralloc_priv.h>
|
|
//#include <gralloc_helper.h>
|
|
|
|
#include <linux/videodev2.h>
|
|
#include <android/native_window.h>
|
|
#include <hardware/hardware.h>
|
|
#include <hardware/tv_input.h>
|
|
#include "TvDeviceV4L2Event.h"
|
|
#include "HinDev.h"
|
|
#include "Utils.h"
|
|
|
|
#ifdef LOG_TAG
|
|
#undef LOG_TAG
|
|
#define LOG_TAG "tv_input"
|
|
#endif
|
|
|
|
using namespace android;
|
|
#define UNUSED(x) (void *)x
|
|
|
|
#define MAX_HIN_DEVICE_SUPPORTED 10
|
|
|
|
#define STREAM_ID_GENERIC 1
|
|
#define STREAM_ID_FRAME_CAPTURE 2
|
|
|
|
// tv input source type
|
|
typedef enum tv_input_source_type {
|
|
SOURCE_INVALID = -1,
|
|
SOURCE_HDMI1 = 0,
|
|
SOURCE_HDMI2,
|
|
SOURCE_TV,
|
|
SOURCE_DTV,
|
|
SOURCE_MAX,
|
|
} tv_input_source_t;
|
|
|
|
typedef struct tv_input_private {
|
|
tv_input_device_t device;
|
|
|
|
// Callback related data
|
|
const tv_input_callback_ops_ext_t* callback;
|
|
HinDevImpl* mDev;
|
|
int mStreamType;
|
|
bool isOpened;
|
|
bool isInitialized;
|
|
} tv_input_private_t;
|
|
|
|
typedef struct tv_input_request_info {
|
|
int deviceId;
|
|
int streamId;
|
|
int seq;
|
|
} tv_input_request_info_t;
|
|
|
|
static tv_input_private_t *s_TvInputPriv;
|
|
static tv_input_request_info_t requestInfo;
|
|
static int s_HinDevStreamWidth = 1280;
|
|
static int s_HinDevStreamHeight = 720;
|
|
static int s_HinDevStreamFormat = DEFAULT_TVHAL_STREAM_FORMAT;
|
|
static int s_HinDevStreamInterlaced = 0;
|
|
//static unsigned int gHinDevOpened = 0;
|
|
//static Mutex gHinDevOpenLock;
|
|
//static HinDevImpl* gHinHals[MAX_HIN_DEVICE_SUPPORTED];
|
|
|
|
//static native_handle_t *pTvStream = NULL;
|
|
|
|
/*****************************************************************************/
|
|
|
|
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
|
|
};
|
|
|
|
tv_input_module_t HAL_MODULE_INFO_SYM = {
|
|
.common = {
|
|
.tag = HARDWARE_MODULE_TAG,
|
|
.version_major = 1,
|
|
.version_minor = 0,
|
|
.id = TV_INPUT_HARDWARE_MODULE_ID,
|
|
.name = "Rockchip TV input module",
|
|
.author = "Rockchip",
|
|
.methods = &tv_input_module_methods,
|
|
}
|
|
};
|
|
|
|
V4L2EventCallBack hinDevEventCallback(int event_type) {
|
|
ALOGD("%s event type: %d", __FUNCTION__,event_type);
|
|
bool isHdmiIn;
|
|
tv_input_event_ext_t event;
|
|
if (s_TvInputPriv && !s_TvInputPriv->isOpened) {
|
|
ALOGE("%s The device is not open ", __FUNCTION__);
|
|
return 0;
|
|
}
|
|
switch (event_type) {
|
|
case V4L2_EVENT_CTRL:
|
|
isHdmiIn = s_TvInputPriv->mDev->get_HdmiIn(false);
|
|
/*if(!isHdmiIn)
|
|
event.type = TV_INPUT_EVENT_DEVICE_UNAVAILABLE;
|
|
else
|
|
event.type = TV_INPUT_EVENT_DEVICE_AVAILABLE;
|
|
*/
|
|
if (!isHdmiIn) {
|
|
if (s_TvInputPriv->mDev) {
|
|
std::map<std::string, std::string> data;
|
|
s_TvInputPriv->mDev->deal_priv_message("hdmiinout", data);
|
|
event.base_event.type = TV_INPUT_EVENT_PRIV_CMD_TO_APP;
|
|
event.priv_app_cmd.action = "hdmiinout";
|
|
}
|
|
}
|
|
break;
|
|
case V4L2_EVENT_SOURCE_CHANGE:
|
|
isHdmiIn = s_TvInputPriv->mDev->get_current_sourcesize(s_HinDevStreamWidth, s_HinDevStreamHeight,s_HinDevStreamFormat);
|
|
s_HinDevStreamInterlaced = s_TvInputPriv->mDev->check_interlaced();
|
|
ALOGD("s_HinDevStreamInterlaced %d ", s_HinDevStreamInterlaced);
|
|
event.base_event.type = TV_INPUT_EVENT_STREAM_CONFIGURATIONS_CHANGED;
|
|
break;
|
|
case RK_HDMIRX_V4L2_EVENT_SIGNAL_LOST:
|
|
if (s_TvInputPriv->mDev) {
|
|
std::map<std::string, std::string> data;
|
|
s_TvInputPriv->mDev->deal_priv_message("hdmiinout", data);
|
|
event.base_event.type = TV_INPUT_EVENT_PRIV_CMD_TO_APP;
|
|
event.priv_app_cmd.action = "hdmiinout";
|
|
}
|
|
break;
|
|
case CMD_HDMIIN_RESET:
|
|
event.base_event.type = TV_INPUT_EVENT_PRIV_CMD_TO_APP;
|
|
event.priv_app_cmd.action = "hdmiinreset";
|
|
break;
|
|
}
|
|
ALOGE("%s width:%d,height:%d,format:0x%x,%d", __FUNCTION__,s_HinDevStreamWidth,s_HinDevStreamHeight,s_HinDevStreamFormat,isHdmiIn);
|
|
event.base_event.device_info.device_id = SOURCE_HDMI1;
|
|
event.base_event.device_info.type = TV_INPUT_TYPE_HDMI;
|
|
event.base_event.device_info.audio_type = AUDIO_DEVICE_NONE;
|
|
event.base_event.device_info.audio_address = NULL;
|
|
if(event.base_event.type > 0) {
|
|
s_TvInputPriv->callback->notify_ext(nullptr, &event, nullptr);
|
|
}
|
|
return 0;
|
|
}
|
|
NotifyCommandCallback commandCallback(tv_input_command command) {
|
|
hinDevEventCallback(command.command_id);
|
|
return 0;
|
|
}
|
|
|
|
static int getHdmiPortID(tv_input_source_t source_type) {
|
|
int port_id = 0;
|
|
switch (source_type) {
|
|
case SOURCE_HDMI1:
|
|
port_id = 1;
|
|
break;
|
|
case SOURCE_HDMI2:
|
|
port_id = 2;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return port_id;
|
|
}
|
|
|
|
static int hin_dev_open(int deviceId, int type)
|
|
{
|
|
ALOGD("hin_dev_open deviceId:=%d",deviceId);
|
|
HinDevImpl* hinDevImpl = NULL;
|
|
//Mutex::Autolock lock(gHinDevOpenLock);
|
|
if (!s_TvInputPriv->isOpened && deviceId == SOURCE_DTV) {
|
|
if (deviceId >= MAX_HIN_DEVICE_SUPPORTED) {
|
|
ALOGD("provided device id out of bounds , deviceid = %d .\n" , deviceId);
|
|
return -EINVAL;
|
|
}
|
|
if (!s_TvInputPriv->mDev) {
|
|
hinDevImpl = new HinDevImpl;
|
|
if (!hinDevImpl) {
|
|
ALOGE("no memory to new hinDevImpl");
|
|
return -ENOMEM;
|
|
}
|
|
s_TvInputPriv->mDev = hinDevImpl;
|
|
s_TvInputPriv->mDev->set_data_callback((V4L2EventCallBack)hinDevEventCallback);
|
|
s_TvInputPriv->mDev->set_command_callback((NotifyCommandCallback)commandCallback);
|
|
if (s_TvInputPriv->mDev->findDevice(deviceId, s_HinDevStreamWidth, s_HinDevStreamHeight,s_HinDevStreamFormat)!= 0) {
|
|
ALOGE("hinDevImpl->findDevice %d failed!", deviceId);
|
|
delete s_TvInputPriv->mDev;
|
|
s_TvInputPriv->mDev = nullptr;
|
|
return -1;
|
|
}
|
|
ALOGD("hinDevImpl->findDevice %d ,%d,0x%x,0x%x!", s_HinDevStreamWidth,s_HinDevStreamHeight,s_HinDevStreamFormat,DEFAULT_V4L2_STREAM_FORMAT);
|
|
s_TvInputPriv->mDev->set_interlaced(s_HinDevStreamInterlaced);
|
|
s_TvInputPriv->isOpened = true;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
/*****************************************************************************/
|
|
static int generateEvent(tv_input_private_t *priv, tv_input_source_t source_type, int event_type) {
|
|
tv_input_event_ext_t event;
|
|
event.base_event.device_info.device_id = source_type;
|
|
event.base_event.device_info.audio_type = AUDIO_DEVICE_NONE;
|
|
event.base_event.device_info.audio_address = NULL;
|
|
event.base_event.type = event_type;
|
|
switch (source_type) {
|
|
case SOURCE_HDMI1:
|
|
case SOURCE_HDMI2:
|
|
event.base_event.device_info.type = TV_INPUT_TYPE_HDMI;
|
|
event.base_event.device_info.hdmi.port_id = getHdmiPortID(source_type);
|
|
break;
|
|
case SOURCE_TV:
|
|
case SOURCE_DTV:
|
|
event.base_event.device_info.type = TV_INPUT_TYPE_TUNER;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
static int connection_status = 1;
|
|
//priv->callback->notify(&priv->device, &event, priv->callback_data);
|
|
// TODO: data --> connection status
|
|
priv->callback->notify_ext(&priv->device, &event, &connection_status);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* List all of the devices, may register hotplug listener here.
|
|
* */
|
|
void findTvDevices(tv_input_private_t *priv) {
|
|
generateEvent(priv, SOURCE_HDMI1, TV_INPUT_EVENT_DEVICE_AVAILABLE);
|
|
generateEvent(priv, SOURCE_HDMI1, TV_INPUT_EVENT_STREAM_CONFIGURATIONS_CHANGED);
|
|
generateEvent(priv, SOURCE_DTV, TV_INPUT_EVENT_DEVICE_AVAILABLE);
|
|
generateEvent(priv, SOURCE_DTV, TV_INPUT_EVENT_STREAM_CONFIGURATIONS_CHANGED);
|
|
}
|
|
|
|
#define NUM_OF_CONFIGS_DEFAULT 2
|
|
static tv_stream_config_ext mconfig[NUM_OF_CONFIGS_DEFAULT];
|
|
static native_handle_t* out_buffer;
|
|
static native_handle_t* out_cancel_buffer = nullptr;
|
|
|
|
static int tv_input_get_stream_configurations_ext(
|
|
const struct tv_input_device *dev, int device_id, int *num_of_configs, const tv_stream_config_ext **configs)
|
|
{
|
|
ALOGD("%s called device_id=%d,s_TvInputPriv=%p", __func__, device_id,s_TvInputPriv);
|
|
UNUSED(dev);
|
|
if (device_id == -1) {
|
|
*num_of_configs = -1;
|
|
}
|
|
if (hin_dev_open(device_id, 0) < 0) {
|
|
ALOGD("Open hdmi failed!!!\n");
|
|
return -EINVAL;
|
|
}
|
|
switch (device_id) {
|
|
case SOURCE_TV:
|
|
case SOURCE_DTV:
|
|
case SOURCE_HDMI1:
|
|
case SOURCE_HDMI2:
|
|
mconfig[0].base_config.stream_id = STREAM_ID_GENERIC;
|
|
mconfig[0].base_config.type = TV_STREAM_TYPE_BUFFER_PRODUCER;
|
|
mconfig[0].base_config.max_video_width = s_HinDevStreamWidth;
|
|
mconfig[0].base_config.max_video_height = s_HinDevStreamHeight;
|
|
mconfig[0].format = s_HinDevStreamFormat;//DEFAULT_TVHAL_STREAM_FORMAT;
|
|
mconfig[0].width = s_HinDevStreamWidth;
|
|
mconfig[0].height = s_HinDevStreamHeight;
|
|
mconfig[0].usage = RK_GRALLOC_USAGE_STRIDE_ALIGN_64;//|GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN;//STREAM_BUFFER_GRALLOC_USAGE;
|
|
mconfig[0].buffCount = APP_PREVIEW_BUFF_CNT;
|
|
|
|
mconfig[1].base_config.stream_id = STREAM_ID_FRAME_CAPTURE;
|
|
mconfig[1].base_config.type = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE;
|
|
mconfig[1].base_config.max_video_width = s_HinDevStreamWidth;
|
|
mconfig[1].base_config.max_video_height = s_HinDevStreamHeight;
|
|
mconfig[1].format = s_HinDevStreamFormat;//DEFAULT_TVHAL_STREAM_FORMAT;
|
|
mconfig[1].width = s_HinDevStreamWidth;
|
|
mconfig[1].height = s_HinDevStreamWidth;
|
|
mconfig[1].usage = RK_GRALLOC_USAGE_STRIDE_ALIGN_64;//|GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN;//STREAM_BUFFER_GRALLOC_USAGE;
|
|
mconfig[1].buffCount = APP_PREVIEW_BUFF_CNT;
|
|
*num_of_configs = NUM_OF_CONFIGS_DEFAULT;
|
|
*configs = mconfig;
|
|
ALOGE("config device_id=%d, %d ,%d,0x%x,0x%x!", device_id, s_HinDevStreamWidth,s_HinDevStreamHeight,s_HinDevStreamFormat,DEFAULT_V4L2_STREAM_FORMAT);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int tv_input_close_stream(struct tv_input_device *dev, int device_id, int stream_id)
|
|
{
|
|
ALOGD("func: %s, device_id: %d, stream_id: %d", __func__, device_id, stream_id);
|
|
if (s_TvInputPriv) {
|
|
if (s_TvInputPriv->mDev) {
|
|
if (out_buffer) {
|
|
native_handle_close(out_buffer);
|
|
native_handle_delete(out_buffer);
|
|
out_buffer=NULL;
|
|
}
|
|
if (out_cancel_buffer) {
|
|
native_handle_close(out_cancel_buffer);
|
|
native_handle_delete(out_cancel_buffer);
|
|
out_cancel_buffer = nullptr;
|
|
}
|
|
s_TvInputPriv->mDev->stop();
|
|
s_TvInputPriv->isInitialized = false;
|
|
s_TvInputPriv->isOpened = false;
|
|
//delete s_TvInputPriv->mDev;
|
|
s_TvInputPriv->mDev = nullptr;
|
|
if (device_id < 0 && stream_id == 0) {
|
|
ALOGD("func: %s,invail device_id: %d, stream_id: %d return -EINVAL",
|
|
__func__, device_id, stream_id);
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int tv_input_open_stream(struct tv_input_device *dev, int device_id, tv_stream_t *stream)
|
|
{
|
|
ALOGD("%s called", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int tv_input_open_stream_ext(struct tv_input_device *dev, int device_id, tv_stream_ext_t *stream)
|
|
{
|
|
ALOGD("func: %s, device_id: %d, stream_id=%d, type=%d", __func__, device_id, stream->base_stream.stream_id, stream->base_stream.type);
|
|
if (s_TvInputPriv) {
|
|
if (s_TvInputPriv->mDev && s_TvInputPriv->isInitialized) {
|
|
int width = s_HinDevStreamWidth;
|
|
int height = s_HinDevStreamHeight;
|
|
requestInfo.streamId = stream->base_stream.stream_id;
|
|
|
|
if(s_TvInputPriv->mDev->set_format(width, height, s_HinDevStreamFormat)) {
|
|
ALOGE("%s set_format failed! force release", __func__);
|
|
tv_input_close_stream(dev, device_id, requestInfo.streamId);
|
|
return -EINVAL;
|
|
}
|
|
int dst_width = 0, dst_height = 0;
|
|
bool use_zme = s_TvInputPriv->mDev->check_zme(width, height, &dst_width, &dst_height);
|
|
if(use_zme) {
|
|
s_TvInputPriv->mDev->set_crop(0, 0, dst_width, dst_height);
|
|
} else {
|
|
s_TvInputPriv->mDev->set_crop(0, 0, width, height);
|
|
}
|
|
if (stream->base_stream.type & TYPE_SIDEBAND_WINDOW) {
|
|
ALOGD("stream->base_stream.type & TYPE_SIDEBAND_WINDOW");
|
|
s_TvInputPriv->mStreamType = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE;
|
|
stream->base_stream.sideband_stream_source_handle = native_handle_clone(s_TvInputPriv->mDev->getSindebandBufferHandle());
|
|
out_buffer = stream->base_stream.sideband_stream_source_handle;
|
|
if (s_TvInputPriv->mDev->getSindebandCancelBufferHandle() == NULL) {
|
|
ALOGD("%s cancel buffer handle is NULL", __FUNCTION__);
|
|
} else {
|
|
stream->sideband_cancel_stream_source_handle = native_handle_clone(s_TvInputPriv->mDev->getSindebandCancelBufferHandle());
|
|
out_cancel_buffer = stream->sideband_cancel_stream_source_handle;
|
|
}
|
|
}
|
|
s_TvInputPriv->mDev->start();
|
|
}
|
|
return 0;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
NotifyQueueDataCallback dataCallback(tv_input_capture_result_t result, uint64_t buff_id) {
|
|
//ALOGV("%s req:%u ,%u in result.buff_id=%" PRIu64, __FUNCTION__,
|
|
// requestInfo.seq, result.seq, buff_id);
|
|
tv_input_event_ext_t event;
|
|
event.base_event.capture_result.device_id = requestInfo.deviceId;
|
|
event.base_event.capture_result.stream_id = requestInfo.streamId;
|
|
event.base_event.capture_result.seq = requestInfo.seq++;
|
|
if (buff_id != -1) {
|
|
event.base_event.type = TV_INPUT_EVENT_CAPTURE_SUCCEEDED;
|
|
event.buff_id = buff_id;
|
|
//event.base_event.capture_result.buffer = result.buffer;
|
|
} else {
|
|
event.base_event.type = TV_INPUT_EVENT_CAPTURE_FAILED;
|
|
}
|
|
s_TvInputPriv->callback->notify_ext(nullptr, &event, nullptr);
|
|
return 0;
|
|
}
|
|
|
|
static int tv_input_priv_cmd_from_app(const std::string action, const std::map<std::string, std::string> data) {
|
|
ALOGV("%s called", __func__);
|
|
if (s_TvInputPriv && s_TvInputPriv->isInitialized && s_TvInputPriv->mDev) {
|
|
s_TvInputPriv->mDev->deal_priv_message(action, data);
|
|
return 0;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int tv_input_request_capture_ext(struct tv_input_device* dev, int device_id,
|
|
int stream_id, uint64_t buff_id, buffer_handle_t buffer, uint32_t seq) {
|
|
ALOGV("%s called,req=%u", __func__,seq);
|
|
if (s_TvInputPriv && s_TvInputPriv->isInitialized && s_TvInputPriv->mDev && buffer != nullptr) {
|
|
//requestInfo.seq = seq;
|
|
s_TvInputPriv->mDev->set_preview_callback((NotifyQueueDataCallback)dataCallback);
|
|
s_TvInputPriv->mDev->request_capture(buffer, buff_id);
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int tv_input_cancel_capture(struct tv_input_device*, int, int, uint32_t)
|
|
{
|
|
ALOGD("%s called", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static int tv_input_set_preview_info(int32_t deviceId, int32_t streamId,
|
|
int32_t top, int32_t left, int32_t width, int32_t height, int32_t extInfo)
|
|
{
|
|
ALOGD("%s device id %d,called,%p", __func__,deviceId,s_TvInputPriv->mDev);
|
|
if (s_TvInputPriv && s_TvInputPriv->mDev && !s_TvInputPriv->isInitialized) {
|
|
if (s_TvInputPriv->mDev->init(deviceId, extInfo,
|
|
s_HinDevStreamWidth, s_HinDevStreamHeight,s_HinDevStreamFormat)!= 0) {
|
|
ALOGE("hinDevImpl->init %d failed!", deviceId);
|
|
return -1;
|
|
}
|
|
s_TvInputPriv->isInitialized = true;
|
|
requestInfo.deviceId = deviceId;
|
|
}
|
|
if(s_TvInputPriv->isInitialized){
|
|
requestInfo.deviceId = deviceId;
|
|
s_TvInputPriv->mDev->set_preview_info(top, left, width, height);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int tv_input_set_preview_buffer(buffer_handle_t rawHandle, uint64_t bufferId)
|
|
{
|
|
ALOGD("%s called", __func__);
|
|
if (!s_TvInputPriv->isInitialized || !s_TvInputPriv->mDev) {
|
|
return -EINVAL;
|
|
}
|
|
s_TvInputPriv->mDev->set_preview_buffer(rawHandle, bufferId);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static int tv_input_device_close(struct hw_device_t *dev)
|
|
{
|
|
ALOGD("%s called", __func__);
|
|
if (s_TvInputPriv) {
|
|
if (s_TvInputPriv->mDev) {
|
|
delete s_TvInputPriv->mDev;
|
|
s_TvInputPriv->mDev = nullptr;
|
|
}
|
|
s_TvInputPriv->isOpened = false;
|
|
s_TvInputPriv->isInitialized = false;
|
|
free(s_TvInputPriv);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int tv_input_initialize_ext(struct tv_input_device* dev,
|
|
const tv_input_callback_ops_ext_t* callback, void* data)
|
|
{
|
|
ALOGD("%s called", __func__);
|
|
if (dev == NULL || callback == NULL) {
|
|
return -EINVAL;
|
|
}
|
|
s_TvInputPriv = (tv_input_private_t*)dev;
|
|
//memset(s_TvInputPriv->mDev,0,sizeof(s_TvInputPriv->mDev));
|
|
s_TvInputPriv->mDev = NULL;
|
|
s_TvInputPriv->isOpened = false;
|
|
s_TvInputPriv->isInitialized = false;
|
|
s_TvInputPriv->callback = callback;
|
|
|
|
findTvDevices(s_TvInputPriv);
|
|
return 0;
|
|
}
|
|
|
|
static int tv_input_initialize(struct tv_input_device* dev,
|
|
const tv_input_callback_ops_t* callback, void* data)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int tv_input_request_capture(
|
|
struct tv_input_device*, int device_id, int stream_id, buffer_handle_t, uint32_t)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int tv_input_get_stream_configurations(
|
|
const struct tv_input_device*, int, int*, const tv_stream_config_t**)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int tv_input_set_placeholder(
|
|
int32_t device_id)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static int tv_input_device_open(const struct hw_module_t* module,
|
|
const char* name, struct hw_device_t** device)
|
|
{
|
|
ALOGD("%s in, name: %s", __func__, name);
|
|
int status = -EINVAL;
|
|
if (!strcmp(name, TV_INPUT_DEFAULT_DEVICE)) {
|
|
tv_input_private_t* dev = (tv_input_private_t*)malloc(sizeof(*dev));
|
|
|
|
/* initialize our state here */
|
|
memset(dev, 0, sizeof(*dev));
|
|
|
|
/* initialize the procs */
|
|
dev->device.common.tag = HARDWARE_DEVICE_TAG;
|
|
dev->device.common.version = TV_INPUT_DEVICE_API_VERSION_0_1;
|
|
dev->device.common.module = const_cast<hw_module_t*>(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;
|
|
dev->device.open_stream = tv_input_open_stream;
|
|
dev->device.close_stream = tv_input_close_stream;
|
|
dev->device.set_preview_info = tv_input_set_preview_info;
|
|
dev->device.set_preview_buffer = tv_input_set_preview_buffer;
|
|
|
|
dev->device.priv_cmd_from_app = tv_input_priv_cmd_from_app;
|
|
dev->device.request_capture = tv_input_request_capture;
|
|
dev->device.cancel_capture = tv_input_cancel_capture;
|
|
|
|
dev->device.initialize_ext = tv_input_initialize_ext;
|
|
dev->device.request_capture_ext = tv_input_request_capture_ext;
|
|
dev->device.get_stream_configurations_ext = tv_input_get_stream_configurations_ext;
|
|
dev->device.set_placeholder = tv_input_set_placeholder;
|
|
dev->device.open_stream_ext = tv_input_open_stream_ext;
|
|
|
|
*device = &dev->device.common;
|
|
status = 0;
|
|
ALOGD("%s end. name: %s %d", __FUNCTION__, name, status);
|
|
}
|
|
return status;
|
|
}
|
|
|