470 lines
12 KiB
C++
470 lines
12 KiB
C++
/*
|
|
* Copyright (c) 2014 Amlogic, Inc. All rights reserved.
|
|
*
|
|
* This source code is subject to the terms and conditions defined in the
|
|
* file 'LICENSE' which is part of this source code package.
|
|
*
|
|
* Description: c++ file
|
|
*/
|
|
|
|
#define LOG_MODULE_TAG "PQ"
|
|
#define LOG_CLASS_TAG "CVdin"
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/ioctl.h>
|
|
#include <stdarg.h>
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "CVdin.h"
|
|
#include "CPQLog.h"
|
|
#include "CConfigFile.h"
|
|
|
|
CVdin *CVdin::mInstance;
|
|
|
|
CVdin *CVdin::getInstance()
|
|
{
|
|
if (NULL == mInstance) {
|
|
mInstance = new CVdin();
|
|
}
|
|
|
|
return mInstance;
|
|
}
|
|
|
|
CVdin::CVdin()
|
|
{
|
|
//open vdin module
|
|
mVdin0DevFd = VDIN_OpenModule();
|
|
|
|
//load tvcfg file
|
|
const char* tvConfigFilePath = getenv(CFG_TV_CONFIG_FILE_PATH_STR);
|
|
if (!tvConfigFilePath) {
|
|
LOGD("%s: read tvconfig file path failed use default path:%s\n", __FUNCTION__, CONFIG_FILE_PATH_DEF);
|
|
tvConfigFilePath = CONFIG_FILE_PATH_DEF;
|
|
} else {
|
|
LOGD("%s: tvconfig file path is %s\n", __FUNCTION__, tvConfigFilePath);
|
|
}
|
|
LoadConfigFile(tvConfigFilePath);
|
|
|
|
Tvin_LoadPortToSourceInputMap();
|
|
}
|
|
|
|
CVdin::~CVdin()
|
|
{
|
|
VDIN_CloseModule();
|
|
UnloadConfigFile();
|
|
}
|
|
|
|
int CVdin::VDIN_OpenModule()
|
|
{
|
|
int fd = open(VDIN_DEV_PATH, O_RDWR );
|
|
|
|
if ( fd < 0 ) {
|
|
LOGE("Open %s error(%s)\n", VDIN_DEV_PATH, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
return fd;
|
|
}
|
|
|
|
int CVdin::VDIN_CloseModule()
|
|
{
|
|
if (mVdin0DevFd != -1) {
|
|
close ( mVdin0DevFd );
|
|
mVdin0DevFd = -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int CVdin::VDIN_DeviceIOCtl( int request, ... )
|
|
{
|
|
int tmp_ret = -1;
|
|
va_list ap;
|
|
void *arg;
|
|
|
|
if (mVdin0DevFd < 0) {
|
|
mVdin0DevFd = VDIN_OpenModule();
|
|
}
|
|
|
|
if ( mVdin0DevFd >= 0 ) {
|
|
va_start (ap, request);
|
|
arg = va_arg (ap, void *);
|
|
va_end (ap);
|
|
|
|
tmp_ret = ioctl(mVdin0DevFd, request, arg);
|
|
return tmp_ret;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int CVdin::VDIN_OpenPort(enum tvin_port_e port)
|
|
{
|
|
struct tvin_parm_s vdinParam;
|
|
|
|
vdinParam.port = port;
|
|
vdinParam.index = 0;
|
|
int ret = VDIN_DeviceIOCtl(TVIN_IOC_OPEN, &vdinParam );
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_ClosePort()
|
|
{
|
|
int ret = VDIN_DeviceIOCtl(TVIN_IOC_CLOSE);
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_StartDec(const struct tvin_parm_s *vdinParam)
|
|
{
|
|
if ( vdinParam == NULL ) {
|
|
return -1;
|
|
}
|
|
|
|
LOGD("VDIN_StartDec: index = [%d] port = [0x%x] format = [0x%x]\n",
|
|
vdinParam->index, (unsigned int)vdinParam->port, (unsigned int)(vdinParam->info.fmt));
|
|
|
|
int ret = VDIN_DeviceIOCtl(TVIN_IOC_START_DEC, vdinParam);
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_StopDec()
|
|
{
|
|
int ret = VDIN_DeviceIOCtl(TVIN_IOC_STOP_DEC);
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_GetSignalEventInfo(struct vdin_event_info *SignalEventInfo)
|
|
{
|
|
int ret = VDIN_DeviceIOCtl(TVIN_IOC_G_EVENT_INFO, SignalEventInfo);
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_GetSignalInfo(struct tvin_info_s *SignalInfo )
|
|
{
|
|
int ret = VDIN_DeviceIOCtl(TVIN_IOC_G_SIG_INFO, SignalInfo);
|
|
if ( ret < 0 ) {
|
|
LOGE("%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_GetVdinParam(struct tvin_parm_s *vdinParam)
|
|
{
|
|
int ret = VDIN_DeviceIOCtl(TVIN_IOC_G_PARM, vdinParam);
|
|
if ( ret < 0 ) {
|
|
LOGE( "%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_GetAllmInfo(tvin_latency_s *AllmInfo)
|
|
{
|
|
int ret = -1;
|
|
if (AllmInfo == NULL) {
|
|
LOGE("%s: param is NULL\n", __FUNCTION__);
|
|
} else {
|
|
ret = VDIN_DeviceIOCtl(TVIN_IOC_GET_LATENCY_MODE, AllmInfo);
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_SetPCMode(game_pc_mode_t mode)
|
|
{
|
|
LOGD("%s: pc mode: %d\n", __FUNCTION__, mode);
|
|
|
|
int ret = -1;
|
|
unsigned int status = 0;
|
|
if (mode == MODE_ON) {
|
|
status = 1;
|
|
} else {
|
|
status = 0;
|
|
}
|
|
ret = VDIN_DeviceIOCtl(TVIN_IOC_S_PC_MODE, &status);
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)", __FUNCTION__, strerror(errno));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_SetGameMode(game_pc_mode_t mode)
|
|
{
|
|
LOGD("%s: game mode: %d\n", __FUNCTION__, mode);
|
|
|
|
int ret = -1;
|
|
unsigned int status = 0;
|
|
if (mode == MODE_ON) {
|
|
status = 1;
|
|
} else {
|
|
status = 0;
|
|
}
|
|
ret = VDIN_DeviceIOCtl(TVIN_IOC_GAME_MODE, &status);
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)", __FUNCTION__, strerror(errno));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::VDIN_GetVrrFreesyncParm(struct vdin_vrr_freesync_param_s *vrrparm)
|
|
{
|
|
int ret = -1;
|
|
if (vrrparm == NULL) {
|
|
LOGE("%s: param is NULL\n", __FUNCTION__);
|
|
} else {
|
|
ret = VDIN_DeviceIOCtl(TVIN_IOC_G_VRR_STATUS, vrrparm);
|
|
if (ret < 0) {
|
|
LOGE("%s failed, error(%s)\n", __FUNCTION__, strerror(errno));
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::Tvin_SetPCMode(game_pc_mode_t mode)
|
|
{
|
|
int ret = -1;
|
|
|
|
ret = VDIN_SetPCMode(mode);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::Tvin_SetGameMode(game_pc_mode_t mode)
|
|
{
|
|
int ret = -1;
|
|
|
|
ret = VDIN_SetGameMode(mode);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::Tvin_GetAllmInfo(tvin_latency_s *AllmInfo)
|
|
{
|
|
int ret = -1;
|
|
|
|
if (AllmInfo == NULL) {
|
|
LOGE("%s AllmInfo is NULL\n", __FUNCTION__);
|
|
} else {
|
|
ret = VDIN_GetAllmInfo(AllmInfo);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::Tvin_GetVdinParam(struct tvin_parm_s *vdinParam)
|
|
{
|
|
int ret = -1;
|
|
if (vdinParam == NULL) {
|
|
LOGE("%s vdinParam is NULL\n", __FUNCTION__);
|
|
} else {
|
|
ret = VDIN_GetVdinParam(vdinParam);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::Tvin_GetSignalEventInfo(struct vdin_event_info *SignalEventInfo)
|
|
{
|
|
int ret = -1;
|
|
if (SignalEventInfo == NULL) {
|
|
LOGE("%s SignalEventInfo is NULL\n", __FUNCTION__);
|
|
} else {
|
|
ret = VDIN_GetSignalEventInfo(SignalEventInfo);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CVdin::Tvin_GetSignalInfo(struct tvin_info_s *SignalInfo)
|
|
{
|
|
int ret = -1;
|
|
if (SignalInfo == NULL) {
|
|
LOGE("%s SignalInfo is NULL\n", __FUNCTION__);
|
|
} else {
|
|
ret = VDIN_GetSignalInfo(SignalInfo);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
tv_source_input_type_t CVdin::Tvin_SourceInputToSourceInputType ( tv_source_input_t source_input )
|
|
{
|
|
tv_source_input_type_t ret = SOURCE_TYPE_MPEG;
|
|
switch (source_input) {
|
|
case SOURCE_TV:
|
|
ret = SOURCE_TYPE_TV;
|
|
break;
|
|
case SOURCE_AV1:
|
|
case SOURCE_AV2:
|
|
ret = SOURCE_TYPE_AV;
|
|
break;
|
|
case SOURCE_YPBPR1:
|
|
case SOURCE_YPBPR2:
|
|
ret = SOURCE_TYPE_COMPONENT;
|
|
break;
|
|
case SOURCE_VGA:
|
|
ret = SOURCE_TYPE_VGA;
|
|
break;
|
|
case SOURCE_HDMI1:
|
|
case SOURCE_HDMI2:
|
|
case SOURCE_HDMI3:
|
|
case SOURCE_HDMI4:
|
|
ret = SOURCE_TYPE_HDMI;
|
|
break;
|
|
case SOURCE_DTV:
|
|
ret = SOURCE_TYPE_DTV;
|
|
break;
|
|
case SOURCE_IPTV:
|
|
ret = SOURCE_TYPE_IPTV;
|
|
break;
|
|
case SOURCE_SPDIF:
|
|
ret = SOURCE_TYPE_SPDIF;
|
|
break;
|
|
default:
|
|
ret = SOURCE_TYPE_MPEG;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static CConfigFile *pTvcfgFile = NULL;
|
|
int CVdin::LoadConfigFile(const char *file_name)
|
|
{
|
|
if (pTvcfgFile != NULL)
|
|
delete pTvcfgFile;
|
|
|
|
pTvcfgFile = new CConfigFile();
|
|
pTvcfgFile->LoadFromFile(file_name);
|
|
return 0;
|
|
}
|
|
|
|
int CVdin::UnloadConfigFile()
|
|
{
|
|
if (pTvcfgFile != NULL)
|
|
delete pTvcfgFile;
|
|
return 0;
|
|
}
|
|
|
|
const char *CVdin::ConfigGetStr(const char *section, const char *key, const char *def_value)
|
|
{
|
|
return pTvcfgFile->GetString(section, key, def_value);
|
|
}
|
|
|
|
unsigned int CVdin::Tvin_TransPortStringToValue(const char *port_str)
|
|
{
|
|
if (strcasecmp(port_str, "TVIN_PORT_CVBS0") == 0) {
|
|
return TVIN_PORT_CVBS0;
|
|
} else if (strcasecmp(port_str, "TVIN_PORT_CVBS1") == 0) {
|
|
return TVIN_PORT_CVBS1;
|
|
} else if (strcasecmp(port_str, "TVIN_PORT_CVBS2") == 0) {
|
|
return TVIN_PORT_CVBS2;
|
|
} else if (strcasecmp(port_str, "TVIN_PORT_CVBS3") == 0) {
|
|
return TVIN_PORT_CVBS3;
|
|
}/*else if (strcasecmp(port_str, "TVIN_PORT_COMP0") == 0) {
|
|
return TVIN_PORT_COMP0;
|
|
} else if (strcasecmp(port_str, "TVIN_PORT_COMP1") == 0) {
|
|
return TVIN_PORT_COMP1;
|
|
} else if (strcasecmp(port_str, "TVIN_PORT_VGA0") == 0) {
|
|
return TVIN_PORT_VGA0;
|
|
}*/else if (strcasecmp(port_str, "TVIN_PORT_HDMI0") == 0) {
|
|
return TVIN_PORT_HDMI0;
|
|
} else if (strcasecmp(port_str, "TVIN_PORT_HDMI1") == 0) {
|
|
return TVIN_PORT_HDMI1;
|
|
} else if (strcasecmp(port_str, "TVIN_PORT_HDMI2") == 0) {
|
|
return TVIN_PORT_HDMI2;
|
|
} else if (strcasecmp(port_str, "TVIN_PORT_HDMI3") == 0) {
|
|
return TVIN_PORT_HDMI3;
|
|
}
|
|
|
|
return TVIN_PORT_NULL;
|
|
}
|
|
|
|
void CVdin::Tvin_LoadPortToSourceInputMap()
|
|
{
|
|
const char *config_value = NULL;
|
|
|
|
memset(mPortToSourceInputMap, SOURCE_INVALID, sizeof(mPortToSourceInputMap));
|
|
|
|
config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_ATV, "TVIN_PORT_CVBS3");
|
|
mPortToSourceInputMap[SOURCE_TV] = Tvin_TransPortStringToValue(config_value);
|
|
config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_AV1, "TVIN_PORT_CVBS1");
|
|
mPortToSourceInputMap[SOURCE_AV1] = Tvin_TransPortStringToValue(config_value);
|
|
config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_AV2, "TVIN_PORT_CVBS2");
|
|
mPortToSourceInputMap[SOURCE_AV2] = Tvin_TransPortStringToValue(config_value);
|
|
/*config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_YPBPR1, "TVIN_PORT_COMP0");
|
|
mPortToSourceInputMap[SOURCE_YPBPR1] = Tvin_TransPortStringToValue(config_value);
|
|
config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_YPBPR2, "TVIN_PORT_COMP1");
|
|
mPortToSourceInputMap[SOURCE_YPBPR2] = Tvin_TransPortStringToValue(config_value);*/
|
|
config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_HDMI1, "TVIN_PORT_HDMI0");
|
|
mPortToSourceInputMap[SOURCE_HDMI1] = Tvin_TransPortStringToValue(config_value);
|
|
config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_HDMI2, "TVIN_PORT_HDMI2");
|
|
mPortToSourceInputMap[SOURCE_HDMI2] = Tvin_TransPortStringToValue(config_value);
|
|
config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_HDMI3, "TVIN_PORT_HDMI1");
|
|
mPortToSourceInputMap[SOURCE_HDMI3] = Tvin_TransPortStringToValue(config_value);
|
|
config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_HDMI4, "TVIN_PORT_HDMI3");
|
|
mPortToSourceInputMap[SOURCE_HDMI4] = Tvin_TransPortStringToValue(config_value);
|
|
/*config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_VGA, "TVIN_PORT_VGA0");
|
|
mPortToSourceInputMap[SOURCE_VGA] = Tvin_TransPortStringToValue(config_value);*/
|
|
mPortToSourceInputMap[SOURCE_MPEG] = TVIN_PORT_MPEG0;
|
|
/*mPortToSourceInputMap[SOURCE_DTV] = TVIN_PORT_DTV;*/
|
|
mPortToSourceInputMap[SOURCE_IPTV] = TVIN_PORT_BT656;
|
|
mPortToSourceInputMap[SOURCE_SPDIF] = TVIN_PORT_CVBS3;
|
|
}
|
|
|
|
tv_source_input_t CVdin::Tvin_PortToSourceInput ( enum tvin_port_e port )
|
|
{
|
|
for ( int i = SOURCE_TV; i < SOURCE_MAX; i++ ) {
|
|
if ( mPortToSourceInputMap[i] == (int)port ) {
|
|
LOGI("%s port=0x%x tv_source_input_t=%d\n", __FUNCTION__, (int)port, i);
|
|
return (tv_source_input_t)i;
|
|
}
|
|
}
|
|
|
|
return SOURCE_MAX;
|
|
}
|
|
|
|
int CVdin::Tvin_GetVrrFreesyncParm(struct vdin_vrr_freesync_param_s *vrrparm)
|
|
{
|
|
int ret = -1;
|
|
|
|
if (vrrparm == NULL) {
|
|
LOGE("%s vrrparm is NULL\n", __FUNCTION__);
|
|
} else {
|
|
ret = VDIN_GetVrrFreesyncParm(vrrparm);
|
|
}
|
|
|
|
return ret;
|
|
} |