1640 lines
57 KiB
C++
1640 lines
57 KiB
C++
/*
|
|
* Copyright (c) 2014 Amlogic, Inc. All rights reserved.
|
|
*
|
|
* This source code is subject to the terms and conditions defined in the
|
|
* file 'LICENSE' which is part of this source code package.
|
|
*
|
|
* Description: c++ file
|
|
*/
|
|
|
|
#define LOG_MODULE_TAG "PQ"
|
|
#define LOG_CLASS_TAG "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));
|
|
}
|