/*
 * Copyright (c) 2019 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:
 */
#define LOG_MODULE_TAG "TV"
#define LOG_CLASS_TAG "CTv"

#include <stdint.h>
#include <string.h>

#include "CTv.h"
#include "tvutils.h"
#include "TvConfigManager.h"
#include "CTvLog.h"
#include "CVpp.h"
#include <sys/ioctl.h>
#include <chrono>
#include "CVrr.h"

/*
static tv_hdmi_edid_version_t Hdmi1CurrentEdidVer = HDMI_EDID_VER_14;
static tv_hdmi_edid_version_t Hdmi2CurrentEdidVer = HDMI_EDID_VER_14;
static tv_hdmi_edid_version_t Hdmi3CurrentEdidVer = HDMI_EDID_VER_14;
static tv_hdmi_edid_version_t Hdmi4CurrentEdidVer = HDMI_EDID_VER_14;
*/
#define NEW_FRAME_TIME_OUT_COUNT 10

//PORT_NUM define as 3 in the kernel.
#define K_PORT_NUM (3)

CTv::CTv()
{
    mpObserver = NULL;
    UenvInit();
    const char* tvConfigFilePath = getenv(CFG_TV_CONFIG_FILE_PATH_STR);
    if (!tvConfigFilePath) {
        LOGD("%s: read tvconfig file path failed!\n", __FUNCTION__);
        tvConfigFilePath = CONFIG_FILE_PATH_DEF;
    } else {
        LOGD("%s: tvconfig file path is %s!\n", __FUNCTION__, tvConfigFilePath);
    }
    LoadConfigFile(tvConfigFilePath);

    const char * value;
    value = ConfigGetStr( CFG_SECTION_TV, CFG_TVIN_ATV_DISPLAY_SNOW, "null" );
    if (strcmp(value, "enable") == 0 ) {
        mATVDisplaySnow = true;
    } else {
        mATVDisplaySnow = false;
    }
    LOGD("%s: load mATVDisplaySnow status [%d]!\n", __FUNCTION__, mATVDisplaySnow);

    mpAmVideo = new CAmVideo();
    mpTvin = CTvin::getInstance();
    mpTvin->Tvin_AddVideoPath(TV_PATH_VDIN_AMLVIDEO2_PPMGR_DEINTERLACE_AMVIDEO);
    mpTvin->Tvin_LoadSourceInputToPortMap();
    if (IsSupportPIP()) {
        mpPipTvin = CTvin::getInstance(VDIN2);
        mpPipTvin->Tvin_LoadSourceInputToPortMap();
        mpTvSubDisplayadapter = new CTvDisplayadapter(SUB_WINDOW);
    }
    mpTvMainDisplayadapter = new CTvDisplayadapter(MAIN_WINDOW);
    mpHDMIRxManager = new CHDMIRxManager();
    // update cec port sequence from hdmi tv config.
    mpHDMIRxManager->SetHdmiPortCecPhysicAddr();
    mpTvWayland = new CTvWayland();

    tvin_info_t signalInfo;
    signalInfo.trans_fmt = TVIN_TFMT_2D;
    signalInfo.fmt = TVIN_SIG_FMT_NULL;
    signalInfo.status = TVIN_SIG_STATUS_NULL;
    signalInfo.cfmt = TVIN_COLOR_FMT_MAX;
    signalInfo.signal_type= 0;
    signalInfo.fps = 60;
    signalInfo.is_dvi = 0;
    signalInfo.aspect_ratio = TVIN_ASPECT_NULL;
    SetCurrenSourceInfo(signalInfo);
    SetCurrentPipSourceInfo(signalInfo);

    //EDID load
    int edidAutoLoadEnable = ConfigGetInt(CFG_SECTION_HDMI, CFG_HDMI_EDID_AUTO_LOAD_EN, 1);
    if (edidAutoLoadEnable == 1) {
        LOGD("%s: EDID data load by tvserver!\n", __FUNCTION__);
        mInitEdid = true;
        const char* buf = GetUenv(HDMI_UBOOT_EDID_VERSION);
        if (buf == NULL) {
            const char* edidDefaultVersion = ConfigGetStr(CFG_SECTION_HDMI, CFG_HDMI_EDID_DEFAULT_VERSION, "1.4");
            int edidSetValue = 0;
            if (strcmp(edidDefaultVersion, "2.0") == 0 ) {
                LOGD("%s: Set EDID default version to 2.0!\n", __FUNCTION__);
                /*
                Hdmi1CurrentEdidVer = HDMI_EDID_VER_20;
                Hdmi2CurrentEdidVer = HDMI_EDID_VER_20;
                Hdmi3CurrentEdidVer = HDMI_EDID_VER_20;
                Hdmi4CurrentEdidVer = HDMI_EDID_VER_20;
                */
                for (int i = 0;i < 4; i ++)
                    edidSetValue |=  (1 << (4*i));
            }
            SetUenv(HDMI_UBOOT_EDID_VERSION,  std::to_string(edidSetValue).c_str());
        }
        if (GetHdmiDlgEnabled()) {
            mDlgVisionEnableState = true;
        }
        bool dolbyVisionEnableState = GetDolbyVisionSupportStatus();
        LoadEdidDataWithPort(0, dolbyVisionEnableState);
    } else {
        LOGD("%s: EDID data load by customer!\n", __FUNCTION__);
    }
    mTvDevicesPollDetect.setObserver(this);
    mTvDevicesPollDetect.startDetect();
    mTvMsgQueue = new CTvMsgQueue(this);
    mTvMsgQueue->startMsgQueue();
    mLastScreenMode = -1;

    //panel tconless init
    CTvPanel *mPanel = CTvPanel::getInstance();
    mPanel->AM_PANEL_Init();
}

CTv::~CTv()
{
    if (mpTvin != NULL) {
        mpTvin->Tvin_RemoveVideoPath(TV_PATH_TYPE_TVIN);
        delete mpTvin;
        mpTvin = NULL;
    }

    if (mpHDMIRxManager != NULL) {
        delete mpHDMIRxManager;
        mpHDMIRxManager = NULL;
    }

    if (mpAmVideo != NULL) {
        delete mpAmVideo;
        mpAmVideo = NULL;
    }

    mpObserver = NULL;
    UnloadConfigFile();
}

int CTv::StartTv(tv_source_input_t source)
{
    LOGD("%s: source = %d!\n", __FUNCTION__, source);
    int ret = 0;

    if (SOURCE_MPEG == source) {
    LOGD("%s: new source is %d! RETURN\n", __FUNCTION__,source);
    return ret;
    }

    mpTvWayland->setMainTunnelId(0);
    mpTvWayland->startMainVideo();
    mpTvWayland->commitAll();

    //main source set 0, 0 as default
    mpTvMainDisplayadapter->TV_setDisplayadapterParam(0,0);
    mpTvMainDisplayadapter->TV_dispAdptCreateLayer();
    mpTvMainDisplayadapter->TV_dispAdptSetLayerZorder(0);

    int freerun_mode = 0;
    mpAmVideo->AmVideoDeviceIOCtl(AMSTREAM_IOC_SET_FREERUN_MODE, &freerun_mode);
    //CVpp::getInstance()->setVideoaxis();//when open source set video axis full screen

    tvin_port_t source_port = mpTvin->Tvin_GetSourcePortBySourceInput(source);
    ret = mpTvin->Tvin_OpenPort(source_port);
    mCurrentSource = source;
    mCurrentSourceType = mpTvin->Tvin_SourceInputToSourceInputType(mCurrentSource);
#ifdef HAVE_AUDIO
    CTvAudio::getInstance()->create_audio_patch(TV_CHANNEL_MAIN, mapSourcetoAudiotupe(source));

    if (AvAudioMode && SOURCE_TYPE_AV == mCurrentSourceType) {
        CTvAudio::getInstance()->set_audio_av_audio_only_enabled(true);
        CTvAudio::getInstance()->set_audio_av_mute(false);
    } else {
        CTvAudio::getInstance()->set_audio_av_mute(true);
    }

#endif
    return ret;
}

int CTv::StopTv(tv_source_input_t source)
{
    LOGD("%s: source = %d!\n", __FUNCTION__, source);
    int ret = 0;
    if (SOURCE_MPEG == source) {
    LOGD("%s:current source is %d! return\n", __FUNCTION__,source);
    return ret;
    }

#ifdef HAVE_AUDIO
    CTvAudio::getInstance()->release_audio_patch(TV_CHANNEL_MAIN);
    CTvAudio::getInstance()->set_audio_av_mute(false);
#endif

    mpTvWayland->stopMainVideo();
    if (mCurrentPipSource == SOURCE_INVALID) {
        mpTvWayland->shutdown();
    }

    mpTvMainDisplayadapter->TV_dispAdptDestroyLayer();
    mpAmVideo->SetVideoLayerStatus(VIDEO_LAYER_STATUS_DISABLE);
    mpAmVideo->SetVideoGlobalOutputMode(VIDEO_GLOBAL_OUTPUT_MODE_DISABLE);
    mpTvin->Tvin_StopDecoder();
    tvin_port_t source_port = mpTvin->Tvin_GetSourcePortBySourceInput(source);
    mpTvin->Tvin_ClosePort(source_port);

    mVdinWorkMode = VDIN_WORK_MODE_VFM;
    mCurrentSource = SOURCE_INVALID;
    mCurrentSourceType = SOURCE_TYPE_MPEG;
    tvin_info_t tempSignalInfo;
    tempSignalInfo.trans_fmt = TVIN_TFMT_2D;
    tempSignalInfo.fmt = TVIN_SIG_FMT_NULL;
    tempSignalInfo.status = TVIN_SIG_STATUS_NULL;
    tempSignalInfo.cfmt = TVIN_COLOR_FMT_MAX;
    tempSignalInfo.signal_type= 0;
    tempSignalInfo.fps = 60;
    tempSignalInfo.is_dvi = 0;
    tempSignalInfo.aspect_ratio = TVIN_ASPECT_NULL;
    SetCurrenSourceInfo(tempSignalInfo);

    return ret;
}

int CTv::SwitchSource(tv_source_input_t dest_source)
{
    if (dest_source != mCurrentSource) {
        StopTv(mCurrentSource);
        StartTv(dest_source);
    } else {
        LOGD("same source,no need switch!\n");
    }

    return 0;
}

tv_source_input_t CTv::GetCurrentSource() {
  return mCurrentSource;
}

void CTv::onSourceConnect(int source, int connect_status)
{
    LOGD("onSourceConnect: source = %d, connect_status= %d!\n", source, connect_status);
    //To do
    TvEvent::SourceConnectEvent event;
    event.mSourceInput = source;
    event.connectionState = connect_status;
    sendTvEvent(event);
}

void CTv::onVdinSignalChange()
{
    vdin_event_info_s SignalEventInfo;
    memset(&SignalEventInfo, 0, sizeof(vdin_event_info_s));
    int ret  = mpTvin->Tvin_GetSignalEventInfo(&SignalEventInfo);
    if (ret < 0) {
        LOGD("Get vidn event error!\n");
    } else {
        tv_source_input_type_t source_type = mpTvin->Tvin_SourceInputToSourceInputType(mCurrentSource);
        tvin_sig_change_flag_t vdinEventType = (tvin_sig_change_flag_t)SignalEventInfo.event_sts;
        switch (vdinEventType) {
        case TVIN_SIG_CHG_SDR2HDR:
        case TVIN_SIG_CHG_HDR2SDR:
        case TVIN_SIG_CHG_DV2NO:
        case TVIN_SIG_CHG_NO2DV: {
            LOGD("%s: hdr info change!\n", __FUNCTION__);
            tvin_info_t vdinSignalInfo;
            memset(&vdinSignalInfo, 0, sizeof(tvin_info_t));
            ret = mpTvin->Tvin_GetSignalInfo(&vdinSignalInfo);
            if (ret < 0) {
                LOGD("%s: Get vidn event error!\n", __FUNCTION__);
            } else {
                if ((mCurrentSignalInfo.status == TVIN_SIG_STATUS_STABLE) && (mCurrentSignalInfo.signal_type != vdinSignalInfo.signal_type)) {
                    if (source_type == SOURCE_TYPE_HDMI) {
                        //tvSetCurrentHdrInfo(vdinSignalInfo.signal_type);
                    }
                    mCurrentSignalInfo.signal_type = vdinSignalInfo.signal_type;
                } else {
                    LOGD("%s: hdmi signal don't stable!\n", __FUNCTION__);
                }
            }
            break;
        }
        case TVIN_SIG_CHG_COLOR_FMT:
            LOGD("%s: no need do any thing for colorFmt change!\n", __FUNCTION__);
            break;
        case TVIN_SIG_CHG_RANGE:
            LOGD("%s: no need do any thing for colorRange change!\n", __FUNCTION__);
            break;
        case TVIN_SIG_CHG_BIT:
            LOGD("%s: no need do any thing for color bit deepth change!\n", __FUNCTION__);
            break;
        case TVIN_SIG_CHG_VS_FRQ:
            LOGD("%s: no need do any thing for VS_FRQ change!\n", __FUNCTION__);
            break;
        case TVIN_SIG_CHG_STS:
            LOGD("%s: vdin signal status change!\n", __FUNCTION__);
            onSigStatusChange();
            break;
        case TVIN_SIG_CHG_AFD: {
            LOGD("%s: AFD info change!\n", __FUNCTION__);
            if (source_type == SOURCE_TYPE_HDMI) {
                tvin_info_t newSignalInfo;
                memset(&newSignalInfo, 0, sizeof(tvin_info_t));
                int ret = mpTvin->Tvin_GetSignalInfo(&newSignalInfo);
                if (ret < 0) {
                    LOGD("%s: Get Signal Info error!\n", __FUNCTION__);
                } else {
                    if ((newSignalInfo.status == TVIN_SIG_STATUS_STABLE)
                        && (mCurrentSignalInfo.aspect_ratio != newSignalInfo.aspect_ratio)) {
                        mCurrentSignalInfo.aspect_ratio = newSignalInfo.aspect_ratio;
                        //tvSetCurrentAspectRatioInfo(newSignalInfo.aspect_ratio);
                    } else {
                        LOGD("%s: signal not stable or same AFD info!\n", __FUNCTION__);
                    }
                }
            }
            break;
        }
        case TVIN_SIG_CHG_DV_ALLM:
            LOGD("%s: allm info change!\n", __FUNCTION__);
            if (source_type == SOURCE_TYPE_HDMI) {
                onSigDvAllmChange();
            } else {
                LOGD("%s: not hdmi source!\n", __FUNCTION__);
            }
            break;
        case TVIN_SIG_CHG_VRR:
            LOGD("%s: vrr change!\n", __FUNCTION__);
            if (source_type == SOURCE_TYPE_HDMI) {
                onSigVrrChange();
            } else {
                LOGD("%s: not hdmi source!\n", __FUNCTION__);
            }
            break;
        case TVIN_SIG_CHG_QMS: {
                if (GetHdmiQmsEnabled()) {
                    LOGD("%s: QMS change!\n", __FUNCTION__);
                    vdin_qms_param_t qmsInfo;
                    memset(&qmsInfo, 0, sizeof(vdin_qms_param_t));
                    int ret = mpTvin->VDIN_GetQmsParm(&qmsInfo);
                    if (ret < 0) {
                        LOGD("%s: Get QMS Info error!\n", __FUNCTION__);
                    } else if (TVIN_SIG_STATUS_STABLE == mCurrentSignalInfo.status) {
                        LOGD("%s: send QMS change event,qms_en:%d, qms_fr：%d, qms_base_fr: %d, fps: %d!\n",
                            __FUNCTION__,qmsInfo.qms_en, qmsInfo.qms_fr, qmsInfo.qms_base_fr, mCurrentSignalInfo.fps);
                        TvEvent::QMSEvent ev;
                        ev.qms_en = (int)qmsInfo.qms_en;
                        ev.qms_fps = (int)qmsInfo.qms_fr;
                        ev.qms_base_fps = qmsInfo.qms_en ? (int)qmsInfo.qms_base_fr:(int)(mCurrentSignalInfo.fps * 1000);
                        sendTvEvent ( ev );
                    } else {
                        LOGD("%s: invalid qms event!\n", __FUNCTION__);
                    }
                } else {
                    LOGD("%s: qms switch closed!\n", __FUNCTION__);
                }
                break;
            }
        default:
            LOGD("%s: invalid vdin event!\n", __FUNCTION__);
            break;
        }
    }
}

void CTv::onSigDvAllmChange(void)
{
    tvin_latency_s AllmInfo;

    int ret = mpTvin->Tvin_GetAllmInfo(&AllmInfo);
	if (ret < 0) {
        LOGE("%s: mpTvin->Tvin_GetAllmInfo() failed!\n", __FUNCTION__);
        return;
    }

    TvEvent::SignalDvAllmEvent event;
    event.allm_mode = static_cast<int>(AllmInfo.allm_mode);
    event.it_content = AllmInfo.it_content ? 1 : 0;
    event.cn_type = AllmInfo.cn_type;
    sendTvEvent(event);
}

int CTv::GetCurrentSourceAllmInfo(tvin_latency_s *info)
{
    int ret = mpTvin->Tvin_GetAllmInfo(info);
	  if (ret < 0) {
        LOGE("%s: mpTvin->Tvin_GetAllmInfo() failed!\n", __FUNCTION__);
    }
    return ret;
}

void CTv::onSigVrrChange(void)
{
    vdin_vrr_freesync_param_s vrrparm;

    int ret = mpTvin->VDIN_GetVrrFreesyncParm(&vrrparm);
    if (ret < 0) {
        LOGE("%s: mpTvin->VDIN_GetVrrFreesyncParm() failed!\n", __FUNCTION__);
        return;
    }

    TvEvent::SignalVrrEvent event;
    event.cur_vrr_status = vrrparm.cur_vrr_status;
    sendTvEvent(event);
}

vdin_vrr_mode_t CTv::GetHdmiVrrMode() {
    vdin_vrr_freesync_param_s vrrparm;
    int ret = mpTvin->VDIN_GetVrrFreesyncParm(&vrrparm);
    if (ret < 0) {
        LOGE("%s: mpTvin->VDIN_GetVrrFreesyncParm() failed!\n", __FUNCTION__);
        return (vdin_vrr_mode_t)0;
    }
    return (vdin_vrr_mode_t)vrrparm.cur_vrr_status;
}

void CTv::onSigStatusChange(void)
{
    LOGD("%s\n", __FUNCTION__);
    tvin_info_s tempSignalInfo;
    int ret = mpTvin->Tvin_GetSignalInfo(&tempSignalInfo);
    if (ret < 0) {
        LOGD("Get Signal Info error!\n");
        return;
    } else {
        SetCurrenSourceInfo(tempSignalInfo);
        LOGD("sig_fmt is %d, status is %d, isDVI is %d, hdr_info is 0x%x\n",
               mCurrentSignalInfo.fmt, mCurrentSignalInfo.status, mCurrentSignalInfo.is_dvi, mCurrentSignalInfo.signal_type);
        if ( mCurrentSignalInfo.status == TVIN_SIG_STATUS_STABLE ) {
            setDisplayCrop(MAIN_WINDOW);
            onSigToStable();
        } else if (mCurrentSignalInfo.status == TVIN_SIG_STATUS_UNSTABLE ) {
            onSigToUnstable();
        } else if ( mCurrentSignalInfo.status == TVIN_SIG_STATUS_NOTSUP ) {
            onSigToUnSupport();
        } else if ( mCurrentSignalInfo.status == TVIN_SIG_STATUS_NOSIG ) {
            onSigToNoSig();
        } else {
            LOGD("%s: invalid signal status!\n",__FUNCTION__);
        }

        return;
    }
}

int CTv::SetCurrenSourceInfo(tvin_info_t sig_info)
{
    mCurrentSignalInfo.trans_fmt = sig_info.trans_fmt;
    mCurrentSignalInfo.fmt = sig_info.fmt;
    mCurrentSignalInfo.status = sig_info.status;
    mCurrentSignalInfo.cfmt = sig_info.cfmt;
    mCurrentSignalInfo.signal_type= sig_info.signal_type;
    mCurrentSignalInfo.fps = sig_info.fps;
    mCurrentSignalInfo.is_dvi = sig_info.is_dvi;
    mCurrentSignalInfo.aspect_ratio = sig_info.aspect_ratio;

    return 0;
}

tvin_info_t CTv::GetCurrentSourceInfo(void)
{
    LOGD("mCurrentSource = %d, trans_fmt is %d,fmt is %d, status is %d.\n",
            mCurrentSource, mCurrentSignalInfo.trans_fmt, mCurrentSignalInfo.fmt, mCurrentSignalInfo.status);
    return mCurrentSignalInfo;
}

int CTv::setTvObserver ( TvIObserver *ob )
{
    LOGD("%s\n", __FUNCTION__);
    if (ob != NULL) {
        mpObserver = ob;
    } else {
        LOGD("%s: Observer is NULL.\n", __FUNCTION__);
    }

    return 0;
}

int CTv::SetEdidData(tv_source_input_t source, char *data)
{
    LOGD("%s\n", __FUNCTION__);
    int ret = -1;
    if (data == NULL) {
        LOGD("%s: data is NULL.\n", __FUNCTION__);
    } else {
        unsigned char edidData[REAL_EDID_DATA_SIZE];
        memcpy(edidData, data, REAL_EDID_DATA_SIZE);
        tvin_port_id_t portId = mpTvin->Tvin_GetHdmiPortIdBySourceInput(source);
        ret = mpHDMIRxManager->UpdataEdidDataWithPort(portId, edidData);
    }

    return ret;
}

int CTv::GetEdidData(tv_source_input_t source, char *data)
{
    char edidData[REAL_EDID_DATA_SIZE];
    char edidFileName[100] = {0};
    int port = (int)source - SOURCE_HDMI1 + 1;
    int edidVer = (GetEdidVersion(source) == HDMI_EDID_VER_20)?20:14;
    char dv_support[4] = {0};

    const char *edidFilePath = ConfigGetStr(CFG_SECTION_HDMI, CFG_HDMI_EDID_FILE_PATH, "/vendor/etc/tvconfig/hdmi");

    if (GetDolbyVisionSupportStatus() == 1)
        strcpy(dv_support, "_dv");

    memset(edidData, 0, REAL_EDID_DATA_SIZE);
    sprintf(edidFileName, "%s/port%d_%d%s.bin", edidFilePath, port, edidVer, dv_support);
    LOGD("%s: EDID file: %s\n", __FUNCTION__, edidFileName);
    ReadDataFromFile(edidFileName, 0, REAL_EDID_DATA_SIZE, edidData);
    memcpy(data, edidData, REAL_EDID_DATA_SIZE);
    return 0;
}

#define MMC_DEVICE      ("/dev/mmcblk0")
#define PANEL_ID_OFFSET 0x9000004
int CTv::GetPanelSize()
{
    int fd, len, panelSize=0;
    off_t offset = 0L;
    char buf[2] = {0}, psize[8]={0};

    if ((fd = open(MMC_DEVICE, O_RDONLY)) < 0) {
        LOGE("open %s error(%s)", MMC_DEVICE, strerror (errno));
        return 0;
    }

    offset = lseek (fd, PANEL_ID_OFFSET, SEEK_SET);
    if ( offset !=  PANEL_ID_OFFSET ) {
        LOGE("Failed to seek. offset[0x%x] requested[0x%x]\n", (uint32_t)offset, PANEL_ID_OFFSET);
        close(fd);
        return 0;
    }

    len = read(fd, buf, 2);
    if (len < 0) {
        LOGE("Read %s error, %s\n", MMC_DEVICE, strerror(errno));
        close(fd);
        return 0;
    }
    sprintf(psize, "%d", buf[1]);
    panelSize = atoi(psize);

    close(fd);
    return panelSize;
}

int CTv::LoadEdidData(int isNeedBlackScreen, int isDolbyVisionEnable)
{
    if (isNeedBlackScreen  == 1) {
        mpTvin->Tvin_StopDecoder();
    }

    char edidLoadBuf[(TVIN_PORT_ID_MAX - 1) * 2 * REAL_EDID_DATA_SIZE];
    char edidFileName[100] = {0};
    int loadNum = 1;
    int i = 0;
    tvin_port_t tvin_port = TVIN_PORT_NULL;
    ui_hdmi_port_id_t ui_port = UI_HDMI_PORT_ID_MAX;
    tv_source_input_t source_input;
    const char *edidFilePath = ConfigGetStr(CFG_SECTION_HDMI,
            CFG_HDMI_EDID_FILE_PATH,
            "/vendor/etc/tvconfig/hdmi");
    LOGD("%s: sizeof edidLoadBuf:[%d] isDolbyVisionEnable = %d.\n",
            __FUNCTION__,
            sizeof(edidLoadBuf),
            isDolbyVisionEnable);
    memset(edidLoadBuf, 0, sizeof(edidLoadBuf));
    for (loadNum = (int)TVIN_PORT_ID_1; loadNum < (int)TVIN_PORT_ID_MAX; loadNum++) {
        tvin_port = mpTvin->Tvin_GetVdinPortByVdinPortID((tvin_port_id_t)loadNum);
        source_input = mpTvin->Tvin_PortToSourceInput(tvin_port);
        ui_port = mpTvin->Tvin_GetUIHdmiPortIdBySourceInput(source_input);
        LOGD("%s:tvin port ID:%d tvin_port:0x%x source_input:%d ui_port:%d\n",
                __FUNCTION__,
                loadNum,
                tvin_port,
                source_input,
                ui_port);

        // Load EDID 1.4 then load EDID 2.0.
        for (i = 0; i < 2; i++) {
            /* sprintf will add a null-terminated character ('\0') at the end of
               the formatted string. So, do not need to memset the buffer.*/
            sprintf(edidFileName, "%s/port%d_%s%s.bin",
                    edidFilePath,
                    ui_port,
                    i ? "20" : "14",
                    isDolbyVisionEnable ? "_dv" : "");
            if (!isFileExist(edidFileName))
                sprintf(edidFileName, "%s/port%d_%s%s.bin",
                        edidFilePath,
                        UI_HDMI_PORT_ID_1,
                        i ? "20" : "14",
                        isDolbyVisionEnable ? "_dv" : "");
            ReadDataFromFile(edidFileName,
                    0,
                    REAL_EDID_DATA_SIZE,
                    edidLoadBuf + (2 * loadNum - 2 + i) * REAL_EDID_DATA_SIZE);
            LOGD("%s:File:%s\n", __FUNCTION__, edidFileName);
        }
    }
    int ret = mpHDMIRxManager->HdmiRxEdidDataSwitch(2 * K_PORT_NUM, edidLoadBuf);
    if (ret == 0) {
        ui_hdmi_port_id_t portId = UI_HDMI_PORT_ID_MAX;
        int edidSetValue = 0;
        int portEdidVersion = 0;
        for (int i=SOURCE_HDMI1;i<SOURCE_VGA;i++) {
            portId = mpTvin->Tvin_GetUIHdmiPortIdBySourceInput((tv_source_input_t)i);
            portEdidVersion = GetEdidVersion((tv_source_input_t)i);
            edidSetValue |=  (portEdidVersion << (4*portId - 4));
        }
        LOGD("%s:[edidSetValue:0x%x]", __FUNCTION__, edidSetValue);
        //for HDMI feature(allm,vrr,qms) status init
        const char *buf = GetUenv(HDMI_UBOOT_EDID_FEATURE);
        int value = 0;
        int allmEnable = 0;
        int VrrEnable = 0;
        int QmsEnable = 0;
        if (buf) {
            value = atoi(buf);
            allmEnable = (value & 1);
            VrrEnable = ((value >> 1) & 1);
            QmsEnable = ((value >> 2) & 1);
            LOGD("%s init HDMI feature status allmEnable:%d, VrrEnable:%d, QmsEnable:%d.\n",
                __FUNCTION__, allmEnable, VrrEnable, QmsEnable);
            mpHDMIRxManager->SetHDMIFeatureInit(allmEnable, VrrEnable, QmsEnable);
        } else {
            allmEnable = mpHDMIRxManager->GetAllmEnabled();
            VrrEnable = mpHDMIRxManager->GetVrrEnabled();
            QmsEnable = mpHDMIRxManager->GetQmsEnabled();
            value = ((QmsEnable << 2)|(VrrEnable << 1)|allmEnable);
            LOGD("%s HDMI feature uenv unexist, save it allmEnable:%d, VrrEnable:%d, QmsEnable:%d.\n",
                __FUNCTION__ , allmEnable, VrrEnable, QmsEnable);
            SetUenv(HDMI_UBOOT_EDID_FEATURE, std::to_string(value).c_str());
        }

        LOGD("%s [UI sequence] edidSetValue:0x%x\n", __FUNCTION__, edidSetValue);
        ret = mpHDMIRxManager->HdmiRxEdidVerSwitch(edidSetValue);
    } else {
        LOGE("%s failed!\n", __FUNCTION__);
    }

    return ret;

}

int CTv::LoadEdidDataWithPort(int isNeedBlackScreen, int isDolbyVisionEnable)
{
    int ret = 0;
    if (isNeedBlackScreen  == 1) {
        mpTvin->Tvin_StopDecoder();
    }

    char edidFileName[100] = {0};
    int loadNum = 1;
    int i = 0;
    tvin_port_t tvin_port = TVIN_PORT_NULL;
    ui_hdmi_port_id_t ui_port = UI_HDMI_PORT_ID_MAX;
    tv_source_input_t source_input;
    const char *edidFilePath = ConfigGetStr(CFG_SECTION_HDMI,
            CFG_HDMI_EDID_FILE_PATH,
            "/vendor/etc/tvconfig/hdmi");

    const char *subString = "21";
    bool support21Edid = hasFileWithSubstring(edidFilePath, subString);
    LOGD("%s: isDolbyVisionEnable = [%d], support21Edid = [%d].\n",
        __FUNCTION__, isDolbyVisionEnable, support21Edid);

    char fileSuffix_14[32] = {0};
    char fileSuffix_20[32] = {0};
    char fileSuffix_21[32] = {0};
    if (isDolbyVisionEnable) {
        strcat(fileSuffix_14, "_dv");
        strcat(fileSuffix_20, "_dv");
    }

    if (mDlgVisionEnableState) {
        strcat(fileSuffix_20, "_dlg");
    }

    if (support21Edid) {
        strcpy(fileSuffix_21, fileSuffix_20);
        strcpy(fileSuffix_20, fileSuffix_14);
    }

    LOGD("%s: 1.4 edid suffix:[%s], 2.0 edid suffix:[%s], 2.1 edid suffix:[%s]\n", __FUNCTION__,
    fileSuffix_14, fileSuffix_20, fileSuffix_21);

    for (loadNum = (int)TVIN_PORT_ID_1; loadNum < (int)TVIN_PORT_ID_MAX; loadNum++) {
        tvin_port = mpTvin->Tvin_GetVdinPortByVdinPortID((tvin_port_id_t)loadNum);
        source_input = mpTvin->Tvin_PortToSourceInput(tvin_port);
        ui_port = mpTvin->Tvin_GetUIHdmiPortIdBySourceInput(source_input);
        LOGD("%s:tvin port ID:%d tvin_port:0x%x source_input:%d ui_port:%d\n",
                __FUNCTION__,
                loadNum,
                tvin_port,
                source_input,
                ui_port);

        char edidLoadBuf[3 * REAL_EDID_DATA_SIZE_MAX];
        memset(edidLoadBuf, 0, sizeof(edidLoadBuf));
        int edid_14_size = 0;
        int edid_20_size = 0;
        int edid_21_size = 0;

        // Load EDID 1.4 then load EDID 2.1 last 2.0
        for (i = 0; i < 3; i++) {
            /* sprintf will add a null-terminated character ('\0') at the end of
               the formatted string. So, do not need to memset the buffer.*/
            sprintf(edidFileName, "%s/port%d_%s%s.bin",
                    edidFilePath,
                    ui_port,
                    i ? (i == 1 ? "21" : "20") : "14",
                    i ? (i == 1 ? fileSuffix_21 : fileSuffix_20) : fileSuffix_14);
            if (!isFileExist(edidFileName)) {

                LOGD("%s: %s, file unexist\n", __FUNCTION__, edidFileName);
                if (i == 2 && support21Edid) {
                    LOGD("%s: only load edid 1.4 & 2.1\n", __FUNCTION__);
                    break;
                }

                sprintf(edidFileName, "%s/port%d_%s%s.bin",
                        edidFilePath,
                        ui_port,
                        i ? "20" : "14",
                        "");
            }

            if (i == 0) {
                 edid_14_size = GetFileSize(edidFileName);
            } else if (i == 1) {
                edid_21_size = GetFileSize(edidFileName);
            } else if (i == 2) {
                edid_20_size = GetFileSize(edidFileName);
            }

            ReadDataFromFile(edidFileName,
                    0,
                    i? (i == 1 ? edid_21_size : edid_20_size) : edid_14_size,
                    i? (i == 1 ? (edidLoadBuf + edid_14_size) : (edidLoadBuf + edid_14_size + edid_21_size)) : edidLoadBuf);
            LOGD("%s:File:%s\n", __FUNCTION__, edidFileName);
        }
        edidLoadBuf[edid_14_size +edid_21_size + edid_20_size] = '\0';

        int type = mpHDMIRxManager->GetHdmiRxLoadEdidType(edid_14_size, edid_21_size, edid_20_size);
        mpHDMIRxManager->HdmiRxLoadEdidDataWithPort(loadNum, type, edid_14_size+edid_21_size+edid_20_size, (unsigned char*)edidLoadBuf);
    }

    if (mInitEdid) {
        tvin_port_id_t portId = TVIN_PORT_ID_MAX;
        int edidSetValue = 0;
        int portEdidVersion = 0;
        for (int i=SOURCE_HDMI1;i<SOURCE_VGA;i++) {
            portId = mpTvin->Tvin_GetHdmiPortIdBySourceInput((tv_source_input_t)i);
            portEdidVersion = GetEdidVersion((tv_source_input_t)i);
            edidSetValue |=  (portEdidVersion << (4*portId - 4));
        }
        LOGD("%s:[edidSetValue:0x%x]", __FUNCTION__, edidSetValue);
        //for HDMI feature(allm,vrr,qms) status init
        const char *buf = GetUenv(HDMI_UBOOT_EDID_FEATURE);
        int value = 0;
        int allmEnable = 0;
        int VrrEnable = 0;
        int QmsEnable = 0;
        if (buf) {
            value = atoi(buf);
            allmEnable = (value & 1);
            VrrEnable = ((value >> 1) & 1);
            QmsEnable = ((value >> 2) & 1);
            LOGD("%s init HDMI feature status allmEnable:%d, VrrEnable:%d, QmsEnable:%d.\n",
                __FUNCTION__, allmEnable, VrrEnable, QmsEnable);
            mpHDMIRxManager->SetHDMIFeatureInit(allmEnable, VrrEnable, QmsEnable);
        } else {
            allmEnable = mpHDMIRxManager->GetAllmEnabled();
            VrrEnable = mpHDMIRxManager->GetVrrEnabled();
            QmsEnable = mpHDMIRxManager->GetQmsEnabled();
            value = ((QmsEnable << 2)|(VrrEnable << 1)|allmEnable);
            LOGD("%s HDMI feature uenv unexist, save it allmEnable:%d, VrrEnable:%d, QmsEnable%d.\n",
                __FUNCTION__ , allmEnable, VrrEnable, QmsEnable);
            SetUenv(HDMI_UBOOT_EDID_FEATURE, std::to_string(value).c_str());
        }

        LOGD("%s [UI sequence] edidSetValue:0x%x\n", __FUNCTION__, edidSetValue);
        ret = mpHDMIRxManager->HdmiRxEdidVerSwitch(edidSetValue);
    }
    mInitEdid = false;

    for (int i=TVIN_PORT_ID_1;i<TVIN_PORT_ID_MAX;i++) {
        mpHDMIRxManager->HdmiRxEdidUpdateWithPort(i);
    }

    return ret;

}

int CTv::SetEdidVersion(tv_source_input_t source, int edidVer)
{
    LOGD("%s: setSource: %d, setVersion: %d\n", __FUNCTION__, source, edidVer);
    int ret = -1;
    int currentVersion = GetEdidVersion(source);
    if (currentVersion != edidVer) {
        mpTvin->Tvin_StopDecoder();
        tvin_port_id_t portId = TVIN_PORT_ID_MAX;
        int edidSetValue = 0;
        //We have already set the port map to kernel.So we should use UI sequence.
        int portEdidVersion = 0;
        for (int i=SOURCE_HDMI1;i<SOURCE_VGA;i++) {
            portId = mpTvin->Tvin_GetHdmiPortIdBySourceInput((tv_source_input_t)i);
            if (i == source) {
                portEdidVersion = edidVer;
            } else {
                portEdidVersion = GetEdidVersion((tv_source_input_t)i);
            }
            edidSetValue |=  (portEdidVersion << (4*portId - 4));
        }
        LOGD("%s [UI sequence] edidSetValue:0x%x\n", __FUNCTION__, edidSetValue);
        ret = mpHDMIRxManager->HdmiRxEdidVerSwitch(edidSetValue);
        if (mCurrentSource == source) {
            //mpHDMIRxManager->HDMIRxDeviceIOCtl(HDMI_IOC_EDID_UPDATE);
            tvin_port_id_t port = mpTvin->Tvin_GetHdmiPortIdBySourceInput(mCurrentSource);
            mpHDMIRxManager->HdmiRxEdidUpdateWithPort((int)port);
        }
        if (ret < 0) {
            LOGE("%s failed.\n", __FUNCTION__);
            ret = -1;
        } else {
            /*
            switch (source) {
            case SOURCE_HDMI1:
                Hdmi1CurrentEdidVer = edidVer;
                break;
            case SOURCE_HDMI2:
                Hdmi2CurrentEdidVer = edidVer;
                break;
            case SOURCE_HDMI3:
                Hdmi3CurrentEdidVer = edidVer;
                break;
            case SOURCE_HDMI4:
                Hdmi4CurrentEdidVer = edidVer;
                break;
            default:
                LOGD("%s: not hdmi source.\n", __FUNCTION__);
                break;
            }
            */
            SetUenv(HDMI_UBOOT_EDID_VERSION, std::to_string(edidSetValue).c_str());
        }
    } else {
        LOGD("%s: same EDID version, no need set.\n", __FUNCTION__);
        ret = 0;
    }

    return ret;

}

int CTv::GetEdidVersion(tv_source_input_t source)
{
    //TODO:add user setting read/write flow
    int retValue = HDMI_EDID_VER_14;
    const char *buf = GetUenv(HDMI_UBOOT_EDID_VERSION);
    int version = 0;
    tvin_port_id_t port_id = TVIN_PORT_ID_MAX;
    if (buf) {
        version = atoi(buf);
    }
    port_id = mpTvin->Tvin_GetHdmiPortIdBySourceInput(source);
    switch (port_id) {
    case TVIN_PORT_ID_1:
        //retValue = Hdmi1CurrentEdidVer;
        retValue = version & 0xf;
        break;
    case TVIN_PORT_ID_2:
        //retValue = Hdmi2CurrentEdidVer;
        retValue = (version >> 4) & 0xf;
        break;
    case TVIN_PORT_ID_3:
        //retValue = Hdmi3CurrentEdidVer;
        retValue = (version >> 8) & 0xf;
        break;
    case TVIN_PORT_ID_4:
        //retValue = Hdmi4CurrentEdidVer;
        retValue = (version >> 12) & 0xf;
        break;
    default:
        LOGD("%s: not hdmi source.\n", __FUNCTION__);
        break;
    }
    return retValue;
}

int CTv::SetVdinWorkMode(vdin_work_mode_t vdinWorkMode)
{
    mVdinWorkMode = vdinWorkMode;
    return 0;
}

int CTv::GetHdmiSPDInfo(tv_source_input_t source, char* data, size_t datalen)
{
    if (mCurrentSource < SOURCE_HDMI1 || mCurrentSource > SOURCE_HDMI4) {
        LOGE("Current source is not HDMI input source.\n");
        return -1;
    }
    if (source != mCurrentSource) {
        LOGE("%d is not current input source, skipped.\n", source);
        return -1;
    }

    int ret = -1;
    struct spd_infoframe_st spd;

    memset(&spd, 0, sizeof(spd));
    ret = mpHDMIRxManager->HdmiRxGetSPDInfoframe(&spd);
    if (ret < 0) {
        LOGE("Get SPD infoframe from HDMIRX manager failed.\n");
    } else {
        if (datalen > sizeof(spd)) {
            memcpy(data, &spd, sizeof(spd));
        } else {
            memcpy(data, &spd, datalen);
        }
    }

    return ret;
}

int CTv::GetFrontendInfo(tvin_frontend_info_t *frontendInfo)
{
    int ret = -1;
    if (frontendInfo == NULL) {
        LOGD("%s: param is NULL.\n", __FUNCTION__);
    } else {
        ret = mpTvin->Tvin_GetFrontendInfo(frontendInfo);
        /*LOGD("%s: scan mode:%d, colorfmt:%d, fps:%d, width:%d, height:%d, colordepth:%d.\n", __FUNCTION__, frontendInfo->scan_mode, frontendInfo->cfmt,
            frontendInfo->fps,frontendInfo->width,frontendInfo->height,frontendInfo->colordepth);*/
    }

    if (ret < 0) {
        LOGE("%s failed.\n", __FUNCTION__);
    } else {
        LOGD("%s success.\n", __FUNCTION__);
    }

    return ret;
}

int CTv::SetCurrentSourceColorRange(tvin_color_range_t range_mode)
{
    int ret = -1;
    if ((range_mode >= TVIN_COLOR_RANGE_MAX) || (range_mode <TVIN_COLOR_RANGE_AUTO)) {
        LOGD("%s: invalid range mode.\n", __FUNCTION__);
    } else {
        ret = mpTvin->Tvin_SetColorRangeMode(range_mode);
    }

    if (ret < 0) {
        LOGE("%s failed.\n", __FUNCTION__);
    } else {
        LOGD("%s success.\n", __FUNCTION__);
    }

    return ret;
}

tvin_color_range_t CTv::GetCurrentSourceColorRange()
{
    int ret = mpTvin->Tvin_GetColorRangeMode();
    LOGD("%s: mode is %d.\n", __FUNCTION__, ret);

    return (tvin_color_range_t)ret;
}

int CTv::GetSourceConnectStatus(tv_source_input_t source)
{
    return mTvDevicesPollDetect.GetSourceConnectStatus(source);
}

int CTv::SetEdidBoostOn(int bBoostOn)
{
    int ret = -1;
    if (mBoostOn == bBoostOn ) {
        LOGD("%s: same EDIDs are loaded for %d, no more action\n", __FUNCTION__, bBoostOn);
        return 0;
    } else {
        LOGD("%s: mBoostOn=%d to be switched to %d\n", __FUNCTION__, mBoostOn, bBoostOn);
        // pass flag for dynamic loading EDID data, switch data to kernel and switch version.
        mBoostOn = bBoostOn;
        ret = LoadEdidDataWithPort(0, mDolbyVisionEnableState);
        return ret;
    }
}

void CTv::onSigToStable()
{
    LOGD("%s: mVdinWorkMode is %d\n", __FUNCTION__, mVdinWorkMode);
    mpTvin->Tvin_StartDecoder(mCurrentSignalInfo);

#ifdef HAVE_AUDIO
    tv_source_input_type_t sourceType = mpTvin->Tvin_SourceInputToSourceInputType(mCurrentSource);
    LOGD("%s: mCurrent sourceType[%d], is_dvi[%d]\n", __FUNCTION__, sourceType, mCurrentSignalInfo.is_dvi);
    if (SOURCE_TYPE_HDMI == sourceType && mCurrentSignalInfo.is_dvi) {
        LOGD("%s: DVI signal, change audio to linein\n", __FUNCTION__);
        CTvAudio::getInstance()->release_audio_patch(TV_CHANNEL_MAIN);
        CTvAudio::getInstance()->create_audio_patch(TV_CHANNEL_MAIN, AUDIO_DEVICE_IN_LINE);
    }

    CTvAudio::getInstance()->set_audio_av_mute(false);
#endif

    CMessage msg;
    msg.mDelayMs = std::chrono::milliseconds(0);
    msg.mType = CTvMsgQueue::TV_MSG_ENABLE_VIDEO_LATER;
    msg.mpPara[0] = 5;
    mTvMsgQueue->sendMsg ( msg );

    //send signal to apk
    TvEvent::SignalDetectEvent event;
    event.mSourceInput = mCurrentSource;
    event.mFmt = mCurrentSignalInfo.fmt;
    event.mTrans_fmt = mCurrentSignalInfo.trans_fmt;
    event.mStatus = mCurrentSignalInfo.status;
    event.mDviFlag = mCurrentSignalInfo.is_dvi;
    event.mhdr_info = mCurrentSignalInfo.signal_type;
    sendTvEvent(event);

    tv_source_input_type_t source_type = mpTvin->Tvin_SourceInputToSourceInputType(mCurrentSource);
    if (source_type == SOURCE_TYPE_HDMI && true == GetHdmiQmsEnabled()) {
        sendQmsEvent();
    }

}

void CTv::onSigToUnstable()
{

    mpAmVideo->SetVideoLayerStatus(VIDEO_LAYER_STATUS_DISABLE);
    mpTvin->Tvin_StopDecoder();

#ifdef HAVE_AUDIO
    if (!(AvAudioMode && SOURCE_TYPE_AV == mCurrentSourceType))
        CTvAudio::getInstance()->set_audio_av_mute(true);
#endif

    LOGD("signal to Unstable!\n");
    //To do
}

void CTv::onSigToUnSupport()
{
    LOGD("%s\n", __FUNCTION__);

    mpAmVideo->SetVideoLayerStatus(VIDEO_LAYER_STATUS_DISABLE);
    mpTvin->Tvin_StopDecoder();

#ifdef HAVE_AUDIO
    if (!(AvAudioMode && SOURCE_TYPE_AV == mCurrentSourceType))
        CTvAudio::getInstance()->set_audio_av_mute(true);
#endif

    TvEvent::SignalDetectEvent event;
    event.mSourceInput = mCurrentSource;
    event.mFmt = mCurrentSignalInfo.fmt;
    event.mTrans_fmt = mCurrentSignalInfo.trans_fmt;
    event.mStatus = mCurrentSignalInfo.status;
    event.mDviFlag = mCurrentSignalInfo.is_dvi;
    event.mhdr_info = mCurrentSignalInfo.signal_type;
    sendTvEvent(event);
    //To do
}

void CTv::onSigToNoSig()
{
    LOGD("%s\n", __FUNCTION__);

    if (needSnowEffect()) {
        SetSnowShowEnable(true);
        mpTvin->Tvin_StartDecoder(mCurrentSignalInfo);
        mpAmVideo->SetVideoLayerStatus(VIDEO_LAYER_STATUS_ENABLE);

    }  else {
        LOGD("%s video layer has disabled \n", __FUNCTION__);
        mpAmVideo->SetVideoLayerStatus(VIDEO_LAYER_STATUS_DISABLE);
        mpTvin->Tvin_StopDecoder();

    #ifdef HAVE_AUDIO
    if (!(AvAudioMode && SOURCE_TYPE_AV == mCurrentSourceType))
        CTvAudio::getInstance()->set_audio_av_mute(true);
    #endif
    }

    TvEvent::SignalDetectEvent event;
    event.mSourceInput = mCurrentSource;
    event.mFmt = mCurrentSignalInfo.fmt;
    event.mTrans_fmt = mCurrentSignalInfo.trans_fmt;
    event.mStatus = mCurrentSignalInfo.status;
    event.mDviFlag = mCurrentSignalInfo.is_dvi;
    event.mhdr_info = mCurrentSignalInfo.signal_type;
    sendTvEvent (event);
    //To do
}

bool CTv::needSnowEffect()
{
    bool isEnable = false;
    LOGD("%s: mCurrentSource = [%d].\n", __FUNCTION__,mCurrentSource);
    if ((SOURCE_TV == mCurrentSource) && mATVDisplaySnow ) {
        isEnable = true;
        LOGD("%s: ATV:snow display is enabled.\n", __FUNCTION__);
    } else {
        LOGD("%s: ATV:snow display is disabled.\n", __FUNCTION__);
    }

    return isEnable;
}

int CTv::SetSnowShowEnable(bool enable)
{
    LOGD("%s: enable = [%d]\n", __FUNCTION__ , enable);
    if (enable) {
        mLastScreenMode = CVpp::getInstance()->getVideoScreenMode();
        LOGD("%s: Get LastScreenMode = %d\n", __FUNCTION__, mLastScreenMode);
        CVpp::getInstance()->setVideoScreenMode(1);//while show snow,need show full screen
    } else {
        LOGD("%s: Set LastScreenMode = %d\n", __FUNCTION__, mLastScreenMode);
        CVpp::getInstance()->setVideoScreenMode(mLastScreenMode);
    }
    return mpTvin->Tvin_SwitchSnow(enable);
}

int CTv::sendTvEvent(CTvEvent &event)
{
    LOGD("%s\n", __FUNCTION__);

    if (mpObserver != NULL) {
        mpObserver->onTvEvent(event);
    } else {
        LOGD("%s: Observer is NULL.\n", __FUNCTION__);
    }

    return 0;
}

#ifdef HAVE_AUDIO
int CTv::mapSourcetoAudiotupe(tv_source_input_t dest_source)
{
    int ret = -1;
    switch (dest_source) {
        case SOURCE_TV:
            ret = AUDIO_DEVICE_IN_TV_TUNER;
            break;
        case SOURCE_AV1:
        case SOURCE_AV2:
            ret = AUDIO_DEVICE_IN_LINE;
            break;
        case SOURCE_HDMI1:
        case SOURCE_HDMI2:
        case SOURCE_HDMI3:
        case SOURCE_HDMI4:
            ret = AUDIO_DEVICE_IN_HDMI;
            break;
        case SOURCE_SPDIF:
            ret = AUDIO_DEVICE_IN_SPDIF;
            break;
        default:
            ret = AUDIO_DEVICE_IN_LINE;
            break;
    }
    return ret;
}
#endif

bool CTv::GetDolbyVisionSupportStatus(void) {
    //return dv support info from current platform device, not display device.
    char buf[1024+1] = {0};
    int fd, len;
    bool ret = false;

    /*bit0: 0-> efuse, 1->no efuse; */
    /*bit1: 1-> ko loaded*/
    /*bit2: 1-> value updated*/
    /*bit3: 1-> tv */
    int supportInfo = 0;

    constexpr int dvDriverEnabled = (1 << 2);
    constexpr int dvSupported = ((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3 ));

    if ((fd = open(SYS_DOLBYVISION_SUPPORT_INFO, O_RDONLY)) < 0) {
        LOGE("open %s fail.\n", SYS_DOLBYVISION_SUPPORT_INFO);
        return false;
    } else {
        if ((len = read(fd, buf, 1024)) < 0) {
            LOGE("read %s error: %s\n", SYS_DOLBYVISION_SUPPORT_INFO, strerror(errno));
            ret =  false;
        } else if (sscanf(buf, "%d", &supportInfo) == 1) {
            if ((supportInfo & dvDriverEnabled) == 0) {
                LOGD("%s is not ready\n",SYS_DOLBYVISION_SUPPORT_INFO);
            }
            ret = ((supportInfo & dvSupported) == dvSupported) ? true : false;
        }

        close(fd);
        return ret;
    }
}

int CTv::SetHdmiAllmEnabled(bool enable)
{
    LOGD("%s: [%s]\n", __FUNCTION__, enable == 1?"enable":"disable");
    const char *buf = GetUenv(HDMI_UBOOT_EDID_FEATURE);
    int saveValue = 0;
    if (buf) {
        saveValue = atoi(buf);
        if ((saveValue & 0x1) == enable) {
            LOGD("%s: same status return!\n", __FUNCTION__);
            return 0;
        }
    }
    muteVideoOnHDMISource();
    saveValue = enable|(saveValue & ~0b1);
    SetUenv(HDMI_UBOOT_EDID_FEATURE,  std::to_string(saveValue).c_str());
    return mpHDMIRxManager->SetAllmEnabled(enable);
}

bool CTv::GetHdmiAllmEnabled()
{
    bool ret = mpHDMIRxManager->GetAllmEnabled();
    LOGD("%s: [%d]\n", __FUNCTION__, ret);
    return ret;
}

bool CTv::GetHdmiVrrSupport()
{
    bool ret = false;
    ret = CVrr::getInstance()->GetVrrSupport();
    return ret;
}

int CTv::SetHdmiVrrEnabled(bool enable)
{
    LOGD("%s: [%s]\n", __FUNCTION__, enable == 1?"enable":"disable");
    const char*buf = GetUenv(HDMI_UBOOT_EDID_FEATURE);
    int saveValue = 0;
    if (buf) {
        saveValue = atoi(buf);
        if ((saveValue >> 1) == enable) {
            LOGD("%s: same status return!\n", __FUNCTION__);
            return 0;
        }
    }
    muteVideoOnHDMISource();
    saveValue = (enable << 1)|(saveValue & ~0b10);
    SetUenv(HDMI_UBOOT_EDID_FEATURE,  std::to_string(saveValue).c_str());
    return mpHDMIRxManager->SetVrrEnabled(enable);
}

bool CTv::GetHdmiVrrEnabled()
{
    bool ret = mpHDMIRxManager->GetVrrEnabled();
    LOGD("%s: [%d]\n", __FUNCTION__, ret);
    return ret;
}

bool CTv::GetHdmiQmsSupport()
{
    int ret = 0;
    ret = ConfigGetInt(CFG_SECTION_HDMI, CFG_HDMI_QMS_SUPPORT, 0);
    LOGD("%s:%d !\n",__FUNCTION__, ret);
    return ret?true:false;
}

int CTv::SetHdmiQmsEnabled (bool enable) {
    int ret = -1;
    LOGD("%s: Set QMS enable = [%d]\n", __FUNCTION__, enable);
    const char*buf = GetUenv(HDMI_UBOOT_EDID_FEATURE);
    int saveValue = 0;
    if (buf) {
        saveValue = atoi(buf);
        if (((saveValue >> 2) & 1) == enable) {
            LOGD("%s: same status return!\n", __FUNCTION__);
            return 0;
        }
    }
    saveValue = (enable << 2)|(saveValue & ~0b100);
    SetUenv(HDMI_UBOOT_EDID_FEATURE,  std::to_string(saveValue).c_str());
    // RX request:
    //qms_func_ctrl only close qms, reopen qms need reload edid
    if (enable) {
        char buf[8] = {0};
        sprintf(buf, "%d", enable);
        tvWriteSysfs(QMS_FUNC_CTRL_PATH, buf);
        bool dolbyVisionEnableState = GetDolbyVisionSupportStatus();
        ret = LoadEdidDataWithPort(1, dolbyVisionEnableState);
        return ret;
    } else {
        return mpHDMIRxManager->SetQmsEnabled(enable);
    }

}

bool CTv::GetHdmiQmsEnabled(void) {
    int qmsEnable = 0;
    const char*buf = GetUenv(HDMI_UBOOT_EDID_FEATURE);
    int saveValue = 0;
    if (buf) {
        saveValue = atoi(buf);
        qmsEnable = ((saveValue >> 2) & 1);
    }
    LOGD("%s:QMS status [%d] !\n",__FUNCTION__,qmsEnable);
    return (bool)qmsEnable;
}

void CTv::sendQmsEvent(void)
{
    LOGD("%s\n", __FUNCTION__);
    vdin_qms_param_t qmsInfo;
    memset(&qmsInfo, 0, sizeof(vdin_qms_param_t));
    int ret = mpTvin->VDIN_GetQmsParm(&qmsInfo);
    if (ret < 0) {
        LOGD("%s: Get QMS Info error!\n", __FUNCTION__);
    } else {
        if ((int)qmsInfo.qms_en == 0) {
            LOGD("%s: non-qms signal,return!\n", __FUNCTION__);
            return;
        }
        LOGD("%s: send QMS change event, new fps：%d!\n", __FUNCTION__, qmsInfo.qms_fr);
        TvEvent::QMSEvent ev;
        ev.qms_en = (int)qmsInfo.qms_en;
        ev.qms_fps = (int)qmsInfo.qms_fr;
        ev.qms_base_fps = (int)qmsInfo.qms_base_fr;
        sendTvEvent ( ev );
    }
}

int CTv::SetHdmiDlgEnabled(bool enable)
 {
    int ret = -1;
    if (GetHdmiDlgSupport()) {
        LOGD("%s:update DLG EDID status, new status = [%d]!\n",__FUNCTION__,enable);
        mDlgVisionEnableState = enable;
        bool dolbyVisionEnableState = GetDolbyVisionSupportStatus();
        ret = LoadEdidDataWithPort(0, dolbyVisionEnableState);
        if ( 0 == ret ) {
            LOGD("%s:update DLG EDID status success!\n",__FUNCTION__);
            const char*buf = GetUenv(HDMI_UBOOT_EDID_FEATURE);
            int saveValue = 0;
            if (buf) {
                saveValue = atoi(buf);
                if (((saveValue >> 3) & 1) == enable) {
                    LOGD("%s: same status return!\n", __FUNCTION__);
                    return ret;
                }
            }
            saveValue = (enable << 3)|(saveValue & ~0b1000);
            SetUenv(HDMI_UBOOT_EDID_FEATURE,  std::to_string(saveValue).c_str());
        } else {
            LOGD("%s:update DLG EDID status fail!\n",__FUNCTION__);
        }
    }else {
    LOGE("%s:unsupport DLG func,return !\n",__FUNCTION__);
    }
    return ret;
}

bool CTv::GetHdmiDlgEnabled()
{
    int dlgEnable = 0;
    const char*buf = GetUenv(HDMI_UBOOT_EDID_FEATURE);
    int saveValue = 0;
    if (buf) {
        saveValue = atoi(buf);
        dlgEnable = ((saveValue >> 3) & 1);
    }
    LOGD("%s:QMS status [%d] !\n",__FUNCTION__,dlgEnable);
    return (bool)dlgEnable;
}

bool  CTv::GetHdmiDlgSupport()
{
    bool ret = false;
    char buf[1024] = {0};
    ret = tvReadSysfs(DLG_FUNC_PATH, buf);
    LOGD("%s: %s\n", __FUNCTION__, buf);
    if (ret < 0) {
        LOGD("%s: read /sys/class/display/cap error, return!\n",__FUNCTION__);
        return ret;
    }

    std::string parm = buf;

    //if 4k1k && 4k2k exist,support dlg
    std::string support4K1K = "3840x1080";
    //The format of 4K2K includes the following variants
    std::string support4K2K_1 = "3840x2160";
    std::string support4K2K_2 = "2160p60hz";
    std::string support4K2K_3 = "4k2k60hz";
    if ((parm.find(support4K1K) != -1)
        && ((parm.find(support4K2K_1) != -1)
        || (parm.find(support4K2K_2) != -1)
        || (parm.find(support4K2K_3) != -1))) {
        LOGD("%s: find exist!\n",__FUNCTION__);
        ret = true;
    }else{
        LOGD("%s: unsupport DLG func,return!\n",__FUNCTION__);
    }

    return ret;
}

void CTv::muteVideoOnHDMISource() {
    if (mCurrentSource < SOURCE_HDMI1 || mCurrentSource > SOURCE_HDMI4) {
        return;
    }
    mpAmVideo->SetVideoLayerStatus(VIDEO_LAYER_STATUS_DISABLE);
}

int CTv::GetCurrentStdInfo (struct tvin_std_s *info)
{
    int ret = 0;
    memset(info, 0 , sizeof(struct tvin_std_s));
    info->source = mCurrentSource;
    info->edid_version = GetEdidVersion(mCurrentSource);
    info->allm_enabled = GetHdmiAllmEnabled();
    info->vrr_enabled = GetHdmiVrrEnabled();
    info->qms_enabled = GetHdmiQmsEnabled();
    LOGD("%s: source:[%d], edid_version:[%d], allm:[%d], vrr:[%d], qms:[%d]",__FUNCTION__,
        info->source, info->edid_version, info->allm_enabled, info->vrr_enabled, info->qms_enabled);
    return ret;
}

void CTv::isVideoFrameAvailable(unsigned int u32NewFrameCount)
{
    unsigned int u32TimeOutCount = 0;
    unsigned int  frameCount = 0;
    while (true) {
        frameCount = (unsigned int)mpAmVideo->GetVideoFrameCount();
        if (frameCount >= u32NewFrameCount) {
            LOGD("%s video available\n", __FUNCTION__);
            break;
        } else {
            if (u32TimeOutCount >= NEW_FRAME_TIME_OUT_COUNT) {
                LOGD("%s Not available frame\n", __FUNCTION__);
                break;
            }
        }
        LOGD("%s new frame count = %d, get time = %d\n",__FUNCTION__, frameCount, u32TimeOutCount);
        usleep(50*1000);
        u32TimeOutCount++;
    }
    mpAmVideo->SetVideoLayerStatus(VIDEO_LAYER_STATUS_ENABLE);
    mpAmVideo->SetVideoGlobalOutputMode(VIDEO_GLOBAL_OUTPUT_MODE_ENABLE);
}

int CTv::SetAudioDecoderId(int channel, int id)
{
#ifdef HAVE_AUDIO
    CTvAudio::getInstance()->set_audio_decoder_id(channel, id);
#endif
    return 0;
}

int CTv::SetAvAudioModeEnabled (bool enable)
{
    LOGD("%s endable = %s\n",__FUNCTION__, enable ? "enable":"disable");
    AvAudioMode = enable;
    return 0;
}

bool CTv::IsSupportPIP()
{
    bool ret = false;
    if (isFileExist("/dev/vdin2")) {
        LOGD("%s: support HDMI PIP\n",__FUNCTION__);
        ret = true;
    } else {
        LOGD("%s: unsupport HDMI PIP\n",__FUNCTION__);
    }
    return ret;
}

int CTv::SetCurrentPipSourceInfo(tvin_info_t sig_info)
{
    mCurrentPipSignalInfo.trans_fmt = sig_info.trans_fmt;
    mCurrentPipSignalInfo.fmt = sig_info.fmt;
    mCurrentPipSignalInfo.status = sig_info.status;
    mCurrentPipSignalInfo.cfmt = sig_info.cfmt;
    mCurrentPipSignalInfo.signal_type= sig_info.signal_type;
    mCurrentPipSignalInfo.fps = sig_info.fps;
    mCurrentPipSignalInfo.is_dvi = sig_info.is_dvi;
    mCurrentPipSignalInfo.aspect_ratio = sig_info.aspect_ratio;

    return 0;
}

void CTv::setDisplayCrop(int source)
{
    tvin_frontend_info_t frontendInfo;
    tv_rect crop;
    memset(&crop, 0, sizeof(tv_rect));
    if (source == MAIN_WINDOW) {
        mpTvin->Tvin_GetFrontendInfo(&frontendInfo);
        crop.w = frontendInfo.width;
        crop.h = frontendInfo.height;
        mpTvMainDisplayadapter->TV_dispAdptSetLayerSourceCrop(crop);
    } else if (source == SUB_WINDOW && mpTvSubDisplayadapter != nullptr) {
        mpPipTvin->Tvin_GetFrontendInfo(&frontendInfo);
        crop.w = frontendInfo.width;
        crop.h = frontendInfo.height;
        mpTvSubDisplayadapter->TV_dispAdptSetLayerSourceCrop(crop);
    }
}

int CTv::StartTvInPIP ( tv_source_input_t source )
{
    if (nullptr == mpPipTvin) {
        LOGD("%s: unsupport PIP return!\n", __FUNCTION__);
        return 0;
    }

    LOGD("%s: source = %d!\n", __FUNCTION__, source);
    int ret = 0;

    mpTvWayland->setPipTunnelId(1);
    mpTvWayland->startPipVideo();
    mpTvWayland->commitAll();

    //sub source set 1, 3 as default
    mpTvMainDisplayadapter->TV_setDisplayadapterParam(1,3);
    mpTvMainDisplayadapter->TV_dispAdptCreateLayer();
    //value limit in {0,64} and big than main
    mpTvMainDisplayadapter->TV_dispAdptSetLayerZorder(1);

    tvin_port_t source_port = mpPipTvin->Tvin_GetSourcePortBySourceInput(source);
    ret = mpPipTvin->Tvin_OpenPort(source_port);
    mCurrentPipSource = source;
    #ifdef HAVE_AUDIO
    int Audiotupe = mapSourcetoAudiotupe(source);
    if (Audiotupe == AUDIO_DEVICE_IN_HDMI) {
        Audiotupe = AUDIO_DEVICE_IN_HDMI1;
    }
    CTvAudio::getInstance()->create_audio_patch(TV_CHANNEL_SUB, Audiotupe);
#endif
    return ret;
}

int CTv::StopTvInPIP ( tv_source_input_t source )
{
    if (nullptr == mpPipTvin) {
        LOGD("%s: unsupport PIP return!\n", __FUNCTION__);
        return 0;
    }

    LOGD("%s: source = %d!\n", __FUNCTION__, source);
    int ret = 0;
#ifdef HAVE_AUDIO
        CTvAudio::getInstance()->release_audio_patch(TV_CHANNEL_SUB);
#endif


    mpTvWayland->stopPipVideo();
    if (mCurrentSource == SOURCE_INVALID) {
        mpTvWayland->shutdown();
    }

    mpPipTvin->Tvin_StopDecoder();
    tvin_port_t source_port = mpPipTvin->Tvin_GetSourcePortBySourceInput(source);
    mpPipTvin->Tvin_ClosePort(source_port);

    mCurrentPipSource = SOURCE_INVALID;
    tvin_info_t tempSignalInfo;
    tempSignalInfo.trans_fmt = TVIN_TFMT_2D;
    tempSignalInfo.fmt = TVIN_SIG_FMT_NULL;
    tempSignalInfo.status = TVIN_SIG_STATUS_NULL;
    tempSignalInfo.cfmt = TVIN_COLOR_FMT_MAX;
    tempSignalInfo.signal_type= 0;
    tempSignalInfo.fps = 60;
    tempSignalInfo.is_dvi = 0;
    tempSignalInfo.aspect_ratio = TVIN_ASPECT_NULL;
    SetCurrentPipSourceInfo(tempSignalInfo);

    return ret;
}

void CTv::onVdin2SignalChange()
{
    if (mCurrentPipSource == SOURCE_INVALID) {
        LOGD("%s: none opened source,return!\n",__FUNCTION__);
        return;
    }

    vdin_event_info_s SignalEventInfo;
    memset(&SignalEventInfo, 0, sizeof(vdin_event_info_s));
    int ret  = mpPipTvin->Tvin_GetSignalEventInfo(&SignalEventInfo);
    if (ret < 0) {
        LOGD("%s: Get vidn event error!\n",__FUNCTION__);
    } else {
        tv_source_input_type_t source_type = mpPipTvin->Tvin_SourceInputToSourceInputType(mCurrentSource);
        tvin_sig_change_flag_t vdinEventType = (tvin_sig_change_flag_t)SignalEventInfo.event_sts;
        switch (vdinEventType) {
        case TVIN_SIG_CHG_STS:
            LOGD("%s: vdin2 signal status change!\n", __FUNCTION__);
            onPipSigStatusChange();
            break;
        default:
            LOGD("%s: invalid vdin event!\n", __FUNCTION__);
            break;
        }
    }

}

void CTv::onPipSigStatusChange(void)
{
    LOGD("%s\n", __FUNCTION__);
    tvin_info_s tempSignalInfo;
    int ret = mpPipTvin->Tvin_GetSignalInfo(&tempSignalInfo);
    if (ret < 0) {
        LOGD("%s: Get Signal Info error!\n",__FUNCTION__);
        return;
    } else {
        SetCurrentPipSourceInfo(tempSignalInfo);
        LOGD("sig_fmt is %d, status is %d, isDVI is %d, hdr_info is 0x%x\n",
               mCurrentPipSignalInfo.fmt, mCurrentPipSignalInfo.status, mCurrentPipSignalInfo.is_dvi, mCurrentPipSignalInfo.signal_type);
        if ( mCurrentPipSignalInfo.status == TVIN_SIG_STATUS_STABLE ) {
            setDisplayCrop(SUB_WINDOW);
            mpPipTvin->Tvin_StartDecoder(mCurrentPipSignalInfo);
        } else if (mCurrentPipSignalInfo.status == TVIN_SIG_STATUS_UNSTABLE ) {
            mpPipTvin->Tvin_StopDecoder();
        } else if ( mCurrentPipSignalInfo.status == TVIN_SIG_STATUS_NOTSUP ) {
            mpPipTvin->Tvin_StopDecoder();
        } else if ( mCurrentPipSignalInfo.status == TVIN_SIG_STATUS_NOSIG ) {
            mpPipTvin->Tvin_StopDecoder();
        } else {
            LOGD("%s: invalid signal status!\n",__FUNCTION__);
            return;
        }

        // send PIP signal detect event to APK
        TvEvent::PipSignalDetectEvent pipEvent;
        pipEvent.mSourceInput = mCurrentPipSource;
        pipEvent.mFmt = mCurrentPipSignalInfo.fmt;
        pipEvent.mTrans_fmt = mCurrentPipSignalInfo.trans_fmt;
        pipEvent.mStatus = mCurrentPipSignalInfo.status;
        pipEvent.mDviFlag = mCurrentPipSignalInfo.is_dvi;
        pipEvent.mhdr_info = mCurrentPipSignalInfo.signal_type;
        sendTvEvent(pipEvent);
        return;
    }
}

CTv::CTvMsgQueue::CTvMsgQueue(CTv *tv)
{
    mpTv = tv;
}

CTv::CTvMsgQueue::~CTvMsgQueue()
{
}

void CTv::CTvMsgQueue::handleMessage ( CMessage &msg )
{
    LOGD ("%s, CTv::CTvMsgQueue::handleMessage type = %d\n", __FUNCTION__,  msg.mType);

    switch ( msg.mType ) {
    case TV_MSG_ENABLE_VIDEO_LATER: {
        int fc = msg.mpPara[0];
        mpTv->isVideoFrameAvailable(fc);
        break;
    }
    default:
        break;
    }
}