/*
 * 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 "TV"
#define LOG_CLASS_TAG "CTvin"

#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 "CTvin.h"
#include "TvConfigManager.h"
#include "tvutils.h"
#include "CTvLog.h"
#include "CTvResman.h"
#include "CVpp.h"


CTvin *CTvin::mVdinInstance = nullptr;
CTvin *CTvin::mVdin2Instance = nullptr;

CTvin *CTvin::getInstance(int devices)
{
    if (VDIN2 == devices) {
        if (nullptr == mVdin2Instance) {
            mVdin2Instance = new CTvin(VDIN2);
        }
        return mVdin2Instance;
    } else {
        if (nullptr == mVdinInstance) {
            mVdinInstance = new CTvin(VDIN0);
        }
        return mVdinInstance;
    }
}

CTvin::CTvin(int devices):mVdinDevFd(-1),mAfeDevFd(-1),mVdinDevName(-1)
{
    mVdinDevName = devices;
    mDecoderStarted = false;
    mVdinDevFd = VDIN_OpenModule(mVdinDevName);
    mAfeDevFd = AFE_OpenModule();
    memset(&mTvinParam, 0, sizeof(tvin_parm_t));
    memset(mSourceInputToPortMap, SOURCE_INVALID, sizeof(mSourceInputToPortMap));

}

CTvin::~CTvin()
{
    VDIN_CloseModule();
    AFE_CloseModule();
}

int CTvin::VDIN_OpenModule(int devices)
{
    int fd = -1;
    if (VDIN2 == devices) {
        fd = open (VDIN2_DEV_PATH, O_RDWR );
    } else {
        fd = open (VDIN_DEV_PATH, O_RDWR );
    }

    if ( fd < 0 ) {
        LOGE("Open %s error(%s)!\n", VDIN2 == devices? VDIN2_DEV_PATH:VDIN_DEV_PATH, strerror(errno));
        return -1;
    }
    LOGD ( "%s: Open %s module fd = [%d]\n",__FUNCTION__, VDIN2 == devices? VDIN2_DEV_PATH:VDIN_DEV_PATH, fd );
    return fd;
}

int CTvin::VDIN_CloseModule()
{
    if ( mVdinDevFd != -1 ) {
        close ( mVdinDevFd );
        mVdinDevFd = -1;
    }

    return 0;
}

int CTvin::VDIN_DeviceIOCtl ( int request, ... )
{
    int tmp_ret = -1;
    va_list ap;
    void *arg;

    if (mVdinDevFd < 0) {
        mVdinDevFd = VDIN_OpenModule(mVdinDevName);
    }

    if ( mVdinDevFd >= 0 ) {
        va_start ( ap, request );
        arg = va_arg ( ap, void * );
        va_end ( ap );

        tmp_ret = ioctl ( mVdinDevFd, request, arg );
        LOGD ( "%s: ret = %d\n",__FUNCTION__,tmp_ret);
        return tmp_ret;
    }

    return -1;
}

int CTvin::VDIN_OpenPort ( tvin_port_t port )
{
    tvin_parm_s vdinParam;
    vdinParam.port = port;
    vdinParam.index = 0;
    int rt = VDIN_DeviceIOCtl ( TVIN_IOC_OPEN, &vdinParam );
    if ( rt < 0 ) {
        LOGE("Vdin open port, error(%s)!\n", strerror(errno));
    }

    return rt;
}

int CTvin::VDIN_ClosePort()
{
    int rt = VDIN_DeviceIOCtl ( TVIN_IOC_CLOSE );
    if ( rt < 0 ) {
        LOGE("Vdin close port, error(%s)!\n", strerror(errno));
    }

    return rt;
}

int CTvin::VDIN_StartDec(tvin_parm_s *vdinParam)
{
    int ret = -1;
    if ( vdinParam == NULL ) {
        return ret;
    }

    if (!CTvResman::getInstance()->Resman_Request(RESMAN_APP_HDMI_IN, RESMAN_ID_VDPLANE, 10000, NULL)) {
        return ret;
    }

    CVpp::getInstance()->setVideoaxis();

    LOGD("VDIN_StartDec: index = [%d] port = [0x%x] format = [0x%x]\n",
        vdinParam->index, ( unsigned int ) vdinParam->port, ( unsigned int ) ( vdinParam->info.fmt ));
    ret = VDIN_DeviceIOCtl(TVIN_IOC_START_DEC, vdinParam);
    if ( ret < 0 ) {
        LOGE("Vdin start decode, error(%s)!\n", strerror ( errno ));
        CTvResman::getInstance()->Resman_FreeRes(RESMAN_ID_VDPLANE);
    }
    return ret;
}

int CTvin::VDIN_StopDec()
{
    int ret = VDIN_DeviceIOCtl ( TVIN_IOC_STOP_DEC );
    if (ret < 0) {
        LOGE("Vdin stop decode, error(%s).\n", strerror ( errno ));
    }
    CTvResman::getInstance()->Resman_FreeRes(RESMAN_ID_VDPLANE);
    return ret;
}

int CTvin::VDIN_GetSignalEventInfo(vdin_event_info_s *SignalEventInfo)
{
    int ret = VDIN_DeviceIOCtl(TVIN_IOC_G_EVENT_INFO, SignalEventInfo);
    if (ret < 0) {
        LOGE("%s error(%s), ret = %d.\n", __FUNCTION__, strerror(errno), ret);
    }

    return ret;
}

int CTvin::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 CTvin::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: ioctl failed!\n", __FUNCTION__);
        }
    }

    return ret;
}

int CTvin::VDIN_SetVdinParam (tvin_parm_s *vdinParam)
{
    int ret = VDIN_DeviceIOCtl ( TVIN_IOC_S_PARM, vdinParam );
    if ( ret < 0 ) {
        LOGE ( "Vdin set signal param, error(%s).\n", strerror ( errno ) );
    }

    return ret;
}

int CTvin::VDIN_GetVdinParam(tvin_parm_s *vdinParam)
{
    int ret = VDIN_DeviceIOCtl ( TVIN_IOC_G_PARM, vdinParam );
    if ( ret < 0 ) {
        LOGE ( "Vdin get signal param, error(%s).\n", strerror ( errno ) );
    }

    return ret;
}

int CTvin::VDIN_SetColorRangeMode(tvin_color_range_t range_mode)
{
    LOGD("mode = %d\n", range_mode);
    int ret = VDIN_DeviceIOCtl ( TVIN_IOC_SET_COLOR_RANGE, &range_mode );
    if ( ret < 0 ) {
        LOGE ( "Vdin Set ColorRange Mode error(%s)!\n", strerror(errno ));
    }

    return ret;
}

int CTvin::VDIN_GetColorRangeMode(void)
{
    int range_mode = TVIN_COLOR_RANGE_AUTO;
    int ret = VDIN_DeviceIOCtl ( TVIN_IOC_GET_COLOR_RANGE, &range_mode );
    if ( ret < 0 ) {
        LOGE ( "Vdin Get ColorRange Mode error(%s)!\n", strerror(errno ));
    }
    LOGD("%s: mode = %d\n", __FUNCTION__, range_mode);

    return range_mode;
}

// AFE
int CTvin::AFE_OpenModule ( void )
{
    int fd = open ( AFE_DEV_PATH, O_RDWR );
    if ( fd < 0 ) {
        LOGE ( "Open tvafe module, error(%s).\n", strerror ( errno ) );
        return -1;
    }
    LOGD ( "%s: Open %s module fd = [%d]\n",__FUNCTION__, AFE_DEV_PATH, fd );
    return fd;
}

int CTvin::AFE_CloseModule ( void )
{
    if ( mAfeDevFd >= 0 ) {
        close ( mAfeDevFd );
        mAfeDevFd = -1;
    }

    return 0;
}

int CTvin::AFE_DeviceIOCtl ( int request, ... )
{
    int tmp_ret = -1;
    va_list ap;
    void *arg;

    if (mAfeDevFd < 0) {
        mAfeDevFd = AFE_OpenModule();
    }

    if ( mAfeDevFd >= 0 ) {
        va_start ( ap, request );
        arg = va_arg ( ap, void * );
        va_end ( ap );

        tmp_ret = ioctl ( mAfeDevFd, request, arg );
        LOGD ( "%s: ret = %d\n",__FUNCTION__,tmp_ret);
        AFE_CloseModule();

        return tmp_ret;
    }

    return -1;
}

int CTvin::Tvin_OpenPort(tvin_port_t source_port)
{
    LOGD ("%s, source_port = %x!\n", __FUNCTION__,  source_port);

    int ret = VDIN_OpenPort(source_port);

    return ret;
}

int CTvin::Tvin_ClosePort(tvin_port_t source_port)
{
    LOGD ("%s, source_port = %x!\n", __FUNCTION__,  source_port);

    int ret = VDIN_ClosePort();

    return ret;
}

tv_source_input_type_t CTvin::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_IPTV:
            ret = SOURCE_TYPE_IPTV;
            break;
        case SOURCE_SPDIF:
            ret = SOURCE_TYPE_SPDIF;
            break;
        default:
            ret = SOURCE_TYPE_MPEG;
            break;
    }

    return ret;
}

tv_source_input_type_t CTvin::Tvin_SourcePortToSourceInputType ( tvin_port_t source_port )
{
    tv_source_input_t source_input = Tvin_PortToSourceInput(source_port);
    return Tvin_SourceInputToSourceInputType(source_input);
}

tvin_port_t CTvin::Tvin_GetSourcePortBySourceType ( tv_source_input_type_t source_type )
{
    tv_source_input_t source_input;

    switch (source_type) {
        case SOURCE_TYPE_TV:
            source_input = SOURCE_TV;
            break;
        case SOURCE_TYPE_AV:
            source_input = SOURCE_AV1;
            break;
        case SOURCE_TYPE_COMPONENT:
            source_input = SOURCE_YPBPR1;
            break;
        case SOURCE_TYPE_VGA:
            source_input = SOURCE_VGA;
            break;
        case SOURCE_TYPE_HDMI:
            source_input = SOURCE_HDMI1;
            break;
        case SOURCE_TYPE_IPTV:
            source_input = SOURCE_IPTV;
            break;
        case SOURCE_TYPE_SPDIF:
            source_input = SOURCE_SPDIF;
            break;
        default:
            source_input = SOURCE_MPEG;
            break;
    }

    return Tvin_GetSourcePortBySourceInput(source_input);
}

tvin_port_t CTvin::Tvin_GetSourcePortBySourceInput ( tv_source_input_t source_input )
{
    tvin_port_t source_port = TVIN_PORT_NULL;

    if ( source_input < SOURCE_TV || source_input >= SOURCE_MAX ) {
        source_port = TVIN_PORT_NULL;
    } else {
        source_port = ( tvin_port_t ) mSourceInputToPortMap[ ( int ) source_input];
    }

    return source_port;
}

tv_source_input_t CTvin::Tvin_PortToSourceInput ( tvin_port_t port )
{
    for ( int i = SOURCE_TV; i < SOURCE_MAX; i++ ) {
        if ( mSourceInputToPortMap[i] == (int)port ) {
            return (tv_source_input_t)i;
        }
    }

    return SOURCE_MAX;
}

tvin_port_id_t CTvin::Tvin_GetHdmiPortIdBySourceInput(tv_source_input_t source_input)
{
    tvin_port_id_t portId = TVIN_PORT_ID_MAX;
    if ((source_input > SOURCE_HDMI4) || (source_input < SOURCE_HDMI1)) {
        LOGD("%s: not HDMI Source.\n", __FUNCTION__);
    } else {
        tvin_port_t portValue = Tvin_GetSourcePortBySourceInput(source_input);
        switch (portValue) {
        case TVIN_PORT_HDMI0:
            portId = TVIN_PORT_ID_1;
            break;
        case TVIN_PORT_HDMI1:
            portId = TVIN_PORT_ID_2;
            break;
        case TVIN_PORT_HDMI2:
            portId = TVIN_PORT_ID_3;
            break;
        case TVIN_PORT_HDMI3:
            portId = TVIN_PORT_ID_4;
            break;
        }
    }

    LOGD("%s: source: %d, portId: %d.\n", __FUNCTION__, source_input, portId);
    return portId;
}

tvin_port_t CTvin::Tvin_GetVdinPortByVdinPortID(tvin_port_id_t portId)
{
    tvin_port_t portValue = TVIN_PORT_NULL;
    switch (portId) {
    case TVIN_PORT_ID_1:
        portValue = TVIN_PORT_HDMI0;
        break;
    case TVIN_PORT_ID_2:
        portValue =TVIN_PORT_HDMI1;
        break;
    case TVIN_PORT_ID_3:
        portValue = TVIN_PORT_HDMI2;
        break;
    case  TVIN_PORT_ID_4 :
        portValue = TVIN_PORT_HDMI3;
        break;
    default:
        portValue = TVIN_PORT_NULL;
        break;
    }
    LOGD("%s: portId: %d, portValue: 0x%x.\n", __FUNCTION__, portId, portValue);
    return portValue;
}

ui_hdmi_port_id_t CTvin::Tvin_GetUIHdmiPortIdBySourceInput(tv_source_input_t source_input)
{
    ui_hdmi_port_id_t portId = UI_HDMI_PORT_ID_MAX;
    if ((source_input > SOURCE_HDMI4) || (source_input < SOURCE_HDMI1)) {
        LOGD("%s: not HDMI Source.\n", __FUNCTION__);
    } else {
        switch (source_input) {
        case SOURCE_HDMI1:
            portId = UI_HDMI_PORT_ID_1;
            break;
        case SOURCE_HDMI2:
            portId = UI_HDMI_PORT_ID_2;
            break;
        case SOURCE_HDMI3:
            portId = UI_HDMI_PORT_ID_3;
            break;
        case SOURCE_HDMI4:
            portId = UI_HDMI_PORT_ID_4;
            break;
        }
    }

    LOGD("%s: source: %d, UIHDMIportId: %d.\n", __FUNCTION__, source_input, portId);
    return portId;
}

int CTvin::Tvin_GetFrontendInfo(tvin_frontend_info_t *frontendInfo)
{
    int ret = -1;
    if (frontendInfo == NULL) {
        LOGE("%s: frontendInfo is NULL!\n", __FUNCTION__);
    } else {
        ret = VDIN_DeviceIOCtl(TVIN_IOC_G_FRONTEND_INFO, frontendInfo);
        if (ret < 0) {
            LOGE("%s error(%s)!\n", __FUNCTION__, strerror(errno));
        }
    }

    return ret;
}

int CTvin::Tvin_SetColorRangeMode(tvin_color_range_t range_mode)

{
    return VDIN_SetColorRangeMode(range_mode);
}

int CTvin::Tvin_GetColorRangeMode()
{
    return VDIN_GetColorRangeMode();
}

unsigned int CTvin::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_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 CTvin::Tvin_LoadSourceInputToPortMap()
{
    const char *config_value = NULL;
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_ATV, "TVIN_PORT_CVBS3");
    mSourceInputToPortMap[SOURCE_TV] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_AV1, "TVIN_PORT_CVBS1");
    mSourceInputToPortMap[SOURCE_AV1] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_AV2, "TVIN_PORT_CVBS2");
    mSourceInputToPortMap[SOURCE_AV2] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_YPBPR1, "TVIN_PORT_COMP0");
    mSourceInputToPortMap[SOURCE_YPBPR1] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_YPBPR2, "TVIN_PORT_COMP1");
    mSourceInputToPortMap[SOURCE_YPBPR2] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_HDMI1, "TVIN_PORT_HDMI0");
    mSourceInputToPortMap[SOURCE_HDMI1] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_HDMI2, "TVIN_PORT_HDMI2");
    mSourceInputToPortMap[SOURCE_HDMI2] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_HDMI3, "TVIN_PORT_HDMI1");
    mSourceInputToPortMap[SOURCE_HDMI3] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_HDMI4, "TVIN_PORT_HDMI3");
    mSourceInputToPortMap[SOURCE_HDMI4] = Tvin_TransPortStringToValue(config_value);
    config_value = ConfigGetStr(CFG_SECTION_SRC_INPUT, CFG_TVCHANNEL_VGA, "TVIN_PORT_VGA0");
    mSourceInputToPortMap[SOURCE_VGA] = Tvin_TransPortStringToValue(config_value);
    mSourceInputToPortMap[SOURCE_MPEG] = TVIN_PORT_MPEG0;
    mSourceInputToPortMap[SOURCE_IPTV] = TVIN_PORT_BT656;
    mSourceInputToPortMap[SOURCE_SPDIF] = TVIN_PORT_CVBS3;
}

int CTvin::Tvin_StartDecoder(tvin_info_t info)
{
    if (mDecoderStarted) {
        LOGD("decoder already started.\n");
        return 0;
    } else {
        mTvinParam.info = info;
        if (VDIN_StartDec(&mTvinParam) >= 0 ) {
            LOGD("StartDecoder succeed.\n");
            mDecoderStarted = true;
            return 0;
        } else {
            LOGE("StartDecoder failed.\n");
            mDecoderStarted = false;
            return -1;
        }
    }
}

int CTvin::Tvin_StopDecoder()
{
    if (!mDecoderStarted) {
        LOGD("Decoder don't started!\n");
        return 0;
    } else {
        if ( VDIN_StopDec() >= 0 ) {
            LOGD("StopDecoder ok!\n");
            mDecoderStarted = false;
            return 0;
        } else {
            LOGE("StopDecoder failed!\n");
            mDecoderStarted = false;
            return -1;
        }
    }
}

int CTvin::Tvin_SwitchSnow(bool enable)
{
    int ret = -1;
    if ( enable ) {
        LOGD("%s: set snow enable\n", __FUNCTION__ );
        ret = AFE_DeviceIOCtl( TVIN_IOC_S_AFE_SNOW_ON );
        ret = VDIN_DeviceIOCtl( TVIN_IOC_SNOW_ON );
    } else {
        LOGD("%s: set snow disable\n", __FUNCTION__ );
        ret = AFE_DeviceIOCtl( TVIN_IOC_S_AFE_SNOW_OFF );
        ret = VDIN_DeviceIOCtl( TVIN_IOC_SNOW_OFF );
    }

    return ret;
}

int CTvin::Tvin_GetSignalEventInfo(vdin_event_info_s *SignalEventInfo)
{
    int ret = -1;
    if (SignalEventInfo == NULL) {
        LOGE("Tvin_GetSignalEventInfo: SignalEventInfo is NULL.\n");
    } else {
        ret = VDIN_GetSignalEventInfo(SignalEventInfo);
    }

    return ret;
}

int CTvin::Tvin_GetSignalInfo(tvin_info_s *SignalInfo)
{
    int ret = -1;
    if (SignalInfo == NULL) {
        LOGE("Tvin_GetSignalInfo: SignalInfo is NULL.\n");
    } else {
        ret = VDIN_GetSignalInfo(SignalInfo);
    }

    return ret;
}

int CTvin::Tvin_GetAllmInfo(tvin_latency_s *AllmInfo)
{
    int ret = -1;

    if (AllmInfo == NULL)
        LOGE("%s: param is NULL;\n", __FUNCTION__);
    else
        ret = VDIN_GetAllmInfo(AllmInfo);

    return ret;
}

int CTvin::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 CTvin::VDIN_GetQmsParm(vdin_qms_param_s *qms_parm)
{
    int ret = -1;
    if (qms_parm == NULL) {
            LOGE("%s: param is NULL\n", __FUNCTION__);
    } else {
        ret = VDIN_DeviceIOCtl(TVIN_IOC_G_QMS_STATUS, qms_parm);
        if (ret < 0) {
            LOGE("%s failed, error(%s)!", __FUNCTION__, strerror(errno));
        }
    }
    return ret;
}

int CTvin::Tvin_GetVdinDeviceFd(void)
{
    int ret = -1;
    if (mVdinDevFd < 0) {
        ret = VDIN_OpenModule(mVdinDevName);
    } else {
        ret = mVdinDevFd;
    }

    return ret;
}

int CTvin::VDIN_AddPath ( const char *videopath )
{
    if (strlen(videopath) > 1024) {
        LOGE("video path too long\n");
        return -1;
    }

    char str[1024 + 1] = {0};
    sprintf (str, "%s", videopath);
    return tvWriteSysfs(SYS_VFM_MAP_PATH, str);
}

int CTvin::VDIN_RemovePath(tv_path_type_t pathtype)

{
    int ret = -1;
    switch (pathtype) {
        case TV_PATH_TYPE_DEFAULT:
            ret = tvWriteSysfs(SYS_VFM_MAP_PATH, "rm default");
            break;
        case TV_PATH_TYPE_TVIN:
            ret = tvWriteSysfs(SYS_VFM_MAP_PATH, "rm tvpath");
            break;
        case TV_PATH_TYPE_DVHDMIIN:
            ret = tvWriteSysfs(SYS_VFM_MAP_PATH, "rm dvhdmiin");
        default:
            LOGE("invalie videopath type!\n");
            break;
    }
    return ret;
}

int CTvin::Tvin_AddVideoPath(int selPath)
{
    int ret = -1;
    std::string vdinPath;
    std::string suffixVideoPath("deinterlace amvideo");
    std::string videoqueuePath("videoqueue.0 ");
    bool amlvideo2Exist = isFileExist(AMLVIDEO2_DEV_PATH);
    bool diBackend = isDiBackend();

    switch ( selPath ) {
    case TV_PATH_VDIN_AMLVIDEO2_PPMGR_DEINTERLACE_AMVIDEO:
        ret = VDIN_RemovePath(TV_PATH_TYPE_TVIN);
        if (amlvideo2Exist)
            vdinPath = "add tvpath vdin0 amlvideo2.0 ";
        else
            vdinPath = "add tvpath vdin0 ";
        break;

    case TV_PATH_DECODER_AMLVIDEO2_PPMGR_DEINTERLACE_AMVIDEO:
        if (amlvideo2Exist)
            vdinPath = "add default decoder amlvideo2.0 ppmgr ";
        else
            vdinPath = "add default decoder ppmgr ";
        break;
    default:
        break;
    }

#ifdef USE_AMVIDEO
    vdinPath += suffixVideoPath;
#else
    if (diBackend) {
        vdinPath += videoqueuePath;
    } else {
        vdinPath += suffixVideoPath;
    }
#endif

    ret = VDIN_AddPath (vdinPath.c_str());

    if (diBackend && (selPath == TV_PATH_VDIN_AMLVIDEO2_PPMGR_DEINTERLACE_AMVIDEO)) {
        std::string vdinDvPath = "add dvhdmiin dv_vdin videoqueue.0";
        ret = VDIN_RemovePath(TV_PATH_TYPE_DVHDMIIN);
        if (ret > 0) {
            LOGD("remove hdmidv path ok\n");
            ret = VDIN_AddPath(vdinDvPath.c_str());
            if (ret > 0)
                LOGD("add hdmidv path ok\n");
            else
                LOGE("add hdmidv path failed\n");
        } else {
            LOGE("remove hdmidv path failed\n");
        }
    }

    return ret;
}

int CTvin::Tvin_RemoveVideoPath(tv_path_type_t pathtype)
{
    int ret = -1;
    int i = 0, dly = 10;
    for ( i = 0; i < 50; i++ ) {
        ret = VDIN_RemovePath(pathtype);
        if ( ret > 0 ) {
            LOGE("remove default path ok, %d ms gone.\n", (dly * i));
            break;
        } else {
            LOGE("remove default path faild, %d ms gone.\n", (dly * i));
            usleep(dly * 1000);
        }
    }
      return ret;
}

int CTvin::Tvin_CheckVideoPathComplete(tv_path_type_t path_type)
{
    int ret = -1;
    FILE *fp = NULL;
    char path[100] = {0};
    char decoder_str[20] = "default {";
    char tvin_str[20] = "tvpath {";
    char *str_find = NULL;
    char di_str[16] = "deinterlace";
    char ppmgr_str[16] = "ppmgr";
    char amvideo_str[16] = "amvideo";

    fp = fopen(SYS_VFM_MAP_PATH, "r");
    if (!fp) {
        LOGE("%s, can not open %s!\n", __FUNCTION__, SYS_VFM_MAP_PATH);
        return ret;
    }

    while (fgets(path, sizeof(path)-1, fp)) {
        if (path_type == TV_PATH_TYPE_DEFAULT) {
            str_find = strstr(path, decoder_str);
        } else if (path_type == TV_PATH_TYPE_TVIN) {
            str_find = strstr(path, tvin_str);
        } else {
            break;
        }

        if (str_find != NULL) {
            if ((strstr(str_find, di_str)) &&
                 (strstr(str_find, ppmgr_str)) &&
                 (strstr(str_find, amvideo_str))) {
                LOGD("VideoPath is complete!\n");
                ret = 0;
            } else {
                LOGD("VideoPath is not complete!\n");
                ret = -1;
            }
            break;
        }
    }

    fclose(fp);
    fp = NULL;

    return ret;
}