/*
 * 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 "SyncDataBase"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <errno.h>

#include "SyncDataBase.h"
#include "CPQLog.h"

#include "SSMAction.h"
#include "CPQDataBase.h"
#include "WhitebalanceDataBase.h"

#include "PQTableTypeOSD.h"

#include "CConfigFile.h"

SyncDataBase *SyncDataBase::mInstance = NULL;
SyncDataBase *SyncDataBase::GetInstance()
{
    if (NULL == mInstance) {
        mInstance = new SyncDataBase();
    }

    return mInstance;
}

static char DatabaseVersion[64] = "\0";

SyncDataBase::SyncDataBase()
{
    const char *config_value;
    config_value = CConfigFile::GetInstance()->GetString(CFG_SECTION_PQ, CGF_PQ_DATABASE_VERSION, "3.1");
    snprintf(DatabaseVersion, sizeof(DatabaseVersion), "%s", config_value);

    LOGD("%s DatabaseVersion %s !\n",__FUNCTION__, DatabaseVersion);

}

SyncDataBase::~SyncDataBase()
{
}

//============================ SSM DATA =================================================//
bool SyncDataBase::SyncDataBaseInit(void)
{
    if (strlen(DatabaseVersion) <= 0) {
        LOGD("%s DatabaseVersion is null !\n",__FUNCTION__);
        return false;
    }

    char INFO[64];
    if (CPQDataBase::GetInstance()->GetSyncData((void *)INFO, sizeof(INFO))) {
        if (strcmp(DatabaseVersion, INFO) == 0 ) {
            LOGD("%s DatabaseVersion %s sync has done!\n",__FUNCTION__, DatabaseVersion);
            return true;
        } else {
            LOGD("%s sync version is not match %s != %s, need sync afresh!\n",__FUNCTION__, DatabaseVersion, INFO);
        }
    }

    LOGD("%s Start sync %s to Current version!\n",__FUNCTION__, DatabaseVersion);

    if (strcmp(DatabaseVersion, "3.1") == 0) {
        SyncDataBasePictureMode();
        SyncDataBasePictureModeData_3_1();
        SyncDataBaseColorTempData();
        SyncDataBaseWbGammaData();
        SyncDataBaseCmsData_3_1();
        SyncDataBaseBySourcePicture();
        SyncDataBaseGlobalPicture();
        SyncDataBaseLcdLvdsSsc();
    } else {
        SyncDataBasePictureMode();
        SyncDataBasePictureModeData();
        SyncDataBaseColorTempData();
        SyncDataBaseWbGammaData();
        SyncDataBaseCmsData();
        SyncDataBaseBySourcePicture();
        SyncDataBaseGlobalPicture();
        SyncDataBaseLcdLvdsSsc();
    }

    snprintf(INFO, sizeof(INFO), "%s", DatabaseVersion);
    if (!CPQDataBase::GetInstance()->SetSyncData((void *)INFO, sizeof(INFO))) {
        LOGE("%s SetSyncData fail info is %s: !\n",__FUNCTION__, INFO);
        return false;
    }

    LOGD("%s Done !\n",__FUNCTION__);

    return true;
}

int SyncDataBase::SyncDataBasePictureMode(void)
{
    LOGD("Sync PictureMode Start\n");

    int Flag = 0;
    int mode = 0;
    SSM_PictureModeInfo param;
    memset(&param, 0, sizeof(SSM_PictureModeInfo));
    PICTURE_MODE_DEFAULT pqmode;
    for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
        for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
            if (!CheckIndexSupport(source, timming)) {
                continue;
            }

            int offset = (source * MAX_SSM_PQ_TIMMING_INDEX + timming) * sizeof(SSM_PictureModeInfo);
            if (!SSMAction::getInstance()->GetSsmDataParam((void *)&param,
                                                            SSM_PQ_MODE_ID,
                                                            sizeof(SSM_PictureModeInfo),
                                                            offset,
                                                            false)) {
                continue;
            }

            int offsetFlag = offset + sizeof(int);
            if (param.Flag == 1 || param.Flag == offsetFlag)
                mode = param.PictureMode;
            else
                continue;

            if (!CPQDataBase::GetInstance()->GetPictureMode(&pqmode, source, timming)) {
                if (!CPQDataBase::GetInstance()->GetPictureMode(&pqmode, 0, timming)) {
                    if (!CPQDataBase::GetInstance()->GetPictureMode(&pqmode, 0, 0)) {
                        continue;
                    }
                }
            }

            if (timming == PQ_FMT_SDR) {
                pqmode.Picture = mode;
            } else if (timming == PQ_FMT_HDR) {
                pqmode.Picture_HDR = mode;
            } else if (timming == PQ_FMT_HDRP) {
                pqmode.Picture_HLG = mode;
            } else if (timming == PQ_FMT_DOLVI) {
                pqmode.Picture_DOLVI = mode;
            } else {
                pqmode.Picture = mode;
            }

            if (!CPQDataBase::GetInstance()->SetPictureMode(&pqmode, source, timming)) {
                LOGE("Sync pqmode source: %d, timming: %d!\n", source, timming);
            } else {
                Flag++;
            }
        }
    }

    LOGD("Sync PictureMode %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncDataBasePictureModeData(void)
{
    LOGI("Sync PictureMode Data Start\n");

    int Flag = 0;
    SSM_PICTURE_STRUCT PictureModeBase;
    for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
        for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
            for (int mode = 0; mode < MAX_SSM_PICTUREMODE_INDEX; mode++) {
                if (!CheckIndexSupport(source, timming))
                    continue;

                int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_PICTUREMODE_INDEX +
                              timming * MAX_SSM_PICTUREMODE_INDEX + mode) *
                              MAX_SSM_PICTUREMODE_PARAM_SIZE;
                if (!SSMAction::getInstance()->GetSsmDataParam((void *)&PictureModeBase,
                                                                SSM_PICTURE_ID,
                                                                sizeof(SSM_PICTURE_STRUCT),
                                                                offset,
                                                                true)) {
                    continue;
                }

                if (!CPQDataBase::GetInstance()->SetPictureModeData((PICTURE_MODE_PARAM *)&PictureModeBase, source, timming, mode)) {
                    LOGE("Sync PictureMode Data source: %d, timming: %d, mode: %d fail!\n", source, timming, mode);
                } else {
                    Flag++;
                }
            }
        }
    }

    LOGI("Sync PictureMode Data %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncDataBasePictureModeData_3_1(void)
{
    LOGI("Sync PictureMode Data Start\n");

    int Flag = 0;
    SSM_3_1_PICTURE_STRUCT PictureModeBase;
    PICTURE_MODE_PARAM PictureModeTarget;
    for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
        for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
            for (int mode = 0; mode < MAX_SSM_PICTUREMODE_INDEX; mode++) {
                if (!CheckIndexSupport(source, timming))
                    continue;

                int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_PICTUREMODE_INDEX +
                              timming * MAX_SSM_PICTUREMODE_INDEX + mode) *
                              MAX_SSM_PICTUREMODE_PARAM_SIZE;
                if (!SSMAction::getInstance()->GetSsmDataParam((void *)&PictureModeBase,
                                                                SSM_PICTURE_ID,
                                                                sizeof(SSM_3_1_PICTURE_STRUCT),
                                                                offset,
                                                                true)) {
                    continue;
                }

                if (!CPQDataBase::GetInstance()->GetPictureModeData(&PictureModeTarget, source, timming, mode)) {
                if (!CPQDataBase::GetInstance()->GetPictureModeData(&PictureModeTarget, 0, timming, mode)) {
                if (!CPQDataBase::GetInstance()->GetPictureModeData(&PictureModeTarget, 0, 0, mode)) {
                    continue;
                }
                }
                }

                PictureModeTarget.Brightness        = PictureModeBase.Brightness;
                PictureModeTarget.Contrast          = PictureModeBase.Contrast;
                PictureModeTarget.Saturation        = PictureModeBase.Saturation;
                PictureModeTarget.Hue               = PictureModeBase.Hue;
                PictureModeTarget.Sharpness         = PictureModeBase.Sharpness;
                PictureModeTarget.Backlight         = PictureModeBase.Backlight;
                PictureModeTarget.Nr                = PictureModeBase.Nr;
                PictureModeTarget.DynamicContrast   = PictureModeBase.DynamicContrast;
                PictureModeTarget.ColorGamut        = PictureModeBase.ColorGamut;
                PictureModeTarget.ColorTemperature  = PictureModeBase.ColorTemperature;
                PictureModeTarget.LocalContrast     = PictureModeBase.LocalContrast;
                PictureModeTarget.BlackStretch      = PictureModeBase.BlackStretch;
                PictureModeTarget.WhiteStretch      = 0;
                PictureModeTarget.BlueStretch       = PictureModeBase.BlueStretch;
                PictureModeTarget.MpegNr            = PictureModeBase.MpegNr;
                PictureModeTarget.ChromaCoring      = PictureModeBase.ChromaCoring;
                PictureModeTarget.SuperResolution   = PictureModeBase.SuperResolution;
                PictureModeTarget.GammaMidLuminance = PictureModeBase.GammaMidLuminance;
                PictureModeTarget.CmLevel           = PictureModeBase.CmLevel;
                PictureModeTarget.DynamicBacklight  = PictureModeBase.DynamicBacklight;
                PictureModeTarget.EyeProtection     = PictureModeBase.EyeProtection;
                PictureModeTarget.SmoothPlus        = PictureModeBase.SmoothPlus;
                PictureModeTarget.HdrTmo            = PictureModeBase.HdrTmo;
                //PictureModeTarget.AmlDolbyMode         = PictureModeBase.AmlDolbyMode;
                //PictureModeTarget.AmlDolbyDarkDetail   = PictureModeBase.AmlDolbyDarkDetail;
                PictureModeTarget.Deblock           = PictureModeBase.MpegNr;
                PictureModeTarget.Demosquito        = PictureModeBase.MpegNr;
                PictureModeTarget.Reserve1          = 0;
                PictureModeTarget.Reserve2          = 0;
                PictureModeTarget.Reserve3          = 0;

                if (!CPQDataBase::GetInstance()->SetPictureModeData((PICTURE_MODE_PARAM *)&PictureModeTarget, source, timming, mode)) {
                    LOGE("Sync PictureMode Data source: %d, timming: %d, mode: %d fail!\n", source, timming, mode);
                } else {
                    Flag++;
                }
            }
        }
    }

    LOGI("Sync PictureMode Data %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncDataBaseColorTempData(void)
{
    LOGI("Sync ColorTemp Start!\n");

    int Flag = 0;
    SSM_COLORTEMP_STRUCT ColorTemp;
    for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
        for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
            for (int level = 0; level < MAX_SSM_COLORTEMP_INDEX; level++) {
                if (!CheckIndexSupport(source, timming))
                    continue;

                int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_COLORTEMP_INDEX +
                              timming * MAX_SSM_COLORTEMP_INDEX + level) *
                              MAX_SSM_COLORTEMP_PARAM_SIZE;
                if (!SSMAction::getInstance()->GetSsmDataParam((void *)&ColorTemp,
                                                                SSM_COLORTEMP_ID,
                                                                sizeof(SSM_COLORTEMP_STRUCT),
                                                                offset,
                                                                true)) {
                    continue;
                }

                if (!CPQDataBase::GetInstance()->SetColorTemperatureData((COLORTEMP_DATA *)&ColorTemp, source, timming, level)) {
                    LOGE("Sync ColorTemp source: %d, timming: %d, level: %d fail!\n", source, timming, level);
                } else {
                    Flag++;
                }
            }
        }
    }

    LOGI("Sync ColorTemp %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncDataBaseWbGammaData(void)
{
    LOGI("Sync ColorTemp Gamma Start\n");

    int Flag = 0;
    SSM_WB_GAMMA_TABLE WbGammaBase;
    for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
        for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
            for (int level = 0; level < MAX_SSM_COLORTEMP_INDEX; level++) {
                for (int mode = 0; mode < WB_GAMMA_MODE_MAX; mode++) {
                    int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_COLORTEMP_INDEX * WB_GAMMA_MODE_MAX +
                                  timming * MAX_SSM_COLORTEMP_INDEX * WB_GAMMA_MODE_MAX +
                                  level * WB_GAMMA_MODE_MAX + mode) *
                                  MAX_SSM_WB_GAMMA_PARAM_SIZE;
                    if (!SSMAction::getInstance()->GetSsmDataParam((void *)&WbGammaBase,
                                                                    SSM_WB_GAMMA_ID,
                                                                    sizeof(SSM_WB_GAMMA_TABLE),
                                                                    offset,
                                                                    true)) {
                        continue;
                    }

                    if (!CPQDataBase::GetInstance()->SetGammaOffsetData((GAMMA_OFFSET_DATA *)&WbGammaBase, level, mode, source, timming)) {
                        LOGE("Sync ColorTemp Gamma source: %d, timming: %d, level: %d, mode: %d fail!\n", source, timming, level, mode);
                    } else {
                        Flag++;
                    }
                }
            }
        }
    }

    LOGI("Sync ColorTemp Gamma %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncDataBaseCmsData_3_1(void)
{
    LOGI("%s Sync Cms Start\n", __FUNCTION__);

    int Flag = 0;
    SSM_TABLE_CMS Cms;
    int offset = 0;

    if (SSMAction::getInstance()->GetSsmDataParam((void *)&Cms.CmsEnable,
                                            VPP_DATA_POS_COLOR_TUNE_START,
                                            sizeof(int),
                                            offset,
                                            false)) {
        if (SSMAction::getInstance()->GetSsmDataParam((void *)&Cms.CmsColor,
                                                VPP_DATA_POS_COLORCUSTOMIZE_CM_START,
                                                sizeof(vpp_cms_cm_param_t),
                                                offset,
                                                false)) {
            for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
                for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
                    for (int mode = 0; mode < MAX_SSM_PICTUREMODE_INDEX; mode++) {
                        if (!CheckIndexSupport(source, timming))
                            continue;

                        if (!CPQDataBase::GetInstance()->SetColorCustomizeData((TABLE_CMS *)&Cms, mode, source, timming)) {
                            LOGE("source: %d, timming: %d, level: %d fail!\n", source, timming, mode);
                        } else {
                            Flag++;
                        }
                    }
                }
            }
        }
    }

    LOGI("%s Sync Cms %d End\n", __FUNCTION__, Flag);

    return Flag;
}

int SyncDataBase::SyncDataBaseCmsData(void)
{
    LOGI("Sync Cms Start\n");

    int Flag = 0;
    SSM_TABLE_CMS Cms;
    for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
        for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
            for (int mode = 0; mode < MAX_SSM_PICTUREMODE_INDEX; mode++) {
                if (!CheckIndexSupport(source, timming))
                    continue;

                int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_PICTUREMODE_INDEX +
                              timming * MAX_SSM_PICTUREMODE_INDEX +
                              mode) *
                              MAX_SSM_COLORCUSTOMIZE_CM_PARAM_SIZE;
                if (!SSMAction::getInstance()->GetSsmDataParam((void *)&Cms,
                                                                SSM_CMS_ID,
                                                                sizeof(SSM_TABLE_CMS),
                                                                offset,
                                                                true)) {
                    continue;
                }

                if (!CPQDataBase::GetInstance()->SetColorCustomizeData((TABLE_CMS *)&Cms, mode, source, timming)) {
                    LOGE("source: %d, timming: %d, level: %d fail!\n", source, timming, mode);
                } else {
                    Flag++;
                }
            }
        }
    }

    LOGI("Sync Cms %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncDataBaseBySourcePicture(void)
{
    LOGI("Sync BySourcePicture Start\n");

    int Flag = 0;
    PICTURE_SETTING_BY_SRC PictureExt;
    for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
        if (!CPQDataBase::GetInstance()->GetPictureStructDataBySrc(&PictureExt, source + 1)) {
            if (!CPQDataBase::GetInstance()->GetPictureStructDataBySrc(&PictureExt, PQ_SRC_DEFAULT)) {
                continue;
            }
        }

        SSMAction::getInstance()->SSMReadMemcMode(source, &PictureExt.Memc);
        for (int j = 0; j < VPP_MEMC_MODE_MAX; j++) {
            SSMAction::getInstance()->SSMReadMemcDeblurLevel(source * VPP_MEMC_MODE_MAX + j, &PictureExt.memc[j].DeBlurLevel);
            SSMAction::getInstance()->SSMReadMemcDeJudderLevel(source * VPP_MEMC_MODE_MAX + j, &PictureExt.memc[j].DeJudderLevel);
        }
        SSMAction::getInstance()->SSMReadMcDiMode(source, &PictureExt.McDiMode);
        SSMAction::getInstance()->SSMReadDisplayMode(source, &PictureExt.DisplayMode);
        SSMAction::getInstance()->SSMReadLocalDimming(source, &PictureExt.LocalDimming);

        if (!CPQDataBase::GetInstance()->SetPictureStructDataBySrc(&PictureExt, source + 1)) {
            LOGE("SetPictureStructDataBySrc source: %d fail!\n", source);
        } else {
            Flag++;
        }
    }

    LOGI("Sync BySourcePicture %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncDataBaseGlobalPicture(void)
{
    LOGI("Sync GlobalPicture Start\n");

    int Flag = 0;
    PICTURE_SETTING_GLOBAL Global;
    if (!CPQDataBase::GetInstance()->GetPictureStructDataGlobal(&Global)) {
        return Flag;
    }

    SSMAction::getInstance()->SSMReadAipqEnableVal(&Global.aipq_enable);
    SSMAction::getInstance()->SSMReadAiSrMode(&Global.aipq_mode);
    SSMAction::getInstance()->SSMReadWhitebalanceGammaMode(0, &Global.WBGammaPoint);
    SSMAction::getInstance()->SSMReadFilmMakerMode(&Global.FilmMakerEnable);

    if (!CPQDataBase::GetInstance()->SetPictureStructDataGlobal(&Global)) {
        LOGE("fail!\n");
    } else {
        Flag++;
    }

    LOGI("Sync GlobalPicture %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncDataBaseLcdLvdsSsc(void)
{
    LOGI("Sync Lcd Lvds Ssc Start\n");

    int Flag = 0;
    LCD_LVDS_SSC ssc;
    if (SSMAction::getInstance()->SSMReadLVDSSSC(0, sizeof(ssc), (int *)&ssc) < 0) {
        return Flag;
    }

    if (!CPQDataBase::GetInstance()->SetLvdsSscData(&ssc, 0)) {
        LOGE("fail!\n");
    } else {
        Flag++;
    }

    LOGI("Sync Lcd Lvds Ssc %d End\n", Flag);

    return Flag;
}


//============================ CRI DATA =================================================//
bool SyncDataBase::SyncCriDataInit(void)
{
    LOGD("%s Factory Start !\n",__FUNCTION__);

    if (strlen(DatabaseVersion) <= 0) {
        LOGD("%s DatabaseVersion is null !\n",__FUNCTION__);
        return false;
    }

    LOGD("%s base cri data version is %s \n",__FUNCTION__, DatabaseVersion);

    char INFO[64];
    if (WhitebalanceDataBase::GetInstance()->GetSyncData((void *)INFO, sizeof(INFO))) {
        if (strcmp(DatabaseVersion, INFO) == 0) {
            LOGD("%s sync version is match %s == %s\n",__FUNCTION__, DatabaseVersion, INFO);
            return true;
        } else {
            LOGD("%s sync version is not match %s != %s, need sync new version to %s!\n",__FUNCTION__,
                DatabaseVersion, INFO, DatabaseVersion);
        }
    }

    if (strcmp(DatabaseVersion, "3.1") == 0) {
        SyncCriDataColorTempData();
        SyncCriDataMultipointGammaData_3_1();
        SyncCriDataGammaData_3_1();
    } else {
        SyncCriDataColorTempData();
        SyncCriDataMultipointGammaData();
        SyncCriDataGammaData();
    }

    snprintf(INFO, sizeof(INFO), "%s", DatabaseVersion);
    if (!WhitebalanceDataBase::GetInstance()->SetSyncData((void *)INFO, sizeof(INFO))) {
        LOGE("WhitebalanceDataBase::GetInstance()->SetSyncData %s fail!\n", INFO);
        return false;
    }

    LOGD("%s Factory success!\n", __FUNCTION__);

    return true;
}

int SyncDataBase::SyncCriDataColorTempData(void)
{
    LOGI("Sync Factory ColorTemp Start\n");

    int Flag = 0;
    tcon_rgb_ogo_t ColorTempBase;
    for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
        int offset =  CRI_RGBOGO_OFFSET + (CRI_RGBOGO_LEN * k);
        int offsetFlag = offset + CRI_RGBOGO_LEN - 2;
        if (!SSMAction::getInstance()->GetCriDataParam((void *)&ColorTempBase,
                                                        sizeof(tcon_rgb_ogo_t),
                                                        offset,
                                                        true,
                                                        offsetFlag,
                                                        2)) {
            continue;
        }

        if (!WhitebalanceDataBase::GetInstance()->SetRGBGainOffsetData((COLORTEMP_DATA *)&ColorTempBase, k)) {
            LOGE("Warning: SetRGBGainOffsetData level: %d fail!\n", k);
        } else {
            Flag++;
        }
    }

    LOGI("Sync Factory ColorTemp %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncCriDataMultipointGammaData(void)
{
    LOGI("Sync Factory Multipoint Gamma Start\n");

    int Flag = 0;
    GAMMA_OFFSET_DATA ColorTempGamma;
    ColorTempGamma.enable = 1;
    for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
        for (int l = 0; l < WB_GAMMA_MODE_MAX; l++) {
            int offset =  CRI_WB_GAMMA_OFFSET + (CRI_WB_GAMMA_LEN * (k * WB_GAMMA_MODE_MAX + l));
            int offsetFlag = offset + CRI_WB_GAMMA_LEN - 2;
            if (!SSMAction::getInstance()->GetCriDataParam((void *)&ColorTempGamma.Gamma,
                                                            sizeof(Multipoint_GAMMA_DATA),
                                                            offset,
                                                            true,
                                                            offsetFlag,
                                                            2)) {
                continue;
            }

            if (!WhitebalanceDataBase::GetInstance()->SetWhitebalanceGammaData(&ColorTempGamma, k, l)) {
                LOGE("WhitebalanceDataBase::GetInstance()->SetWhitebalanceGammaData level: %d mode: %d fail!\n", k, l);
            } else {
                Flag++;
            }
        }
    }

    LOGI("Sync Factory Multipoint Gamma %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncCriDataGammaData(void)
{
    LOGI("Sync Factory Gamma Start\n");

    int Flag = 0;
    tcon_gamma_table_t Gamma;
    for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
        for (int l = 0; l < MAX_CH; l++) {
            int offset =  CRI_GAMMA_OFFSET + ((k * MAX_CH + l) * CRI_GAMMA_LEN);
            int flag_offset = offset + CRI_GAMMA_LEN - sizeof(int);
            if (!SSMAction::getInstance()->GetCriDataParam((void *)&Gamma,
                                                            sizeof(tcon_gamma_table_t),
                                                            offset,
                                                            true,
                                                            flag_offset,
                                                            4)) {
                continue;
            }

            if (!WhitebalanceDataBase::GetInstance()->SetGammaTableData(&Gamma, k, l)) {
                LOGE("Sync Gamma level: %d type: %d fail!\n", k, l);
            } else {
                Flag++;
            }
        }
    }

    LOGI("Sync Factory Gamma %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncCriDataMultipointGammaData_3_1(void)
{
    LOGI("Sync Factory Multipoint Gamma Start\n");

    int Flag = 0;
    GAMMA_OFFSET_DATA ColorTempGamma;
    ColorTempGamma.enable = 1;
    for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
        for (int l = 0; l < WB_GAMMA_MODE_MAX; l++) {
            int offset =  CRI_DATA_WB_GAMMA_OFFSET_3_1 + (CRI_DATE_WB_GAMMA_LEN_3_1 * (k * WB_GAMMA_MODE_MAX + l));
            int offsetFlag = offset + CRI_DATE_WB_GAMMA_LEN_3_1 - 2;
            if (!SSMAction::getInstance()->GetCriDataParam((void *)&ColorTempGamma.Gamma,
                                                            sizeof(Multipoint_GAMMA_DATA),
                                                            offset,
                                                            true,
                                                            offsetFlag,
                                                            2)) {
                continue;
            }

            if (!WhitebalanceDataBase::GetInstance()->SetWhitebalanceGammaData(&ColorTempGamma, k, l)) {
                LOGE("WhitebalanceDataBase::GetInstance()->SetWhitebalanceGammaData level: %d mode: %d fail!\n", k, l);
            } else {
                Flag++;
            }
        }
    }

    LOGI("Sync Factory Multipoint Gamma %d End\n", Flag);

    return Flag;
}

int SyncDataBase::SyncCriDataGammaData_3_1(void)
{
    LOGI("Sync Factory Gamma Start\n");

    int Flag = 0;
    GAMMA_TABLE Gamma;
    for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
        int offset =  CRI_DATA_GAMMA_OFFSET_3_1 + (k * CRI_DATE_GAMMA_LEN_3_1);
        int flag_offset = offset + CRI_DATE_GAMMA_LEN_3_1 - 2;
        if (!SSMAction::getInstance()->GetCriDataParam((void *)&Gamma,
                                                        sizeof(GAMMA_TABLE),
                                                        offset,
                                                        true,
                                                        flag_offset,
                                                        2)) {
            continue;
        }

        int ret = 0;
        if (!WhitebalanceDataBase::GetInstance()->SetGammaTableData(&Gamma.R, k, RED_CH)) {
            ret |= -1;
            LOGE("Sync Gamma level: %d type: %d fail!\n", k, RED_CH);
        }

        if (!WhitebalanceDataBase::GetInstance()->SetGammaTableData(&Gamma.G, k, GREEN_CH)) {
            ret |= -1;
            LOGE("Sync Gamma level: %d type: %d fail!\n", k, GREEN_CH);
        }

        if (!WhitebalanceDataBase::GetInstance()->SetGammaTableData(&Gamma.B, k, BLUE_CH)) {
            ret |= -1;
            LOGE("Sync Gamma level: %d type: %d fail!\n", k, BLUE_CH);
        }

        if (ret == 0)
            Flag++;
    }

    LOGI("Sync Factory Gamma %d End\n", Flag);

    return Flag;
}

bool SyncDataBase::CheckIndexSupport(int source, int timming)
{
    if ((source == PQ_SRC_TV) ||
        (source >= PQ_SRC_AV1 && source <= PQ_SRC_YPBPR2) ||
        (source == PQ_SRC_VGA) ||
        (source == PQ_SRC_SVIDEO)) {
        if (timming != PQ_FMT_SDR)
            return false;
    } else if (source >= PQ_SRC_IPTV && source < PQ_SRC_MAX) {
        return false;
    }

    if (source != PQ_SRC_DEFAULT) {
        if (timming == PQ_FMT_DEFAULT) {
            return false;
        }
    }

    return true;
}