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

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

#include "CPQDataBase.h"
#include "CPQLog.h"
#include "CConfigFile.h"

#include "SSMAction.h"

extern TABLE_VER_OSD                           mVerInfoOSD;
extern TABLE_DATA_STRUCT                       mNonlinearMappingTable[];
extern TABLE_DATA_STRUCT                       mPictureModeTypeTable[];
extern TABLE_DATA_STRUCT                       mPictureModeTable[];
extern TABLE_DATA_STRUCT                       mColorTempTable[];
extern TABLE_DATA_STRUCT                       mRGBOffsetTable[];
extern TABLE_DATA_STRUCT                       mGammaOffsetTable[];
extern TABLE_DATA_STRUCT                       mColorCustomizeTable[];
extern TABLE_DATA_STRUCT                       mPictureSettingBySourceTable[];
extern PICTURE_SETTING_GLOBAL                  mDefaultPictureSettingGlobalType;

#define PICTURE_TABLE_NAME                     "PICTURE_TABLE"

#define KEY_VERSION_INFO                       "KEY_VERSION_INFO"

#define KEY_NONLINEAR_MAPPING                  "KEY_NONLINEAR_MAPPING"
#define KEY_DEFAULT_NONLINEAR_MAPPING          "KEY_DEFAULT_NONLINEAR_MAPPING"

#define KEY_PQ_MODE                            "KEY_PQ_MODE"
#define KEY_DEFAULT_PQ_MODE                    "KEY_DEFAULT_PQ_MODE"
#define KEY_LAST_PQ_MODE                       "KEY_LAST_PQ_MODE"

#define KEY_PICTURE_MODE                       "KEY_PICTURE_MODE"
#define KEY_DEFAULT_PICTURE_MODE               "KEY_DEFAULT_PICTURE_MODE"

#define KEY_COLOR_TEMPERATURE                  "KEY_COLOR_TEMPERATURE"
#define KEY_DEFAULT_COLOR_TEMPERATURE          "KEY_DEFAULT_COLOR_TEMPERATURE"

#define KEY_RGB_OFFSET                         "KEY_RGB_OFFSET"
#define KEY_DEFAULT_RGB_OFFSET                 "KEY_DEFAULT_RGB_OFFSET"

#define KEY_GAMMA_OFFSET                       "KEY_GAMMA_OFFSET"
#define KEY_DEFAULT_GAMMA_OFFSET               "KEY_DEFAULT_GAMMA_OFFSET"

#define KEY_CMS                                "KEY_CMS"
#define KEY_DEFAULT_CMS                        "KEY_DEFAULT_CMS"

#define KEY_PICTURE_BY_SRC                     "KEY_PICTURE_BY_SRC"
#define KEY_DEFAULT_PICTURE_BY_SRC             "KEY_DEFAULT_PICTURE_BY_SRC"

#define KEY_PICTURE_GLOBAL                     "KEY_PICTURE_GLOBAL"
#define KEY_DEFAULT_PICTURE_GLOBAL             "KEY_DEFAULT_PICTURE_GLOBAL"

#define PQ_SQL_DEFAULT_PATH                    "/vendor/etc/tvconfig/pq"

#define PARAM_OSD_BIN_PATH                     "/vendor/etc/tvconfig/pq/UI_PQSetting.bin"

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

    return mInstance;
}

CPQDataBase::CPQDataBase()
{
}

CPQDataBase::~CPQDataBase()
{
}

int CPQDataBase::Init(const char *path)
{
    static char sql_path[128] = "\0";

    const char *config_value = NULL;
    if (path == NULL) {
        SYS_LOGI("%s Path is NULL\n",__FUNCTION__);
        config_value = CConfigFile::GetInstance()->GetSettingDataFilePath(CFG_SECTION_PQ, CFG_PQ_SETTINGDATA_FILE_PATH, PQ_SQL_DEFAULT_PATH);
    } else {
        config_value = path;
    }

    snprintf(sql_path, sizeof(sql_path), "%s/TV_PICTURE", config_value);

    SYS_LOGD("%s Gen Sql Path: %s\n",__FUNCTION__, sql_path);

    closeDb();
    if (CreateNewDB(sql_path) != true) {
        SYS_LOGE("%s CreateNewDB fail!\n", sql_path);
        return -1;
    }

    if (!CheckTable()) {
        SYS_LOGE("%s DataBase Structural changes, Init DataBase!!!\n", __FUNCTION__);
        InitialValue();
    }

    return 0;
}

int CPQDataBase::closePqDB(void)
{
    return closeDb();
}

int CPQDataBase::reopenDB(const char *db_path)
{
    int  rval = openDb(db_path);
    return rval;
}

bool CPQDataBase::CreateNewDB(const char *db_path)
{
    if (openDb(db_path) != 0) {// Create a new db file
        SYS_LOGE("%s Create db file fail!\n",__FUNCTION__);
        closeDb();
        return false;
    }

    if (CreateTable(PICTURE_TABLE_NAME) != true) {
        SYS_LOGE("%s Create table %s fail!\n",__FUNCTION__, PICTURE_TABLE_NAME);
        return false;
    }

    return true;
}

bool CPQDataBase::CreateTable(const char *TableName)
{
    char key[128];
    snprintf(key, sizeof(key), "CREATE TABLE IF NOT EXISTS %s(Key TEXT PRIMARY KEY, Value BLOB)", TableName);

    if (exeSql(key) != true) {
        SYS_LOGE("%s CREATE SQL: %s fail!\n", __FUNCTION__, key);
        return false;
    }

    //for get
    char key_get[128];
    snprintf(key_get, sizeof(key_get), "SELECT Value FROM %s WHERE Key=?", TableName);
    PrepareSqlSelect(key_get);

    //for set
    char key_set[128];
    snprintf(key_set, sizeof(key_set), "REPLACE INTO %s(Key,Value) VALUES(?,?)", TableName);
    PrepareSqlUpdate(key_set);

    //for delete
    char key_delete[128];
    snprintf(key_delete, sizeof(key_delete), "DELETE FROM %s WHERE Key=?", TableName);
    PrepareSqlDelete(key_delete);

    return true;
}

bool CPQDataBase::LoadOSDBin(void)
{
    static const char *OSD_bin_path = NULL;

    OSD_bin_path = CConfigFile::GetInstance()->GetString(CFG_SECTION_PQ, CFG_PQ_UI_SETTING_PATH, PARAM_OSD_BIN_PATH);
    if (OSD_bin_path == NULL) {
        SYS_LOGE("%s sql path is NULL\n",__FUNCTION__);
        return false;
    }

    SYS_LOGD("%s Load OSD Bin: %s\n",__FUNCTION__, OSD_bin_path);

    if (!CConfigFile::GetInstance()->isFileExist(OSD_bin_path)) {
        return false;
    }

    FILE *pFile = fopen(OSD_bin_path, "rb");
    if (pFile == NULL) {
        SYS_LOGE("%s pFile is NULL, no OSD bin: %s access! return to load default Table\n", __FUNCTION__, OSD_bin_path);
        return false;
    }

    fseek(pFile, 0L, SEEK_END);
    long size = ftell(pFile);
    rewind(pFile);

    if (size <= 0) {
        SYS_LOGE("%s Load  %s fail! size = %ld\n",__FUNCTION__, OSD_bin_path, size);
        fclose(pFile);
        return false;
    }

    const long MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
    if (size > MAX_FILE_SIZE) {
        SYS_LOGE("%s File too large: %ld bytes\n",__FUNCTION__, size);
        fclose(pFile);
        return false;
    }

    unsigned char *buffer = (unsigned char *)malloc(size);
    if (buffer == NULL) {
        SYS_LOGE("%s malloc buffer size = %ld fail\n",__FUNCTION__, size);
        fclose(pFile);
        return false;
    }

    unsigned int readSize = fread(buffer, 1, size, pFile);
    if (readSize != (unsigned int)size) {
        SYS_LOGE("%s fread readSize = %u, expected = %ld\n",__FUNCTION__, readSize, size);
        free(buffer);
        fclose(pFile);
        return false;
    }

    fclose(pFile); // close File

    if (static_cast<size_t>(size) < sizeof(PQ_OSD_FILE_HEADER)) {
        SYS_LOGE("%s File too small for header\n",__FUNCTION__);
        free(buffer);
        return false;
    }

    //============================================Check CRC===========================================================//
    PQ_OSD_FILE_HEADER *pHeader = (PQ_OSD_FILE_HEADER *)buffer;
    size_t dataOffset = sizeof(PQ_OSD_FILE_HEADER);
    if (static_cast<size_t>(size) < dataOffset) {
        SYS_LOGE("%s Invalid file size for CRC calculation\n",__FUNCTION__);
        free(buffer);
        return false;
    }

    size_t crcSize = size - dataOffset;
    unsigned char *pData = buffer + dataOffset;
    unsigned short int crc = get_crc16((unsigned const char *)pData, crcSize);
    if (crc != pHeader->crc) {
        SYS_LOGE("%s CRC: %d != pHeader->crc: %d, bin not match, return false\n",__FUNCTION__, crc, pHeader->crc);
        free(buffer);
        return false;
    } else {
        SYS_LOGD("%s CRC %d OK\n",__FUNCTION__, crc);
    }
    //================================================================================================================//


    PQ_OSD_TABLE_STRUCT_HEADER *pTableHeader = NULL;
    unsigned char *pTableData = NULL;
    unsigned char *pTableIndex = NULL;
    PQ_OSD_TABLE_DATA_STRUCT_SAVE *pIndex = NULL;
    unsigned int IndexMaxNum = 0;
    unsigned int MaxTableNum = 0;

    //========================================PqOsdVer================================================================//
    if (!GetTable(pData, pHeader->PqOsdVerOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        SYS_LOGE("%s GetTable for PqOsdVerOffset failed\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(TABLE_VER_OSD);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s PqOsdVer IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s PqOsdVer IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    TABLE_VER_OSD *pVerOsdData = (TABLE_VER_OSD *)pTableData;
    if (pVerOsdData == NULL) {
        SYS_LOGE("%s pVerOsdData is NULL\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    if (!SetVersionInfo(pVerOsdData)) {
        free(buffer);
        return false;
    }
    SYS_LOGD("%s ProjectVersion: %.255s\n",__FUNCTION__, pVerOsdData->ProjectVersion);
    SYS_LOGD("%s ChipVersion:    %.255s\n",__FUNCTION__, pVerOsdData->ChipVersion);
    SYS_LOGD("%s TableVersion:   %.255s\n",__FUNCTION__, pVerOsdData->TableVersion);
    SYS_LOGD("%s oem_model:      %.255s\n",__FUNCTION__, pVerOsdData->oem_model);
    SYS_LOGD("%s PanelIndex:     %.255s\n",__FUNCTION__, pVerOsdData->PanelIndex);
    //================================================================================================================//


    //=======================================NonlinearMapping=========================================================//
    if (!GetTable(pData, pHeader->NonlinearMappingOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        SYS_LOGE("%s GetTable for NonlinearMappingOffset failed\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(NonlinearModeType);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s NonlinearMapping IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s NonlinearMapping IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    NonlinearModeType *pNonlinearData = (NonlinearModeType *)pTableData;
    if ((unsigned char*)pNonlinearData < pData || (unsigned char*)pNonlinearData >= pData + crcSize) {
        SYS_LOGE("%s pNonlinearData table data out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    pIndex = (PQ_OSD_TABLE_DATA_STRUCT_SAVE *)pTableIndex;
    if ((unsigned char*)pIndex < pData || (unsigned char*)pIndex >= pData + crcSize) {
        SYS_LOGE("%s NonlinearMapping index table out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    for (unsigned char i = 0; i < IndexMaxNum; i++) {
        if (pIndex[i].tableDataIdx > (short)MaxTableNum ||
            pIndex[i].tableDataIdx < 0 ||
            pIndex[i].tableDataLen > 1) {
            SYS_LOGE("%s Invalid NonlinearMapping tableDataIdx %d or tableDataLen %u at index %d\n",
                     __FUNCTION__, pIndex[i].tableDataIdx, pIndex[i].tableDataLen, i);
            free(buffer);
            return false;
        }

        unsigned int idx = 0;
        for (short j = 0; j < pIndex[i].tableDataIdx; j++) {
            idx += pIndex[j].tableDataLen;
            if (idx > MaxTableNum) {
                SYS_LOGE("%s Invalid NonlinearMapping idx = %d at index %d\n", __FUNCTION__, idx, i);
                free(buffer);
                return false;
            }
        }

        for (unsigned int j = 0; j < pIndex[i].tableDataLen; j++) {
            if ((idx + j) > MaxTableNum) {
                SYS_LOGE("%s Invalid NonlinearMapping [idx + j] = %d at index %d\n", __FUNCTION__, idx + j, i);
                free(buffer);
                return false;
            }

            if (!SetNonlinearData(&pNonlinearData[idx + j], pIndex[i].source, pIndex[i].timing) ||
                !SetDefaultNonlinearData(&pNonlinearData[idx + j], pIndex[i].source, pIndex[i].timing)) {
                free(buffer);
                return false;
            }
        }
    }
    //================================================================================================================//


    //=======================================PictureModeType==========================================================//
    if (!GetTable(pData, pHeader->PictureModeTypeOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(PICTURE_MODE_DEFAULT);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s PictureModeType IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s PictureModeType IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    PICTURE_MODE_DEFAULT *pPictureMode = (PICTURE_MODE_DEFAULT *)pTableData;
    if ((unsigned char*)pPictureMode < pData || (unsigned char*)pPictureMode >= pData + crcSize) {
        SYS_LOGE("%s pPictureMode table data out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    pIndex = (PQ_OSD_TABLE_DATA_STRUCT_SAVE *)pTableIndex;
    if ((unsigned char*)pIndex < pData || (unsigned char*)pIndex >= pData + crcSize) {
        SYS_LOGE("%s PictureModeType index table out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    for (unsigned char i = 0; i < IndexMaxNum; i++) {
        if (pIndex[i].tableDataIdx > (short)MaxTableNum ||
            pIndex[i].tableDataIdx < 0 ||
            pIndex[i].tableDataLen > 1) {
            SYS_LOGE("%s Invalid PictureModeType tableDataIdx %d or tableDataLen %u at index %d\n",
                     __FUNCTION__, pIndex[i].tableDataIdx, pIndex[i].tableDataLen, i);
            free(buffer);
            return false;
        }

        unsigned int idx = 0;
        for (short j = 0; j < pIndex[i].tableDataIdx; j++) {
            idx += pIndex[j].tableDataLen;
            if (idx > MaxTableNum) {
                SYS_LOGE("%s Invalid PictureModeType idx = %d at index %d\n", __FUNCTION__, idx, i);
                free(buffer);
                return false;
            }
        }
        for (unsigned int j = 0; j < pIndex[i].tableDataLen; j++) {
            if ((idx + j) > MaxTableNum) {
                SYS_LOGE("%s Invalid PictureModeType [idx + j] = %d at index %d\n", __FUNCTION__, idx + j, i);
                free(buffer);
                return false;
            }
            if (!SetPictureMode(&pPictureMode[idx + j], pIndex[i].source, pIndex[i].timing) ||
                !SetLastPictureMode(&pPictureMode[idx + j], pIndex[i].source, pIndex[i].timing) ||
                !SetDefaultPictureMode(&pPictureMode[idx + j], pIndex[i].source, pIndex[i].timing)) {
                free(buffer);
                return false;
            }
        }
    }
    //================================================================================================================//


    //========================================PictureMode=============================================================//
    if (!GetTable(pData, pHeader->PictureModeOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(PICTURE_MODE_DATA);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s PictureMode IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s PictureMode IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    PICTURE_MODE_DATA *pPicData = (PICTURE_MODE_DATA *)pTableData;
    if ((unsigned char*)pPicData < pData || (unsigned char*)pPicData >= pData + crcSize) {
        SYS_LOGE("%s PictureMode table data out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    pIndex = (PQ_OSD_TABLE_DATA_STRUCT_SAVE *)pTableIndex;
    if ((unsigned char*)pIndex < pData || (unsigned char*)pIndex >= pData + crcSize) {
        SYS_LOGE("%s PictureMode index table out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    for (unsigned char i = 0; i < IndexMaxNum; i++) {
        if (pIndex[i].tableDataIdx > (short)MaxTableNum ||
            pIndex[i].tableDataIdx < 0 ||
            pIndex[i].tableDataLen > PICTURE_MODE_MAX) {
            SYS_LOGE("%s Invalid PictureMode tableDataIdx %d or tableDataLen %u at index %d\n",
                     __FUNCTION__, pIndex[i].tableDataIdx, pIndex[i].tableDataLen, i);
            free(buffer);
            return false;
        }

        unsigned int idx = 0;
        for (short j = 0; j < pIndex[i].tableDataIdx; j++) {
            if (j >= (short)IndexMaxNum) {
                SYS_LOGE("%s PictureMode inner index %d out of range %u\n", __FUNCTION__, j, IndexMaxNum);
                free(buffer);
                return false;
            }

            idx += pIndex[j].tableDataLen;
            if (idx > MaxTableNum) {
                SYS_LOGE("%s Invalid PictureMode idx = %u at index %d\n", __FUNCTION__, idx, i);
                free(buffer);
                return false;
            }
        }
        for (unsigned int j = 0; j < pIndex[i].tableDataLen; j++) {
            if ((idx + j) > MaxTableNum) {
                SYS_LOGE("%s Invalid PictureMode [idx + j] = %d at index %d\n", __FUNCTION__, idx + j, i);
                free(buffer);
                return false;
            }
            if (!SetPictureModeData(&pPicData[idx + j].DataInfo, pIndex[i].source, pIndex[i].timing, pPicData[idx + j].mode) ||
                !SetDefaultPictureModeData(&pPicData[idx + j].DataInfo, pIndex[i].source, pIndex[i].timing, pPicData[idx + j].mode)) {
                free(buffer);
                return false;
            }
        }
    }
    //================================================================================================================//


    //========================================ColorTemperature========================================================//
    if (!GetTable(pData, pHeader->ColorTempOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(COLORTEMP_DATA);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s ColorTemperature IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s ColorTemperature IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    COLORTEMP_DATA *pColorTemp = (COLORTEMP_DATA *)pTableData;
    if ((unsigned char*)pColorTemp < pData || (unsigned char*)pColorTemp >= pData + crcSize) {
        SYS_LOGE("%s pColorTemp table data out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    pIndex = (PQ_OSD_TABLE_DATA_STRUCT_SAVE *)pTableIndex;
    if ((unsigned char*)pIndex < pData || (unsigned char*)pIndex >= pData + crcSize) {
        SYS_LOGE("%s ColorTemperature index table out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    for (unsigned char i = 0; i < IndexMaxNum; i++) {
        if (pIndex[i].tableDataIdx > (short)MaxTableNum ||
            pIndex[i].tableDataIdx < 0 ||
            pIndex[i].tableDataLen > COLOR_TMP_MODE_MAX) {
            SYS_LOGE("%s Invalid ColorTemperature tableDataIdx %d or tableDataLen %u at index %d\n",__FUNCTION__,
                     pIndex[i].tableDataIdx, pIndex[i].tableDataLen, i);
            free(buffer);
            return false;
        }

        unsigned int idx = 0;
        for (short j = 0; j < pIndex[i].tableDataIdx; j++) {
            idx += pIndex[j].tableDataLen;
            if (idx > MaxTableNum) {
                SYS_LOGE("%s Invalid ColorTemperature idx = %d at index %d\n", __FUNCTION__, idx, i);
                free(buffer);
                return false;
            }
        }
        for (unsigned int j = 0; j < pIndex[i].tableDataLen; j++) {
            if ((idx + j) > MaxTableNum) {
                SYS_LOGE("%s Invalid ColorTemperature [idx + j] = %d at index %d\n", __FUNCTION__, idx + j, i);
                free(buffer);
                return false;
            }
            if (!SetColorTemperatureData(&pColorTemp[idx + j], pIndex[i].source, pIndex[i].timing, (int)j) ||
                !SetDefaultColorTemperatureData(&pColorTemp[idx + j], pIndex[i].source, pIndex[i].timing, (int)j)) {
                free(buffer);
                return false;
            }
        }
    }
    //================================================================================================================//


    //========================================RgbOffset===============================================================//
    if (!GetTable(pData, pHeader->RgbOffsetOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(COLORTEMP_OFFSET_DATA);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s RgbOffset IndexMaxNum %u or MaxTableNum %u out of range 255\n",__FUNCTION__, IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s RgbOffset IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    COLORTEMP_OFFSET_DATA *pRGBOffset = (COLORTEMP_OFFSET_DATA *)pTableData;
    if ((unsigned char*)pRGBOffset < pData || (unsigned char*)pRGBOffset >= pData + crcSize) {
        SYS_LOGE("%s pColorTemp table data out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    pIndex = (PQ_OSD_TABLE_DATA_STRUCT_SAVE *)pTableIndex;
    if ((unsigned char*)pIndex < pData || (unsigned char*)pIndex >= pData + crcSize) {
        SYS_LOGE("%s RgbOffset index table out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    for (unsigned char i = 0; i < IndexMaxNum; i++) {
        if (pIndex[i].tableDataIdx > (short)MaxTableNum ||
            pIndex[i].tableDataIdx < 0 ||
            pIndex[i].tableDataLen > COLOR_TMP_MODE_MAX) {
            SYS_LOGE("%s Invalid RgbOffset tableDataIdx %d or tableDataLen %u at index %d\n",__FUNCTION__,
                     pIndex[i].tableDataIdx, pIndex[i].tableDataLen, i);
            free(buffer);
            return false;
        }

        unsigned int idx = 0;
        for (short j = 0; j < pIndex[i].tableDataIdx; j++) {
            idx += pIndex[j].tableDataLen;
            if (idx > MaxTableNum) {
                SYS_LOGE("%s Invalid RgbOffset idx = %d at index %d\n", __FUNCTION__, idx, i);
                free(buffer);
                return false;
            }
        }
        for (unsigned int j = 0; j < pIndex[i].tableDataLen; j++) {
            if ((idx + j) > MaxTableNum) {
                SYS_LOGE("%s Invalid RgbOffset [idx + j] = %d at index %d\n", __FUNCTION__, idx + j, i);
                free(buffer);
                return false;
            }
            if (!SetRGBOffsetData(&pRGBOffset[idx + j], (int)j, pIndex[i].source, pIndex[i].timing) ||
                !SetDefaultRGBOffsetData(&pRGBOffset[idx + j], (int)j, pIndex[i].source, pIndex[i].timing)) {
                free(buffer);
                return false;
            }
        }
    }
    //================================================================================================================//


    //======================================GammaOffset===============================================================//
    if (!GetTable(pData, pHeader->GammaOffsetOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(GAMMA_OFFSET_DATA);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s GammaOffset IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s GammaOffset IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    GAMMA_OFFSET_DATA *pGamma = (GAMMA_OFFSET_DATA *)pTableData;
    if ((unsigned char*)pGamma < pData || (unsigned char*)pRGBOffset >= pData + crcSize) {
        SYS_LOGE("%s pGamma table data out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    pIndex = (PQ_OSD_TABLE_DATA_STRUCT_SAVE *)pTableIndex;
    if ((unsigned char*)pIndex < pData || (unsigned char*)pIndex >= pData + crcSize) {
        SYS_LOGE("%s GammaOffset index table out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    for (unsigned char i = 0; i < IndexMaxNum; i++) {
        if (pIndex[i].tableDataIdx > (short)MaxTableNum ||
            pIndex[i].tableDataIdx < 0 ||
            pIndex[i].tableDataLen > COLOR_TMP_MODE_MAX) {
            SYS_LOGE("%s Invalid GammaOffset tableDataIdx %d or tableDataLen %u at index %d\n",__FUNCTION__,
                     pIndex[i].tableDataIdx, pIndex[i].tableDataLen, i);
            free(buffer);
            return false;
        }

        unsigned int idx = 0;
        for (short j = 0; j < pIndex[i].tableDataIdx; j++) {
            idx += pIndex[j].tableDataLen;
            if (idx > MaxTableNum) {
                SYS_LOGE("%s Invalid GammaOffset idx = %d at index %d\n", __FUNCTION__, idx, i);
                free(buffer);
                return false;
            }
        }
        for (unsigned int j = 0; j < pIndex[i].tableDataLen; j++) {
            if ((idx + j) > MaxTableNum) {
                SYS_LOGE("%s Invalid GammaOffset [idx + j] = %d at index %d\n", __FUNCTION__, idx + j, i);
                free(buffer);
                return false;
            }
            if (!SetGammaOffsetData(&pGamma[idx + j], (int)j, pIndex[i].type, pIndex[i].source, pIndex[i].timing) ||
                !SetDefaultGammaOffsetData(&pGamma[idx + j], (int)j, pIndex[i].type, pIndex[i].source, pIndex[i].timing)) {
                free(buffer);
                return false;
            }
        }
    }
    //================================================================================================================//


    //======================================ColorCustomize============================================================//
    if (!GetTable(pData, pHeader->ColorCustomizeOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(TABLE_CMS);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s CMS IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s CMS IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    TABLE_CMS *pCms = (TABLE_CMS *)pTableData;
    if ((unsigned char*)pCms < pData || (unsigned char*)pCms >= pData + crcSize) {
        SYS_LOGE("%s pCms table data out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    pIndex = (PQ_OSD_TABLE_DATA_STRUCT_SAVE *)pTableIndex;
    if ((unsigned char*)pIndex < pData || (unsigned char*)pIndex >= pData + crcSize) {
        SYS_LOGE("%s CMS index table out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    for (unsigned char i = 0; i < IndexMaxNum; i++) {
        if (pIndex[i].tableDataIdx > (short)MaxTableNum ||
            pIndex[i].tableDataIdx < 0 ||
            pIndex[i].tableDataLen > 1) {
            SYS_LOGE("%s Invalid CMS tableDataIdx %d or tableDataLen %u at index %d\n",__FUNCTION__,
                     pIndex[i].tableDataIdx, pIndex[i].tableDataLen, i);
            free(buffer);
            return false;
        }

        unsigned int idx = 0;
        for (short j = 0; j < pIndex[i].tableDataIdx; j++) {
            idx += pIndex[j].tableDataLen;
            if (idx > MaxTableNum) {
                SYS_LOGE("%s Invalid CMS idx = %d at index %d\n", __FUNCTION__, idx, i);
                free(buffer);
                return false;
            }
        }
        for (unsigned int j = 0; j < pIndex[i].tableDataLen; j++) {
            if ((idx + j) > MaxTableNum) {
                SYS_LOGE("%s Invalid CMS [idx + j] = %d at index %d\n", __FUNCTION__, idx + j, i);
                free(buffer);
                return false;
            }
            if (!SetColorCustomizeData(&pCms[idx + j], pIndex[i].type, pIndex[i].source, pIndex[i].timing) ||
                !SetDefaultColorCustomizeData(&pCms[idx + j], pIndex[i].type, pIndex[i].source, pIndex[i].timing)) {
                free(buffer);
                return false;
            }
        }
    }
    //================================================================================================================//


    //=========================================PictureSettingBySource=================================================//
    if (!GetTable(pData, pHeader->PictureSettingBySourceOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(PICTURE_SETTING_BY_SRC);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s BySource IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s BySource IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    PICTURE_SETTING_BY_SRC *BySource = (PICTURE_SETTING_BY_SRC *)pTableData;
    if ((unsigned char*)BySource < pData || (unsigned char*)BySource >= pData + crcSize) {
        SYS_LOGE("%s BySource table data out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    pIndex = (PQ_OSD_TABLE_DATA_STRUCT_SAVE *)pTableIndex;
    if ((unsigned char*)pIndex < pData || (unsigned char*)pIndex >= pData + crcSize) {
        SYS_LOGE("%s BySource index table out of range\n", __FUNCTION__);
        free(buffer);
        return false;
    }

    for (unsigned char i = 0; i < IndexMaxNum; i++) {
        if (pIndex[i].tableDataIdx > (short)MaxTableNum ||
            pIndex[i].tableDataIdx < 0 ||
            pIndex[i].tableDataLen > 1) {
            SYS_LOGE("%s Invalid BySource tableDataIdx %d or tableDataLen %u at index %d\n",__FUNCTION__,
                     pIndex[i].tableDataIdx, pIndex[i].tableDataLen, i);
            free(buffer);
            return false;
        }

        unsigned int idx = 0;
        for (short j = 0; j < pIndex[i].tableDataIdx; j++) {
            idx += pIndex[j].tableDataLen;
            if (idx > MaxTableNum) {
                SYS_LOGE("%s Invalid BySource idx = %d at index %d\n", __FUNCTION__, idx, i);
                free(buffer);
                return false;
            }
        }
        for (unsigned int j = 0; j < pIndex[i].tableDataLen; j++) {
            if ((idx + j) > MaxTableNum) {
                SYS_LOGE("%s Invalid BySource [idx + j] = %d at index %d\n", __FUNCTION__, idx + j, i);
                free(buffer);
                return false;
            }
            if (!SetPictureStructDataBySrc(&BySource[idx + j], pIndex[i].source) ||
                !SetDefaultPictureStructDataBySrc(&BySource[idx + j], pIndex[i].source)) {
                free(buffer);
                return false;
            }
        }
    }
    //================================================================================================================//


    //=========================================PictureSettingGlobal===================================================//
    if (!GetTable(pData, pHeader->PictureSettingGlobalOffset, crcSize, &pTableHeader, &pTableData, &pTableIndex)) {
        free(buffer);
        return false;
    }

    IndexMaxNum = pTableHeader->IndexTableNum;
    MaxTableNum = pTableHeader->TableSize / sizeof(PICTURE_SETTING_GLOBAL);
    if (IndexMaxNum > 255 || MaxTableNum > 255) {
        SYS_LOGE("%s Global IndexMaxNum %u or MaxTableNum %u out of range\n",__FUNCTION__,IndexMaxNum, MaxTableNum);
        free(buffer);
        return false;
    }
    SYS_LOGD("%s Global IndexMaxNum: %u, MaxTableNum: %u\n", __FUNCTION__, IndexMaxNum, MaxTableNum);

    PICTURE_SETTING_GLOBAL *byGlobal = (PICTURE_SETTING_GLOBAL *)pTableData;
    if (!SetPictureStructDataGlobal(byGlobal) ||
        !SetDefaultPictureStructDataGlobal(byGlobal)) {
        free(buffer);
        return false;
    }
    //================================================================================================================//

    if (buffer)
        free(buffer);

    SYS_LOGD("%s done\n", __FUNCTION__);

    return true;
}

bool CPQDataBase::LoadDefaultTable(void)
{
    SYS_LOGD("%s Star to load default Table\n",__FUNCTION__);

    if (!SetVersionInfo(&mVerInfoOSD))
        return false;
    SYS_LOGD("%s ProjectVersion: %s\n",__FUNCTION__, mVerInfoOSD.ProjectVersion);
    SYS_LOGD("%s ChipVersion:    %s\n",__FUNCTION__, mVerInfoOSD.ChipVersion);
    SYS_LOGD("%s TableVersion:   %s\n",__FUNCTION__, mVerInfoOSD.TableVersion);
    SYS_LOGD("%s oem_model:      %s\n",__FUNCTION__, mVerInfoOSD.oem_model);
    SYS_LOGD("%s PanelIndex:     %s\n",__FUNCTION__, mVerInfoOSD.PanelIndex);

    for (int i = 0; i < GetNonlinearMappingTableSize(); i++) {
        TABLE_DATA_STRUCT* pTable = &mNonlinearMappingTable[i];
        NonlinearModeType *pData = (NonlinearModeType *)pTable->tableData;
        for (unsigned int j = 0; j < pTable->tableDataLen; j++) {
            if (!SetNonlinearData(&pData[j], pTable->source, pTable->timing))
                return false;
            if (!SetDefaultNonlinearData(&pData[j], pTable->source, pTable->timing))
                return false;
        }
    }

    for (int i = 0; i < GetPictureModeTypeTableSize(); i++) {
        TABLE_DATA_STRUCT* pTable = &mPictureModeTypeTable[i];
        PICTURE_MODE_DEFAULT *pData = (PICTURE_MODE_DEFAULT *)pTable->tableData;
        for (unsigned int j = 0; j < pTable->tableDataLen; j++) {
            if (!SetPictureMode(&pData[j], pTable->source, pTable->timing))
                return false;
            if (!SetLastPictureMode(&pData[j], pTable->source, pTable->timing))
                return false;
            if (!SetDefaultPictureMode(&pData[j], pTable->source, pTable->timing))
                return false;
        }
    }

    for (int i = 0; i < GetPictureModeTableSize(); i++) {
        TABLE_DATA_STRUCT* pTable = &mPictureModeTable[i];
        PICTURE_MODE_DATA *pData = (PICTURE_MODE_DATA *)pTable->tableData;
        for (unsigned int j = 0; j < pTable->tableDataLen; j++) {
            if (!SetPictureModeData(&pData[j].DataInfo, pTable->source, pTable->timing, pData[j].mode))
                return false;
            if (!SetDefaultPictureModeData(&pData[j].DataInfo, pTable->source, pTable->timing, pData[j].mode))
                return false;
        }
    }

    for (int i = 0; i < GetColorTempTableSize(); i++) {
        TABLE_DATA_STRUCT* pTable = &mColorTempTable[i];
        COLORTEMP_DATA *pData = (COLORTEMP_DATA *)pTable->tableData;
        for (unsigned int j = 0; j < pTable->tableDataLen; j++) {
            if (!SetColorTemperatureData(&pData[j], pTable->source, pTable->timing, (int)j))
                return false;
            if (!SetDefaultColorTemperatureData(&pData[j], pTable->source, pTable->timing, (int)j))
                return false;
        }
    }

    for (int i = 0; i < GetRGBOffsetTableSize(); i++) {
        TABLE_DATA_STRUCT* pTable = &mRGBOffsetTable[i];
        COLORTEMP_OFFSET_DATA *pData = (COLORTEMP_OFFSET_DATA *)pTable->tableData;
        for (unsigned int j = 0; j < pTable->tableDataLen; j++) {
            if (!SetRGBOffsetData(&pData[j], (int)j, pTable->source, pTable->timing))
                return false;
            if (!SetDefaultRGBOffsetData(&pData[j], (int)j, pTable->source, pTable->timing))
                return false;
        }
    }

    for (int i = 0; i < GetGammaOffsetTableSize(); i++) {
        TABLE_DATA_STRUCT* pTable = &mGammaOffsetTable[i];
        GAMMA_OFFSET_DATA *pData = (GAMMA_OFFSET_DATA *)pTable->tableData;
        for (unsigned int j = 0; j < pTable->tableDataLen; j++) {
            if (!SetGammaOffsetData(&pData[j], (int)j, pTable->type, pTable->source, pTable->timing))
                return false;
            if (!SetDefaultGammaOffsetData(&pData[j], (int)j, pTable->type, pTable->source, pTable->timing))
                return false;
        }
    }

    for (int i = 0; i < GetColorCustomizeTableSize(); i++) {
        TABLE_DATA_STRUCT* pTable = &mColorCustomizeTable[i];
        TABLE_CMS *pData = (TABLE_CMS *)pTable->tableData;
        for (unsigned int j = 0; j < pTable->tableDataLen; j++) {
            if (!SetColorCustomizeData(&pData[j], pTable->type, pTable->source, pTable->timing))
                return false;
            if (!SetDefaultColorCustomizeData(&pData[j], pTable->type, pTable->source, pTable->timing))
                return false;
        }
    }

    for (int i = 0; i < GetPictureSettingBySourceTableSize(); i++) {
        TABLE_DATA_STRUCT* pTable = &mPictureSettingBySourceTable[i];
        PICTURE_SETTING_BY_SRC *pData = (PICTURE_SETTING_BY_SRC *)pTable->tableData;
        for (unsigned int j = 0; j < pTable->tableDataLen; j++) {
            if (!SetPictureStructDataBySrc(&pData[j], pTable->source))
                return false;
            if (!SetDefaultPictureStructDataBySrc(&pData[j], pTable->source))
                return false;
        }
    }

    if (!SetPictureStructDataGlobal(&mDefaultPictureSettingGlobalType))
        return false;
    if (!SetDefaultPictureStructDataGlobal(&mDefaultPictureSettingGlobalType))
        return false;

    return true;
}

bool CPQDataBase::GetTable(unsigned char *pData,
                         int offset,
                         size_t dataSize,
                         PQ_OSD_TABLE_STRUCT_HEADER **ppTableHeader,
                         unsigned char **ppTableData,
                         unsigned char **ppTableIndex)
{
    if ((size_t)offset + sizeof(PQ_OSD_TABLE_STRUCT_HEADER) > dataSize) {
        SYS_LOGE("GetTable: Not enough space for table header at offset %d\n", offset);
        return false;
    }

    *ppTableHeader = (PQ_OSD_TABLE_STRUCT_HEADER *)(pData + offset);
    if (*ppTableHeader == NULL) {
        SYS_LOGE("GetTable: Null table header\n");
        return false;
    }

    if ((*ppTableHeader)->TableSize > dataSize - offset - sizeof(PQ_OSD_TABLE_STRUCT_HEADER)) {
        SYS_LOGE("GetTable: TableSize %u too large, available %zu\n",
                 (*ppTableHeader)->TableSize, dataSize - offset - sizeof(PQ_OSD_TABLE_STRUCT_HEADER));
        return false;
    }

    size_t indexTableSize = (*ppTableHeader)->IndexTableNum * sizeof(PQ_OSD_TABLE_DATA_STRUCT_SAVE);
    if ((size_t)offset + sizeof(PQ_OSD_TABLE_STRUCT_HEADER) + (*ppTableHeader)->TableSize + indexTableSize > dataSize) {
        SYS_LOGE("GetTable: Not enough space for index table or have no index\n");
    }

    *ppTableData = pData + offset + sizeof(PQ_OSD_TABLE_STRUCT_HEADER);
    *ppTableIndex = pData + offset + sizeof(PQ_OSD_TABLE_STRUCT_HEADER) + (*ppTableHeader)->TableSize;

    return true;
}

void CPQDataBase::InitialValue(void)
{
    StartSQLBatchHighSpeedMode();//切换高速批量模式

    if (!mpObserver->LoadPictureModeDbSetting()) {
        if (!LoadOSDBin()) {
            if (!LoadDefaultTable()) {
                rollbackTransaction();
                SYS_LOGE("%s Load all fail\n", __FUNCTION__);
            }
        }
    }

    EndSQLBatchHighSpeedMode();//恢复到安全模式

    return;
}

bool CPQDataBase::CheckTable(void)
{
    NonlinearModeType NonlinearMode;
    if (!GetNonlinearData(&NonlinearMode, 0, 0)) {
        SYS_LOGE("[%s] Check Nonlinear Table DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    PICTURE_MODE_DEFAULT PictureMode;
    if (!GetPictureMode(&PictureMode, 0, 0)) {
        SYS_LOGE("[%s] Check GetPictureMode DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    PICTURE_MODE_PARAM Picture;
    if (!GetPictureModeData(&Picture, 0, 0, 0)) {
        SYS_LOGE("[%s] Check Picture Table DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    COLORTEMP_DATA ColorTemp;
    if (!GetColorTemperatureData(&ColorTemp, 0, 0, 0)) {
        SYS_LOGE("[%s] Check ColorTemp Table DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    COLORTEMP_OFFSET_DATA RgbOffset;
    if (!GetRGBOffsetData(&RgbOffset, 0, 0, 0)) {
        SYS_LOGE("[%s] Check RgbOffset Table DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    GAMMA_OFFSET_DATA GammaOffset;
    if (!GetGammaOffsetData(&GammaOffset, 0, 0, 0, 0)) {
        SYS_LOGE("[%s] Check GammaOffset Table DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    TABLE_CMS CmsTable;
    if (!GetColorCustomizeData(&CmsTable, 0, 0, 0)) {
        SYS_LOGE("[%s] Check GetColorCustomizeData Table DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    PICTURE_SETTING_BY_SRC BySrcParam;
    if (!GetPictureStructDataBySrc(&BySrcParam, 0)) {
        SYS_LOGE("[%s] Check GetPictureStructDataBySrc Table DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    PICTURE_SETTING_GLOBAL GlobalParam;
    if (!GetPictureStructDataGlobal(&GlobalParam)) {
        SYS_LOGE("[%s] Check GetPictureStructDataGlobal Table DB fail, start reset DB\n", __FUNCTION__);
        return false;
    }

    return true;
}

bool CPQDataBase::StartSQLBatchHighSpeedMode(void)
{
    if (!EnableBatchHighSpeedMode()) {
        SYS_LOGE("[%s] EnableBatchHighSpeedMode fail!\n", __FUNCTION__);
        return false;
    }

    if (!beginTransaction()) {
        SYS_LOGE("[%s] fail to beginTransaction!\n", __FUNCTION__);
        DisableBatchHighSpeedMode();
        return false;
    }

    SYS_LOGD("[%s] success! \n", __FUNCTION__);

    return true;
}

bool CPQDataBase::EndSQLBatchHighSpeedMode(void)
{
    if (!commitTransaction()) {
        SYS_LOGE("Failed to commit transaction\n");
        DisableBatchHighSpeedMode();
        return false;
    }

    if (!DisableBatchHighSpeedMode()) {
        SYS_LOGE("Warning: Failed to fully disable initialization mode\n");
        return false;
    }

    SYS_LOGD("[%s] success! \n", __FUNCTION__);

    return true;
}

bool CPQDataBase::SetSyncData(void *pData, int iSize)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s", "SYNC_VERSION");

    return SetBlobValueToTable(key, pData, iSize);
}

bool CPQDataBase::GetSyncData(void *pData, int iSize)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s", "SYNC_VERSION");

    return GetBlobValueFromTable(key, pData, iSize);
}

bool CPQDataBase::SetVersionInfo(TABLE_VER_OSD *pData)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s", KEY_VERSION_INFO);

    return SetBlobValueToTable(key, (void *)pData, sizeof(TABLE_VER_OSD));
}

bool CPQDataBase::GetVersionInfo(TABLE_VER_OSD *pData)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s", KEY_VERSION_INFO);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(TABLE_VER_OSD));
}

bool CPQDataBase::SetNonlinearData(NonlinearModeType *pData, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_NONLINEAR_MAPPING, src, timing);

    return SetBlobValueToTable(key, (void *)pData, sizeof(NonlinearModeType));
}

bool CPQDataBase::GetNonlinearData(NonlinearModeType *pData, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_NONLINEAR_MAPPING, src, timing);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(NonlinearModeType));
}

bool CPQDataBase::SetDefaultNonlinearData(NonlinearModeType *pData, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_DEFAULT_NONLINEAR_MAPPING, src, timing);

    return SetBlobValueToTable(key, (void *)pData, sizeof(NonlinearModeType));
}

bool CPQDataBase::GetDefaultNonlinearData(NonlinearModeType *pData, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_DEFAULT_NONLINEAR_MAPPING, src, timing);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(NonlinearModeType));
}

bool CPQDataBase::SetPictureMode(PICTURE_MODE_DEFAULT *pData, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_PQ_MODE, src, timming);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_MODE_DEFAULT));
}

bool CPQDataBase::GetPictureMode(PICTURE_MODE_DEFAULT *pData, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_PQ_MODE, src, timming);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_MODE_DEFAULT));
}

bool CPQDataBase::SetDefaultPictureMode(PICTURE_MODE_DEFAULT *pData, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_DEFAULT_PQ_MODE, src, timming);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_MODE_DEFAULT));
}

bool CPQDataBase::GetDefaultPictureMode(PICTURE_MODE_DEFAULT *pData, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_DEFAULT_PQ_MODE, src, timming);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_MODE_DEFAULT));
}

bool CPQDataBase::SetLastPictureMode(PICTURE_MODE_DEFAULT *pData, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_LAST_PQ_MODE, src, timming);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_MODE_DEFAULT));
}

bool CPQDataBase::GetLastPictureMode(PICTURE_MODE_DEFAULT *pData, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d", KEY_LAST_PQ_MODE, src, timming);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_MODE_DEFAULT));
}

bool CPQDataBase::SetPictureModeData(PICTURE_MODE_PARAM *pData, int src, int timing, int mode)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_PICTURE_MODE, src, timing, mode);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_MODE_PARAM));
}

bool CPQDataBase::GetPictureModeData(PICTURE_MODE_PARAM *pData, int src, int timing, int mode)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_PICTURE_MODE, src, timing, mode);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_MODE_PARAM));
}

bool CPQDataBase::SetDefaultPictureModeData(PICTURE_MODE_PARAM *pData, int src, int timing, int mode)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_DEFAULT_PICTURE_MODE, src, timing, mode);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_MODE_PARAM));
}

bool CPQDataBase::GetDefaultPictureModeData(PICTURE_MODE_PARAM *pData, int src, int timing, int mode)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_DEFAULT_PICTURE_MODE, src, timing, mode);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_MODE_PARAM));
}

bool CPQDataBase::SetColorTemperatureData(COLORTEMP_DATA *pData, int src, int timing, int level)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_COLOR_TEMPERATURE, src, timing, level);

    return SetBlobValueToTable(key, (void *)pData, sizeof(COLORTEMP_DATA));
}

bool CPQDataBase::GetColorTemperatureData(COLORTEMP_DATA *pData, int src, int timing, int level)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_COLOR_TEMPERATURE, src, timing, level);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(COLORTEMP_DATA));
}

bool CPQDataBase::SetDefaultColorTemperatureData(COLORTEMP_DATA *pData, int src, int timing, int level)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_DEFAULT_COLOR_TEMPERATURE, src, timing, level);

    return SetBlobValueToTable(key, (void *)pData, sizeof(COLORTEMP_DATA));
}

bool CPQDataBase::GetDefaultColorTemperatureData(COLORTEMP_DATA *pData, int src, int timing, int level)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_DEFAULT_COLOR_TEMPERATURE, src, timing, level);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(COLORTEMP_DATA));
}

bool CPQDataBase::SetRGBOffsetData(COLORTEMP_OFFSET_DATA *pData, int level, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_RGB_OFFSET, src, timing, level);

    return SetBlobValueToTable(key, (void *)pData, sizeof(COLORTEMP_OFFSET_DATA));
}

bool CPQDataBase::GetRGBOffsetData(COLORTEMP_OFFSET_DATA *pData, int level, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_RGB_OFFSET, src, timing, level);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(COLORTEMP_OFFSET_DATA));
}

bool CPQDataBase::SetDefaultRGBOffsetData(COLORTEMP_OFFSET_DATA *pData, int level, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_DEFAULT_RGB_OFFSET, src, timing, level);

    return SetBlobValueToTable(key, (void *)pData, sizeof(COLORTEMP_OFFSET_DATA));
}

bool CPQDataBase::GetDefaultRGBOffsetData(COLORTEMP_OFFSET_DATA *pData, int level, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_DEFAULT_RGB_OFFSET, src, timing, level);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(COLORTEMP_OFFSET_DATA));
}

bool CPQDataBase::SetGammaOffsetData(GAMMA_OFFSET_DATA *pData, int level, int mode, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d_%d", KEY_GAMMA_OFFSET, src, timing, level, mode);

    return SetBlobValueToTable(key, (void *)pData, sizeof(GAMMA_OFFSET_DATA));
}

bool CPQDataBase::GetGammaOffsetData(GAMMA_OFFSET_DATA *pData, int level, int mode, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d_%d", KEY_GAMMA_OFFSET, src, timing, level, mode);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(GAMMA_OFFSET_DATA));
}

bool CPQDataBase::SetDefaultGammaOffsetData(GAMMA_OFFSET_DATA *pData, int level, int mode, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d_%d", KEY_DEFAULT_GAMMA_OFFSET, src, timing, level, mode);

    return SetBlobValueToTable(key, (void *)pData, sizeof(GAMMA_OFFSET_DATA));
}

bool CPQDataBase::GetDefaultGammaOffsetData(GAMMA_OFFSET_DATA *pData, int level, int mode, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d_%d", KEY_DEFAULT_GAMMA_OFFSET, src, timing, level, mode);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(GAMMA_OFFSET_DATA));
}

bool CPQDataBase::SetColorCustomizeData(TABLE_CMS *pData, int PictureMode, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_CMS, src, timing, PictureMode);

    return SetBlobValueToTable(key, (void *)pData, sizeof(TABLE_CMS));
}

bool CPQDataBase::GetColorCustomizeData(TABLE_CMS *pData, int PictureMode, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_CMS, src, timing, PictureMode);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(TABLE_CMS));
}

bool CPQDataBase::SetDefaultColorCustomizeData(TABLE_CMS *pData, int PictureMode, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_DEFAULT_CMS, src, timing, PictureMode);

    return SetBlobValueToTable(key, (void *)pData, sizeof(TABLE_CMS));
}

bool CPQDataBase::GetDefaultColorCustomizeData(TABLE_CMS *pData, int PictureMode, int src, int timing)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d_%d_%d", KEY_DEFAULT_CMS, src, timing, PictureMode);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(TABLE_CMS));
}

bool CPQDataBase::SetPictureStructDataBySrc(PICTURE_SETTING_BY_SRC *pData, int src)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d", KEY_PICTURE_BY_SRC, src);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_SETTING_BY_SRC));
}

bool CPQDataBase::GetPictureStructDataBySrc(PICTURE_SETTING_BY_SRC *pData, int src)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d", KEY_PICTURE_BY_SRC, src);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_SETTING_BY_SRC));
}

bool CPQDataBase::SetDefaultPictureStructDataBySrc(PICTURE_SETTING_BY_SRC *pData, int src)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d", KEY_DEFAULT_PICTURE_BY_SRC, src);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_SETTING_BY_SRC));
}

bool CPQDataBase::GetDefaultPictureStructDataBySrc(PICTURE_SETTING_BY_SRC *pData, int src)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d", KEY_DEFAULT_PICTURE_BY_SRC, src);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_SETTING_BY_SRC));
}

bool CPQDataBase::SetPictureStructDataGlobal(PICTURE_SETTING_GLOBAL *pData)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s", KEY_PICTURE_GLOBAL);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_SETTING_GLOBAL));
}

bool CPQDataBase::GetPictureStructDataGlobal(PICTURE_SETTING_GLOBAL *pData)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s", KEY_PICTURE_GLOBAL);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_SETTING_GLOBAL));
}

bool CPQDataBase::SetDefaultPictureStructDataGlobal(PICTURE_SETTING_GLOBAL *pData)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s", KEY_DEFAULT_PICTURE_GLOBAL);

    return SetBlobValueToTable(key, (void *)pData, sizeof(PICTURE_SETTING_GLOBAL));
}

bool CPQDataBase::GetDefaultPictureStructDataGlobal(PICTURE_SETTING_GLOBAL *pData)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s", KEY_DEFAULT_PICTURE_GLOBAL);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(PICTURE_SETTING_GLOBAL));
}

//lvds ssc
bool CPQDataBase::SetLvdsSscData(LCD_LVDS_SSC *pData, int index)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d", "KEY_LCD_LVDS_SSC", index);

    return SetBlobValueToTable(key, (void *)pData, sizeof(LCD_LVDS_SSC));
}

bool CPQDataBase::GetLvdsSscData(LCD_LVDS_SSC *pData, int index)
{
    if (pData == NULL) {
        return false;
    }

    char key[64];
    snprintf(key, sizeof(key), "%s_%d", "KEY_LCD_LVDS_SSC", index);

    return GetBlobValueFromTable(key, (void *)pData, sizeof(LCD_LVDS_SSC));
}